《操作系统真象还原》从零开始自制操作系统自写源码实现（fs相关文件）

待我称王封你为后i 2022-09-04 15:56 16阅读 0赞

### 文章目录 ###

*   *  专栏博客链接
     *  fs相关文件
     *   *  编写完的dir.c
         *  编写完的dir.h
         *  编写完的file.c
         *  编写完的file.h
         *  编写完的fs.c
         *  编写完的fs.h
         *  编写完的inode.c
         *  编写完的inode.h
         *  编写完的super\_block.h

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

## 专栏博客链接 ##

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

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

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

## fs相关文件 ##

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

### 编写完的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;
    }
    
    //把pdir中编号为inode_no目录项删除
    bool delete_dir_entry(struct partition* part,struct dir* pdir,uint32_t inode_no,void* io_buf)
    { 
        struct inode* dir_inode = pdir->inode;
        uint32_t block_idx = 0,all_blocks[140] = { 0};
        while(block_idx < 12)
        { 
            all_blocks[block_idx] = dir_inode->i_sectors[block_idx];
            ++block_idx;
        }
        if(dir_inode->i_sectors[12])
            ide_read(part->my_disk,dir_inode->i_sectors[12],all_blocks + 12,1);
            
        //目录项存储不像inode那样存在夹在两个扇区间的情况 
        uint32_t dir_entry_size = part->sb->dir_entry_size;
        uint32_t dir_entrys_per_sec = (SECTOR_SIZE / dir_entry_size);
        struct dir_entry* dir_e = (struct dir_entry*)io_buf;
        struct dir_entry* dir_entry_found = NULL;
        uint8_t dir_entry_idx,dir_entry_cnt;
        bool is_dir_first_block = false;		//目录的第一个块
        
        block_idx = 0;
        while(block_idx < 140)
        { 
            is_dir_first_block = false;
            if(all_blocks[block_idx] == 0)
            { 
                ++block_idx;
                continue;
            }
            
            dir_entry_idx = dir_entry_cnt = 0;
            memset(io_buf,0,SECTOR_SIZE);
            ide_read(part->my_disk,all_blocks[block_idx],io_buf,1);
            
            //挨个挨个遍历寻找
            while(dir_entry_idx < dir_entrys_per_sec)
            { 
                if((dir_e + dir_entry_idx)->f_type != FT_UNKNOWN)
                { 
                	//找到根目录所在扇区了 说明不可回收此扇区
                    if(!strcmp((dir_e + dir_entry_idx)->filename,"."))
                    { 
                        is_dir_first_block = true;
                    }
                    else if(strcmp((dir_e + dir_entry_idx)->filename,".") && strcmp((dir_e + dir_entry_idx)->filename,".."))
                    { 
                        dir_entry_cnt++; //判断是否回收此扇区
                        if((dir_e + dir_entry_idx)->i_no == inode_no)
                        { 
                            ASSERT(dir_entry_found == NULL);
                            dir_entry_found = dir_e + dir_entry_idx;
                            //继续遍历 统计共有多少目录项
                        }
                    }
                }
                ++dir_entry_idx;
            }
            
            //这个扇区没找到 到一下个扇区继续找
            if(dir_entry_found == NULL)
            { 
                ++block_idx;
                continue;
            }
            
            ASSERT(dir_entry_cnt >= 1);
            
            //不包括根目录 该块且只有一个目录项 这个目录项刚好是我们需要删除的
            if(dir_entry_cnt == 1 && !is_dir_first_block)
            { 
                uint32_t block_bitmap_idx = all_blocks[block_idx] - part->sb->data_start_lba;
                bitmap_set(&part->block_bitmap,block_bitmap_idx,0);
                bitmap_sync(cur_part,block_bitmap_idx,BLOCK_BITMAP);  //块同步进去
                
                if(block_idx < 12)
                    dir_inode->i_sectors[block_idx]  = 0;
                else //还需要判断是否要把间接块表回收回去
                { 
                    uint32_t indirect_blocks = 0;
                    uint32_t indirect_block_idx = 12;
                    while(indirect_block_idx  < 140)
                    { 
                        if(all_blocks[indirect_block_idx] != 0)
                             ++indirect_blocks;
                    }
                    ASSERT(indirect_blocks >= 1); //至少一个
                    
                    if(indirect_blocks > 1) //间接表块不回收
                    { 
                        all_blocks[block_idx] = 0; //那个地方的块地址写成0
                        ide_write(part->my_disk,dir_inode->i_sectors[12],all_blocks+ 12,1);
                    }
                    else //先回收那个块表
                    { 
                        /*这里是我加的*/
                        all_blocks[block_idx] = 0; //那个地方的块地址写成0
                        ide_write(part->my_disk,dir_inode->i_sectors[12],all_blocks+ 12,1);
                        /*我认为这是必须加的两行*/
                        
                        block_bitmap_idx = dir_inode->i_sectors[12] - part->sb->data_start_lba;
                        bitmap_set(&part->block_bitmap,block_bitmap_idx,0);
                        bitmap_sync(cur_part,block_bitmap_idx,BLOCK_BITMAP);
                    }
                }
            }
            else
            { 
                memset(dir_entry_found,0,dir_entry_size);//把那里的目录项清一条即可
                ide_write(part->my_disk,all_blocks[block_idx],io_buf,1);
            }    
                
            ASSERT(dir_inode->i_size >= dir_entry_size);
            dir_inode->i_size -= dir_entry_size;  //大小减去一条目录项的
            memset(io_buf,0,SECTOR_SIZE * 2);
            inode_sync(part,dir_inode,io_buf);   //把inode写入硬盘
            return true;
        }
        return false;
    }
    
    //读取目录
    struct dir_entry* dir_read(struct dir* dir)
    { 
        struct dir_entry* dir_e = (struct dir_entry*)dir->dir_buf; //哈哈 目录项里面自己有缓冲区
        struct inode* dir_inode = dir->inode;
        uint32_t all_blocks[140] = { 0},block_cnt = 12;
        uint32_t block_idx = 0,dir_entry_idx = 0;
        
        //读取直接块
        while(block_idx < 12)
        { 
            all_blocks[block_idx] = dir_inode->i_sectors[block_idx];
            ++block_idx;
        }
        
        //有间接块 读入
        if(dir_inode->i_sectors[12] != 0)
        { 
            ide_read(cur_part->my_disk,dir_inode->i_sectors[12],all_blocks + 12,1);
            block_cnt = 140;
        }
        block_idx = 0;
        
        uint32_t cur_dir_entry_pos = 0;		//遍历目录了
        uint32_t dir_entry_size = cur_part->sb->dir_entry_size;
        uint32_t dir_entrys_per_sec = SECTOR_SIZE / dir_entry_size;
        
        while(dir->dir_pos < dir_inode->i_size)
        { 
            //该目录中都已经目录项已经遍历完了
            if(dir->dir_pos >= dir_inode->i_size)	return NULL;
            if(all_blocks[block_idx] == 0)
            { 
                block_idx++;
                continue;
            }
            memset(dir_e,0,SECTOR_SIZE);
            ide_read(cur_part->my_disk,all_blocks[block_idx],dir_e,1);
            dir_entry_idx = 0;
            while(dir_entry_idx < dir_entrys_per_sec)
            { 
                //FT_UNKNOWN是未知
                if((dir_e + dir_entry_idx)->f_type)
                { 
                    //原来已经遍历过了 因为需要从头开始 
                    if(cur_dir_entry_pos < dir->dir_pos)
                    { 
                        cur_dir_entry_pos += dir_entry_size;
                        ++dir_entry_idx;
                        continue;
                    }
                    ASSERT(cur_dir_entry_pos == dir->dir_pos);
                    dir->dir_pos += dir_entry_size;
                    //返回目录地址
                    return dir_e + dir_entry_idx;
                }
                ++dir_entry_idx;
            }
            ++block_idx;
        }
        return NULL;
    }
    
    bool dir_is_empty(struct dir* dir)
    { 
        if(!dir)
        { 
            printk("dir_is_empty: dir is NULL\n");
            return false;
        }
        struct inode* dir_inode = dir->inode;
        return dir_inode->i_size == cur_part->sb->dir_entry_size * 2; //目前目录里面只有. 和 ..
    }
    
    //父目录parent_dir删除指定child_dir
    int32_t dir_remove(struct dir* parent_dir,struct dir* child_dir)
    { 
        struct inode* child_dir_inode = child_dir->inode;
        
        //如果是空目录的话 只有第一个扇区有根目录. 和 .. 其他都是空的
        int32_t block_idx = 1;
        while(block_idx < 13)
        { 
            ASSERT(child_dir_inode->i_sectors[block_idx] == 0);
            ++block_idx;
        }
        void* io_buf = sys_malloc(SECTOR_SIZE * 2);
        if(io_buf == NULL)
        { 
            printk("dir_remove: malloc for io_buf failed\n");
            return -1;
        }
        
        //之前就有的 删除其目录项
        delete_dir_entry(cur_part,parent_dir,child_dir_inode->i_no,io_buf);
        inode_release(cur_part,child_dir_inode->i_no);
        sys_free(io_buf);
        return 0;
    }

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

### 编写完的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);
    bool delete_dir_entry(struct partition* part,struct dir* pdir,uint32_t inode_no,void* io_buf);
    struct dir_entry* dir_read(struct dir* dir);
    bool dir_is_empty(struct dir* dir);
    int32_t dir_remove(struct dir* parent_dir,struct dir* child_dir);
    
    #endif

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

### 编写完的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"
    #include "interrupt.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;
    }
    
    //打开编号为inode_no的文件 成功返回文件描述符 否则返回-1
    int32_t file_open(uint32_t inode_no,uint8_t flag)
    { 
        
        int fd_idx = get_free_slot_in_global();	//全局描述符表得到idx
        if(fd_idx == -1)
        { 
        	printk("exceed max open files\n");
        	return -1;
        }
        file_table[fd_idx].fd_pos = 0;
        file_table[fd_idx].fd_flag = flag;
        file_table[fd_idx].fd_inode = inode_open(cur_part,inode_no);
        		  
        bool* write_deny = &file_table[fd_idx].fd_inode->write_deny;
        
        //可写 或者 可读可写 涉及临界区的情况 记得屏蔽中断
        if(flag & O_WRONLY || flag & O_RDWR)
        { 
        	enum intr_status old_status = intr_disable();
        	if(!(*write_deny))
        	{ 
        	    *write_deny = true;
        	    intr_set_status(old_status);
        	}
        	else
        	{ 
        	    printk("file cant written now try again later!\n");
        	    intr_set_status(old_status);
        	    return -1;
        	}
        }
        return pcb_fd_install(fd_idx);
    }
    
    //关闭文件 且使文件描述符恢复可用
    int32_t file_close(struct file* file)
    { 
        if(file == NULL)
            return -1;
        file->fd_inode->write_deny = false;
        inode_close(file->fd_inode);
        file->fd_inode = NULL;	//检测全局描述符u表是否可用 是看inode是否为NULL 即恢复可用
        return 0;
    }
    
    int32_t file_read(struct file* file,void* buf,uint32_t count)
    { 
        uint8_t* buf_dst = (uint8_t*)buf;
        uint32_t size = count ,size_left = count;
        
        //如果要读取的内容比原本文件的字节数更多 则重新设置size 如果到底了 就直接退出
        if((file->fd_pos + count) > file->fd_inode->i_size)
        { 
            size = file->fd_inode->i_size - file->fd_pos;
            size_left = size;
            if(size == 0)
                return -1;
        }
        
        uint8_t* io_buf = sys_malloc(BLOCK_SIZE);
        if(io_buf == NULL)
        { 
            printk("file_read: sys_malloc for io_buf failed\n");
            return -1;	//书上没写
        }
        
        uint32_t* all_blocks = (uint32_t*)sys_malloc(BLOCK_SIZE + 48);//48 + 512 = 560
        if(all_blocks == NULL)
        { 
            printk("file_read: sys_malloc for io_buf failed\n");
            return -1;
        }
        uint32_t block_read_start_idx = file->fd_pos / BLOCK_SIZE;           //开始读取的扇区号
        uint32_t block_read_end_idx   = (file->fd_pos + count) / BLOCK_SIZE; //结束读取的扇区号
        uint32_t read_blocks          = block_read_end_idx - block_read_start_idx;
        
        ASSERT(block_read_start_idx < 139 && block_read_end_idx < 139);	    
        
        int32_t indirect_block_table;
        uint32_t block_idx;
        
        if(read_blocks == 0) //没有增量 则就在原扇区读
        { 
        	ASSERT(block_read_end_idx == block_read_start_idx);
        	if(block_read_end_idx < 12)		//在直接块中
        	{ 
        	    block_idx = block_read_end_idx;
        	    all_blocks[block_idx] = file->fd_inode->i_sectors[block_idx];
        	}
        	else
        	{ 
        	    indirect_block_table = file->fd_inode->i_sectors[12];
        	    ide_read(cur_part->my_disk,indirect_block_table,all_blocks + 12,1);
        	}
        }
        else	//有增量
        { 
        	if(block_read_end_idx < 12)		//在直接块中
        	{ 
        	    block_idx = block_read_start_idx;
        	    while(block_idx <= block_read_end_idx)
        	    { 
        	    	all_blocks[block_idx] = file->fd_inode->i_sectors[block_idx];
        	    	++block_idx;
        	    }
        	}
        	else if(block_read_start_idx < 12 && block_read_end_idx >= 12) //越界
        	{ 
        	    block_idx = block_read_start_idx;
        	    while(block_idx < 12)
        	    { 
        	    	all_blocks[block_idx] = file->fd_inode->i_sectors[block_idx];
        	    	++block_idx;
        	    }
        	    indirect_block_table = file->fd_inode->i_sectors[12];
        	    ide_read(cur_part->my_disk,indirect_block_table,all_blocks + 12,1);
        	}
        	else
        	{ 
        	    ASSERT(file->fd_inode->i_sectors[12] != 0); 
        	    indirect_block_table = file->fd_inode->i_sectors[12];
        	    ide_read(cur_part->my_disk,indirect_block_table,all_blocks + 12,1);
        	}
        }
        //开始读数据
        uint32_t sec_idx,sec_lba,sec_off_bytes,sec_left_bytes,chunk_size;
        uint32_t bytes_read = 0;
        
        while(bytes_read < size)
        { 
        	sec_idx = file->fd_pos / BLOCK_SIZE;
        	sec_lba = all_blocks[sec_idx];
        	sec_off_bytes = file->fd_pos % BLOCK_SIZE;
        	sec_left_bytes = BLOCK_SIZE - sec_off_bytes;
        	chunk_size = size_left < sec_left_bytes ? size_left : sec_left_bytes;
        	
            memset(io_buf,0,BLOCK_SIZE);
            ide_read(cur_part->my_disk,sec_lba,io_buf,1);
            memcpy(buf_dst,io_buf + sec_off_bytes,chunk_size);
            
            buf_dst += chunk_size;
            file->fd_pos += chunk_size;
            bytes_read += chunk_size;
            size_left -= chunk_size;
        }
        ASSERT(size_left == 0);
        sys_free(all_blocks);
        sys_free(io_buf);
        return bytes_read;
    }
    
    //写入文件
    int32_t file_write(struct file* file,const void* buf,uint32_t count)
    { 
        if((file->fd_inode->i_size + count) > (BLOCK_SIZE * 140))	//超过总数字节数 则不分配
        { 
        	printk("file_write: exceed max file_size 71680 bytes, write file failed\n"); //512 * 140 = 71680
        	return -1;
        }
        
        uint8_t* io_buf = (uint8_t*)sys_malloc(512);
        if(io_buf == NULL)
        { 
        	printk("file_write: sys_malloc for io_buf failed\n");
        	return -1;
        }
        
        uint32_t* all_blocks = (uint32_t*)sys_malloc(BLOCK_SIZE + 48);	//48是直接块访问 512是间接块访问
        if(all_blocks == NULL)
        { 
        	printk("file_write: sys_malloc for all blocks failed\n");
        	return -1;
        }
        
        const uint8_t* src = buf;						//指向代写入数据
        uint32_t bytes_written = 0;					//已经写入的数据
        uint32_t size_left     = count;					//剩下没写的字节
        int32_t  block_lba     = -1;					//块地址
        uint32_t block_bitmap_idx = 0;
        
        uint32_t sec_idx;							// 索引扇区
        uint32_t sec_lba;							// 扇区地址
        uint32_t sec_off_bytes;						// 扇区内字节偏移量
        uint32_t sec_left_bytes;						// 扇区内剩余字节数
        uint32_t chunk_size;						// 一次写入硬盘的数据量
        int32_t  indirect_block_table;					// 一级间接块地址
        uint32_t block_idx;						// 块索引
        
        //看看是否第一次写入数据 是的话先分配一个扇区
        if(file->fd_inode->i_sectors[0] == 0)
        { 
        	block_lba = block_bitmap_alloc(cur_part);
        	if(block_lba == -1)	//分配失败
        	{ 
        	    printk("file_write: block_bitmap_alloc failed\n");
        	    sys_free(all_blocks);
        	    sys_free(io_buf);
        	    return -1;
        	}
        	file->fd_inode->i_sectors[0] = block_lba;
        	
        	block_bitmap_idx = block_lba - cur_part->sb->data_start_lba;
        	ASSERT(block_bitmap_idx != 0);
        	bitmap_sync(cur_part,block_bitmap_idx,BLOCK_BITMAP);
        }
        
        
        uint32_t file_has_used_blocks = file->fd_inode->i_size / BLOCK_SIZE + 1;	//不满一扇区的也要当一扇区
        uint32_t file_will_use_blocks = (file->fd_inode->i_size + count) / BLOCK_SIZE + 1;
        ASSERT(file_will_use_blocks <= 140);
        
        uint32_t add_blocks = file_will_use_blocks - file_has_used_blocks;//求增量扇区 为0表示不需要
        
        //在原先分配的扇区继续写内容
        if(add_blocks == 0)
        { 
        	//原先分配的12个 直接使用的扇区
        	if(file_has_used_blocks <= 12)
        	{ 
        	    block_idx = file_has_used_blocks - 1;//从最后一个扇区开始
        	    all_blocks[block_idx] = file->fd_inode->i_sectors[block_idx];
        	}
        	else
        	{ 
        	    ASSERT(file->fd_inode->i_sectors[12] != 0);
        	    indirect_block_table = file->fd_inode->i_sectors[12];
        	    ide_read(cur_part->my_disk,indirect_block_table,all_blocks + 12,1);//间接块内容读进去了
        	}
        }
        else
        { 
        	if(file_will_use_blocks <= 12)
        	{ 
        	    block_idx = file_has_used_blocks - 1;		  //继续写最后一块没有写完的空间
        	    ASSERT(file->fd_inode->i_sectors[block_idx] != 0);
        	    all_blocks[block_idx] = file->fd_inode->i_sectors[block_idx];
        	    
        	    block_idx = file_has_used_blocks;			  //即将要新分配的扇区位置
        	    while(block_idx < file_will_use_blocks)
        	    { 
        	    	block_lba = block_bitmap_alloc(cur_part);
        	    	if(block_lba == -1)
        	    	{ 
        	    	    printk("file_write: block_bitmap_alloc for situation 1 failed\n");
        	    	    sys_free(all_blocks);
        	    	    sys_free(io_buf);
        	    	    return -1;
        	    	}
        	        ASSERT(file->fd_inode->i_sectors[block_idx] == 0);
        	        file->fd_inode->i_sectors[block_idx] = all_blocks[block_idx] = block_lba;
        	        block_bitmap_idx = block_lba - cur_part->sb->data_start_lba;
        	        bitmap_sync(cur_part,block_bitmap_idx,BLOCK_BITMAP);
        	    	++block_idx;
        	    }
        	}
        	else if(file_has_used_blocks <= 12 && file_will_use_blocks > 12) //直接块可能分配完了 要分配间接块了
        	{ 
        	    //把即将要写入的空闲区放到all_block[block_idx]
        	    block_idx = file_has_used_blocks - 1;
        	    all_blocks[block_idx] = file->fd_inode->i_sectors[block_idx];
        	    
        	    block_lba = block_bitmap_alloc(cur_part);
        	    if(block_lba == -1)
        	    { 
        	    	printk("file_write: block_bitmap_alloc for situation 2 failed\n");
        	    	sys_free(all_blocks);
        	    	sys_free(io_buf);
        	    	return -1;
        	    }
        	    
        	    ASSERT(file->fd_inode->i_sectors[12] == 0);
        	    indirect_block_table = file->fd_inode->i_sectors[12] = block_lba; //先把一级间接表分配了
        	    
        	    /*这里书上没有写 但是肯定是必须要有同步的 不然是肯定错误的*/
        	    block_bitmap_idx = block_lba - cur_part->sb->data_start_lba;
        	    bitmap_sync(cur_part,block_bitmap_idx,BLOCK_BITMAP);
        	    
        	    block_idx = file_has_used_blocks;
        	    
        	    while(block_idx < file_will_use_blocks)
        	    { 
        	    	block_lba = block_bitmap_alloc(cur_part);
        	    	if(block_lba == -1)
        	    	{ 
        	    	    printk("file_write: block_bitmap_alloc for situation 2 failed\n");
        	    	    sys_free(all_blocks);
        	    	    sys_free(io_buf);
        	    	    return -1;
        	    	}
        	    	
        	    	if(block_idx < 12)
        	    	{ 
        	    	    ASSERT(file->fd_inode->i_sectors[block_lba] == 0);
        	    	    file->fd_inode->i_sectors[block_lba] = all_blocks[block_idx] = block_lba;
        	    	}
        	    	else	all_blocks[block_idx] = block_lba;
        	    	
        	    	block_bitmap_idx = block_lba - cur_part->sb->data_start_lba;
        	    	bitmap_sync(cur_part,block_bitmap_idx,BLOCK_BITMAP);
        	    	++block_idx;
        	    }
        	    ide_write(cur_part->my_disk,indirect_block_table,all_blocks + 12,1);
        	}
        	else if(file_has_used_blocks > 12)
        	{ 
        	    ASSERT(file->fd_inode->i_sectors[12] != 0);
        	    indirect_block_table = file->fd_inode->i_sectors[12];
        	    
        	    block_idx = file_has_used_blocks;
        	    
        	    while(block_idx < file_will_use_blocks)
        	    { 
        	        block_lba = block_bitmap_alloc(cur_part);
        	        if(block_lba == -1)
        	        { 
        	            printk("file_write: block_bitmap_alloc for situation 3 failed\n");
        	            sys_free(all_blocks);
        	    	    sys_free(io_buf);
        	    	    return -1;
        	        }
        	        
        	        all_blocks[block_idx] = block_lba;
        	    	
        	    	block_bitmap_idx = block_lba - cur_part->sb->data_start_lba;
        	    	bitmap_sync(cur_part,block_bitmap_idx,BLOCK_BITMAP);
        	    	++block_idx;
        	    }
        	    ide_write(cur_part->my_disk,indirect_block_table,all_blocks + 12,1);
        	}
        }
        
        bool first_write_block = true;              // 有剩余空间块的标识 就表示没处理第一个有空余块的标识
        file->fd_pos = file->fd_inode->i_size - 1;  // 指针放到文件大小的最后一个
        while(bytes_written < count)
        { 
            memset(io_buf,0,BLOCK_SIZE);
            sec_idx = file->fd_inode->i_size / BLOCK_SIZE; //扇区起始
            sec_lba = all_blocks[sec_idx];
            sec_off_bytes  = file->fd_inode->i_size % BLOCK_SIZE; //扇区中的偏移位置
            sec_left_bytes = BLOCK_SIZE - sec_off_bytes;
            
            chunk_size = size_left < sec_left_bytes ? size_left : sec_left_bytes;
            if(first_write_block)
            { 
                ide_read(cur_part->my_disk,sec_lba,io_buf,1);
                first_write_block = false;
            }
            memcpy(io_buf + sec_off_bytes,src,chunk_size);
            ide_write(cur_part->my_disk,sec_lba,io_buf,1);
            src += chunk_size;
            file->fd_inode->i_size += chunk_size;
            file->fd_pos += chunk_size;
            bytes_written += chunk_size;
            size_left -= chunk_size;
        }
        inode_sync(cur_part,file->fd_inode,io_buf);
        sys_free(all_blocks);
        sys_free(io_buf);
        return bytes_written;
    }

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

### 编写完的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);
    int32_t file_open(uint32_t inode_no,uint8_t flag);
    int32_t file_close(struct file* file);
    int32_t file_write(struct file* file,const void* buf,uint32_t count);
    int32_t file_read(struct file* file,void* buf,uint32_t count);
    
    #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"
    #include "../thread/thread.h"
    #include "../device/console.h"
    #include "../device/ioqueue.h"
    #include "../device/keyboard.h"
    
    extern struct ioqueue ioqueue;
    
    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] |= 0x01;
        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 用~来处理 真的很妙
        uint32_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] |= 0x01;	                                          //第一个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;
    }
    
    //局部pcb文件描述符表返回全局表下标号
    uint32_t fd_local2global(uint32_t local_fd)
    { 
        struct task_struct* cur = running_thread();
        int32_t global_fd = cur->fd_table[local_fd];
        ASSERT(global_fd >= 0 && global_fd <= MAX_FILE_OPEN);
        return (uint32_t)global_fd;
    }
    
    //关闭pcb文件描述符fd的文件 成功返回0 失败-1
    int32_t sys_close(int32_t fd)
    { 
        int32_t ret = -1;	//返回值默认为-1
        if(fd > 2)		// 0 1都是标准输入 输出
        { 
        	uint32_t _fd = fd_local2global(fd);
        	ret = file_close(&file_table[_fd]);
        	running_thread()->fd_table[fd] = -1;	//pcb fd恢复可用
        }
        return ret;
    }
    
    //写入连续的count字节到文件描述符fd
    int32_t sys_write(int32_t fd,const void* buf,uint32_t count)
    { 
        if(fd < 0)
        { 
            printk("sys_write: fd error\n");
            return -1;
        }
        if(fd == stdout_no)
        { 
            char tmp_buf[1024] = { 0};
            memcpy(tmp_buf,buf,count);
            console_put_str(tmp_buf);
            return count;
        }
        
        uint32_t _fd = fd_local2global(fd);
        struct file* wr_file = &file_table[_fd];
        if(wr_file->fd_flag & O_WRONLY || wr_file->fd_flag & O_RDWR)
        { 
            uint32_t bytes_written = file_write(wr_file,buf,count);
            return bytes_written;
        }
        else
        { 
            console_put_str("sys_write: not allowed to write file without flag O_RDWR or O_WRONLY\n");
            return -1;
        }
    }
    
    int32_t sys_read(int32_t fd,void* buf,uint32_t count)
    { 
        int ret = -1;
        if(fd < 0 || fd == stdout_no || fd == stderr_no)
        { 
        	printk("sys_read : fd error\n");
        	return -1;
        }
        else if(fd == stdin_no)
        { 
            char* buffer = buf;
            uint32_t bytes_read = 0;
            while(bytes_read < count)
            { 
                *buffer = ioq_getchar(&ioqueue);
                ++bytes_read;
                ++buffer;
            }
            ret = (bytes_read == 0) ? -1 : (int32_t)bytes_read;
        }
        else
        { 
            uint32_t _fd = fd_local2global(fd);
            if(count == 2525)while(1);
            ret = file_read(&file_table[_fd],buf,count);
        }   
        return ret;
    }
    
    int32_t sys_lseek(int32_t fd,int32_t offset,uint8_t whence)
    { 
        if(fd < 0)
        { 
            printk("sys_lseek: fd error\n");
            return -1;
        }
        ASSERT(whence > 0 && whence < 4);
        uint32_t _fd = fd_local2global(fd);
        struct file* file = &file_table[_fd];
        int32_t new_pos = 0;
        int32_t file_size = (int32_t)file->fd_inode->i_size;
        switch(whence)
        { 
            case SEEK_SET:
                new_pos = offset; //相对文件开始的偏移
                break;
            case SEEK_CUR:
                new_pos = offset + (int32_t)file->fd_pos;
                break;
            case SEEK_END:
                new_pos = offset + (int32_t)file_size;
                break;    
        }
        if(new_pos < 0 || new_pos > (file_size -1))
        	return -1;
       
        file->fd_pos = new_pos;
        return file->fd_pos;
    }
    
    //删除普通文件
    int32_t sys_unlink(const char* pathname)
    { 
        ASSERT(strlen(pathname) < MAX_PATH_LEN);
        
        struct path_search_record searched_record;
        memset(&searched_record,0,sizeof(struct path_search_record));
        int inode_no = search_file(pathname,&searched_record);
        ASSERT(inode_no != 0);
        if(inode_no == -1)
        { 
            printk("file %s not found!\n",pathname);
            dir_close(searched_record.parent_dir);
            return -1;
        }
        if(searched_record.file_type == FT_DIRECTORY)
        { 
            printk("cant delete a directory with unlink(),use rmdir() to instead\n");
            dir_close(searched_record.parent_dir);
            return -1;
        }
        
        //检查在不在已经打开文件列表
        uint32_t file_idx  = 0;
        while(file_idx < MAX_FILE_OPEN)
        { 
            if(file_table[file_idx].fd_inode != NULL && (uint32_t)inode_no == file_table[file_idx].fd_inode->i_no)
                break;
            file_idx++;
        }
        if(file_idx < MAX_FILE_OPEN)
        { 
            dir_close(searched_record.parent_dir);
            printk("file %s is in use , not allowed to delete!\n",pathname);
            return -1;
        }
        
        ASSERT(file_idx == MAX_FILE_OPEN);
        
        void* io_buf = sys_malloc(1024);
        if(io_buf == NULL)
        { 
            dir_close(searched_record.parent_dir);
            printk("sys_unlink: malloc for io_buf failed!\n");
            return -1;
        }
        
        struct dir* parent_dir = searched_record.parent_dir;
        delete_dir_entry(cur_part,parent_dir,inode_no,io_buf);//删除目录项
        inode_release(cur_part,inode_no);			    //删除inode
        sys_free(io_buf);
        dir_close(searched_record.parent_dir);
        return 0;	//成功删除
        
    }
    
    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);
        	    break;
            default:
                fd = file_open(inode_no,flags);
        }
        
        return fd;
    }
    
    //创建目录 成功返回0 失败返回-1
    int32_t sys_mkdir(const char* pathname)
    { 
        uint8_t rollback_step = 0;
        void* io_buf = sys_malloc(SECTOR_SIZE * 2);
        if(io_buf == NULL)
        { 
            printk("sys_mkdir: sys_malloc for io_buf failed\n");
            return -1;
        }
        
        struct path_search_record searched_record;
        memset(&searched_record,0,sizeof(struct path_search_record));
        int inode_no = -1;
        inode_no = search_file(pathname,&searched_record);
        if(inode_no != -1)	//如果找到同名的 目录或者文件 则inode_no 肯定不为-1 则进入逆转
        { 
            printk("sys_mkdir: file or directory %s exist\n",pathname);
            rollback_step = 1;
            goto rollback;
        }
        else
        { 
            uint32_t pathname_depth = path_depth_cnt((char*)pathname); 
            uint32_t path_searched_depth = path_depth_cnt(searched_record.searched_path);
            //看深度是否相同 不相同说明到中间某处就找不到停止了 可带入两个路径看看效果
            if(pathname_depth != path_searched_depth)
            { 
                printk("sys_mkdir: cannot access %s: Not a directory,subpath %s isnt exist\n",pathname,searched_record.searched_path);
                rollback_step = 1;
                goto rollback;
            }
        }
        
        struct dir* parent_dir = searched_record.parent_dir; //得到最后路径的直接父路径
        char* dirname = strrchr(searched_record.searched_path,'/') + 1; //得到最后目标目录名称
        inode_no = inode_bitmap_alloc(cur_part);  //得到新分配的inode结点 
        if(inode_no == -1)
        { 
            printk("sys_mkdir: allocate inode failed\n");
            rollback_step = 1;
            goto rollback;
        }
        
        //即将要使用的inode 负责memcpy到硬盘中
        struct inode new_dir_inode;
        inode_init(inode_no,&new_dir_inode);
        
        //再分配一个块
        uint32_t block_bitmap_idx = 0;
        int32_t  block_lba = -1;
        block_lba = block_bitmap_alloc(cur_part);
        if(block_lba == -1)
        { 
            printk("sys_mkdir: block_bitmap_alloc for create directory failed\n");
            rollback_step = 2; //把之前的inode给回滚了
            goto rollback;
        }   
        new_dir_inode.i_sectors[0] = block_lba;
        block_bitmap_idx = block_lba - cur_part->sb->data_start_lba;
        ASSERT(block_bitmap_idx != 0);
        bitmap_sync(cur_part,block_bitmap_idx,BLOCK_BITMAP);
        
        //'.' 和 '..'写入目录中
        memset(io_buf,0,SECTOR_SIZE * 2);
        struct dir_entry* p_de = (struct dir_entry*)io_buf;
        
        //第一个目录项 .
        memcpy(p_de->filename,".",1);
        p_de->i_no = inode_no;
        p_de->f_type = FT_DIRECTORY;
        
        //移动到下一个目录项的位置 ..
        p_de++;  
        memcpy(p_de->filename,"..",2);
        p_de->i_no = parent_dir->inode->i_no;
        p_de->f_type = FT_DIRECTORY;
        ide_write(cur_part->my_disk,new_dir_inode.i_sectors[0],io_buf,1);
        
        new_dir_inode.i_size = 2 * cur_part->sb->dir_entry_size;
        
        struct dir_entry new_dir_entry;
        memset(&new_dir_entry,0,sizeof(struct dir_entry));
        memset(io_buf,0,SECTOR_SIZE * 2);
        //目录项存放在new_dir_entry中 new_inode已经初始化好了 里面的数据也都填了
        create_dir_entry(dirname,inode_no,FT_DIRECTORY,&new_dir_entry); 
        
        //失败了
        if(!sync_dir_entry(parent_dir,&new_dir_entry,io_buf))
        { 
            printk("sys_mkdir: sync_dir_entry to disk_failed\n");
            rollback_step = 2;
            goto rollback;
        }
        
        //父结点的inode写入到硬盘中
        memset(io_buf,0,SECTOR_SIZE * 2);
        inode_sync(cur_part,parent_dir->inode,io_buf);
        
        //新建立的写入到硬盘中
        memset(io_buf,0,SECTOR_SIZE * 2);
        inode_sync(cur_part,&new_dir_inode,io_buf);
        
        bitmap_sync(cur_part,inode_no,INODE_BITMAP);
        
        sys_free(io_buf);
        dir_close(searched_record.parent_dir);
        return 0;
        
        rollback:
            switch(rollback_step)
            { 
                case 2:
                    bitmap_set(&cur_part->inode_bitmap,inode_no,0);
                case 1:
                    dir_close(searched_record.parent_dir);
                    break;
            }
            sys_free(io_buf);
            return -1;
    }
    
    //打开指定目录 返回其目录指针 失败返回NULL
    struct dir* sys_opendir(const char* name)
    { 
        //如果是根目录
        ASSERT(strlen(name) < MAX_PATH_LEN);
        if(name[0] == '/' && (name[1] == 0 || name[0] == '.'))
            return &root_dir;
            
        struct path_search_record searched_record;
        memset(&searched_record,0,sizeof(struct path_search_record));
        int inode_no = search_file(name,&searched_record);
        struct dir* ret = NULL;
        if(inode_no == -1) 
        { 
            printk("sys_opendir:In %s,sub path %s not exist\n",name,searched_record.searched_path);
            return NULL;
        }
        else
        { 
            if(searched_record.file_type == FT_REGULAR)
                printk("%s is regular file!\n",name);
            else if(searched_record.file_type == FT_DIRECTORY)
                ret = dir_open(cur_part,inode_no);
        }    
        dir_close(searched_record.parent_dir);
        return ret;
    }
    
    //dir是临时目录 
    int32_t sys_closedir(struct dir* dir)
    { 
        int32_t ret = -1;
        if(dir != NULL)
        { 
            dir_close(dir);
            ret = 0;
        }
        return ret;
    }
    
    //包装函数
    struct dir_entry* sys_readdir(struct dir* dir)
    { 
        ASSERT(dir != NULL);
        return dir_read(dir); //返回读的地址 
    }
    
    //目录指针位置dir_pos置0
    void sys_rewinddir(struct dir* dir)
    { 
        dir->dir_pos = 0;
    }
    
    //删除空目录项 成功返回0 失败-1
    int32_t sys_rmdir(const char* pathname)
    { 
        struct path_search_record searched_record;
        memset(&searched_record,0,sizeof(struct path_search_record));
        int inode_no = search_file(pathname,&searched_record);
        ASSERT(inode_no != 0);
        int retval = -1;
        if(inode_no == -1)
            printk("In %s,sub path %s not exist\n",pathname,searched_record.searched_path);
        else
        { 
            if(searched_record.file_type == FT_REGULAR)
            { 
                printk("%s is regular file!\n",pathname);
            }
            else
            { 
                struct dir* dir = dir_open(cur_part,inode_no);
                if(!dir_is_empty(dir)) //必须要是空目录
                    printk("dir %s is not empty,it is not allowed to delete a nonempty directory!\n",pathname);
                else
                { 
                    if(!dir_remove(searched_record.parent_dir,dir))
                        retval = 0;
                }
            }
        }
        dir_close(searched_record.parent_dir);
        return retval;
    }
    
    //得到父目录的inode编号
    uint32_t get_parent_dir_inode_nr(uint32_t child_inode_nr,void* io_buf)
    { 
        struct inode* child_dir_inode = inode_open(cur_part,child_inode_nr);
        uint32_t block_lba = child_dir_inode->i_sectors[0];
        ASSERT(block_lba >= cur_part->sb->data_start_lba);
        inode_close(child_dir_inode);
        ide_read(cur_part->my_disk,block_lba,io_buf,1);
        struct dir_entry* dir_e = (struct dir_entry*)io_buf;
        ASSERT(dir_e[1].i_no < 4096 && dir_e[1].f_type == FT_DIRECTORY);
        return dir_e[1].i_no;
    }
    
    //在inode编号为p_inode_nr中寻找编号c_inode_nr的名字 且把路径存到path中
    int get_child_dir_name(uint32_t p_inode_nr,uint32_t c_inode_nr,char* path,void* io_buf)
    { 
        struct inode* parent_dir_inode = inode_open(cur_part,p_inode_nr);
        uint8_t block_idx = 0;
        uint32_t all_blocks[140] = { 0},block_cnt = 12;
        //老套路 读间接块咯
        while(block_idx < 12)
        { 
            all_blocks[block_idx] = parent_dir_inode->i_sectors[block_idx];
            ++block_idx;
        }
        //有间接块的话 直接读
        if(parent_dir_inode->i_sectors[12])
        { 
            ide_read(cur_part->my_disk,parent_dir_inode->i_sectors[12],all_blocks + 12,1);
            block_cnt = 140;
        }
        inode_close(parent_dir_inode);
        
        struct dir_entry* dir_e = (struct dir_entry*)io_buf;
        uint32_t dir_entry_size = cur_part->sb->dir_entry_size;
        uint32_t dir_entrys_per_sec = (512 / dir_entry_size);
        block_idx = 0;
        
        while(block_idx < block_cnt)
        { 
            if(all_blocks[block_idx])
            { 
                memset(io_buf,0,SECTOR_SIZE);
                ide_read(cur_part->my_disk,all_blocks[block_idx],io_buf,1);
                uint8_t dir_e_idx = 0;
                while(dir_e_idx < dir_entrys_per_sec)
                { 
                    if((dir_e_idx + dir_e)->i_no == c_inode_nr)
                    { 
                        strcat(path,"/");
                        strcat(path,(dir_e + dir_e_idx)->filename);
                        return 0;
                    }
                    ++dir_e_idx;
                }
                ++block_idx;
            }
        }
        return -1;
    }
    
    //当前工作目录写入buf 如果buf为NULL 则操作系统提供并写入
    char* sys_getcwd(char* buf,uint32_t size)
    { 
        ASSERT(buf != NULL);
        void* io_buf = sys_malloc(SECTOR_SIZE);
        if(io_buf == NULL)
            return NULL;
            
        struct task_struct* cur_thread = running_thread();
        int32_t parent_inode_nr = 0;
        int32_t child_inode_nr = cur_thread->cwd_inode_nr;
        ASSERT(child_inode_nr >= 0 && child_inode_nr < 4096);
        if(child_inode_nr == 0)
        { 
            buf[0] = '/';
            buf[1] = 0;
            return buf;
        }
        
        memset(buf,0,size);
        char full_path_reverse[MAX_PATH_LEN] = { 0};
        while((child_inode_nr))
        { 
            parent_inode_nr = get_parent_dir_inode_nr(child_inode_nr,io_buf); //得到工作目录父结点
            //如果失败了 则退出
            if(get_child_dir_name(parent_inode_nr,child_inode_nr,full_path_reverse,io_buf) == -1)
            { 
                sys_free(io_buf);
                return NULL;
            }
            child_inode_nr = parent_inode_nr; //子结点inode数等于父结点的 然后一路递归上去 则路径就是从子->父
        }
        ASSERT(strlen(full_path_reverse) <= size);
        
        char* last_slash;
        //倒着把路径给录入进去
        while((last_slash = strrchr(full_path_reverse,'/') ))
        { 
            uint16_t len = strlen(buf);
            strcpy(buf + len,last_slash);
            *last_slash = 0;
        }
        sys_free(io_buf);
        return buf;
    }
    
    int32_t sys_chdir(const char* path)
    { 
        int32_t ret = -1;
        struct path_search_record searched_record;
        memset(&searched_record,0,sizeof(struct path_search_record));
        int inode_no = search_file(path,&searched_record);
        //找到了就继续
        if(inode_no != -1)
        { 
            if(searched_record.file_type == FT_DIRECTORY)
            { 
                //切换工作cwd_inode_nr
                running_thread()->cwd_inode_nr = inode_no;
                ret = 0;
            }
            else
                printk("sys_chdir: %s is regular file or other!\n");
        }
        dir_close(searched_record.parent_dir);
        return ret;   
    }
    
    //在buf中填充文件结构相关信息 成功返回0 失败返回-1
    int32_t sys_stat(const char* path,struct stat* buf)
    { 
        //如果是根目录
        if(!strcmp(path,"/") || !strcmp(path,"/.") || !strcmp(path,"/.."))
        { 
            buf->st_filetype = FT_DIRECTORY;
            buf->st_ino = 0;
            buf->st_size = root_dir.inode->i_size;
        }
        
        int32_t ret = -1;
        struct path_search_record searched_record;
        memset(&searched_record,0,sizeof(struct path_search_record));
        
        int inode_no = search_file(path,&searched_record);
        if(inode_no != -1)
        { 
            struct inode* obj_inode = inode_open(cur_part,inode_no);
            buf->st_size = obj_inode->i_size;
            buf->st_filetype = searched_record.file_type;
            buf->st_ino = inode_no;
            inode_close(obj_inode);
            ret = 0;
        }
        else
            printk("sys_stat: %s not found\n",path);
        
        dir_close(searched_record.parent_dir);
        return ret;
    }

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

### 编写完的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	//创建
    };
    
    enum whence
    { 
        SEEK_SET = 1,
        SEEK_CUR,
        SEEK_END
    };
    
    struct path_search_record
    { 
        char searched_path[MAX_PATH_LEN]; //父路径
        struct dir* parent_dir;	       //文件直接的父路径 或者说上一级的路径
        enum file_types file_type;        //普通文件 目录 或者未知类型
    };
    
    struct stat
    { 
        uint32_t st_ino;		       //inode编号
        uint32_t st_size;		       //尺寸
        enum file_types st_filetype;      //文件类型
    };
    
    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);
    uint32_t fd_local2global(uint32_t local_fd);
    int32_t sys_close(int32_t fd);
    int32_t sys_write(int32_t fd,const void* buf,uint32_t count);
    int32_t sys_read(int32_t fd,void* buf,uint32_t count);
    int32_t sys_lseek(int32_t fd,int32_t offset,uint8_t whence);
    int32_t sys_unlink(const char* pathname);
    int32_t sys_mkdir(const char* pathname);
    struct dir* sys_opendir(const char* name);
    int32_t sys_closedir(struct dir* dir);
    struct dir_entry* sys_readdir(struct dir* dir);
    void sys_rewinddir(struct dir* dir);
    int32_t sys_rmdir(const char* pathname);
    uint32_t get_parent_dir_inode_nr(uint32_t child_inode_nr,void* io_buf);
    int get_child_dir_name(uint32_t p_inode_nr,uint32_t c_inode_nr,char* path,void* io_buf);
    char* sys_getcwd(char* buf,uint32_t size);
    int32_t sys_chdir(const char* path);
    int32_t sys_stat(const char* path,struct stat* buf);
    
    #endif

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

### 编写完的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"
    #include "bitmap.h"
    #include "file.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_table中的inode
    void inode_delete(struct partition* part,uint32_t inode_no,void* io_buf)
    { 
        ASSERT(inode_no < 4096);
        struct inode_position inode_pos;	//存储inode的pos的
        inode_locate(part,inode_no,&inode_pos);
        ASSERT(inode_pos.sec_lba <= (part->start_lba + part->sec_cnt));
        
        char* inode_buf = (char*)io_buf;
        if(inode_pos.two_sec)
        { 
            ide_read(part->my_disk,inode_pos.sec_lba,inode_buf,2);	//夹在两个扇区间
            memset((inode_buf + inode_pos.off_size),0,sizeof(struct inode)); //把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);	//夹在两个扇区间
            memset((inode_buf + inode_pos.off_size),0,sizeof(struct inode)); //把inode信息清除 再次写回硬盘
            ide_write(part->my_disk,inode_pos.sec_lba,inode_buf,1); 
        }
    }
    
    //回收inode 将inode位图给收回 并把inode里面所占用的块给回收
    void inode_release(struct partition* part,uint32_t inode_no)
    { 
        struct inode* inode_to_del = inode_open(part,inode_no);  //返回inode指针
        ASSERT(inode_to_del->i_no == inode_no);
        
        uint8_t  block_idx = 0,block_cnt = 12; //预设先设置12个直接块
        uint32_t block_bitmap_idx;
        uint32_t all_blocks[140] = { 0};	//所有块的块地址 12 + 128 = 140
        
        //先把12个直接块地址放进去 再看间接块是否为0 为0无视 有地址的话 再把间接块全部放进去
        while(block_idx < 12)
        { 
        	all_blocks[block_idx] = inode_to_del->i_sectors[block_idx];
        	++block_idx;
        }
        
        if(inode_to_del->i_sectors[12] != 0)
        { 
            ide_read(part,inode_to_del->i_sectors[12],all_blocks + 12,1);
            block_cnt = 140;
            
            //先回收存放间接块地址的那一块
            block_bitmap_idx = inode_to_del->i_sectors[12] - part->sb->data_start_lba;
            ASSERT(block_bitmap_idx > 0);
            bitmap_set(&part->block_bitmap,block_bitmap_idx,0);
            bitmap_sync(cur_part,block_bitmap_idx,BLOCK_BITMAP);
        }
        
        block_idx = 0;
        
        while(block_idx < block_cnt)
        { 
            if(all_blocks[block_idx] != 0)
            { 
            
                //不需要清除硬盘上的0 以后再分配上去 数据覆盖即可
                block_bitmap_idx = 0;
                block_bitmap_idx = all_blocks[block_idx] - part->sb->data_start_lba;
                ASSERT(block_bitmap_idx > 0);
                bitmap_set(&part->block_bitmap,block_bitmap_idx,0);
                bitmap_sync(cur_part,block_bitmap_idx,BLOCK_BITMAP);
            }
            ++block_idx;
        }
        
        //清除这个inode所占用的inode位图 置0
        bitmap_set(&part->inode_bitmap,inode_no,0);
        bitmap_sync(cur_part,inode_no,INODE_BITMAP);
        
        //下面的inode_delete 主要看看 inode_table 我们原来分配的内容有没有置0
        void* io_buf = sys_malloc(1024);
        inode_delete(part,inode_no,io_buf);
        sys_free(io_buf);    
        inode_close(inode_to_del);  //把内存中的inode删除
    }

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

### 编写完的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);
    void inode_delete(struct partition* part,uint32_t inode_no,void* io_buf);
    void inode_release(struct partition* part,uint32_t inode_no);
    
    #endif

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

### 编写完的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

[Link 1]: https://love6.blog.csdn.net/article/details/119133589