//-----------------------------------------------------------------
// DfsReadBlock reads an allocated DFS block from the disk
// (which could span multiple physical disk blocks). The block
// must be allocated in order to read from it. Returns DFS_FAIL
// on failure, and the number of bytes read on success.
//-----------------------------------------------------------------
int DfsReadBlock(uint32 blocknum, dfs_block *b) {
disk_block diskb;
int diskblocksize;
int factor;
int i;
int count = 0;
if(!sb.valid) {
printf("DfsReadBlock: file system is not valid\n");
return DFS_FAIL;
}
// if(!(fbv[blocknum / 32] & (1 << (blocknum % 32)))) {
// printf("DfsReadBlock: the block %d is not allocated\n", blocknum);
// return DFS_FAIL;
// }
diskblocksize = DiskBytesPerBlock();
factor = sb.blocksize / diskblocksize;
for(i = 0; i < factor; i++) {
if(DiskReadBlock((blocknum * factor) + i, &diskb) == DISK_FAIL) {
printf("DfsReadBlock: Disk read failed copied %d of %d\n", count, sb.blocksize);
break;
}
bcopy(diskb.data, &(b->data[i * diskblocksize]), diskblocksize);
count += diskblocksize;
}
return count;
}
int DfsReadBlock(int blocknum, dfs_block *b) {
int i;
int ratio;
disk_block disk_b;
int disk_blocknum;
// printf("InDfsReadBlock\n");
if (sb.valid == 0){
printf("File system not open!\n");
return DFS_FAIL;
}
if((blocknum<0)||(blocknum>sb.filesys_blocknum)){
printf("Invalid blocknum = %d\n",blocknum);
return DFS_FAIL;
}
if(Dfscheck(blocknum)== DFS_FAIL){
printf("Error,DFS block %d not allocated!\n",blocknum);
return DFS_FAIL;
}
ratio = sb.filesys_blocksize/(DISK_BLOCKSIZE);
disk_blocknum=(blocknum*ratio);
for(i=0;i<ratio;i++){
if (DiskReadBlock((uint32)(disk_blocknum + i),&disk_b) == DISK_FAIL){
printf("Cannot read block %d from disk!\n",disk_blocknum);
return DISK_FAIL;
}
bcopy((char *)(&disk_b),(char *)((int)b+i*(DISK_BLOCKSIZE)),DISK_BLOCKSIZE);
}
return (sb.filesys_blocksize);
}
int DfsOpenFileSystem() {
disk_block diskb;
dfs_block dfsb;
char* inbytes;
unsigned int i;
//Basic steps:
// Check that filesystem is not already open
if(sb.valid) {
printf("DfsOpenFilesystem: File system is already open\n");
return DFS_FAIL;
}
// Read superblock from disk. Note this is using the disk read rather
// than the DFS read function because the DFS read requires a valid
// filesystem in memory already, and the filesystem cannot be valid
// until we read the superblock. Also, we don't know the block size
// until we read the superblock, either.
DiskReadBlock(1, &diskb);
// Copy the data from the block we just read into the superblock in memory
bcopy(diskb.data, (char*) &sb, sizeof(sb));
// sb should be valid at this point since sb was supposed to be valid on disk
if(!sb.valid) {
printf("DfsOpenFileSystem: Filesystem on disk is not valid\n");
return DFS_FAIL;
}
// All other blocks are sized by virtual block size:
// Read inodes
inbytes = (char*) inodes;
for(i = sb.inode_start_block; i < sb.fbv_start_block; i++) {
DfsReadBlock(i, &dfsb);
bcopy(dfsb.data, &(inbytes[(i - sb.inode_start_block) * sb.blocksize]), sb.blocksize);
}
// Read free block vector
inbytes = (char*) fbv;
for(i = sb.fbv_start_block; i < sb.data_start_block; i++) {
DfsReadBlock(i, &dfsb);
bcopy(dfsb.data, &(inbytes[(i - sb.fbv_start_block) * sb.blocksize]), sb.blocksize);
}
// Change superblock to be invalid, write back to disk, then change
// it back to be valid in memory
sb.valid = 0;
bzero(diskb.data, DISK_BLOCKSIZE);
bcopy((char*)&sb, diskb.data, sizeof(sb));
DiskWriteBlock(1, &diskb);
sb.valid = 1;
return DFS_SUCCESS;
}
int DfsOpenFileSystem() {
int i;
int num;
dfs_block dfs_b;
disk_block disk_b;
//Basic steps:
// Check that filesystem is not already open
// Read superblock from disk. Note this is using the disk read rather
// than the DFS read function because the DFS read requires a valid
// filesystem in memory already, and the filesystem cannot be valid
// until we read the superblock. Also, we don't know the block size
// until we read the superblock, either.
// printf("In DfsOpenFileSystem\n");
// Copy the data from the block we just read into the superblock in memory
// All other blocks are sized by virtual block size:
// Read inodes
// Read free block vector
// Change superblock to be invalid, write back to disk, then change
// it back to be valid in memory
if (sb.valid == 1){
printf("The filesystem is already open!\n");
return DFS_FAIL;
}
if ((num = DiskReadBlock(1,&disk_b)) == DISK_FAIL){
printf("Cannot read superblock from disk!\n");
return DFS_FAIL;
}
bcopy((char *)(&disk_b),(char *)(&sb),sizeof(dfs_superblock));
//print superblock info from disk
/* printf("superblock.valid %d\n",sb.valid);
printf("superblock.filesys_blocksize %d\n",sb.filesys_blocksize);
printf("superblock.filesys_blocknum %d\n",sb.filesys_blocknum);
printf("superblock.filesys_inodestart %d\n",sb.filesys_inodestart);
printf("superblock.inodenum %d\n",sb.inodenum);
printf("superblock.filesys_fbvstart %d\n",sb.filesys_fbvstart);
printf("superblock.filesys_datastart %d\n",sb.filesys_datastart);
*/
for(i=sb.filesys_inodestart;i<sb.filesys_fbvstart;i++){
if (( num = DfsReadBlock (i,&dfs_b)) == DFS_FAIL){
printf("Cannot read inode from disk!\n");
return DFS_FAIL;
}
bcopy((char *)(&dfs_b),(char *)(&inodes[(i-sb.filesys_inodestart)*(sb.filesys_blocksize)/sizeof(dfs_inode)]),sb.filesys_blocksize);
}
SetupRootDir();
//print inode info from disk
// for(i=0;i<192;i++){
// printf("inodes[%d].inuse=%d,inodes[%d].filesize=%d\n",i,inodes[i].inuse,i,inodes[i].filesize);
// }
//
for(i=sb.filesys_fbvstart;i<sb.filesys_datastart;i++){
if (( num = DfsReadBlock(i, &dfs_b)) == DFS_FAIL){
printf("Cannot read free block vector from disk!\n");
return DFS_FAIL;
}
bcopy((char *)(&dfs_b),(char *)(&fbv[(i-sb.filesys_fbvstart)*(sb.filesys_blocksize)/sizeof(uint32)]),sb.filesys_blocksize);
}
//print fbv info from disk
// for(i=0;i<DFS_FBV_MAX_NUM;i++){
// printf("fbv[%d]=0x%x\n",i,fbv[i]);
// }
//
DfsInvalidate();
bzero((char *)(&disk_b),sizeof(disk_block));
bcopy((char *)(&sb),(char *)(&disk_b),sizeof(dfs_superblock));
if (DiskWriteBlock(1,&disk_b) == DISK_FAIL){
printf("Cannot write superblock back to disk!\n");
return DFS_FAIL;
}
sb.valid = 1;
// printf("Exit DfsOpenFileSystem\n");
return DFS_SUCCESS;
}
