davgstat.c

FDI Intel开发的FLASH文件系统,功能很强大

/* Copyright (c) 1995-2004 Intel Corporation */
/* Intel Confidential                        */

/* ###########################################################################
###  DAV - Direct Access Volume Enhancement to FDI
###
###  Module: dav_gstat.c - DAV Interface Function:  Get Memory Statistics
###                        Module
###
###  $Workfile: davgstat.c $
###  $Revision: 63 $
###  $NoKeywords: $
########################################################################### */

/*                                                               
 *****************************************************************
 * NOTICE OF LICENSE AGREEMENT                                    
 *                                                                
 * This code is provided by Intel Corp., and the use is governed  
 * under the terms of a license agreement. See license agreement  
 * for complete terms of license.                                 
 *                                                                
 * YOU MAY ONLY USE THE SOFTWARE WITH INTEL FLASH PRODUCTS.  YOUR 
 * USE OF THE SOFTWARE WITH ANY OTHER FLASH PRODUCTS IS EXPRESSLY 
 * PROHIBITED UNLESS AND UNTIL YOU APPLY FOR, AND ARE GRANTED IN  
 * INTEL'S SOLE DISCRETION, A SEPARATE WRITTEN SOFTWARE LICENSE   
 * FROM INTEL LICENSING ANY SUCH USE.                             
 *****************************************************************
 */
 

/*### Include Files
#########################*/
#include "DavLib.h"

#if (DIRECT_ACCESS_VOLUME == TRUE)

#include "davmem.h"

/*### Local Declarations
#########################*/

/*### Global Declarations
#########################*/

/*### Local Functions
#########################*/

#define ExitOnError(status) \
   if (status != ERR_NONE) \
   {  FDI_APIUnlock(); \
      return status;  }

/* E5.5.962 Begin */   
#define CleanupAndExitOnError(status)   \
   if(status != ERR_NONE)               \
   {                                    \
      FDI_APIUnlock();                  \
      mDEBUG_CHECK_ERRCODE(status)      \
      MEM_CalcMemoryStatistics(FALSE);  \
      return status;                    \
  }
/* E5.5.962 End */

/*### Global Functions
#########################*/

/*##################################################################
  ### FDI_GetMemoryStatistics
  ###
  ### DESCRIPTION:
  ###   This function returns all information about the DAV 
  ###   environment in the structure pointed to by the 
  ###   memory_stats_ptr.  Global tracking variables, reclaim 
  ###   level and component specific information like flash block 
  ###   size is returned.
  ###
  ### PARAMETERS:
  ###   memory_stats_ptr  - IN:  Not used.
  ###                       OUT: memory_stats_ptr is updated with
  ###                            the global DAV tracking variables.
  ###
  ### RETURNS:
  ###   ERR_INIT if initialization is not complete yet,
  ###   otherwise return ERR_NONE.
  ###*/
ERR_CODE FDI_GetMemoryStatistics( FDI_MemoryStatisticsPtr memory_stats_ptr )
{
FDI_MemoryStatisticsPtr mem_stats_ptr;
ERR_CODE status = ERR_NONE;

   /* Check for completion of Initialization, */
   /* and if not yet complete return the proper error code. */
   if (DAV_InitializationComplete != TRUE)
   {
      return ERR_INIT;
   }

   /* Multitasking API exclusivity.  (This may not be necessary to the
      full extent as it is done here, but for now it is the safest way.) */
   FDI_APILock();
  
   MEM_CalcMemoryStatistics(FALSE);

   mem_stats_ptr = memory_stats_ptr;

   mem_stats_ptr->TotalFlashMem    = FDI_TotalFlashSpace;
                                                     
   mem_stats_ptr->TotalObjectSpace = FDI_TotalObjectSpace;
                                                     
   mem_stats_ptr->FlashBlockSize   = FDI_BlockSize;
                                                        
   mem_stats_ptr->PageSize         = FDI_PageSize;
                                                                
   mem_stats_ptr->NumReclaimBlks   = FDI_ReservedReclaimBlocks;
                                                   
   mem_stats_ptr->NumSystemBlks    = FDI_ReservedSystemBlocks;
    
   mem_stats_ptr->MemUsage.PageOverhead.Valid =
                                 FDI_MemUsage.PageOverhead.Valid;
                                        
   mem_stats_ptr->MemUsage.PageOverhead.Invalid =
                                 FDI_MemUsage.PageOverhead.Invalid;
                                        
   mem_stats_ptr->MemUsage.PageOverhead.Free =
                                 FDI_MemUsage.PageOverhead.Free;
                                        
   mem_stats_ptr->MemUsage.PageOverhead.Absorbed =
                                 FDI_MemUsage.PageOverhead.Absorbed;
                                        
   mem_stats_ptr->MemUsage.PageOverhead.ReclaimReserves =
                                 FDI_MemUsage.PageOverhead.ReclaimReserves;
                                        
   mem_stats_ptr->MemUsage.ParaOverhead.Valid =
                                 FDI_MemUsage.ParaOverhead.Valid;
                                        
   mem_stats_ptr->MemUsage.ParaOverhead.Invalid =
                                 FDI_MemUsage.ParaOverhead.Invalid;
                                        
   mem_stats_ptr->MemUsage.ParaOverhead.Free =
                                 FDI_MemUsage.ParaOverhead.Free;
                                        
   mem_stats_ptr->MemUsage.ParaOverhead.Absorbed =
                                 FDI_MemUsage.ParaOverhead.Absorbed;
                                        
   mem_stats_ptr->MemUsage.ParaOverhead.ReclaimReserves =
                                 FDI_MemUsage.ParaOverhead.ReclaimReserves;
                                        
   mem_stats_ptr->MemUsage.PageSpace.Free =
                                 FDI_MemUsage.PageSpace.Free;
                                        
   mem_stats_ptr->MemUsage.PageSpace.Valid =
                                 FDI_MemUsage.PageSpace.Valid;
                                        
   mem_stats_ptr->MemUsage.PageSpace.Invalid =
                                 FDI_MemUsage.PageSpace.Invalid;
                                        
   mem_stats_ptr->MemUsage.PageSpace.Reserves =
                                 FDI_MemUsage.PageSpace.Reserves;
                                        
   mem_stats_ptr->MemUsage.ParaSpace.Free =
                                 FDI_MemUsage.ParaSpace.Free;
                                        
   mem_stats_ptr->MemUsage.ParaSpace.Valid =
                                 FDI_MemUsage.ParaSpace.Valid;
                                        
   mem_stats_ptr->MemUsage.ParaSpace.Invalid =
                                 FDI_MemUsage.ParaSpace.Invalid;
                                        
   mem_stats_ptr->MemUsage.ParaSpace.Reserves = FDI_MemUsage.ParaSpace.Reserves;

   mem_stats_ptr->MemUsage.ParaSpace.ReservesInUse =
                                 FDI_MemUsage.ParaSpace.ReservesInUse;

   mem_stats_ptr->MemUsage.PageSpace.ReservesInUse =
                                 FDI_MemUsage.PageSpace.ReservesInUse;
                                        
   mem_stats_ptr->SystemState = FDI_SystemState;

   status = MEM_CalcReclaimablePageSpace(&(mem_stats_ptr->TotalObjectSpaceReclaimable));
   ExitOnError(status);
   mem_stats_ptr->TotalObjectSpaceReclaimable = mem_stats_ptr->TotalObjectSpaceReclaimable * FDI_PageSize;
   mem_stats_ptr->ReclaimLevel = FDI_ReclaimLevel;


   FDI_APIUnlock(); 
   return status;
}

#endif /* DIRECT_ACCESS_VOLUME */