解耦 bitmap 与 buddy 分配器, 补充项目说明文档.

xiaoyi1212 · xiaoyi1212 · commit d5163f44b5c2 · 2025-09-21T20:38:39.000+08:00
diff --git a/docs/zh_cn/kernel_module.md b/docs/zh_cn/kernel_module.md
@@ -10,6 +10,8 @@
 目前已有内核模块:
 
 - `extfs` - ext 文件系统实现
+- `e1000` - e1000 网卡驱动实现
+- `nvme` - nvme 硬盘驱动实现
 
 ## 源码目录
 
diff --git a/docs/zh_cn/subsystem.md b/docs/zh_cn/subsystem.md
@@ -29,10 +29,11 @@
 
 - heap/: 内核堆分配器实现, 由 `copi143` 编写的 `plalloc` 分配器.
 - lazyalloc.c: 懒分配器实现.
-- frame.c: 物理页框分配器实现.
+- frame.c: 物理页框分配器上层抽象接口.
 - memstats.c: 内存统计实现.
 - page.c: 页表管理相关实现.
-- bitmap.c: 位图实现, 页框分配器使用位图来管理物理内存.
+- bitmap.c: 位图分配策略的实现.
+- buddy.c: 伙伴分配策略的实现.(CP_Kernel 3.7 后的默认物理页框分配策略)
 - hhdm.c: 有关于高半部映射的内存偏移获取以及一些虚实地址转换.
 
 ## Interrupt and Clock Subsystem (中断与时钟子系统)
@@ -77,6 +78,8 @@
 - pipe.c: 管道实现, 提供进程间通信的管道机制.
 - modfs.c: 模块文件系统实现, 提供内核模块的加载与管理功能.
 - partition.c: 分区管理实现, 提供对磁盘分区的识别与操作功能, 并将识别到的分区作为虚拟块设备挂载到 `devfs`.
+- cpio/cpfs.c: `initramfs` 挂载虚拟文件系统处理层
+- cpio/cpio.c: `initramfs` 挂载器实现.
 
 ## Services and Modules (服务与模块)
 
diff --git a/src/x86_64/include/bitmap.h b/src/x86_64/include/bitmap.h
@@ -19,3 +19,19 @@ void bitmap_set_range(Bitmap *bitmap, size_t start, size_t end, bool value);
 size_t bitmap_find_range(const Bitmap *bitmap, size_t length, bool value);
 
 bool bitmap_range_all(const Bitmap *bitmap, size_t start, size_t end, bool value);
+
+void bitmap_free_frames(uint64_t addr, size_t count);
+
+void bitmap_free_frame(uint64_t addr);
+
+void bitmap_free_frames_2M(uint64_t addr);
+
+void bitmap_free_frames_1G(uint64_t addr);
+
+uint64_t bitmap_alloc_frames(size_t count);
+
+uint64_t bitmap_alloc_frames_2M(size_t count);
+
+uint64_t bitmap_alloc_frames_1G(size_t count);
+
+void init_frame_bitmap();
diff --git a/src/x86_64/mem/bitmap.c b/src/x86_64/mem/bitmap.c
@@ -1,4 +1,11 @@
 #include "bitmap.h"
+#include "boot.h"
+#include "frame.h"
+#include "hhdm.h"
+#include "klog.h"
+
+extern FrameAllocator frame_allocator;
+extern uint64_t       memory_size;
 
 void bitmap_init(Bitmap *bitmap, uint8_t *buffer, size_t size) {
     bitmap->buffer = buffer;
@@ -88,3 +95,146 @@ bool bitmap_range_all(const Bitmap *bitmap, size_t start, size_t end, bool value
     }
     return true;
 }
+
+void bitmap_free_frames(uint64_t addr, size_t count) {
+    if (addr == 0 || count == 0) return;
+    size_t frame_index = addr / 4096;
+    if (frame_index == 0) return;
+    Bitmap *bitmap = &frame_allocator.bitmap;
+    bitmap_set_range(bitmap, frame_index, frame_index + count, true);
+}
+
+void bitmap_free_frame(uint64_t addr) {
+    if (addr == 0) return;
+    size_t frame_index = addr / 4096;
+    if (frame_index == 0) return;
+    Bitmap *bitmap = &frame_allocator.bitmap;
+    bitmap_set(bitmap, frame_index, true);
+}
+
+void bitmap_free_frames_2M(uint64_t addr) {
+    if (addr == 0) return;
+    size_t frame_index = addr / 4096;
+    if (frame_index == 0) return;
+    Bitmap *bitmap = &frame_allocator.bitmap;
+    for (size_t i = 0; i < 512; i++) {
+        bitmap_set(bitmap, frame_index + i, true);
+    }
+}
+
+void bitmap_free_frames_1G(uint64_t addr) {
+    if (addr == 0) return;
+    size_t frame_index = addr / 4096;
+    if (frame_index == 0) return;
+    Bitmap *bitmap = &frame_allocator.bitmap;
+    for (size_t i = 0; i < 262144; i++) {
+        bitmap_set(bitmap, frame_index + i, true);
+    }
+}
+
+uint64_t bitmap_alloc_frames(size_t count) {
+    Bitmap *bitmap      = &frame_allocator.bitmap;
+    size_t  frame_index = bitmap_find_range(bitmap, count, true);
+
+    if (frame_index == (size_t)-1) return 0;
+    bitmap_set_range(bitmap, frame_index, frame_index + count, false);
+    frame_allocator.usable_frames -= count;
+
+    return frame_index * 4096;
+}
+
+uint64_t bitmap_alloc_frames_2M(size_t count) {
+    Bitmap *bitmap         = &frame_allocator.bitmap;
+    size_t  frames_per_2mb = 512;
+    size_t  total_frames   = count * frames_per_2mb;
+
+    for (size_t i = 0; i < bitmap->length; i += frames_per_2mb) {
+        if (i + total_frames > bitmap->length) break;
+
+        if (bitmap_range_all(bitmap, i, i + total_frames, true)) {
+            bitmap_set_range(bitmap, i, i + total_frames, false);
+            frame_allocator.usable_frames -= total_frames;
+            return i * 4096;
+        }
+    }
+
+    return 0;
+}
+
+uint64_t bitmap_alloc_frames_1G(size_t count) {
+    Bitmap *bitmap         = &frame_allocator.bitmap;
+    size_t  frames_per_1gb = 262144;
+    size_t  total_frames   = count * frames_per_1gb;
+
+    for (size_t i = 0; i < bitmap->length; i += frames_per_1gb) {
+        if (i + total_frames > bitmap->length) break;
+
+        if (bitmap_range_all(bitmap, i, i + total_frames, true)) {
+            bitmap_set_range(bitmap, i, i + total_frames, false);
+            frame_allocator.usable_frames -= total_frames;
+            return i * 4096;
+        }
+    }
+
+    return 0;
+}
+
+void init_frame_bitmap() {
+    struct limine_memmap_response *memory_map = get_memory_map();
+    memory_size                               = get_memory_size();
+
+    extern uint64_t reserved_memory;
+    extern uint64_t bad_memory;
+    extern uint64_t all_memory;
+
+    size_t   bitmap_size    = (memory_size / 4096 + 7) / 8;
+    uint64_t bitmap_address = 0;
+
+    for (uint64_t i = 0; i < memory_map->entry_count; i++) {
+        struct limine_memmap_entry *region = memory_map->entries[i];
+        if (region->type == LIMINE_MEMMAP_USABLE && region->length >= bitmap_size) {
+            bitmap_address = region->base;
+            break;
+        }
+    }
+
+    if (!bitmap_address) return;
+
+    Bitmap *bitmap = &frame_allocator.bitmap;
+    bitmap_init(bitmap, phys_to_virt(bitmap_address), bitmap_size);
+
+    size_t origin_frames = 0;
+    for (uint64_t i = 0; i < memory_map->entry_count; i++) {
+        struct limine_memmap_entry *region = memory_map->entries[i];
+
+        switch (region->type) {
+        case LIMINE_MEMMAP_USABLE:
+            size_t start_frame  = region->base / 4096;
+            size_t frame_count  = region->length / 4096;
+            origin_frames      += frame_count;
+            bitmap_set_range(bitmap, start_frame, start_frame + frame_count, true);
+            all_memory += region->length;
+            break;
+        case LIMINE_MEMMAP_RESERVED:
+        case LIMINE_MEMMAP_ACPI_NVS:
+        case LIMINE_MEMMAP_ACPI_RECLAIMABLE:
+            reserved_memory += region->length;
+            all_memory      += region->length;
+            break;
+        case LIMINE_MEMMAP_BAD_MEMORY:
+            bad_memory += region->length;
+            all_memory += region->length;
+            break;
+        }
+    }
+
+    size_t bitmap_frame_start = bitmap_address / 4096;
+    size_t bitmap_frame_count = (bitmap_size + 4095) / 4096;
+    size_t bitmap_frame_end   = bitmap_frame_start + bitmap_frame_count;
+    bitmap_set_range(bitmap, bitmap_frame_start, bitmap_frame_end, false);
+
+    frame_allocator.origin_frames = origin_frames;
+    frame_allocator.usable_frames = origin_frames - bitmap_frame_count;
+
+    logkf("Available memory: %lld MiB\n", (origin_frames / 256));
+}
diff --git a/src/x86_64/mem/frame.c b/src/x86_64/mem/frame.c
