305 lines
9.2 KiB
C++
305 lines
9.2 KiB
C++
/*++
|
|
|
|
Copyright (C) 1997-2001 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
MMFARENA.H
|
|
|
|
Abstract:
|
|
|
|
CArena derivative based on memory mapped files.
|
|
|
|
History:
|
|
|
|
a-raymcc 23-Apr-96 Created
|
|
paulall 23-Mar-98 Re-worked
|
|
|
|
--*/
|
|
|
|
#if (defined __WIN9x_BUILD__)
|
|
#include "mmfarena2_w9x.h"
|
|
#elif (defined __WINNT_BUILD__)
|
|
|
|
#ifndef _MMFARENA_H_
|
|
#define _MMFARENA_H_
|
|
|
|
#include "corepol.h"
|
|
#include "FlexArry.h"
|
|
|
|
#if defined _WIN32
|
|
#define MMF_DELETED_MASK 0x80000000
|
|
#define MMF_REMOVE_DELETED_MASK 0x7FFFFFFF
|
|
#define MMF_DEBUG_DELETED_TAG 0xFFFFFFFF
|
|
#define MMF_DEBUG_INUSE_TAG 0xFEFEFEFE
|
|
#elif defined _WIN64
|
|
#define MMF_DELETED_MASK 0x8000000000000000
|
|
#define MMF_REMOVE_DELETED_MASK 0x7FFFFFFFFFFFFFFF
|
|
#define MMF_DEBUG_DELETED_TAG 0xFFFFFFFFFFFFFFFF
|
|
#define MMF_DEBUG_INUSE_TAG 0xFEFEFEFEFEFEFEFE
|
|
#endif
|
|
|
|
struct MMFOffsetItem;
|
|
|
|
#include "corex.h"
|
|
class DATABASE_FULL_EXCEPTION : public CX_Exception
|
|
{
|
|
};
|
|
|
|
//***************************************************************************
|
|
//
|
|
// struct MMF_ARENA_HEADER
|
|
//
|
|
// Root structure for MMF Arena. This is recorded on the disk
|
|
// image at the very beginning of the file.
|
|
//
|
|
//***************************************************************************
|
|
|
|
#pragma pack(4) // Require fixed aligment.
|
|
|
|
typedef struct
|
|
{
|
|
// Version used to create file
|
|
// vvvvvv MUST BE FIRST VALUE vvvvvvv
|
|
DWORD m_dwVersion; // <<<<<< MUST BE FIRST VALUE!
|
|
// ^^^^^^ MUST BE FIRST VALUE ^^^^^^^
|
|
DWORD m_dwGranularity; // Granularity of allocation
|
|
DWORD m_dwCurrentSize; // Current size of heap
|
|
DWORD m_dwMaxSize; // Max heap size, -1= no limit
|
|
DWORD m_dwGrowBy; // Bytes to grow by during out-of-heap
|
|
|
|
DWORD_PTR m_dwHeapExtent; // First unused address
|
|
DWORD_PTR m_dwEndOfHeap; // Last valid address + 1
|
|
DWORD_PTR m_dwFreeList; // NULL if empty
|
|
DWORD_PTR m_dwRootBlock; // Root block
|
|
DWORD m_dwSizeOfFirstPage; //Size of the first block
|
|
|
|
} MMF_ARENA_HEADER;
|
|
|
|
typedef struct
|
|
{
|
|
DWORD m_dwSize; //Size of block. Highest bit set when deleted.
|
|
|
|
} MMF_BLOCK_HEADER;
|
|
|
|
typedef struct
|
|
{
|
|
DWORD_PTR m_dwFLback; //previous free block in the chain, NULL if not deleted
|
|
DWORD m_dwCheckBlock[2];
|
|
|
|
} MMF_BLOCK_TRAILER;
|
|
|
|
typedef struct
|
|
{
|
|
DWORD_PTR m_dwFLnext; //Next free block in the chain
|
|
|
|
} MMF_BLOCK_DELETED;
|
|
|
|
typedef struct
|
|
{
|
|
DWORD m_dwSize; //Size of page
|
|
|
|
} MMF_PAGE_HEADER; //Page header... not there for first page.
|
|
#pragma pack() // Restore previous aligment.
|
|
|
|
|
|
//***************************************************************************
|
|
//
|
|
// class CMMFArena2
|
|
//
|
|
// Implements an offset-based heap over a memory-mapped file.
|
|
//
|
|
//***************************************************************************
|
|
|
|
class POLARITY CMMFArena2
|
|
{
|
|
DWORD m_dwStatus;
|
|
HANDLE m_hFile;
|
|
MMF_ARENA_HEADER *m_pHeapDescriptor;
|
|
DWORD m_dwCursor;
|
|
DWORD m_dwMappingGranularity;
|
|
bool m_bReadOnlyAccess;
|
|
DWORD m_dwMaxPageSize;
|
|
CFlexArray m_OffsetManager;
|
|
|
|
//Adds the header and trailer items to the specified block.
|
|
BOOL DecorateUsedBlock(DWORD_PTR dwBlock, DWORD dwBytes);
|
|
|
|
//Adds header and trailer items to the specified block and marks it as deleted
|
|
BOOL DecorateAsDeleted(DWORD_PTR dwBlock,
|
|
DWORD dwBytes,
|
|
DWORD_PTR dwNextFreeListOffset,
|
|
DWORD_PTR dwPrevFreeListOffset);
|
|
|
|
//Retrieves the size of the block from the header and removes the deleted bit
|
|
DWORD GetSize(MMF_BLOCK_HEADER *pBlock) { return pBlock->m_dwSize & MMF_REMOVE_DELETED_MASK; }
|
|
|
|
MMF_BLOCK_DELETED *GetUserBlock(MMF_BLOCK_HEADER *pBlockHeader) { return (MMF_BLOCK_DELETED*)(LPBYTE(pBlockHeader) + sizeof(MMF_BLOCK_HEADER)); }
|
|
MMF_BLOCK_TRAILER *GetTrailerBlock(MMF_BLOCK_HEADER *pBlockHeader) { return (MMF_BLOCK_TRAILER*)(LPBYTE(pBlockHeader) + GetSize(pBlockHeader) - sizeof(MMF_BLOCK_TRAILER)); }
|
|
|
|
|
|
//Removes a deleted block from the free-list
|
|
BOOL RemoveBlockFromFreeList(MMF_BLOCK_HEADER *pBlock);
|
|
|
|
//Gets the previous block pointer if the block is deleted, otherwise return NULL
|
|
MMF_BLOCK_HEADER *GetPreviousDeletedBlock(MMF_BLOCK_HEADER *pBlockHeader);
|
|
|
|
//Zero's out a block (not including the header and trailer!)
|
|
BOOL ZeroOutBlock(DWORD_PTR dwBlock, int cFill)
|
|
#if (defined DEBUG || defined _DEBUG)
|
|
;
|
|
#else
|
|
{ return TRUE;}
|
|
#endif
|
|
|
|
//Some debugging functions...
|
|
void Reset();
|
|
BOOL Next(LPBYTE *ppAddress, DWORD *pdwSize, BOOL *pbActive);
|
|
|
|
//Checks the deleted bit of the size block
|
|
BOOL IsDeleted(MMF_BLOCK_HEADER *pBlock) { return (pBlock->m_dwSize & MMF_DELETED_MASK) ? TRUE : FALSE; }
|
|
//Validates a pointer
|
|
BOOL ValidateBlock(DWORD_PTR dwBlock)
|
|
#if (defined DEBUG || defined _DEBUG)
|
|
;
|
|
#pragma message("MMF heap validation enabled.")
|
|
#else
|
|
{ return TRUE;}
|
|
#endif
|
|
|
|
// Grows the size of the arena by a minumum of the specified amount
|
|
DWORD_PTR GrowArena(DWORD dwGrowBySize);
|
|
|
|
//For a given offset, return the mapped base offset and size
|
|
DWORD_PTR GetBlockBaseAddress(DWORD_PTR dwOffset, DWORD &dwSize);
|
|
|
|
MMFOffsetItem *CreateNewPage(DWORD_PTR dwBaseOffset, DWORD dwSize);
|
|
MMFOffsetItem *CreateBasePage(DWORD dwInitSize, DWORD dwGanularity);
|
|
MMFOffsetItem *OpenBasePage(DWORD &dwSizeOfRepository);
|
|
MMFOffsetItem *OpenExistingPage(DWORD_PTR dwBaseOffset);
|
|
void ClosePage(MMFOffsetItem *pOffsetItem);
|
|
void CloseAllPages();
|
|
|
|
public:
|
|
enum { create_new, use_existing };
|
|
|
|
// Constructor.
|
|
CMMFArena2(bool bReadOnly = false);
|
|
|
|
// Destructor.
|
|
~CMMFArena2();
|
|
|
|
//Methods to open an MMF
|
|
bool LoadMMF(const char *pszFile);
|
|
bool CreateNewMMF(const char *pszFile,
|
|
DWORD dwGranularity,
|
|
DWORD dwInitSize);
|
|
|
|
// Allocates a block of memory.
|
|
DWORD_PTR Alloc(IN DWORD dwBytes);
|
|
|
|
// Reallocates a block of memory.
|
|
DWORD_PTR Realloc(DWORD_PTR dwOriginal, DWORD dwNewSize);
|
|
|
|
// Frees a block of memory.
|
|
BOOL Free(DWORD_PTR dwBlock);
|
|
|
|
DWORD Size(DWORD_PTR dwBlock);
|
|
|
|
//Writes any changes not already commited in the MMF to disk.
|
|
BOOL Flush();
|
|
BOOL Flush(DWORD_PTR dwOffsetToFlush);
|
|
|
|
void SetVersion(DWORD dwVersion) { if (m_pHeapDescriptor) m_pHeapDescriptor->m_dwVersion = dwVersion; }
|
|
DWORD GetVersion() { return (m_pHeapDescriptor? m_pHeapDescriptor->m_dwVersion : 0); }
|
|
|
|
DWORD_PTR GetRootBlock();
|
|
void SetRootBlock(DWORD_PTR dwRootBlock) { if (m_pHeapDescriptor) m_pHeapDescriptor->m_dwRootBlock = dwRootBlock; }
|
|
|
|
DWORD GetStatus() { return m_dwStatus; }
|
|
|
|
// Tells the amount of memory remaining without a remap or new extent.
|
|
// ===================================================================
|
|
DWORD_PTR ExtentMemAvail()
|
|
{ return (m_pHeapDescriptor ? (m_pHeapDescriptor->m_dwEndOfHeap - m_pHeapDescriptor->m_dwHeapExtent) : 0);
|
|
}
|
|
|
|
//Given an offset, returns a fixed up pointer
|
|
LPBYTE OffsetToPtr(DWORD_PTR dwOffset);
|
|
|
|
//Given a pointer, returns an offset from the start of the MMF
|
|
DWORD_PTR PtrToOffset(LPBYTE pBlock);
|
|
|
|
// Gets summary heap information.
|
|
// ==============================
|
|
void GetHeapInfo(
|
|
DWORD *pdwTotalSize,
|
|
DWORD *pdwActiveBlocks,
|
|
DWORD *pdwActiveBytes,
|
|
DWORD *pdwFreeBlocks,
|
|
DWORD *pdwFreeBytes
|
|
);
|
|
|
|
MMF_ARENA_HEADER *GetMMFHeader() { return m_pHeapDescriptor; }
|
|
|
|
//Dumps the heap to a file
|
|
void TextDump(const char *pszFile);
|
|
|
|
//Checks the deleted bit of the size block
|
|
BOOL IsDeleted(DWORD_PTR dwBlock) { return IsDeleted((MMF_BLOCK_HEADER*)(OffsetToPtr(dwBlock - sizeof(MMF_BLOCK_HEADER)))); }
|
|
|
|
BOOL IsValidBlock(DWORD_PTR dwBlock) { return ValidateBlock(dwBlock - sizeof(MMF_BLOCK_HEADER)); }
|
|
|
|
//Does a check of the MMF file to make sure it is valid. At time of writing this only
|
|
//checks the file size.
|
|
static BOOL FileValid(const char *pszFilename);
|
|
|
|
bool MappingGood() { return true; }
|
|
|
|
};
|
|
|
|
//***************************************************************************
|
|
//
|
|
// Fixup helpers.
|
|
//
|
|
// These are all strongly type variations of the same thing: they fix
|
|
// up the based ptr to a dereferenceable pointer or take the ptr and
|
|
// fix it back down to an offset.
|
|
//
|
|
//***************************************************************************
|
|
extern CMMFArena2* g_pDbArena;
|
|
template <class T> T Fixup(T ptr)
|
|
{ return T(g_pDbArena->OffsetToPtr(DWORD_PTR(ptr))); }
|
|
template <class T> T Fixdown(T ptr)
|
|
{ return T(g_pDbArena->PtrToOffset(LPBYTE(ptr))); }
|
|
|
|
template <class T> class Offset_Ptr
|
|
{
|
|
private:
|
|
T *m_pTarget;
|
|
T *m_poTarget;
|
|
|
|
protected:
|
|
void SetValue(T *val) { m_pTarget = Fixup(val); m_poTarget = val;}
|
|
void SetValue(Offset_Ptr &val) { m_pTarget = val.m_pTarget; m_poTarget = val.m_poTarget; }
|
|
|
|
public:
|
|
Offset_Ptr() : m_pTarget(0), m_poTarget(0) {}
|
|
|
|
T* operator ->() { return m_pTarget; }
|
|
DWORD_PTR GetDWORD_PTR() { return DWORD_PTR(m_poTarget); }
|
|
T* GetOffset() { return m_poTarget; }
|
|
T* GetPtr() { return m_pTarget; }
|
|
};
|
|
#endif
|
|
|
|
#else
|
|
#define __STR2__(x) #x
|
|
#define __STR1__(x) __STR2__(x)
|
|
#define __LOC__ __FILE__ "("__STR1__(__LINE__)") : Error xxxx: "
|
|
#pragma message("Unknown platform destination specified in makefile. Don't know what database version to use.")
|
|
#pragma message(__LOC__"Unsupported platform destination for MMFArena2.")
|
|
#undef __STR2__
|
|
#undef __STR1__
|
|
#undef __LOC__
|
|
#endif |