admin/iloveos
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

revise the way to use rawdisk R/W, add rawdisk obj as reference, revise writeFreeListHead API and it bit shifting

Browse Source
This commit is contained in:
Victor 2023-11-07 15:58:20 -08:00
parent 94a1496127
commit 4823b76d6c
1 changed files with 64 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
include/fs.h
View File

@ -1,23 +1,39 @@
#include "rawdisk.h" #include "rawdisk.h"
/*****************************************************
30GB Disk low-level operation and data structure: spuerblock, inode, and buffer cache
512 bytes sector for 1 block, 62914560 block(sector)
4K bytes sector for 1 block, 7864320 block(sector)
one inode equipped with one 512 bytes block
*****************************************************/
#define MAX_INODE 524288
#define MAX_BLOCKNUM 62914560
class SuperBlock{ class SuperBlock{
public: public:
static off_t getFreeListHead(){ SuperBlock(const char *directory){
}
~SuperBlock(){
}
static off_t getFreeListHead(RawDisk &disk){
char buffer[512] = {0}; char buffer[512] = {0};
rawdisk_read(0, buffer); disk.rawdisk_read(0, buffer, sizeof(buffer));
off_t t = 0; off_t t = 0;
for (int j = 0; j < 8; j++) for (int j = 0; j < 8; j++)
t = t | (((off_t)buffer[j])<<(8*j)); t = t | (((off_t)buffer[j])<<(8*j));
return t; return t;
} }
static void writeFreeListHead(){ static void writeFreeListHead(RawDisk &disk, off_t t){
char buffer[512] = {0}; char buffer[512] = {0};
for (int j = 0; j < 8; j++){ for (int j = 0; j < 8; j++){
buffer[j] = t & (((off_t)1<<(8*j))-1); buffer[j] = (t >> (8 * j)) & 0xFF;
t >>= 8;
} }
rawdisk_write(0, buffer); disk.rawdisk_write(0, buffer, sizeof(buffer));
} }
}; };
@ -42,14 +58,14 @@ public:
current_pos += 8; current_pos += 8;
} }
void inode_construct(off_t blockNumber){ void inode_construct(off_t blockNumber, RawDisk &disk){
char buffer[512] = {0}; char buffer[512] = {0};
rawdisk_read(blockNumber, buffer); disk.rawdisk_read(blockNumber*512, buffer, sizeof(buffer));
block_number = blockNumber; block_number = blockNumber;
int current_pos = 0; int current_pos = 0;
// initialize blocks // initialize blocks
for (int i = 0; i < 48; i++){ for (int i = 0; i < 48; i++){
read_get_byte(block[i], current_pos, buffer); read_get_byte(blocks[i], current_pos, buffer);
} }
read_get_byte(single_indirect, current_pos, buffer); read_get_byte(single_indirect, current_pos, buffer);
read_get_byte(double_indirect, current_pos, buffer); read_get_byte(double_indirect, current_pos, buffer);
@ -68,11 +84,11 @@ public:
current_pos += 8; current_pos += 8;
} }
void inode_save(){ void inode_save(RawDisk &disk){
char buffer[512] = {0}; char buffer[512] = {0};
int current_pos = 0; int current_pos = 0;
for (int i = 0; i < 48; i++){ for (int i = 0; i < 48; i++){
write_get_byte(block[i], current_pos, buffer); write_get_byte(blocks[i], current_pos, buffer);
} }
write_get_byte(single_indirect, current_pos, buffer); write_get_byte(single_indirect, current_pos, buffer);
write_get_byte(double_indirect, current_pos, buffer); write_get_byte(double_indirect, current_pos, buffer);
@ -81,12 +97,12 @@ public:
write_get_byte(gid, current_pos, buffer); write_get_byte(gid, current_pos, buffer);
write_get_byte(permissions, current_pos, buffer); write_get_byte(permissions, current_pos, buffer);
write_get_byte(size, current_pos, buffer); write_get_byte(size, current_pos, buffer);
rawdisk_write(block_number, buffer); disk.rawdisk_write(block_number*512, buffer, sizeof(buffer));
} }
off_t datablock_allocate_in_list(){ off_t datablock_allocate_in_list(RawDisk &disk){
//find a free data block //find a free data block
off_t freeListHead = SuperBlock::getFreeListHead(); off_t freeListHead = SuperBlock::getFreeListHead(disk);
/* /*
1. initialization 1. initialization
2. data block starting position 2. data block starting position
@ -94,10 +110,11 @@ public:
*/ */
char buffer[512] = {0}; char buffer[512] = {0};
off_t freeBlockNum = 0; off_t freeBlockNum = 0;
rawdisk_read(freeListHead, buffer); disk.rawdisk_read(freeListHead*512, buffer, sizeof(buffer));
for (int i = 8; i < 264; i++){ for (int i = 8; i < 264; i++){
if(buffer[i] != 255){ if(buffer[i] != 255){
for (int j = 0; j < 8; j++){ int j = 0;
for (j = 0; j < 8; j++){
if ((buffer[i]&(1<<j)) == 0){ if ((buffer[i]&(1<<j)) == 0){
buffer[i] |= (1<<j); buffer[i] |= (1<<j);
break; break;
@ -117,52 +134,55 @@ public:
off_t next_header = 0; off_t next_header = 0;
for (int j = 0; j < 8; j++) for (int j = 0; j < 8; j++)
next_header = next_header | (((off_t)buffer[j])<<(8*j)); next_header = next_header | (((off_t)buffer[j])<<(8*j));
writeFreeListHead(next_header); SuperBlock::writeFreeListHead(disk, next_header);
} }
return freeBlockNum; return freeBlockNum;
} }
// allowcate 1 datablock and add to the end of the file // allowcate 1 datablock and add to the end of the file
off_t datablock_allocate(){ off_t datablock_allocate(RawDisk &disk){
//do we need to check dynamic? //do we need to check dynamic?
//add the data block to blocks, single, double, triple //add the data block to blocks, single, double, triple
off_t freeBlockNum = datablock_allocate_in_list(); off_t freeBlockNum = datablock_allocate_in_list(disk);
bool inBlocks = false; bool inBlocks = false;
for (int i = 0; i < 48; i++) for (int i = 0; i < 48; i++)
if(block[i] == 0){ if(blocks[i] == 0){
inBlocks = true; inBlocks = true;
block[i] = freeBlockNum; blocks[i] = freeBlockNum;
break; break;
} }
if(!inBlocks){ if(!inBlocks){
if (single_indirect == 0){ if (single_indirect == 0){
single_indirect = datablock_allocate_in_list(); single_indirect = datablock_allocate_in_list(disk);
} }
int inSingle = false; int inSingle = false;
char buffer[512] = {0}; char buffer[512] = {0};
rawdisk_read(single_indirect, buffer); disk.rawdisk_read(single_indirect*512, buffer, sizeof(buffer));
for (int i = 0; i < 512; i++) for (int i = 0; i < 512; i++){
if(buffer[i] == 0){ if(buffer[i] == 0){
inSingle = true; inSingle = true;
buffer[i] = freeBlockNum; buffer[i] = freeBlockNum;
break; break;
} }
if(i < 512){ //ask which scope
rawdisk_write(single_indirect, buffer); if(i < 512){
} disk.rawdisk_write(single_indirect*512, buffer, sizeof(buffer));
else{ }
if (double_indirect == 0){ else{
double_indirect = datablock_allocate_in_list(); if (double_indirect == 0){
double_indirect = datablock_allocate_in_list(disk);
}
int inDouble = false;
disk.rawdisk_read(double_indirect*512, buffer, sizeof(buffer));
// w.t.f is this
} }
int inDouble = false;
rawdisk_read(double_indirect, buffer);
// w.t.f is this
} }
} }
da
//return the block number //return the block number
inode_save(); inode_save(disk);
return freeBlockNum; return freeBlockNum;
} }
@ -170,25 +190,25 @@ public:
void datablock_deallocate(){ void datablock_deallocate(){
} }
} };
class INodeOperation{ class INodeOperation{
// free list head is at super block (0): first 8 bytes // free list head is at super block (0): first 8 bytes
public: public:
//initialization of the rawdisk //initialization of the rawdisk
void initialize(){ void initialize(RawDisk &disk){
SuperBlock::writeFreeListHead(524288); // maximum inode number SuperBlock::writeFreeListHead(disk, MAX_INODE); // maximum inode number 2^19 0x80000
for (off_t i = 524288; i <7864320; i += 2048){ //Have tested this initialize function but MAX_BLOCK too much, MAX_INODE*2 works
for (off_t i = MAX_INODE; i < MAX_BLOCKNUM; i += 2048){
char buffer[512] = {0}; char buffer[512] = {0};
off_t t = i + 2048; off_t t = i + 2048;
if (t < 7864320){ if (t < MAX_BLOCKNUM){
for (int j = 0; j < 8; j++){ for (int j = 0; j < 8; j++){
buffer[j] = t & (((off_t)1<<(8*j))-1); buffer[j] = (t >> (8 * j)) & 0xFF;
t >>= 8;
} }
} }
rawdisk_write(i, buffer); disk.rawdisk_write(i*512, buffer, sizeof(buffer));
} }
} }
@ -212,4 +232,4 @@ public:
void inode_write(){ void inode_write(){
} }
} };