boolean FileGetSomeBytes (blkhdrtype *BlkHdr, farlongtype FileOffset,
unsigned SomeBytes,
ft F,lt Z,zz *Status, addrtype BytesAddr)
{
size_t CheckCount = 0;
int SeekStatus = 0;
SeekStatus = fseek (BlkHdr->BlkFile, FileOffset, SEEK_SET);
if (SeekStatus != 0)
{
sprintf (Msg, TraceStr(9),
/* "***FileGetSomeBytes... SeekStatus= %u\n" */
SeekStatus);
TraceMsg (0, Msg);
*Status = File_BadDiskWrite;
}
CheckCount = fread (BytesAddr, SomeBytes, (size_t )1,
BlkHdr->BlkFile);
if (CheckCount != (int )1)
{
sprintf (Msg, TraceStr(10),
/* "***FileGetSomeBytes... CheckCount= %u\n" */
CheckCount);
TraceMsg (0, Msg);
*Status = File_BadDiskWrite;
}
if (SomeBytes == 0)
*Status = Err_NoBytesMoved;
TRACK(TrackBak,"FileGetSomeBytes\n");
return(STAT);
}
//
// DetermineUnitGeometry()
//
// Extract and determine the logical and physical geometry.
//
VOID DetermineUnitGeometry (NPU npU)
{
NPA npA;
NPGEO npGEO;
ULONG MaxSec;
USHORT SecPerCyl;
UCHAR rc;
T('G') T('<')
if ((npU->Flags & (UCBF_NOTPRESENT | UCBF_FORCE)) == UCBF_NOTPRESENT) return;
npA = npU->npA;
// Reconsile the physical geometries.
if (npU->FlagsT & UTBF_IDEGEOMETRYVALID) {
npGEO = &npU->IDEPhysGeom;
} else {
npU->Status = UTS_NOT_PRESENT;
}
npU->PhysGeom = *npGEO;
if ((npU->Flags & (UCBF_NOTPRESENT | UCBF_ATAPIDEVICE)) == 0) {
// Get the BIOS Parameter Block Logical geometry for this drive.
if (!BPBGeometryGet (npU)) {
if (npU->Flags & UCBF_ONTRACK)
npU->PhysGeom.TotalSectors -= ONTRACK_SECTOR_OFFSET;
if (npU->BPBLogGeom.NumHeads * npU->BPBLogGeom.SectorsPerTrack)
npU->FlagsT |= UTBF_BPBGEOMETRYVALID;
}
// Get the BIOS reported and Logical geometry (only if BPB geom failed!)
if (InitActive && !Int13GeometryGet (npU))
if (npU->I13LogGeom.NumHeads * npU->I13LogGeom.SectorsPerTrack)
npU->FlagsT |= UTBF_I13GEOMETRYVALID;
}
// Calculate a logical geometry based on the physical geometry.
LogGeomCalculate (&npU->IDELogGeom, &npU->PhysGeom);
if ((npU->IDELogGeom.NumHeads * npU->IDELogGeom.SectorsPerTrack) == 0)
npU->FlagsT &= ~UTBF_IDEGEOMETRYVALID;
#if TRACES
if (Debug & 16) {
TWRITE(16)
TraceStr ("LGeoB: H:%u S:%u", npU->BPBLogGeom.NumHeads,
npU->BPBLogGeom.SectorsPerTrack);
TWRITE(16)
TraceStr ("LGeo3: H:%u S:%u", npU->I13LogGeom.NumHeads,
npU->I13LogGeom.SectorsPerTrack);
TWRITE(16)
TraceStr ("LGeoI: C:%u H:%u S:%u", npU->IDELogGeom.TotalCylinders,
npU->IDELogGeom.NumHeads,
npU->IDELogGeom.SectorsPerTrack);
TWRITE(16)
}
boolean CoreMoveBytes (addrtype Source, sizeinbytes SourceSize,
sizeinbytes TargetSize,
ft F,lt Z,zz *Status, addrtype *Target )
{
if (SourceSize == 0)
{
*Target = Source;
*Status = Err_NoBytesMoved;
}
if (Normal(*Status))
if (CoreMoreCore (TargetSize, McStat, Target))
memcpy ((char *)*Target, (char *)Source, SourceSize);
if (sprintf (Msg, TraceStr(66),
/* " CoreMoveBytes(%u) @%x to %x NewSize(%u)\n" */
SourceSize, Source, *Target, TargetSize))
SendMsg (0, Msg);
if (Normal(*Status))
CoreFreeCoreSpace (&Source, SourceSize, McStat);
TRACK(TrackBak,"CoreMoveBytes\n");
return(STAT);
}
int CompareBytes (addrtype Source, addrtype CmpVal,
sizeinbytes ByteCount, ft F,lt Z,zz *Status)
{
int i = 0;
if (DeBug >= 2)
if (sprintf (Msg, TraceStr(87),
/* " %u Bytes compared testvalue= %u \n" */
ByteCount, Source, CmpVal,
i = memcmp ((char *)Source, (char *)CmpVal, ByteCount)))
TraceMsg (0, Msg);
if (i<0)
*Status = Env_Less;
else if(i>0)
*Status = Env_Gtr;
else
*Status = Env_Normal;
StackTrack ("CompareBytes\n");
STAT;
return(i);
}
/*+-----------------------------------------------------------------------+
~CM GENERIC EXTERNAL UTILITIES !
+-----------------------------------------------------------------------+*/
void MoveBytes (addrtype Source, addrtype Target,
sizeinbytes ByteCount)
{
memcpy ((char *)Target, (char *)Source, ByteCount);
if (DeBug >= 2 || MemBug)
{
sprintf (Msg, TraceStr(82),
/* " %u Bytes moved from %x to %x " */
ByteCount, Source, Target);
TraceMsg (0, Msg);
switch (ByteCount)
{
case 1 :
sprintf (Msg, TraceStr(83),
/* " %4u\n" */
*(char *)Source);
break;
case 2 :
sprintf (Msg, TraceStr(84),
/* " %4u\n" */
*(short *)Source);
break;
case 8 :
sprintf (Msg, TraceStr(85),
/* "<[%4lu:%4lu]> || <%6xX : %6xX>\n" */
*(longtype *)Source,
*(longtype *)((char *)Source + sizeof (long)),
*(addrtype *)Source,
*(addrtype *)((char *)Source + sizeof (addrtype)));
break;
case 4 :
default :
sprintf (Msg, TraceStr(86),
/* "<%4ld> || <%6xX>\n" */
*(lt64 *)Source, *(addrtype *)Source);
}
TraceMsg (0, Msg);
}
StackTrack ("MoveBytes\n");
return;
}
boolean FileInChunk (numtype *Chunk, blkhdrtype *BlkHdr,
boolean Release,
ft F,lt Z,zz *Status, vbntype *VbnBlk)
{
addrtype ChunkAddr = NullPtr;
bytessize UnitSize = 0;
indextype UnitCount = 0;
sizetype ChunkSize = 0;
sizetype BlkSize = 0;
chunkstruc ChunkRef;
chunkstruc *ChunkRefPtr = &ChunkRef;
addrtype ChunkBlk = NullPtr;
indextype BlkIndex = 0;
if (MemGetIndex (BlkHdr->BlkDirChunk, *VbnBlk,
McStat, &BlkIndex))
if (MemGetWord (BlkHdr->BlkSizeChunk, BlkIndex,
McStat, &BlkSize))
if (!*Chunk)
MemNewChunkBlk (BlkSize, McStat, Chunk, &ChunkBlk);
else {
if (MemGetChunkAddr (*Chunk, McStat, &ChunkAddr))
ChunkBlk = (addrtype )((char *)ChunkAddr - sizeof (chunkstruc));
}
if (Normal(*Status))
if (FileInBlk (&ChunkBlk, BlkSize,
BlkHdr, False, McStat, VbnBlk))
{
ChunkRefPtr = (chunkstruc *)ChunkBlk;
UnitSize = ChunkRefPtr->UnitSize;
UnitCount = ChunkRefPtr->UnitCount;
MemPutChunkStruc (*Chunk, (chunkstruc *)ChunkBlk,
DbmDbId, McStat);
ChunkSize = UnitSize * UnitCount;
if (ChunkSize != BlkSize - sizeof (chunkstruc))
if (sprintf (Msg, TraceStr(41),
/* " ***ERROR... FileInChunk. Size %4u != BlkSize %4u\n" */
ChunkSize, BlkSize))
TraceMsg (0, Msg);
}
if (Normal(*Status))
if (Release)
MemFreeFileBlk (BlkHdr, McStat, VbnBlk);
TRACK(TrackBak,"FileInChunk\n");
return(STAT);
}
/* 12.0.4 */
boolean GrpGetObject (dbheader *CoreDb, objheader *ObjHdr,
indextype Index,
ft F,lt Z,zz *Status, addrtype *RgnAddr)
{
numtype RgnNum = 0;
numtype Chunk = 0;
addrtype ChunkAddr = NullPtr;
indextype LocalIndex = 0;
if (Normal(*Status))
{
if (Index < ObjHdr->BaseIndex)
{
RgnNum = 0;
LocalIndex = Index;
if (ObjHdr->BaseRegion == 0)
GrpGetRegion (CoreDb, (grpheader *)ObjHdr, 0,
McStat, &ObjHdr->BaseRegion, &ChunkAddr);
else
MemGetChunkAddr (ObjHdr->BaseRegion, McStat, &ChunkAddr);
Chunk = ObjHdr->BaseRegion;
} else {
RgnNum = (Index - ObjHdr->BaseIndex) / ObjHdr->RegionObjects;
if (ObjHdr->BaseIndex)
RgnNum++;
LocalIndex = (Index - ObjHdr->BaseIndex) % ObjHdr->RegionObjects;
GrpGetRegion (CoreDb, (grpheader *)ObjHdr, RgnNum,
McStat, &Chunk, &ChunkAddr);
}
*RgnAddr = ChunkAddr;
}
if (Normal(*Status))
if (Admin_Run)
if (CoreDb->DbId < PrimalId)
MemPutBit (ObjHdr->DirtyRegionDir, RgnNum, 1, McStat);
if (!Normal(*Status) || GrpBug || DbmBug || DeBug)
if (sprintf (Msg, TraceStr(6),
/* " GrpGetObject DbId=%3u Obj[%3u] Index=%4u Region[%2u:%2u]\n" */
CoreDb->DbId, ObjHdr->LocalObjNum, Index,
RgnNum, LocalIndex))
TraceMsg (0, Msg);
TRACK(TrackBak,"GrpGetObject\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);
}
/*--------------------------------------------*/
USHORT SetupCommonPre (NPA npA)
{
CHAR Unit;
USHORT Cap;
NPU npU;
UCHAR MinIFTiming, MinUDMA;
#define Restrictions (npA->PCIInfo.Ident.TModes)
/*
** If there were no units attached, then the ACB has been
** deallocated, so do no configuration on this IDE channel.
*/
if (!npA->cUnits) return 1;
npA->PIIX_IDEtim = 0; /* clear timing value initially */
npA->PIIX_SIDEtim = 0; /* clear timing value initially */
npA->DMAtim[0] = 0; /* clear timing value initially */
npA->DMAtim[1] = 0; /* clear timing value initially */
if (npA->Cap & CHIPCAP_SATA) npA->Cap |= CHANCAP_CABLE80 | CHANCAP_SPEED;
if (npA->Cap & CHANCAP_CABLE80) npA->FlagsT |= ATBF_80WIRE;
Cap = npA->Cap;
if (!(npA->FlagsT & ATBF_80WIRE))
Cap &= ~CHANCAP_SPEED;
MinIFTiming = 2;
MinUDMA = 15;
for (npU = npA->UnitCB, Unit = npA->cUnits; --Unit >= 0; npU++) {
if (!(Cap & CHIPCAP_ULTRAATA)) npU->UltraDMAMode = 0;
if (!(Cap & CHIPCAP_ATA66) && (npU->UltraDMAMode > ULTRADMAMODE_2))
npU->UltraDMAMode = ULTRADMAMODE_2;
if (!(Cap & CHIPCAP_ATA100) && (npU->UltraDMAMode > ULTRADMAMODE_4))
npU->UltraDMAMode = ULTRADMAMODE_4;
if (!(Cap & CHIPCAP_ATA133) && (npU->UltraDMAMode > ULTRADMAMODE_5))
npU->UltraDMAMode = ULTRADMAMODE_5;
TSTR("UF:%lX,O:%X", npU->Flags, npU->FlagsT);
if (npU->FlagsT & UTBF_NOT_BM) npU->Flags &= ~UCBF_BM_DMA;
if (npU->Flags & UCBF_ATAPIDEVICE) {
npA->FlagsT |= ATBF_ATAPIPRESENT;
if ((!npU->ATAVersion || (npA->HardwareType == generic))
&& !(npU->FlagsT & UTBF_SET_BM))
npU->Flags &= ~UCBF_BM_DMA;
if (npA->Cap & CHIPCAP_ATAPIPIO32) npU->Flags |= UCBF_PIO32;
if (!(npA->Cap & CHIPCAP_ATAPIDMA)) npU->Flags &= ~UCBF_BM_DMA;
} else {
if (npA->Cap & CHIPCAP_ATAPIO32) npU->Flags |= UCBF_PIO32;
if (!(npA->Cap & CHIPCAP_ATADMA)) npU->Flags &= ~UCBF_BM_DMA;
}
if (npU->Features & 0x2000) npU->Flags &= ~UCBF_PIO32;
npU->InterfaceTiming = (npU->CurPIOMode >= 3) ? npU->CurPIOMode - 2 : 0;
if (!(npU->UltraDMAMode | npU->CurDMAMode))
npU->Flags &= ~UCBF_BM_DMA;
if (npU->Flags & UCBF_BM_DMA) {
if (npU->CurDMAMode && !npU->UltraDMAMode) {
if ((npU->InterfaceTiming == 0) && (Restrictions & TR_PIO0_WITH_DMA)) {
npU->InterfaceTiming = npU->CurDMAMode;
} else if (Restrictions & TR_PIO_EQ_DMA) {
if (npU->InterfaceTiming > npU->CurDMAMode)
npU->InterfaceTiming = npU->CurDMAMode;
}
} else {
if (MinUDMA > npU->UltraDMAMode) MinUDMA = npU->UltraDMAMode;
}
} else {
npU->CurDMAMode = npU->UltraDMAMode = 0;
}
if (MinIFTiming > npU->InterfaceTiming)
MinIFTiming = npU->InterfaceTiming;
TS("F:%lX,", npU->Flags)
}
npA->FlagsT &= ~ATBF_BM_DMA;
for (npU = npA->UnitCB, Unit = npA->cUnits; --Unit >= 0; npU++) {
if (Restrictions & TR_PIO_SHARED) npU->InterfaceTiming = MinIFTiming;
if ((npU->Flags & UCBF_BM_DMA) && npU->CurDMAMode && !npU->UltraDMAMode) {
npU->CurDMAMode = npU->InterfaceTiming;
if (!npU->CurDMAMode) npU->Flags &= ~UCBF_BM_DMA;
}
if (npU->InterfaceTiming == 0) {
npU->CurPIOMode = 0;
} else {
if (npU->CurPIOMode || !(Restrictions & TR_PIO0_WITH_DMA))
npU->CurPIOMode = npU->InterfaceTiming + 2;
}
if (npU->UltraDMAMode && (Restrictions & TR_UDMA_SHARED))
npU->UltraDMAMode = MinUDMA;
if (npU->UltraDMAMode >= ULTRADMAMODE_3) npA->Cap |= CHANREQ_ATA66;
if (npU->UltraDMAMode >= ULTRADMAMODE_5) npA->Cap |= CHANREQ_ATA100;
if (npU->UltraDMAMode >= ULTRADMAMODE_6) npA->Cap |= CHANREQ_ATA133;
if (npU->Flags & UCBF_BM_DMA) npA->FlagsT |= ATBF_BM_DMA;
}
#if TRACES
if (Debug & 2) {
TraceStr ("Cbl:%02X,Lvl:%X,Cap:%04X,", npA->FlagsT & ATBF_80WIRE, npA->PCIInfo.Level, npA->Cap);
}
#endif
CurPCIInfo = &npA->PCIInfo;
CurLevel = npA->PCIInfo.Level;
RegOffset = 0;
return 0;
}
/*+-----------------------------------------------------------------------+*
~L DOWN LOAD
*+-----------------------------------------------------------------------+*/
boolean DbmLoadObjHdr (tokentype *DbToken, numtype LocalObj,
ft F,lt Z,zz *Status, objheader **ObjHdr)
{
boolean TmpWriteHdr = WriteHdr;
boolean TmpSwapBug = SwapBug;
int TmpDeBug = DeBug;
vbntype MaxVbn = 0;
vbntype ObjHdrVbn = 0;
boolean Release = False;
dbheader *DbHdr = NullPtr;
statustype DumpStatus = Env_Normal;
if (!DbmBug)
WriteHdr = True;
SwapBug = SwapBug;
DeBug = DeBug;
DbmDbId = DbToken->DbId;
if (TmFetchCoreDb (DbToken, McStat, &DbHdr))
if (MemGetStackPtr (DbHdr->ObjVbnDir, McStat, &MaxVbn))
if (LocalObj >= MaxVbn)
if (sprintf (Msg, TraceStr(21),
/* " ***Error...ObjHdrNotExist for LocalObj=%3u MaxVbn=%u\n" */
LocalObj, MaxVbn))
if (TraceMsg (0, Msg))
{
MemDumpChunk (0, DbHdr->ObjVbnDir, Dump_Status);
*Status = Dbm_ObjHdrNotExist;
}
if (Normal(*Status))
if (MemGetVbn (DbHdr->ObjVbnDir, LocalObj, McStat, &ObjHdrVbn))
if (!ObjHdrVbn)
if (sprintf (Msg, TraceStr(22),
/* " ***Error...ObjHdrNotExist for LocalObj=%3u Vbn=%u\n" */
LocalObj, ObjHdrVbn))
if (TraceMsg (0, Msg))
{
if (DeBug)
MemDumpChunk (0, DbHdr->ObjVbnDir, Dump_Status);
*Status = Dbm_ObjHdrNotExist;
}
if (Normal(*Status))
if (DbHdr->BlkHdr.BlkFile)
{
#ifdef __DISPLAY_MESSAGE__
if (DeBug || DbmBug)
if (sprintf (Msg, TraceStr(23),
/* "\n LOAD OBJHDR[%2u] from FilePtr = %x\n" */
LocalObj, DbHdr->BlkHdr.BlkFile))
TraceMsg (0, Msg);
#endif /* __DISPLAY_MESSAGE__ */
} else {
*Status = File_NotFound;
#ifdef __DISPLAY_MESSAGE__
sprintf (Msg, TraceStr(24),
/* " DbmLoad CoreDb[%2u]::ObjHdr[%2u] has a NULL FilePtr" */
DbHdr->DbId, LocalObj);
SendMsg (0, Msg);
#endif /* __DISPLAY_MESSAGE__ */
}
/* Reserve space for ObjHeader */
if (Normal(*Status))
if (CoreMoreCore (sizeof(objheader), McStat, (addrtype *)ObjHdr))
if (FileInBlk ((addrtype *)ObjHdr, (bytessize )sizeof (objheader),
&DbHdr->BlkHdr, Release, McStat, &ObjHdrVbn))
if (DeBug || DbmBug)
if (sprintf (Msg, TraceStr(25),
/* " OBJ HDR restored from FileVbn[%3u]\n" */
ObjHdrVbn))
TraceMsg (0, Msg);
if (Normal(*Status))
{
(*ObjHdr)->ObjectLockDir = 0;
(*ObjHdr)->FieldNumMap = 0;
(*ObjHdr)->LocalAttrNumMap = 0;
(*ObjHdr)->FieldOffsetDir = 0;
(*ObjHdr)->ClassOffsetDir = 0;
(*ObjHdr)->FieldRefDir = 0;
(*ObjHdr)->FieldMapDir = 0;
(*ObjHdr)->FieldArrayDir = 0;
(*ObjHdr)->NoRegionsInCore = True;
if (FREEZE_GRP_PACKETS == True)
{
(*ObjHdr)->FreezeClass = 1;
(*ObjHdr)->DiskCache = False;
} else {
(*ObjHdr)->FreezeClass = 0;
(*ObjHdr)->DiskCache = True;
}
if ((*ObjHdr)->ObjNum == lSetNode_ObjNum
|| (*ObjHdr)->ObjNum == gSetNode_ObjNum)
(*ObjHdr)->FreezeClass = 1;
(*ObjHdr)->RegionChunkDir = 0;
(*ObjHdr)->RegionVbnDir = 0;
(*ObjHdr)->RegionSwapDir = 0;
(*ObjHdr)->RegionFreezeDir = 0;
(*ObjHdr)->TextChunk = 0;
(*ObjHdr)->ExObjectTbl = 0;
(*ObjHdr)->RgnStatusDir = 0;
}
if (Normal(*Status))
if (DbmFileInObjHdr (*ObjHdr, DbmDbId, &DbHdr->BlkHdr, Release, McStat))
if (MemPutAddr (DbHdr->ObjHdrDir, LocalObj,
*(addrtype *)ObjHdr, McStat))
if (DeBug)
MemDumpChunk (0, DbHdr->ObjHdrDir, Dump_Status);
#ifdef __DISPLAY_MESSAGE__
if (DeBug >= 0)
if (sprintf (Msg, TraceStr(26),
/* " CoreDb[%2u] ObjHdr[%2u] Loaded @ %x\n" */
DbToken->DbId, LocalObj, *ObjHdr))
TraceMsg (0, Msg);
#endif /* __DISPLAY_MESSAGE__ */
if (DbmBug)
if (*ObjHdr)
OaDumpObjHdr (0, DbToken, (*ObjHdr)->ObjNum, McStat);
SwapBug = TmpSwapBug;
DeBug = TmpDeBug;
WriteHdr = TmpWriteHdr;
/* ... Done by calling procedure after return from here ...
if (Normal(*Status))
OmChkImage (DbToken, (*ObjHdr)->ObjNum, McStat);
*/
TRACK(TrackBak,"DbmLoadObjHdr\n");
return(STAT);
}
boolean Mem_MoveChunk (numtype ChunkNum, ft F,lt Z,zz *Status,
addrtype *FreeAddr, sizeinbytes *FreeSize)
{
addrtype Source = NullPtr;
addrtype SourceRegion = NullPtr;
sizeinbytes SourceSize = 0;
addrtype TargetRegion = NullPtr;
addrtype *ChunkAddrPtr = NullPtr;
*FreeAddr = NullPtr;
*FreeSize = 0;
if (DbmBug)
if (TraceMsg (0, " BEFORE move :: "))
Mem_DumpChunkChunk (0, ChunkNum);
SourceRegion = Chunk_Addr (ChunkNum);
SourceRegion = (addrtype )((char *)SourceRegion - sizeof (chunkstruc));
Source = SourceRegion;
SourceSize = Unit_Size (ChunkNum) * Unit_Count (ChunkNum);
SourceSize += sizeof (chunkstruc);
if (Normal(*Status))
{
/* This is a Normal Chunk Expansion */
if (NewRegion (SourceSize, McStat, (addrtype *)&ChunkAddrPtr))
{
TargetRegion = ChunkAddrPtr;
if (DbmBug || MemBug)
{
sprintf (Msg, TraceStr(41),
/* " Copy from Source(* %8u) @%x TO Target @%x\n" */
SourceSize, SourceRegion, TargetRegion);
TraceMsg (0, Msg);
}
memcpy ((char *)ChunkAddrPtr, (char *)SourceRegion, SourceSize);
/* Adjust for the chunkstruc Header Block */
TargetRegion = (addrtype )((char *)TargetRegion
+ sizeof (chunkstruc));
ChunkAddrPtr = (addrtype *)TargetRegion;
/* Set the Chunk Stats on the New Chunk */
Chunk_Addr(ChunkNum) = TargetRegion;
if (DbmBug)
if (TraceMsg (0, " AFTER move :: "))
Mem_DumpChunkChunk (0, ChunkNum);
}
*FreeAddr = Source;
*FreeSize = SourceSize;
if (DbmBug)
{
sprintf (Msg,
" Mem_MoveChunk [%6u] :: TO Target @%8x; Size :=%6u, From @%8x.\n",
ChunkNum, TargetRegion, SourceSize, SourceRegion);
TraceMsg (0, Msg);
}
}
TRACK(TrackBak,"Mem_MoveChunk\n");
return(STAT);
}
/*+-----------------------------------------------------------------------+*/
boolean DbmFileInObjHdr (objheader *ObjHdr, idtype DbId,
blkhdrtype *BlkHdr, boolean Release,
ft F,lt Z,zz *Status )
{
struchdr *StrucHdr = NullPtr;
DbmFileInGrpHdr ((grpheader *)ObjHdr, DbId,
BlkHdr, Release, McStat);
if (DbId == RenvId)
ObjHdr->FreezeClass = 1;
if (Normal(*Status))
if (ObjHdr->ObjectLockDirVbn)
if (FileInChunk (&ObjHdr->ObjectLockDir, BlkHdr, Release,
McStat, &ObjHdr->ObjectLockDirVbn))
if (DeBug || DbmBug) {
sprintf (Msg, TraceStr(53),
/* " Obj ObjectLockDir : Chunk[%4u] AT Vbn[%3u]\n" */
ObjHdr->ObjectLockDir,ObjHdr->ObjectLockDirVbn);
TraceMsg (0, Msg);
}
if (Normal(*Status))
if (FileInChunk (&ObjHdr->FieldNumMap, BlkHdr, Release,
McStat, &ObjHdr->FieldNumMapVbn))
if (DeBug || DbmBug) {
sprintf (Msg, TraceStr(32),
/* " Obj FieldNumMap : Chunk[%4u] AT Vbn[%3u]\n" */
ObjHdr->FieldNumMap, ObjHdr->FieldNumMapVbn);
TraceMsg (0, Msg);
}
if (Normal(*Status))
if (FileInChunk (&ObjHdr->LocalAttrNumMap, BlkHdr, Release,
McStat, &ObjHdr->LocalAttrNumMapVbn))
if (DeBug || DbmBug) {
sprintf (Msg, TraceStr(33),
/* " Obj LocalAttrNumMap : Chunk[%4u] AT Vbn[%3u]\n" */
ObjHdr->LocalAttrNumMap, ObjHdr->LocalAttrNumMapVbn);
TraceMsg (0, Msg);
}
if (Normal(*Status))
if (FileInChunk (&ObjHdr->FieldOffsetDir, BlkHdr, Release,
McStat, &ObjHdr->FieldOffsetDirVbn))
if (DeBug || DbmBug) {
sprintf (Msg, TraceStr(34),
/* " Obj FieldOffsetDir : Chunk[%4u] AT Vbn[%3u]\n" */
ObjHdr->FieldOffsetDir, ObjHdr->FieldOffsetDirVbn);
TraceMsg (0, Msg);
}
if (Normal(*Status))
if (FileInChunk (&ObjHdr->ClassOffsetDir, BlkHdr, Release,
McStat, &ObjHdr->ClassOffsetDirVbn))
if (DeBug || DbmBug) {
sprintf (Msg, TraceStr(35),
/* " Obj ClassOffsetDir : Chunk[%4u] AT Vbn[%3u]\n" */
ObjHdr->ClassOffsetDir, ObjHdr->ClassOffsetDirVbn);
TraceMsg (0, Msg);
}
if (Normal(*Status))
if (FileInChunk (&ObjHdr->FieldRefDir, BlkHdr, Release,
McStat, &ObjHdr->FieldRefDirVbn))
if (DeBug || DbmBug) {
sprintf (Msg, TraceStr(36),
/* " Obj FieldRefDir : Chunk[%4u] AT Vbn[%3u]\n" */
ObjHdr->FieldRefDir, ObjHdr->FieldRefDirVbn);
TraceMsg (0, Msg);
}
if (Normal(*Status))
if (ObjHdr->FieldMapCount)
if (FileInChunk (&ObjHdr->FieldMapDir, BlkHdr, Release,
McStat, &ObjHdr->FieldMapDirVbn))
if (DeBug || DbmBug) {
sprintf (Msg, TraceStr(37),
/* " Obj FieldMapDir : Chunk[%4u] AT Vbn[%3u]\n" */
ObjHdr->FieldMapDir, ObjHdr->FieldMapDirVbn);
TraceMsg (0, Msg);
}
if (Normal(*Status))
if (ObjHdr->FieldArrayCount)
if (FileInChunk (&ObjHdr->FieldArrayDir, BlkHdr, Release,
McStat, &ObjHdr->FieldArrayDirVbn))
if (DeBug || DbmBug) {
sprintf (Msg, TraceStr(38),
/* " Obj FieldArrayDir : Chunk[%4u] AT Vbn[%3u]\n" */
ObjHdr->FieldArrayDir, ObjHdr->FieldArrayDirVbn);
TraceMsg (0, Msg);
}
if (Normal(*Status))
if (ObjHdr->TextChunkVbn)
if (FileInChunk (&ObjHdr->TextChunk, BlkHdr, Release,
McStat, &ObjHdr->TextChunkVbn))
if (MemGetChunkAddr (ObjHdr->TextChunk, McStat, (addrtype *)&StrucHdr))
{
if (StrucHdr->TextVbn)
FileInChunk (&StrucHdr->TextChunk, BlkHdr, Release,
McStat, &StrucHdr->TextVbn);
if (DeBug || DbmBug)
{
sprintf (Msg, TraceStr(38),
/* " Obj TextChunk : Chunk[%4u] AT Vbn[%3u]\n" */
ObjHdr->TextChunk, ObjHdr->TextChunkVbn);
TraceMsg (0, Msg);
}
}
TRACK(TrackBak,"DbmFileInObjHdr\n");
return(STAT);
}
void CoreShowStats (void)
{
statustype ShellStatus = Env_Normal;
TraceMsg (MSGFILE, "\n Memory Manager Statistics::\n\n");
sprintf (Msg, TraceStr(67),
/* " Void Allocated :: %lu\n" */
VoidAllocated);
TraceMsg (MSGFILE, Msg);
sprintf (Msg, TraceStr(68),
/* " Void De Allocated :: %lu\n" */
VoidDeAllocated);
TraceMsg (MSGFILE, Msg);
sprintf (Msg, TraceStr(69),
/* " Void CurrentSize :: %lu\n" */
VoidUsed);
TraceMsg (MSGFILE, Msg);
sprintf (Msg, " Void MAX Alloc'd (at any point in Run) :: %8lu\n\n", VoidMaxUsed);
TraceMsg (MSGFILE, Msg);
sprintf (Msg, TraceStr(70),
/* " Blks Allocated :: %lu\n" */
VoidBlksAllocated);
TraceMsg (MSGFILE, Msg);
sprintf (Msg, TraceStr(71),
/* " Blks De Allocated :: %lu\n\n" */
VoidBlksDeAllocated);
TraceMsg (MSGFILE, Msg);
sprintf (Msg, TraceStr(72),
/* " Regions Allocated :: %u\n" */
Num1Regions);
TraceMsg (MSGFILE, Msg);
sprintf (Msg, TraceStr(73),
/* " Core Used :: %lu\n" */
Core1Size);
TraceMsg (MSGFILE, Msg);
sprintf (Msg, TraceStr(74),
/* " Core Freeed :: %lu\n" */
Core1Freeed);
TraceMsg (MSGFILE, Msg);
sprintf (Msg, TraceStr(75),
/* " Core Reclaimed :: %lu\n\n" */
Core1Reclaimed);
TraceMsg (MSGFILE, Msg);
sprintf (Msg, " Core Current Size :: %8lu\n\n",Core1Used);
TraceMsg (MSGFILE, Msg);
sprintf (Msg, TraceStr(76),
/* " CoreBlks Requested :: %lu\n" */
CoreBlksRequested);
TraceMsg (MSGFILE, Msg);
sprintf (Msg, TraceStr(77),
/* " CoreBlks Freeed :: %lu\n\n" */
CoreBlksFreeed);
TraceMsg (MSGFILE, Msg);
sprintf (Msg, TraceStr(78),
/* " CoreBlks Reclaimed :: %lu\n" */
CoreBlksReclaimed);
TraceMsg (MSGFILE, Msg);
sprintf (Msg, TraceStr(79),
/* " By Exact Size :: %lu\n" */
CoreBlksExactReclaimed);
TraceMsg (MSGFILE, Msg);
sprintf (Msg, TraceStr(80),
/* " By Gaps :: %lu\n" */
CoreBlksGapReclaimed);
TraceMsg (MSGFILE, Msg);
sprintf (Msg, TraceStr(81),
/* " By Page Space :: %lu\n\n" */
CoreBlksPageSpaceReclaimed);
TraceMsg (MSGFILE, Msg);
if (ClassBug || CoreBug)
if (KrnlFreeAddrChunk)
{
TraceMsg (MSGFILE, " Dump of KrnlFreeAddrChunk :: ");
Mem_DumpChunkPart (MSGFILE, KrnlFreeAddrChunk, 0, 100, ShellMcStat);
TraceMsg (MSGFILE, "\n Dump of KrnlFreeSizeChunk :: ");
Mem_DumpChunkPart (MSGFILE, KrnlFreeSizeChunk, 0, 100, ShellMcStat);
TraceMsg (MSGFILE, "\n");
}
return;
}
/*+-----------------------------------------------------------------------+*/
boolean DbmPairRgnObjects (dbheader *CoreDb, objheader *ObjHdr,
numtype CurrRgnChunk, ft F,lt Z,zz *Status)
{
indextype Index = 0;
indextype Offset = 0;
indextype Objects = 0;
byte *RegionAddr = NullPtr;
handletype *HandlePtr = NullPtr;
addrtype ObjectAddr = NullPtr;
int TempDeBug = DeBug;
booleantype TempMemBug = MemBug;
numtype MemLoc = 0;
if (!PairObjects)
{
TRACK(TrackBak,"DbmPairRgnObjects\n");
return (STAT);
}
if (MemGetChunkAddr (CurrRgnChunk, McStat, (addrtype *)&RegionAddr))
MemGetStackPtr (CurrRgnChunk, McStat, &Objects);
if (!RegionAddr || !Objects)
{
*Status = Odbm_BadSwapChunks;
sprintf (Msg, TraceStr(41),
/* " BAD PAIR Handles for RegionChunk[%3u] @%x count %4u\n" */
CurrRgnChunk, RegionAddr, Objects);
TraceMsg (0, Msg);
}
if (SWAP)
{
DeBug = 0;
MemBug = False;
while (Normal(*Status)
&& Index < Objects)
{
Offset = (ObjHdr->ObjSize * Index) + ObjHdr->HandleOffset;
ObjectAddr = (addrtype )(RegionAddr + (ObjHdr->ObjSize * Index));
HandlePtr = (handletype *)(RegionAddr + Offset);
if (*HandlePtr == 1
&& ObjHdr->ObjectCount != 1)
{
sprintf (Msg,
" DbmPairRgnObjects:: RegionChunk[%3u] Index = %2u; Handle=%4u\n",
CurrRgnChunk, Index, *HandlePtr);
TraceMsg (0, Msg);
TraceMsg (0,
" ***ERROR... Should not be equal 1, as is NOT a Primal!\n");
*Status = Dbm_BadHandleInRegion;
}
if (*HandlePtr)
{
if (HmGetObjectMemLoc (CoreDb, *HandlePtr, McStat, &MemLoc))
if (MemLoc == 0)
HmPutObjectAddr (CoreDb, *HandlePtr, ObjectAddr, McStat);
if (!Normal(*Status))
if (sprintf (Msg,
TraceStr(45),
/* " Region[%3u] Object[%3u] Handle= %4u\n" */
CurrRgnChunk, Index, *HandlePtr))
TraceMsg (0, Msg);
}
++Index;
}
MemBug = TempMemBug;
DeBug = TempDeBug;
}
TRACK(TrackBak,"DbmPairRgnObjects\n");
return (STAT);
}
farlongtype SysFarCoreLeft (void)
{
indextype CoreBlks = 0;
addrtype CoreAddr[20];
counttype i = 0;
farlongtype AllocAmount = Core_PageSize;
static
sizetype SizeOfInt = sizeof(int);
if (FirstTry == False
|| FirstTry == True)
return (1024000L);
if (FirstTry == True)
{
FirstTry = False;
if (SizeOfInt <= 2)
return (1024000L);
while ((CoreAddr[i] = (addrtype )GET_MEM (1, AllocAmount)) != NULL)
{
Alloc_Amount += AllocAmount;
sprintf (Msg, TraceStr(7),
/* " Allocated %6u bytes @%x\n" */
AllocAmount, CoreAddr[i]);
SendMsg (0, Msg);
++i;
}
AllocAmount -= 100;
while ( (AllocAmount &&
(CoreAddr[i] = (addrtype )GET_MEM (1, AllocAmount)) == NULL))
{
AllocAmount -= 100;
}
if (CoreAddr[i])
{
Alloc_Amount += AllocAmount;
sprintf (Msg, TraceStr(8),
/* " Allocated %6u bytes @%x\n" */
AllocAmount, CoreAddr[i]);
SendMsg (0, Msg);
} else
--i;
if (Alloc_Amount)
{
CoreBlks = i;
while (i >= 0)
{
sprintf (Msg, TraceStr(9),
/* " De Allocate block[%2u] @ %x\n" */
i, CoreAddr[i]);
SendMsg (0, Msg);
FREE_MEM (CoreAddr[i]);
i--;
}
CoreFreeStoreSize = (Core_PageSize * CoreBlks) + AllocAmount;
sprintf (Msg, TraceStr(10),
/* " *** INFO *** Far Core Available = %lu\n" */
CoreFreeStoreSize);
SendMsg (0, Msg);
} else
SendMsg (0, " *** CORE *** CoreNoMore\n");
}
return (CoreFreeStoreSize);
}
void VoidFreeCore (addrtype *CoreAddr, farlongtype SizeInBytes)
{
farlongtype FarSize = 0;
sizetype ByteAlignment = 0;
addrtype EndCoreBlkAddr = NullPtr;
lt64 *LongPtr = NullPtr;
VoidStatus = Env_Normal;
#ifdef __BCC__
sprintf (Msg, /* TraceStr[6] */
" VOID FreeCore:: Void Range (* %-8lu) @ %8x :: %8x\n",
SizeInBytes, *CoreAddr,
(addrtype )(*(farlongtype **)CoreAddr + SizeInBytes));
TraceMsg (0, Msg);
#else
if (CoreBug)
if (sprintf (Msg, TraceStr(6),
/* " VOID FreeCore:: Void Range (* %-8lu) @ %8x :: %8x\n" */
SizeInBytes, *CoreAddr,
(addrtype )(*(farlongtype **)CoreAddr + SizeInBytes)))
TraceMsg (0, Msg);
#endif
if (*CoreAddr)
{
#ifdef CORE_CRC_CHECK
FarSize = SizeInBytes + CORE_BLOCK_ALIGN + 4;
if (FarSize % CoreBlk_GapSpace)
{
ByteAlignment = CoreBlk_GapSpace - (FarSize % CoreBlk_GapSpace);
FarSize += ByteAlignment;
}
*CoreAddr = (addrtype )((char *)*CoreAddr - CORE_BLOCK_ALIGN);
LongPtr = *(numtype **)CoreAddr;
EndCoreBlkAddr = (addrtype )((char *)*CoreAddr + (FarSize - 4));
if (*(numtype *)LongPtr != CORE_CONSTANT)
{
SendMsg (0, "\n ***ERROR... in Management of VOID\n");
SendMsg (0, " FIRST 4 bytes in VOID Block OVER-WRITEN !\n");
sprintf (Msg, " VOID address := @%8x\n", *CoreAddr);
TraceMsg (0, Msg);
VoidStatus = Core_CRCoverWritten;
} else if (*(numtype *)EndCoreBlkAddr != CORE_CONSTANT) {
SendMsg (0, "\n ***ERROR... in Management of VOID\n");
SendMsg (0, " LAST 4 bytes in VOID Block OVER-WRITEN !\n");
sprintf (Msg, " VOID address := @%8x\n", *CoreAddr);
TraceMsg (0, Msg);
VoidStatus = Core_CRCoverWritten;
}
#else
FarSize = SizeInBytes;
if (FarSize % CoreBlk_GapSpace)
{
ByteAlignment = CoreBlk_GapSpace - (FarSize % CoreBlk_GapSpace);
FarSize += ByteAlignment;
}
#endif /* CORE_CRC_CHECK */
VoidDeAllocated += FarSize;
VoidUsed -= FarSize;
FREE_MEM (*(void **)CoreAddr);
} else {
sprintf (Msg, "***ERROR... Core Address <%8x> Below Void <%8x>\n",
*CoreAddr, VoidLowestAddr);
TraceMsg (0, Msg);
VoidStatus = Core_NULLCoreAddrOfFree;
}
*CoreAddr = NullPtr;
VoidBlksDeAllocated++;
if ( DeBug )
{
sprintf(Msg, "Free VOID [%6u] := %8lu bytes; VoidUsed := %8lu\n",
VoidBlksDeAllocated , SizeInBytes, VoidUsed);
TraceMsg (0, Msg);
}
StackTrack ("VoidFreeCore\n");
return;
}
addrtype VoidExtendCore (farlongtype *SizeInBytes)
{
lt64 *LongPtr = NullPtr;
addrtype CoreAddr = NullPtr;
addrtype EndCoreBlkAddr = NullPtr;
sizetype ByteAlignment = 0;
farlongtype FarSize = 0;
static
boolean FirstTime = False;
static
boolean FirstLimit = True;
VoidStatus = Env_Normal;
#ifdef __BCC__
sprintf (Msg, " Extend VOID [%6u] %8lu bytes; New Void =%8lu\n",
VoidBlksAllocated + 1, *SizeInBytes, VoidUsed);
TraceMsg (0, Msg);
#endif
#ifdef CORE_LIMIT
if (*SizeInBytes > CORE_LIMIT)
{
sprintf (Msg, TraceStr(0),
/* " Alloc from the VOID %8lu bytes;\n" */
*SizeInBytes);
TraceMsg (0, Msg);
return (CoreAddr);
}
#endif
#ifdef OLDWAY
if (*SizeInBytes % CoreBlk_GapSpace)
{
ByteAlignment = CoreBlk_GapSpace - (*SizeInBytes % CoreBlk_GapSpace);
*SizeInBytes += ByteAlignment;
}
#else
#ifdef CORE_CRC_CHECK
FarSize = *SizeInBytes + CORE_BLOCK_ALIGN + 4;
if (FarSize % CoreBlk_GapSpace)
{
ByteAlignment = CoreBlk_GapSpace - (FarSize % CoreBlk_GapSpace);
FarSize += ByteAlignment;
}
#else
FarSize = *SizeInBytes;
if (FarSize % CoreBlk_GapSpace)
{
ByteAlignment = CoreBlk_GapSpace - (FarSize % CoreBlk_GapSpace);
FarSize += ByteAlignment;
}
#endif /* CORE_CRC_CHECK */
#endif /* OLDWAY */
if ((FarSize + VoidUsed) > VOID_BOUNDARY)
{
if (FirstLimit)
SendMsg (0, "\n *** WARNING *** VOID_BOUNDARY EXCEEDED!!!\n");
else
SendMsg (0, "\n *** ERROR *** VOID_BOUNDARY EXCEEDED!!!\n");
sprintf (Msg, " BOUNDARY := %8d; RESERVE := %8d;\n",
VOID_BOUNDARY, VOID_RESERVE);
SendMsg (0, Msg);
if (FirstLimit)
VOID_BOUNDARY += VOID_RESERVE;
FirstLimit = False;
return (NullPtr);
}
if ((LongPtr = (lt64 *)GET_MEM (1, FarSize)) == NULL)
{
if (!FirstTry)
{
return (NullPtr);
} else {
FirstTry = False;
do
{
*SizeInBytes = *SizeInBytes - 256;
LongPtr = (lt64 *)GET_MEM (1, *SizeInBytes);
} while (*SizeInBytes >= 256 && LongPtr == NULL);
if (LongPtr)
if (sprintf (Msg, TraceStr(1),
/* " *** WARNING ... Partial Core Page = %lu\n" */
*SizeInBytes))
SendMsg (0, Msg);
}
}
if (! CoreFreeStoreSize && FirstTry)
SysFarCoreLeft();
else
CoreFreeStoreSize -= FarSize;
#ifdef CORE_CRC_CHECK
memset ((addrtype )LongPtr, 0x55, 4);
EndCoreBlkAddr = (addrtype )((char *)LongPtr + (FarSize - 4));
memset (EndCoreBlkAddr, 0x55, 4);
CoreAddr = (addrtype )((char *)LongPtr + CORE_BLOCK_ALIGN);
#else
CoreAddr = (addrtype )LongPtr;
#endif /* CORE_CRC_CHECK */
VoidAllocated += FarSize;
VoidUsed += FarSize;
if (VoidUsed > VoidMaxUsed)
VoidMaxUsed = VoidUsed;
VoidBlksAllocated++;
if (FirstTime)
{
VoidLowestAddr = CoreAddr;
FirstTime = False;
} else if (CoreAddr < VoidLowestAddr) {
VoidLowestAddr = CoreAddr;
}
if (StrucAlignment)
{
if ((farlongtype )CoreAddr % StrucAlignment)
{
sprintf (Msg, TraceStr(4),
/* " CoreMoreCore... Non Aligned Address= %8x\n" */
LongPtr);
TraceMsg (0, Msg);
sprintf (Msg, TraceStr(5),
/* " Core1Size = %8lu\n" */
Core1Size);
SendMsg (0, Msg);
VoidStatus = Core_NotInAlignment;
}
}
if ( DeBug )
{
sprintf(Msg, "Extend VOID [%6u] := %8lu bytes; VoidUsed := %8lu\n",
VoidBlksAllocated , *SizeInBytes, VoidUsed);
TraceMsg (0, Msg);
}
return (CoreAddr);
}
/* 12.0.3 */
boolean GrpNewObject (dbheader *CoreDb, objheader *ObjHdr,
ft F,lt Z,zz *Status, indextype *Index,
numtype *RgnIndex, addrtype *RgnAddr)
{
numtype Chunk = 0;
addrtype ChunkAddr = NullPtr;
indextype LocalIndex = 0;
boolean ExObject = False;
numtype BuffIndex = 0;
if (ObjHdr->EnvObjType > That_AttrNum)
if (sprintf (Msg, TraceStr(0),
/* " ObjHdr[%3u:%3u] Not set as ObjectType.\n" */
CoreDb->DbId, ObjHdr->ObjNum))
if (SendMsg (0, Msg))
ObjHdr->EnvObjType = 0;
if (ObjHdr->ExObjectCount)
{
ExObject = True;
if (MemPopIndex (ObjHdr->ExObjectTbl,
McStat, Index, &ObjHdr->ExObjectCount))
if (*Index < ObjHdr->BaseIndex)
{
*RgnIndex = 0;
Chunk = ObjHdr->BaseRegion;
MemGetChunkAddr (Chunk, McStat, &ChunkAddr);
} else {
*RgnIndex = (*Index - ObjHdr->BaseIndex) / ObjHdr->RegionObjects;
if (ObjHdr->BaseIndex)
++*RgnIndex;
GrpGetRegion (CoreDb, (grpheader *)ObjHdr, *RgnIndex,
McStat, &Chunk, &ChunkAddr);
}
/* ObjHdr->ExObjectCount--;
*/
} else if (ObjHdr->ObjectCount < ObjHdr->BaseIndex) {
*Index = ObjHdr->ObjectCount++;
*RgnIndex = 0;
if (*Index == 0)
{
GrpNewRegion (CoreDb, (grpheader *)ObjHdr, *Index, *RgnIndex,
McStat, &Chunk, &ChunkAddr);
ObjHdr->BaseRegion = Chunk;
} else {
Chunk = ObjHdr->BaseRegion;
MemGetChunkAddr (Chunk, McStat, &ChunkAddr);
}
} else {
*Index = ObjHdr->ObjectCount++;
*RgnIndex = (*Index - ObjHdr->BaseIndex) / ObjHdr->RegionObjects;
if (ObjHdr->BaseIndex)
++*RgnIndex;
LocalIndex = (*Index - ObjHdr->BaseIndex) % ObjHdr->RegionObjects;
if (LocalIndex == 0)
{
GrpNewRegion (CoreDb, (grpheader *)ObjHdr,
*Index, *RgnIndex,
McStat, &Chunk, &ChunkAddr);
} else {
if (MemGetChunkNum (ObjHdr->RegionChunkDir, *RgnIndex,
McStat, &Chunk))
if (Chunk != 0)
MemGetChunkAddr (Chunk, McStat, &ChunkAddr);
if (Chunk == 0
|| ChunkAddr == NullPtr)
GrpGetRegion (CoreDb, (grpheader *)ObjHdr, *RgnIndex,
McStat, &Chunk, &ChunkAddr);
if (Normal(*Status))
{
BuffIndex = ObjHdr->RgnBuffNums[*RgnIndex];
ObjHdr->RgnBuffNodes[BuffIndex] = 1;
}
}
}
/* Allocate space for Entry: Bytes in Region Chunk Space */
if (Normal(*Status))
if (*RgnIndex)
LocalIndex = (*Index - ObjHdr->BaseIndex) % ObjHdr->RegionObjects;
else
LocalIndex = *Index;
if (Normal(*Status))
if (!ExObject)
MemPutStackPtr (Chunk, LocalIndex+1, McStat);
if (Normal(*Status))
if (MemPutBit (ObjHdr->DirtyRegionDir, *RgnIndex, 1, McStat))
*RgnAddr = ChunkAddr;
if (DbmBug)
MemBug = False;
if (!Normal(*Status) || DeBug || GrpBug || DbmBug)
if (sprintf (Msg, TraceStr(3),
/* " GrpNewObject[%4u] (%4u) Rgn=%3u RgnChunk= %3u @ %x\n" */
*Index, LocalIndex, *RgnIndex, Chunk, *RgnAddr))
TraceMsg (0, Msg);
TRACK(TrackBak,"GrpNewObject\n");
return(STAT);
}
boolean FileInBlk (addrtype *BlkAddr, bytessize BlkSize,
blkhdrtype *BlkHdr, boolean Release,
ft F,lt Z,zz *Status, vbntype *VbnBlk)
{
bytessize UnitSize = BlkSize;
indextype UnitCount = (indextype )1;
lt64 FileOffset = 0;
indextype VbnBlkIndex = 0;
blktkntype BlkTkn;
int FileRead = 0;
/* This is a ChunkRef Chunk || a ObjHdr || a File Block */
if (*BlkAddr == NullPtr)
CoreMoreCore (BlkSize, McStat, BlkAddr);
if (Normal(*Status))
if (MemGetIndex (BlkHdr->BlkDirChunk, *VbnBlk,
McStat, &VbnBlkIndex))
MemGetSomeBytes (BlkHdr->BlkTknChunk, VbnBlkIndex,
sizeof (blktkntype),
McStat, (addrtype )&BlkTkn);
if (Normal(*Status))
{
FileOffset = BlkTkn.Offset;
if (FileOffset <= 0)
{
sprintf (Msg, TraceStr(35),
/* " *** ZERO File Offset for Vbn = %6u; BlkIndex= %6u;\n" */
*VbnBlk, VbnBlkIndex);
TraceMsg (0, Msg);
}
}
/* Copy from File space to CoreSpace */
if (Normal(*Status))
{
fseek (BlkHdr->BlkFile, FileOffset, SEEK_SET);
FileRead = fread (*BlkAddr, (unsigned )UnitSize,
(unsigned )UnitCount, BlkHdr->BlkFile);
if (FileRead != (int )UnitCount)
{
sprintf (Msg, TraceStr(38),
/* " FILE read ERROR # Vbn[%3u]\n" */
*VbnBlk);
TraceMsg (0, Msg);
perror(" Error Msg ");
*Status = File_BadDiskRead;
}
LastFileOffset = FileOffset + UnitCount;
}
if (Normal(*Status))
if (Release)
MemFreeFileBlk (BlkHdr, McStat, VbnBlk);
TRACK(TrackBak,"FileInBlk\n");
return(STAT);
}
