/*+-----------------------------------------------------------------------+*
~MFM Memory Manager Xmem BlkHdr
*+-----------------------------------------------------------------------+*/
boolean Mem_MakeXmemChunks
(indextype AllocQty, indextype ExtendQty,
ft F,lt Z,zz *Status)
{
/* Create The VirtualFile ChunkChunks */
if (MemMakeChunk (sizeof(indextype), AllocQty,
ExtendQty, 0,
McStat, &XmemBlkDirChunk))
if (MemPutStackPtr (XmemBlkDirChunk, 1, McStat))
if (MemMakeChunk (sizeof(blktkntype), AllocQty,
ExtendQty, 0,
McStat, &XmemBlkTknChunk))
if (MemPutStackPtr (XmemBlkTknChunk, 1, McStat))
if (MemMakeChunk (sizeof(bytessize ), AllocQty,
ExtendQty, 0,
McStat, &XmemBlkSizeChunk))
if (MemPutStackPtr (XmemBlkSizeChunk, 1, McStat))
{
XmemSize = 0;
MemBlkFile = XmemFilePtr;
MemBlkDirChunk = XmemBlkDirChunk;
MemBlkTknChunk = XmemBlkTknChunk;
MemBlkSizeChunk = XmemBlkSizeChunk;
XmemHeadFreeVbns =
MemHeadFreeVbns = 0;
XmemHeadFreeBlks =
MemHeadFreeBlks = 0;
XmemHeadNullBlks =
MemHeadNullBlks = 0;
XmemBlkDir =
MemBlkDir = (indextype *)Theory->ChunkAddr[XmemBlkDirChunk];
XmemBlkTkn =
MemBlkTkn = (blktkntype *)Theory->ChunkAddr[XmemBlkTknChunk];
XmemBlkSize =
MemBlkSize = (bytessize *)Theory->ChunkAddr[XmemBlkSizeChunk];
}
if (DeBug)
DumpChunkChunk (1, XmemBlkDirChunk);
TRACK(TrackBak," strcpy (Mem_MakeXmemChunks\n");
return (STAT);
}
boolean FileGetZeroedChunk (vbntype VbnBlk, blkhdrtype *BlkHdr,
boolean Release,
ft F,lt Z,zz *Status, numtype *Chunk)
{
bytessize UnitSize = 0;
indextype UnitCount = 0;
bytessize ChunkSize = 0;
vbntype ChunkRefVbn = VbnBlk;
chunkstruc ChunkRef;
chunkstruc *ChunkRefPtr = &ChunkRef;
addrtype ChunkAddr = NullPtr;
/* Load Chunk Struc Into Core */
if (FileInBlk ((addrtype *)&ChunkRefPtr, sizeof(chunkstruc),
BlkHdr, Release, McStat, &ChunkRefVbn))
{
UnitSize = ChunkRefPtr->UnitSize;
UnitCount = ChunkRefPtr->UnitCount;
ChunkSize = UnitCount * UnitSize;
if (!*Chunk)
MemMakeChunk (UnitSize, UnitCount, ChunkRef.ExtendQty,
DbmDbId, McStat, Chunk);
if (Normal(*Status))
MemPutStackPtr (*Chunk, ChunkRef.StackPtr, McStat);
if (!ChunkSize)
if (sprintf (Msg, TraceStr(43),
/* " ZERO BLOCK [%3u] ZERO Chunk[%4u](%2u * %2u)\n" */
VbnBlk, *Chunk, UnitCount, UnitSize))
TraceMsg (0, Msg);
if (MemGetChunkAddr (*Chunk, McStat, &ChunkAddr))
memset (ChunkAddr, NULL, (size_t )ChunkSize);
}
if (Normal(*Status))
if (DeBug)
MemDumpChunk (0, *Chunk, McStat);
TRACK(TrackBak,"FileGetZeroedChunk\n");
return(STAT);
}
boolean DbmGetVchunkTkn (tokentype *Token,
ft F,lt Z,zz *Status, vchunktkntype *VchunkTkn)
{
dbheader *CoreDb = NullPtr;
grpheader *GrpHdr = NullPtr;
vchunktkntype *VchunkDir = NullPtr;
numtype RgnNum = 0;
indextype LocalIndex = 0;
numtype Chunk = 0;
indextype StackPtr = 0;
if (!Token->Handle)
*Status = Oa_VchunkNotExist;
if (TmGetCoreDb (Token, McStat, &CoreDb))
if ((GrpHdr = CoreDb->VchunkGrpHdr) == NullPtr)
{
if (GrpGetPacket (Token, CoreDb->VchunkGrpNum,
McStat, &CoreDb->VchunkGrpHdr))
{
GrpHdr = CoreDb->VchunkGrpHdr;
StackPtr = GrpHdr->EntryCount + 1;
}
if (Normal(*Status))
if (DbmBug)
Grp_DumpStruct (Token, CoreDb->VchunkGrpNum, McStat);
#ifdef __FREEZE_VCHUNKS__
if (Normal(*Status))
if (CoreDb->DbId > WenvId)
if (MemNewBitChunk (StackPtr, CoreDb->DbId,
McStat, &(CoreDb->VchunkCommitDir)))
if (MemMakeChunk (sizeof(vbntype), StackPtr, 2000,
CoreDb->DbId, McStat, &(CoreDb->VchunkSwapDir)))
MemPutStackPtr (CoreDb->VchunkSwapDir, StackPtr, McStat);
#endif /* __FREEZE_VCHUNKS__ */
}
if (Normal(*Status))
{
if (Token->Handle < GrpHdr->BaseIndex)
{
RgnNum = 0;
LocalIndex = Token->Handle;
} else {
RgnNum = (Token->Handle - GrpHdr->BaseIndex)
/ GrpHdr->RegionEntrys;
if (GrpHdr->BaseIndex)
RgnNum++;
LocalIndex = (Token->Handle - GrpHdr->BaseIndex)
% GrpHdr->RegionEntrys;
}
if (GrpGetRegion (CoreDb, GrpHdr, RgnNum,
McStat, &Chunk, (addrtype *)&VchunkDir))
*VchunkTkn = VchunkDir[LocalIndex];
if ( RgnNum == 0 )
GrpHdr->BaseRegion = Chunk ;
if (VchunkTkn->InCore == 0
&& VchunkTkn->OnDisk == 0)
if (MemGetChunkNum (GrpHdr->RegionChunkDir, RgnNum, McStat, &Chunk))
if (Chunk)
DumpChunkChunk (0, Chunk);
}
TRACK(TrackBak,"DbmGetVchunkTkn\n");
return (STAT);
}
boolean DbmNewVchunk (tokentype *Anchor, sizetype UnitSize,
indextype UnitCount, indextype ExtendQty,
ft F,lt Z,zz *Status,
indextype *Vchunk, addrtype *ChunkAddr)
{
dbheader *CoreDb = NullPtr;
vchunktkntype VchunkToken;
grpheader *GrpHdr = NullPtr;
static sizetype EntrySize = sizeof (vchunktkntype);
static numtype AllocRgns = 0;
static numtype RgnEntrys = 125;
static numtype AllocXs = 1000;
static numtype BaseIndex = 2;
static accesstype AccessType = Read_Write;
static boolean DiskCache = False;
static numtype CacheLimit = 0;
static numtype CacheLoad = 0;
static numtype NumBuffRgns = 0;
numtype GrpNum = 0;
numtype BaseRegion = 0;
DiskCache = False;
AllocRgns = (Alloc_Handles/125) + 22;
NumBuffRgns = AllocRgns;
CacheLimit = AllocRgns;
CacheLoad = 100;
VchunkToken.OnDisk = 0;
VchunkToken.InCore = 0;
if (TmGetCoreDb (Anchor, McStat, &CoreDb))
if (CoreDb->VchunkGrpNum == 0)
{
if (GrpNewPacket (Anchor, EntrySize, AllocRgns, RgnEntrys,
AllocXs, BaseIndex, AccessType, DiskCache,
CacheLimit,CacheLoad, NumBuffRgns,
McStat, &GrpNum, &GrpHdr, &BaseRegion))
if (GrpNewEntry (Anchor, GrpNum,
McStat, Vchunk, (addrtype )&VchunkToken))
GrpHdr->EnvObjType = UnitChunk_AttrNum;
CoreDb->VchunkGrpNum = GrpNum;
CoreDb->VchunkGrpHdr = GrpHdr;
if (Normal(*Status))
if (Anchor->DbId > WenvId)
if (CoreDb->VchunkCommitDir == 0)
if (MemNewBitChunk (10000, Anchor->DbId,
McStat, &(CoreDb->VchunkCommitDir)))
if (MemMakeChunk (sizeof(vbntype), 10000, 2000,
Anchor->DbId, McStat, &(CoreDb->VchunkSwapDir)))
MemPutStackPtr (CoreDb->VchunkSwapDir, 1, McStat);
}
if (Normal(*Status))
if (MemMakeChunk (UnitSize, UnitCount, ExtendQty, Anchor->DbId,
McStat, &VchunkToken.InCore))
GrpPutNewEntry (Anchor, CoreDb->VchunkGrpNum,
(addrtype )&VchunkToken,
McStat, Vchunk);
if (Normal(*Status))
MemGetChunkAddr (VchunkToken.InCore, McStat, ChunkAddr);
#ifdef __FREEZE_VCHUNKS__
if (Normal(*Status))
if (Anchor->DbId > WenvId)
if (CoreDb->VchunkCommitDir)
if (MemPutBit (CoreDb->VchunkCommitDir, *Vchunk, 1,
McStat))
MemPutVbn (CoreDb->VchunkSwapDir, *Vchunk, 0,
McStat);
#endif /* __FREEZE_VCHUNKS__ */
TRACK(TrackBak,"DbmNewVchunk\n");
return (STAT);
}
/*+-----------------------------------------------------------------------+*/
boolean DbmFileInBlkHdr (dbheader *DbHdr, ft F,lt Z,zz *Status)
{
chunkstruc CS;
farlongtype Offset = sizeof (chunkstruc);
addrtype ChunkAddr = NullPtr;
/* Create The DbFile Blk Chunks */
if (DeBug >= 0 || DbmBug)
if (sprintf (Msg, " DB BlkDirOffset : @%8x\n", DbHdr->BlkDirOffset))
TraceMsg (0, Msg);
if (FileGetSomeBytes (&DbHdr->BlkHdr, DbHdr->BlkDirOffset,
(unsigned )sizeof (chunkstruc),
McStat, (addrtype )&CS))
if (MemMakeChunk (CS.UnitSize, CS.UnitCount,
CS.ExtendQty, DbHdr->DbId,
McStat, &DbHdr->BlkHdr.BlkDirChunk))
if (MemGetChunkAddr (DbHdr->BlkHdr.BlkDirChunk, McStat, &ChunkAddr))
if (FileGetSomeBytes (&DbHdr->BlkHdr, DbHdr->BlkDirOffset + Offset,
(unsigned )(CS.UnitSize * CS.UnitCount),
McStat, ChunkAddr))
MemPutStackPtr (DbHdr->BlkHdr.BlkDirChunk, CS.StackPtr, McStat);
if (DeBug >= 0 || DbmBug)
if (sprintf (Msg, " DB BlkDirChunk : Chunk[%4u] AT Vbn[%3u]\n",
DbHdr->BlkHdr.BlkDirChunk, DbHdr->BlkDirVbn))
if (TraceMsg (0, Msg))
MemDumpChunkStruc(&CS, McStat);
if (Normal(*Status))
if (FileGetSomeBytes (&DbHdr->BlkHdr, DbHdr->BlkTknOffset,
(unsigned )sizeof (chunkstruc),
McStat, (addrtype )&CS))
if (MemMakeChunk (CS.UnitSize, CS.UnitCount,
CS.ExtendQty, 0,
McStat, &DbHdr->BlkHdr.BlkTknChunk))
if (MemGetChunkAddr (DbHdr->BlkHdr.BlkTknChunk, McStat, &ChunkAddr))
if (FileGetSomeBytes (&DbHdr->BlkHdr, DbHdr->BlkTknOffset + Offset,
(unsigned )(CS.UnitSize * CS.UnitCount),
McStat, ChunkAddr))
if (MemPutStackPtr (DbHdr->BlkHdr.BlkTknChunk, CS.StackPtr, McStat))
if (DeBug >= 0 || DbmBug)
if (sprintf (Msg, " DB BlkTknChunk : Chunk[%4u] AT Vbn[%3u]\n",
DbHdr->BlkHdr.BlkTknChunk, DbHdr->BlkTknVbn))
if (TraceMsg (0, Msg))
MemDumpChunkStruc(&CS, McStat);
if (Normal(*Status))
if (FileGetSomeBytes (&DbHdr->BlkHdr, DbHdr->BlkSizeOffset,
(unsigned )sizeof (chunkstruc),
McStat, (addrtype )&CS))
if (MemMakeChunk (CS.UnitSize, CS.UnitCount,
CS.ExtendQty, 0,
McStat, &DbHdr->BlkHdr.BlkSizeChunk))
if (MemGetChunkAddr (DbHdr->BlkHdr.BlkSizeChunk, McStat, &ChunkAddr))
if (FileGetSomeBytes (&DbHdr->BlkHdr, DbHdr->BlkSizeOffset+ Offset,
(unsigned )(CS.UnitSize * CS.UnitCount),
McStat, ChunkAddr))
if (MemPutStackPtr (DbHdr->BlkHdr.BlkSizeChunk, CS.StackPtr, McStat))
if (DeBug >= 0 || DbmBug)
if (sprintf (Msg, " DB BlkSizeChunk : Chunk[%4u] AT Vbn[%3u]\n",
DbHdr->BlkHdr.BlkSizeChunk, DbHdr->BlkSizeVbn))
if (TraceMsg (0, Msg))
MemDumpChunkStruc(&CS, McStat);
TRACK(TrackBak,"DbmFileInBlkHdr\n");
return(STAT);
}
boolean DbmLoadDbHdr (tokentype *DbToken, char *LoadFileName,
ft F,lt Z,zz *Status, dbheader **CoreDb)
{
boolean TmpWriteHdr = WriteHdr;
boolean TmpSwapBug = SwapBug;
int TmpDeBug = DeBug;
boolean TmpDbmBug = DbmBug;
vbntype DbHdrVbn = 0;
boolean Release = False;
dbheader *DbHdr = *CoreDb;
indextype HndlUnits = 0;
numtype AllocGroups = 0;
sprintf (Msg, "\n OPEN File %s \n", LoadFileName);
TraceMsg (0, Msg);
if (!DbmBug && !SwapBug)
WriteHdr = True;
/*DbmBug = True; */
/* Reserve space for the NEW DbHeader */
if (*CoreDb)
{
WriteHdr = TmpWriteHdr;
sprintf (Msg, "\n CoreDb ALREADY LOADED @%x\n\n", *CoreDb);
TraceMsg (0, Msg);
return (STAT);
}
if (LoadFileName == NullPtr)
*Status = File_NoName;
else if (!strlen (LoadFileName))
*Status = File_NoName;
else
DiskFilePtr = fopen (LoadFileName, "r+b");
if (DiskFilePtr == NULL)
{
#ifdef _WIN32
int err = errno;
unsigned long lasterr = GetLastError();
#endif
SendMsg (0, " DbmLoadDbHdr:: Null File Name\n");
*Status = File_WontOpen;
}
#ifdef NO_DISKCACHE
else
setvbuf (DiskFilePtr, NULL, _IONBF, 1024);
/* setvbuf (DiskFilePtr, NULL, _IOFBF, 1024); */
#endif
#ifdef __DISPLAY_MESSAGE__
if (Normal(*Status) || DbmBug)
if (sprintf (Msg, " LOAD DBHDR FilePtr = %x; CoreDb @%8x\n",
DiskFilePtr, *CoreDb))
TraceMsg (0, Msg);
#endif /* __DISPLAY_MESSAGE__ */
/* LastBlkOffset[DbHdr->DbId] = 0;
fseek (DbHdr->BlkHdr.BlkFile, LastBlkOffset[DbHdr->DbId], SEEK_SET);
*/
if (Normal(*Status))
{
CoreMoreCore (sizeof (dbheader), McStat, (addrtype *)&DbHdr);
#ifdef __DISPLAY_MESSAGE__
sprintf (Msg, " CoreDb[%4u] Located @%x\n", DbToken->DbId, DbHdr);
TraceMsg (0, Msg);
#endif /* __DISPLAY_MESSAGE__ */
}
if (Normal(*Status))
{
*Status = Env_Normal;
if (sprintf (Msg, " *Status =%4d\n", *Status))
TraceMsg (0, Msg);
DbHdr->BlkHdr.BlkFile = DiskFilePtr;
if (FileGetSomeBytes (&DbHdr->BlkHdr, (farlongtype )0,
(unsigned )sizeof (dbheader),
McStat, (addrtype )DbHdr))
{
/*
BlkDir_Vbn = DbHdr->BlkDirVbn;
BlkDir_Units = DbHdr->BlkDirUnits;
BlkDir_Offset = DbHdr->BlkDirOffset;
BlkTkn_Vbn = DbHdr->BlkTknVbn;
BlkTkn_Units = DbHdr->BlkTknUnits;
BlkTkn_Offset = DbHdr->BlkTknOffset;
BlkSize_Vbn = DbHdr->BlkSizeVbn;
BlkSize_Offset = DbHdr->BlkSizeOffset;
*/
sprintf (Msg, " DB HDR restored from FileVbn[%3u]\n", DbHdrVbn);
TraceMsg (0, Msg);
}
}
if (Normal(*Status))
{
DbHdr->GrpHdrDir = 0;
DbHdr->GrpVbnDir = 0;
DbHdr->ObjectIndexDir = 0;
DbHdr->ObjectAddrDir = 0;
DbHdr->ObjectMemLocDir = 0;
DbHdr->ObjectMemRefDir = 0;
DbHdr->LocalObjNumDir = 0;
DbHdr->LocalObjNumMap = 0;
DbHdr->ObjHandleDir = 0;
DbHdr->ObjNumMap = 0;
DbHdr->ObjTimeStampDir = 0;
DbHdr->ObjHdrDir = 0;
DbHdr->ObjVbnDir = 0;
DbHdr->VchunkCommitDir = 0;
DbHdr->VchunkSwapDir = 0;
DbHdr->VbnDeleteDir = 0;
DbHdr->VchunkGrpHdr = NullPtr;
DbHdr->NewHandles = 0;
DbHdr->FreeRegionDir = 0;
DbHdr->FreeRegionLengths = 0;
DbHdr->BlkHdr.BlkFile = DiskFilePtr;
DbHdr->BlkHdr.BlkDirChunk = 0;
DbHdr->BlkHdr.BlkTknChunk = 0;
DbHdr->BlkHdr.BlkSizeChunk= 0;
DbHdr->LocalAttrNumMap = 0;
DbHdr->AttrHandleDir = 0;
DbHdr->AttrNumMap = 0;
DbHdr->LocalAttrSizeTbl = 0;
DbHdr->TextTokenDir = 0;
DbHdr->FreeTxtTknStack = 0;
if (DbHdr->DbId == RenvId && SwapHandles)
{
CoreHandles = DbHdr->HandleCount;
if (sprintf (Msg, " 1st %u Handles Of Renv are NonPutable\n",
CoreHandles))
TraceMsg (0, Msg);
}
}
#ifdef __FREEZE_VCHUNKS__
if (Normal(*Status))
if (DbHdr->DbId > WenvId)
if (MemMakeChunk (sizeof(vbntype), 5000, 2000,
DbHdr->DbId, McStat, &(DbHdr->VbnDeleteDir)))
MemPutStackPtr (DbHdr->VbnDeleteDir, 0, McStat);
#endif /* __FREEZE_VCHUNKS__ */
if (Normal(*Status))
if (DbHdr->ObjectAddrDir == 0)
if (DbHdr->HandleUnits)
{
if (MemMakeChunk (sizeof(addr),
DbHdr->HandleUnits, Extend_Handles,
DbHdr->DbId, McStat, &(DbHdr->ObjectAddrDir)))
MemPutStackPtr (DbHdr->ObjectAddrDir, DbHdr->HandleCount, McStat);
HndlUnits = DbHdr->HandleUnits;
}
if (Normal(*Status))
if (DbHdr->HandleUnits)
MemNewBitChunk (HndlUnits, DbHdr->DbId,
McStat, &(DbHdr->ObjectMemLocDir));
if (Normal(*Status))
if (DbHdr->HandleUnits)
if (DbHdr->DbId > WenvId)
if (MemMakeChunk (sizeof(shorttype),
DbHdr->HandleUnits, Extend_Handles,
DbHdr->DbId, McStat, &(DbHdr->ObjectMemRefDir)))
MemPutStackPtr (DbHdr->ObjectMemRefDir, DbHdr->HandleCount, McStat);
if (Normal(*Status))
if (DbmFileInBlkHdr (DbHdr, McStat))
if (DbmFileInDbHdr (DbHdr, Release, McStat))
if (DbHdr->GrpCount == 0 )
AllocGroups = Alloc_Grps ;
else
AllocGroups = DbHdr->GrpCount + Extend_Grps ;
if (Normal(*Status))
if (MemMakeChunk (sizeof(addrtype),
AllocGroups , Extend_Grps,
DbHdr->DbId, McStat, &(DbHdr->GrpHdrDir)))
if (MemPutStackPtr (DbHdr->GrpHdrDir, DbHdr->GrpCount+1, McStat))
if (MemGetChunkAddr(DbHdr->GrpHdrDir,McStat,(addrtype *) &DbHdr->GrpHdrs))
if (MemMakeChunk (sizeof(addrtype),
DbHdr->LastEnvObjCount+1 , Extend_DbObjs,
DbHdr->DbId, McStat, &(DbHdr->ObjHdrDir)))
if (MemPutStackPtr (DbHdr->ObjHdrDir, DbHdr->LocalObjCount+2, McStat))
if (DeBug || DbmBug)
if (sprintf (Msg, " DB ObjHdrDir : Chunk[%4u] AT Vbn[%3u]\n",
DbHdr->ObjHdrDir, DbHdr->ObjHdrDirVbn))
TraceMsg (0, Msg);
if (Normal(*Status))
{
*CoreDb = DbHdr;
sprintf (Msg, "\n DB[%2u] LOADED; Handles= %u\n",
DbHdr->DbId, DbHdr->HandleCount);
TraceMsg (0, Msg);
/*
sprintf (Msg, " DB[%2u] Header LOADED @ %x Handles= %u\n",
DbHdr->DbId, DbHdr, DbHdr->HandleCount);
TraceMsg (0, Msg);
*/
}
if (Normal(*Status))
if (DbHdr->DbId == WenvId)
{
CoreDbCount = 100;
/* CoreDbs[WenvId] = DbHdr;
KernelGetAttr (&WenvTkn, DbCount_AttrNum,
McStat, (addrtype )&CoreDbCount);
*/
}
SwapBug = TmpSwapBug;
DbmBug = TmpDbmBug;
DeBug = TmpDeBug;
WriteHdr = TmpWriteHdr;
TRACK(TrackBak,"DbmLoadDbHdr\n");
return(STAT);
}
