From 5cbee55bd4f437ae6a61e1db5462193dc37005eb Mon Sep 17 00:00:00 2001 From: FactorialN Date: Sun, 5 Nov 2023 16:01:00 -0800 Subject: [PATCH 01/17] started layer 1 --- include/fs.h | 130 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 130 insertions(+) create mode 100644 include/fs.h diff --git a/include/fs.h b/include/fs.h new file mode 100644 index 0000000..ba9f0cf --- /dev/null +++ b/include/fs.h @@ -0,0 +1,130 @@ +#include "rawdisk.h" + +class SuperBlock{ +public: + static off_t getFreeListHead(){ + char buffer[512] = {0}; + rawdisk_read(0, 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(){ + char buffer[512] = {0}; + for (int j = 0; j < 8; j++){ + buffer[j] = t & (((off_t)1<<(8*j))-1); + t >>= 8; + } + rawdisk_write(0, buffer); + } +}; + +class INode{ + // direct datablocks + off_t blocks[48]; + // indirect address + off_t single_indirect, double_indirect, triple_indirect; + // other + + off_t uid; + off_t gid; + off_t permissions; + off_t size; + +public: + void read_get_byte(off_t &t, int ¤t_pos, char *buffer){ + t = 0; + for (int j = 0; j < 8; j++) + t = t | (((off_t)buffer[j+current_pos])<<(8*j)); + current_pos += 8; + } + + void inode_construct(off_t blockNumber){ + char buffer[512] = {0}; + rawdisk_read(blockNumber, buffer); + int current_pos = 0; + // initialize blocks + for (int i = 0; i < 48; i++){ + read_get_byte(block[i], current_pos, buffer); + } + read_get_byte(single_indirect, current_pos, buffer); + read_get_byte(double_indirect, current_pos, buffer); + read_get_byte(triple_indirect, current_pos, buffer); + read_get_byte(uid, current_pos, buffer); + read_get_byte(gid, current_pos, buffer); + read_get_byte(permissions, current_pos, buffer); + read_get_byte(size, current_pos, buffer); + } + + void write_get_byte(off_t t, int ¤t_pos, char *buffer){ + for (int j = 0; j < 8; j++){ + buffer[j+current_pos] = t & (((off_t)1<<(8*j))-1); + t >>= 8; + } + current_pos += 8; + } + + void inode_save(off_t blockNumber){ + 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(single_indirect, current_pos, buffer); + write_get_byte(double_indirect, current_pos, buffer); + write_get_byte(triple_indirect, current_pos, buffer); + write_get_byte(uid, current_pos, buffer); + write_get_byte(gid, current_pos, buffer); + write_get_byte(permissions, current_pos, buffer); + write_get_byte(size, current_pos, buffer); + rawdisk_write(bloackNumber, buffer); + } + + // allowcate 1 datablock and add to the end of the file + off_t datablock_allocate(){ + //do we need to check dynamic? + + //find a free data block + off_t freeListHead = SuperBlock::getFreeListHead(); + for (freeListHead) + + //add the data block to blocks, single, double, triple + + //return the block number + + } + + // deallocate 1 datablock from the end of the file + void datablock_deallocate(){ + + } +} + +class INodeOperation{ +// free list head is at super block (0): first 8 bytes + +public: + + // allocate an inode and return the number of the inode + // the i-th inode is in the i-th block + off_t inode_allocate(){ + + //return inode number + } + + // + void inode_free(off_t iNodeNumber){ + + } + + //ignore for now + void inode_read(){ + + } + + void inode_write(){ + + } +} \ No newline at end of file From b961114ae1fb8002497d7998d50ed8056f022a4d Mon Sep 17 00:00:00 2001 From: FactorialN Date: Sun, 5 Nov 2023 17:02:59 -0800 Subject: [PATCH 02/17] layer1 datablock allocate --- include/fs.h | 99 ++++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 92 insertions(+), 7 deletions(-) diff --git a/include/fs.h b/include/fs.h index ba9f0cf..7211bfc 100644 --- a/include/fs.h +++ b/include/fs.h @@ -32,6 +32,7 @@ class INode{ off_t gid; off_t permissions; off_t size; + off_t block_number; public: void read_get_byte(off_t &t, int ¤t_pos, char *buffer){ @@ -44,6 +45,7 @@ public: void inode_construct(off_t blockNumber){ char buffer[512] = {0}; rawdisk_read(blockNumber, buffer); + block_number = blockNumber; int current_pos = 0; // initialize blocks for (int i = 0; i < 48; i++){ @@ -66,7 +68,7 @@ public: current_pos += 8; } - void inode_save(off_t blockNumber){ + void inode_save(){ char buffer[512] = {0}; int current_pos = 0; for (int i = 0; i < 48; i++){ @@ -79,21 +81,89 @@ public: write_get_byte(gid, current_pos, buffer); write_get_byte(permissions, current_pos, buffer); write_get_byte(size, current_pos, buffer); - rawdisk_write(bloackNumber, buffer); + rawdisk_write(block_number, buffer); + } + + off_t datablock_allocate_in_list(){ + //find a free data block + off_t freeListHead = SuperBlock::getFreeListHead(); + /* + 1. initialization + 2. data block starting position + 3. r/w between storage and rawdisk to maintain + */ + char buffer[512] = {0}; + off_t freeBlockNum = 0; + rawdisk_read(freeListHead, buffer); + for (int i = 8; i < 264; i++){ + if(buffer[i] != 255){ + for (int j = 0; j < 8; j++){ + if ((buffer[i]&(1<>= 8; + } + } + rawdisk_write(i, buffer); + } + } // allocate an inode and return the number of the inode // the i-th inode is in the i-th block From d276bb0e4c9197a502e9a432c58659a4604e38bb Mon Sep 17 00:00:00 2001 From: FactorialN Date: Sun, 5 Nov 2023 17:03:19 -0800 Subject: [PATCH 03/17] layer1 datablock allocate --- include/fs.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/fs.h b/include/fs.h index 7211bfc..f35971d 100644 --- a/include/fs.h +++ b/include/fs.h @@ -160,7 +160,7 @@ public: // w.t.f is this } } - + da //return the block number inode_save(); return freeBlockNum; From 4823b76d6c903eb7231e4855b6ecb1dc493d64e0 Mon Sep 17 00:00:00 2001 From: Victor Date: Tue, 7 Nov 2023 15:58:20 -0800 Subject: [PATCH 04/17] revise the way to use rawdisk R/W, add rawdisk obj as reference, revise writeFreeListHead API and it bit shifting --- include/fs.h | 108 ++++++++++++++++++++++++++++++--------------------- 1 file changed, 64 insertions(+), 44 deletions(-) diff --git a/include/fs.h b/include/fs.h index f35971d..086d02d 100644 --- a/include/fs.h +++ b/include/fs.h @@ -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<>= 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(){ } -} \ No newline at end of file +}; \ No newline at end of file From d3bf233e42820d934c23e76d7d74a35a7cbbb566 Mon Sep 17 00:00:00 2001 From: FactorialN Date: Tue, 7 Nov 2023 19:36:27 -0800 Subject: [PATCH 05/17] save before changing datablock to 4k --- include/fs.h | 156 ++++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 129 insertions(+), 27 deletions(-) diff --git a/include/fs.h b/include/fs.h index 086d02d..e91df8c 100644 --- a/include/fs.h +++ b/include/fs.h @@ -139,6 +139,57 @@ public: return freeBlockNum; } + bool allo_single_indirect(RawDisk &disk, off_t &single_i, off_t freeBlockNum) { + if (single_i == 0){ + single_i = datablock_allocate_in_list(disk); + } + bool inSingle = false; + char buffer[512] = {0}; + disk.rawdisk_read(single_i*512, buffer, sizeof(buffer)); + for (int i = 0; i < 512; i++){ + if(buffer[i] == 0){ + inSingle = true; + buffer[i] = freeBlockNum; + break; + } + return inSingle; + } + + bool allo_double_indirect(RawDisk &disk, off_t &double_i, off_t freeBlockNum) { + if (double_i == 0){ + double_i = datablock_allocate_in_list(disk); + } + bool inDouble = false; + char buffer[512] = {0}; + disk.rawdisk_read(double_i*512, buffer, sizeof(buffer)); + for (int i = 0; i < 512; i++){ + bool flag = allo_single_indirect(disk, buffer[i], freeBlockNum); + if (flag){ + inDouble = true; + break; + } + } + return inDouble; + } + + bool allo_triple_indirect(RawDisk &disk, off_t &triple_i, off_t freeBlockNum) { + if (triple_i == 0){ + triple_i = datablock_allocate_in_list(disk); + } + bool inTriple = false; + char buffer[512] = {0}; + disk.rawdisk_read(triple_i*512, buffer, sizeof(buffer)); + for (int i = 0; i < 512, i++){ + bool flag = allo_double_indirect(disk, buffer[i], freeBlockNum); + if (flag){ + inTriple = true; + break; + } + } + return inTriple; + } + + // allowcate 1 datablock and add to the end of the file off_t datablock_allocate(RawDisk &disk){ //do we need to check dynamic? @@ -153,32 +204,14 @@ public: break; } if(!inBlocks){ - if (single_indirect == 0){ - single_indirect = datablock_allocate_in_list(disk); - } - int inSingle = false; - char buffer[512] = {0}; - 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; + bool inSingle = allo_single_indirect(disk, single_indirect, freeBlockNum); + if (!inSingle){ + bool inDouble = allo_double_indirect(disk, double_indirect, freeBlockNum); + if (!inDouble){ + bool inTriple = allo_triple_indirect(disk, triple_indirect, freeBlockNum); + // wait to deal with too big files } - //ask which scope - if(i < 512){ - disk.rawdisk_write(single_indirect*512, buffer, sizeof(buffer)); - } - else{ - 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 - } - } - + } } //return the block number @@ -186,10 +219,79 @@ public: return freeBlockNum; } - // deallocate 1 datablock from the end of the file - void datablock_deallocate(){ + void datablock_deallocate_in_list(off_t freeBlockNum) { } + + bool deallow_single_indirect(RawDisk &disk, off_t &single_i){ + if (single_i == 0){ + return false; + } + char buffer[512] = {0}; + int delpoint = -1; + disk.rawdisk_read(single_i*512, buffer, sizeof(buffer)); + for (int i=255; i >= 0; i--) + if(buffer[i] != 0){ + buffer[i] = 0; + delpoint = i; + break; + } + if (delpoint == 0 && buffer[0] == 0){ + datablock_deallocate_in_list(single_i); + single_i = 0; + } + return true; + } + + bool deallow_double_indirect(RawDisk &disk, off_t &double_i){ + if (double_i == 0){ + return false; + } + char buffer[512] = {0}; + int delpoint = -1; + disk.rawdisk_read(double_i*512, buffer, sizeof(buffer)); + for (int i=255; i >= 0; i--){ + bool inSingle = deallo_single_indirect(disk, buffer[i]); + if (inSingle){ + delpoint = i; + break; + } + } + if (delpoint == 0 && buffer[0] == 0){ + datablock_deallocate_in_list(double_i); + double_i = 0; + } + return true; + } + + bool deallo_triple_indirect(RawDisk &disk, off_t &triple_i){ + if (triple_i == 0){ + return false; + } + char buffer[512] = {0}; + int delpoint = -1; + disk.rawdisk_read(triple_i*512, buffer, sizeof(buffer)); + for (int i=255; i >= 0; i--){ + bool inDouble = deallo_double_indirect(disk, buffer[i]); + if (inDouble){ + delpoint = i; + break; + } + } + if (delpoint == 0 && buffer[0] == 0){ + datablock_deallocate_in_list(triple_i); + triple_i = 0; + } + return true; + } + + // deallocate 1 datablock from the end of the file + void datablock_deallocate(RawDisk &disk){ + // find the last datablock and remove it from inode (triple->direct) + + + // add it back to freeBlocklist + } }; class INodeOperation{ From 489b92cf240956c79d1f3705e2ba3c62e6508708 Mon Sep 17 00:00:00 2001 From: FactorialN Date: Tue, 7 Nov 2023 20:39:41 -0800 Subject: [PATCH 06/17] changed to 4k, implemented most --- include/fs.h | 169 +++++++++++++++++++++++++++++++++++---------------- 1 file changed, 118 insertions(+), 51 deletions(-) diff --git a/include/fs.h b/include/fs.h index e91df8c..52e2eb6 100644 --- a/include/fs.h +++ b/include/fs.h @@ -7,6 +7,8 @@ one inode equipped with one 512 bytes block *****************************************************/ +#define SECTOR_SIZE 512 +#define IO_BLOCK_SIZE 4096 #define MAX_INODE 524288 #define MAX_BLOCKNUM 62914560 @@ -20,7 +22,7 @@ public: } static off_t getFreeListHead(RawDisk &disk){ - char buffer[512] = {0}; + char buffer[SECTOR_SIZE] = {0}; disk.rawdisk_read(0, buffer, sizeof(buffer)); off_t t = 0; for (int j = 0; j < 8; j++) @@ -29,7 +31,7 @@ public: } static void writeFreeListHead(RawDisk &disk, off_t t){ - char buffer[512] = {0}; + char buffer[SECTOR_SIZE] = {0}; for (int j = 0; j < 8; j++){ buffer[j] = (t >> (8 * j)) & 0xFF; } @@ -58,9 +60,16 @@ public: current_pos += 8; } + off_t read_byte_at(int current_pos, char *buffer){ + off_t t = 0; + for (int j = 0; j < 8; j++) + t = t | (((off_t)buffer[j+current_pos])<<(8*j)); + return t; + } + void inode_construct(off_t blockNumber, RawDisk &disk){ - char buffer[512] = {0}; - disk.rawdisk_read(blockNumber*512, buffer, sizeof(buffer)); + char buffer[SECTOR_SIZE] = {0}; + disk.rawdisk_read(blockNumber*SECTOR_SIZE, buffer, sizeof(buffer)); block_number = blockNumber; int current_pos = 0; // initialize blocks @@ -78,14 +87,21 @@ public: void write_get_byte(off_t t, int ¤t_pos, char *buffer){ for (int j = 0; j < 8; j++){ - buffer[j+current_pos] = t & (((off_t)1<<(8*j))-1); + buffer[j+current_pos] = t & (((off_t)1<<(8))-1); t >>= 8; } current_pos += 8; } + void write_byte_at(off_t t, int current_pos, char *buffer){ + for (int j = 0; j < 8; j++){ + buffer[j+current_pos] = t & (((off_t)1<<(8))-1); + t >>= 8; + } + } + void inode_save(RawDisk &disk){ - char buffer[512] = {0}; + char buffer[SECTOR_SIZE] = {0}; int current_pos = 0; for (int i = 0; i < 48; i++){ write_get_byte(blocks[i], current_pos, buffer); @@ -97,7 +113,7 @@ public: write_get_byte(gid, current_pos, buffer); write_get_byte(permissions, current_pos, buffer); write_get_byte(size, current_pos, buffer); - disk.rawdisk_write(block_number*512, buffer, sizeof(buffer)); + disk.rawdisk_write(block_number*SECTOR_SIZE, buffer, sizeof(buffer)); } off_t datablock_allocate_in_list(RawDisk &disk){ @@ -108,9 +124,9 @@ public: 2. data block starting position 3. r/w between storage and rawdisk to maintain */ - char buffer[512] = {0}; + char buffer[IO_BLOCK_SIZE] = {0}; off_t freeBlockNum = 0; - disk.rawdisk_read(freeListHead*512, buffer, sizeof(buffer)); + disk.rawdisk_read(freeListHead, buffer, sizeof(buffer)); for (int i = 8; i < 264; i++){ if(buffer[i] != 255){ int j = 0; @@ -120,9 +136,10 @@ public: break; } } - freeBlockNum = freeListHead + (i-8)*8 + j + 1; + freeBlockNum = freeListHead + ((i-8)*8 + j + 1)*IO_BLOCK_SIZE; } } + disk.rawdisk_write(freeListHead, buffer, sizeof(buffer)); bool notFull = false; for (int i = 8; i < 264; i++){ if((i < 263 && buffer[i] != 255) || (i == 263 && buffer[i] != 127)){ @@ -144,14 +161,17 @@ public: single_i = datablock_allocate_in_list(disk); } bool inSingle = false; - char buffer[512] = {0}; - disk.rawdisk_read(single_i*512, buffer, sizeof(buffer)); - for (int i = 0; i < 512; i++){ - if(buffer[i] == 0){ + char buffer[IO_BLOCK_SIZE] = {0}; + disk.rawdisk_read(single_i, buffer, sizeof(buffer)); + for (int i = 0; i < IO_BLOCK_SIZE; i+=8){ + off_t addr = read_byte_at(i, buffer); + if(addr == 0){ inSingle = true; - buffer[i] = freeBlockNum; + write_byte_at(freeBlockNum, i, buffer); + disk.rawdisk_write(single_i, buffer, sizeof(buffer)); break; } + } return inSingle; } @@ -160,11 +180,14 @@ public: double_i = datablock_allocate_in_list(disk); } bool inDouble = false; - char buffer[512] = {0}; - disk.rawdisk_read(double_i*512, buffer, sizeof(buffer)); - for (int i = 0; i < 512; i++){ - bool flag = allo_single_indirect(disk, buffer[i], freeBlockNum); + char buffer[IO_BLOCK_SIZE] = {0}; + disk.rawdisk_read(double_i, buffer, sizeof(buffer)); + for (int i = 0; i < IO_BLOCK_SIZE; i+=8){ + off_t addr = read_byte_at(i, buffer); + bool flag = allo_single_indirect(disk, addr, freeBlockNum); if (flag){ + write_byte_at(addr, i, buffer); + disk.rawdisk_write(double_i, buffer, sizeof(buffer)); inDouble = true; break; } @@ -177,11 +200,14 @@ public: triple_i = datablock_allocate_in_list(disk); } bool inTriple = false; - char buffer[512] = {0}; - disk.rawdisk_read(triple_i*512, buffer, sizeof(buffer)); - for (int i = 0; i < 512, i++){ - bool flag = allo_double_indirect(disk, buffer[i], freeBlockNum); + char buffer[IO_BLOCK_SIZE] = {0}; + disk.rawdisk_read(triple_i, buffer, sizeof(buffer)); + for (int i = 0; i < IO_BLOCK_SIZE, i+=8){ + off_t addr = read_byte_at(i, buffer); + bool flag = allo_double_indirect(disk, addr, freeBlockNum); if (flag){ + write_byte_at(addr, i, buffer); + disk.rawdisk_write(triple_i, buffer, sizeof(buffer)); inTriple = true; break; } @@ -220,77 +246,118 @@ public: } void datablock_deallocate_in_list(off_t freeBlockNum) { + // find the related 2048block head + // mark it alive in its bitmap + + // if its bitmap was 0, add it back to the list head } - bool deallow_single_indirect(RawDisk &disk, off_t &single_i){ + off_t deallo_single_indirect(RawDisk &disk, off_t &single_i){ if (single_i == 0){ - return false; + return 0; } - char buffer[512] = {0}; + off_t freeBlockNum = 0; + char buffer[IO_BLOCK_SIZE] = {0}; int delpoint = -1; - disk.rawdisk_read(single_i*512, buffer, sizeof(buffer)); - for (int i=255; i >= 0; i--) - if(buffer[i] != 0){ - buffer[i] = 0; + disk.rawdisk_read(single_i, buffer, sizeof(buffer)); + for (int i=4088; i >= 0; i--){ + off_t addr = read_byte_at(i, buffer); + if(addr != 0){ + freeBlockNum = addr; + addr = 0; + write_byte_at(addr, i, buffer); delpoint = i; break; } - if (delpoint == 0 && buffer[0] == 0){ + } + disk.rawdisk_read(triple_i, buffer, sizeof(buffer)); + off_t addr = read_byte_at(0, buffer); + if (delpoint == 0 && addr == 0){ datablock_deallocate_in_list(single_i); single_i = 0; } - return true; + return freeBlockNum; } - bool deallow_double_indirect(RawDisk &disk, off_t &double_i){ + bool deallo_double_indirect(RawDisk &disk, off_t &double_i){ if (double_i == 0){ return false; } - char buffer[512] = {0}; + off_t freeBlockNum = 0; + char buffer[IO_BLOCK_SIZE] = {0}; int delpoint = -1; - disk.rawdisk_read(double_i*512, buffer, sizeof(buffer)); - for (int i=255; i >= 0; i--){ - bool inSingle = deallo_single_indirect(disk, buffer[i]); + disk.rawdisk_read(double_i, buffer, sizeof(buffer)); + for (int i=4088; i >= 0; i-=8){ + off_t addr = read_byte_at(i, buffer); + off_t inSingle = deallo_single_indirect(disk, addr); if (inSingle){ + freeBlockNum = inSingle; + write_byte_at(addr, i, buffer); delpoint = i; break; } } - if (delpoint == 0 && buffer[0] == 0){ + disk.rawdisk_read(triple_i, buffer, sizeof(buffer)); + off_t addr = read_byte_at(0, buffer); + if (delpoint == 0 && addr == 0){ datablock_deallocate_in_list(double_i); double_i = 0; } - return true; + return freeBlockNum; } bool deallo_triple_indirect(RawDisk &disk, off_t &triple_i){ if (triple_i == 0){ return false; } - char buffer[512] = {0}; + off_t freeBlockNum = 0; + char buffer[IO_BLOCK_SIZE] = {0}; int delpoint = -1; - disk.rawdisk_read(triple_i*512, buffer, sizeof(buffer)); - for (int i=255; i >= 0; i--){ - bool inDouble = deallo_double_indirect(disk, buffer[i]); + disk.rawdisk_read(triple_i, buffer, sizeof(buffer)); + for (int i=4088; i >= 0; i-=8){ + off_t addr = read_byte_at(i, buffer); + off_t inDouble = deallo_double_indirect(disk, addr); if (inDouble){ + freeBlockNum = inDouble; + write_byte_at(addr, i, buffer); delpoint = i; break; } } - if (delpoint == 0 && buffer[0] == 0){ + disk.rawdisk_read(triple_i, buffer, sizeof(buffer)); + off_t addr = read_byte_at(0, buffer); + if (delpoint == 0 && addr == 0){ datablock_deallocate_in_list(triple_i); triple_i = 0; } - return true; + return freeBlockNum; } // deallocate 1 datablock from the end of the file void datablock_deallocate(RawDisk &disk){ // find the last datablock and remove it from inode (triple->direct) - + off_t freeBlockNum = 0; + freeBlockNum = deallo_triple_indirect(disk, triple_indirect); + if(!freeBlockNum){ + freeBlockNum = deallo_double_indirect(disk, double_indirect); + if(!freeBlockNum){ + freeBlockNum = deallo_single_indirect(disk, single_indirect); + if(!freeBlockNum){ + for(int i = 47; i>=0; i--) + if(blocks[i] != 0){ + freeBlockNum = block[i]; + blocks[i] = 0; + break; + } + // deal with empty + } + } + } // add it back to freeBlocklist + datablock_deallocate_in_list(freeBlockNum); + inode_save(disk); } }; @@ -300,17 +367,17 @@ class INodeOperation{ public: //initialization of the rawdisk void initialize(RawDisk &disk){ - SuperBlock::writeFreeListHead(disk, MAX_INODE); // maximum inode number 2^19 0x80000 + SuperBlock::writeFreeListHead(disk, MAX_INODE*SECTOR_SIZE); // 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; + for (off_t i = MAX_INODE; i < MAX_BLOCKNUM-4096; i += 2048*8){ + char buffer[IO_BLOCK_SIZE] = {0}; + off_t t = (i + 2048*8)*SECTOR_SIZE; if (t < MAX_BLOCKNUM){ for (int j = 0; j < 8; j++){ buffer[j] = (t >> (8 * j)) & 0xFF; } } - disk.rawdisk_write(i*512, buffer, sizeof(buffer)); + disk.rawdisk_write(i*SECTOR_SIZE, buffer, sizeof(buffer)); } } From 91ec52e7187ee9094597177847dd4382972db905 Mon Sep 17 00:00:00 2001 From: FactorialN Date: Tue, 7 Nov 2023 23:09:59 -0800 Subject: [PATCH 07/17] implemented deallo list operation --- include/fs.h | 23 +++++++++++++++++++---- 1 file changed, 19 insertions(+), 4 deletions(-) diff --git a/include/fs.h b/include/fs.h index 52e2eb6..dd26e07 100644 --- a/include/fs.h +++ b/include/fs.h @@ -148,9 +148,7 @@ public: } } if (!notFull){ - off_t next_header = 0; - for (int j = 0; j < 8; j++) - next_header = next_header | (((off_t)buffer[j])<<(8*j)); + off_t next_header = read_byte_at(0, buffer); SuperBlock::writeFreeListHead(disk, next_header); } return freeBlockNum; @@ -247,10 +245,27 @@ public: void datablock_deallocate_in_list(off_t freeBlockNum) { // find the related 2048block head + off_t freeBlockHead = ((freeBlockNum/SECTOR_SIZE-MAX_INODE)/(8*2048)*(8*2048)+MAX_INODE)*SECTOR_SIZE; // mark it alive in its bitmap - + char buffer[IO_BLOCK_SIZE] = {0}; + bool notEmpty = false; + disk.rawdisk_read(freeBlockHead, buffer, sizeof(buffer)); + for (int i = 8; i < 264; i++){ + if(buffer[i] != 0){ + notEmpty = true; + } + } + off_t inBlockPos = (freeBlockNum-freeBlockHead)/IO_BLOCK_SIZE-1; + buffer[8+inBlockPos/8] |= (1<<(inBlockPos%8)); + // if its bitmap was 0, add it back to the list head + if(!notEmpty){ + off_t freeListHead = SuperBlock::getFreeListHead(disk); + write_byte_at(freeListHead, 0, buffer); + SuperBlock::writeFreeListHead(disk, freeBlockHead); + } + disk.rawdisk_write(freeBlockHead, buffer, sizeof(buffer)); } off_t deallo_single_indirect(RawDisk &disk, off_t &single_i){ From 5eb9fcdbdabf9fd3ec6622a564830eec99222104 Mon Sep 17 00:00:00 2001 From: FactorialN Date: Tue, 7 Nov 2023 23:33:52 -0800 Subject: [PATCH 08/17] implemented inode list operation --- include/fs.h | 57 ++++++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 49 insertions(+), 8 deletions(-) diff --git a/include/fs.h b/include/fs.h index dd26e07..df925a9 100644 --- a/include/fs.h +++ b/include/fs.h @@ -22,7 +22,7 @@ public: } static off_t getFreeListHead(RawDisk &disk){ - char buffer[SECTOR_SIZE] = {0}; + char buffer[8] = {0}; disk.rawdisk_read(0, buffer, sizeof(buffer)); off_t t = 0; for (int j = 0; j < 8; j++) @@ -31,12 +31,29 @@ public: } static void writeFreeListHead(RawDisk &disk, off_t t){ - char buffer[SECTOR_SIZE] = {0}; + char buffer[8] = {0}; for (int j = 0; j < 8; j++){ buffer[j] = (t >> (8 * j)) & 0xFF; } disk.rawdisk_write(0, buffer, sizeof(buffer)); } + + static off_t getFreeINodeHead(RawDisk &disk){ + char buffer[8] = {0}; + disk.rawdisk_read(8, 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 writeFreeINodeHead(RawDisk &disk, off_t t){ + char buffer[8] = {0}; + for (int j = 0; j < 8; j++){ + buffer[j] = (t >> (8 * j)) & 0xFF; + } + disk.rawdisk_write(8, buffer, sizeof(buffer)); + } }; class INode{ @@ -382,6 +399,18 @@ class INodeOperation{ public: //initialization of the rawdisk void initialize(RawDisk &disk){ + // initialize Inode list head + SuperBlock::writeFreeINodeHead(disk, 1); + for (off_t i = 1; i < MAX_INODE; i++){ + char buffer[SECTOR_SIZE] = {0}; + off_t t = i + 1; + if (t < MAX_INODE){ + for (int j = 0; j < 8; j++){ + buffer[j] = (t >> (8 * j)) & 0xFF; + } + } + disk.rawdisk_write(i*SECTOR_SIZE, buffer, sizeof(buffer)); + } SuperBlock::writeFreeListHead(disk, MAX_INODE*SECTOR_SIZE); // 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-4096; i += 2048*8){ @@ -396,16 +425,28 @@ public: } } - // allocate an inode and return the number of the inode + // allocate an inode from free inode list head and return the number of the inode // the i-th inode is in the i-th block - off_t inode_allocate(){ - + off_t inode_allocate(RawDisk &disk){ + off_t freeINodeHead = SuperBlock::getFreeINodeHead(disk); + char buffer[SECTOR_SIZE] = {0}; + disk.rawdisk_read(freeINodeHead*SECTOR_SIZE, buffer, sizeof(buffer)); + off_t newINodeHead = read_byte_at(0, buffer); + // deal with no more INode + SuperBlock::writeFreeINodeHead(disk, newINodeHead); + //to do: initialize the INode on disk at freeINodeHead + //return inode number + return freeINodeHead; } - // - void inode_free(off_t iNodeNumber){ - + // free the inode and add it to the free inode list head + void inode_free(RawDisk &disk, off_t INodeNumber){ + off_t freeINodeHead = SuperBlock::getFreeINodeHead(disk); + char buffer[SECTOR_SIZE] = {0}; + write_byte_at(freeINodeHead, 0, buffer); + disk.rawdisk_write(INodeNumber*SECTOR_SIZE, buffer, sizeof(buffer)); + SuperBlock::writeFreeINodeHead(disk, INodeNumber); } //ignore for now From fda144c3530327073b48f6b254ef75f740f3f8e4 Mon Sep 17 00:00:00 2001 From: Victor Date: Sat, 11 Nov 2023 13:10:07 -0800 Subject: [PATCH 09/17] fix bugs e.g. static function, disk argument, address offset and add test API code --- include/fs.h | 31 +++++++++++++------------ test/CMakeLists.txt | 8 ++++++- test/layer1_API.cpp | 55 +++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 77 insertions(+), 17 deletions(-) create mode 100644 test/layer1_API.cpp diff --git a/include/fs.h b/include/fs.h index df925a9..04561af 100644 --- a/include/fs.h +++ b/include/fs.h @@ -10,7 +10,7 @@ one inode equipped with one 512 bytes block #define SECTOR_SIZE 512 #define IO_BLOCK_SIZE 4096 #define MAX_INODE 524288 -#define MAX_BLOCKNUM 62914560 +#define MAX_BLOCKNUM MAX_INODE*2 //62914560 class SuperBlock{ @@ -77,7 +77,7 @@ public: current_pos += 8; } - off_t read_byte_at(int current_pos, char *buffer){ + static off_t read_byte_at(int current_pos, char *buffer){ off_t t = 0; for (int j = 0; j < 8; j++) t = t | (((off_t)buffer[j+current_pos])<<(8*j)); @@ -110,7 +110,7 @@ public: current_pos += 8; } - void write_byte_at(off_t t, int current_pos, char *buffer){ + static void write_byte_at(off_t t, int current_pos, char *buffer){ for (int j = 0; j < 8; j++){ buffer[j+current_pos] = t & (((off_t)1<<(8))-1); t >>= 8; @@ -217,7 +217,7 @@ public: bool inTriple = false; char buffer[IO_BLOCK_SIZE] = {0}; disk.rawdisk_read(triple_i, buffer, sizeof(buffer)); - for (int i = 0; i < IO_BLOCK_SIZE, i+=8){ + for (int i = 0; i < IO_BLOCK_SIZE; i+=8){ off_t addr = read_byte_at(i, buffer); bool flag = allo_double_indirect(disk, addr, freeBlockNum); if (flag){ @@ -260,7 +260,7 @@ public: return freeBlockNum; } - void datablock_deallocate_in_list(off_t freeBlockNum) { + void datablock_deallocate_in_list(off_t freeBlockNum, RawDisk &disk) { // find the related 2048block head off_t freeBlockHead = ((freeBlockNum/SECTOR_SIZE-MAX_INODE)/(8*2048)*(8*2048)+MAX_INODE)*SECTOR_SIZE; @@ -306,7 +306,7 @@ public: disk.rawdisk_read(triple_i, buffer, sizeof(buffer)); off_t addr = read_byte_at(0, buffer); if (delpoint == 0 && addr == 0){ - datablock_deallocate_in_list(single_i); + datablock_deallocate_in_list(single_i, disk); single_i = 0; } return freeBlockNum; @@ -333,7 +333,7 @@ public: disk.rawdisk_read(triple_i, buffer, sizeof(buffer)); off_t addr = read_byte_at(0, buffer); if (delpoint == 0 && addr == 0){ - datablock_deallocate_in_list(double_i); + datablock_deallocate_in_list(double_i, disk); double_i = 0; } return freeBlockNum; @@ -360,7 +360,7 @@ public: disk.rawdisk_read(triple_i, buffer, sizeof(buffer)); off_t addr = read_byte_at(0, buffer); if (delpoint == 0 && addr == 0){ - datablock_deallocate_in_list(triple_i); + datablock_deallocate_in_list(triple_i, disk); triple_i = 0; } return freeBlockNum; @@ -378,7 +378,7 @@ public: if(!freeBlockNum){ for(int i = 47; i>=0; i--) if(blocks[i] != 0){ - freeBlockNum = block[i]; + freeBlockNum = blocks[i]; blocks[i] = 0; break; } @@ -388,7 +388,7 @@ public: } // add it back to freeBlocklist - datablock_deallocate_in_list(freeBlockNum); + datablock_deallocate_in_list(freeBlockNum, disk); inode_save(disk); } }; @@ -416,10 +416,9 @@ public: for (off_t i = MAX_INODE; i < MAX_BLOCKNUM-4096; i += 2048*8){ char buffer[IO_BLOCK_SIZE] = {0}; off_t t = (i + 2048*8)*SECTOR_SIZE; - if (t < MAX_BLOCKNUM){ - for (int j = 0; j < 8; j++){ - buffer[j] = (t >> (8 * j)) & 0xFF; - } + //t is address, storing in to buffer + for (int j = 0; j < 8; j++){ + buffer[j] = (t >> (8 * j)) & 0xFF; } disk.rawdisk_write(i*SECTOR_SIZE, buffer, sizeof(buffer)); } @@ -431,7 +430,7 @@ public: off_t freeINodeHead = SuperBlock::getFreeINodeHead(disk); char buffer[SECTOR_SIZE] = {0}; disk.rawdisk_read(freeINodeHead*SECTOR_SIZE, buffer, sizeof(buffer)); - off_t newINodeHead = read_byte_at(0, buffer); + off_t newINodeHead = INode::read_byte_at(0, buffer); // deal with no more INode SuperBlock::writeFreeINodeHead(disk, newINodeHead); //to do: initialize the INode on disk at freeINodeHead @@ -444,7 +443,7 @@ public: void inode_free(RawDisk &disk, off_t INodeNumber){ off_t freeINodeHead = SuperBlock::getFreeINodeHead(disk); char buffer[SECTOR_SIZE] = {0}; - write_byte_at(freeINodeHead, 0, buffer); + INode::write_byte_at(freeINodeHead, 0, buffer); disk.rawdisk_write(INodeNumber*SECTOR_SIZE, buffer, sizeof(buffer)); SuperBlock::writeFreeINodeHead(disk, INodeNumber); } diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 4ff961f..b946592 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -1,4 +1,5 @@ set(TARGET_LAYER0 test_layer0) +set(TARGET_LAYER1_API test_layer1_API) set(DIR_PLACE /dev/vdb) # add test sources here ... @@ -6,6 +7,11 @@ add_executable(${TARGET_LAYER0} # add need lib and source code here layer0.cpp ) +add_executable(${TARGET_LAYER1_API} + # add need lib and source code here + layer1_API.cpp +) # add test to activate ctest -VV -add_test(NAME ${TARGET_LAYER0} COMMAND sudo ./${TARGET_LAYER0} ${DIR_PLACE}) \ No newline at end of file +add_test(NAME ${TARGET_LAYER0} COMMAND sudo ./${TARGET_LAYER0} ${DIR_PLACE}) +add_test(NAME ${TARGET_LAYER1_API} COMMAND sudo ./${TARGET_LAYER1_API} ${DIR_PLACE}) \ No newline at end of file diff --git a/test/layer1_API.cpp b/test/layer1_API.cpp new file mode 100644 index 0000000..94719aa --- /dev/null +++ b/test/layer1_API.cpp @@ -0,0 +1,55 @@ +#include +#include +#include +#include "fs.h" +#include + +int main(int argc, char *argv[]) { + const char* d = (argc < 2) ? "/dev/vdc" : argv[1]; + + RawDisk *H = new RawDisk(d); + + printf("test inode\n"); + INodeOperation inop; + inop.initialize(*H); + char buffer[8] = {0}; + //test the begining of inode 1~524287 + H->rawdisk_read((1) * SECTOR_SIZE, buffer, sizeof(buffer)); + off_t t = 0; + for (int j = 0; j < 8; j++) + t |= ((off_t)(unsigned char)buffer[j]) << (8 * j); + + assert(t == 2); + //test the number before end of inode 524286 + H->rawdisk_read((MAX_INODE - 2) * SECTOR_SIZE, buffer, sizeof(buffer)); + t = 0; + for (int j = 0; j < 8; j++) + t |= ((off_t)(unsigned char)buffer[j]) << (8 * j); + + assert(t == MAX_INODE - 1); + //test the end of inode 1~524287 + H->rawdisk_read((MAX_INODE - 1) * SECTOR_SIZE, buffer, sizeof(buffer)); + t = 0; + for (int j = 0; j < 8; j++) + t |= ((off_t)(unsigned char)buffer[j]) << (8 * j); + + assert(t == 0); + //test the begining of datablock + H->rawdisk_read((MAX_INODE) * SECTOR_SIZE, buffer, sizeof(buffer)); + t = 0; + for (int j = 0; j < 8; j++) + t |= ((off_t)(unsigned char)buffer[j]) << (8 * j); + + assert(t == (MAX_INODE+2048*8)*SECTOR_SIZE); + //test the end of the datablock + H->rawdisk_read((MAX_BLOCKNUM - 2048*8) * SECTOR_SIZE, buffer, sizeof(buffer)); + t = 0; + for (int j = 0; j < 8; j++) + t |= ((off_t)(unsigned char)buffer[j]) << (8 * j); + + assert(t == (MAX_BLOCKNUM)*SECTOR_SIZE); + + delete H; // Delete the RawDisk object + + return 0; +} From bb98bb9487906ab85be9acbc2462096340e71081 Mon Sep 17 00:00:00 2001 From: FactorialN Date: Sat, 11 Nov 2023 13:32:11 -0800 Subject: [PATCH 10/17] changed type of off_t to unsigned --- include/rawdisk.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/include/rawdisk.h b/include/rawdisk.h index efd45ed..344777e 100644 --- a/include/rawdisk.h +++ b/include/rawdisk.h @@ -6,6 +6,8 @@ #include #include +typedef unsigned long long off_t; + class RawDisk{ int fd; From 350c00fd403d5f43cb68759491c7de3931be5a2d Mon Sep 17 00:00:00 2001 From: FactorialN Date: Sat, 11 Nov 2023 13:38:54 -0800 Subject: [PATCH 11/17] changed type of off_t to u_int64_t --- include/fs.h | 136 ++++++++++++++++++++++---------------------- include/rawdisk.h | 14 ++--- test/layer0.cpp | 4 +- test/layer1_API.cpp | 12 ++-- 4 files changed, 82 insertions(+), 84 deletions(-) diff --git a/include/fs.h b/include/fs.h index 04561af..19ba178 100644 --- a/include/fs.h +++ b/include/fs.h @@ -21,16 +21,16 @@ public: ~SuperBlock(){ } - static off_t getFreeListHead(RawDisk &disk){ + static u_int64_t getFreeListHead(RawDisk &disk){ char buffer[8] = {0}; disk.rawdisk_read(0, buffer, sizeof(buffer)); - off_t t = 0; + u_int64_t t = 0; for (int j = 0; j < 8; j++) - t = t | (((off_t)buffer[j])<<(8*j)); + t = t | (((u_int64_t)buffer[j])<<(8*j)); return t; } - static void writeFreeListHead(RawDisk &disk, off_t t){ + static void writeFreeListHead(RawDisk &disk, u_int64_t t){ char buffer[8] = {0}; for (int j = 0; j < 8; j++){ buffer[j] = (t >> (8 * j)) & 0xFF; @@ -38,16 +38,16 @@ public: disk.rawdisk_write(0, buffer, sizeof(buffer)); } - static off_t getFreeINodeHead(RawDisk &disk){ + static u_int64_t getFreeINodeHead(RawDisk &disk){ char buffer[8] = {0}; disk.rawdisk_read(8, buffer, sizeof(buffer)); - off_t t = 0; + u_int64_t t = 0; for (int j = 0; j < 8; j++) - t = t | (((off_t)buffer[j])<<(8*j)); + t = t | (((u_int64_t)buffer[j])<<(8*j)); return t; } - static void writeFreeINodeHead(RawDisk &disk, off_t t){ + static void writeFreeINodeHead(RawDisk &disk, u_int64_t t){ char buffer[8] = {0}; for (int j = 0; j < 8; j++){ buffer[j] = (t >> (8 * j)) & 0xFF; @@ -58,33 +58,33 @@ public: class INode{ // direct datablocks - off_t blocks[48]; + u_int64_t blocks[48]; // indirect address - off_t single_indirect, double_indirect, triple_indirect; + u_int64_t single_indirect, double_indirect, triple_indirect; // other - off_t uid; - off_t gid; - off_t permissions; - off_t size; - off_t block_number; + u_int64_t uid; + u_int64_t gid; + u_int64_t permissions; + u_int64_t size; + u_int64_t block_number; public: - void read_get_byte(off_t &t, int ¤t_pos, char *buffer){ + void read_get_byte(u_int64_t &t, int ¤t_pos, char *buffer){ t = 0; for (int j = 0; j < 8; j++) - t = t | (((off_t)buffer[j+current_pos])<<(8*j)); + t = t | (((u_int64_t)buffer[j+current_pos])<<(8*j)); current_pos += 8; } - static off_t read_byte_at(int current_pos, char *buffer){ - off_t t = 0; + static u_int64_t read_byte_at(int current_pos, char *buffer){ + u_int64_t t = 0; for (int j = 0; j < 8; j++) - t = t | (((off_t)buffer[j+current_pos])<<(8*j)); + t = t | (((u_int64_t)buffer[j+current_pos])<<(8*j)); return t; } - void inode_construct(off_t blockNumber, RawDisk &disk){ + void inode_construct(u_int64_t blockNumber, RawDisk &disk){ char buffer[SECTOR_SIZE] = {0}; disk.rawdisk_read(blockNumber*SECTOR_SIZE, buffer, sizeof(buffer)); block_number = blockNumber; @@ -102,17 +102,17 @@ public: read_get_byte(size, current_pos, buffer); } - void write_get_byte(off_t t, int ¤t_pos, char *buffer){ + void write_get_byte(u_int64_t t, int ¤t_pos, char *buffer){ for (int j = 0; j < 8; j++){ - buffer[j+current_pos] = t & (((off_t)1<<(8))-1); + buffer[j+current_pos] = t & (((u_int64_t)1<<(8))-1); t >>= 8; } current_pos += 8; } - static void write_byte_at(off_t t, int current_pos, char *buffer){ + static void write_byte_at(u_int64_t t, int current_pos, char *buffer){ for (int j = 0; j < 8; j++){ - buffer[j+current_pos] = t & (((off_t)1<<(8))-1); + buffer[j+current_pos] = t & (((u_int64_t)1<<(8))-1); t >>= 8; } } @@ -133,16 +133,16 @@ public: disk.rawdisk_write(block_number*SECTOR_SIZE, buffer, sizeof(buffer)); } - off_t datablock_allocate_in_list(RawDisk &disk){ + u_int64_t datablock_allocate_in_list(RawDisk &disk){ //find a free data block - off_t freeListHead = SuperBlock::getFreeListHead(disk); + u_int64_t freeListHead = SuperBlock::getFreeListHead(disk); /* 1. initialization 2. data block starting position 3. r/w between storage and rawdisk to maintain */ char buffer[IO_BLOCK_SIZE] = {0}; - off_t freeBlockNum = 0; + u_int64_t freeBlockNum = 0; disk.rawdisk_read(freeListHead, buffer, sizeof(buffer)); for (int i = 8; i < 264; i++){ if(buffer[i] != 255){ @@ -165,13 +165,13 @@ public: } } if (!notFull){ - off_t next_header = read_byte_at(0, buffer); + u_int64_t next_header = read_byte_at(0, buffer); SuperBlock::writeFreeListHead(disk, next_header); } return freeBlockNum; } - bool allo_single_indirect(RawDisk &disk, off_t &single_i, off_t freeBlockNum) { + bool allo_single_indirect(RawDisk &disk, u_int64_t &single_i, u_int64_t freeBlockNum) { if (single_i == 0){ single_i = datablock_allocate_in_list(disk); } @@ -179,7 +179,7 @@ public: char buffer[IO_BLOCK_SIZE] = {0}; disk.rawdisk_read(single_i, buffer, sizeof(buffer)); for (int i = 0; i < IO_BLOCK_SIZE; i+=8){ - off_t addr = read_byte_at(i, buffer); + u_int64_t addr = read_byte_at(i, buffer); if(addr == 0){ inSingle = true; write_byte_at(freeBlockNum, i, buffer); @@ -190,7 +190,7 @@ public: return inSingle; } - bool allo_double_indirect(RawDisk &disk, off_t &double_i, off_t freeBlockNum) { + bool allo_double_indirect(RawDisk &disk, u_int64_t &double_i, u_int64_t freeBlockNum) { if (double_i == 0){ double_i = datablock_allocate_in_list(disk); } @@ -198,7 +198,7 @@ public: char buffer[IO_BLOCK_SIZE] = {0}; disk.rawdisk_read(double_i, buffer, sizeof(buffer)); for (int i = 0; i < IO_BLOCK_SIZE; i+=8){ - off_t addr = read_byte_at(i, buffer); + u_int64_t addr = read_byte_at(i, buffer); bool flag = allo_single_indirect(disk, addr, freeBlockNum); if (flag){ write_byte_at(addr, i, buffer); @@ -210,7 +210,7 @@ public: return inDouble; } - bool allo_triple_indirect(RawDisk &disk, off_t &triple_i, off_t freeBlockNum) { + bool allo_triple_indirect(RawDisk &disk, u_int64_t &triple_i, u_int64_t freeBlockNum) { if (triple_i == 0){ triple_i = datablock_allocate_in_list(disk); } @@ -218,7 +218,7 @@ public: char buffer[IO_BLOCK_SIZE] = {0}; disk.rawdisk_read(triple_i, buffer, sizeof(buffer)); for (int i = 0; i < IO_BLOCK_SIZE; i+=8){ - off_t addr = read_byte_at(i, buffer); + u_int64_t addr = read_byte_at(i, buffer); bool flag = allo_double_indirect(disk, addr, freeBlockNum); if (flag){ write_byte_at(addr, i, buffer); @@ -232,11 +232,11 @@ public: // allowcate 1 datablock and add to the end of the file - off_t datablock_allocate(RawDisk &disk){ + u_int64_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(disk); + u_int64_t freeBlockNum = datablock_allocate_in_list(disk); bool inBlocks = false; for (int i = 0; i < 48; i++) if(blocks[i] == 0){ @@ -260,9 +260,9 @@ public: return freeBlockNum; } - void datablock_deallocate_in_list(off_t freeBlockNum, RawDisk &disk) { + void datablock_deallocate_in_list(u_int64_t freeBlockNum, RawDisk &disk) { // find the related 2048block head - off_t freeBlockHead = ((freeBlockNum/SECTOR_SIZE-MAX_INODE)/(8*2048)*(8*2048)+MAX_INODE)*SECTOR_SIZE; + u_int64_t freeBlockHead = ((freeBlockNum/SECTOR_SIZE-MAX_INODE)/(8*2048)*(8*2048)+MAX_INODE)*SECTOR_SIZE; // mark it alive in its bitmap char buffer[IO_BLOCK_SIZE] = {0}; @@ -273,28 +273,28 @@ public: notEmpty = true; } } - off_t inBlockPos = (freeBlockNum-freeBlockHead)/IO_BLOCK_SIZE-1; + u_int64_t inBlockPos = (freeBlockNum-freeBlockHead)/IO_BLOCK_SIZE-1; buffer[8+inBlockPos/8] |= (1<<(inBlockPos%8)); // if its bitmap was 0, add it back to the list head if(!notEmpty){ - off_t freeListHead = SuperBlock::getFreeListHead(disk); + u_int64_t freeListHead = SuperBlock::getFreeListHead(disk); write_byte_at(freeListHead, 0, buffer); SuperBlock::writeFreeListHead(disk, freeBlockHead); } disk.rawdisk_write(freeBlockHead, buffer, sizeof(buffer)); } - off_t deallo_single_indirect(RawDisk &disk, off_t &single_i){ + u_int64_t deallo_single_indirect(RawDisk &disk, u_int64_t &single_i){ if (single_i == 0){ return 0; } - off_t freeBlockNum = 0; + u_int64_t freeBlockNum = 0; char buffer[IO_BLOCK_SIZE] = {0}; int delpoint = -1; disk.rawdisk_read(single_i, buffer, sizeof(buffer)); for (int i=4088; i >= 0; i--){ - off_t addr = read_byte_at(i, buffer); + u_int64_t addr = read_byte_at(i, buffer); if(addr != 0){ freeBlockNum = addr; addr = 0; @@ -303,8 +303,8 @@ public: break; } } - disk.rawdisk_read(triple_i, buffer, sizeof(buffer)); - off_t addr = read_byte_at(0, buffer); + disk.rawdisk_write(single_i, buffer, sizeof(buffer)); + u_int64_t addr = read_byte_at(0, buffer); if (delpoint == 0 && addr == 0){ datablock_deallocate_in_list(single_i, disk); single_i = 0; @@ -312,17 +312,17 @@ public: return freeBlockNum; } - bool deallo_double_indirect(RawDisk &disk, off_t &double_i){ + bool deallo_double_indirect(RawDisk &disk, u_int64_t &double_i){ if (double_i == 0){ return false; } - off_t freeBlockNum = 0; + u_int64_t freeBlockNum = 0; char buffer[IO_BLOCK_SIZE] = {0}; int delpoint = -1; disk.rawdisk_read(double_i, buffer, sizeof(buffer)); for (int i=4088; i >= 0; i-=8){ - off_t addr = read_byte_at(i, buffer); - off_t inSingle = deallo_single_indirect(disk, addr); + u_int64_t addr = read_byte_at(i, buffer); + u_int64_t inSingle = deallo_single_indirect(disk, addr); if (inSingle){ freeBlockNum = inSingle; write_byte_at(addr, i, buffer); @@ -330,8 +330,8 @@ public: break; } } - disk.rawdisk_read(triple_i, buffer, sizeof(buffer)); - off_t addr = read_byte_at(0, buffer); + disk.rawdisk_write(double_i, buffer, sizeof(buffer)); + u_int64_t addr = read_byte_at(0, buffer); if (delpoint == 0 && addr == 0){ datablock_deallocate_in_list(double_i, disk); double_i = 0; @@ -339,17 +339,17 @@ public: return freeBlockNum; } - bool deallo_triple_indirect(RawDisk &disk, off_t &triple_i){ + bool deallo_triple_indirect(RawDisk &disk, u_int64_t &triple_i){ if (triple_i == 0){ return false; } - off_t freeBlockNum = 0; + u_int64_t freeBlockNum = 0; char buffer[IO_BLOCK_SIZE] = {0}; int delpoint = -1; disk.rawdisk_read(triple_i, buffer, sizeof(buffer)); for (int i=4088; i >= 0; i-=8){ - off_t addr = read_byte_at(i, buffer); - off_t inDouble = deallo_double_indirect(disk, addr); + u_int64_t addr = read_byte_at(i, buffer); + u_int64_t inDouble = deallo_double_indirect(disk, addr); if (inDouble){ freeBlockNum = inDouble; write_byte_at(addr, i, buffer); @@ -357,8 +357,8 @@ public: break; } } - disk.rawdisk_read(triple_i, buffer, sizeof(buffer)); - off_t addr = read_byte_at(0, buffer); + disk.rawdisk_write(triple_i, buffer, sizeof(buffer)); + u_int64_t addr = read_byte_at(0, buffer); if (delpoint == 0 && addr == 0){ datablock_deallocate_in_list(triple_i, disk); triple_i = 0; @@ -369,7 +369,7 @@ public: // deallocate 1 datablock from the end of the file void datablock_deallocate(RawDisk &disk){ // find the last datablock and remove it from inode (triple->direct) - off_t freeBlockNum = 0; + u_int64_t freeBlockNum = 0; freeBlockNum = deallo_triple_indirect(disk, triple_indirect); if(!freeBlockNum){ freeBlockNum = deallo_double_indirect(disk, double_indirect); @@ -401,9 +401,9 @@ public: void initialize(RawDisk &disk){ // initialize Inode list head SuperBlock::writeFreeINodeHead(disk, 1); - for (off_t i = 1; i < MAX_INODE; i++){ + for (u_int64_t i = 1; i < MAX_INODE; i++){ char buffer[SECTOR_SIZE] = {0}; - off_t t = i + 1; + u_int64_t t = i + 1; if (t < MAX_INODE){ for (int j = 0; j < 8; j++){ buffer[j] = (t >> (8 * j)) & 0xFF; @@ -413,9 +413,9 @@ public: } SuperBlock::writeFreeListHead(disk, MAX_INODE*SECTOR_SIZE); // 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-4096; i += 2048*8){ + for (u_int64_t i = MAX_INODE; i < MAX_BLOCKNUM-4096; i += 2048*8){ char buffer[IO_BLOCK_SIZE] = {0}; - off_t t = (i + 2048*8)*SECTOR_SIZE; + u_int64_t t = (i + 2048*8)*SECTOR_SIZE; //t is address, storing in to buffer for (int j = 0; j < 8; j++){ buffer[j] = (t >> (8 * j)) & 0xFF; @@ -426,11 +426,11 @@ public: // allocate an inode from free inode list head and return the number of the inode // the i-th inode is in the i-th block - off_t inode_allocate(RawDisk &disk){ - off_t freeINodeHead = SuperBlock::getFreeINodeHead(disk); + u_int64_t inode_allocate(RawDisk &disk){ + u_int64_t freeINodeHead = SuperBlock::getFreeINodeHead(disk); char buffer[SECTOR_SIZE] = {0}; disk.rawdisk_read(freeINodeHead*SECTOR_SIZE, buffer, sizeof(buffer)); - off_t newINodeHead = INode::read_byte_at(0, buffer); + u_int64_t newINodeHead = INode::read_byte_at(0, buffer); // deal with no more INode SuperBlock::writeFreeINodeHead(disk, newINodeHead); //to do: initialize the INode on disk at freeINodeHead @@ -440,8 +440,8 @@ public: } // free the inode and add it to the free inode list head - void inode_free(RawDisk &disk, off_t INodeNumber){ - off_t freeINodeHead = SuperBlock::getFreeINodeHead(disk); + void inode_free(RawDisk &disk, u_int64_t INodeNumber){ + u_int64_t freeINodeHead = SuperBlock::getFreeINodeHead(disk); char buffer[SECTOR_SIZE] = {0}; INode::write_byte_at(freeINodeHead, 0, buffer); disk.rawdisk_write(INodeNumber*SECTOR_SIZE, buffer, sizeof(buffer)); diff --git a/include/rawdisk.h b/include/rawdisk.h index 344777e..4cccf70 100644 --- a/include/rawdisk.h +++ b/include/rawdisk.h @@ -6,14 +6,12 @@ #include #include -typedef unsigned long long off_t; - class RawDisk{ int fd; const char* dir; - off_t numSectors; - off_t diskSize; + u_int64_t numSectors; + u_int64_t diskSize; public: RawDisk(const char *directory) : fd(-1), dir(nullptr), numSectors(0), diskSize(0) { @@ -50,8 +48,8 @@ public: } } - int rawdisk_read(off_t offset, char *buffer, size_t length) { - if (lseek(fd, offset, SEEK_SET) == (off_t)-1) { + int rawdisk_read(u_int64_t offset, char *buffer, size_t length) { + if (lseek(fd, offset, SEEK_SET) == (u_int64_t)-1) { perror("Error seeking to offset"); return -1; } @@ -66,8 +64,8 @@ public: } // Write a specified number of bytes at a given byte offset - int rawdisk_write(off_t offset, char *buffer, size_t length) { - if (lseek(fd, offset, SEEK_SET) == (off_t)-1) { + int rawdisk_write(u_int64_t offset, char *buffer, size_t length) { + if (lseek(fd, offset, SEEK_SET) == (u_int64_t)-1) { perror("Error seeking to offset"); return -1; } diff --git a/test/layer0.cpp b/test/layer0.cpp index be5d998..8cc358a 100644 --- a/test/layer0.cpp +++ b/test/layer0.cpp @@ -14,11 +14,11 @@ int main(int argc, char *argv[]) { //printf("dir %s, numSectors %lld, diskSize %lld \n", H->dir, H->numSectors, H->diskSize); //use number to substitute H->getnumSector(), getnumSectors() are not yest implemented - for(off_t i = 0; i < 10; i++) { + for(u_int64_t i = 0; i < 10; i++) { H->rawdisk_write(i*512, buf, strlen(buf));//Change write_API } //use number to substitute H->getnumSector(), getnumSectors() are not yest implemented - for(off_t i = 0; i < 10; i++) { + for(u_int64_t i = 0; i < 10; i++) { H->rawdisk_read(i*512, readBuffer, sizeof(readBuffer));//Change read_API assert(strncmp(readBuffer, buf, strlen(buf)) == 0); } diff --git a/test/layer1_API.cpp b/test/layer1_API.cpp index 94719aa..799a76f 100644 --- a/test/layer1_API.cpp +++ b/test/layer1_API.cpp @@ -15,37 +15,37 @@ int main(int argc, char *argv[]) { char buffer[8] = {0}; //test the begining of inode 1~524287 H->rawdisk_read((1) * SECTOR_SIZE, buffer, sizeof(buffer)); - off_t t = 0; + u_int64_t t = 0; for (int j = 0; j < 8; j++) - t |= ((off_t)(unsigned char)buffer[j]) << (8 * j); + t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); assert(t == 2); //test the number before end of inode 524286 H->rawdisk_read((MAX_INODE - 2) * SECTOR_SIZE, buffer, sizeof(buffer)); t = 0; for (int j = 0; j < 8; j++) - t |= ((off_t)(unsigned char)buffer[j]) << (8 * j); + t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); assert(t == MAX_INODE - 1); //test the end of inode 1~524287 H->rawdisk_read((MAX_INODE - 1) * SECTOR_SIZE, buffer, sizeof(buffer)); t = 0; for (int j = 0; j < 8; j++) - t |= ((off_t)(unsigned char)buffer[j]) << (8 * j); + t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); assert(t == 0); //test the begining of datablock H->rawdisk_read((MAX_INODE) * SECTOR_SIZE, buffer, sizeof(buffer)); t = 0; for (int j = 0; j < 8; j++) - t |= ((off_t)(unsigned char)buffer[j]) << (8 * j); + t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); assert(t == (MAX_INODE+2048*8)*SECTOR_SIZE); //test the end of the datablock H->rawdisk_read((MAX_BLOCKNUM - 2048*8) * SECTOR_SIZE, buffer, sizeof(buffer)); t = 0; for (int j = 0; j < 8; j++) - t |= ((off_t)(unsigned char)buffer[j]) << (8 * j); + t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); assert(t == (MAX_BLOCKNUM)*SECTOR_SIZE); From 43d1a57f12900930aad2de651ace5872612b25b5 Mon Sep 17 00:00:00 2001 From: Victor Date: Sat, 11 Nov 2023 13:55:45 -0800 Subject: [PATCH 12/17] delete assign unsigned char --- test/layer1_API.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/test/layer1_API.cpp b/test/layer1_API.cpp index 799a76f..dcc80b6 100644 --- a/test/layer1_API.cpp +++ b/test/layer1_API.cpp @@ -17,35 +17,35 @@ int main(int argc, char *argv[]) { H->rawdisk_read((1) * SECTOR_SIZE, buffer, sizeof(buffer)); u_int64_t t = 0; for (int j = 0; j < 8; j++) - t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); + t |= ((u_int64_t)buffer[j]) << (8 * j); assert(t == 2); //test the number before end of inode 524286 H->rawdisk_read((MAX_INODE - 2) * SECTOR_SIZE, buffer, sizeof(buffer)); t = 0; for (int j = 0; j < 8; j++) - t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); + t |= ((u_int64_t)buffer[j]) << (8 * j); assert(t == MAX_INODE - 1); //test the end of inode 1~524287 H->rawdisk_read((MAX_INODE - 1) * SECTOR_SIZE, buffer, sizeof(buffer)); t = 0; for (int j = 0; j < 8; j++) - t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); + t |= ((u_int64_t)buffer[j]) << (8 * j); assert(t == 0); //test the begining of datablock H->rawdisk_read((MAX_INODE) * SECTOR_SIZE, buffer, sizeof(buffer)); t = 0; for (int j = 0; j < 8; j++) - t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); + t |= ((u_int64_t)buffer[j]) << (8 * j); assert(t == (MAX_INODE+2048*8)*SECTOR_SIZE); //test the end of the datablock H->rawdisk_read((MAX_BLOCKNUM - 2048*8) * SECTOR_SIZE, buffer, sizeof(buffer)); t = 0; for (int j = 0; j < 8; j++) - t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); + t |= ((u_int64_t)buffer[j]) << (8 * j); assert(t == (MAX_BLOCKNUM)*SECTOR_SIZE); From 2fd109e1dda2db241a5a2526fb93e2762d51c51a Mon Sep 17 00:00:00 2001 From: Victor Date: Sat, 11 Nov 2023 14:27:37 -0800 Subject: [PATCH 13/17] test inode inode_allocate and free function --- test/layer1_API.cpp | 40 ++++++++++++++++++++++++++++++++++------ 1 file changed, 34 insertions(+), 6 deletions(-) diff --git a/test/layer1_API.cpp b/test/layer1_API.cpp index dcc80b6..1a569f6 100644 --- a/test/layer1_API.cpp +++ b/test/layer1_API.cpp @@ -17,38 +17,66 @@ int main(int argc, char *argv[]) { H->rawdisk_read((1) * SECTOR_SIZE, buffer, sizeof(buffer)); u_int64_t t = 0; for (int j = 0; j < 8; j++) - t |= ((u_int64_t)buffer[j]) << (8 * j); + t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); assert(t == 2); //test the number before end of inode 524286 H->rawdisk_read((MAX_INODE - 2) * SECTOR_SIZE, buffer, sizeof(buffer)); t = 0; for (int j = 0; j < 8; j++) - t |= ((u_int64_t)buffer[j]) << (8 * j); - + t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); + + fprintf(stderr,"[t %llu,%d]\n",t,__LINE__); assert(t == MAX_INODE - 1); //test the end of inode 1~524287 H->rawdisk_read((MAX_INODE - 1) * SECTOR_SIZE, buffer, sizeof(buffer)); t = 0; for (int j = 0; j < 8; j++) - t |= ((u_int64_t)buffer[j]) << (8 * j); + t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); assert(t == 0); //test the begining of datablock H->rawdisk_read((MAX_INODE) * SECTOR_SIZE, buffer, sizeof(buffer)); t = 0; for (int j = 0; j < 8; j++) - t |= ((u_int64_t)buffer[j]) << (8 * j); + t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); assert(t == (MAX_INODE+2048*8)*SECTOR_SIZE); //test the end of the datablock H->rawdisk_read((MAX_BLOCKNUM - 2048*8) * SECTOR_SIZE, buffer, sizeof(buffer)); t = 0; for (int j = 0; j < 8; j++) - t |= ((u_int64_t)buffer[j]) << (8 * j); + t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); assert(t == (MAX_BLOCKNUM)*SECTOR_SIZE); + //initialize + int inode_list[20] = {0}; + printf("Allocate 20 inode num:{"); + for(int i=0;i<20;i++){ + inode_list[i] = inop.inode_allocate(*H); + printf(" %d", inode_list[i]); + } + printf("}\n"); + //free the last 10 + printf("Free: inode num:{"); + for(int i=10;i<20;i++){ + inop.inode_free(*H,inode_list[i]); + printf(" %d", inode_list[i]); + } + printf("}\n"); + //allocate again the last 10 + printf("Allocate again: inode num:{"); + for(int i=10;i<20;i++){ + inode_list[i] = inop.inode_allocate(*H); + printf(" %d", inode_list[i]); + } + printf("}\n"); + printf("The status 20 inode num:{"); + for(int i=0;i<20;i++){ + printf(" %d", inode_list[i]); + } + printf("}\n"); delete H; // Delete the RawDisk object return 0; From 359521e12ed07636a3b07fc455c365863dfc39bc Mon Sep 17 00:00:00 2001 From: FactorialN Date: Sat, 11 Nov 2023 14:38:47 -0800 Subject: [PATCH 14/17] changed all char to unsigned char --- include/fs.h | 46 ++++++++++++++++++++++----------------------- include/rawdisk.h | 10 ++++++---- lib/main.cpp | 2 +- test/layer0.cpp | 8 ++++---- test/layer1_API.cpp | 16 ++++++++-------- 5 files changed, 42 insertions(+), 40 deletions(-) diff --git a/include/fs.h b/include/fs.h index 19ba178..2978a7e 100644 --- a/include/fs.h +++ b/include/fs.h @@ -15,14 +15,14 @@ one inode equipped with one 512 bytes block class SuperBlock{ public: - SuperBlock(const char *directory){ + SuperBlock(const uchar *directory){ } ~SuperBlock(){ } static u_int64_t getFreeListHead(RawDisk &disk){ - char buffer[8] = {0}; + uchar buffer[8] = {0}; disk.rawdisk_read(0, buffer, sizeof(buffer)); u_int64_t t = 0; for (int j = 0; j < 8; j++) @@ -31,7 +31,7 @@ public: } static void writeFreeListHead(RawDisk &disk, u_int64_t t){ - char buffer[8] = {0}; + uchar buffer[8] = {0}; for (int j = 0; j < 8; j++){ buffer[j] = (t >> (8 * j)) & 0xFF; } @@ -39,7 +39,7 @@ public: } static u_int64_t getFreeINodeHead(RawDisk &disk){ - char buffer[8] = {0}; + uchar buffer[8] = {0}; disk.rawdisk_read(8, buffer, sizeof(buffer)); u_int64_t t = 0; for (int j = 0; j < 8; j++) @@ -48,7 +48,7 @@ public: } static void writeFreeINodeHead(RawDisk &disk, u_int64_t t){ - char buffer[8] = {0}; + uchar buffer[8] = {0}; for (int j = 0; j < 8; j++){ buffer[j] = (t >> (8 * j)) & 0xFF; } @@ -70,14 +70,14 @@ class INode{ u_int64_t block_number; public: - void read_get_byte(u_int64_t &t, int ¤t_pos, char *buffer){ + void read_get_byte(u_int64_t &t, int ¤t_pos, uchar *buffer){ t = 0; for (int j = 0; j < 8; j++) t = t | (((u_int64_t)buffer[j+current_pos])<<(8*j)); current_pos += 8; } - static u_int64_t read_byte_at(int current_pos, char *buffer){ + static u_int64_t read_byte_at(int current_pos, uchar *buffer){ u_int64_t t = 0; for (int j = 0; j < 8; j++) t = t | (((u_int64_t)buffer[j+current_pos])<<(8*j)); @@ -85,7 +85,7 @@ public: } void inode_construct(u_int64_t blockNumber, RawDisk &disk){ - char buffer[SECTOR_SIZE] = {0}; + uchar buffer[SECTOR_SIZE] = {0}; disk.rawdisk_read(blockNumber*SECTOR_SIZE, buffer, sizeof(buffer)); block_number = blockNumber; int current_pos = 0; @@ -102,7 +102,7 @@ public: read_get_byte(size, current_pos, buffer); } - void write_get_byte(u_int64_t t, int ¤t_pos, char *buffer){ + void write_get_byte(u_int64_t t, int ¤t_pos, uchar *buffer){ for (int j = 0; j < 8; j++){ buffer[j+current_pos] = t & (((u_int64_t)1<<(8))-1); t >>= 8; @@ -110,7 +110,7 @@ public: current_pos += 8; } - static void write_byte_at(u_int64_t t, int current_pos, char *buffer){ + static void write_byte_at(u_int64_t t, int current_pos, uchar *buffer){ for (int j = 0; j < 8; j++){ buffer[j+current_pos] = t & (((u_int64_t)1<<(8))-1); t >>= 8; @@ -118,7 +118,7 @@ public: } void inode_save(RawDisk &disk){ - char buffer[SECTOR_SIZE] = {0}; + uchar buffer[SECTOR_SIZE] = {0}; int current_pos = 0; for (int i = 0; i < 48; i++){ write_get_byte(blocks[i], current_pos, buffer); @@ -141,7 +141,7 @@ public: 2. data block starting position 3. r/w between storage and rawdisk to maintain */ - char buffer[IO_BLOCK_SIZE] = {0}; + uchar buffer[IO_BLOCK_SIZE] = {0}; u_int64_t freeBlockNum = 0; disk.rawdisk_read(freeListHead, buffer, sizeof(buffer)); for (int i = 8; i < 264; i++){ @@ -176,7 +176,7 @@ public: single_i = datablock_allocate_in_list(disk); } bool inSingle = false; - char buffer[IO_BLOCK_SIZE] = {0}; + uchar buffer[IO_BLOCK_SIZE] = {0}; disk.rawdisk_read(single_i, buffer, sizeof(buffer)); for (int i = 0; i < IO_BLOCK_SIZE; i+=8){ u_int64_t addr = read_byte_at(i, buffer); @@ -195,7 +195,7 @@ public: double_i = datablock_allocate_in_list(disk); } bool inDouble = false; - char buffer[IO_BLOCK_SIZE] = {0}; + uchar buffer[IO_BLOCK_SIZE] = {0}; disk.rawdisk_read(double_i, buffer, sizeof(buffer)); for (int i = 0; i < IO_BLOCK_SIZE; i+=8){ u_int64_t addr = read_byte_at(i, buffer); @@ -215,7 +215,7 @@ public: triple_i = datablock_allocate_in_list(disk); } bool inTriple = false; - char buffer[IO_BLOCK_SIZE] = {0}; + uchar buffer[IO_BLOCK_SIZE] = {0}; disk.rawdisk_read(triple_i, buffer, sizeof(buffer)); for (int i = 0; i < IO_BLOCK_SIZE; i+=8){ u_int64_t addr = read_byte_at(i, buffer); @@ -265,7 +265,7 @@ public: u_int64_t freeBlockHead = ((freeBlockNum/SECTOR_SIZE-MAX_INODE)/(8*2048)*(8*2048)+MAX_INODE)*SECTOR_SIZE; // mark it alive in its bitmap - char buffer[IO_BLOCK_SIZE] = {0}; + uchar buffer[IO_BLOCK_SIZE] = {0}; bool notEmpty = false; disk.rawdisk_read(freeBlockHead, buffer, sizeof(buffer)); for (int i = 8; i < 264; i++){ @@ -290,7 +290,7 @@ public: return 0; } u_int64_t freeBlockNum = 0; - char buffer[IO_BLOCK_SIZE] = {0}; + uchar buffer[IO_BLOCK_SIZE] = {0}; int delpoint = -1; disk.rawdisk_read(single_i, buffer, sizeof(buffer)); for (int i=4088; i >= 0; i--){ @@ -317,7 +317,7 @@ public: return false; } u_int64_t freeBlockNum = 0; - char buffer[IO_BLOCK_SIZE] = {0}; + uchar buffer[IO_BLOCK_SIZE] = {0}; int delpoint = -1; disk.rawdisk_read(double_i, buffer, sizeof(buffer)); for (int i=4088; i >= 0; i-=8){ @@ -344,7 +344,7 @@ public: return false; } u_int64_t freeBlockNum = 0; - char buffer[IO_BLOCK_SIZE] = {0}; + uchar buffer[IO_BLOCK_SIZE] = {0}; int delpoint = -1; disk.rawdisk_read(triple_i, buffer, sizeof(buffer)); for (int i=4088; i >= 0; i-=8){ @@ -402,7 +402,7 @@ public: // initialize Inode list head SuperBlock::writeFreeINodeHead(disk, 1); for (u_int64_t i = 1; i < MAX_INODE; i++){ - char buffer[SECTOR_SIZE] = {0}; + uchar buffer[SECTOR_SIZE] = {0}; u_int64_t t = i + 1; if (t < MAX_INODE){ for (int j = 0; j < 8; j++){ @@ -414,7 +414,7 @@ public: SuperBlock::writeFreeListHead(disk, MAX_INODE*SECTOR_SIZE); // maximum inode number 2^19 0x80000 //Have tested this initialize function but MAX_BLOCK too much, MAX_INODE*2 works for (u_int64_t i = MAX_INODE; i < MAX_BLOCKNUM-4096; i += 2048*8){ - char buffer[IO_BLOCK_SIZE] = {0}; + uchar buffer[IO_BLOCK_SIZE] = {0}; u_int64_t t = (i + 2048*8)*SECTOR_SIZE; //t is address, storing in to buffer for (int j = 0; j < 8; j++){ @@ -428,7 +428,7 @@ public: // the i-th inode is in the i-th block u_int64_t inode_allocate(RawDisk &disk){ u_int64_t freeINodeHead = SuperBlock::getFreeINodeHead(disk); - char buffer[SECTOR_SIZE] = {0}; + uchar buffer[SECTOR_SIZE] = {0}; disk.rawdisk_read(freeINodeHead*SECTOR_SIZE, buffer, sizeof(buffer)); u_int64_t newINodeHead = INode::read_byte_at(0, buffer); // deal with no more INode @@ -442,7 +442,7 @@ public: // free the inode and add it to the free inode list head void inode_free(RawDisk &disk, u_int64_t INodeNumber){ u_int64_t freeINodeHead = SuperBlock::getFreeINodeHead(disk); - char buffer[SECTOR_SIZE] = {0}; + uchar buffer[SECTOR_SIZE] = {0}; INode::write_byte_at(freeINodeHead, 0, buffer); disk.rawdisk_write(INodeNumber*SECTOR_SIZE, buffer, sizeof(buffer)); SuperBlock::writeFreeINodeHead(disk, INodeNumber); diff --git a/include/rawdisk.h b/include/rawdisk.h index 4cccf70..73e3fb3 100644 --- a/include/rawdisk.h +++ b/include/rawdisk.h @@ -6,15 +6,17 @@ #include #include +typedef unsigned char uchar; + class RawDisk{ int fd; - const char* dir; + const uchar* dir; u_int64_t numSectors; u_int64_t diskSize; public: - RawDisk(const char *directory) : fd(-1), dir(nullptr), numSectors(0), diskSize(0) { + RawDisk(const uchar *directory) : fd(-1), dir(nullptr), numSectors(0), diskSize(0) { dir = directory; /*dir = strdup("/dev/vdc"); numSectors = 62914560; @@ -48,7 +50,7 @@ public: } } - int rawdisk_read(u_int64_t offset, char *buffer, size_t length) { + int rawdisk_read(u_int64_t offset, uchar *buffer, size_t length) { if (lseek(fd, offset, SEEK_SET) == (u_int64_t)-1) { perror("Error seeking to offset"); return -1; @@ -64,7 +66,7 @@ public: } // Write a specified number of bytes at a given byte offset - int rawdisk_write(u_int64_t offset, char *buffer, size_t length) { + int rawdisk_write(u_int64_t offset, uchar *buffer, size_t length) { if (lseek(fd, offset, SEEK_SET) == (u_int64_t)-1) { perror("Error seeking to offset"); return -1; diff --git a/lib/main.cpp b/lib/main.cpp index 396b885..c236c12 100644 --- a/lib/main.cpp +++ b/lib/main.cpp @@ -4,7 +4,7 @@ int main(){ fischl *F = new fischl; F->init(); - char *d = strdup("/dev/vdc"); + uchar *d = strdup("/dev/vdc"); RawDisk *H = new RawDisk(d); return 0; } \ No newline at end of file diff --git a/test/layer0.cpp b/test/layer0.cpp index 8cc358a..3629ed8 100644 --- a/test/layer0.cpp +++ b/test/layer0.cpp @@ -3,13 +3,13 @@ #include #include "rawdisk.h" -int main(int argc, char *argv[]) { - const char* d = (argc < 2) ? "/dev/vdc" : argv[1]; +int main(int argc, uchar *argv[]) { + const uchar* d = (argc < 2) ? "/dev/vdc" : argv[1]; RawDisk *H = new RawDisk(d); - char *buf = "iloveosdfjlseirfnerig"; - char readBuffer[512] = {0}; // Initialize to zeros + uchar *buf = "iloveosdfjlseirfnerig"; + uchar readBuffer[512] = {0}; // Initialize to zeros //printf("dir %s, numSectors %lld, diskSize %lld \n", H->dir, H->numSectors, H->diskSize); diff --git a/test/layer1_API.cpp b/test/layer1_API.cpp index 1a569f6..eb8b7e4 100644 --- a/test/layer1_API.cpp +++ b/test/layer1_API.cpp @@ -4,27 +4,27 @@ #include "fs.h" #include -int main(int argc, char *argv[]) { - const char* d = (argc < 2) ? "/dev/vdc" : argv[1]; +int main(int argc, uchar *argv[]) { + const uchar* d = (argc < 2) ? "/dev/vdc" : argv[1]; RawDisk *H = new RawDisk(d); printf("test inode\n"); INodeOperation inop; inop.initialize(*H); - char buffer[8] = {0}; + uchar buffer[8] = {0}; //test the begining of inode 1~524287 H->rawdisk_read((1) * SECTOR_SIZE, buffer, sizeof(buffer)); u_int64_t t = 0; for (int j = 0; j < 8; j++) - t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); + t |= ((u_int64_t)(uchar)buffer[j]) << (8 * j); assert(t == 2); //test the number before end of inode 524286 H->rawdisk_read((MAX_INODE - 2) * SECTOR_SIZE, buffer, sizeof(buffer)); t = 0; for (int j = 0; j < 8; j++) - t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); + t |= ((u_int64_t)(uchar)buffer[j]) << (8 * j); fprintf(stderr,"[t %llu,%d]\n",t,__LINE__); assert(t == MAX_INODE - 1); @@ -32,21 +32,21 @@ int main(int argc, char *argv[]) { H->rawdisk_read((MAX_INODE - 1) * SECTOR_SIZE, buffer, sizeof(buffer)); t = 0; for (int j = 0; j < 8; j++) - t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); + t |= ((u_int64_t)(uchar)buffer[j]) << (8 * j); assert(t == 0); //test the begining of datablock H->rawdisk_read((MAX_INODE) * SECTOR_SIZE, buffer, sizeof(buffer)); t = 0; for (int j = 0; j < 8; j++) - t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); + t |= ((u_int64_t)(uchar)buffer[j]) << (8 * j); assert(t == (MAX_INODE+2048*8)*SECTOR_SIZE); //test the end of the datablock H->rawdisk_read((MAX_BLOCKNUM - 2048*8) * SECTOR_SIZE, buffer, sizeof(buffer)); t = 0; for (int j = 0; j < 8; j++) - t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); + t |= ((u_int64_t)(uchar)buffer[j]) << (8 * j); assert(t == (MAX_BLOCKNUM)*SECTOR_SIZE); //initialize From 23c5b4da6face1a3e2407a38a4d23876e223aba7 Mon Sep 17 00:00:00 2001 From: FactorialN Date: Sat, 11 Nov 2023 14:54:22 -0800 Subject: [PATCH 15/17] recalled the uchar modification --- include/fs.h | 54 ++++++++++++++++++++++----------------------- include/rawdisk.h | 10 ++++----- lib/main.cpp | 2 +- test/layer0.cpp | 8 +++---- test/layer1_API.cpp | 16 +++++++------- 5 files changed, 44 insertions(+), 46 deletions(-) diff --git a/include/fs.h b/include/fs.h index 2978a7e..a67c516 100644 --- a/include/fs.h +++ b/include/fs.h @@ -15,23 +15,23 @@ one inode equipped with one 512 bytes block class SuperBlock{ public: - SuperBlock(const uchar *directory){ + SuperBlock(const char *directory){ } ~SuperBlock(){ } static u_int64_t getFreeListHead(RawDisk &disk){ - uchar buffer[8] = {0}; + char buffer[8] = {0}; disk.rawdisk_read(0, buffer, sizeof(buffer)); u_int64_t t = 0; for (int j = 0; j < 8; j++) - t = t | (((u_int64_t)buffer[j])<<(8*j)); + t = t | (((u_int64_t)(unsigned char)buffer[j])<<(8*j)); return t; } static void writeFreeListHead(RawDisk &disk, u_int64_t t){ - uchar buffer[8] = {0}; + char buffer[8] = {0}; for (int j = 0; j < 8; j++){ buffer[j] = (t >> (8 * j)) & 0xFF; } @@ -39,16 +39,16 @@ public: } static u_int64_t getFreeINodeHead(RawDisk &disk){ - uchar buffer[8] = {0}; + char buffer[8] = {0}; disk.rawdisk_read(8, buffer, sizeof(buffer)); u_int64_t t = 0; for (int j = 0; j < 8; j++) - t = t | (((u_int64_t)buffer[j])<<(8*j)); + t = t | (((u_int64_t)(unsigned char)buffer[j])<<(8*j)); return t; } static void writeFreeINodeHead(RawDisk &disk, u_int64_t t){ - uchar buffer[8] = {0}; + char buffer[8] = {0}; for (int j = 0; j < 8; j++){ buffer[j] = (t >> (8 * j)) & 0xFF; } @@ -70,22 +70,22 @@ class INode{ u_int64_t block_number; public: - void read_get_byte(u_int64_t &t, int ¤t_pos, uchar *buffer){ + void read_get_byte(u_int64_t &t, int ¤t_pos, char *buffer){ t = 0; for (int j = 0; j < 8; j++) - t = t | (((u_int64_t)buffer[j+current_pos])<<(8*j)); + t = t | (((u_int64_t)(unsigned char)buffer[j+current_pos])<<(8*j)); current_pos += 8; } - static u_int64_t read_byte_at(int current_pos, uchar *buffer){ + static u_int64_t read_byte_at(int current_pos, char *buffer){ u_int64_t t = 0; for (int j = 0; j < 8; j++) - t = t | (((u_int64_t)buffer[j+current_pos])<<(8*j)); + t = t | (((u_int64_t)(unsigned char)buffer[j+current_pos])<<(8*j)); return t; } void inode_construct(u_int64_t blockNumber, RawDisk &disk){ - uchar buffer[SECTOR_SIZE] = {0}; + char buffer[SECTOR_SIZE] = {0}; disk.rawdisk_read(blockNumber*SECTOR_SIZE, buffer, sizeof(buffer)); block_number = blockNumber; int current_pos = 0; @@ -102,7 +102,7 @@ public: read_get_byte(size, current_pos, buffer); } - void write_get_byte(u_int64_t t, int ¤t_pos, uchar *buffer){ + void write_get_byte(u_int64_t t, int ¤t_pos, char *buffer){ for (int j = 0; j < 8; j++){ buffer[j+current_pos] = t & (((u_int64_t)1<<(8))-1); t >>= 8; @@ -110,7 +110,7 @@ public: current_pos += 8; } - static void write_byte_at(u_int64_t t, int current_pos, uchar *buffer){ + static void write_byte_at(u_int64_t t, int current_pos, char *buffer){ for (int j = 0; j < 8; j++){ buffer[j+current_pos] = t & (((u_int64_t)1<<(8))-1); t >>= 8; @@ -118,7 +118,7 @@ public: } void inode_save(RawDisk &disk){ - uchar buffer[SECTOR_SIZE] = {0}; + char buffer[SECTOR_SIZE] = {0}; int current_pos = 0; for (int i = 0; i < 48; i++){ write_get_byte(blocks[i], current_pos, buffer); @@ -141,7 +141,7 @@ public: 2. data block starting position 3. r/w between storage and rawdisk to maintain */ - uchar buffer[IO_BLOCK_SIZE] = {0}; + char buffer[IO_BLOCK_SIZE] = {0}; u_int64_t freeBlockNum = 0; disk.rawdisk_read(freeListHead, buffer, sizeof(buffer)); for (int i = 8; i < 264; i++){ @@ -176,7 +176,7 @@ public: single_i = datablock_allocate_in_list(disk); } bool inSingle = false; - uchar buffer[IO_BLOCK_SIZE] = {0}; + char buffer[IO_BLOCK_SIZE] = {0}; disk.rawdisk_read(single_i, buffer, sizeof(buffer)); for (int i = 0; i < IO_BLOCK_SIZE; i+=8){ u_int64_t addr = read_byte_at(i, buffer); @@ -195,7 +195,7 @@ public: double_i = datablock_allocate_in_list(disk); } bool inDouble = false; - uchar buffer[IO_BLOCK_SIZE] = {0}; + char buffer[IO_BLOCK_SIZE] = {0}; disk.rawdisk_read(double_i, buffer, sizeof(buffer)); for (int i = 0; i < IO_BLOCK_SIZE; i+=8){ u_int64_t addr = read_byte_at(i, buffer); @@ -215,7 +215,7 @@ public: triple_i = datablock_allocate_in_list(disk); } bool inTriple = false; - uchar buffer[IO_BLOCK_SIZE] = {0}; + char buffer[IO_BLOCK_SIZE] = {0}; disk.rawdisk_read(triple_i, buffer, sizeof(buffer)); for (int i = 0; i < IO_BLOCK_SIZE; i+=8){ u_int64_t addr = read_byte_at(i, buffer); @@ -265,7 +265,7 @@ public: u_int64_t freeBlockHead = ((freeBlockNum/SECTOR_SIZE-MAX_INODE)/(8*2048)*(8*2048)+MAX_INODE)*SECTOR_SIZE; // mark it alive in its bitmap - uchar buffer[IO_BLOCK_SIZE] = {0}; + char buffer[IO_BLOCK_SIZE] = {0}; bool notEmpty = false; disk.rawdisk_read(freeBlockHead, buffer, sizeof(buffer)); for (int i = 8; i < 264; i++){ @@ -290,7 +290,7 @@ public: return 0; } u_int64_t freeBlockNum = 0; - uchar buffer[IO_BLOCK_SIZE] = {0}; + char buffer[IO_BLOCK_SIZE] = {0}; int delpoint = -1; disk.rawdisk_read(single_i, buffer, sizeof(buffer)); for (int i=4088; i >= 0; i--){ @@ -317,7 +317,7 @@ public: return false; } u_int64_t freeBlockNum = 0; - uchar buffer[IO_BLOCK_SIZE] = {0}; + char buffer[IO_BLOCK_SIZE] = {0}; int delpoint = -1; disk.rawdisk_read(double_i, buffer, sizeof(buffer)); for (int i=4088; i >= 0; i-=8){ @@ -344,7 +344,7 @@ public: return false; } u_int64_t freeBlockNum = 0; - uchar buffer[IO_BLOCK_SIZE] = {0}; + char buffer[IO_BLOCK_SIZE] = {0}; int delpoint = -1; disk.rawdisk_read(triple_i, buffer, sizeof(buffer)); for (int i=4088; i >= 0; i-=8){ @@ -402,7 +402,7 @@ public: // initialize Inode list head SuperBlock::writeFreeINodeHead(disk, 1); for (u_int64_t i = 1; i < MAX_INODE; i++){ - uchar buffer[SECTOR_SIZE] = {0}; + char buffer[SECTOR_SIZE] = {0}; u_int64_t t = i + 1; if (t < MAX_INODE){ for (int j = 0; j < 8; j++){ @@ -414,7 +414,7 @@ public: SuperBlock::writeFreeListHead(disk, MAX_INODE*SECTOR_SIZE); // maximum inode number 2^19 0x80000 //Have tested this initialize function but MAX_BLOCK too much, MAX_INODE*2 works for (u_int64_t i = MAX_INODE; i < MAX_BLOCKNUM-4096; i += 2048*8){ - uchar buffer[IO_BLOCK_SIZE] = {0}; + char buffer[IO_BLOCK_SIZE] = {0}; u_int64_t t = (i + 2048*8)*SECTOR_SIZE; //t is address, storing in to buffer for (int j = 0; j < 8; j++){ @@ -428,7 +428,7 @@ public: // the i-th inode is in the i-th block u_int64_t inode_allocate(RawDisk &disk){ u_int64_t freeINodeHead = SuperBlock::getFreeINodeHead(disk); - uchar buffer[SECTOR_SIZE] = {0}; + char buffer[SECTOR_SIZE] = {0}; disk.rawdisk_read(freeINodeHead*SECTOR_SIZE, buffer, sizeof(buffer)); u_int64_t newINodeHead = INode::read_byte_at(0, buffer); // deal with no more INode @@ -442,7 +442,7 @@ public: // free the inode and add it to the free inode list head void inode_free(RawDisk &disk, u_int64_t INodeNumber){ u_int64_t freeINodeHead = SuperBlock::getFreeINodeHead(disk); - uchar buffer[SECTOR_SIZE] = {0}; + char buffer[SECTOR_SIZE] = {0}; INode::write_byte_at(freeINodeHead, 0, buffer); disk.rawdisk_write(INodeNumber*SECTOR_SIZE, buffer, sizeof(buffer)); SuperBlock::writeFreeINodeHead(disk, INodeNumber); diff --git a/include/rawdisk.h b/include/rawdisk.h index 73e3fb3..4cccf70 100644 --- a/include/rawdisk.h +++ b/include/rawdisk.h @@ -6,17 +6,15 @@ #include #include -typedef unsigned char uchar; - class RawDisk{ int fd; - const uchar* dir; + const char* dir; u_int64_t numSectors; u_int64_t diskSize; public: - RawDisk(const uchar *directory) : fd(-1), dir(nullptr), numSectors(0), diskSize(0) { + RawDisk(const char *directory) : fd(-1), dir(nullptr), numSectors(0), diskSize(0) { dir = directory; /*dir = strdup("/dev/vdc"); numSectors = 62914560; @@ -50,7 +48,7 @@ public: } } - int rawdisk_read(u_int64_t offset, uchar *buffer, size_t length) { + int rawdisk_read(u_int64_t offset, char *buffer, size_t length) { if (lseek(fd, offset, SEEK_SET) == (u_int64_t)-1) { perror("Error seeking to offset"); return -1; @@ -66,7 +64,7 @@ public: } // Write a specified number of bytes at a given byte offset - int rawdisk_write(u_int64_t offset, uchar *buffer, size_t length) { + int rawdisk_write(u_int64_t offset, char *buffer, size_t length) { if (lseek(fd, offset, SEEK_SET) == (u_int64_t)-1) { perror("Error seeking to offset"); return -1; diff --git a/lib/main.cpp b/lib/main.cpp index c236c12..396b885 100644 --- a/lib/main.cpp +++ b/lib/main.cpp @@ -4,7 +4,7 @@ int main(){ fischl *F = new fischl; F->init(); - uchar *d = strdup("/dev/vdc"); + char *d = strdup("/dev/vdc"); RawDisk *H = new RawDisk(d); return 0; } \ No newline at end of file diff --git a/test/layer0.cpp b/test/layer0.cpp index 3629ed8..8cc358a 100644 --- a/test/layer0.cpp +++ b/test/layer0.cpp @@ -3,13 +3,13 @@ #include #include "rawdisk.h" -int main(int argc, uchar *argv[]) { - const uchar* d = (argc < 2) ? "/dev/vdc" : argv[1]; +int main(int argc, char *argv[]) { + const char* d = (argc < 2) ? "/dev/vdc" : argv[1]; RawDisk *H = new RawDisk(d); - uchar *buf = "iloveosdfjlseirfnerig"; - uchar readBuffer[512] = {0}; // Initialize to zeros + char *buf = "iloveosdfjlseirfnerig"; + char readBuffer[512] = {0}; // Initialize to zeros //printf("dir %s, numSectors %lld, diskSize %lld \n", H->dir, H->numSectors, H->diskSize); diff --git a/test/layer1_API.cpp b/test/layer1_API.cpp index eb8b7e4..91ef4ef 100644 --- a/test/layer1_API.cpp +++ b/test/layer1_API.cpp @@ -4,27 +4,27 @@ #include "fs.h" #include -int main(int argc, uchar *argv[]) { - const uchar* d = (argc < 2) ? "/dev/vdc" : argv[1]; +int main(int argc, char *argv[]) { + const char* d = (argc < 2) ? "/dev/vdc" : argv[1]; RawDisk *H = new RawDisk(d); printf("test inode\n"); INodeOperation inop; inop.initialize(*H); - uchar buffer[8] = {0}; + char buffer[8] = {0}; //test the begining of inode 1~524287 H->rawdisk_read((1) * SECTOR_SIZE, buffer, sizeof(buffer)); u_int64_t t = 0; for (int j = 0; j < 8; j++) - t |= ((u_int64_t)(uchar)buffer[j]) << (8 * j); + t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); assert(t == 2); //test the number before end of inode 524286 H->rawdisk_read((MAX_INODE - 2) * SECTOR_SIZE, buffer, sizeof(buffer)); t = 0; for (int j = 0; j < 8; j++) - t |= ((u_int64_t)(uchar)buffer[j]) << (8 * j); + t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); fprintf(stderr,"[t %llu,%d]\n",t,__LINE__); assert(t == MAX_INODE - 1); @@ -32,21 +32,21 @@ int main(int argc, uchar *argv[]) { H->rawdisk_read((MAX_INODE - 1) * SECTOR_SIZE, buffer, sizeof(buffer)); t = 0; for (int j = 0; j < 8; j++) - t |= ((u_int64_t)(uchar)buffer[j]) << (8 * j); + t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); assert(t == 0); //test the begining of datablock H->rawdisk_read((MAX_INODE) * SECTOR_SIZE, buffer, sizeof(buffer)); t = 0; for (int j = 0; j < 8; j++) - t |= ((u_int64_t)(uchar)buffer[j]) << (8 * j); + t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); assert(t == (MAX_INODE+2048*8)*SECTOR_SIZE); //test the end of the datablock H->rawdisk_read((MAX_BLOCKNUM - 2048*8) * SECTOR_SIZE, buffer, sizeof(buffer)); t = 0; for (int j = 0; j < 8; j++) - t |= ((u_int64_t)(uchar)buffer[j]) << (8 * j); + t |= ((u_int64_t)(char)buffer[j]) << (8 * j); assert(t == (MAX_BLOCKNUM)*SECTOR_SIZE); //initialize From 1d567ff487c54a690f69ade6e2fd5ce8f51ea80d Mon Sep 17 00:00:00 2001 From: Victor Date: Sat, 11 Nov 2023 16:08:35 -0800 Subject: [PATCH 16/17] fixed several bugs --- include/fs.h | 15 ++++++++++----- test/layer1_API.cpp | 28 +++++++++++++++++++++++++++- 2 files changed, 37 insertions(+), 6 deletions(-) diff --git a/include/fs.h b/include/fs.h index a67c516..067d595 100644 --- a/include/fs.h +++ b/include/fs.h @@ -145,7 +145,7 @@ public: u_int64_t freeBlockNum = 0; disk.rawdisk_read(freeListHead, buffer, sizeof(buffer)); for (int i = 8; i < 264; i++){ - if(buffer[i] != 255){ + if((i < 263 && buffer[i] != -1) || (i == 263 && buffer[i] != 127)){ int j = 0; for (j = 0; j < 8; j++){ if ((buffer[i]&(1<direct) u_int64_t freeBlockNum = 0; freeBlockNum = deallo_triple_indirect(disk, triple_indirect); @@ -390,6 +394,7 @@ public: // add it back to freeBlocklist datablock_deallocate_in_list(freeBlockNum, disk); inode_save(disk); + return freeBlockNum; } }; diff --git a/test/layer1_API.cpp b/test/layer1_API.cpp index 91ef4ef..c71ac28 100644 --- a/test/layer1_API.cpp +++ b/test/layer1_API.cpp @@ -46,7 +46,7 @@ int main(int argc, char *argv[]) { H->rawdisk_read((MAX_BLOCKNUM - 2048*8) * SECTOR_SIZE, buffer, sizeof(buffer)); t = 0; for (int j = 0; j < 8; j++) - t |= ((u_int64_t)(char)buffer[j]) << (8 * j); + t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); assert(t == (MAX_BLOCKNUM)*SECTOR_SIZE); //initialize @@ -76,6 +76,32 @@ int main(int argc, char *argv[]) { for(int i=0;i<20;i++){ printf(" %d", inode_list[i]); } + printf("}\n"); + + INode inode_inside[10]; + for(int i=0;i<10;i++){ + inode_inside[i].inode_construct(inode_list[i],*H); + printf("%dth data block starting addres: ", i); + for(int j=0;j<6;j++){ + printf("%d," ,inode_inside[i].datablock_allocate(*H)); + } + printf("\n"); + } + for(int i=0;i<10;i++){ + printf("%dth data block free addres: ", i); + for(int j=0;j<3;j++){ + printf("%d," ,inode_inside[i].datablock_deallocate(*H)); + } + printf("\n"); + } + for(int i=0;i<10;i++){ + printf("%dth data block allocate again addres: ", i); + for(int j=0;j<3;j++){ + printf("%d," ,inode_inside[i].datablock_allocate(*H)); + } + printf("\n"); + } + printf("}\n"); delete H; // Delete the RawDisk object From 71f87b0320afe08473c9b4b3bbb7ea1bc28c4fe9 Mon Sep 17 00:00:00 2001 From: Victor Date: Sat, 11 Nov 2023 23:05:03 -0800 Subject: [PATCH 17/17] add instructions and steps to know how to do further testing --- test/layer1_API.cpp | 95 +++++++++++++++++++++++++-------------------- 1 file changed, 52 insertions(+), 43 deletions(-) diff --git a/test/layer1_API.cpp b/test/layer1_API.cpp index c71ac28..0c63001 100644 --- a/test/layer1_API.cpp +++ b/test/layer1_API.cpp @@ -11,37 +11,40 @@ int main(int argc, char *argv[]) { printf("test inode\n"); INodeOperation inop; - inop.initialize(*H); + inop.initialize(*H);//for inode initialization and datablock initialization char buffer[8] = {0}; - //test the begining of inode 1~524287 + /**************************test inode Initialization***************************/ + //test the begining of inode 1th H->rawdisk_read((1) * SECTOR_SIZE, buffer, sizeof(buffer)); u_int64_t t = 0; for (int j = 0; j < 8; j++) t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); - assert(t == 2); - //test the number before end of inode 524286 + assert(t == 2);//the first 1th unused inode will store the next unused inode 2th + //test the number before end of inode 524286th H->rawdisk_read((MAX_INODE - 2) * SECTOR_SIZE, buffer, sizeof(buffer)); t = 0; for (int j = 0; j < 8; j++) t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); - fprintf(stderr,"[t %llu,%d]\n",t,__LINE__); - assert(t == MAX_INODE - 1); - //test the end of inode 1~524287 + assert(t == MAX_INODE - 1);//store the maximun th inode + //test the end of inode 524287th H->rawdisk_read((MAX_INODE - 1) * SECTOR_SIZE, buffer, sizeof(buffer)); t = 0; for (int j = 0; j < 8; j++) t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); - assert(t == 0); - //test the begining of datablock - H->rawdisk_read((MAX_INODE) * SECTOR_SIZE, buffer, sizeof(buffer)); + assert(t == 0);//the end of inode(524287th inode) do not have the next inode address + /**************************test datablock Initialization***************************/ + //we separate 2048 4kB I/O block(1+2047) as a group and the first I/O block will manage the following 2047 I/O block usage. + //the first 8 bytes(0~7) in first I/O block store the address of next first I/O block, the following 256(8~263) bytes record 2047 I/O block usage. + //test the begining of free datablock + H->rawdisk_read((MAX_INODE) * SECTOR_SIZE, buffer, sizeof(buffer));//the begining of free datablock will store from address (MAX_INODE) * SECTOR_SIZE t = 0; for (int j = 0; j < 8; j++) t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); - assert(t == (MAX_INODE+2048*8)*SECTOR_SIZE); + assert(t == (MAX_INODE+2048*8)*SECTOR_SIZE);//the first 8 bytes of 4k I/O block will store the next address(after 2048*4k I/O block) //test the end of the datablock H->rawdisk_read((MAX_BLOCKNUM - 2048*8) * SECTOR_SIZE, buffer, sizeof(buffer)); t = 0; @@ -49,60 +52,66 @@ int main(int argc, char *argv[]) { t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j); assert(t == (MAX_BLOCKNUM)*SECTOR_SIZE); - //initialize + + /***************************test inode de/allocation**********************************/ + //when requesting an inode, the inode_allocation will give you the inode number, we use inode_list to store the sequence allocate inode + //arrary version int inode_list[20] = {0}; - printf("Allocate 20 inode num:{"); + int record_free[10] = {0};//should do a pop up structure to record the free inode + int rec = 9; + //printf("Allocate 20 inode num:{"); for(int i=0;i<20;i++){ inode_list[i] = inop.inode_allocate(*H); - printf(" %d", inode_list[i]); + assert(inode_list[i] == i+1); + //printf(" %d", inode_list[i]); } - printf("}\n"); - //free the last 10 - printf("Free: inode num:{"); + //printf("}\n"); for(int i=10;i<20;i++){ - inop.inode_free(*H,inode_list[i]); - printf(" %d", inode_list[i]); + inop.inode_free(*H,inode_list[i]);//free the 10 element from inode_list[10] + record_free[i-10] = inode_list[i]; } - printf("}\n"); //allocate again the last 10 printf("Allocate again: inode num:{"); for(int i=10;i<20;i++){ inode_list[i] = inop.inode_allocate(*H); - printf(" %d", inode_list[i]); + //printf("inode %d, rec_f %d\n,", inode_list[i],record_free[rec]); + assert(inode_list[i] == record_free[rec]); + rec--; } printf("}\n"); - - printf("The status 20 inode num:{"); - for(int i=0;i<20;i++){ - printf(" %d", inode_list[i]); - } - printf("}\n"); - + /***************************test direct blocks[48] de/allocation**********************************/ + //after free the datablock, the program will find the first smallest address of datablock to give to the inode + //should test random resize each node, but should use datablock_free data structure to record INode inode_inside[10]; + u_int64_t rec_datablock_free[10][3] = {0};//array version for(int i=0;i<10;i++){ inode_inside[i].inode_construct(inode_list[i],*H); - printf("%dth data block starting addres: ", i); + //printf("%dth data block starting addres: ", i); for(int j=0;j<6;j++){ - printf("%d," ,inode_inside[i].datablock_allocate(*H)); + inode_inside[i].datablock_allocate(*H); + //printf("%d," ,inode_inside[i].datablock_allocate(*H)); } - printf("\n"); + //printf("\n"); } for(int i=0;i<10;i++){ - printf("%dth data block free addres: ", i); - for(int j=0;j<3;j++){ - printf("%d," ,inode_inside[i].datablock_deallocate(*H)); + //printf("%dth data block free addres: ", i); + for(int j = 2;j >=0;j--){ + rec_datablock_free[i][j] = inode_inside[i].datablock_deallocate(*H); + //printf("", rec_datablock_free[i][j]); } - printf("\n"); - } - for(int i=0;i<10;i++){ - printf("%dth data block allocate again addres: ", i); - for(int j=0;j<3;j++){ - printf("%d," ,inode_inside[i].datablock_allocate(*H)); - } - printf("\n"); + //printf("\n"); } - printf("}\n"); + for(int i=0;i<10;i++){ + //printf("%dth data block allocate again addres: ", i); + for(int j=0;j<3;j++){ + assert(inode_inside[i].datablock_allocate(*H) == rec_datablock_free[i][j]); + //printf("%d," ,inode_inside[i].datablock_allocate(*H)); + } + //printf("\n"); + } + + //printf("}\n"); delete H; // Delete the RawDisk object return 0;