You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1680 lines
55 KiB
1680 lines
55 KiB
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1995-2000.
|
|
//
|
|
// File: PropRec.hxx
|
|
//
|
|
// Contents: Record format for persistent property store
|
|
//
|
|
// Classes: CPropertyRecord
|
|
//
|
|
// History: 28-Dec-19 KyleP Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#pragma once
|
|
|
|
#include <propset.h>
|
|
#include <cidebug.hxx>
|
|
#include <pstore.hxx>
|
|
|
|
class CStorageVariant;
|
|
|
|
const PREV = 0;
|
|
const NEXT = 1;
|
|
const FREEBLOCKSIZE = 2;
|
|
const cFreeListSlots = 3;
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Class: COnDiskPropertyRecord
|
|
//
|
|
// Purpose: Manipulates property values for single object/record
|
|
//
|
|
// History: 28-Dec-95 KyleP Created
|
|
// 29-May-97 KrishnaN Made records self describing
|
|
// 16-Dec-97 KrishnaN Added support for "lean" records
|
|
//
|
|
// Notes: This class is like a template, that applies structure to a
|
|
// single record of a memory-mapped file. Layout of data
|
|
// members corresponds exactly to the on-disk version of the
|
|
// property store.
|
|
//
|
|
// There are two types of records "normal" and "lean". Normal
|
|
// records have all the support they need to handle overflows,
|
|
// variable length records, and variable length properties. The
|
|
// "lean" records, on the other hand, can only store fixed
|
|
// properties. Since the size of a lean record is always known
|
|
// and fixed (until changes to the metadata are made), we don't
|
|
// need the ability for overflows and for variable length records.
|
|
// That gives us an opportunity to eliminate a significant portion
|
|
// of the COnDiskPropertyRecord overhead for a lean record.
|
|
//
|
|
// Layout of a normal record is as follows:
|
|
// 1) Per-record state.
|
|
// Count of additional records appended physically
|
|
// to this one. Low bit used to indicate record
|
|
// is in use.
|
|
// Used space in variable property area (in dwords)
|
|
// Link to overflow record.
|
|
// 2) Existence bitmap. One dword / 16 properties, rounded up
|
|
// to nearest dword. First bit (of two) indicates existence.
|
|
// Second indicates existence is on overflow.
|
|
// 3) Fixed length property storage.
|
|
// 4) Variable length property storage. For each property:
|
|
// Dword for size.
|
|
// High word is size (in dwords) used by current property.
|
|
// Low word is allocated size (in dwords).
|
|
// Allocated space.
|
|
//
|
|
//
|
|
// Layout of a lean record is as follows:
|
|
//
|
|
// 1) Existence bitmap. One dword / 16 properties, rounded up
|
|
// to nearest dword. First bit (of two) indicates existence.
|
|
// Second is unused but left in for compatibility with normal record.
|
|
// 3) Fixed length property storage.
|
|
//
|
|
// Freelist Maintenance:
|
|
//
|
|
// When a record is not in use, it goes into the free list. This list
|
|
// is a doubly linked list sorted by size. The next and prev pointers
|
|
// used to be stored in the toplevel and overflow fields of the normal
|
|
// record. With the introduction of the lean version of the record,
|
|
// which doesn't have the toplevel and overflow fields, we need to
|
|
// have two fields to be always present that can be used for link
|
|
// tracking. The first and second fields of the data portion, pointed
|
|
// to by _aul, will be used to store these ptrs. A third field is needed
|
|
// to track the size of the next free block. Therefore the minimum
|
|
// size of a record is being modified to include space for _aul[PREV], _aul[NEXT],
|
|
// and _aul[FREEBLOCKSIZE]. When we start adding records, we will account for the
|
|
// preallocation of these three ULONG fields.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#include <pshpack4.h>
|
|
|
|
class COnDiskPropertyRecord
|
|
{
|
|
enum ERecType { eVirgin = 0x0000,
|
|
eTopLevel = 0xAAAA,
|
|
eOverflow = 0x5555,
|
|
eFree = 0xBBBB,
|
|
eTopLevelLean = 0xCCCC,
|
|
eFreeLean = 0xDDDD};
|
|
|
|
public:
|
|
|
|
inline void * operator new( size_t size, ULONG record, BYTE * pBase, ULONG culRec );
|
|
inline void operator delete( void * p );
|
|
|
|
inline static ULONG MinStreamSize( ULONG record, ULONG culRec );
|
|
|
|
//
|
|
// Block linking
|
|
//
|
|
|
|
inline WORKID OverflowBlock() const;
|
|
inline void SetOverflowBlock( WORKID wid );
|
|
|
|
inline WORKID ToplevelBlock() const;
|
|
inline void SetToplevelBlock( WORKID wid );
|
|
inline void ClearToplevelField();
|
|
|
|
|
|
//
|
|
// Simple reads / writes.
|
|
//
|
|
|
|
void ReadFixed( ULONG Ordinal,
|
|
ULONG Mask,
|
|
ULONG oStart,
|
|
ULONG cTotal,
|
|
ULONG Type,
|
|
PROPVARIANT & var,
|
|
BYTE * pbExtra,
|
|
unsigned * pcbExtra,
|
|
PStorage & storage );
|
|
|
|
BOOL ReadVariable( ULONG Ordinal,
|
|
ULONG Mask,
|
|
ULONG oStart,
|
|
ULONG cTotal,
|
|
ULONG cFixed,
|
|
PROPVARIANT & var,
|
|
BYTE * pbExtra,
|
|
unsigned * pcbExtra );
|
|
|
|
void WriteFixed( ULONG Ordinal,
|
|
ULONG Mask,
|
|
ULONG oStart,
|
|
ULONG Type,
|
|
ULONG cTotal,
|
|
CStorageVariant const & var );
|
|
|
|
BOOL WriteVariable( ULONG Ordinal,
|
|
ULONG Mask,
|
|
ULONG oStart,
|
|
ULONG cTotal,
|
|
ULONG cFixed,
|
|
ULONG culRec,
|
|
CStorageVariant const & var,
|
|
PStorage & storage );
|
|
|
|
//
|
|
// Multi-record properties.
|
|
//
|
|
|
|
inline BOOL IsLongRecord();
|
|
inline ULONG CountRecords() const;
|
|
inline void MakeLongRecord( ULONG cRecords );
|
|
|
|
inline BOOL IsValidType() const;
|
|
inline BOOL IsValidInUseRecord( WORKID wid, ULONG cRecPerPage ) const;
|
|
inline BOOL IsValidLength( WORKID wid, ULONG cRecPerPage ) const;
|
|
inline BOOL AreLinksValid( WORKID widMax ) const;
|
|
|
|
static ULONG CountNormalRecordsToStore( ULONG cTotal, ULONG culRec,
|
|
CStorageVariant const & var );
|
|
|
|
//
|
|
// Free list management
|
|
//
|
|
inline void MakeNormalFreeRecord( ULONG cRecords, WORKID widNextFree,
|
|
ULONG cNextFree, ULONG culRec );
|
|
inline void MakeNormalFreeRecord( WORKID widNextFree,
|
|
ULONG cNextFree, ULONG culRec );
|
|
|
|
inline void MakeLeanFreeRecord( ULONG cRecords, WORKID widNextFree,
|
|
ULONG cNextFree, ULONG culRec );
|
|
inline void MakeLeanFreeRecord( WORKID widNextFree,
|
|
ULONG cNextFree, ULONG culRec );
|
|
inline ULONG GetNextFreeRecord() const;
|
|
inline ULONG GetPreviousFreeRecord() const;
|
|
inline ULONG GetNextFreeSize() const;
|
|
inline void SetNextFree( WORKID widNextFree, ULONG cNextFree );
|
|
inline void SetPreviousFreeRecord( WORKID widPreviousFree );
|
|
|
|
//
|
|
// Overflow records chaining.
|
|
//
|
|
inline ULONG GetOverflowChainLength() const;
|
|
inline void IncrementOverflowChainLength();
|
|
inline void SetOverflowChainLength( ULONG cOvfl );
|
|
|
|
//
|
|
// Existence / Use
|
|
//
|
|
|
|
inline BOOL IsInUse() const;
|
|
inline BOOL IsTopLevel() const;
|
|
inline BOOL IsNormalTopLevel() const;
|
|
inline BOOL IsOverflow() const;
|
|
inline BOOL IsLeanFreeRecord() const;
|
|
inline BOOL IsFreeRecord() const;
|
|
inline BOOL IsFreeOrVirginRecord() const;
|
|
|
|
inline void MakeNewNormalTopLevel();
|
|
inline void MakeNewLeanTopLevel();
|
|
inline void MakeNewOverflow();
|
|
inline void ForceOverflow();
|
|
|
|
inline void ClearNormal( ULONG culRec );
|
|
inline void ClearLean( ULONG culRec );
|
|
inline void ClearAll( ULONG culRec );
|
|
|
|
inline BOOL HasProperties( ULONG cTotal );
|
|
|
|
inline USHORT Type() const;
|
|
inline void SetType(USHORT type);
|
|
|
|
//
|
|
// Reader / Writer
|
|
//
|
|
|
|
inline BOOL IsBeingWritten();
|
|
inline BOOL IsBeingRead();
|
|
|
|
inline void AddReader();
|
|
inline void RemoveReader();
|
|
inline void AddWriter();
|
|
inline void RemoveWriter();
|
|
|
|
# if CIDBG == 1
|
|
inline BOOL LokIsBeingWrittenTwice();
|
|
inline BOOL IsNormalEmpty( ULONG culRec );
|
|
inline BOOL IsLeanEmpty( ULONG culRec );
|
|
# endif
|
|
|
|
inline static ULONG FixedOverheadLean();
|
|
inline static ULONG FixedOverheadNormal();
|
|
inline static ULONG MinimalOverheadNormal();
|
|
|
|
inline BOOL IsStored( ULONG Ordinal, ULONG mask );
|
|
inline BOOL IsStoredOnOverflow( ULONG Ordinal, ULONG mask );
|
|
|
|
//
|
|
// Backup support
|
|
//
|
|
|
|
inline void * GetTopLevelFieldAddress() const
|
|
{
|
|
Win4Assert(!IsLeanRecord());
|
|
return (void *) &((SNormalRecord *)&Data)->_ulToplevel;
|
|
};
|
|
|
|
// Lean record support
|
|
inline BOOL IsLeanRecord() const
|
|
{
|
|
return (Type() == eTopLevelLean ||
|
|
Type() == eFreeLean);
|
|
}
|
|
|
|
private:
|
|
|
|
inline void SetStored( ULONG Ordinal, ULONG mask );
|
|
inline void ClearStored( ULONG Ordinal, ULONG mask );
|
|
|
|
inline void SetStoredOnOverflow( ULONG Ordinal, ULONG mask );
|
|
inline void ClearStoredOnOverflow( ULONG Ordinal, ULONG mask );
|
|
|
|
inline static ULONG UsedSize( ULONG ul );
|
|
inline static ULONG AllocatedSize( ULONG ul ) { return (ul & 0xFFFF); }
|
|
|
|
inline static void SetUsedSize( ULONG * pul, ULONG ul );
|
|
inline static void SetAllocatedSize( ULONG * pul, ULONG ul );
|
|
|
|
inline static void MarkOverflow( ULONG * pul );
|
|
inline static BOOL IsOverflow( ULONG ul );
|
|
|
|
inline ULONG FreeVariableSpace( ULONG cTotal, ULONG cFixed, ULONG oStart, ULONG cbRec );
|
|
|
|
inline ULONG * FindVariableProp( ULONG Ordinal, ULONG cFixed, ULONG cTotal, ULONG oStart );
|
|
|
|
static void RightCompress( ULONG * pul, ULONG cul, ULONG cRemaining );
|
|
|
|
static ULONG * LeftCompress( ULONG * pul, ULONG cul, ULONG * pulEnd );
|
|
|
|
//
|
|
// Special optimized Unicode writes.
|
|
//
|
|
|
|
static BOOL IsUnicodeSpecial( CStorageVariant const & var, ULONG & cul );
|
|
|
|
static BOOL IsUnicodeSpecial( SERIALIZEDPROPERTYVALUE const * pProp,
|
|
ULONG & cb );
|
|
|
|
static void WriteUnicodeSpecial( CStorageVariant const & var,
|
|
SERIALIZEDPROPERTYVALUE * pProp );
|
|
|
|
static void ReadUnicodeSpecial( SERIALIZEDPROPERTYVALUE const * pProp,
|
|
PROPVARIANT & var,
|
|
BYTE * pbExtra );
|
|
|
|
static void ReadUnicodeSpecialCTMA( SERIALIZEDPROPERTYVALUE const * pProp,
|
|
PROPVARIANT & var );
|
|
|
|
struct SNormalRecord
|
|
{
|
|
USHORT _type; // Type of the record
|
|
USHORT _cAdditionalRecords; // For long records, size (in records) of long record.
|
|
ULONG _culVariableUsed; // Bytes of record that are in use. Variable section only.
|
|
|
|
WORKID _ulOverflow; // Pointer to overflow block.
|
|
WORKID _ulToplevel; // Pointer to the toplevel record. For toplevel
|
|
// records, this will be the length of the
|
|
// chain.
|
|
|
|
ULONG _aul[1]; // Rest of block is variable:
|
|
// a) Existence bits
|
|
// b) Fixed size properties
|
|
// c) Variable size properties
|
|
};
|
|
|
|
struct SLeanRecord
|
|
{
|
|
USHORT _type; // Type of the record
|
|
USHORT _cAdditionalRecords; // For long records, size (in records) of long record.
|
|
// We only use this field for free list maintenance.
|
|
// "In use" lean records are always one record long.
|
|
ULONG _aul[1]; // Rest of block is variable:
|
|
// a) Existence bits
|
|
// b) Fixed size properties
|
|
};
|
|
|
|
// Convenient inline functions
|
|
|
|
// _cAdditionalRecords is at the same position in both
|
|
// structures. Cast to either structure is fine.
|
|
inline USHORT AdditionalRecords() const
|
|
{
|
|
Win4Assert(offsetof(SNormalRecord, _cAdditionalRecords) ==
|
|
offsetof(SLeanRecord, _cAdditionalRecords));
|
|
return ((SNormalRecord *)&Data)->_cAdditionalRecords;
|
|
}
|
|
|
|
inline void SetAdditionalRecords(USHORT cRecs)
|
|
{
|
|
Win4Assert(offsetof(SNormalRecord, _cAdditionalRecords) ==
|
|
offsetof(SLeanRecord, _cAdditionalRecords));
|
|
((SNormalRecord *)&Data)->_cAdditionalRecords = cRecs;
|
|
}
|
|
|
|
inline ULONG VariableUsed() const
|
|
{
|
|
Win4Assert(!IsLeanRecord());
|
|
return ((SNormalRecord *)&Data)->_culVariableUsed;
|
|
}
|
|
|
|
inline void SetVariableUsed(ULONG ulVarUsed)
|
|
{
|
|
Win4Assert(!IsLeanRecord());
|
|
((SNormalRecord *)&Data)->_culVariableUsed = ulVarUsed;
|
|
}
|
|
|
|
// All we have is a buffer containing the on-disk bits of the record. Depending
|
|
// on the type of the record, we will cast that buffer into SNormalRecord or
|
|
// SLeanRecord.
|
|
ULONG Data;
|
|
};
|
|
|
|
#include <poppack.h>
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::operator new, public
|
|
//
|
|
// Synopsis: Special operator new (computes offset of record in file)
|
|
//
|
|
// Arguments: [size] -- Required (and unused) parameter
|
|
// [record] -- Record number
|
|
// [pBase] -- Address of record 0
|
|
// [culRec] -- Size in dwords of single record
|
|
//
|
|
// History: 27-Dec-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void * COnDiskPropertyRecord::operator new( size_t size,
|
|
ULONG record,
|
|
BYTE * pBase,
|
|
ULONG culRec )
|
|
{
|
|
ciDebugOut(( DEB_PROPSTORE,
|
|
"PROPSTORE: Opening record at offset 0x%x (%d)\n",
|
|
record * culRec * 4,
|
|
record * culRec * 4 ));
|
|
|
|
return pBase + record * culRec * 4;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::operator delete, public
|
|
//
|
|
// Synopsis: Just to make sure it isn't called...
|
|
//
|
|
// History: 27-Dec-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void COnDiskPropertyRecord::operator delete( void * p )
|
|
{
|
|
// No action. This is mapped onto a file.
|
|
}
|
|
|
|
|
|
// _type is the first field of both SNormalRecord
|
|
// and SLeanRecord, so we access it through either
|
|
inline USHORT COnDiskPropertyRecord::Type() const
|
|
{
|
|
return ((SNormalRecord *)&Data)->_type;
|
|
}
|
|
|
|
inline void COnDiskPropertyRecord::SetType(USHORT type)
|
|
{
|
|
((SNormalRecord *)&Data)->_type = type;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::IsLongRecord, public
|
|
//
|
|
// Returns: TRUE if record is long (consists of more than one
|
|
// physically contiguous record).
|
|
//
|
|
// History: 27-Dec-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline BOOL COnDiskPropertyRecord::IsLongRecord()
|
|
{
|
|
// Lean records can only be long when they are in the free list
|
|
#if CIDBG == 1
|
|
if (eTopLevelLean == Type())
|
|
Win4Assert(0 == AdditionalRecords());
|
|
#endif // CIDBG
|
|
|
|
return ( AdditionalRecords() != 0);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::CountRecords, public
|
|
//
|
|
// Returns: Size of record (in one-records)
|
|
//
|
|
// History: 27-Dec-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline ULONG COnDiskPropertyRecord::CountRecords() const
|
|
{
|
|
// Lean records can only be long when they are in the free list
|
|
#if CIDBG == 1
|
|
if (eTopLevelLean == Type())
|
|
Win4Assert(0 == AdditionalRecords());
|
|
#endif // CIDBG
|
|
|
|
return AdditionalRecords() + 1;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::MakeLongRecord, public
|
|
//
|
|
// Synopsis: Indicates record is long.
|
|
//
|
|
// Arguments: [cRecords] -- Number of physically contiguous records.
|
|
//
|
|
// History: 27-Dec-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void COnDiskPropertyRecord::MakeLongRecord( ULONG cRecords )
|
|
{
|
|
Win4Assert( cRecords >= 1 );
|
|
// Win4Assert( !HasProperties( 1 ) );
|
|
|
|
// Lean records can only be long when they are in the free list
|
|
#if CIDBG == 1
|
|
if (eTopLevelLean == Type())
|
|
Win4Assert(1 == cRecords);
|
|
#endif // CIDBG
|
|
|
|
SetAdditionalRecords((USHORT) (cRecords - 1));
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskProperyRecord::IsFreeRecord
|
|
//
|
|
// Synopsis: Tests if the current record is a Free record.
|
|
//
|
|
// History: 2-23-96 srikants Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline BOOL COnDiskPropertyRecord::IsFreeRecord() const
|
|
{
|
|
return (eFreeLean == Type() || eFree == Type());
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskProperyRecord::IsLeanFreeRecord
|
|
//
|
|
// Synopsis: Tests if the current record is a Lean Free record.
|
|
//
|
|
// History: Dec-31-97 KrishnaN Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline BOOL COnDiskPropertyRecord::IsLeanFreeRecord() const
|
|
{
|
|
return (eFreeLean == Type());
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskProperyRecord::IsFreeOrVirginRecord
|
|
//
|
|
// Synopsis: Tests if the current record is a Free or a virgin record.
|
|
//
|
|
// History: 12-03-97 krishnaN Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline BOOL COnDiskPropertyRecord::IsFreeOrVirginRecord() const
|
|
{
|
|
return (eFree == Type() || eFreeLean == Type() ||
|
|
eVirgin == Type());
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::MakeNormalFreeRecord
|
|
//
|
|
// Synopsis: Makes the current normal record a free record.
|
|
//
|
|
// Arguments: [ulNextFree] - The workid of the next free record
|
|
// [cFree] - Size of next free record
|
|
// [culRec] - Count of ULONGs per record.
|
|
//
|
|
// History: 4-11-96 srikants Created
|
|
//
|
|
// Notes: It is assumed that the "_cAdditionalRecords" is correctly set
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void COnDiskPropertyRecord::MakeNormalFreeRecord( WORKID ulNextFree,
|
|
ULONG cFree,
|
|
ULONG culRec )
|
|
{
|
|
ClearNormal( culRec );
|
|
|
|
SetNextFree( ulNextFree, cFree );
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::MakeLeanFreeRecord
|
|
//
|
|
// Synopsis: Makes the current lean record a free record.
|
|
//
|
|
// Arguments: [ulNextFree] - The workid of the next free record
|
|
// [cFree] - Size of next free record
|
|
// [culRec] - Count of ULONGs per record.
|
|
//
|
|
// History: 17-12-97 KrishnaN Created
|
|
//
|
|
// Notes: It is assumed that the "_cAdditionalRecords" is correctly set
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void COnDiskPropertyRecord::MakeLeanFreeRecord( WORKID ulNextFree,
|
|
ULONG cFree,
|
|
ULONG culRec )
|
|
{
|
|
ClearLean( culRec );
|
|
|
|
SetNextFree( ulNextFree, cFree );
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::MakeNormalFreeRecord
|
|
//
|
|
// Synopsis: Makes the current record a free record of length "cRecords"
|
|
//
|
|
// Arguments: [cRecords] - Length of this block in "records"
|
|
// [ulNextFree] - The next free record wid
|
|
// [cFree] - Size of next free record
|
|
// [culRec] - Count of ULONGs per record
|
|
//
|
|
// History: 4-11-96 srikants Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void COnDiskPropertyRecord::MakeNormalFreeRecord(
|
|
ULONG cRecords,
|
|
WORKID ulNextFree,
|
|
ULONG cFree,
|
|
ULONG culRec )
|
|
{
|
|
MakeLongRecord( cRecords );
|
|
MakeNormalFreeRecord( ulNextFree, cFree, culRec );
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::MakeNormalFreeRecord
|
|
//
|
|
// Synopsis: Makes the current record a free record of length "cRecords"
|
|
//
|
|
// Arguments: [cRecords] - Length of this block in "records"
|
|
// [ulNextFree] - The next free record wid
|
|
// [cFree] - Size of next free record
|
|
// [culRec] - Count of ULONGs per record
|
|
//
|
|
// History: 12-17-97 KrishnaN Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void COnDiskPropertyRecord::MakeLeanFreeRecord(
|
|
ULONG cRecords,
|
|
WORKID ulNextFree,
|
|
ULONG cFree,
|
|
ULONG culRec )
|
|
{
|
|
// Mark it to be a free record before attempting to make it a long
|
|
// record.
|
|
|
|
MakeLeanFreeRecord( ulNextFree, cFree, culRec );
|
|
MakeLongRecord( cRecords );
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::SetNextFreeRecord
|
|
//
|
|
// Synopsis: Sets the next free record.
|
|
//
|
|
// History: 4-10-96 srikants Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void COnDiskPropertyRecord::SetNextFree( WORKID widNextFree,
|
|
ULONG cNextFree )
|
|
{
|
|
Win4Assert( IsFreeRecord() );
|
|
ULONG *aul;
|
|
|
|
if (eFree == Type())
|
|
aul = ((SNormalRecord *)&Data)->_aul;
|
|
else
|
|
aul = ((SLeanRecord *)&Data)->_aul;
|
|
|
|
aul[NEXT] = widNextFree;
|
|
aul[FREEBLOCKSIZE] = cNextFree;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::SetPreviousFreeRecord
|
|
//
|
|
// Synopsis: Sets the previous free record.
|
|
//
|
|
// History: 4-10-96 srikants Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void COnDiskPropertyRecord::SetPreviousFreeRecord( WORKID widPrevFree )
|
|
{
|
|
Win4Assert( IsFreeRecord() );
|
|
|
|
if (eFree == Type())
|
|
((SNormalRecord *)&Data)->_aul[PREV] = widPrevFree;
|
|
else
|
|
((SLeanRecord *)&Data)->_aul[PREV] = widPrevFree;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::GetNextFreeRecord
|
|
//
|
|
// Synopsis: Gets the next free record.
|
|
//
|
|
// History: 4-10-96 srikants Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline ULONG COnDiskPropertyRecord::GetNextFreeRecord() const
|
|
{
|
|
Win4Assert( IsFreeRecord() );
|
|
|
|
if (eFree == Type())
|
|
return ((SNormalRecord *)&Data)->_aul[NEXT];
|
|
else
|
|
return ((SLeanRecord *)&Data)->_aul[NEXT];
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::GetPreviousFreeRecord
|
|
//
|
|
// Synopsis: Gets the previous free record.
|
|
//
|
|
// History: 4-10-96 srikants Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline ULONG COnDiskPropertyRecord::GetPreviousFreeRecord() const
|
|
{
|
|
Win4Assert( IsFreeRecord() );
|
|
|
|
if (eFree == Type())
|
|
return ((SNormalRecord *)&Data)->_aul[PREV];
|
|
else
|
|
return ((SLeanRecord *)&Data)->_aul[PREV];
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::GetNextFreeSize
|
|
//
|
|
// Synopsis: Gets the next free blocks size.
|
|
//
|
|
// History: 4-10-96 srikants Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline ULONG COnDiskPropertyRecord::GetNextFreeSize() const
|
|
{
|
|
Win4Assert( IsFreeRecord() );
|
|
|
|
if (eFree == Type())
|
|
return ((SNormalRecord *)&Data)->_aul[FREEBLOCKSIZE];
|
|
else
|
|
return ((SLeanRecord *)&Data)->_aul[FREEBLOCKSIZE];
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::MinStreamSize, public
|
|
//
|
|
// Synopsis: Computes position of record in stream
|
|
//
|
|
// Arguments: [record] -- Record number
|
|
// [culRec] -- Size in dwords of single record
|
|
//
|
|
// Returns: Minimum size stream that can hold this record.
|
|
//
|
|
// History: 27-Dec-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline ULONG COnDiskPropertyRecord::MinStreamSize( ULONG record, ULONG culRec )
|
|
{
|
|
return (record + 1) * culRec * 4;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::OverflowBlock, public
|
|
//
|
|
// Returns: Overflow block id (zero if no overflow block)
|
|
//
|
|
// History: 27-Dec-95 KyleP Created.
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline WORKID COnDiskPropertyRecord::OverflowBlock() const
|
|
{
|
|
Win4Assert(!IsLeanRecord());
|
|
return ((SNormalRecord *)&Data)->_ulOverflow;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::SetOverflowBlock, public
|
|
//
|
|
// Synopsis: Sets overflow block id (zero if no overflow block)
|
|
//
|
|
// Arguments: [wid] -- Workid (record number) of link
|
|
//
|
|
// History: 27-Dec-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void COnDiskPropertyRecord::SetOverflowBlock( WORKID wid )
|
|
{
|
|
Win4Assert(!IsLeanRecord());
|
|
((SNormalRecord *)&Data)->_ulOverflow = wid;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::ToplevelBlock
|
|
//
|
|
// Synopsis: Returns the previous block value.
|
|
//
|
|
// History: 4-10-96 srikants Created
|
|
//
|
|
// Notes: For a top-level record, this will be the length of the
|
|
// overflow chain records.
|
|
// For a free list record, this will be the size of the next
|
|
// free block in the list.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline WORKID COnDiskPropertyRecord::ToplevelBlock() const
|
|
{
|
|
Win4Assert(!IsLeanRecord());
|
|
return ((SNormalRecord *)&Data)->_ulToplevel;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::SetToplevelBlock
|
|
//
|
|
// Synopsis: Updates the previous block value.
|
|
//
|
|
// Arguments: [widPrev] - Value of the previous block
|
|
//
|
|
// History: 4-10-96 srikants Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void COnDiskPropertyRecord::SetToplevelBlock( WORKID widToplevel )
|
|
{
|
|
Win4Assert( eOverflow == Type() );
|
|
((SNormalRecord *)&Data)->_ulToplevel = widToplevel;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::ClearToplevelField, public
|
|
//
|
|
// Arguments:
|
|
//
|
|
// History: 4-10-96 srikants Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void COnDiskPropertyRecord::ClearToplevelField()
|
|
{
|
|
Win4Assert( eFree == Type() || eVirgin == Type() );
|
|
// can't use SetToplevelBlock because that is to be used
|
|
// only with overflow records.
|
|
((SNormalRecord *)&Data)->_ulToplevel = 0;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::GetOverflowChainLength, public
|
|
//
|
|
// Arguments:
|
|
//
|
|
// History: 4-10-96 srikants Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline ULONG COnDiskPropertyRecord::GetOverflowChainLength() const
|
|
{
|
|
Win4Assert( eTopLevel == Type() );
|
|
return ToplevelBlock();
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::IncrementOverflowChainLength, public
|
|
//
|
|
// Arguments:
|
|
//
|
|
// History: 4-10-96 srikants Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void COnDiskPropertyRecord::IncrementOverflowChainLength()
|
|
{
|
|
Win4Assert( eTopLevel == Type() );
|
|
(((SNormalRecord *)&Data)->_ulToplevel)++;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::SetOverflowChainLength, public
|
|
//
|
|
// Arguments: [cCount] -- Size of overflow chain
|
|
//
|
|
// History: 4-10-96 srikants Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void COnDiskPropertyRecord::SetOverflowChainLength( ULONG cCount )
|
|
{
|
|
Win4Assert( !IsLeanRecord() );
|
|
// can't use SetToplevelBlock because that is to be used
|
|
// only with overflow records.
|
|
((SNormalRecord *)&Data)->_ulToplevel = cCount;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::IsInUse, public
|
|
//
|
|
// Returns: TRUE if record is in use.
|
|
//
|
|
// History: 27-Dec-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline BOOL COnDiskPropertyRecord::IsInUse() const
|
|
{
|
|
return (eTopLevel == Type() || eOverflow == Type() ||
|
|
eTopLevelLean == Type());
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::HasProperties, public
|
|
//
|
|
// Arguments: [cTotal] -- Total number of properties in record.
|
|
//
|
|
// Returns: TRUE if record has properties stored on it. May be
|
|
// in use. Used for debugging.
|
|
//
|
|
// History: 22-Feb-96 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline BOOL COnDiskPropertyRecord::HasProperties( ULONG cTotal )
|
|
{
|
|
ULONG *aul;
|
|
|
|
// This won't work if we have a "lean virgin" record. In that case,
|
|
// we need to have separate functions for lean and normal records.
|
|
|
|
Win4Assert(eVirgin != Type());
|
|
|
|
if (IsLeanRecord())
|
|
aul = ((SLeanRecord *)&Data)->_aul;
|
|
else
|
|
aul = ((SNormalRecord *)&Data)->_aul;
|
|
|
|
for ( ULONG cBitWords = ((cTotal-1) / 16) + 1; cBitWords > 0; cBitWords-- )
|
|
{
|
|
if ( aul[cBitWords-1] != 0 )
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::MakeNewNormalTopLevel
|
|
//
|
|
// Synopsis: Marks the current record as a normal top level record.
|
|
//
|
|
// History: 2-23-96 srikants Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void COnDiskPropertyRecord::MakeNewNormalTopLevel()
|
|
{
|
|
Win4Assert(!IsLeanRecord());
|
|
SetType(eTopLevel);
|
|
((SNormalRecord *)&Data)->_ulToplevel =
|
|
((SNormalRecord *)&Data)->_ulOverflow = 0; // Setting the length of overflow chain
|
|
SetVariableUsed(0);
|
|
|
|
// reset the ULONGs of _aul used for free list mgmt.
|
|
RtlZeroMemory(((SNormalRecord *)&Data)->_aul, cFreeListSlots*sizeof(ULONG));
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::MakeNewLeanTopLevel
|
|
//
|
|
// Synopsis: Marks the current record as a lean top level record.
|
|
//
|
|
// History: 17-Dec-97 KrishnaN Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void COnDiskPropertyRecord::MakeNewLeanTopLevel()
|
|
{
|
|
SetType(eTopLevelLean);
|
|
|
|
// reset the ULONGs of _aul used for free list mgmt.
|
|
RtlZeroMemory(((SLeanRecord *)&Data)->_aul, cFreeListSlots*sizeof(ULONG));
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskProperyRecord::IsTopLevel
|
|
//
|
|
// Synopsis: Tests if the current record is a TopLevel record.
|
|
//
|
|
// History: 2-23-96 srikants Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline BOOL COnDiskPropertyRecord::IsTopLevel() const
|
|
{
|
|
return (eTopLevel == Type() || eTopLevelLean == Type());
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskProperyRecord::IsNormalTopLevel
|
|
//
|
|
// Synopsis: Tests if the current record is a TopLevel record.
|
|
//
|
|
// History: 2-23-96 srikants Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline BOOL COnDiskPropertyRecord::IsNormalTopLevel() const
|
|
{
|
|
return (eTopLevel == Type());
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::MakeNewOverflow
|
|
//
|
|
// Synopsis: Marks the record as an overflow record
|
|
//
|
|
// History: 4-10-96 srikants Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void COnDiskPropertyRecord::MakeNewOverflow()
|
|
{
|
|
Win4Assert(!IsLeanRecord());
|
|
|
|
SetType(eOverflow);
|
|
((SNormalRecord *)&Data)->_ulToplevel =
|
|
((SNormalRecord *)&Data)->_ulOverflow = 0; // Setting the length of overflow chain
|
|
SetVariableUsed(0);
|
|
|
|
// reset the ULONGs of _aul used for free list mgmt.
|
|
RtlZeroMemory(((SNormalRecord *)&Data)->_aul, cFreeListSlots*sizeof(ULONG));
|
|
}
|
|
|
|
inline void COnDiskPropertyRecord::ForceOverflow()
|
|
{
|
|
Win4Assert(!IsLeanRecord());
|
|
|
|
SetType(eOverflow);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::IsOverflow
|
|
//
|
|
// Synopsis: Tests if this is an overflow record.
|
|
//
|
|
// History: 4-10-96 srikants Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline BOOL COnDiskPropertyRecord::IsOverflow() const
|
|
{
|
|
return eOverflow == Type();
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::IsValidLength
|
|
//
|
|
// Synopsis: Tests if the length is valid for this record for the given
|
|
// WORKID and records per page. A record can never span page and
|
|
// so the WORKID will help us determine if the length is valid
|
|
// or not.
|
|
//
|
|
// Arguments: [wid] - WORKID of this record
|
|
// [cRecPerPage] - Number of records per page.
|
|
//
|
|
// History: 4-10-96 srikants Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline BOOL COnDiskPropertyRecord::IsValidLength( WORKID wid, ULONG cRecPerPage ) const
|
|
{
|
|
WORKID offset = wid % cRecPerPage;
|
|
|
|
// Lean records can only be long when they are in the free list
|
|
#if CIDBG == 1
|
|
if (eTopLevelLean == Type())
|
|
Win4Assert(0 == AdditionalRecords());
|
|
#endif // CIDBG
|
|
|
|
return offset+AdditionalRecords() < cRecPerPage;
|
|
}
|
|
|
|
inline BOOL COnDiskPropertyRecord::IsValidInUseRecord( WORKID wid, ULONG cRecPerPage ) const
|
|
{
|
|
if ( eTopLevel == Type() || eOverflow == Type() || eTopLevelLean == Type() )
|
|
{
|
|
return IsValidLength( wid, cRecPerPage );
|
|
}
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
inline BOOL COnDiskPropertyRecord::IsValidType() const
|
|
{
|
|
return eTopLevel == Type() ||
|
|
eOverflow == Type() ||
|
|
eFree == Type() ||
|
|
eVirgin == Type() ||
|
|
eFreeLean == Type() ||
|
|
eTopLevelLean== Type();
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::AreLinksValid
|
|
//
|
|
// Synopsis: Tests if the forward and backward links are valid given the
|
|
// widMax.
|
|
//
|
|
// Arguments: [widMax] - The maximum workid that is in use for the entire
|
|
// property store.
|
|
//
|
|
// History: 4-10-96 srikants Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline BOOL COnDiskPropertyRecord::AreLinksValid( WORKID widMax ) const
|
|
{
|
|
// If this method is used for free or virgin records, we will need a
|
|
// conditional return. The links for free records are in _aul[PREV] and _aul[NEXT].
|
|
Win4Assert(!IsFreeOrVirginRecord());
|
|
|
|
if (IsLeanRecord())
|
|
return TRUE; // no links to worry about.
|
|
else
|
|
return OverflowBlock() <= widMax && ToplevelBlock() <= widMax;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::ClearNormal, public
|
|
//
|
|
// Synopsis: Zero complete normal record.
|
|
//
|
|
// Arguments: [culRec] -- Size in dwords of record
|
|
//
|
|
// History: 27-Dec-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void COnDiskPropertyRecord::ClearNormal( ULONG culRec )
|
|
{
|
|
Win4Assert( 2 == offsetof( SNormalRecord, _cAdditionalRecords ) );
|
|
Win4Assert( 4 == offsetof( SNormalRecord, _culVariableUsed ) );
|
|
|
|
RtlZeroMemory( &((SNormalRecord *)&Data)->_culVariableUsed,
|
|
culRec * CountRecords() * sizeof (ULONG) -
|
|
offsetof( SNormalRecord, _culVariableUsed ) );
|
|
|
|
SetType(eFree);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::ClearLean, public
|
|
//
|
|
// Synopsis: Zero complete lean record.
|
|
//
|
|
// Arguments: [culRec] -- Size in dwords of record
|
|
//
|
|
// History: 17-Dec-97 KrishnaN Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void COnDiskPropertyRecord::ClearLean( ULONG culRec )
|
|
{
|
|
RtlZeroMemory( ((SLeanRecord *)&Data)->_aul,
|
|
culRec * CountRecords() * sizeof (ULONG) -
|
|
offsetof( SLeanRecord, _aul ) );
|
|
|
|
SetType(eFreeLean);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::ClearAll
|
|
//
|
|
// Synopsis: Clears the entire record to be 0 filled.
|
|
//
|
|
// Arguments: [culRec] -
|
|
//
|
|
// History: 3-25-96 srikants Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void COnDiskPropertyRecord::ClearAll( ULONG culRec )
|
|
{
|
|
RtlZeroMemory(&Data, culRec*sizeof(ULONG));
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::FixedOverheadNormal, public
|
|
//
|
|
// Returns: Size of normal record including 3 dwords for free list mgmt.
|
|
//
|
|
// History: 27-Dec-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline ULONG COnDiskPropertyRecord::FixedOverheadNormal()
|
|
{
|
|
// We need to preallocate the first three ULONGs of the variable
|
|
// section of the record for free list mgmt.
|
|
return ((ULONG) (ULONG_PTR)&((SNormalRecord *)0)->_aul[3]) / sizeof(ULONG);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::MinimalOverheadNormal, public
|
|
//
|
|
// Returns: Size of normal record, sans uninterpreted variable area.
|
|
//
|
|
// History: 27-Dec-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline ULONG COnDiskPropertyRecord::MinimalOverheadNormal()
|
|
{
|
|
// Just the minimal overhead of a normal record
|
|
return ((ULONG) (ULONG_PTR)&((SNormalRecord *)0)->_aul[0]) / sizeof(ULONG);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::FixedOverheadLean, public
|
|
//
|
|
// Returns: Size of lean record, sans uninterpreted variable area.
|
|
//
|
|
// History: 17-Dec-97 KrishnaN Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline ULONG COnDiskPropertyRecord::FixedOverheadLean()
|
|
{
|
|
// We need to preallocate the first three ULONGs of the variable
|
|
// section of the record for free list mgmt.
|
|
return ((ULONG) (ULONG_PTR)&((SLeanRecord *)0)->_aul[3]) / sizeof(ULONG);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::IsStored, public
|
|
//
|
|
// Synopsis: Test property existence.
|
|
//
|
|
// Arguments: [Ordinal] -- Position of property in list.
|
|
// [mask] -- Bitmask of ordinal. Pre-computed for efficiency.
|
|
//
|
|
// Returns: TRUE if property at [Ordinal] is stored.
|
|
//
|
|
// History: 27-Dec-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline BOOL COnDiskPropertyRecord::IsStored( ULONG Ordinal, ULONG mask )
|
|
{
|
|
Win4Assert(eVirgin != Type());
|
|
|
|
ULONG *aul;
|
|
|
|
if (IsLeanRecord())
|
|
aul = ((SLeanRecord *)&Data)->_aul;
|
|
else
|
|
aul = ((SNormalRecord *)&Data)->_aul;
|
|
|
|
return ( (aul[Ordinal / 16] & mask) != 0 );
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::SetStored, public
|
|
//
|
|
// Synopsis: Marks property as stored.
|
|
//
|
|
// Arguments: [Ordinal] -- Position of property in list.
|
|
// [mask] -- Bitmask of ordinal. Pre-computed for efficiency.
|
|
//
|
|
// History: 27-Dec-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void COnDiskPropertyRecord::SetStored( ULONG Ordinal, ULONG mask )
|
|
{
|
|
Win4Assert(eVirgin != Type());
|
|
|
|
ULONG *aul;
|
|
|
|
if (IsLeanRecord())
|
|
aul = ((SLeanRecord *)&Data)->_aul;
|
|
else
|
|
aul = ((SNormalRecord *)&Data)->_aul;
|
|
|
|
aul[Ordinal / 16] |= mask;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::ClearStored, public
|
|
//
|
|
// Synopsis: Marks property as not stored.
|
|
//
|
|
// Arguments: [Ordinal] -- Position of property in list.
|
|
// [mask] -- Bitmask of ordinal. Pre-computed for efficiency.
|
|
//
|
|
// History: 27-Dec-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void COnDiskPropertyRecord::ClearStored( ULONG Ordinal, ULONG mask )
|
|
{
|
|
Win4Assert(eVirgin != Type());
|
|
|
|
ULONG *aul;
|
|
|
|
if (IsLeanRecord())
|
|
aul = ((SLeanRecord *)&Data)->_aul;
|
|
else
|
|
aul = ((SNormalRecord *)&Data)->_aul;
|
|
|
|
aul[Ordinal / 16] &= ~mask;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::IsStoredOnOverflow, public
|
|
//
|
|
// Synopsis: Test property overflow.
|
|
//
|
|
// Arguments: [Ordinal] -- Position of property in list.
|
|
// [mask] -- Bitmask of ordinal. Pre-computed for efficiency.
|
|
//
|
|
// Returns: TRUE if property at [Ordinal] is stored on overflow record.
|
|
//
|
|
// History: 27-Dec-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline BOOL COnDiskPropertyRecord::IsStoredOnOverflow( ULONG Ordinal, ULONG mask )
|
|
{
|
|
Win4Assert( !IsLeanRecord() );
|
|
Win4Assert( ( mask & (mask - 1) ) == 0 );
|
|
return ( ( ((SNormalRecord *)&Data)->_aul[Ordinal / 16] & (mask << 1)) != 0 );
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::SetStoredOnOverflow, public
|
|
//
|
|
// Synopsis: Marks property as stored on overflow record.
|
|
//
|
|
// Arguments: [Ordinal] -- Position of property in list.
|
|
// [mask] -- Bitmask of ordinal. Pre-computed for efficiency.
|
|
//
|
|
// History: 27-Dec-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void COnDiskPropertyRecord::SetStoredOnOverflow( ULONG Ordinal, ULONG mask )
|
|
{
|
|
Win4Assert( !IsLeanRecord() );
|
|
Win4Assert( ( mask & (mask - 1) ) == 0 );
|
|
((SNormalRecord *)&Data)->_aul[Ordinal / 16] |= (mask << 1);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::ClearStoredOnOverflow, public
|
|
//
|
|
// Synopsis: Marks property as not stored on overflow record.
|
|
//
|
|
// Arguments: [Ordinal] -- Position of property in list.
|
|
// [mask] -- Bitmask of ordinal. Pre-computed for efficiency.
|
|
//
|
|
// History: 27-Dec-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void COnDiskPropertyRecord::ClearStoredOnOverflow( ULONG Ordinal, ULONG mask )
|
|
{
|
|
Win4Assert( !IsLeanRecord() );
|
|
Win4Assert( ( mask & (mask - 1) ) == 0 );
|
|
((SNormalRecord *)&Data)->_aul[Ordinal / 16] &= ~(mask << 1);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::UsedSize, public
|
|
//
|
|
// Arguments: [ul] -- Dword containing used/alloced size fields.
|
|
//
|
|
// Returns: Used size.
|
|
//
|
|
// History: 27-Dec-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline ULONG COnDiskPropertyRecord::UsedSize( ULONG ul )
|
|
{
|
|
ULONG size = ul >> 16;
|
|
|
|
if ( size == 0xFFFF)
|
|
size = 0;
|
|
|
|
return size;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::SetUsedSize, public
|
|
//
|
|
// Synopsis: Sets used size.
|
|
//
|
|
// Arguments: [pul] -- Pointer to dword containing used/alloced size fields.
|
|
// [ul] -- New used size
|
|
//
|
|
// History: 27-Dec-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void COnDiskPropertyRecord::SetUsedSize( ULONG * pul, ULONG ul )
|
|
{
|
|
Win4Assert( AllocatedSize(*pul) >= ul || ul == 0xFFFF );
|
|
*pul = (*pul & 0xFFFF) | (ul << 16);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::SetAllocatedSize, public
|
|
//
|
|
// Synopsis: Sets allocated size.
|
|
//
|
|
// Arguments: [pul] -- Pointer to dword containing used/alloced size fields.
|
|
// [ul] -- New allocated size
|
|
//
|
|
// History: 27-Dec-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void COnDiskPropertyRecord::SetAllocatedSize( ULONG * pul, ULONG ul )
|
|
{
|
|
Win4Assert( (ul >> 16) == 0 );
|
|
*pul = (*pul & 0xFFFF0000) | ul;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::MarkOverflow, public
|
|
//
|
|
// Synopsis: Indicates variable stored in overflow record.
|
|
//
|
|
// Arguments: [pul] -- Pointer to dword containing used/alloced size fields.
|
|
//
|
|
// History: 27-Dec-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void COnDiskPropertyRecord::MarkOverflow( ULONG * pul )
|
|
{
|
|
SetUsedSize( pul, 0xFFFF );
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::IsOverflow, public
|
|
//
|
|
// Arguments: [ul] -- dword containing used/alloced size fields.
|
|
//
|
|
// Returns: TRUE if variable is in overflow record.
|
|
//
|
|
// History: 27-Dec-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline BOOL COnDiskPropertyRecord::IsOverflow( ULONG ul )
|
|
{
|
|
return ((ul & 0xFFFF0000) == 0xFFFF0000);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::FreeVariableSpace, public
|
|
//
|
|
// Synopsis: Compute free space.
|
|
//
|
|
// Arguments: [cTotal] -- Total number of properties in record.
|
|
// [cFixed] -- Count of fixed properties in record.
|
|
// [oStart] -- Offset to start of variable storage area
|
|
// [culRec] -- Size in dwords of record.
|
|
//
|
|
// Returns: Unused variable space in record.
|
|
//
|
|
// History: 27-Dec-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline ULONG COnDiskPropertyRecord::FreeVariableSpace( ULONG cTotal,
|
|
ULONG cFixed,
|
|
ULONG oStart,
|
|
ULONG culRec )
|
|
{
|
|
Win4Assert( !IsLeanRecord() );
|
|
LONG lFree = (culRec * CountRecords()) - // Record size
|
|
MinimalOverheadNormal() - // Minimal fixed overhead
|
|
((cTotal - 1) / 16 + 1) - // Existence bitmap
|
|
oStart - // Fixed property storage
|
|
(cTotal - cFixed) - // Used/Alloc sizes
|
|
VariableUsed(); // Variable properties
|
|
Win4Assert(lFree >= 0);
|
|
|
|
return (ULONG) lFree;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::FindVariableProp, public
|
|
//
|
|
// Synopsis: Locate start of property.
|
|
//
|
|
// Arguments: [Ordinal] -- Ordinal of property to locate.
|
|
// [cFixed] -- Count of fixed properties in record.
|
|
// [cTotal] -- Total number of properties in record.
|
|
// [oStart] -- Offset to start of variable storage area.
|
|
//
|
|
// Returns: Pointer to start of property
|
|
//
|
|
// History: 27-Dec-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline ULONG * COnDiskPropertyRecord::FindVariableProp( ULONG Ordinal,
|
|
ULONG cFixed,
|
|
ULONG cTotal,
|
|
ULONG oStart )
|
|
{
|
|
Win4Assert( !IsLeanRecord() );
|
|
ciDebugOut(( DEB_PROPSTORE,
|
|
"Ordinal = %d, %d fixed, %d total, offset = 0x%x\n",
|
|
Ordinal, cFixed, cTotal, oStart ));
|
|
//
|
|
// Start is after existance bitmap and fixed properties.
|
|
//
|
|
|
|
ULONG * pulVarRecord = &((SNormalRecord *)&Data)->_aul[(cTotal-1) / 16 + 1 + oStart];
|
|
#if CIDBG
|
|
ULONG culUsed = 0;
|
|
#endif // CIDBG
|
|
|
|
|
|
//
|
|
// Skip over variable props. The "+1" is for the allocation dword.
|
|
//
|
|
|
|
for ( ULONG i = cFixed; i < Ordinal; i++ )
|
|
{
|
|
ciDebugOut(( DEB_PROPSTORE, "Ordinal %d starts at offset 0x%x (%d)\n",
|
|
i,
|
|
(ULONG)((ULONG_PTR)pulVarRecord - (ULONG_PTR)this),
|
|
(ULONG)((ULONG_PTR)pulVarRecord - (ULONG_PTR)this) ));
|
|
|
|
#if CIDBG
|
|
culUsed += UsedSize(*pulVarRecord);
|
|
#endif
|
|
pulVarRecord += AllocatedSize(*pulVarRecord) + 1;
|
|
}
|
|
|
|
ciDebugOut(( DEB_PROPSTORE, "Ordinal %d starts at offset 0x%x (%d)\n",
|
|
i,
|
|
(ULONG)((ULONG_PTR)pulVarRecord - (ULONG_PTR)this),
|
|
(ULONG)((ULONG_PTR)pulVarRecord - (ULONG_PTR)this) ));
|
|
|
|
Win4Assert( culUsed + UsedSize(*pulVarRecord) <= VariableUsed() );
|
|
return pulVarRecord;
|
|
}
|
|
|
|
#if CIDBG == 1
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::IsNormalEmpty, public
|
|
//
|
|
// Arguments: [culRec] -- Size of record.
|
|
//
|
|
// Returns: TRUE if the normal record is empty.
|
|
//
|
|
// History: 19-Dec-97 KrishnaN Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline BOOL COnDiskPropertyRecord::IsNormalEmpty( ULONG culRec )
|
|
{
|
|
BOOL fEmpty = ( 0 == VariableUsed() &&
|
|
0 == OverflowBlock() &&
|
|
0 == ToplevelBlock() );
|
|
|
|
for ( ULONG i = 0; i < (culRec-5); i++ )
|
|
{
|
|
if ( 0 != ((SNormalRecord *)&Data)->_aul[i] )
|
|
{
|
|
fEmpty = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return fEmpty;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COnDiskPropertyRecord::IsLeanEmpty, public
|
|
//
|
|
// Arguments: [culRec] -- Size of record.
|
|
//
|
|
// Returns: TRUE if the lean record is empty.
|
|
//
|
|
// History: 19-Dec-97 KrishnaN Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline BOOL COnDiskPropertyRecord::IsLeanEmpty( ULONG culRec )
|
|
{
|
|
BOOL fEmpty = TRUE;
|
|
|
|
for ( ULONG i = 0; i < (culRec-1); i++ )
|
|
{
|
|
if ( 0 != ((SLeanRecord *)&Data)->_aul[i] )
|
|
{
|
|
fEmpty = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return fEmpty;
|
|
}
|
|
|
|
#endif // CIDBG
|
|
|
|
|