davmem.h

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

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

/* ###########################################################################
###  DAV - Direct Access Volume Enhancement to FDI
###
###  Module: davmem.h - DAV Memory and Space Types & Macros Include File
###
###  $Workfile: davmem.h $
###  $Revision: 1 $
###  $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.                             
 *****************************************************************
 */
 

#ifndef __dav_mem_h  /* sentry header */
#define __dav_mem_h

#if (DIRECT_ACCESS_VOLUME == TRUE)

#include "davsearch.h"

/* Paragraph Space Macros */

/* This macro defines the amount of paragraph space that can */
/*  be regained by issuing a paragraph only reclaim.         */
#define MEM_CalcReclaimableParas() \
           (FDI_MemUsage.ParaSpace.Invalid + \
            FDI_MemUsage.ParaOverhead.Invalid + \
            FDI_MemUsage.PageOverhead.Invalid + \
            FDI_MemUsage.PageOverhead.Absorbed)

#define MEM_CalcReclaimableParaSpace() \
           (FDI_MemUsage.ParaSpace.Invalid + \
            FDI_MemUsage.ParaOverhead.Invalid + \
            FDI_MemUsage.PageOverhead.Absorbed)

#define MEM_CalcValidParaSpace() \
           (FDI_MemUsage.ParaOverhead.Valid + \
            FDI_MemUsage.ParaSpace.Valid + \
            FDI_MemUsage.PageOverhead.Valid)

#define MEM_CalcInvalidParaSpace() \
           (FDI_MemUsage.ParaSpace.Invalid + \
            FDI_MemUsage.ParaOverhead.Invalid + \
            FDI_MemUsage.PageOverhead.Invalid + \
            FDI_MemUsage.PageOverhead.Absorbed)

#define MEM_CalcAbsorbedParaSpace() \
           (FDI_MemUsage.ParaOverhead.Absorbed + \
            FDI_MemUsage.PageOverhead.Absorbed)
            
#define MEM_CalcReservedParaSpace() \
           (FDI_MemUsage.ParaOverhead.ReclaimReserves + \
            FDI_MemUsage.ParaSpace.Reserves)

#define MEM_TotalUsedParagraphSpace() \
           (MEM_CalcValidParaSpace() + \
            MEM_CalcInvalidParaSpace() + \
            MEM_CalcAbsorbedParaSpace())
          
#define MEM_TotalPossibleParaSpace() \
           (FDI_LastObjectAddress - MEM_CalcEndOfParaSpace() + 1)

/* Page Space Macros */

#define MEM_CalcInvalidPageSpace() \
           (FDI_MemUsage.PageSpace.Invalid)
           
#define MEM_TotalPossiblePageSpace() \
           (MEM_CalcEndOfPageSpace() - FDI_StartAddress)
            
#define MEM_CalcValidPageSpace() \
           (FDI_MemUsage.PageSpace.Valid)

#define MEM_TotalUsedPageSpace() \
           (FDI_MemUsage.PageSpace.Valid + \
            FDI_MemUsage.PageSpace.Invalid)
   
#define MEM_CalcReservedPageSpace() \
           (FDI_MemUsage.PageSpace.Reserves + \
            FDI_MemUsage.PageOverhead.ReclaimReserves)

/* BEGIN NEW MACROS */
#define MEM_CalcParaSystemReserves() \
           (RECTBL_ParaReclaimSpace + \
            OTTTBL_ParaReclaimSpace +\
            RECINPLC_ReAllocateTableSpace + \
            HDR_EndOfTableBufferReserve)
            
#define MEM_CalcPageSystemReserves() \
           (RECTBL_PageReclaimSpace)

#define MEM_CalcPageObjReserves() \
           (FDI_MemUsage.PageSpace.Reserves)

#define MEM_CalcParaObjReserves() \
           (FDI_MemUsage.ParaSpace.Reserves)


/*### Flash Memory Statistics (originally from davlib.h)
#############################*/
typedef struct
{
   UINT32 Valid;          /* Overhead assoc. with valid object headers    */
   UINT32 Invalid;        /* Overhead assoc. with Invalid object headers  */
   UINT32 Free;           /* Overhead assoc. with free object headers     */
   UINT32 Absorbed;       /* Overhead assoc. with Absorbed object headers */
   UINT32 ReclaimReserves;/* Overhead assoc. reclaim and system           */
} FDI_OverheadSpace;

typedef struct
{
   UINT32 Free;           /* Free memory within assoc. memory space       */
   UINT32 Valid;          /* Valid memory within assoc. memory space      */
   UINT32 Invalid;        /* Invalid memory within assoc. memory space    */
   UINT32 Reserves;       /* Available rsvd memory within assoc. memory   */
                          /*  space                                       */
   UINT32 ReservesInUse;  /* Used rsvd memory within assoc. memory space  */
} FDI_ObjectSpace;

typedef struct
{
   FDI_OverheadSpace PageOverhead;/* Overhead associated with Page Space */
   FDI_OverheadSpace ParaOverhead;/* Overhead associated with Para Space */
   FDI_ObjectSpace   PageSpace;   /* Describes page space memory usage   */
   FDI_ObjectSpace   ParaSpace;   /* Describes paragraph space memory    */
                                  /*  usage.                             */
}  FDI_MemoryUsage, __FAR_ * FDI_MemoryUsagePtr;

/* 
 *           Added byte_align field for placeholder.
 */
typedef struct
{
   UINT32   TotalFlashMem;    /* Total Flash available to the DAV         */
   UINT32   TotalObjectSpace; /* Total DAV managed object space           */
   UINT32   FlashBlockSize;   /* Size of flash blocks in bytes            */
   UINT32   PageSize;         /* Size of a page in bytes                  */
   UINT32   NumReclaimBlks;   /* Total blocks used for reclaim            */
   UINT32   NumSystemBlks;    /* Total Blocks not managed by DAV          */
   UINT32   TotalObjectSpaceReclaimable;  /* Total pages available if full defrag performed */
   UINT32   ReclaimLevel;     /* Threshold level for triggering reclaim   */
   UINT16   byte_align;
   UINT16   SystemState;      /* Describes the current state of the DAV   */
   FDI_MemoryUsage MemUsage;  /* Describes the usage of managed space     */
} FDI_MemoryStatistics, __FAR_ * FDI_MemoryStatisticsPtr;

/* RESERVES */
#define HDR_HA_NoReserves       0x00
#define HDR_HA_UseReserves      0x01

/*### Global externs
#########################*/

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

ERR_CODE MEM_CalcMemoryStatistics(BOOLEAN restart);

ERR_CODE MEM_CalcBeginningOfFreePoolInPageSpace(FDI_HandlePtr aFreePoolHandlePtr);

ERR_CODE MEM_CalcSizeAndHandleOfFreePoolInPageSpace(UINT32*       aSizeInPages, 
                                                    FDI_HandlePtr aFreePoolHandlePtr);

ERR_CODE MEM_CalcBeginningOfFreePoolInParaSpace(FDI_HandlePtr aFreePoolHandlePtr);

ERR_CODE MEM_CalcSizeAndHandleOfFreePoolInParaSpace(UINT32*       aSizeInBytes,
                                                    FDI_HandlePtr aFreePoolHandlePtr);

ERR_CODE MEM_FindLargestFreeChunkInPageSpace(FDI_HandlePtr aFreeChunkHandlePtr, 
                                             UINT32*       aSizeInPages);

ERR_CODE MEM_FindLargestUnpinnedFreeChunkInPageSpace(FDI_HandlePtr aFreeChunkHandlePtr, 
                                                     UINT32*       aSizeInPages);

ERR_CODE MEM_FindFirstFitFreeChunkInPageSpace(FDI_HandlePtr aFreeChunkHandlePtr, 
                                              UINT32        aRequestedSizeInPages,
                                              UINT32*       aReturnedSizeInPages);

ERR_CODE MEM_FindBestFitFreeChunkInPageSpace(FDI_HandlePtr aFreeChunkHandlePtr,
                                             UINT32 aRequestedSizeInPages,
                                             UINT32* aReturnedSizeInPages);

ERR_CODE MEM_CalcTotalFreeSpaceInPageSpace(UINT32* aSizeInPages);

ERR_CODE MEM_CalcTotalFreeSpaceInParaSpace(UINT32* aSizeInBytes);

ERR_CODE MEM_CalcTotalDirtySpaceInPageSpace(UINT32* aSizeInPages);

ERR_CODE MEM_CalcTotalDirtySpaceInParaSpace(UINT32* aSizeInBytes);

ERR_CODE MEM_CalcReclaimablePageSpace(UINT32* aReclaimablePages);


#endif /* DIRECT_ACCESS_VOLUME */

#endif /* sentry */