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

96
include/fs.h
View File

@ -1,23 +1,39 @@
#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{
public:
static off_t getFreeListHead(){
SuperBlock(const char *directory){
}
~SuperBlock(){
}
static off_t getFreeListHead(RawDisk &disk){
char buffer[512] = {0};
rawdisk_read(0, buffer);
disk.rawdisk_read(0, buffer, sizeof(buffer));
off_t t = 0;
for (int j = 0; j < 8; j++)
t = t | (((off_t)buffer[j])<<(8*j));
return t;
}
static void writeFreeListHead(){
static void writeFreeListHead(RawDisk &disk, off_t t){
char buffer[512] = {0};
for (int j = 0; j < 8; j++){
buffer[j] = t & (((off_t)1<<(8*j))-1);
t >>= 8;
buffer[j] = (t >> (8 * j)) & 0xFF;
}
rawdisk_write(0, buffer);
disk.rawdisk_write(0, buffer, sizeof(buffer));
}
};
@ -42,14 +58,14 @@ public:
current_pos += 8;
}
void inode_construct(off_t blockNumber){
void inode_construct(off_t blockNumber, RawDisk &disk){
char buffer[512] = {0};
rawdisk_read(blockNumber, buffer);
disk.rawdisk_read(blockNumber*512, buffer, sizeof(buffer));
block_number = blockNumber;
int current_pos = 0;
// initialize blocks
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(double_indirect, current_pos, buffer);
@ -68,11 +84,11 @@ public:
current_pos += 8;
}
void inode_save(){
void inode_save(RawDisk &disk){
char buffer[512] = {0};
int current_pos = 0;
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(double_indirect, current_pos, buffer);
@ -81,12 +97,12 @@ public:
write_get_byte(gid, current_pos, buffer);
write_get_byte(permissions, 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
off_t freeListHead = SuperBlock::getFreeListHead();
off_t freeListHead = SuperBlock::getFreeListHead(disk);
/*
1. initialization
2. data block starting position
@ -94,10 +110,11 @@ public:
*/
char buffer[512] = {0};
off_t freeBlockNum = 0;
rawdisk_read(freeListHead, buffer);
disk.rawdisk_read(freeListHead*512, buffer, sizeof(buffer));
for (int i = 8; i < 264; i++){
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){
buffer[i] |= (1<<j);
break;
@ -117,52 +134,55 @@ public:
off_t next_header = 0;
for (int j = 0; j < 8; j++)
next_header = next_header | (((off_t)buffer[j])<<(8*j));
writeFreeListHead(next_header);
SuperBlock::writeFreeListHead(disk, next_header);
}
return freeBlockNum;
}
// 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?
//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;
for (int i = 0; i < 48; i++)
if(block[i] == 0){
if(blocks[i] == 0){
inBlocks = true;
block[i] = freeBlockNum;
blocks[i] = freeBlockNum;
break;
}
if(!inBlocks){
if (single_indirect == 0){
single_indirect = datablock_allocate_in_list();
single_indirect = datablock_allocate_in_list(disk);
}
int inSingle = false;
char buffer[512] = {0};
rawdisk_read(single_indirect, buffer);
for (int i = 0; i < 512; i++)
disk.rawdisk_read(single_indirect*512, buffer, sizeof(buffer));
for (int i = 0; i < 512; i++){
if(buffer[i] == 0){
inSingle = true;
buffer[i] = freeBlockNum;
break;
}
//ask which scope
if(i < 512){
rawdisk_write(single_indirect, buffer);
disk.rawdisk_write(single_indirect*512, buffer, sizeof(buffer));
}
else{
if (double_indirect == 0){
double_indirect = datablock_allocate_in_list();
double_indirect = datablock_allocate_in_list(disk);
}
int inDouble = false;
rawdisk_read(double_indirect, buffer);
disk.rawdisk_read(double_indirect*512, buffer, sizeof(buffer));
// w.t.f is this
}
}
da
}
//return the block number
inode_save();
inode_save(disk);
return freeBlockNum;
}
@ -170,25 +190,25 @@ public:
void datablock_deallocate(){
}
}
};
class INodeOperation{
// free list head is at super block (0): first 8 bytes
public:
//initialization of the rawdisk
void initialize(){
SuperBlock::writeFreeListHead(524288); // maximum inode number
for (off_t i = 524288; i <7864320; i += 2048){
void initialize(RawDisk &disk){
SuperBlock::writeFreeListHead(disk, MAX_INODE); // maximum inode number 2^19 0x80000
//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};
off_t t = i + 2048;
if (t < 7864320){
if (t < MAX_BLOCKNUM){
for (int j = 0; j < 8; j++){
buffer[j] = t & (((off_t)1<<(8*j))-1);
t >>= 8;
buffer[j] = (t >> (8 * j)) & 0xFF;
}
}
rawdisk_write(i, buffer);
disk.rawdisk_write(i*512, buffer, sizeof(buffer));
}
}
@ -212,4 +232,4 @@ public:
void inode_write(){
}
}
};