From 4823b76d6c903eb7231e4855b6ecb1dc493d64e0 Mon Sep 17 00:00:00 2001
From: Victor <victor.yingyi@gmail.com>
Date: Tue, 7 Nov 2023 15:58:20 -0800
Subject: [PATCH] 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<<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;
                 }
-            if(i < 512){
-                rawdisk_write(single_indirect, buffer);
-            }
-            else{
-                if (double_indirect == 0){
-                    double_indirect = datablock_allocate_in_list();
+                //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
                 }
-                int inDouble = false;
-                rawdisk_read(double_indirect, 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(){
 
     }
-}
\ No newline at end of file
+};
\ No newline at end of file