void ram(void){
int menu = 0;
while(true) {
lcdClear();
printHeader();
switch(menu)
{
case MENU_DISK:
printDisk();
break;
default:
break;
}
lcdDisplay();
getInputWait();
return;
/*
switch(getInputWaitRelease()){
case BTN_UP:
case BTN_DOWN:
return;
case BTN_LEFT:
menu = --menu < 0 ? MENU_MAX : menu;
break;
case BTN_RIGHT:
menu = ++menu > MENU_MAX ? 0 : menu;
break;
case BTN_ENTER:
return;
}
*/
}
}
int main(){
FileSystem fs;
size_type size = 0x7FFFFFF;
printf("system size set to: %ld\n", size);
initFS(size, 20, &fs);
loadFS(&fs);
printFileSystem(&fs);
// printDisk(&(fs.disk_emulator), 0);
Inode inode;
size_type inode_id = ROOT_INODE_ID;
if(getInode(&fs, &inode_id, &inode)!=Success){
printf("[Potato mount] Error: root directory not exist.\n");
//return Err_GetInode;
return -1;
}
//allocate a block to root directory
size_type block_id;
allocBlock(&fs, &block_id);
inode.fileType = Directory;
size_type i = 0;
for(i=0; i<DIRECT_BLOCK_NUM; i++){
inode.directBlock[i] = -1;
}
inode.singleBlock = -1;
inode.doubleBlock = -1;
inode.tripleBlock = -1;
inode.directBlock[0] = block_id;
inode.used = true;
strcpy(inode.fileOwner, "NULL");
inode.fileModifiedTime = time(NULL);
inode.fileAccessTime = time(NULL);
inode.inodeModifiedTime = time(NULL);
inode.Permission = S_IFDIR | 0755;
DirEntry dir_entry[2];
strcpy(dir_entry[0].key, ".");
dir_entry[0].inodeId = ROOT_INODE_ID;
strcpy(dir_entry[1].key, "..");
dir_entry[1].inodeId = ROOT_INODE_ID;
BYTE* buf = malloc(BLOCK_SIZE);
memcpy(buf, dir_entry, sizeof(dir_entry));
put(&fs, block_id + fs.super_block.firstDataBlockId, buf);
inode.fileSize = sizeof(dir_entry);
//for . and ..
inode.numOfLinks = 2;
ErrorCode err = putInode(&fs, &inode_id, &inode);
if(err != Success){
printf("put root failed: Error %d", err);
}
Inode cur_inode;
getInode(&fs, &inode_id, &cur_inode);
printf("inode links: %ld\n", cur_inode.numOfLinks);
printDisk(&(fs.disk_emulator), 1);
//put free list buf into disk
put(&fs, fs.super_block.pDataFreeListHead + fs.super_block.firstDataBlockId, &(fs.dataBlockFreeListHeadBuf));
put(&fs, fs.super_block.pDataFreeListTail + fs.super_block.firstDataBlockId, &(fs.dataBlockFreeListTailBuf));
SuperBlockonDisk super_block_on_disk;
mapSuperBlockonDisk(&(fs.super_block), &(super_block_on_disk));
memcpy(buf, &super_block_on_disk, sizeof(SuperBlockonDisk));
put(&fs, SUPER_BLOCK_OFFSET, buf);
//set root acess time
free(buf);
closefs(&fs);
FileSystem new_fs;
loadFS(&new_fs);
// printFileSystem(&new_fs);
getInode(&new_fs, &inode_id, &cur_inode);
printf("inode links: %ld\n", cur_inode.numOfLinks);
closefs(&fs);
return 0;
}
int serverInit(char * MFS_image){
//this binds the server to port 100000
//sd = UDP_Open(10000);
// assert(sd > -1);
int sentinel, i = 0;
//first open disk
diskFD = open(MFS_image,O_RDWR);
//if disk doesn't exist, create it
if((int)diskFD < 0){
diskFD = open(MFS_image, O_RDWR| O_CREAT| O_TRUNC, S_IRWXU);
//create checkpoint region and write it
//MFS_Ckpt ckptregion;
//this ideally needs to be done with lseek at the end, but this is the easiest way to do it
ckptregion.endLog = sizeof(ckptregion)+ sizeof(MFS_Imap_Piece) +sizeof(MFS_Inode)+sizeof(MFS_Dir_Block);
for(i = 0; i < 256; i++ ){
//may need this calculation later
ckptregion.imapPiecePtrs[i] = -1;
}
/* Disk Image implemented as:
| CR | Imap p1 | Inode1| Data1 | Inode2 | Data2 | ...| Imap p2 | Inode1 | Data1 |... |<-endLog
*/
//point the first piece of the imap to the end of the log
ckptregion.imapPiecePtrs[0] = sizeof(ckptregion);
lseek(diskFD, 0, 0);
write(diskFD, &ckptregion, sizeof(ckptregion));
//create and write root data, inode, imap
MFS_Imap_Piece imapP1;
for(i = 0; i < 16; i++)
imapP1.imapPtrs[i] = -1;
imapP1.imapPtrs[0] = sizeof(ckptregion)+sizeof(imapP1);
//check all good before write
if(DEBUG){
printf("imap1.imapPtrs[0]: %d\n", imapP1.imapPtrs[0]);
printf("imap1.imapPtrs[1]: %d\n", imapP1.imapPtrs[1]);
}
write(diskFD, &imapP1, sizeof(imapP1));
MFS_Inode root_inode;
root_inode.stats.type = 0;
for(i = 0; i < 14; i++)
root_inode.blockPtrs[i] = -1;
//point this to the first datablock, right next to the inode
root_inode.blockPtrs[0] = sizeof(ckptregion)+sizeof(imapP1)+sizeof(root_inode) ;
//root_inode.stats.size = MFS_BLOCK_SIZE;
root_inode.stats.size = 2*MFS_BLOCK_SIZE;
write(diskFD, &root_inode, sizeof(root_inode));
// This is the first Directory Block
MFS_Dir_Block rootDirBlock;
//prepare rootDirBlock
sentinel = sizeof(rootDirBlock)/sizeof(rootDirBlock.dirEntries[0]);
for(i = 0; i < sentinel; i ++){
rootDirBlock.dirEntries[i].inum= -1;
memcpy(rootDirBlock.dirEntries[i].name, "\0", sizeof("\0"));
}
//these are the first two directory entries into the rootDirBlock
memcpy(rootDirBlock.dirEntries[0].name, ".\0", sizeof(".\0"));
rootDirBlock.dirEntries[0].inum= 0;
memcpy(rootDirBlock.dirEntries[1].name, "..\0", sizeof("..\0"));
rootDirBlock.dirEntries[1].inum=0;
//write rootDirBlock
write(diskFD, &rootDirBlock, sizeof(rootDirBlock));
}
else{
//to check all set up okay
if(DEBUG)
printDisk();
//disk image exists
//load checkpoint region into memory
(void) read(diskFD,&ckptregion, sizeof(ckptregion));
//check if this is right
if(DEBUG){
printf("printing ckptregion\n");
printf("printing ckptregion.endLog: %d \n", ckptregion.endLog);
for(i = 0; i < 5; i++){
printf("printing ckptregion.imapPiecePtrs[%d]: %d \n",i, ckptregion.imapPiecePtrs[i]);
}
}
}
//load inodeMap into memory
for(i = 0; i < 4096; i++){
inodeMap.inodes[i] = -1;
}
i =0;
sentinel = 0;
int j = 0;
MFS_Imap_Piece imapPiece;
while(ckptregion.imapPiecePtrs[i] >= 0){
lseek(diskFD,ckptregion.imapPiecePtrs[i], 0);
read(diskFD,&imapPiece, sizeof(imapPiece));
while(imapPiece.imapPtrs[sentinel] >= 0){
inodeMap.inodes[j] = imapPiece.imapPtrs[sentinel];
j++;sentinel++;
}
i++;
}
//check inodeMap, etc
if(DEBUG){
printf("diskFD: |%d|", (int)diskFD);
for(i = 0; i < 10; i++){
printf("inodeMap.inodes[%d]: %d\n",i, inodeMap.inodes[i]);
}
}
memLoad();
//make sure you flush
/************************************************************************/
//fsync(diskFD);
/************************************************************************/
return 0;
}
