《操作系统真象还原》第十四章 ---- 实现文件系统任务繁多饭得一口口吃路得一步步走啊（上一）

快来打我* 2022-09-03 05:09 23阅读 0赞

### 文章目录 ###

*   *  专栏博客链接
     *  相关查阅博客链接
     *  本书中错误勘误
     *  部分缩写熟知
     *  闲聊时刻
     *  实现文件系统的原理
     *   *  inode构建原理
         *  目录构建原理
         *  超级块构建思路
     *  创建文件系统
     *   *  编写完的super\_block.h
         *  编写完的inode.h
         *  编写完的dir.h
         *  编写完的fs.h
         *  编写完的fs.c
         *  修改后的ide.h
         *  修改后的MakeFile
         *  修改后的init.c
         *  创建文件系统的debug心路历程
     *  make all 验证成果（实现操作系统）
     *   *  第一个make all阶段（第一次给分区装载文件系统）
         *  第二个make all阶段（第二次给分区装载文件系统+挂载）

--------------------

## 专栏博客链接 ##

--------------------

**[《操作系统真象还原》从零开始自制操作系统 全章节博客链接][Link 1]**

--------------------

## 相关查阅博客链接 ##

--------------------

**[linux 中“.”和“…”代表什么意思][linux _.]**  
**[C语言中extern的用法][C_extern]**

--------------------

## 本书中错误勘误 ##

--------------------

## 部分缩写熟知 ##

--------------------

**`fs` `file system`文件系统**  
**`ft` `file type`文件类型**

**由于我没怎么用过`.` `..`经常用 所以下面提一嘴**  
**在`Linux`中 `.`是当前目录 `..`是到上一级目录**

--------------------

## 闲聊时刻 ##

--------------------

**各位看官 又来到了每章必到的闲聊时刻了哈 哈哈  
这次我想想又想聊点什么呢 感觉刚刚有很多话想说 自己编辑的时候的又写不出来什么**

**就是聊一下最近写这个《操作系统真象还原》相关的章节博客嘛 其实说实话 因为每一章其实我都是自己定了时间大概多久就必须完成 但其实往往每一章花的时间要比我预计的时间还是要多个一天多**

**除此之外呢 其实我真的觉得写这个还是相当的不轻松的 当然书籍作者是最不轻松的 不仅要把代码写完 还要以各种方式把整个实现给呈现出来**  
**不轻松的原因就是 我还是特别希望整个操作系统十五章 每一章的博客我都尽量写的细致一点 当然最主要的原因是 写操作系统的代码确实太不好写了**

**细节多 而且我是属于全部都自己能思考清楚之后 我再大部分看了代码 自己再写一遍 而不是属于很纯粹的`copy` 你让那些`copy`代码的人来说一下 各种地方的实现原理 我相信是根本说不出来的 而且这个写操作系统纯`copy`代码的人而言 是真的我不相信有几个能写下来 哈哈**

**为什么我会这样说呢 因为我自己的情况就是 比如写一章花的时间是12小时 3-5小时敲代码 + 6-7小时调试各种问题 + 2-3个小时写博客 这里当然是抛开了思考时间 看书的时间**  
**不清楚思路 不清楚代码为什么这样写的人 写出来的代码出现了问题 你让他去`debug` 哈哈 根本就是痴人说梦了 而且书中时不时的还会出现一些错误 不带着思考审视的眼光去看 去写代码 很多地方就会被卡死**

**现在也来到了倒数第二章了 我看了看内容 这十四章的实现思路总的来说呢 还是挺清晰的 后面我应该会先写思路写出来 再给代码**

**写了那么多 其实我当时就想说 写这个操作系统 真的得连续花时间一鼓作气写下去 如果心里面不沉淀下来 很多人中途就会放弃 而且其实写这个的这段时间 我总是感觉有一个沉沉的担子在身上 就是感觉心里面装了事情 一点都不轻松 可能到最后操作系统写完的那一天 我把最后的博客发了 并且把代码先全贴出来 看能不能放到`github`上面 最后再贴个链接 可能要给自己放个一天的假了 哈哈哈哈 到时候再说吧 先一步步做着走 那下面再见**

**这是第二次编辑 由于本章内容超级多 且我想这一章就分六个博客结束**  
**上一 上二 中一 中二 下一 下二 所以请各位看官耐心一点点 进度和代码都是一点点在迭代**

**那就下面见了！**

--------------------

## 实现文件系统的原理 ##

--------------------

**这个的话 还是内容挺多的 刚刚和我的好homie聊了会天 聊了个把小时 一直没心思写这部分的内容 现在静下来了 我就来写一下**

**我们话说在前面  
我们不聊`FAT`文件系统 `FAT`文件系统不好的地方 就在于每个文件节点的末尾都用链表链接 每次寻找文件的话都只能通过链表遍历一遍才能找到**

**好了 说了不聊还是聊了一下 哈哈 回到我们的重点**

--------------------

### inode构建原理 ###

--------------------

**我们采用`Linux`文件系统的思路 什么是核心呢 `inode` 对 `inode`起到什么作用呢 `inode`基本上可以代表着文件 这个话说的有点武断 但是我们可以通过`inode`寻找到文件所在的磁盘位置 这是怎么寻找到的呢 我们先介绍这个 待会在介绍上一层的目录**

**我们对硬盘进行了分区 当然可以不分 先不聊分区 `linux` 中的`inode` 有多少`inode`就有多少文件 `inode`中有个`15`的整型数组 其中`0-12`是直接的`lba`块所在直接编号 这够直接吧 对的 我们通过访问`inode`中的数组就能直接找到文件所在的块位置 那一个块大小挺小的 `15`个整型数组怎么存放的到那么多块呢 比如一个文件`2GB` 我们怎么存放呢 对了 可能有聪明的hxd就想到了 我们的第13号可以指定一个区域的块 里面存放着块信息 这样是不是就扩大了呢 哈哈 那怎么扩的更大呢 我们第14号就指定的那个区域 里面的区域全是存放着另一个区域的块号 而那个另一个区域里面再负责指定精准块号不就行了吗 哈哈 这样其实就相当多了 依次类推即可**

**对了 再额外提一嘴 `inode`里面除了存放文件具体存储在哪些块 还存放着 文件日期 访问权限 大小 当然还有编号 除了大小 编号 其他的都是比较成熟的文件系统构建的 我们的小型系统就不构建这些啦 哈哈**

**`inode`文件并不关心里面装的是什么类型 并且里面也没有说明 但是这和我们平时的认识就冲突了 我们的文件有各种类型 比如在`windos下的` `mp4` `jpg` `docx` 那我们访问的时候怎么知道文件是什么类型呢 哈哈 而且我们平时访问文件的时候也根本没有出现`inode` 我们又是怎么访问到的呢 这又要引出下面一个概念了 目录 各位看官往下看**

--------------------

### 目录构建原理 ###

--------------------

**站在`inode`的上一层 我的理解就是目录 比如我们的`windows` 我们与文件的交互 都是利用图标与文件名 对吧 不存在什么`inode`编号 如果我们访问每个文件都是采用输入`inode`编号来访问的 那也是真的太烦人了吧 哈哈**

**目录是干什么的呢 我们与文件交互都是利用文件名 而且我们也会给文件命名 文件系统是以一种树的类型建立起来的 我们访问一个文件 如果目录项里面的文件名和我们的文件名匹配 并且目录项里面存放着的有该文件的`inode`编号 以及文件类型 我们不是可以把相关文件交给相关文件处理文件处理啦 那我们上面的问题不是迎刃而解了 是吧**

**注意 `inode`可不管你文件类型是什么 这叫给目录项来管理 但是我们访问目录找到指定的文件 是一级一级的寻找 我们是不是必须要把根目录给固定下来 找`inode`首先需要先找目录 找到对应的`inode`编号 再通过`inode`编号找到具体的`inode` 再通过具体的`inode`访问到对应的块**

**那找目录 我们从哪里开始找呢 对了 就是根目录 我们必须要把根目录固定下来 不然每次我们都不知道在哪里找目录 而目录文件也是文件类型的一种 找文件的话又要通过`inode`找 找`inode`又要通过目录项来找 这样的话进入死循环了 怎么办**

**就如我说的那样 固定 固定下来 我们必须要把最底层的东西固定下来 我们的第一个`inode`固定成根目录的专属`inode` 每一次找根目录 直接找固定下来的根目录位置 那我们怎么找固定根目录位置呢 哈哈 这又要引入一个下面的一个概念了 超级块**

**上面说了那么多 根目录是最地基需要固定好的**

--------------------

### 超级块构建思路 ###

--------------------

**书上我记得有一句话说的特别好 就是其实很多在上面的东西 都必须要依靠最底层最固定的东西 仔细想了一想是这个样子的**  
**都写到接近尾声了 我现在都还能记得 我们第一步写`mbr`的时候 `cpu`读入的时候 不都是确定了必须是硬盘的第一块扇区吗 就像`mbr`也必须是确定要512字节的 很多东西都是必须要确定下来 后面的东西才能依次开展**

**超级块 是干什么的呢 我们既然要分区 那我们很多地方的起始位置 或者 存放位置是不是得固定下来 比如`inode数组`的位置 `inode数组`由位图来管理 空闲块也由位图来管理 这些位图位置是不是得放好了之后得存在超级块里面呢**

**那当然 超级块的位置肯定是确定好了 我们放在哪里呢 哈哈 这又得说 我们的引导块是放在除去第一个扇区后面的 我把书上的原图拍下来是给弄在这里 方便各位学习**

**哈哈 是不是特别贴心**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTAwNTE2_size_16_color_FFFFFF_t_70]

--------------------

**然后超级块里面 也是存放着该分区的各种信息 很多很多 这里也可以贴一下 我就懒得说那么多了 哈哈 当然这是我们的小型操作系统所要用的 其他的都很少**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTAwNTE2_size_16_color_FFFFFF_t_70 1]

--------------------

**总得来说就是那么多了 代码里面我可是满满的注释 超级详细 哈哈 直接上代码咯**

--------------------

## 创建文件系统 ##

--------------------

### 编写完的super\_block.h ###

--------------------

**路径`fs/super_block.h`**

#ifndef __FS_SUPER_BLOCK_H
    #define __FS_SUPER_BLOCK_H
    
    struct super_block
    { 
        uint32_t magic;			//表示文件系统类型
        
        uint32_t sec_cnt;			//扇区数量
        uint32_t inode_cnt;		//分区中的inode数量
        uint32_t part_lba_base;    	//分区lba起始位置
        
        uint32_t block_bitmap_lba;	//块位图本身起始扇区lba地址
        uint32_t block_bitmap_sects;	//块位图所占的扇区数
        
        uint32_t inode_bitmap_lba;	//inode位图本身起始扇区lba地址
        uint32_t inode_bitmap_sects;	//inode位图所占的扇区数
        
        uint32_t inode_table_lba;		//inode数组本身起始扇区lba地址
        uint32_t inode_table_sects;	//inode数组所占扇区数
        
        uint32_t data_start_lba;		//存放数据区开始的第一个扇区号
        uint32_t root_inode_no;		//根目录所在的inode号
        uint32_t dir_entry_size;		//目录项大小
        
        uint8_t pad[460];			//13 * 4 + 460 = 512 为了后面位图起始位置一些列方便
    }; __attribute__ ((packed));
    
    #endif

--------------------

### 编写完的inode.h ###

--------------------

**路径`fs/inode.h`**

#ifndef __FS_INODE_H
    #define __FS_INODE_H
    
    #include "list.h"
    
    struct inode
    { 
        uint32_t i_no;	     		//inode 编号
        uint32_t i_size;	     		//文件大小 或者 目录项总大小 inode不管是什么文件的
        
        uint32_t i_open_cnts;   		//记录此文件被打开的次数
        bool write_deny;	     		//写文件不能并行
        
        uint32_t i_sectors[13]; 		//这里只实现了一级简介块 12为一级简介块指针 0-11直接是inode编号
        struct list_elem inode_tag;	//从硬盘读取速率太慢 此list做缓冲用 当第二次使用时如果list中有
        					//直接通过list_elem得到inode而不用再读取硬盘
    };
    
    #endif

--------------------

### 编写完的dir.h ###

--------------------

#ifndef __FS_DIR_H
    #define __FS_DIR_H
    
    #define MAX_FILE_NAME_LEN 16 //最长16个字
    struct dir			//在内存中用的目录结构
    { 
        struct inode* inode;	//指向已经打开的inode指针
        uint32_t dir_pos;		//目录偏移位置
        uint8_t  dir_buf[512];	//目录的数据缓冲
    };
    
    struct dir_entry			//目录项
    { 
        char filename[MAX_FILE_NAME_LEN];	//16个字的名字
        uint32_t i_no;			//inode编号
        enum file_types f_type;		//文件类型 由此看是目录还是文件类型
    };
    
    #endif

--------------------

### 编写完的fs.h ###

--------------------

**路径`fs/fs.h`**

#ifndef __FS_FS_H
    #define __FS_FS_H
    #include "ide.h"
    
    
    #define MAX_FILES_PER_PART 4096 //每个扇区最大支持文件数
    #define BITS_PER_SECTOR 4096 //每扇区的位数 512字节 * 8
    #define SECTOR_SIZE 512 //每扇区的字节数 512字节
    #define BLOCK_SIZE SECTOR_SIZE //块字节大小 我们这里一块 == 一扇区
    
    enum file_types 
    { 
        FT_UNKNOWN,	//未知文件类型
        FT_REGULAR,	//普通文件类型
        FT_DIRECTORY	//目录文件类型
    };
    
    void partition_format(struct disk* hd,struct partition* part);
    bool mount_partition(struct list_elem* pelem,int arg);
    void filesys_init(void);
    
    #endif

--------------------

### 编写完的fs.c ###

--------------------

#include "fs.h"
    #include "stdint.h"
    #include "global.h"
    #include "../device/ide.h"
    #include "inode.h"
    #include "dir.h"
    #include "super_block.h"
    #include "stdio-kernel.h"
    #include "string.h"
    #include "debug.h"
    #include "list.h"
    
    struct partition* cur_part;	//默认操作分区
    
    void partition_format(struct disk* hd,struct partition* part)
    { 
        uint32_t boot_sector_sects = 1;		//引导块一个块
        uint32_t super_block_sects = 1;		//超级块一个块
        uint32_t inode_bitmap_sects = DIV_ROUND_UP(MAX_FILES_PER_PART,BITS_PER_SECTOR);  //inode位图占的块数
        										       //inode数组所占的块数
        uint32_t inode_table_sects = DIV_ROUND_UP((sizeof(struct inode) * MAX_FILES_PER_PART),SECTOR_SIZE);
        
        //注意这里的used_sects 肯定是不准确 差了那么一点点的 因为还没有包含block_bitmap_sects 但是为了简单处理 要先得到free_sects才能推 所以到后面block_bitmap_sects 要除两次
        uint32_t used_sects = boot_sector_sects + super_block_sects + inode_bitmap_sects + inode_table_sects;
        uint32_t free_sects = part->sec_cnt - used_sects;
        
        uint32_t block_bitmap_sects = DIV_ROUND_UP(free_sects,BITS_PER_SECTOR);	//一位一块
        uint32_t block_bitmap_bit_len = free_sects - block_bitmap_sects;	//再减去block_bitmap的
        block_bitmap_sects = DIV_ROUND_UP(block_bitmap_bit_len,BITS_PER_SECTOR);
        
        struct super_block sb;	        		//利用栈来初始化超级块 我们的栈此刻在
        sb.magic         = 0x23333333;			//魔数
        sb.sec_cnt       = part->sec_cnt; 		//该分区总扇区数
        sb.inode_cnt     = MAX_FILES_PER_PART;		//该分区总inode数
        sb.part_lba_base = part->start_lba;		//该分区lba起始扇区位置
        
        // 引导块 超级块 空闲块位图 inode位图 inode数组 根目录 空闲块区域
        //挨着挨着顺序赋值即可
        sb.block_bitmap_lba   = part->start_lba + boot_sector_sects + super_block_sects;
        sb.block_bitmap_sects = block_bitmap_sects;
        
        sb.inode_bitmap_lba   = sb.block_bitmap_lba + block_bitmap_sects;
        sb.inode_bitmap_sects = inode_bitmap_sects;
        
        sb.inode_table_lba    = sb.inode_bitmap_lba + inode_bitmap_sects;
        sb.inode_table_sects  = inode_table_sects;
        
        sb.data_start_lba     = sb.inode_table_lba + inode_table_sects;
        sb.root_inode_no	   = 0;			//根目录inode起始编号 0 
        sb.dir_entry_size     = sizeof(struct dir_entry); //目录项大小
        
        printk("%s info:\n",part->name);
        printk(" magic:0x%x\n part_lba_base:0x%x\n all_sectors:0x%x\n \ inode_cnt:0x%x\n block_bitmap_lba:0x%x\n block_bitmap_sectors:0x%x\n \ inode_bitmap_lba:0x%x\n inode_bitmap_sectors:0x%x\n \ inode_table_lba:0x%x\n inode_table_sectors:0x%x\n \ data_start_lba:0x%x\n", \
        sb.magic,sb.part_lba_base,sb.sec_cnt,sb.inode_cnt,sb.block_bitmap_lba,sb.block_bitmap_sects,\
        sb.inode_bitmap_lba,sb.inode_bitmap_sects,sb.inode_table_lba,\
        sb.inode_table_sects,sb.data_start_lba);   
        
        //把元信息挨个挨个写进硬盘
        ide_write(hd,part->start_lba + boot_sector_sects,&sb,super_block_sects);
        printk(" super_block_lba:0x%x\n",part->start_lba + 1);
        
        //找一个最大的数据缓冲区 我们的栈已经不足以满足我们的各种信息的储存了 之后还要把元信息给腾到硬盘中
        uint32_t buf_size = (sb.block_bitmap_sects >= sb.inode_bitmap_sects) ? sb.block_bitmap_sects : sb.inode_bitmap_sects;
        buf_size = ((buf_size >= inode_table_sects) ? buf_size : inode_table_sects) * SECTOR_SIZE;
        //申请缓冲空间 给元信息腾空间 设置成uint8_t* 原因是 先弄块位图的初始化
        uint8_t* buf = (uint8_t*)sys_malloc(buf_size);
        
        /* 初始化块位图了 */
        buf[0] |= 0x1;
        uint32_t block_bitmap_last_byte = block_bitmap_bit_len / 8; //先算算占用多少字节
        uint8_t block_bitmap_last_bit  = block_bitmap_bit_len % 8; //最后还有剩余多少位
        uint32_t last_size = SECTOR_SIZE - (block_bitmap_last_byte % SECTOR_SIZE); //先除余数 算出来多少字节空的
        
        //处理字节 把可能多的一字节全部置成1 这几步处理的很细节阿
        memset(&buf[block_bitmap_last_byte],0xff,last_size);	 //全部置1 保证不会被使用
        
        //处理最后的位 有效位变成0 用~来处理 真的很妙
        uint8_t bit_idx = 0;
        while(bit_idx <= block_bitmap_last_bit)
        	buf[block_bitmap_last_byte] &= ~(1 << (bit_idx++));	//有效位
        
        //把位图元信息给写到硬盘中 块位图的部分就结束了 还有inode位图 inode数组等着我们
        ide_write(hd,sb.block_bitmap_lba,buf,sb.block_bitmap_sects);
        
        /*初始化inode位图了*/
        memset(buf,0,buf_size);
        buf[0] |= 0x1;	                                          //第一个inode用于存根目录
        ide_write(hd,sb.inode_bitmap_lba,buf,sb.inode_bitmap_sects); //第一个inode初始化在后面
        
        /*初始化inode数组了*/
        memset(buf,0,buf_size);
        struct inode* i = (struct inode*)buf;			//先初始化第一个inode 根目录所在的
        i->i_size = sb.dir_entry_size * 2;			//. 和 .. 
        i->i_no   = 0;
        i->i_sectors[0]  = sb.data_start_lba;			//根目录所在扇区就是最开始的第一个扇区
        
        ide_write(hd,sb.inode_table_lba,buf,sb.inode_table_sects);
        
        /*写根目录文件进入 第一个扇区了*/
        memset(buf,0,buf_size);
        struct dir_entry* p_de = (struct dir_entry*)buf;
        
        memcpy(p_de->filename,".",1);				//名称
        p_de->i_no = 0;						//根目录. inode仍然是自己
        p_de->f_type = FT_DIRECTORY;
        p_de++;							//移动到下一条目录项
        
        memcpy(p_de->filename,"..",2);
        p_de->i_no = 0;						//根目录的父目录仍然是自己 因为自己是固定好的 根基
        p_de->f_type = FT_DIRECTORY;
        
        ide_write(hd,sb.data_start_lba,buf,1);			//把根目录文件写到第一个扇区中
        
        printk(" root_dir_lba:0x%x\n",sb.data_start_lba);
        printk("%s format done\n",part->name);
        sys_free(buf);						//临时借用的 现在得还回去了 
    }
    
    //除了挂载 还需要在内存中把超级块指针 块位图 i结点位图 i结点指针给初始化赋值了 方便使用
    bool mount_partition(struct list_elem* pelem,int arg)
    { 
        char* part_name = (char*)arg;
        struct partition* part = elem2entry(struct partition,part_tag,pelem);//得到分区指针 partition*
        if(!strcmp(part->name,part_name))					   //字符串相匹配
        { 
        	cur_part = part;						   //赋值指针
        	struct disk* hd = cur_part->my_disk;
        	
        	struct super_block* sb_buf = (struct super_block*)sys_malloc(SECTOR_SIZE);
        	if(sb_buf == NULL)
        	    PANIC("alloc memory failed!");
        	
        	memset(sb_buf,0,SECTOR_SIZE);
        	ide_read(hd,cur_part->start_lba + 1,sb_buf,1);
        	
        	cur_part->sb = sb_buf;
        	
        	cur_part->block_bitmap.bits = (uint8_t*)sys_malloc(sb_buf->block_bitmap_sects * SECTOR_SIZE);
        	if(cur_part->block_bitmap.bits == NULL)
        	   PANIC("alloc memory failed!");
        	cur_part->block_bitmap.btmp_bytes_len = sb_buf->block_bitmap_sects * SECTOR_SIZE;
        	ide_read(hd,sb_buf->block_bitmap_lba,cur_part->block_bitmap.bits,sb_buf->block_bitmap_sects);
        	
            cur_part->inode_bitmap.bits = (uint8_t*)sys_malloc(sb_buf->inode_bitmap_sects * SECTOR_SIZE);
            if(cur_part->inode_bitmap.bits == NULL)
        	   PANIC("alloc memory failed!");
        	cur_part->inode_bitmap.btmp_bytes_len = sb_buf->inode_bitmap_sects * SECTOR_SIZE;
        	ide_read(hd,sb_buf->inode_bitmap_lba,cur_part->inode_bitmap.bits,sb_buf->inode_bitmap_sects);
        	
        	list_init(&cur_part->open_inodes);
        	printk("mount %s done!\n",part->name);
        	return true;	//停止循环
        	
        }
        return false;	//继续循环
    }
    
    //文件系统初始化 磁盘上搜索 如果没有则格式化分区 并创建文件系统
    void filesys_init(void)
    { 
        uint8_t channel_no = 0,dev_no,part_idx = 0;
        struct super_block* sb_buf = (struct super_block*)sys_malloc(SECTOR_SIZE);
        
        if(sb_buf == NULL)	PANIC("alloc memory failed!");
        printk("searching filesysteam......\n");
        while(channel_no < channel_cnt)
        { 
        	dev_no = 1;
        	while(dev_no < 2)
        	{ 
        	    if(!dev_no)	//跳过hd60M.img主盘
        	    { 
        	    	++dev_no;	
        	    	continue;
        	    }
        	    struct disk* hd = &channels[0].devices[1];		//得到硬盘指针
        	    struct partition* part = hd->prim_parts;				//先为主区创建文件系统
        	    while(part_idx < 12)		//4个主区 + 8个逻辑分区
        	    { 
        	    	if(part_idx == 4)
        	    	    part = hd->logic_parts;	
        	    	if(part->sec_cnt != 0)		//分区存在 如果没有初始化 即所有成员都为0
        	    	{ 
        	    	    memset(sb_buf,0,SECTOR_SIZE);
        	    	    ide_read(hd,part->start_lba +1,sb_buf,1);	//读取超级块的扇区
        	    	    
        	    	    if(sb_buf->magic != 0x23333333)			//还没有创建文件系统
        	    	    { 
        	    	    	printk("formatting %s's partition %s......\n",\
        	    	    	hd->name,part->name);
        	    	    	partition_format(hd,part);
        	    	    }
        	    	    else
        	    	    	printk("%s has filesystem\n",part->name);
        	    	}
        	    	++part_idx;
        	    	++part;	//到下一个分区看
        	    }
        	    ++dev_no;		//切换盘号
        	}
        	++channel_no;		//增加ide通道号
        }
        sys_free(sb_buf);
        char default_part[8] = "sdb1";	//参数为int 4字节字符串指针传的进去
        list_traversal(&partition_list,mount_partition,(int)default_part);
    }

--------------------

### 修改后的ide.h ###

--------------------

**增加下面三条**

extern uint8_t channel_cnt;
    extern struct ide_channel channels[2];
    extern struct list partition_list;

--------------------

### 修改后的MakeFile ###

--------------------

BUILD_DIR = ./build
    ENTRY_POINT = 0xc0001500
    AS = nasm
    CC = gcc
    LD = ld
    LIB = -I lib/ -I lib/kernel/ -I lib/user/ -I kernel/ -I device/ 
    ASFLAGS = -f elf
    CFLAGS = -Wall -m32 -fno-stack-protector $(LIB) -c -fno-builtin -W -Wstrict-prototypes -Wmissing-prototypes
    LDFLAGS =  -m elf_i386 -Ttext $(ENTRY_POINT) -e main -Map $(BUILD_DIR)/kernel.map
    OBJS = $(BUILD_DIR)/main.o $(BUILD_DIR)/init.o $(BUILD_DIR)/interrupt.o \
          $(BUILD_DIR)/timer.o $(BUILD_DIR)/kernel.o $(BUILD_DIR)/print.o $(BUILD_DIR)/switch.o \
          $(BUILD_DIR)/debug.o $(BUILD_DIR)/string.o $(BUILD_DIR)/memory.o \
          $(BUILD_DIR)/bitmap.o $(BUILD_DIR)/thread.o $(BUILD_DIR)/list.o \
          $(BUILD_DIR)/sync.o $(BUILD_DIR)/console.o $(BUILD_DIR)/keyboard.o \
          $(BUILD_DIR)/ioqueue.o $(BUILD_DIR)/tss.o $(BUILD_DIR)/process.o \
          $(BUILD_DIR)/syscall-init.o $(BUILD_DIR)/syscall.o $(BUILD_DIR)/stdio.o \
          $(BUILD_DIR)/stdio-kernel.o $(BUILD_DIR)/ide.o $(BUILD_DIR)/fs.o
          
    ##############     c代码编译     ###############
    $(BUILD_DIR)/main.o: kernel/main.c lib/kernel/print.h \
            lib/stdint.h kernel/init.h lib/string.h kernel/memory.h \
            thread/thread.h kernel/interrupt.h device/console.h \
            device/keyboard.h device/ioqueue.h userprog/process.h \
            lib/user/syscall.h userprog/syscall-init.h lib/stdio.h \
            lib/kernel/stdio-kernel.h
    	$(CC) $(CFLAGS) $< -o $@
    
    $(BUILD_DIR)/init.o: kernel/init.c kernel/init.h lib/kernel/print.h \
            lib/stdint.h kernel/interrupt.h device/timer.h kernel/memory.h \
            thread/thread.h device/console.h device/keyboard.h userprog/tss.h \
            userprog/syscall-init.h device/ide.h fs/fs.h
    	$(CC) $(CFLAGS) $< -o $@
    
    $(BUILD_DIR)/interrupt.o: kernel/interrupt.c kernel/interrupt.h \
            lib/stdint.h kernel/global.h lib/kernel/io.h lib/kernel/print.h \
            kernel/kernel.h
    	$(CC) $(CFLAGS) $< -o $@
    
    $(BUILD_DIR)/timer.o: device/timer.c device/timer.h lib/kernel/io.h lib/kernel/print.h \
            kernel/interrupt.h thread/thread.h kernel/debug.h kernel/global.h
    	$(CC) $(CFLAGS) $< -o $@
    
    $(BUILD_DIR)/debug.o: kernel/debug.c kernel/debug.h \
            lib/kernel/print.h lib/stdint.h kernel/interrupt.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/string.o: lib/string.c lib/string.h \
    	kernel/debug.h kernel/global.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/memory.o: kernel/memory.c kernel/memory.h \
    	lib/stdint.h lib/kernel/bitmap.h kernel/debug.h lib/string.h kernel/global.h \
    	thread/sync.h thread/thread.h lib/kernel/list.h kernel/interrupt.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/bitmap.o: lib/kernel/bitmap.c lib/kernel/bitmap.h kernel/global.h \
    	lib/string.h kernel/interrupt.h lib/kernel/print.h kernel/debug.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/thread.o: thread/thread.c thread/thread.h \
    	lib/stdint.h lib/string.h kernel/global.h kernel/memory.h \
    	kernel/debug.h kernel/interrupt.h lib/kernel/print.h \
    	userprog/process.h thread/sync.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/list.o: lib/kernel/list.c lib/kernel/list.h \
    	kernel/interrupt.h lib/stdint.h kernel/debug.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/sync.o: thread/sync.c thread/sync.h \
    	lib/stdint.h thread/thread.h kernel/debug.h kernel/interrupt.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/console.o: device/console.c device/console.h \
    	lib/kernel/print.h thread/sync.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/keyboard.o: device/keyboard.c device/keyboard.h \
    	lib/kernel/print.h lib/kernel/io.h kernel/interrupt.h \
    	kernel/global.h lib/stdint.h device/ioqueue.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/ioqueue.o: device/ioqueue.c device/ioqueue.h \
    	kernel/interrupt.h kernel/global.h kernel/debug.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/tss.o: userprog/tss.c userprog/tss.h \
    	kernel/global.h thread/thread.h lib/kernel/print.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/process.o: userprog/process.c userprog/process.h \
    	lib/string.h kernel/global.h kernel/memory.h lib/kernel/print.h \
    	thread/thread.h kernel/interrupt.h kernel/debug.h device/console.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/syscall-init.o: userprog/syscall-init.c userprog/syscall-init.h \
    	lib/user/syscall.h lib/stdint.h lib/kernel/print.h kernel/interrupt.h thread/thread.h \
    	kernel/memory.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/syscall.o: lib/user/syscall.c lib/user/syscall.h 
    	$(CC) $(CFLAGS) $< -o $@
    
    $(BUILD_DIR)/stdio.o: lib/stdio.c lib/stdio.h lib/stdint.h lib/string.h lib/user/syscall.h
    	$(CC) $(CFLAGS) $< -o $@
    
    $(BUILD_DIR)/stdio-kernel.o: lib/kernel/stdio-kernel.c lib/kernel/stdio-kernel.h \
    	lib/stdio.h device/console.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/ide.o: device/ide.c device/ide.h lib/stdint.h kernel/debug.h \
    	lib/kernel/stdio-kernel.h lib/stdio.h kernel/global.h thread/sync.h \
    	lib/kernel/io.h device/timer.h kernel/interrupt.h lib/kernel/list.h fs/fs.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/fs.o: fs/fs.c fs/fs.h lib/stdint.h kernel/global.h device/ide.h fs/inode.h fs/dir.h \
    	fs/super_block.h lib/kernel/stdio-kernel.h lib/string.h kernel/debug.h lib/kernel/list.h
    	$(CC) $(CFLAGS) $< -o $@
    
    ##############    汇编代码编译    ###############
    $(BUILD_DIR)/kernel.o: kernel/kernel.S
    	$(AS) $(ASFLAGS) $< -o $@
    
    $(BUILD_DIR)/print.o: lib/kernel/print.S
    	$(AS) $(ASFLAGS) $< -o $@
    
    $(BUILD_DIR)/switch.o: thread/switch.S
    	$(AS) $(ASFLAGS) $< -o $@
    
    ##############    链接所有目标文件    #############
    $(BUILD_DIR)/kernel.bin: $(OBJS)
    	$(LD) $(LDFLAGS) $^ -o $@
    
    .PHONY : mk_dir hd clean all
    
    mk_dir:
    	if [ ! -d $(BUILD_DIR) ]; then mkdir $(BUILD_DIR); fi
    
    hd:
    	dd if=$(BUILD_DIR)/kernel.bin \
               of=/home/cooiboi/bochs/hd60M.img \
               bs=512 count=200 seek=9 conv=notrunc
    
    clean:
    	cd $(BUILD_DIR) && rm -f  ./* build: $(BUILD_DIR)/kernel.bin all: mk_dir build hd

--------------------

### 修改后的init.c ###

--------------------

#include "init.h"
    #include "print.h"
    #include "interrupt.h"
    #include "../device/timer.h"
    #include "memory.h"
    #include "../thread/thread.h"
    #include "../device/console.h"
    #include "../device/keyboard.h"
    #include "../userprog/tss.h"
    #include "../userprog/syscall-init.h"
    #include "../device/ide.h"
    #include "../fs/fs.h"
    
    /*负责初始化所有模块 */
    void init_all() { 
       put_str("init_all\n");
       idt_init();	     // 初始化中断
       mem_init();
       timer_init();
       thread_init();
       console_init();
       keyboard_init();
       tss_init();
       syscall_init();
       ide_init();
       filesys_init();
    }

--------------------

### 创建文件系统的debug心路历程 ###

--------------------

**这部分与其说是创建文件系统的debug心路历程 还不如说是悲惨史 哈哈**  
**真的还是挺惨的 感觉表面上我博客代码写的那么多 内容写的那么充实 其实背后我写代码 `make all`编译不知道实现一部分功能我就需要调试编译几十次 如果出现大功能 整体做完出错了 我可能需要纠错 编译上百次 + 修改一些最基本的语法错误 总之还是真的很累人的**

**这次在创建文件系统最后的读取超级块的时候发生了错误  
当时的时候 我心里面还没什么感觉 就觉得哪里肯定写了一点错误 但在排查了一个小时 用`while(1);` 断点尝试之后 发现就是在`ide_read()`函数出了错**

**我之后仔细思考了一下 如果到后面的`filesys_init`才出错的话  
前面的`ide_init`也是用了函数`filesys_init` 但我们的读取的内容都是对的  
怎么到`filesys_init`就出错了 此时我在想是不是线程切换出了错 此时我就倒吸了一口冷气 线程切换这个出了错那是相当不好调试的 啊 怎么办**

**没办法 只能一行一行尝试 断点尝试`while(1)` 并尝试`printk`一些数据 看一下是不是哪里访问出错了 在从上午的11点到下午的2点 终于有了突破 发现错误在于`ide_read函数`中的`read_from_sector();`函数**

**我刚开始认为是不是中断在那几次读过了之后就被屏蔽了 但在尝试了几次后 就发现没有问题 之后又想了想 不会是内存分配的问题吧 毕竟我们的内存都是`malloc`出来的 我一直觉得`malloc`那个地方细节太多了 真的调试起来难度相当相当大 最后在尝试了几次`malloc`都发现挺合情合理的**

**那问题在哪里呢 在我摸不着头脑时 我就把`ide_read`函数放在了`sema_down`的前面 结果就发现不出错了 我当时冷汗更是直冒 问题出在`sema_down`啊 但我事后仔细想了想 `sema_down`的核心就在于阻塞 而核心应该是`schedule`调度函数 一次偶然的尝试下 我看了看我们`ide_read`前我们的页表 竟然发现我们的页表 我们分配的虚拟地址竟然不在页表中 我真的服了**

**之后又想了想 在`schedule`前后 `schedule`前可以`ide_read` `schedule`后出错 后面进行了两次断点 发现如下图的页表**  
**我们分配的虚拟地址是在`0xc0101c0c` 分配了512字节 最高地址在`0xc0101e0c` 还没有到`0xc0101ffff`**

**没有`schedule`前的页表**  
![在这里插入图片描述][62eeef2038ea4151b3c787a1782e9d96.png]  
**`schedule`后的页表**  
![在这里插入图片描述][bbca8b1726234ea38a64f37f0b9be7a3.png]

--------------------

**厚米 我是相当无语 我想了想`schedule`唯一和页表有关系的  
只有`page_dir_activate`函数中的  
`asm volatile ("movl %0,%%cr3" : : "r"(pagedir_phy_addr) : "memory");`**

**我之后仔细想了哈 不对啊 我们的初始化都在内核啊 只是重新装载了相同的物理地址 页表应该是相同的啊 怎么会出现不一样的页表 而且内核区域的页表一直都是相同的物理地址`0x100000`**

**之后我就很明确感觉到 问题肯定在`memory.c` 中的`sys_malloc` 和`sys_free`  
因为那里面的函数 很多涉及页表位置的修改 页表项的移除与还原**  
**于是在我一行一行的代码的对比纠察下 功夫不负有心人 终于找到了凶手**  
**就是在`sys_free`的最后两行代码 少写了两行代码 其中的赋值后面还画蛇添足的加了个`++`**  
**在修改后 终于一切都正常的运转起来了**  
**这就是一次 我`debug`的全程的想法和心路历程 相当的折磨**

**其实之前写的每一章博客 基本上每一章都有这样类似的bug出现 每一次我都是心力劳损的一点点慢慢的修改 这样类似的情况还有很多很多次 只是这次我想着已经快接近尾声了 还是写点有意思的东西吧**  
**不然表面上看上去写操作系统很简单的样子 哈哈 其实真的挺难的 各种问题和意想不到的事情发生 都需要耐住性子一点点去解决 一点点去磨**

**哈哈 这部分就先写到这里 毕竟是事后了 现在的心情肯定是舒畅的 那个时候肯定是比较难受的 哈哈**

--------------------

## make all 验证成果（实现操作系统） ##

--------------------

**这里分两个个阶段 因为写入硬盘就直接写入了 和内存不一样  
所以的话 最后一次重复的时候我们的文件系统已经创建完成 所以就直接出现`sda1 has filesystem`  
`sda5 has filesystem`  
`sda6 has filesystem`  
`sda7 has filesystem`  
`sda8 has filesystem`  
`sda9 has filesystem`**

--------------------

### 第一个make all阶段（第一次给分区装载文件系统） ###

--------------------

**这里的话 我当时把`filesys_init`放到了`ide_init的最后了` 就导致最后一句是`ide_init done` 后面就单独弄出来了**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTAwNTE2_size_16_color_FFFFFF_t_70 2]

--------------------

### 第二个make all阶段（第二次给分区装载文件系统+挂载） ###

--------------------

**第二次的时候不仅装好了文件系统 还弄好了挂载 如下图所示  
各位下篇见！**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTAwNTE2_size_16_color_FFFFFF_t_70 3]

--------------------

[Link 1]: https://love6.blog.csdn.net/article/details/119133589
[linux _.]: https://zhidao.baidu.com/question/1308613892595128819.html
[C_extern]: https://blog.csdn.net/zwl1584671413/article/details/79061866
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTAwNTE2_size_16_color_FFFFFF_t_70]: /images/20220829/0850d211e6984c699c61b1014474ca42.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTAwNTE2_size_16_color_FFFFFF_t_70 1]: /images/20220829/3d74d6cf2204435f88ff29552ea4a240.png
[62eeef2038ea4151b3c787a1782e9d96.png]: /images/20220829/efd046a2bdf54f51a1c087ffb0ec8293.png
[bbca8b1726234ea38a64f37f0b9be7a3.png]: /images/20220829/1a0d10c69d9449b6ad940d78a16679c3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTAwNTE2_size_16_color_FFFFFF_t_70 2]: /images/20220829/415cd25ad74e4055a6928c7613f51e1c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTAwNTE2_size_16_color_FFFFFF_t_70 3]: /images/20220829/b4b93e102b67469998fbd19276fdc7f4.png