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

淩亂°似流年 2022-09-03 13:17 55阅读 0赞

### 文章目录 ###

*   *  专栏博客链接
     *  相关查阅博客链接
     *  本书中错误勘误
     *  闲聊时刻
     *  部分缩写熟知
     *  实现文件描述符的原理
     *   *  文件描述符的介绍
         *  文件描述符与inode的介绍
         *  文件描述符与PCB的描述符数组的介绍
     *  实现文件操作基础函数（仅实现到文件建立sys\_open）
     *   *  编写完的inode.c
         *  编写完的inode.h
         *  编写完的file.c
         *  编写完的file.h
         *  编写完的dir.c
         *  编写完的dir.h
         *  编写完的fs.c
         *  编写完的fs.h
         *  修改后的MakeFile
         *  修改后的main.c
     *  make all 验证sys\_open功能实现成功
     *   *  xxd.sh文件代码
         *  得到sda1起始数据扇区号
         *  验证根目录是否建立成功
         *  第一次调用sys\_open
         *  第二次调用sys\_open

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

## 专栏博客链接 ##

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

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

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

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

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

## 本书中错误勘误 ##

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

## 闲聊时刻 ##

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

**由于第十四章的内容超级多 而且都是重活累活 各种地方到处都是函数 所以可能我预计的是分上中下三篇来写 这里是第二次编辑 现在来看肯定三篇是写不完的 可能要分 上中下续一续二 可以肯定的是 这个第十四章 绝对是所有章节中 最难啃最难啃的 代码超级多 你说实现起来难吧 思路难吧 肯定是相比进线程切换 内存分配那些更简单的 但由于各种函数的问题 而且细节也还是挺多的 尤其是代码量超级超级多 我做一天下来 可能才能做个几章 而且还需要debug 所以进度更慢了**

**我其实操作系统预计应该8.7日就应该写完的 但是现在已经是8.7日的晚上的11点了 我晚上7点才回到的成都 9点才到的家 而文件操作的函数才把最基本的`inode`操作写完 所以 哎 希望这两天加把力 早点完结这个系列**

**至于为什么回成都 因为学校里面各种事情心情很烦 不可抗力我就回到了家里面了 哎 一言难尽 呜呜**

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

## 部分缩写熟知 ##

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

**`fd` `file description` 文件描述符**  
**`slot` 空隙 间隙**  
**`RDONLY` `Read Only`只读**  
**`WRONLY` `Write Only`只写**  
**`RDWR` `Read Write` 可写可读**  
**`CREAT` `Create` 创造**

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

## 实现文件描述符的原理 ##

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

**说实话 刚哥如果把文件系统放在最前面的话 我就已经被劝退了 后面肯定都写不下去了 但是呢 现在又写了很多了 就差最后一章半了 很多函数真的写起来太多了 而且很容易写错 哎 只能再咬咬牙坚持写一点**

**这里来说一下文件描述符的原理 为什么要出现这个东西  
首先我们上一节实现了文件系统 那我们怎么管理文件呢 系统建立好了 我们总得有方法打开文件吧 所有的文件操作得由东西管理吧 就比如权限 访问**

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

### 文件描述符的介绍 ###

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

**这就得引出一个概念了 文件描述符**  
**我们先从底层原理说 我们怎么用 我们的文件描述表是全局变量 我们可以这样理解 就是一个操作系统最大打开文件的数量 我们每打开一个文件 无论是相同的还是不同的 都会创建一个文件描述符 里面具体有什么内容呢 我下面贴一个图 就大概是这样的**

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

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

### 文件描述符与inode的介绍 ###

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

**每打开一个新文件就会创建一个文件描述符 在文件描述符管理表中 对的 可能这个时候你想得到了 文件和什么有关 肯定是inode相关啊 我们在文件系统访问文件全靠着inode来寻找扇区号来访问**

**那我们就需要把文件描述符和inode结点相关到一起了 这个时候有个关系就是**  
**`文件描述符->inode` 可以这样理解吧 每次我们访问文件的时候都是通过目录文件路径来访问的 对吧 这个就和上面的文件系统有关了  
我先谈一嘴 `sys_open`的函数定义是`int sys_open(const char* pathname,uint8_t flags)` 先可以不用太管`flags` `flags`是你访问这个文件的目的 有`WRITE` `READ` `WRITE READ` `CREATE` 这个后面会将**  
**然后你看我们访问文件就是给的路径 由于有目录可以寻找都`inode` 我们是不是就得到了`inode`号了 前面说了 我们每访问一个文件 就要创建一个描述符表 我们可以同时打开多个相同文件 每个也都必须要创建一个 我们就可以在全局描述符表中找到空位然后把描述符写了 并指向那个`inode`即可**

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

### 文件描述符与PCB的描述符数组的介绍 ###

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

**这里就完了吗 还差一两步 由于我们在操作系统中 我们执行的每个任务我们都是以进程的方式来访问的 所以每次访问文件 同样进程的`PCB`中是需要局部的描述符数组的 但是呢 里面的每个只是数字 负责只向全局描述符的每一项 最后`sys_open`的返回值 就是返回的`PCB`中的全部描述符数组的数组下标 我们通过那个下标 即可得到那个文件的描述符 最后再得到访问文件 一切都`make sense`了 感觉这样说起来有点乱 这样 我下面放个图 一目了然**

**那话就不多说了 原理就是这样 剩下的只有很多的函数底层实现 和 高层功能实现 把所有的底层实现函数串联起来实现功能而已 任务很多 代码很多 任务艰巨啊 各位看官往下看吧**

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

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

## 实现文件操作基础函数（仅实现到文件建立sys\_open） ##

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

**下面的文件后面实现其他函数的时候可能还会更迭修改**  
**这里是仅仅实现到sys\_open**

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

### 编写完的inode.c ###

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

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

#include "inode.h"
    #include "ide.h"
    #include "debug.h"
    #include "../thread/thread.h"
    #include "memory.h"
    #include "string.h"
    #include "list.h"
    #include "interrupt.h"
    
    //得到inode 所在位置 给inode_pos赋值
    void inode_locate(struct partition* part,uint32_t inode_no,struct inode_position* inode_pos)
    { 
        ASSERT(inode_no < 4096);
        uint32_t inode_table_lba = part->sb->inode_table_lba; //得到起始扇区lba
        
        uint32_t inode_size = sizeof(struct inode);
        uint32_t off_size = inode_no * inode_size;
        uint32_t off_sec  = off_size / 512;		    //得到偏移扇区数
        uint32_t off_size_in_sec = off_size % 512;	    //得到在扇区内偏移字节数
        
        uint32_t left_in_sec = 512 - off_size_in_sec;	    //在扇区内剩余字节数 不满sizeof(struct inode)即在两扇区间
        if(left_in_sec < inode_size)	inode_pos->two_sec = true;
        else       inode_pos->two_sec = false;
        
        inode_pos->sec_lba = inode_table_lba + off_sec;
        inode_pos->off_size = off_size_in_sec;
    }
    
    //把inode写回硬盘 io_buf是提前申请的缓冲区 防止内存申请失败前面回读状态时前面任务全白做
    void inode_sync(struct partition* part,struct inode* inode,void* io_buf)
    { 
        uint8_t inode_no = inode->i_no;			
        struct inode_position inode_pos;			    //inode_position
        inode_locate(part,inode_no,&inode_pos);
        
        ASSERT(inode_pos.sec_lba <= (part->start_lba + part->sec_cnt));
        
        struct inode pure_inode;
        memcpy(&pure_inode,inode,sizeof(struct inode));
        
        //这些都只在内存中有用
        pure_inode.i_open_cnts = 0;
        pure_inode.write_deny  = false;
        pure_inode.inode_tag.prev = pure_inode.inode_tag.next = NULL;
        
        char* inode_buf = (char*)io_buf;
        //如果跨分区
        if(inode_pos.two_sec)
        { 
        	//一次性读两个扇区的内容 复制粘贴完了回读回去
        	ide_read(part->my_disk,inode_pos.sec_lba,inode_buf,2);
        	memcpy((inode_buf + inode_pos.off_size),&pure_inode,sizeof(struct inode));
        	ide_write(part->my_disk,inode_pos.sec_lba,inode_buf,2);
        }
        else
        { 
        	ide_read(part->my_disk,inode_pos.sec_lba,inode_buf,1);
        	memcpy((inode_buf + inode_pos.off_size),&pure_inode,sizeof(struct inode));
        	ide_write(part->my_disk,inode_pos.sec_lba,inode_buf,1);
        }
    }
    
    //返回相对应的inode指针
    struct inode* inode_open(struct partition* part,uint32_t inode_no)
    { 
        //先从inode链表找到inode 为了提速而创建的
        struct list_elem* elem = part->open_inodes.head.next; //第一个结点开始
        struct inode* inode_found;			    //返回
        while(elem != &part->open_inodes.tail)
        { 
        	inode_found = elem2entry(struct inode,inode_tag,elem);
            if(inode_found->i_no == inode_no)
            { 
                inode_found->i_open_cnts++;
                return inode_found;
            }
        	elem = elem->next;
        }
        
        //缓冲链表没找到 则需要在硬盘区找
        struct inode_position inode_pos;
        inode_locate(part,inode_no,&inode_pos);
        
        //由于我们的sys_malloc 看当前线程处于用户还是内核是根据 pgdir是否有独立页表 
        //而不管是我们处在用户还是内核 为了让所有进程都能看到这个inode 我们必须把内存分配在内核
        struct task_struct* cur = running_thread();
        uint32_t* cur_pagedir_back = cur->pgdir;
        cur->pgdir = NULL; 
        inode_found = (struct inode*)sys_malloc(sizeof(struct inode));
        cur->pgdir = cur_pagedir_back;
        
        char* inode_buf;
        if(inode_pos.two_sec)
        { 
            inode_buf = (char*)sys_malloc(1024);
            ide_read(part->my_disk,inode_pos.sec_lba,inode_buf,2);
        }
        else
        { 
        	inode_buf = (char*)sys_malloc(512);
            ide_read(part->my_disk,inode_pos.sec_lba,inode_buf,1);
        }
        memcpy(inode_found,inode_buf + inode_pos.off_size,sizeof(struct inode));   
        //放在队首 因为很有可能接下来要访问
        list_push(&part->open_inodes,&inode_found->inode_tag);
        inode_found->i_open_cnts = 1;
        
        sys_free(inode_buf);
        return inode_found;
    }
    
    //关闭inode 或减少inode打开数
    void inode_close(struct inode* inode)
    { 
        enum intr_status old_status = intr_disable();
        //减少次数后 当发现为0了 直接释放即可
        if(--inode->i_open_cnts == 0)
        { 
        	struct task_struct* cur = running_thread();
        	uint32_t* cur_pagedir_back = cur->pgdir;
        	cur->pgdir = NULL;
        	sys_free(inode);
        	cur->pgdir = cur_pagedir_back;
        }
        intr_set_status(old_status);
    }
    
    //初始化inode inode第一个编号是0
    void inode_init(uint32_t inode_no,struct inode* new_inode)
    { 
        new_inode->i_no = inode_no;
        new_inode->i_size = 0;
        new_inode->i_open_cnts = 0;
        new_inode->write_deny = false;
        
        uint8_t sec_idx = 0;
        while(sec_idx < 13)
        	new_inode->i_sectors[sec_idx++] = 0;
    }

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

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

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

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

#ifndef __FS_INODE_H
    #define __FS_INODE_H
    
    #include "list.h"
    #include "global.h"
    #include "stdint.h"
    #include "ide.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而不用再读取硬盘
    };
    
    struct inode_position
    { 
        bool two_sec;			//是否inode存储位置在两个扇区间
        uint32_t sec_lba;			//inode所在的扇区号
        uint32_t off_size;			//在所存储的扇区的偏移位置
    };
    
    void inode_locate(struct partition* part,uint32_t inode_no,struct inode_position* inode_pos);
    void inode_sync(struct partition* part,struct inode* inode,void* io_buf);
    struct inode* inode_open(struct partition* part,uint32_t inode_no);
    void inode_close(struct inode* inode);
    void inode_init(uint32_t inode_no,struct inode* new_inode);
    
    #endif

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

### 编写完的file.c ###

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

**路径`fs/file.c`**

#include "file.h"
    #include "stdio-kernel.h"
    #include "../thread/thread.h"
    #include "ide.h"
    #include "fs.h"
    #include "memory.h"
    #include "string.h"
    #include "global.h"
    #include "debug.h"
    
    struct file file_table[MAX_FILE_OPEN];
    
    //全局文件表中获取
    uint32_t get_free_slot_in_global(void)
    { 
        uint32_t fd_idx = 3;
        while(fd_idx < MAX_FILE_OPEN)
        { 
        	if(file_table[fd_idx].fd_inode == NULL)
        		break;
        	++fd_idx;
        }
        
        if(fd_idx == MAX_FILE_OPEN)
        { 
        	printk("exceed max open files\n");
        	return -1;
        }
        
        return fd_idx;
    }
    
    //安装到pcb中的文件描述符数组中
    uint32_t pcb_fd_install(int32_t global_fd_idx)
    { 
        struct task_struct* cur = running_thread();
        uint8_t local_fd_idx = 3;			//从3开始
        while(local_fd_idx < MAX_FILES_OPEN_PER_PROC)
        { 
        	if(cur->fd_table[local_fd_idx] == -1)
        	{ 
        	    cur->fd_table[local_fd_idx]  = global_fd_idx;
        	    break;
        	}
        	++local_fd_idx;
        }
        
        if(local_fd_idx == MAX_FILES_OPEN_PER_PROC)
        { 
        	printk("exceed max open files\n");
        	return -1;
        }
        return local_fd_idx;
    }
    
    //分配一个inode 并且返回其结点号
    int32_t inode_bitmap_alloc(struct partition* part)
    { 
        int32_t bit_idx = bitmap_scan(&part->inode_bitmap,1);
        if(bit_idx == -1)  return -1;
        bitmap_set(&part->inode_bitmap,bit_idx,1);
        return bit_idx;
    }
    
    //分配一个扇区 并且返回扇区号
    int32_t block_bitmap_alloc(struct partition* part)
    { 
        int32_t bit_idx = bitmap_scan(&part->block_bitmap,1);
        if(bit_idx == -1)	return -1;
        bitmap_set(&part->block_bitmap,bit_idx,1);
        return part->sb->data_start_lba + bit_idx;
    }
    
    //将内存中的bitmap第bit_idx位所在的512字节同步到硬盘
    void bitmap_sync(struct partition* part,uint32_t bit_idx,uint8_t btmp)
    { 	
        uint32_t off_sec = bit_idx / 4096;
        uint32_t off_size = off_sec * 512;
        
        uint32_t sec_lba;
        uint8_t* bitmap_off;
        
        switch(btmp)
        { 
        	case INODE_BITMAP:
    	    sec_lba = part->sb->inode_bitmap_lba + off_sec;
    	    bitmap_off = part->inode_bitmap.bits + off_size;
    	    break;
    	case BLOCK_BITMAP:
    	    sec_lba = part->sb->block_bitmap_lba + off_sec;
    	    bitmap_off = part->block_bitmap.bits + off_size;  
    	    break;
        }
        ide_write(part->my_disk,sec_lba,bitmap_off,1);
    }
    
    /*创建文件 成功则返回文件描述符*/
    int32_t file_create(struct dir* parent_dir,char* filename,uint8_t flag)
    { 
        void* io_buf = sys_malloc(1024);
        if(io_buf == NULL)
        { 
        	printk("in file_create: sys_malloc for io_buf failed\n");
        	return -1;
        }
        
        uint8_t rollback_step = 0;	// 用于回滚资源状态计数
        int32_t inode_no = inode_bitmap_alloc(cur_part);
        
        if(inode_no == -1)
        { 
        	printk("in file_create: allocate inode failed\n");
        	return -1;
        }
        
        struct inode* new_file_inode = (struct inode*)sys_malloc(sizeof(struct inode));
        if(new_file_inode == NULL)
        { 
        	printk("file_create: sys_malloc for inode failed\n");
        	rollback_step = 1;
        	goto rollback;
        }
        inode_init(inode_no,new_file_inode);
        
        int fd_idx = get_free_slot_in_global();
        if(fd_idx == -1)
        { 
        	printk("exceed max open files\n");
        	rollback_step = 2;
        	goto rollback;
        }
        
        
        file_table[fd_idx].fd_inode = new_file_inode;
        file_table[fd_idx].fd_inode->write_deny = false;
        file_table[fd_idx].fd_pos   = 0;
        file_table[fd_idx].fd_flag  = flag;
        
        struct dir_entry new_dir_entry;
        memset(&new_dir_entry,0,sizeof(struct dir_entry));
        
        create_dir_entry(filename,inode_no,FT_REGULAR,&new_dir_entry);
        
        if(!sync_dir_entry(parent_dir,&new_dir_entry,io_buf))
        { 
        	printk("sync dir_entry to disk failed\n");
        	rollback_step = 3;
        	goto rollback;
        }
        
        memset(io_buf,0,1024);
        inode_sync(cur_part,parent_dir->inode,io_buf);
        
        memset(io_buf,0,1024);
        inode_sync(cur_part,new_file_inode,io_buf);
        
        bitmap_sync(cur_part,inode_no,INODE_BITMAP);
        list_push(&cur_part->open_inodes,&new_file_inode->inode_tag);
        new_file_inode->i_open_cnts = 1;
        
        sys_free(io_buf);
        return pcb_fd_install(fd_idx);
        
    rollback:
        switch(rollback_step)	//从上到下执行
        { 
            case 3:
                memset(&file_table[fd_idx],0,sizeof(struct file));
            case 2:
                sys_free(new_file_inode);
            case 1:
                bitmap_set(&cur_part->inode_bitmap,inode_no,0);
                break;
        }
        sys_free(io_buf);
        return -1;
    }

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

### 编写完的file.h ###

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

#ifndef __FS_FILE_H
    #define __FS_FILE_H
    
    #include "inode.h"
    #include "stdint.h"
    #include "dir.h"
    
    #define MAX_FILE_OPEN 32 //系统最大打开文件数
    struct file
    { 
        uint32_t fd_pos;		//文件偏移位置
        uint32_t fd_flag;		
        struct inode* fd_inode;    //指向下一级的inode指针
    };
    
    enum std_fd
    { 
        stdin_no,			//标准输入
        stdout_no,			//标准输入
        stderr_no			//标准错误
    };
    
    enum bitmap_type
    { 
        INODE_BITMAP,		//inode位图
        BLOCK_BITMAP		//块位图
    };
    
    extern struct file file_table[MAX_FILE_OPEN];
    
    uint32_t get_free_slot_in_global(void);
    uint32_t pcb_fd_install(int32_t global_fd_idx);
    int32_t inode_bitmap_alloc(struct partition* part);
    int32_t block_bitmap_alloc(struct partition* part);
    void bitmap_sync(struct partition* part,uint32_t bit_idx,uint8_t btmp);
    int32_t file_create(struct dir* parent_dir,char* filename,uint8_t flag);
    
    #endif

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

### 编写完的dir.c ###

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

#include "dir.h"
    #include "ide.h"
    #include "fs.h"
    #include "inode.h"
    #include "memory.h"
    #include "string.h"
    #include "stdint.h"
    #include "stdio-kernel.h"
    #include "debug.h"
    #include "file.h"
    
    struct dir root_dir;
    
    //打开根目录
    void open_root_dir(struct partition* part)
    { 
        root_dir.inode = inode_open(part,part->sb->root_inode_no);
        root_dir.dir_pos = 0;
    }
    
    //打开指定inode结点中的目录 返回目录指针
    struct dir* dir_open(struct partition* part,uint32_t inode_no)
    { 
        struct dir* pdir = (struct dir*)sys_malloc(sizeof(struct dir));
        pdir->inode = inode_open(part,inode_no);
        pdir->dir_pos = 0;
        return pdir;
    }
    
    //在part分区找名字为name的文件或者目录
    //找到后返回true 并且把目录项存放到dir_e中 以后可能解析目录的时候通过递归来实现
    bool search_dir_entry(struct partition* part,struct dir* pdir,const char* name,struct dir_entry* dir_e)
    { 
         uint32_t block_cnt = 140; //inode中12个直接指 + 1个128间接 = 140 128 = 512/4
         uint32_t* all_blocks = (uint32_t*)sys_malloc(block_cnt*4);
         if(all_blocks == NULL)
         { 
             printk("search_dir_entry: sys_malloc for all_blocks failed\n");
             return false;
         }
         
         uint32_t block_idx = 0;
         while(block_idx < 12)
         { 
             all_blocks[block_idx] = pdir->inode->i_sectors[block_idx];
             ++block_idx;
         }
         
         block_idx = 0;
         
         //如果存在一级间接块表
         if(pdir->inode->i_sectors[12] != 0)
             ide_read(part->my_disk,pdir->inode->i_sectors[12],all_blocks,1);
         
         //每次只分配一个扇区大小 之后我们把目录项不会再出现放到两个扇区之间的情况
         uint8_t* buf = (uint8_t*)sys_malloc(SECTOR_SIZE);
         struct dir_entry* p_de = (struct dir_entry*)buf;
         
         uint32_t dir_entry_size = part->sb->dir_entry_size;
         uint32_t dir_entry_cnt  = SECTOR_SIZE / dir_entry_size;
         
         while(block_idx < block_cnt)
         { 
         	 //说明此处没有目录文件 继续遍历
             if(all_blocks[block_idx] == 0)
             { 
                 ++block_idx;
                 continue;
             }
             //把其内容读出来
             ide_read(part->my_disk,all_blocks[block_idx],buf,1);
             
             uint32_t dir_entry_idx = 0;
             while(dir_entry_idx < dir_entry_cnt)
             { 
                 if(!strcmp(p_de->filename,name))
                 { 
                     memcpy(dir_e,p_de,dir_entry_size);	//把目录项内容复制到dir_e指针区
                     sys_free(buf);
                     sys_free(all_blocks);
                     return true;
                 }
                 ++p_de;
                 ++dir_entry_idx;
             }
             ++block_idx;
             p_de = (struct dir_entry*)buf;		//赋值还原回去
    	 memset(buf,0,SECTOR_SIZE);         		//全部设置为0 初始化buf
         }
         sys_free(buf);
         sys_free(all_blocks);
         return false;
    }
    
    //关闭目录
    void dir_close(struct dir* dir)
    { 
        if(dir == &root_dir)
        	return;
        inode_close(dir->inode);
        sys_free(dir);
    }
    
    //在内存中初始化目录项
    void create_dir_entry(char* filename,uint32_t inode_no,uint8_t file_type,struct dir_entry* p_de)
    { 
        ASSERT(strlen(filename) <= MAX_FILE_NAME_LEN);
        memcpy(p_de->filename,filename,strlen(filename));
        p_de->i_no = inode_no;
        p_de->f_type = file_type;
    }
    
    //将目录项p_de 写入父目录parent_dir io_buf由主调函数提供
    bool sync_dir_entry(struct dir* parent_dir,struct dir_entry* p_de,void* io_buf)
    { 
        struct inode* dir_inode = parent_dir->inode;
        uint32_t dir_size = dir_inode->i_size;
        uint32_t dir_entry_size = cur_part->sb->dir_entry_size;
        
        ASSERT(dir_size % dir_entry_size == 0);
        
        uint32_t dir_entrys_per_sec = (512 / dir_entry_size);	//得到每扇区最多多少个目录项
        int32_t block_lba = -1;					
        uint8_t block_idx = 0;
        uint32_t all_blocks[140] = { 0};				//局部变量 所有块
        
        //先看直接块 后面再看简介块
        while(block_idx < 12)
        { 
        	all_blocks[block_idx] = dir_inode->i_sectors[block_idx];	//直接块读取
        	block_idx++;
        }
        
        struct dir_entry* dir_e = (struct dir_entry*)io_buf;		//遍历目录项的临时指针
        int32_t block_bitmap_idx = -1;					//位图idx
        
        block_idx = 0;
        while(block_idx < 140)
        { 
        	block_bitmap_idx = -1;
        	if(all_blocks[block_idx] == 0)				//此块还没有分配
        	{ 
        	    block_lba = block_bitmap_alloc(cur_part);
        	    if(block_lba == -1)
        	    { 
        	        printk("alloc block bitmap for sync_dir_entry failed\n");
        	        return false;
        	    }
        	    
        	    block_bitmap_idx = block_lba - cur_part->sb->data_start_lba;//由分配扇区号 - 起始扇区号 = 位图的相对偏移
        	    bitmap_sync(cur_part,block_bitmap_idx,BLOCK_BITMAP);        //同步到硬盘
        	    
        	    block_bitmap_idx = -1;
        	    if(block_idx < 12)		//直接块
        	    	dir_inode->i_sectors[block_idx] = all_blocks[block_idx] = block_lba;
        	    else if(block_idx == 12)	//一级间接表 间接表
        	    { 
        	    	dir_inode->i_sectors[block_idx] = block_lba;
        	    	block_lba = -1;
        	    	block_lba = block_bitmap_alloc(cur_part);	//再给到一个块 给简介块第0个赋值
        	        if(block_lba == -1)	//分配失败则需要回退之前的分配
        	        { 
        	            block_bitmap_idx = dir_inode->i_sectors[12] - cur_part->sb->data_start_lba;
        	            bitmap_set(&cur_part->block_bitmap,block_bitmap_idx,0);
        	            dir_inode->i_sectors[12] = 0;
        	            printk("alloc block bitmap for sync_dir_entry failed\n");
        	            return false;
        	        }
        	        block_bitmap_idx = block_lba - cur_part->sb->data_start_lba;
        	        ASSERT(block_bitmap_idx != -1);
        	        bitmap_sync(cur_part,block_bitmap_idx,BLOCK_BITMAP);
        	        all_blocks[12] = block_lba;
        	        ide_write(cur_part->my_disk,dir_inode->i_sectors[12],all_blocks + 12,1);	//一级间接块复制到硬盘中
        	    }
        	    else	//已经有一级间接表了 
        	    { 
        	    	all_blocks[block_idx] = block_lba;
        	    	ide_write(cur_part->my_disk,dir_inode->i_sectors[12],all_blocks + 12,1);	//一级间接表复制到硬盘中
        	    }
        	    
        	    memset(io_buf,0,512);
        	    memcpy(io_buf,p_de,dir_entry_size);
        	    ide_write(cur_part->my_disk,all_blocks[block_idx],io_buf,1);			//把目录项放到新分配的区块
        	    dir_inode->i_size += dir_entry_size;
        	    return true;
        	}
    	
    	//此块已经被分配 寻找空余空间 
        	ide_read(cur_part->my_disk,all_blocks[block_idx],io_buf,1);
        	uint8_t dir_entry_idx = 0;
        	while(dir_entry_idx < dir_entrys_per_sec)	//由于我们存放目录项不再出现存放于两个扇区间的情况 即<dir_entrys_per_sec即可
        	{ 
        	    if((dir_e + dir_entry_idx)->f_type == FT_UNKNOWN)	//这个位置还没有存放目录项
        	    { 
        	    	memcpy(dir_e + dir_entry_idx,p_de,dir_entry_size);
        	    	ide_write(cur_part->my_disk,all_blocks[block_idx],io_buf,1);	//写回去
        	    	dir_inode->i_size += dir_entry_size;				//文件大小增加
        	    	return true;
        	    }
        	    ++dir_entry_idx;
        	}
        	++block_idx;	//遍历完140个块
        }
        printk("directory is full!\n");
        return false;
    }

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

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

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

#ifndef __FS_DIR_H
    #define __FS_DIR_H
    
    #define MAX_FILE_NAME_LEN 16 //最长16个字
    #include "ide.h"
    #include "fs.h"
    
    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;		//文件类型 由此看是目录还是文件类型
    };
    
    extern struct dir root_dir;
    
    void open_root_dir(struct partition* part);
    struct dir* dir_open(struct partition* part,uint32_t inode_no);
    bool search_dir_entry(struct partition* part,struct dir* pdir,const char* name,struct dir_entry* dir_e);
    void dir_close(struct dir* dir);
    void create_dir_entry(char* filename,uint32_t inode_no,uint8_t file_type,struct dir_entry* p_de);
    bool sync_dir_entry(struct dir* parent_dir,struct dir_entry* p_de,void* io_buf);
    
    #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"
    #include "file.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;	//继续循环
    }
    
    //解析路径 并把下一级路径的字符串赋值给name_store 返回现在已经解析完的指针位置
    char* path_parse(char* pathname,char* name_store)
    { 
        if(pathname[0] == '/')
            while(*(++pathname) == '/');	//直到pathname位置不是
    
        while(*pathname != '/' && *pathname != '\0')
        	*(name_store++) = *(pathname++);
        	
        if(pathname[0] == 0)	return NULL;
        return pathname;
    }
    
    //返回路径的层数 
    int32_t path_depth_cnt(char* pathname)
    { 
        ASSERT(pathname != NULL);
        char* p = pathname;
        char name[MAX_FILE_NAME_LEN];
        
        uint32_t depth = 0;
        
        p = path_parse(p,name);
        while(name[0])
        { 
        	++depth;
        	memset(name,0,MAX_FILE_NAME_LEN);
        	if(p)
        	    p = path_parse(p,name);
        }
        return depth;
    }
    
    //搜索文件 找到则返回inode号 否则返回-1
    int search_file(const char* pathname,struct path_search_record* searched_record)
    { 
        //如果是根目录 则直接判定返回即可 下面的工作就不需要做了
        if(!strcmp(pathname,"/") || !strcmp(pathname,"/.") || !strcmp(pathname,"/.."))
        { 
        	searched_record->parent_dir = &root_dir;
        	searched_record->file_type  = FT_DIRECTORY;
        	searched_record->searched_path[0] = 0;		//置空
        	return 0;	//根目录inode编号为0
        }
        
        uint32_t path_len = strlen(pathname);
        
        ASSERT(pathname[0] == '/' && path_len > 1 && path_len < MAX_PATH_LEN);		
        char* sub_path = (char*)pathname;
        struct dir* parent_dir = &root_dir;			//每个刚开始都是从根目录开始
        struct dir_entry dir_e;					//存放目录项的临时变量
        
        char name[MAX_FILE_NAME_LEN] = { 0};
        
        searched_record->parent_dir = parent_dir;
        searched_record->file_type  = FT_UNKNOWN;
        uint32_t parent_inode_no = 0;				//父目录的inode号
        
        sub_path = path_parse(sub_path,name);			//解析目录
        while(name[0])
        { 
        	ASSERT(strlen(searched_record->searched_path) < 512);
        	strcat(searched_record->searched_path,"/");
        	strcat(searched_record->searched_path,name);
        	
        	if(search_dir_entry(cur_part,parent_dir,name,&dir_e))
        	{ 
        	    memset(name,0,MAX_FILE_NAME_LEN);
        	    if(sub_path)    sub_path = path_parse(sub_path,name);   
        	    
        	    if(FT_DIRECTORY == dir_e.f_type)	//打开的是目录继续解析即可
        	    { 
        	    	
        	    	parent_inode_no = parent_dir->inode->i_no;
        	    	dir_close(parent_dir);
        	    	parent_dir = dir_open(cur_part,dir_e.i_no);
        	    	searched_record->parent_dir = parent_dir;
        	    }
        	    else if(FT_REGULAR == dir_e.f_type)
        	    { 
        	    	searched_record->file_type = FT_REGULAR;
        	    	return dir_e.i_no;
        	    }
        	}
        	else 	return -1;
        }
        
        dir_close(searched_record->parent_dir);
        searched_record->parent_dir = dir_open(cur_part,parent_inode_no);
        searched_record->file_type = FT_DIRECTORY;
        return dir_e.i_no;
    }
    
    //文件系统初始化 磁盘上搜索 如果没有则格式化分区 并创建文件系统
    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);
        open_root_dir(cur_part);
        
        uint32_t fd_idx = 0;
        while(fd_idx < MAX_FILE_OPEN)
        	file_table[fd_idx++].fd_inode = NULL;
    }
    
    int32_t sys_open(const char* pathname,uint8_t flags)
    { 
        //最后一位是'/'则无法辨析 这里是打开文件
        if(pathname[strlen(pathname) - 1] == '/')
        { 
        	printk("cant open a directory %s\n",pathname);
        	return -1;
        }
        ASSERT(flags <= 7);
        int32_t fd = -1;
        
        struct path_search_record searched_record;	     //记录访问记录
        memset(&searched_record,0,sizeof(struct path_search_record));
        
        uint32_t pathname_depth = path_depth_cnt((char*)pathname);
        
        int inode_no = search_file(pathname,&searched_record); //搜索文件
        bool found = (inode_no == -1) ? false : true;
        
        if(searched_record.file_type == FT_DIRECTORY)	     //如果是目录文件类型
        { 
        	printk("cant open a directory with open(),use opendir() to instead\n");
        	dir_close(searched_record.parent_dir);
        	return -1;
        }
        
        uint32_t path_searched_depth = path_depth_cnt(searched_record.searched_path);
        
        if(pathname_depth != path_searched_depth)
        { 
        	printk("cannot access %s:Not a directory,subpath %s isnt exist\n",pathname,searched_record.searched_path);
        	dir_close(searched_record.parent_dir);
        	return -1;	
        }
        
        if(!found && !(flags & O_CREAT))
        { 
        	printk("in path %s: Not a directory, subpath %s isnt exist\n",pathname,searched_record.searched_path);
        	dir_close(searched_record.parent_dir);
        	return -1;
        }
        else if(found && (flags & O_CREAT))
        { 
        	printk("%s has already exist!\n",pathname);
        	dir_close(searched_record.parent_dir);
        	return -1;
        }
        
        switch(flags & O_CREAT)
        { 
        	case O_CREAT:
        	    printk("creating file\n");
        	    fd = file_create(searched_record.parent_dir,strrchr(pathname,'/') + 1,flags);
        	    dir_close(searched_record.parent_dir);
        }
        
        return fd;
    }

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

### 编写完的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 //块字节大小 我们这里一块 == 一扇区
    #define MAX_PATH_LEN 512 //最大路径长度
    
    extern struct partition* cur_part;
    
    enum file_types 
    { 
        FT_UNKNOWN,	//未知文件类型
        FT_REGULAR,	//普通文件类型
        FT_DIRECTORY	//目录文件类型
    };
    
    enum oflags
    { 
        O_RDONLY,		//只读属性
        O_WRONLY,		//只写属性
        O_RDWR,		//可读写
        O_CREAT = 4	//创建
    };
    
    struct path_search_record
    { 
        char searched_path[MAX_PATH_LEN]; //父路径
        struct dir* parent_dir;	       //文件直接的父路径 或者说上一级的路径
        enum file_types file_type;        //普通文件 目录 或者未知类型
    };
    
    void partition_format(struct disk* hd,struct partition* part);
    bool mount_partition(struct list_elem* pelem,int arg);
    void filesys_init(void);
    char* path_parse(char* pathname,char* name_store);
    int32_t path_depth_cnt(char* pathname);
    int search_file(const char* pathname,struct path_search_record* searched_record);
    int32_t sys_open(const char* pathname,uint8_t flags);
    
    #endif

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

### 修改后的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 $(BUILD_DIR)/inode.o \
          $(BUILD_DIR)/file.o $(BUILD_DIR)/dir.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 fs/file.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 \
    	fs/file.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/inode.o: fs/inode.c fs/inode.h device/ide.h kernel/debug.h thread/thread.h \
    	kernel/memory.h lib/string.h lib/kernel/list.h kernel/interrupt.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/file.o: fs/file.c fs/file.h lib/kernel/stdio-kernel.h thread/thread.h device/ide.h \
    	fs/file.h kernel/global.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/dir.o: fs/dir.c fs/dir.h device/ide.h fs/fs.h fs/inode.h kernel/memory.h lib/string.h lib/stdint.h \
    	lib/kernel/stdio-kernel.h kernel/debug.h fs/file.h kernel/memory.h lib/string.h kernel/debug.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

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

### 修改后的main.c ###

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

#include "print.h"
    #include "init.h"
    #include "debug.h"
    #include "string.h"
    #include "memory.h"
    #include "../thread/thread.h"
    #include "interrupt.h"
    #include "../device/console.h"
    #include "../device/ioqueue.h"
    #include "../device/keyboard.h"
    #include "../userprog/process.h"
    #include "../lib/user/syscall.h"
    #include "../userprog/syscall-init.h"
    #include "../lib/stdio.h"
    #include "../lib/kernel/stdio-kernel.h"
    #include "../fs/fs.h"
    #include "../fs/file.h"
    
    int main(void) { 
       put_str("I am kernel\n");
       init_all();
       intr_enable();
       sys_open("/file1",O_CREAT);
       while(1);
       return 0;
    }

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

## make all 验证sys\_open功能实现成功 ##

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

**这里其实我是真的很建议 大家一定要多做备份 我这里至少在windows备份了五六个版本了 而且硬盘`hd80M.img`由于我要把调试过程给重新写出来 弄成博客 所以就导致我需要重新备份很多次硬盘 那我们就先开始弄吧**

**debug我昨晚还是调试了很久 因为调试中途会发现 各种地方自己写错的地方 尤其还发现自己的原来写的`string.c`里面也有函数写错了 于是我又修改了之后再去把原来的博客里面的函数给更新了 一个地方写错了 后面多个地方就没办法运行**

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

### xxd.sh文件代码 ###

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

**这里温馨的把`xxd.sh`文件给出来 因为毕竟很久也没用了 我之前也没有用过 这一章才创建的 有点难翻 这里就直接给出来即可**

**`xxd.sh`**

xxd -u -a -g 1 -s $2 -l $3 $1

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

### 得到sda1起始数据扇区号 ###

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

**我们要调试验证的话 我们先去看看我们的根目录实现成功没有  
其实我经常调试着调试着 就会发现原来很多地方自己写错了 然后又回去改  
这次也是这样 我就发现 我不仅根目录的名称写错了 而且也没有建立成功 我自己返回去改了代码和博客之后才成功**

**我们由于写到这里了 文件系统已经建立好了 那我们怎么得到sbb1的`info`呢  
哈哈 我就重新把我原来一个星期以前的硬盘从`windows`复制到了`ubuntu` 并在`sdb1`的文件建立后面 设置了一个`while(1);` 就得到了下面的信息**

**ok 成功得到`sdb1 root_dir_lba: 0XA67`**

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

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

### 验证根目录是否建立成功 ###

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

**我们通过进制转换 我的`sdb1`起始扇区号是`0xA67` 也就是`2663`  
那么我们通过计算机算一下 `2663*512 = 1363456` 得到了起始的扇区号**  
**此时用命令`sh xxd.sh hd80M.img 1363456 512`看一下起始扇区内的内容装了什么**  
**由于我们的根目录的目录项就是放在其实第一个扇区的 所以下面就是结果**

**`2E` 和 `2E 2E` 其实就是`.`和`..` 这里先看不出来 `02`就是`f_type`**

**之后我们把`main.c`中的`sys_open("/file1",O_CREAT);`给取消注释了 创建文件看看是否我们的`file1`放进去了**

![在这里插入图片描述][eccce69292de445a8b11de2c84717ae7.png]

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

### 第一次调用sys\_open ###

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

**下面是第一次create `file1`的截图  
可以明显看到显示结果 `creating file` 此时我们不妨`xxd.sh`看看我们的根目录所在扇区有没有存进去**

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

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

**退出虚拟机 `sh xxd.sh hd80M.img 1363456 512` 看看里面究竟是什么样子**  
**可以很清楚的看到 `file1`存储了进去 并且分配了`inode`编号为1 `f_type`为1普通文件`FT_REGULAR` 我们再去调用一下`sys_open`看看结果**  
![在这里插入图片描述][05e9029367234e47adb9f37beace5e45.png]

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

### 第二次调用sys\_open ###

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

**可以很清楚的看到  
`/file1 has already exist!` 满足预期！ 那这一部分也先宣告结束了**  
**每一章内容太多的话 就只能分到多个博客来发了 各位看官下一章再见了**

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

[Link 1]: https://love6.blog.csdn.net/article/details/119133589
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTAwNTE2_size_16_color_FFFFFF_t_70]: /images/20220829/57d69b8b0b7d49f98047e712a32b8ac0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTAwNTE2_size_16_color_FFFFFF_t_70 1]: /images/20220829/3320c18c38eb4c31b7a6ff29fc49ee66.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTAwNTE2_size_16_color_FFFFFF_t_70 2]: /images/20220829/04d98335520344338d25088a23fdc587.png
[eccce69292de445a8b11de2c84717ae7.png]: /images/20220829/af92db7daa7f43ff8c419374611c02d2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTAwNTE2_size_16_color_FFFFFF_t_70 3]: /images/20220829/74edfd085fe64127870723f0b2a65055.png
[05e9029367234e47adb9f37beace5e45.png]: /images/20220829/fc8330e834ff4915ac8e104c53cf4412.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTAwNTE2_size_16_color_FFFFFF_t_70 4]: /images/20220829/79e9f150b85948468fc6803f53d74ca2.png