davmem.c

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

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

/* ###########################################################################
###  MEM
###
###  Module: davmem.c - functions for determining locations, flash usage
###
###  $Workfile: davmem.c $
###  $Revision: 10 $
###  $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"
#include "davext.h"

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

/*### Global Declarations
#########################*/
FDI_MemoryUsage FDI_MemUsage;        /* Structure containing all memory */
                                     /* usage information               */

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

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

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

/*#################################################################
  ### MEM_CalcMemoryStatistics
  ###
  ### DESCRIPTION:
  ###   This function updates the DAV related global tracking 
  ###   variables based on a scan of the header table entries.  
  ###   It will also repair the last header when it is found 
  ###   with an invalid identifier.
  ###
  ### PARAMETERS:
  ###   none.
  ###
  ### RETURNS:
  ###   When this function passes with no errors a value of 0 is
  ###   returned otherwise, it returns a status of type ERR_CODE.
  ###*/
ERR_CODE MEM_CalcMemoryStatistics(BOOLEAN restart)
{
ERR_CODE           status = ERR_NONE;
SEARCH_SearchInfo  srch_info;
HDR_Header         srch_header;
UINT32             pageFreePoolSize;
UINT32             paraFreePoolSize;
FDI_Handle         pageFreePoolHandle;
FDI_Handle         paraFreePoolHandle;

   if (!DAV_InitializationComplete)
   {
      status = ERR_SYSTEM;
      ExitOnError(status);
   }

   /* Initialize global variables */
   FDI_NextFreeHeaderEntry  = DAV_MEM_FirstHeaderAddr;
   FDI_LastHeaderEntry      = FDI_NextFreeHeaderEntry + FHDR_CalcHeaderSize();
   FDI_PageObjectCounter    = 0;
   FDI_ReclaimLevel         = 0;


   FDI_MemUsage.ParaSpace.Valid         = 0;
   FDI_MemUsage.ParaSpace.Invalid       = 0;
   FDI_MemUsage.ParaSpace.Free          = 0;
   FDI_MemUsage.ParaSpace.Reserves      = 0;
   FDI_MemUsage.ParaSpace.ReservesInUse = 0;

   FDI_MemUsage.PageSpace.Valid         = 0;
   FDI_MemUsage.PageSpace.Invalid       = 0;
   FDI_MemUsage.PageSpace.Free          = 0;
   FDI_MemUsage.PageSpace.Reserves      = 0;
   FDI_MemUsage.PageSpace.ReservesInUse = 0;
   
   FDI_MemUsage.PageOverhead.Valid      = 0;
   FDI_MemUsage.PageOverhead.Invalid    = 0;
   FDI_MemUsage.PageOverhead.Free       = 0;
   FDI_MemUsage.PageOverhead.Absorbed   = 0;
   FDI_MemUsage.PageOverhead.ReclaimReserves = 0;
   
   FDI_MemUsage.ParaOverhead.Valid      = 0;
   FDI_MemUsage.ParaOverhead.Invalid    = 0;
   FDI_MemUsage.ParaOverhead.Free       = 0;
   FDI_MemUsage.ParaOverhead.Absorbed   = 0;
   FDI_MemUsage.ParaOverhead.ReclaimReserves = 0;

   /* Scan the entire header table and setup tracking variables */
   SEARCH_Header2SearchInfo((&srch_info), &srch_header);
   while(TRUE)
   { 
      status = SEARCH_GetNextHeaderHandle((&srch_info), SEARCH_Normal, restart);
/* E5.5.970 Start */ 
      mDEBUG_CHECK_ERRCODE(status);
/* E5.5.970 Start */ 
      if (
         (status == ERR_NO_MORE_ENTRIES) ||
         (FHDR_GetHeaderStatus(&(srch_info.HeaderPtr->FHdr)) == HDR_HEADER_UNUSED)
         )
      {
         /* we're finished */
         status = ERR_NO_MORE_ENTRIES;
         /* Set the fixed header entry handles appropriately */
         FDI_NextFreeHeaderEntry = srch_info.CurrObj.HeaderAddress;
         FDI_LastHeaderEntry = FDI_NextFreeHeaderEntry + FHDR_CalcHeaderSize();
         break;
      }

      /* Repair the header if it is needed. */
      if (status == ERR_PARAM)
      {
         /* Repair Last header */
         status = FHDR_RepairHeader(srch_info.CurrObj.HeaderAddress, &(srch_info.HeaderPtr->FHdr));
         ExitOnError(status);
      }

      if (FHDR_GetAbsorbStatus(&(srch_info.HeaderPtr->FHdr)) == HDR_NOT_ABSORBED)
      {
         switch (FHDR_GetAllocationStatus(&(srch_info.HeaderPtr->FHdr)))
         {
            case HDR_ALLOC_WRITE_IN_PROGRESS:
            case HDR_ALLOC_VALID:
               /* space has been allocated for this object */
               if (FHDR_IsPageObject(&(srch_info.HeaderPtr->FHdr)))
               {  
                  if (FHDR_GetReallocationStatus(&(srch_info.HeaderPtr->FHdr)) == HDR_REALLOC_BACKUP_NOT_COMPLETE)
                  {
                     /* this is not a backup object */
                     FDI_PageObjectCounter++;
                     FDI_MemUsage.PageSpace.Valid += (srch_info.CurrObj.ObjectSize - OHDR_CalcHeaderSize());
                     FDI_MemUsage.PageOverhead.Valid += OHDR_CalcHeaderSize();
                     /* if this object is larger than the current reclaim reserve
                        then set the reclaim reserve to this object */
                     if (srch_info.CurrObj.ObjectSize > FDI_MemUsage.PageSpace.Reserves)
                     {
                        FDI_MemUsage.PageSpace.Reserves = srch_info.CurrObj.ObjectSize;
                     }
                  }
                  else
                  {
                     /* this is a backup object */
                     FDI_MemUsage.PageSpace.ReservesInUse += srch_info.CurrObj.ObjectSize;
                     
                  }
                  FDI_MemUsage.ParaOverhead.Valid += FHDR_CalcHeaderSize();
               }
               else
               {
                  /* Add to paragraph objects */
                  FDI_MemUsage.ParaSpace.Valid += srch_info.CurrObj.ObjectSize;
                  FDI_MemUsage.ParaOverhead.Valid += FHDR_CalcHeaderSize();
                  
               }
            break;

            case HDR_ALLOC_EMPTY:
               /* space has been allocated for this object */
               if (FHDR_IsPageObject(&(srch_info.HeaderPtr->FHdr)))
               {
                  /* Add to free pages */
                  FDI_MemUsage.PageSpace.Free += srch_info.CurrObj.ObjectSize;
                  FDI_MemUsage.ParaOverhead.Free += FHDR_CalcHeaderSize();
               }
               else
               {
                  /* Add to free paragraphs (really will never exist in para space) */
                  FDI_MemUsage.ParaSpace.Free += srch_info.CurrObj.ObjectSize;
                  FDI_MemUsage.ParaOverhead.Free += FHDR_CalcHeaderSize();
               }
            break;
            case HDR_ALLOC_INVALID:
               /* space has been allocated for this object */
               if (FHDR_IsPageObject(&(srch_info.HeaderPtr->FHdr)))
               {
                  /* Add to invalid pages */
                  FDI_MemUsage.PageSpace.Invalid += srch_info.CurrObj.ObjectSize;
                  FDI_MemUsage.ParaOverhead.Invalid += FHDR_CalcHeaderSize();
               }
               else
               {
                  /* Add to invalid paragraphs */
                  FDI_MemUsage.ParaSpace.Invalid += srch_info.CurrObj.ObjectSize;
                  FDI_MemUsage.ParaOverhead.Invalid += FHDR_CalcHeaderSize();
               }
            break;
 
            default:
            {};
         }
      }
      else
      {
         /* Header is Absorbed */
         FDI_MemUsage.ParaOverhead.Absorbed += FHDR_CalcHeaderSize(); 
      }
   } /* end while */

   /*##################################################################*/
   /*### By this point all headers should                              */
   /*### be accounted for in FDI_MemUsage.  All that remains is to     */
   /*### calculate the amount of free  memory.                         */
   /*##################################################################*/


   /* calculate the free pool in page space */
   status = MEM_CalcSizeAndHandleOfFreePoolInPageSpace(&pageFreePoolSize, &pageFreePoolHandle);
   ExitOnError(status);

   FDI_MemUsage.PageSpace.Free += (pageFreePoolSize * FDI_PageSize);

   /* calculate the free pool in para space */
   status = MEM_CalcSizeAndHandleOfFreePoolInParaSpace(&paraFreePoolSize, &paraFreePoolHandle);
   ExitOnError(status);

   FDI_MemUsage.ParaSpace.Free += paraFreePoolSize;

   return ERR_NONE;
}

/*#################################################################
  ### MEM_CalcBeginningOfFreePoolInPageSpace
  ### 
  ### DESCRIPTION:
  ###   This function will calculate a handle to the beginning of
  ###   the free pool in page space.
  ### 
  ### PARAMETERS:
  ### 
  ### RETURNS:
  ###   Error status.
  ###*/
ERR_CODE MEM_CalcBeginningOfFreePoolInPageSpace(FDI_HandlePtr aFreePoolHandlePtr)
{
ERR_CODE                  status = ERR_NONE;
FDI_Handle                currHeaderHandle = DAV_MEM_FirstHeaderAddr;
HDR_FixedHeader           currHeader;
HDR_FixedHeader           lastHeader;
UINT32                    currOffset = 0;
UINT32                    candidateOffset;

   HDR_InitHeaderAttr1(currHeader.Attr1);
   HDR_InitHeaderAttr2(currHeader.Attr2);
   HDR_InitHeaderAttr1(lastHeader.Attr1);
   HDR_InitHeaderAttr2(lastHeader.Attr2);

   do
   {
      status = FHDR_ReadFixedHeader(currHeaderHandle, &currHeader, FALSE);
      /* if the header points to a real user object, dirty chunk, or free chunk in page space */
      if (
            (status == ERR_NONE) &&
            (FHDR_GetHeaderStatus(&currHeader) == HDR_HEADER_VALID) && 
            (FHDR_GetAbsorbStatus(&currHeader) == HDR_NOT_ABSORBED) && 
            (FHDR_IsPageObject(&currHeader))
         )
      {
	      /* compare the offset in this header with the current offset */
	      /* save it if it's higher */
         candidateOffset = FHDR_GetHeaderIndexOffset(&currHeader);
         if ((candidateOffset > currOffset) || (currOffset == 0))
	      {
	         /* this object exists in page space above the current object */
            /* and it's above than any previous objects found */
            currOffset = candidateOffset;
            lastHeader.Attr1 = currHeader.Attr1;
            lastHeader.Attr2 = currHeader.Attr2;
         }
      }
      currHeaderHandle = SEARCH_CalcNextHdrAddr(currHeaderHandle);
   } while ((status == ERR_NONE) && 
            (FHDR_GetHeaderStatus(&currHeader) != HDR_HEADER_UNUSED));

   ExitOnError(status);

   if (currOffset == 0 && FHDR_GetHeaderStatus(&lastHeader) == HDR_HEADER_UNUSED)
   {
      /* the page space is empty */
      *aFreePoolHandlePtr = FDI_PageSpaceAddressBottom;
   }
   else
   {
      *aFreePoolHandlePtr = FHDR_CalcObjectHandle(&lastHeader) + 
                            FHDR_CalcObjectSize(&lastHeader);
   }
   return status;
}

/*#################################################################
  ### MEM_CalcSizeAndHandleOfFreePoolInPageSpace
  ### 
  ### DESCRIPTION:
  ###   This function will calculate the size in pages and the
  ###   handle of the free pool in page space.
  ### 
  ### PARAMETERS:
  ### 
  ### RETURNS:
  ###   Error status.
  ###*/
ERR_CODE MEM_CalcSizeAndHandleOfFreePoolInPageSpace(UINT32* sizeInPages, 
                                                       FDI_HandlePtr aFreePoolHandlePtr)
{
ERR_CODE              status = ERR_NONE;
   
   status = MEM_CalcBeginningOfFreePoolInPageSpace(aFreePoolHandlePtr);
   ExitOnError(status);
   *sizeInPages = ((FDI_ParaSpaceAddressBottom - *aFreePoolHandlePtr) / FDI_PageSize);