void xHeap::DumpUsage(const char * filename) { FILE * f = fopen(filename, "wt"); if(!f) return; uint32 freeSize = 0x7fffffff; WriteStats(f, freeSize); #ifndef USE_APP_HEAP_SAVING_MODE WriteFreeBlockHeader(f, freeSize); WriteFreeBlocks(f, freeSize); #endif // USE_APP_HEAP_SAVING_MODE #ifdef DEBUG_APP_HEAP WriteSmallBlockHeader(f, freeSize); WriteSmallBlocks(f, freeSize); #endif #ifndef USE_APP_HEAP_SAVING_MODE WriteBlockHeader(f, 1, freeSize); WriteBlocks(f, &dummyBlock, freeSize); #endif // USE_APP_HEAP_SAVING_MODE WriteBlockHeader(f, 2, freeSize); WriteBlocks(f, &dummyLargeBlock, freeSize); fclose(f); }
int FatWriteBootRecord (struct FatSB *fsb) { uint8 temp_sector[512]; uint16 signature; int t; KPRINTF ("FatWriteBootRecord()"); ReadBlocks (fsb, &kernel_as, temp_sector, 0, 0, 512); MemCpy (temp_sector, &fsb->bpb, sizeof (struct FatBPB)); if (fsb->fat_type == TYPE_FAT32) { MemCpy (temp_sector + BPB_EXT_OFFSET, &fsb->bpb32, sizeof (struct FatBPB_32Ext)); MemCpy (temp_sector + FAT32_BOOTCODE_START, fat32_bootcode, SIZEOF_FAT32_BOOTCODE); } else { MemCpy (temp_sector + BPB_EXT_OFFSET, &fsb->bpb16, sizeof (struct FatBPB_16Ext)); MemCpy (temp_sector + FAT16_BOOTCODE_START, fat16_bootcode, SIZEOF_FAT16_BOOTCODE); } *(temp_sector + 510) = 0x55; *(temp_sector + 511) = 0xaa; WriteBlocks (fsb, &kernel_as, temp_sector, 0, 0, 512, BUF_IMMED); if (fsb->fat_type == TYPE_FAT32) { WriteBlocks (fsb, &kernel_as, &fsb->fsi, 1, 0, sizeof (struct FatFSInfo), BUF_IMMED); signature = 0xaa55; WriteBlocks (fsb, &kernel_as, &signature, 2, 510, 2, BUF_IMMED); for (t=0; t<3; t++) { ReadBlocks (fsb, &kernel_as, temp_sector, t, 0, 512); WriteBlocks (fsb, &kernel_as, temp_sector, 6+t, 0, 512, BUF_IMMED); } } return 0; }
int FlushDirent (struct FatSB *fsb, struct FatNode *node) { fsb = node->fsb; if (fsb->validated == FALSE || node == &fsb->root_node || fsb->write_protect == TRUE) return 0; WriteBlocks (fsb, &kernel_as, &node->dirent, node->dirent_sector, node->dirent_offset, sizeof (struct FatDirEntry), BUF_IMMED); return 0; }
int ext2::WriteDataBlock(ulong blockNumber, FileDescriptor *fd, uchar *src) { // find if we need to allocate a block or not ulong addr = FindAddressByBlockNumber(blockNumber, fd->fileInode.blockPointers); if(addr == 0) // we need to allocate a new block { Panic::PrintMessage("NEED TO ALLOCATE NEW BLOCK\n", false); addr = AllocateNewDataBlock(blockNumber, fd); } // write the block out to disk return WriteBlocks(addr, 1, src); }
int FatEraseDisk (struct FatSB *fsb, uint32 flags) { uint32 t, sectors; uint32 fat_sz; uint32 root_dir_sectors = 0; uint8 temp_sector[512]; KPRINTF ("FatEraseDisk()"); MemSet (temp_sector, 0, 512); if (fsb->fat_type == TYPE_FAT32) fat_sz = fsb->bpb32.sectors_per_fat32; else fat_sz = fsb->bpb.sectors_per_fat16; root_dir_sectors = ((fsb->bpb.root_entries_cnt * 32) + (fsb->bpb.bytes_per_sector - 1)) / fsb->bpb.bytes_per_sector; if (flags & FORMATF_QUICK) { sectors = fsb->bpb.reserved_sectors_cnt + (fsb->bpb.fat_cnt * fat_sz) + root_dir_sectors; if (fsb->fat_type == TYPE_FAT32) sectors += fsb->bpb.sectors_per_cluster; } else sectors = fsb->partition_size; for (t=0; t<sectors; t++) { KPRINTF ("Erasing sector %d", t); WriteBlocks (fsb, &kernel_as, temp_sector, t, 0, 512, BUF_IMMED); } return 0; }
// // Write functions // int ext2::WriteInode(ulong inode, Inode *theInode) { if(inode < 2) { Panic::PrintMessage("Tried to write inode zero\n"); return(-1); } ulong groupNumber = inode / theSuperBlock.inodesPerGroup; ulong blocksNeeded = DivUp(theSuperBlock.inodesPerGroup * sizeof(Inode), blockSize); // calc the blocks needed for all inodes uchar *buff = new uchar[blocksNeeded * blockSize]; Inode *tmpInode = reinterpret_cast<Inode*>(buff); /* printf("INODE: %d\n", inode); printf("INODES PER GROUP: %d\n", theSuperBlock.inodesPerGroup); printf("GROUP NUMBER: %d\n", groupNumber); printf("INODE TABLE ADDR: %d\n", theGroupDescriptors[groupNumber].inodeTableAddress); printf("BLOCKS REQUESTED: %d\n", blocksNeeded); printf("INODE SIZE: %d\n", sizeof(Inode)); */ // read the inode table for that group int ret = ReadBlocks(theGroupDescriptors[groupNumber].inodeTableAddress, blocksNeeded, buff); // check for an error on the read if(ret < 0) { delete [] buff; return ret; } // decrease inode because array index at zero and inodes at one MemCopy(&tmpInode[(inode-1) % theSuperBlock.inodesPerGroup], theInode, sizeof(Inode)); // write this back out to disk ret = WriteBlocks(theGroupDescriptors[groupNumber].inodeTableAddress, blocksNeeded, buff); delete [] buff; return(ret); }