ext2_group_descriptor

fs/ext2/ext2_fs.cpp

@@ -85,7 +85,7 @@ void EXT2_FS::mount() {
     block_size = 1024 * (1 << sb->log_block_size);
     dev->seek(block_size + 1024);  // 指向GDT
 
-    int group_cnt = 8 * sb->blocks_count / sb->blocks_per_group;
+    group_cnt = 8 * sb->blocks_count / sb->blocks_per_group;
     for (int i = 0; i < group_cnt; i++) {
         GroupDescriptor* gtp = new GroupDescriptor();
         dev->read(sb_buf, sizeof(GroupDescriptor));
@@ -137,12 +137,71 @@ _u32 EXT2_FS::alloc_inode() {
         if (buf.data[i] != (char)0xff) {
             int t = lowest_0(buf.data[i]);
             buf.data[i] |= _BITS_SIZE(t);
+            
+            gd->free_inodes_count--;          
             return t + i * 8;
         }
     }
     return 0;
 }
 
+_u32 EXT2_FS::alloc_block() {
+    GroupDescriptor* gd = nullptr;
+    for (GroupDescriptor* gdd: gdt_list) {
+        if (gdd->free_blocks_count > 0) {
+            gd = gdd;
+            break;
+        }
+    }
+    if (gd == nullptr) {
+        _log_info("No free data block.");
+        return 0;
+    }
+    MM::Buf buf(block_size);
+    dev->seek(block_to_pos(gd->block_bitmap));
+    dev->read(buf, block_size);
+    _sa(buf.data, block_size);
+    for (int i = 0; i < block_size; i++) {
+        if (buf.data[i] != (char)0xff) {
+            int t = lowest_0(buf.data[i]);
+            buf.data[i] |= _BITS_SIZE(t);
+            gd->free_blocks_count--;         
+            return t + i * 8;
+        }
+    }
+    return 0;
+}
+
+void EXT2_FS::write_super() {
+    _u32 super_pos = 1;
+    MM::Buf buf(sizeof(SuperBlock));
+    memcpy(buf.data, sb, sizeof(SuperBlock));
+    for (auto x: gdt_list) {
+        dev->seek(super_pos);
+        dev->write(buf, sizeof(SuperBlock));
+        super_pos += sb->blocks_per_group;
+    }
+}
+
+void EXT2_FS::write_gdt() {
+    _u32 super_pos = 2;
+    MM::Buf buf(gdt_list.size() * sizeof(GroupDescriptor));
+    _u32 s_pos = 0;
+    for (auto x: gdt_list) {
+        memcpy(buf.data + s_pos, x, sizeof(GroupDescriptor));
+        s_pos += sizeof(GroupDescriptor);
+    }
+    for (auto x: gdt_list) {
+        dev->seek(super_pos);
+        dev->write(buf, sizeof(SuperBlock));
+        super_pos += sb->blocks_per_group;
+    }
+}
+
+void EXT2_FS::write_inode_bitmap(EXT2::GroupDescriptor* gd) {
+    
+}
+
 EXT2_FS::~EXT2_FS() {
     for (auto x: gdt_list) {
         delete x;

fs/ext2/ext2_fs.h

@@ -23,12 +23,18 @@ namespace EXT2 {
         std::list<GroupDescriptor*> gdt_list;
 
         _u32 block_size;
+        _u32 group_cnt;
 
         _u32 alloc_inode();
+        _u32 alloc_block();
+
+        void write_super();
+        void write_gdt();
+        void write_inode_bitmap(GroupDescriptor*);
+
         EXT2_FS(Dev::BlockDevice* dev);
         void mount();
         ~EXT2_FS();
     };
 
-
 }

fs/ext2/ext2_group_descriptor.cpp

@@ -0,0 +1,88 @@
+#include "ext2_group_descriptor.h"
+#include "ext2_disk_stru.h"
+#include "bits.h"
+#include <cstring>
+using namespace EXT2;
+
+
+EXT2_GD::EXT2_GD(EXT2_FS *fs, GroupDescriptor* gd, _u32 n) {
+    this->gd = gd;
+    this->fs = fs;
+    group_n = n;
+}
+
+EXT2_GD::~EXT2_GD() {
+    delete gd;
+    delete inode_bitmap;
+    delete block_bitmap;
+}
+
+GroupDescriptor *EXT2_GD::get_gd() {
+    return gd;
+}
+
+_u8 *EXT2_GD::get_inode_bitmap() {
+    if (inode_bitmap != nullptr)
+        return inode_bitmap;
+    MM::Buf buf(fs->block_size);
+    fs->dev->seek(fs->block_to_pos(gd->inode_bitmap));
+    fs->dev->read(buf, fs->block_size);
+    inode_bitmap = new _u8[fs->block_size];
+    memcpy(inode_bitmap, buf.data, fs->block_size);
+    return inode_bitmap;
+}
+
+_u8 *EXT2_GD::get_block_bitmap() {
+    if (block_bitmap != nullptr)
+        return block_bitmap;
+    MM::Buf buf(fs->block_size);
+    fs->dev->seek(fs->block_to_pos(gd->block_bitmap));
+    fs->dev->read(buf, fs->block_size);
+    block_bitmap = new _u8[fs->block_size];
+    memcpy(block_bitmap, buf.data, fs->block_size);
+    return block_bitmap;
+}
+
+_u32 EXT2_GD::alloc_inode() {
+    if (gd->free_inodes_count == 0)
+        return 0;
+    get_inode_bitmap();
+    for (int i = 0; i < fs->block_size; i++) {
+        if (inode_bitmap[i] != (_u8)0xff) {
+            int t = lowest_0(inode_bitmap[i]);
+            inode_bitmap[i] |= _BITS_SIZE(t);
+            gd->free_blocks_count--;         
+            return t + i * 8;
+        }
+    }
+    return 0;
+}
+
+_u32 EXT2_GD::alloc_block() {
+    if (gd->free_blocks_count == 0)
+        return 0;
+    get_block_bitmap();
+    for (int i = 0; i < fs->block_size; i++) {
+        if (block_bitmap[i] != (_u8)0xff) {
+            int t = lowest_0(block_bitmap[i]);
+            block_bitmap[i] |= _BITS_SIZE(t);
+            gd->free_blocks_count--;         
+            return t + i * 8;
+        }
+    }
+    return 0;
+}
+
+void EXT2_GD::write_inode_bitmap() {
+    fs->dev->seek(fs->block_to_pos(gd->inode_bitmap));
+    MM::Buf buf(fs->block_size);
+    memcpy(buf.data, inode_bitmap, fs->block_size);
+    fs->dev->write(buf, fs->block_size);
+}
+
+void EXT2_GD::write_block_bitmap() {
+    fs->dev->seek(fs->block_to_pos(gd->block_bitmap));
+    MM::Buf buf(fs->block_size);
+    memcpy(buf.data, block_bitmap, fs->block_size);
+    fs->dev->write(buf, fs->block_size);
+}

fs/ext2/ext2_group_descriptor.h

@@ -0,0 +1,21 @@
+#pragma once
+#include "ext2_fs.h"
+
+namespace EXT2 {
+    class EXT2_GD {
+        _u8 *inode_bitmap = nullptr, *block_bitmap = nullptr;
+        GroupDescriptor* gd;
+        EXT2_FS *fs;
+        _u32 group_n;
+    public:
+        EXT2_GD(EXT2_FS *fs, GroupDescriptor* gd, _u32 n);
+        ~EXT2_GD();
+        GroupDescriptor *get_gd();
+        _u8 *get_inode_bitmap();
+        _u8 *get_block_bitmap();
+        _u32 alloc_inode();
+        _u32 alloc_block();
+        void write_inode_bitmap();
+        void write_block_bitmap();
+    };
+}

mm/buf.h

@@ -4,11 +4,11 @@
 namespace MM {
     class Buf {
     public:
-        char* data = nullptr;
+        _u8* data = nullptr;
         Buf(_u32 size) {
-            data = new char[size];
+            data = new _u8[size];
         }
-        char* raw() {
+        _u8* raw() {
             return data;
         }
         ~Buf() {