long Ext2InitPartition(CICell ih)
{
long cnt, gdPerBlock;
if (ih == gCurrentIH) return 0;
printf("Ext2InitPartition: %x\n", ih);
gCurrentIH = 0;
// Read for the Super Block.
Seek(ih, SBOFF);
Read(ih, (long)gFSBuf, SBSIZE);
gFS = (struct m_ext2fs *)gFSBuf;
e2fs_sb_bswap(&gFS->e2fs, &gFS->e2fs);
if (gFS->e2fs.e2fs_magic != E2FS_MAGIC) return -1;
// Calculate the block size and set up the block cache.
gBlockSize = 1024 << gFS->e2fs.e2fs_log_bsize;
if (gBlockSizeOld <= gBlockSize) {
gTempBlock = AllocateBootXMemory(gBlockSize);
}
CacheInit(ih, gBlockSize);
gBlockSizeOld = gBlockSize;
gCurrentIH = ih;
gdPerBlock = gBlockSize / sizeof(struct ext2_gd);
// Fill in the in memory super block fields.
gFS->e2fs_bsize = 1024 << gFS->e2fs.e2fs_log_bsize;
gFS->e2fs_bshift = LOG_MINBSIZE + gFS->e2fs.e2fs_log_bsize;
gFS->e2fs_qbmask = gFS->e2fs_bsize - 1;
gFS->e2fs_bmask = ~gFS->e2fs_qbmask;
gFS->e2fs_fsbtodb = gFS->e2fs.e2fs_log_bsize + 1;
gFS->e2fs_ncg = HowMany(gFS->e2fs.e2fs_bcount - gFS->e2fs.e2fs_first_dblock,
gFS->e2fs.e2fs_bpg);
gFS->e2fs_ngdb = HowMany(gFS->e2fs_ncg, gdPerBlock);
gFS->e2fs_ipb = gFS->e2fs_bsize / EXT2_DINODE_SIZE;
gFS->e2fs_itpg = gFS->e2fs.e2fs_ipg / gFS->e2fs_ipb;
gFS->e2fs_gd = AllocateBootXMemory(gFS->e2fs_ngdb * gFS->e2fs_bsize);
// Read the summary information from disk.
for (cnt = 0; cnt < gFS->e2fs_ngdb; cnt++) {
ReadBlock(((gBlockSize > 1024) ? 0 : 1) + cnt + 1, 0, gBlockSize,
(char *)&gFS->e2fs_gd[gdPerBlock * cnt], 0);
e2fs_cg_bswap(&gFS->e2fs_gd[gdPerBlock * cnt],
&gFS->e2fs_gd[gdPerBlock * cnt], gBlockSize);
}
// Read the Root Inode
ReadInode(EXT2_ROOTINO, &gRootInode, 0, 0);
return 0;
}
static char *
NewSymbol( char * string )
{
static SymbolPtr lastGuy = 0;
SymbolPtr symbol;
// Look for string in the list of symbols.
symbol = FindSymbol(string, 0);
// Add the new symbol.
if (symbol == 0)
{
#if USEMALLOC
symbol = (SymbolPtr)malloc(sizeof(Symbol) + 1 + strlen(string));
#else
symbol = (SymbolPtr)AllocateBootXMemory(sizeof(Symbol) + 1 + strlen(string));
#endif
if (symbol == 0) //return 0;
stop("NULL symbol!");
// Set the symbol's data.
symbol->refCount = 0;
strcpy(symbol->string, string);
// Add the symbol to the list.
symbol->next = gSymbolsHead;
gSymbolsHead = symbol;
}
// Update the refCount and return the string.
symbol->refCount++;
if (lastGuy && lastGuy->next != 0) stop("last guy not last!");
return symbol->string;
}
static TagPtr
NewTag( void )
{
long cnt;
TagPtr tag;
if (gTagsFree == 0)
{
#if USEMALLOC
tag = (TagPtr)malloc(kTagsPerBlock * sizeof(Tag));
#else
tag = (TagPtr)AllocateBootXMemory(kTagsPerBlock * sizeof(Tag));
#endif
if (tag == 0) return 0;
// Initalize the new tags.
for (cnt = 0; cnt < kTagsPerBlock; cnt++)
{
tag[cnt].type = kTagTypeNone;
tag[cnt].string = 0;
tag[cnt].tag = 0;
tag[cnt].tagNext = tag + cnt + 1;
}
tag[kTagsPerBlock - 1].tagNext = 0;
gTagsFree = tag;
}
tag = gTagsFree;
gTagsFree = tag->tagNext;
return tag;
}
static char *NewSymbol(char *string)
{
SymbolPtr symbol;
// Look for string in the list of symbols.
symbol = FindSymbol(string, 0);
// Add the new symbol.
if (symbol == 0) {
symbol = AllocateBootXMemory(sizeof(Symbol) + strlen(string));
if (symbol == 0) return 0;
// Set the symbol's data.
symbol->refCount = 0;
strcpy(symbol->string, string);
// Add the symbol to the list.
symbol->next = gSymbolsHead;
gSymbolsHead = symbol;
}
// Update the refCount and return the string.
symbol->refCount++;
return symbol->string;
}
CICell NetInitPartition(char *devSpec)
{
NetPartInfoPtr net;
net = (NetPartInfoPtr)AllocateBootXMemory(sizeof(NetPartInfo));
if (net == 0) return 0;
strcpy(net->devSpec, devSpec);
return (CICell)net;
}
long UFSInitPartition(CICell ih)
{
if (ih == gCurrentIH) return 0;
printf("UFSInitPartition: %x\n", ih);
gCurrentIH = 0;
// Assume there is no Disk Label
gPartitionBase = 0;
// Look for the Super Block
Seek(ih, gPartitionBase + SBOFF);
Read(ih, (long)gFSBuf, SBSIZE);
gFS = (struct fs *)gFSBuf;
if (gFS->fs_magic != FS_MAGIC) {
return -1;
}
// Calculate the block size and set up the block cache.
gBlockSize = gFS->fs_bsize;
gFragSize = gFS->fs_fsize;
gFragsPerBlock = gBlockSize / gFragSize;
if (gBlockSizeOld <= gBlockSize) {
gTempBlock = AllocateBootXMemory(gBlockSize);
}
CacheInit(ih, gBlockSize);
gBlockSizeOld = gBlockSize;
gCurrentIH = ih;
// Read the Root Inode
ReadInode(ROOTINO, &gRootInode, 0, 0);
return 0;
}