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

痛定思痛。 2022-09-04 05:40 63阅读 0赞

### 文章目录 ###

*   *  专栏博客链接
     *  相关查阅博客链接
     *  本书中错误勘误
     *  部分缩写熟知
     *  实现遍历目录
     *   *  编写完的fs.c（sys\_opendir）
         *  编写完的dir.c（dir\_read）
         *  编写完的fs.c
         *  编写完的main.c
         *  make all 验证成果
     *  实现删除目录
     *   *  编写完的dir.c（dir\_is\_empty && dir\_remove）
         *  编写完的fs.c（sys\_redir）
         *  修改完的main.c
         *  make all 验证成果
     *  实现任务的工作目录
     *   *  编写完的fs.c（get\_parent\_dir\_inode\_nr）
         *  编写完的fs.c（get\_child\_dir\_name）
         *  修改完的thread.h（task\_struct）
         *  修改完的thread.c（init\_thread）
         *  编写完的fs.c（sys\_getcwd）
         *  编写完的fs.c（sys\_chdir）
         *  修改完的main.c
         *  make all 验证成果
     *  实现获取文件属性
     *   *  编写完的fs.h（struct stat）
         *  编写完的fs.c（sys\_stat）
         *  修改完的main.c
         *  make all 验证成果

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

## 专栏博客链接 ##

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

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

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

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

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

## 本书中错误勘误 ##

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

**`fs.c` 函数`sys_opendir` 判断根目录那里写错了  
应该是`if(name[0] == '/' && (name[1] == 0 || name[1] == '.'))`**

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

## 部分缩写熟知 ##

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

**cwd `current working dir` 当前工作目录 应该是这个全称**

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

## 实现遍历目录 ##

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

### 编写完的fs.c（sys\_opendir） ###

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

//打开指定目录 返回其目录指针 失败返回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.c（dir\_read） ###

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

//读取目录
    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;
    }

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

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

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

//包装函数
    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;
    }

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

### 编写完的main.c ###

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

**这里的硬盘是连着之前创建了  
`/file2`的连着来的 如果想用下面的代码 可以复制一个原来的硬盘再来 哈哈**

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

### make all 验证成果 ###

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

**实现效果是一样的 哈哈 还是挺好的**

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

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

## 实现删除目录 ##

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

### 编写完的dir.c（dir\_is\_empty && dir\_remove） ###

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

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;
    }

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

### 编写完的fs.c（sys\_redir） ###

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

//删除空目录项 成功返回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;
    }

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

### 修改完的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();
       
       /*printk("/dir1/subdir1 create %s!\n",(sys_mkdir("/dir1/subdir1") == 0) ? "done" : "fail"); printk("/dir1 create %s!\n",(sys_mkdir("/dir1") == 0) ? "done" : "fail"); printk("/dir1/subdir1 create %s!\n",(sys_mkdir("/dir1/subdir1") == 0) ? "done" : "fail"); int fd = sys_open("/dir1/subdir1/file2",O_CREAT | O_RDWR); if(fd != -1) { printk("/dir1/subdir1/file2 create done!\n"); sys_write(fd,"Catch me if u can!\n",19); sys_lseek(fd,0,SEEK_SET); char buf[32] = {0}; sys_read(fd,buf,19); printf("/dir1/subdir1/file2 says:\n%s",buf); sys_close(fd); }*/
    
       struct dir* p_dir = sys_opendir("/dir1/subdir1");
       struct dir_entry* dir_e = NULL;
       if(p_dir)
       { 
           printf("/dir1/subdir1 open done!\ncontent:\n");
           char* type = NULL;
           while((dir_e = sys_readdir(p_dir)))
           { 
               if(dir_e->f_type == FT_REGULAR)
               { 
                   type = "regular";
               }
               else	type = "directory";
               printk(" %s %s\n",type,dir_e->filename);
           }
           if(sys_closedir(p_dir) == 0)
               printk("/dir1/subdir1 close done!\n");
           else
               printk("/dir1/subdir1 close fail!\n");
       }
       else printf("/dir1/subdir1 open fail\n\n");
       
       printk("try to delete nonempty directory /dir1/subdir1\n");
       if(sys_rmdir("/dir1/subdir1") == -1)
       	printk("sys_rmdir: /dir/subdir1 delete fail\n");
       
       printk("try to delete directory /dir1/subdir1/file2\n");
       if(sys_rmdir("/dir1/subdir1/file2") == -1)
       	printk("sys_rmdir: /dir/subdir1/file2 delete fail\n");
       	
       if(sys_unlink("/dir1/subdir1/file2") == -1)
       	printk("sys_unlink: /dir/subdir1/file2 delete fail\n");
       else
       	printk("sys_unlink: /dir/subdir1/file2 delete done\n");
       	
       printk("try to delete directory /dir1/subdir1 again\n");
       if(sys_rmdir("/dir1/subdir1") == -1)
       	printk("sys_rmdir: /dir/subdir1 delete fail\n");
       else
            printk("sys_rmdir:/dir1/subdir1 delete done!\n");
            
       p_dir = sys_opendir("/dir1");
       dir_e = NULL;
       if(p_dir)
       { 
           printf("/dir1 open done!\ncontent:\n");
           char* type = NULL;
           while((dir_e = sys_readdir(p_dir)))
           { 
               if(dir_e->f_type == FT_REGULAR)
               { 
                   type = "regular";
               }
               else	type = "directory";
               printk(" %s %s\n",type,dir_e->filename);
           }
           if(sys_closedir(p_dir) == 0)
               printk("/dir1 close done!\n");
           else
               printk("/dir1 close fail!\n");
       }
       else printf("/dir1 open fail\n");
       
       while(1);
       return 0;
    }

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

### make all 验证成果 ###

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

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

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

## 实现任务的工作目录 ##

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

### 编写完的fs.c（get\_parent\_dir\_inode\_nr） ###

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

//得到父目录的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;
    }

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

### 编写完的fs.c（get\_child\_dir\_name） ###

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

//在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;
    }

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

### 修改完的thread.h（task\_struct） ###

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

struct task_struct
    { 
        uint32_t* self_kstack;                          //pcb中的 kernel_stack 内核栈
        pid_t pid;
        enum task_status status;                        //线程状态
        uint8_t priority;				      //特权级
        uint8_t ticks;				      //在cpu 运行的滴答数 看ticks 来判断是否用完了时间片
        uint32_t elapsed_ticks;                         //一共执行了多久
        char name[16];
        
        struct list_elem general_tag;                   //就绪队列中的连接节点
        struct list_elem all_list_tag;		      //总队列的连接节点
        int32_t fd_table[MAX_FILES_OPEN_PER_PROC];      //文件描述符数组
        
        uint32_t* pgdir;				      //进程自己页表的虚拟地址 线程没有 
        struct virtual_addr userprog_vaddr;	      //用户进程的虚拟空间 
        struct mem_block_desc u_block_desc[DESC_CNT];   //内存块描述符
        uint32_t cwd_inode_nr;			      //工作目录inode编号
        uint32_t stack_magic;			      //越界检查 因为我们pcb上面的就是我们要用的栈了 到时候还要越界检查
    };

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

### 修改完的thread.c（init\_thread） ###

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

void init_thread(struct task_struct* pthread,char* name,int prio)
    { 
        memset(pthread,0,sizeof(*pthread)); //pcb位置清0
        strcpy(pthread->name,name);
        
        if(pthread == main_thread)
        	pthread->status = TASK_RUNNING;                              //我们的主线程肯定是在运行的
        else
        	pthread->status = TASK_READY;					//放到就绪队列里面
        	
        pthread->self_kstack = (uint32_t*)((uint32_t)pthread + PG_SIZE); //刚开始的位置是最低位置 栈顶位置+一页得最顶部
                                                                         //后面还要对这个值进行修改
        pthread->pid = allocate_pid();                                   //提前分配pid 
        pthread->priority = prio;                                        
        pthread->ticks = prio;                                           //和特权级 相同的时间片
        pthread->elapsed_ticks = 0;
        pthread->pgdir = NULL;                                           //线程没有单独的地址
        pthread->fd_table[0] = 0;						
        pthread->fd_table[1] = 0;
        pthread->fd_table[2] = 0;
        
        uint8_t fd_idx = 3;
        while(fd_idx < MAX_FILES_OPEN_PER_PROC)
        	pthread->fd_table[fd_idx++] = -1;
        pthread->cwd_inode_nr = 0;					//默认工作路径在根目录
        pthread->stack_magic = 0x23333333;                               //设置的魔数 检测是否越界限
    }

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

### 编写完的fs.c（sys\_getcwd） ###

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

//当前工作目录写入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;
    }

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

### 编写完的fs.c（sys\_chdir） ###

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

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;   
    }

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

### 修改完的main.c ###

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

### make all 验证成果 ###

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

**做了些许改动 可以看出来应该功能还是实现了**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTAwNTE2_size_16_color_FFFFFF_t_70 2]

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

## 实现获取文件属性 ##

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

### 编写完的fs.h（struct stat） ###

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

struct stat
    { 
        uint32_t st_ino;		       //inode编号
        uint32_t st_size;		       //尺寸
        enum file_types st_filetype;      //文件类型
    };

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

### 编写完的fs.c（sys\_stat） ###

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

//在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;
    }

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

### 修改完的main.c ###

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

### make all 验证成果 ###

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

**这里看出来信息还是对的  
根目录下 只有 `.` `..` `/dir1`  
`dir1`下 只有`.` `..` `/subdir1`**  
**而作为普通文件 `/file2` 我们写入了`Catch me if u can!\n`刚好19个字节 文件类型也对上了**

**啊这一章终于画上句号了 后面我先把这一章代码先给发出来 哈哈 写这一章确实是心理和体力的双重考验啊 我其中的闲聊基本上也没心情写了 哈哈 就先写到这里 我们下一篇博客见 哈哈**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTAwNTE2_size_16_color_FFFFFF_t_70 3]

[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/0e5def81019247088140528d32eeae4d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTAwNTE2_size_16_color_FFFFFF_t_70 1]: /images/20220829/18fcfbb4152142fbaf9511cd37bf4f7f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTAwNTE2_size_16_color_FFFFFF_t_70 2]: /images/20220829/ebff019ab9f74de39ae95f3f680da23f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTAwNTE2_size_16_color_FFFFFF_t_70 3]: /images/20220829/de5af6479f07446e835ad10de27e5a2b.png