C语言模拟Linux文件系统：从零实现教学级文件系统核心-北京尧图网络

1. 项目概述为什么用C语言模拟Linux文件系统如果你学过C语言也接触过Linux那你大概率对“文件系统”这个词既熟悉又陌生。熟悉是因为每天都在用ls、cd、cat这些命令和文件打交道陌生是因为它底层到底怎么组织数据、怎么找到文件感觉像是个黑盒子。这个项目就是用C语言亲手把这个黑盒子打开自己从零搭建一个简化版的Linux文件系统。这听起来有点“造轮子”但它的价值远超你的想象。它不是让你去写一个能替代Ext4或Btrfs的真实文件系统而是一个教学级的模拟实现。通过它你能把操作系统、数据结构和C语言编程这三块知识彻底打通。你会真正理解一个文件从创建到读写背后经历了怎样的数据结构和算法调度。当你下次在Linux下遇到“只读文件系统”或者磁盘空间不足的报错时你脑子里浮现的将不再是冰冷的错误代码而是一幅清晰的磁盘布局图。这个项目适合谁首先是计算机专业的学生尤其是正在学习《操作系统》或《高级程序设计》的同学们这是绝佳的课程设计或毕业设计选题。其次是那些已经工作但感觉自己的知识体系在“应用层”飘着想向下扎根、理解系统底层原理的后端或嵌入式开发者。最后哪怕你只是个C语言爱好者想挑战一个综合性、有深度的大项目这个模拟文件系统也绝对能让你过足瘾。2. 核心设计思路化繁为简抓住精髓一个完整的Linux文件系统极其复杂涉及磁盘布局、缓存、日志、权限、链接等无数细节。我们的模拟实现必须做减法抓住最核心的骨架用最简单的数据结构在内存中模拟出关键流程。2.1 设计目标与约束我们的目标是模拟一个单用户、无权限控制、运行在内存中的简化文件系统。为什么这么设计单用户无权限真实的文件权限rwx和用户/组管理是一个庞大的子系统。为了聚焦核心的文件存储与检索逻辑我们先剥离这部分。内存模拟我们不直接操作物理硬盘或镜像文件初期而是用一大块内存比如一个char数组来模拟磁盘块。这样做调试方便速度极快避免了复杂的设备驱动和IO操作。后期可以很容易地扩展为将这片内存持久化到一个本地文件从而实现“虚拟磁盘”。核心功能实现最基础的几条命令format格式化、mkdir创建目录、ls列表、cd切换目录、create创建文件、write写文件、read读文件、rm删除。能跑通这个流程核心思想就掌握了。2.2 架构选型类Unix文件系统模型我们参考经典的Unix文件系统设计如早期的UFS它清晰地将磁盘分为几个关键区域超级块 (Superblock)文件系统的“总控中心”存储整个系统的元数据如魔数标识文件系统类型、总块数、空闲块数、inode数量等。系统启动时首先读取它。inode位图 (inode Bitmap)和数据区块位图 (Block Bitmap)这是两种位图数据结构。用来高效管理inode和数据块的分配状态。每个bit代表一个inode或数据块0表示空闲1表示已用。位图是管理空闲资源最高效的方式之一。inode表 (inode Table)这是文件系统的“心脏”。inode索引节点不保存文件名而是保存文件的元数据和数据块指针。元数据包括文件大小、创建/修改时间、链接数、文件类型普通文件、目录等。指针则指向实际存储文件内容的数据块。数据区 (Data Blocks)真正存放文件内容或目录条目的地方。为什么选择这个模型因为它清晰地分离了元数据inode和数据Data Block。这种设计使得列出目录只需读目录的inode和数据块和读取大文件通过inode中的多级指针都非常高效。我们的模拟将严格遵循这个逻辑。2.3 关键数据结构定义用C语言实现第一步就是用结构体定义出上面的核心组件。这里的设计直接影响后续所有操作的复杂度。// 假设一个磁盘块大小为512字节 #define BLOCK_SIZE 512 #define MAX_BLOCKS 1024 // 模拟磁盘有1024个块 #define INODE_TABLE_SIZE 128 // 最多128个inode // 超级块结构体 typedef struct { int magic_number; // 魔数比如0x1234用于识别文件系统 int total_blocks; // 总块数 int free_blocks; // 空闲块数 int total_inodes; // 总inode数 int free_inodes; // 空闲inode数 int block_bitmap_start; // 块位图起始块号 int inode_bitmap_start; // inode位图起始块号 int inode_table_start; // inode表起始块号 int data_blocks_start; // 数据区起始块号 } SuperBlock; // Inode结构体 (一个inode占一个磁盘块可能浪费但简化设计) typedef struct { int is_used; // 是否使用中 int file_type; // 0-空闲1-文件2-目录 int file_size; // 文件大小字节 int create_time; int modify_time; int direct_blocks[10]; // 直接指针指向10个数据块 int indirect_block; // 一级间接指针块号 // 可以扩展二级间接指针但本项目简化处理 } Inode; // 目录项结构体 (存储在目录文件的数据块中) typedef struct { char filename[28]; // 文件名 int inode_no; // 对应的inode编号 } DirEntry; // 全局“磁盘” - 用内存数组模拟 char virtual_disk[MAX_BLOCKS][BLOCK_SIZE]; // 当前目录的inode编号 int current_dir_inode_no 0; // 默认根目录inode编号为0设计解析direct_blocks[10]这是最核心的设计。小文件 10 * 512B 5KB可以直接通过这10个指针找到所有数据块访问是O(1)复杂度。indirect_block用于存放更大的文件。这个指针指向一个专门的数据块这个块里不存文件内容而是存满了更多的数据块指针假设每个指针4字节一个块能存512/4128个指针。这样通过一级间接文件最大可以到 5KB 128 * 512B ≈ 66KB。这就是Unix文件系统经典的多级索引分配策略在空间效率和访问效率之间取得了平衡。DirEntry目录在文件系统看来就是一个特殊的文件它的数据块里不存子目录/文件的内容而是存DirEntry数组。通过“文件名”找到对应的inode_no再通过inode_no去inode_table里找到真正的文件元数据和内容指针。这就是“一切皆文件”和路径解析的基础。3. 核心模块实现与实操要点有了顶层设计我们开始动手实现各个核心模块。我会把重点放在最容易出错的“分配”与“查找”逻辑上。3.1 磁盘空间管理位图的操作位图是高效管理大量二元状态空闲/占用的标准方法。我们需要实现分配和释放inode/数据块的函数。// 全局位图指针指向virtual_disk中的特定块 unsigned char *block_bitmap; unsigned char *inode_bitmap; // 初始化位图将所有位设置为0空闲 void bitmap_init(unsigned char *bitmap, int size_in_bits) { memset(bitmap, 0, (size_in_bits 7) / 8); // 计算需要的字节数 } // 分配一个空闲位返回位索引从0开始失败返回-1 int allocate_bit(unsigned char *bitmap, int size_in_bits) { int total_bytes (size_in_bits 7) / 8; for (int i 0; i total_bytes; i) { if (bitmap[i] ! 0xFF) { // 这个字节不是全1说明有空位 unsigned char byte bitmap[i]; for (int j 0; j 8; j) { if (!(byte (1 j))) { // 找到为0的位 int bit_index i * 8 j; if (bit_index size_in_bits) return -1; // 越界保护 bitmap[i] | (1 j); // 将该位置1 return bit_index; } } } } return -1; // 没有空闲位 } // 释放指定的位 void free_bit(unsigned char *bitmap, int bit_index) { int byte_index bit_index / 8; int bit_offset bit_index % 8; bitmap[byte_index] ~(1 bit_offset); // 将该位置0 }实操心得位图操作中最容易犯的错误是索引计算和越界检查。size_in_bits是总位数而bitmap数组是按字节分配的。allocate_bit中if (bit_index size_in_bits) return -1;这行保护至关重要因为最后一个字节可能只有部分位有效。调试时可以写一个print_bitmap函数来可视化位图状态非常直观。3.2 Inode与数据块的分配策略分配一个文件需要两步1. 分配一个空闲inode2. 根据文件大小分配若干空闲数据块。// 分配一个空闲的inode返回inode在表中的索引号 int allocate_inode() { int inode_no allocate_bit(inode_bitmap, INODE_TABLE_SIZE); if (inode_no -1) { printf(错误inode已耗尽\n); return -1; } // 初始化这个inode Inode *ino ((Inode*)virtual_disk[superblock.inode_table_start])[inode_no]; memset(ino, 0, sizeof(Inode)); ino-is_used 1; // 其他字段如时间戳可以在这里设置 superblock.free_inodes--; return inode_no; } // 为inode分配一个数据块返回块号 int allocate_block_for_inode(Inode *ino) { int block_no allocate_bit(block_bitmap, superblock.total_blocks); if (block_no -1) { printf(错误磁盘空间不足\n); return -1; } // 找到ino中第一个空闲的直接指针 for (int i 0; i 10; i) { if (ino-direct_blocks[i] 0) { // 0表示未分配 ino-direct_blocks[i] block_no; superblock.free_blocks--; return block_no; } } // 直接指针用完了使用一级间接指针 if (ino-indirect_block 0) { // 先分配一个块作为间接指针块 int indirect_blk allocate_bit(block_bitmap, superblock.total_blocks); if (indirect_blk -1) return -1; ino-indirect_block indirect_blk; // 初始化这个间接指针块全部清零 memset(virtual_disk[indirect_blk], 0, BLOCK_SIZE); } // 在间接指针块中找一个空闲项 int *indirect_array (int *)virtual_disk[ino-indirect_block]; for (int i 0; i BLOCK_SIZE / sizeof(int); i) { if (indirect_array[i] 0) { indirect_array[i] block_no; superblock.free_blocks--; return block_no; } } printf(错误文件太大间接指针块也已满\n); free_bit(block_bitmap, block_no); // 分配了块但没地方记需要释放 return -1; }注意事项这里的分配策略是“首次适应”找到第一个空闲位置就用。在allocate_block_for_inode中为间接指针块分配空间后一定要memset清零因为这块内存之前可能被其他数据污染。这是一个非常隐蔽的Bug来源。3.3 目录树的创建与路径解析文件系统是树状结构。根目录/是一个固定的inode比如0号。创建目录就是在当前目录的数据块里添加一个DirEntry并为其分配一个新的、类型为目录的inode。// 创建目录 int my_mkdir(const char *dirname) { // 1. 检查当前目录下是否已存在同名项 Inode *cur_dir_inode get_inode(current_dir_inode_no); DirEntry *entries (DirEntry *)get_block_data(cur_dir_inode, 0); // 获取目录第一个数据块 int entry_count cur_dir_inode-file_size / sizeof(DirEntry); for (int i 0; i entry_count; i) { if (strcmp(entries[i].filename, dirname) 0) { printf(错误目录 %s 已存在\n, dirname); return -1; } } // 2. 为新建目录分配inode和数据块 int new_inode_no allocate_inode(); if (new_inode_no -1) return -1; Inode *new_inode get_inode(new_inode_no); new_inode-file_type 2; // 目录类型 // 为目录分配至少一个数据块用来存放 . 和 .. 条目 int block_no allocate_block_for_inode(new_inode); if (block_no -1) { free_inode(new_inode_no); // 分配失败回滚 return -1; } new_inode-file_size 2 * sizeof(DirEntry); // 初始大小两个条目 // 3. 在新目录的数据块中创建 . 和 .. 条目 DirEntry *new_dir_entries (DirEntry *)virtual_disk[block_no]; strcpy(new_dir_entries[0].filename, .); new_dir_entries[0].inode_no new_inode_no; strcpy(new_dir_entries[1].filename, ..); new_dir_entries[1].inode_no current_dir_inode_no; // 4. 在当前目录的数据块中添加新目录的条目 // 需要先判断当前目录的数据块是否已满如果满了要分配新块这里简化假设不满 strcpy(entries[entry_count].filename, dirname); entries[entry_count].inode_no new_inode_no; cur_dir_inode-file_size sizeof(DirEntry); // 更新当前目录大小 return 0; }路径解析是文件操作中最复杂的部分之一。例如解析/home/user/test.txt。从根目录inode0号开始。在根目录的数据块中查找名为home的DirEntry得到其inode号。进入home目录的inode在其数据块中查找user。进入user目录的inode在其数据块中查找test.txt。找到test.txt的inode号最终操作这个inode。这个过程需要递归或循环查找要小心处理.当前目录和..上级目录的情况。绝对路径从根开始相对路径从当前目录开始。4. 文件读写与数据块管理创建文件和读写内容是文件系统的终极考验。这里涉及到数据块的管理、文件大小的动态增长以及读写偏移量的维护。4.1 创建与打开文件创建文件my_create的逻辑和创建目录my_mkdir非常相似区别在于分配的inode其file_type设置为1普通文件。初始file_size为0。不需要立即分配数据块也不需要创建.和..条目。数据块将在第一次写入时按需分配。我们还需要维护一个“打开文件表”模拟内核的文件描述符表。每个表项记录打开文件的inode号、当前读写偏移量等。typedef struct { int inode_no; int read_write_offset; // 读写指针位置 int is_used; } OpenFileEntry; OpenFileEntry open_file_table[MAX_OPEN_FILES]; // 模拟open系统调用返回文件描述符fd int my_open(const char *pathname, int mode) { int inode_no path_lookup(pathname); // 路径解析函数返回inode号 if (inode_no 0) { if (mode O_CREAT) { // 创建新文件先在父目录添加条目再分配inode inode_no create_file_in_dir(pathname); } else { return -1; // 文件不存在且不创建 } } // 在打开文件表中找一个空闲项 for (int fd 0; fd MAX_OPEN_FILES; fd) { if (!open_file_table[fd].is_used) { open_file_table[fd].inode_no inode_no; open_file_table[fd].read_write_offset 0; // 默认从头开始 open_file_table[fd].is_used 1; return fd; // 返回文件描述符 } } printf(错误打开文件数达到上限\n); return -1; }4.2 写入数据块分配与寻址写入数据是核心中的核心。我们需要根据文件当前大小和写入偏移计算出数据应该放在哪个逻辑块然后找到或分配对应的物理数据块。// 关键辅助函数根据inode和文件内的逻辑块号找到对应的物理数据块号。 // 如果该逻辑块尚未分配物理块则分配一个。 int get_or_alloc_block_no(Inode *ino, int logic_block_no) { // 逻辑块号从0开始 if (logic_block_no 10) { // 使用直接指针 if (ino-direct_blocks[logic_block_no] 0) { int phy_blk allocate_block_for_inode(ino); if (phy_blk -1) return -1; ino-direct_blocks[logic_block_no] phy_blk; } return ino-direct_blocks[logic_block_no]; } else { // 使用一级间接指针 if (ino-indirect_block 0) { // 分配间接指针块 int indirect_blk allocate_bit(block_bitmap, superblock.total_blocks); if (indirect_blk -1) return -1; ino-indirect_block indirect_blk; memset(virtual_disk[indirect_blk], 0, BLOCK_SIZE); } int index_in_indirect logic_block_no - 10; int *indirect_array (int *)virtual_disk[ino-indirect_block]; if (indirect_array[index_in_indirect] 0) { int phy_blk allocate_bit(block_bitmap, superblock.total_blocks); if (phy_blk -1) return -1; indirect_array[index_in_indirect] phy_blk; } return indirect_array[index_in_indirect]; } } // 模拟write系统调用 int my_write(int fd, const void *buf, size_t count) { if (fd 0 || fd MAX_OPEN_FILES || !open_file_table[fd].is_used) { return -1; } OpenFileEntry *entry open_file_table[fd]; Inode *ino get_inode(entry-inode_no); size_t bytes_written 0; char *src (char *)buf; // 循环写入可能跨越多个数据块 while (bytes_written count) { // 计算当前偏移量所在的逻辑块号及块内偏移 int logic_block_no entry-read_write_offset / BLOCK_SIZE; int offset_in_block entry-read_write_offset % BLOCK_SIZE; // 获取或分配对应的物理块 int phy_block_no get_or_alloc_block_no(ino, logic_block_no); if (phy_block_no -1) break; // 分配失败 // 计算本次能写入当前块的最大字节数 int bytes_to_write BLOCK_SIZE - offset_in_block; if (bytes_to_write (count - bytes_written)) { bytes_to_write count - bytes_written; } // 执行内存拷贝模拟磁盘写入 memcpy(virtual_disk[phy_block_no] offset_in_block, src bytes_written, bytes_to_write); // 更新偏移量和已写入字节数 entry-read_write_offset bytes_to_write; bytes_written bytes_to_write; // 如果写指针超过了原文件大小需要更新inode中的文件大小 if (entry-read_write_offset ino-file_size) { ino-file_size entry-read_write_offset; } } // 更新文件修改时间 ino-modify_time get_current_time(); // 假设的函数 return bytes_written; // 返回实际写入的字节数 }避坑指南my_write函数是Bug重灾区。最容易出错的地方是边界计算logic_block_no和offset_in_block的计算必须准确。bytes_to_write的计算需要取剩余块空间和剩余请求写入量的最小值。另一个关键是文件大小的更新只有在写指针超过原文件大小时才更新ino-file_size。如果是在文件中间写入比如用lseek调整了偏移量则不应改变文件大小除非写入操作覆盖了文件末尾。4.3 读取数据读取的逻辑比写入简单因为不需要分配新块。但需要检查读取范围是否超出文件大小。int my_read(int fd, void *buf, size_t count) { // ... 参数检查同上 OpenFileEntry *entry open_file_table[fd]; Inode *ino get_inode(entry-inode_no); // 计算最大可读取的字节数不能超过文件末尾 size_t max_readable ino-file_size - entry-read_write_offset; if (max_readable 0) return 0; // 已到文件尾 if (count max_readable) { count max_readable; } size_t bytes_read 0; char *dst (char *)buf; while (bytes_read count) { int logic_block_no entry-read_write_offset / BLOCK_SIZE; int offset_in_block entry-read_write_offset % BLOCK_SIZE; // 根据逻辑块号找到物理块号读取时块必须已存在 int phy_block_no get_physical_block_no(ino, logic_block_no); if (phy_block_no 0) { // 0表示未分配的块 // 遇到“文件空洞”用0填充目标缓冲区 int hole_size BLOCK_SIZE - offset_in_block; if (hole_size (count - bytes_read)) hole_size count - bytes_read; memset(dst bytes_read, 0, hole_size); entry-read_write_offset hole_size; bytes_read hole_size; continue; } int bytes_to_read BLOCK_SIZE - offset_in_block; if (bytes_to_read (count - bytes_read)) { bytes_to_read count - bytes_read; } memcpy(dst bytes_read, virtual_disk[phy_block_no] offset_in_block, bytes_to_read); entry-read_write_offset bytes_to_read; bytes_read bytes_to_read; } return bytes_read; }这里引入了一个重要概念文件空洞。如果一个文件很大但只在开头和结尾写了数据中间的逻辑块可能没有分配物理块phy_block_no为0。读取到这些“空洞”时按照POSIX标准应该返回0。我们的模拟也实现了这一点。5. 系统格式化、挂载与命令解析一个完整的文件系统需要初始化和用户交互界面。5.1 格式化创建初始磁盘映像格式化就是在“虚拟磁盘”上构建出我们设计好的初始布局写入超级块、初始化位图、创建根目录。void my_format() { printf(正在格式化虚拟磁盘...\n); // 0. 清空整个虚拟磁盘 memset(virtual_disk, 0, sizeof(virtual_disk)); // 1. 初始化超级块 SuperBlock *sb (SuperBlock *)virtual_disk[0]; // 假设超级块在第0块 sb-magic_number 0x1234; sb-total_blocks MAX_BLOCKS; sb-data_blocks_start 10; // 假设前10块留给元数据 // 计算位图和inode表的位置简化布局 sb-block_bitmap_start 1; sb-inode_bitmap_start 2; sb-inode_table_start 3; sb-total_inodes INODE_TABLE_SIZE; // 初始化位图全部空闲 block_bitmap (unsigned char *)virtual_disk[sb-block_bitmap_start]; inode_bitmap (unsigned char *)virtual_disk[sb-inode_bitmap_start]; bitmap_init(block_bitmap, sb-total_blocks); bitmap_init(inode_bitmap, sb-total_inodes); // 标记元数据块为已占用超级块、位图块、inode表块 for (int i 0; i sb-data_blocks_start; i) { int byte_idx i / 8; int bit_idx i % 8; block_bitmap[byte_idx] | (1 bit_idx); sb-free_blocks sb-total_blocks - sb-data_blocks_start; } // 2. 创建根目录的inode (inode 0) int root_inode_no 0; allocate_bit(inode_bitmap, sb-total_inodes); // 占用0号inode Inode *root_inode get_inode(root_inode_no); root_inode-is_used 1; root_inode-file_type 2; // 目录 // 为根目录分配第一个数据块 int root_dir_block allocate_block_for_inode(root_inode); root_inode-file_size 2 * sizeof(DirEntry); // 在根目录数据块中创建 . 和 .. 条目都指向自己 DirEntry *root_entries (DirEntry *)virtual_disk[root_dir_block]; strcpy(root_entries[0].filename, .); root_entries[0].inode_no root_inode_no; strcpy(root_entries[1].filename, ..); root_entries[1].inode_no root_inode_no; sb-free_inodes sb-total_inodes - 1; current_dir_inode_no root_inode_no; printf(格式化完成。根目录inode: %d\n, root_inode_no); }5.2 实现一个简单的Shell为了让我们的文件系统能交互需要写一个简单的命令行循环解析用户输入的命令。void shell_loop() { char cmdline[256]; while (1) { // 可以在这里显示当前路径需要实现路径查找函数 printf(myfs ); fflush(stdout); if (fgets(cmdline, sizeof(cmdline), stdin) NULL) break; cmdline[strcspn(cmdline, \n)] 0; // 去掉换行符 if (strlen(cmdline) 0) continue; // 简单的命令解析 char *cmd strtok(cmdline, ); char *arg1 strtok(NULL, ); char *arg2 strtok(NULL, ); if (strcmp(cmd, ls) 0) { my_ls(arg1); // arg1可能是路径如ls /home } else if (strcmp(cmd, mkdir) 0) { if (arg1) my_mkdir(arg1); } else if (strcmp(cmd, cd) 0) { if (arg1) my_cd(arg1); } else if (strcmp(cmd, create) 0) { if (arg1) my_create(arg1); } else if (strcmp(cmd, write) 0) { // 格式: write filename content if (arg1 arg2) { int fd my_open(arg1, O_WRONLY | O_CREAT); if (fd 0) { my_write(fd, arg2, strlen(arg2)); my_close(fd); } } } else if (strcmp(cmd, cat) 0) { if (arg1) { int fd my_open(arg1, O_RDONLY); if (fd 0) { char buffer[1024]; int n; while ((n my_read(fd, buffer, sizeof(buffer)-1)) 0) { buffer[n] \0; printf(%s, buffer); } printf(\n); my_close(fd); } } } else if (strcmp(cmd, rm) 0) { if (arg1) my_rm(arg1); } else if (strcmp(cmd, format) 0) { my_format(); } else if (strcmp(cmd, exit) 0) { break; } else { printf(未知命令: %s\n, cmd); } } }6. 调试技巧与常见问题实录做这个项目大部分时间不是在写代码而是在调试。以下是我踩过的一些坑和解决方法。6.1 内存越界与数据损坏这是C语言项目的通病在文件系统中尤为致命因为数据结构环环相扣。症状莫名其妙的Segmentation fault或者位图、inode数据突然乱掉。排查大量使用assert在每个关键函数入口用assert检查参数有效性如inode_no是否在有效范围内block_no是否有效。边界检查所有计算逻辑块号、数组索引的地方手动检查是否越界。例如get_or_alloc_block_no函数中logic_block_no不能超过直接指针数间接指针容量。内存初始化任何新分配的内存如新数据块、新inode必须用memset清零。残留的旧数据会导致不可预知的行为。使用Valgrind这是Linux下强大的内存检测工具。编译时加上-g选项用valgrind ./myfs运行你的程序它能精准定位内存非法访问、泄漏等问题。6.2 目录遍历中的无限循环在实现ls或路径解析时如果处理不好.和..或者目录项损坏可能导致无限递归。症状程序卡死或栈溢出。解决设置递归深度限制在路径解析函数中设置一个最大深度比如20层超过则报错。检查目录项有效性读取DirEntry后检查其inode_no是否在有效范围内以及对应的inode类型是否为目录。防御性编程在my_cd进入一个目录前可以检查该目录的inode中是否包含指向自身的.条目以及指向父目录的..条目是否合理不能指向自己除非是根目录。6.3 文件删除与空间回收删除文件my_rm不是简单的抹掉目录项。你必须确保释放该文件占用的所有数据块更新块位图。释放该文件的inode更新inode位图。将其从父目录的数据块中移除可能需要移动后面的目录项来填补空隙或者标记为“空闲”类似FAT的删除。更新父目录的file_size。最容易遗漏的是第1步。你需要遍历文件的inode释放所有direct_blocks和indirect_block指向的物理块。对于间接块需要先读取它释放里面记录的所有指针块最后再释放这个间接块本身。void free_inode_and_blocks(int inode_no) { Inode *ino get_inode(inode_no); if (!ino || !ino-is_used) return; // 释放直接数据块 for (int i 0; i 10; i) { if (ino-direct_blocks[i] ! 0) { free_bit(block_bitmap, ino-direct_blocks[i]); superblock.free_blocks; ino-direct_blocks[i] 0; } } // 释放间接数据块 if (ino-indirect_block ! 0) { int *indirect_array (int *)virtual_disk[ino-indirect_block]; for (int i 0; i BLOCK_SIZE / sizeof(int); i) { if (indirect_array[i] ! 0) { free_bit(block_bitmap, indirect_array[i]); superblock.free_blocks; } } // 释放间接指针块本身 free_bit(block_bitmap, ino-indirect_block); superblock.free_blocks; ino-indirect_block 0; } // 释放inode memset(ino, 0, sizeof(Inode)); free_bit(inode_bitmap, inode_no); superblock.free_inodes; }6.4 如何测试你的文件系统不要等到所有功能写完再测试。应该分模块测试。单元测试单独测试allocate_bit/free_bit确保位图操作正确。单独测试get_or_alloc_block_no验证直接和间接指针的分配逻辑。集成测试先测试my_format和my_ls看能否正确显示根目录。然后测试my_mkdir和my_cd构建简单的目录树。接着测试文件的创建、写入、读取。最后测试删除。压力测试创建大量小文件直到inode用尽观察错误处理。创建一个大于66KB直接一级间接指针容量的文件测试间接指针是否正确工作。进行反复的创建、删除操作检查是否有空间泄漏即块或inode没有正确释放。持久化测试进阶将virtual_disk数组定期写入一个本地文件如disk.img。程序启动时从这个文件加载。这能测试你的文件系统在“关机”和“重启”后数据是否依然完整。这是从“内存模拟”到“模拟磁盘”的关键一步。这个项目写到后面你会发现自己不仅仅是在写C代码更像是在扮演一个微型操作系统的设计者。每一个数据结构的选择每一个函数的实现都直接关系到这个“小世界”的稳定和高效。当你的shell里能成功执行mkdir test; cd test; echo “hello” file.txt; cat file.txt这一串命令并看到正确输出时那种成就感是无可比拟的。它带给你的是对计算机系统底层运作方式的深刻洞察这种洞察力是任何教科书和视频课程都无法直接赋予的。

C语言模拟Linux文件系统：从零实现教学级文件系统核心

相关推荐

听劝！新手买萨克斯，90%人都会踩的3个坑（附高性价比型号推荐）

多目标跟踪MOT(Multiple Object Tracking)核心算法演进与实战解析

2026新手电钢琴选购攻略！6款高性价比电钢琴实测推荐

更多资讯

Cataclysm-DDA 建造教程：用 2 步建起第一堵砖墙

TextKit2实战：重构iOS小说阅读器文字渲染架构

核心模块与导入导出链路的契约一致性校准

Anthropic-Cybersecurity-Skills 实战：OSINT 外部侦察 Agent 的 API 参考与源码级解析

Node.js彻底卸载与安装最佳实践指南

Rockchip平台scrcpy DMA-BUF泄漏导致黑屏根因与修复

今日更新

SpacetimeDB C++ 模块库实战：用 C++20 在数据库内构建 WebAssembly 模块

别踩雷！不是所有 AI 写作工具都靠谱，2026 高校认可工具精选

SSM+MySQL幼儿园管理系统源码解析：从部署到优化

本周精选

超人会飞不算本事：系统稳定依赖清晰规则与边界设计

超人VS蜘蛛侠：拆解超级IP的影响力与传播方法论

基于CNN的调制信号识别：MATLAB实现时频图分类实战

本月热门

基于YOLO的焊缝缺陷检测：从数据标注到工业部署全流程实践

分布式服务的决策记录

创业产品的首版范围

读完文章，想聊聊您的网站？