# 第六章.实验四:文件系统
### 目录
- [6.1 实验4的基础知识 ](#fundamental )
- [6.1.1 文件系统概述 ](#filesystem )
- [6.1.2 PKE的文件系统架构 ](#pke_fs )
- [6.1.3 文件系统提供的接口 ](#fs_interface )
- [6.1.4 虚拟文件系统 ](#vfs )
- [6.1.5 RFS文件系统 ](#rfs )
- [6.2 lab4_1 文件操作 ](#lab4_1_file )
- [给定应用 ](#lab4_1_app )
- [实验内容 ](#lab4_1_content )
- [实验指导 ](#lab4_1_guide )
- [6.3 lab4_2 目录文件 ](#lab4_2_dir )
- [给定应用 ](#lab4_2_app )
- [实验内容 ](#lab4_2_content )
- [实验指导 ](#lab4_2_guide )
- [6.4 lab4_3 硬链接 ](#lab4_3_hardlink )
- [给定应用 ](#lab4_3_app )
- [实验内容 ](#lab4_3_content )
- [实验指导 ](#lab4_3_guide )
- [6.5 lab4_challenge1 相对路径（难度：★★★☆☆） ](#lab4_challenge1_pwd )
- [给定应用 ](#lab4_challenge1_app )
- [实验内容 ](#lab4_challenge1_content )
- [实验指导 ](#lab4_challenge1_guide )
- [6.6 lab4_challenge2 重载执行（难度：★★★★☆） ](#lab4_challenge2_exec )
- [给定应用 ](#lab4_challenge2_app )
- [实验内容 ](#lab4_challenge2_content )
- [实验指导 ](#lab4_challenge2_guide )
< a name = "fundamental" > < / a >
## 6.1 实验4的基础知识
本章我们将首先以Linux的文件系统为例介绍文件系统的基础知识， ， ，
< a name = "filesystem" > < / a >
### 6.1.1 文件系统概述
文件系统是操作系统用于存储、组织和访问计算机数据的方法， ， （ ， ） （ ） ， ， ， ， ，
不同的文件系统往往采用不同种类的元数据来完成既定功能。对不同类型元数据的采用， ， ， ， ， ， ， （ ） ， ， ， （ ） ， ， （ ）
由于有多个文件系统的存在， ， ， （ ， ， ） ， ， ， ，
< a name = "pke_fs" > < / a >
### 6.1.2 PKE的文件系统架构
PKE文件系统架构如下图所示， ， ， ， ， ， ，
< img src = "pictures/lab4.pke_fs_architecture.png" alt = "1660396457538" style = "zoom: 70%;" / >
在PKE系统启动时， ， ：
```c
53 int s_start(void) {
54 sprint("Enter supervisor mode...\n");
55 // in the beginning, we use Bare mode (direct) memory mapping as in lab1.
56 // but now, we are going to switch to the paging mode @lab2_1 .
57 // note, the code still works in Bare mode when calling pmm_init() and kern_vm_init().
58 write_csr(satp, 0);
59
60 // init phisical memory manager
61 pmm_init();
62
63 // build the kernel page table
64 kern_vm_init();
65
66 // now, switch to paging mode by turning on paging (SV39)
67 enable_paging();
68 // the code now formally works in paging mode, meaning the page table is now in use.
69 sprint("kernel page table is on \n");
70
71 // added @lab3_1
72 init_proc_pool();
73
74 // init file system, added @lab4_1
75 fs_init();
76
77 sprint("Switch to user mode...\n");
78 // the application code (elf) is first loaded into memory, and then put into execution
79 // added @lab3_1
80 insert_to_ready_queue( load_user_program() );
81 schedule();
82
83 // we should never reach here.
84 return 0;
85 }
```
我们看到， ， ：
```c
21 void fs_init(void) {
22 // initialize the vfs
23 vfs_init();
24
25 // register hostfs and mount it as the root
26 if( register_hostfs() < 0 ) panic ( " fs_init: cannot register hostfs . \n" );
27 struct device *hostdev = init_host_device("HOSTDEV");
28 vfs_mount("HOSTDEV", MOUNT_AS_ROOT);
29
30 // register and mount rfs
31 if( register_rfs() < 0 ) panic ( " fs_init: cannot register rfs . \n" );
32 struct device *ramdisk0 = init_rfs_device("RAMDISK0");
33 rfs_format_dev(ramdisk0);
34 vfs_mount("RAMDISK0", MOUNT_DEFAULT);
35 }
```
我们看到， （ ） ， （ ） ， （ ） ， （ ） ，
< img src = "pictures/lab4.pke_fs_mountpoint.png" alt = "1660396457538" style = "zoom: 100%;" / >
从上图中我们看到， ， ， ， ， ， ， ， ：
```c
1 #ifndef _HOSTFS_H_
2 #define _HOSTFS_H_
3 #include "vfs.h"
4
5 #define HOSTFS_TYPE 1
6
7 // dinode type
8 #define H_FILE FILE_I
9 #define H_DIR DIR_I
10
11 // root directory
12 #define H_ROOT_DIR "./hostfs_root"
13
14 // hostfs utility functin declarations
15 int register_hostfs();
16 struct device *init_host_device(char *name);
17 void get_path_string(char *path, struct dentry *dentry);
18 struct vinode *hostfs_alloc_vinode(struct super_block *sb);
19 int hostfs_write_back_vinode(struct vinode *vinode);
20 int hostfs_update_vinode(struct vinode *vinode);
21
22 // hostfs interface function declarations
23 ssize_t hostfs_read(struct vinode *f_inode, char *r_buf, ssize_t len,
24 int *offset);
25 ssize_t hostfs_write(struct vinode *f_inode, const char *w_buf, ssize_t len,
26 int *offset);
27 struct vinode *hostfs_lookup(struct vinode *parent, struct dentry *sub_dentry);
28 struct vinode *hostfs_create(struct vinode *parent, struct dentry *sub_dentry);
29 int hostfs_lseek(struct vinode *f_inode, ssize_t new_offset, int whence,
30 int *offset);
31 int hostfs_hook_open(struct vinode *f_inode, struct dentry *f_dentry);
32 int hostfs_hook_close(struct vinode *f_inode, struct dentry *dentry);
33 struct super_block *hostfs_get_superblock(struct device *dev);
34
35 extern const struct vinode_ops hostfs_node_ops;
36
37 #endif
```
注意kernel/hostfs.h文件中第12行的定义， ， ， ， ， ， ， ，
在应用对于文件或者子目录进行访问时，会通过被访问的文件或子目录的**路径**进行判断，来决定被访问的文件的具体放置位置。例如:
- 如果访问的路径是/dir1/file1， ， ： ；
- 如果访问的路径是/RAMDISK0/dir2/file2， ，
< a name = "fs_interface" > < / a >
### 6.1.3 文件系统提供的接口
在PKE文件系统架构下， ：
< img src = "pictures/lab4.pke_fs_callgraph.png" alt = "1660396457538" style = "zoom: 80%;" / >
从用户程序发出的文件读写操作（ ） ， ， （ ） ， （ ， ） ， ， （ ） ，
在lab4中， ， ：
```C
21 // data structure that manages all openned files in a PCB
22 typedef struct proc_file_management_t {
23 struct dentry *cwd; // vfs dentry of current working directory
24 struct file opened_files[MAX_FILES]; // opened files array
25 int nfiles; // the number of opened files a process has
26 } proc_file_management;
```
我们看到， ， ， ：
```c
51 typedef struct process_t {
52 // pointing to the stack used in trap handling.
53 uint64 kstack;
54 // user page table
55 pagetable_t pagetable;
56 // trapframe storing the context of a (User mode) process.
57 trapframe* trapframe;
58
59 // points to a page that contains mapped_regions. below are added @lab3_1
60 mapped_region *mapped_info;
61 // next free mapped region in mapped_info
62 int total_mapped_region;
63
64 // process id
65 uint64 pid;
66 // process status
67 int status;
68 // parent process
69 struct process_t *parent;
70 // next queue element
71 struct process_t *queue_next;
72
73 // accounting. added @lab3_3
74 int tick_count;
75
76 // file system. added @lab4_1
77 proc_file_management *pfiles;
78 }process;
```
我们看到在进程定义的77行， ， ，
```c
41 proc_file_management *init_proc_file_management(void) {
42 proc_file_management *pfiles = (proc_file_management * )alloc_page();
43 pfiles->cwd = vfs_root_dentry; // by default, cwd is the root
44 pfiles->nfiles = 0;
45
46 for (int fd = 0; fd < MAX_FILES ; + + fd ) {
47 pfiles->opened_files[fd].status = FD_NONE;
48 ++pfiles->nfiles;
49 }
50 sprint("FS: created a file management struct for a process.\n");
51 return pfiles;
52 }
```
该函数的作用是为将要管理的“打开文件”分配一个物理页面的空间， （ ） ， （ ） ； （ ） ， （ ） （ ） （ ） （ ） （ ） （ ） ， （ ） ， （ ） ， ， ，
这里， ， （ ） ：
```c
083 int do_open(char *pathname, int flags) {
084 struct file *opened_file = NULL;
085 if ((opened_file = vfs_open(pathname, flags)) == NULL) return -1;
086
087 int fd = 0;
088 struct file *pfile;
089 for (fd = 0; fd < MAX_FILES ; + + fd ) {
090 pfile = &(current->pfiles->opened_files[fd]);
091 if (pfile->status == FD_NONE) break;
092 }
093 if (pfile->status != FD_NONE) // no free entry
094 panic("do_open: no file entry for current process!\n");
095
096 // initialize this file structure
097 memcpy(pfile, opened_file, sizeof(struct file));
098
099 ++current->pfiles->nfiles;
100 return fd;
101 }
```
我们看到， ， （ ） ， ， （ ） （ ） （ ） ：
```c
107 int do_read(int fd, char *buf, uint64 count) {
108 struct file *pfile = get_opened_file(fd);
109
110 if (pfile->readable == 0) panic("do_read: no readable file!\n");
111
112 char buffer[count + 1];
113 int len = vfs_read(pfile, buffer, count);
114 buffer[count] = '\0';
115 strcpy(buf, buffer);
116 return len;
117 }
```
我们看到， ， ， ，
实际上， ， ， （ ） ，
< a name = "vfs" > < / a >
### 6.1.4 虚拟文件系统
虚拟文件系统（ ） ， ， ， ， ，
#### 6.1.4.1 VFS的功能接口
在PKE中， （ ） ， ：
```c
21 // device interfaces
22 struct super_block *vfs_mount(const char *dev_name, int mnt_type);
23
24 // file interfaces
25 struct file *vfs_open(const char *path, int flags);
26 ssize_t vfs_read(struct file *file, char *buf, size_t count);
27 ssize_t vfs_write(struct file *file, const char *buf, size_t count);
28 ssize_t vfs_lseek(struct file *file, ssize_t offset, int whence);
29 int vfs_stat(struct file *file, struct istat *istat);
30 int vfs_disk_stat(struct file *file, struct istat *istat);
31 int vfs_link(const char *oldpath, const char *newpath);
32 int vfs_unlink(const char *path);
33 int vfs_close(struct file *file);
34
35 // directory interfaces
36 struct file *vfs_opendir(const char *path);
37 int vfs_readdir(struct file *file, struct dir *dir);
38 int vfs_mkdir(const char *path);
39 int vfs_closedir(struct file *file);
```
上述接口函数可以用来完成文件系统挂载、读写文件和目录、创建文件硬链接等功能。系统内的其他模块通过调用这些接口函数来完成对文件系统的访问。在上一节中提到的面向进程的一组接口（ ） ， ， （ ） ，
#### 6.1.4.2 VFS的重要数据结构
VFS对具体的文件系统进行了抽象， ，
* *vinode*
VFS对具体文件系统中的inode进行了抽象， （ ） ， ， ， ， ； ， （ ） ， ， （ ） ， ： ， ， （ ） （ ） ：
```c
115 struct vinode {
116 int inum; // inode number of the disk inode
117 int ref; // reference count
118 int size; // size of the file (in bytes)
119 int type; // one of FILE_I, DIR_I
120 int nlinks; // number of hard links to this file
121 int blocks; // number of blocks
122 int addrs[DIRECT_BLKNUM]; // direct blocks
123 void *i_fs_info; // filesystem-specific info (see s_fs_info)
124 struct super_block *sb; // super block of the vfs inode
125 const struct vinode_ops *i_ops; // vfs inode operations
126 };
```
其中需要重点关注的成员是：
**inum** ： ， （ ） ， （ ） ， ， ， （ ， ） ， （ ） ：
```c
09 typedef struct file_t {
10 int kfd; // file descriptor of the host file
11 uint32 refcnt;
12 } spike_file_t;
```
该结构体保存了宿主机中一个打开文件的文件描述符，
**sb** ： ， ，
**i_ops** ： ， ， ，
对于RFS而言， （ ） ， ， ，
* *dentry*
dentry即directory entry， ， ， ， ：
```c
38 struct dentry {
39 char name[MAX_DENTRY_NAME_LEN];
40 int d_ref;
41 struct vinode *dentry_inode;
42 struct dentry *parent;
43 struct super_block *sb;
45 };
```
与vinode类似， ， （ ） ， ， ， ，
为了支撑dentry的功能， ， ， ， ， （ ） ，
* *super_block*
super_block结构用来保存一个已挂载文件系统的相关信息。在一个文件系统被挂载到系统中时， ， （ ） ， ， ， ， ， ：
```c
104 struct super_block {
105 int magic; // magic number of the file system
106 int size; // size of file system image (blocks)
107 int nblocks; // number of data blocks
108 int ninodes; // number of inodes.
109 struct dentry *s_root; // root dentry of inode
110 struct device *s_dev; // device of the superblock
111 void *s_fs_info; // filesystem-specific info. for rfs, it points bitmap
112 };
```
其中最重要的数据项是s_root与s_dev。s_root指向该文件系统根目录所对应的dentry，
- *file*
在用户进程的眼里， ， ：
```c
71 struct file {
72 int status;
73 int readable;
74 int writable;
75 int offset;
76 struct dentry *f_dentry;
77 };
```
显然，
#### 6.1.4.3 viop函数的定义和使用
viop函数是VFS与具体文件系统进行交互的重要部分， ， （ ， ， ） ：
```c
136 struct vinode_ops {
137 // file operations
138 ssize_t (*viop_read)(struct vinode *node, char *buf, ssize_t len,
139 int *offset);
140 ssize_t (*viop_write)(struct vinode *node, const char *buf, ssize_t len,
141 int *offset);
142 struct vinode *(*viop_create)(struct vinode *parent, struct dentry *sub_dentry);
143 int (*viop_lseek)(struct vinode *node, ssize_t new_off, int whence, int *off);
144 int (*viop_disk_stat)(struct vinode *node, struct istat *istat);
145 int (*viop_link)(struct vinode *parent, struct dentry *sub_dentry,
146 struct vinode *link_node);
147 int (*viop_unlink)(struct vinode *parent, struct dentry *sub_dentry,
148 struct vinode *unlink_node);
149 struct vinode *(*viop_lookup)(struct vinode *parent,
150 struct dentry *sub_dentry);
151
152 // directory operations
153 int (*viop_readdir)(struct vinode *dir_vinode, struct dir *dir, int *offset);
154 struct vinode *(*viop_mkdir)(struct vinode *parent, struct dentry *sub_dentry);
155
156 // write back inode to disk
157 int (*viop_write_back_vinode)(struct vinode *node);
158
159 // hook functions
160 // In the vfs layer, we do not assume that hook functions will do anything,
161 // but simply call them (when they are defined) at the appropriate time.
162 // Hook functions exist because the fs layer may need to do some additional
163 // operations (such as allocating additional data structures) at some critical
164 // times.
165 int (*viop_hook_open)(struct vinode *node, struct dentry *dentry);
166 int (*viop_hook_close)(struct vinode *node, struct dentry *dentry);
167 int (*viop_hook_opendir)(struct vinode *node, struct dentry *dentry);
168 int (*viop_hook_closedir)(struct vinode *node, struct dentry *dentry);
169 };
```
上述函数接口实际上是一系列的函数指针， ， ， ， ， ， （ ） （ ） ：
```c
22 const struct vinode_ops rfs_i_ops = {
23 .viop_read = rfs_read,
24 .viop_write = rfs_write,
25 .viop_create = rfs_create,
26 .viop_lseek = rfs_lseek,
27 .viop_disk_stat = rfs_disk_stat,
28 .viop_link = rfs_link,
29 .viop_unlink = rfs_unlink,
30 .viop_lookup = rfs_lookup,
31
32 .viop_readdir = rfs_readdir,
33 .viop_mkdir = rfs_mkdir,
34
35 .viop_write_back_vinode = rfs_write_back_vinode,
36
37 .viop_hook_opendir = rfs_hook_opendir,
38 .viop_hook_closedir = rfs_hook_closedir,
39 };
```
从该结构中我们可以清晰的看出inode操作函数接口（ ） （ ） ， ， ，
继续回到vinode_ops， ， ： （ ） （ ） （ ） （ ） ， （ ） ， ： ，
而对于VFS层为vinode提供的钩子函数接口， ： ， ， ， ， ， ， （ ） ：
```c
111 struct file *vfs_open(const char *path, int flags) {
112 struct dentry *parent = vfs_root_dentry; // we start the path lookup from root.
113 char miss_name[MAX_PATH_LEN];
114
115 // path lookup.
116 struct dentry *file_dentry = lookup_final_dentry(path, & parent, miss_name);
117
118 // file does not exist
119 if (!file_dentry) {
120 int creatable = flags & O_CREAT;
121
122 // create the file if O_CREAT bit is set
123 if (creatable) {
124 char basename[MAX_PATH_LEN];
125 get_base_name(path, basename);
126
127 // a missing directory exists in the path
128 if (strcmp(miss_name, basename) != 0) {
129 sprint("vfs_open: cannot create file in a non-exist directory!\n");
130 return NULL;
131 }
132
133 // create the file
134 file_dentry = alloc_vfs_dentry(basename, NULL, parent);
135 struct vinode *new_inode = viop_create(parent->dentry_inode, file_dentry);
136 if (!new_inode) panic("vfs_open: cannot create file!\n");
137
138 file_dentry->dentry_inode = new_inode;
139 new_inode->ref++;
140 hash_put_dentry(file_dentry);
141 hash_put_vinode(new_inode);
142 } else {
143 sprint("vfs_open: cannot find the file!\n");
144 return NULL;
145 }
146 }
147
148 if (file_dentry->dentry_inode->type != FILE_I) {
149 sprint("vfs_open: cannot open a directory!\n");
150 return NULL;
151 }
152
153 // get writable and readable flags
154 int writable = 0;
155 int readable = 0;
156 switch (flags & MASK_FILEMODE) {
157 case O_RDONLY:
158 writable = 0;
159 readable = 1;
160 break;
161 case O_WRONLY:
162 writable = 1;
163 readable = 0;
164 break;
165 case O_RDWR:
166 writable = 1;
167 readable = 1;
168 break;
169 default:
170 panic("fs_open: invalid open flags!\n");
171 }
172
173 struct file *file = alloc_vfs_file(file_dentry, readable, writable, 0);
174
175 // additional open operations for a specific file system
176 // hostfs needs to conduct actual file open.
177 if (file_dentry->dentry_inode->i_ops->viop_hook_open) {
178 if (file_dentry->dentry_inode->i_ops->
179 viop_hook_open(file_dentry->dentry_inode, file_dentry) < 0 ) {
180 sprint("vfs_open: hook_open failed!\n");
181 }
182 }
183
184 return file;
185 }
```
vfs_open函数即为前文中提到的VFS层对上层应用提供的接口之一， ： （ ， ： ， ， ） ， ， ， （ ） ， ， ， （ ） ， ， （ ）
接下来我们再来看vfs_open的177--182行， （ ） ： ， （ ） ， ， ， （ ） ， ， ， （ ） ， ？ ， ， ， ， ， ， ， ， ， ，
为了验证这一点， （ ） ：
```c
14 const struct vinode_ops hostfs_i_ops = {
15 .viop_read = hostfs_read,
16 .viop_write = hostfs_write,
17 .viop_create = hostfs_create,
18 .viop_lseek = hostfs_lseek,
19 .viop_lookup = hostfs_lookup,
20
21 .viop_hook_open = hostfs_hook_open,
22 .viop_hook_close = hostfs_hook_close,
23
24 .viop_write_back_vinode = hostfs_write_back_vinode,
25
26 // not implemented
27 .viop_link = hostfs_link,
28 .viop_unlink = hostfs_unlink,
29 .viop_readdir = hostfs_readdir,
30 .viop_mkdir = hostfs_mkdir,
31 };
```
在第21行可以看到， ： ， ：
```c
236 int hostfs_hook_open(struct vinode *f_inode, struct dentry *f_dentry) {
237 if (f_inode->i_fs_info != NULL) return 0;
238
239 char path[MAX_PATH_LEN];
240 get_path_string(path, f_dentry);
241 spike_file_t *f = spike_file_open(path, O_RDWR, 0);
242 if ((int64)f < 0 ) {
243 sprint("hostfs_hook_open cannot open the given file.\n");
244 return -1;
245 }
246
247 f_inode->i_fs_info = f;
248 return 0;
249 }
```
由此可见， ， ， ： ， （ ） （ ） （ ） （ ）
hostfs实现了前两种钩子函数， ：
* hostfs_hook_open（ ） ： ，
* hostfs_hook_close（ ） ：
RFS实现了后两种钩子函数， （ ） ：
* rfs_hook_opendir（ ） ： （ ） ，
* rfs_hook_closedir（ ） ：
#### 6.1.4.4 VFS层的目录组织
类似于底层文件系统中保存在磁盘上的目录结构， ， ：
< img src = "pictures/lab4.vfs_directory.png" alt = "1660396457538" style = "zoom: 40%;" / >
这里， ， ：
```c
049 struct super_block *vfs_mount(const char *dev_name, int mnt_type) {
050 // device pointer
051 struct device *p_device = NULL;
052
053 // find the device entry in vfs_device_list named as dev_name
054 for (int i = 0; i < MAX_VFS_DEV ; + + i ) {
055 p_device = vfs_dev_list[i];
056 if (p_device & & strcmp(p_device->dev_name, dev_name) == 0) break;
057 }
058 if (p_device == NULL) panic("vfs_mount: cannot find the device entry!\n");
059
060 // add the super block into vfs_sb_list
061 struct file_system_type *fs_type = p_device->fs_type;
062 struct super_block *sb = fs_type->get_superblock(p_device);
063
064 // add the root vinode into vinode_hash_table
065 hash_put_vinode(sb->s_root->dentry_inode);
066
067 int err = 1;
068 for (int i = 0; i < MAX_MOUNTS ; + + i ) {
069 if (vfs_sb_list[i] == NULL) {
070 vfs_sb_list[i] = sb;
071 err = 0;
072 break;
073 }
074 }
075 if (err) panic("vfs_mount: too many mounts!\n");
076
077 // mount the root dentry of the file system to right place
078 if (mnt_type == MOUNT_AS_ROOT) {
079 vfs_root_dentry = sb->s_root;
080
081 // insert the mount point into hash table
082 hash_put_dentry(sb->s_root);
083 } else if (mnt_type == MOUNT_DEFAULT) {
084 if (!vfs_root_dentry)
085 panic("vfs_mount: root dentry not found, please mount the root device first!\n");
086
087 struct dentry *mnt_point = sb->s_root;
088
089 // set the mount point directory's name to device name
090 char *dev_name = p_device->dev_name;
091 strcpy(mnt_point->name, dev_name);
092
093 // by default, it is mounted under the vfs root directory
094 mnt_point->parent = vfs_root_dentry;
095
096 // insert the mount point into hash table
097 hash_put_dentry(sb->s_root);
098 } else {
099 panic("vfs_mount: unknown mount type!\n");
100 }
101
102 return sb;
103 }
```
为了简化文件系统挂载过程， ， ： ； ， ； ， ， ， ， ， （ ， ） ： ， ， ， ，
在上述VFS层文件系统挂载过程中， ： ， ， ， ， ， ？ ：
```c
304 struct dentry *lookup_final_dentry(const char *path, struct dentry * *parent,
305 char *miss_name) {
306 char path_copy[MAX_PATH_LEN];
307 strcpy(path_copy, path);
308
309 // split the path, and retrieves a token at a time.
310 // note: strtok() uses a static (local) variable to store the input path
311 // string at the first time it is called. thus it can out a token each time.
312 // for example, when input path is: /RAMDISK0/test_dir/ramfile2
313 // strtok() outputs three tokens: 1)RAMDISK0, 2)test_dir and 3)ramfile2
314 // at its three continuous invocations.
315 char *token = strtok(path_copy, "/");
316 struct dentry *this = *parent;
317
318 while (token != NULL) {
319 *parent = this;
320 this = hash_get_dentry((*parent), token); // try hash first
321 if (this == NULL) {
322 // if not found in hash, try to find it in the directory
323 this = alloc_vfs_dentry(token, NULL, *parent);
324 // lookup subfolder/file in its parent directory. note:
325 // hostfs and rfs will take different procedures for lookup.
326 struct vinode *found_vinode = viop_lookup((*parent)->dentry_inode, this);
327 if (found_vinode == NULL) {
328 // not found in both hash table and directory file on disk.
329 free_page(this);
330 strcpy(miss_name, token);
331 return NULL;
332 }
333
334 struct vinode *same_inode = hash_get_vinode(found_vinode->sb, found_vinode->inum);
335 if (same_inode != NULL) {
336 // the vinode is already in the hash table (i.e. we are opening another hard link)
337 this->dentry_inode = same_inode;
338 same_inode->ref++;
339 free_page(found_vinode);
340 } else {
341 // the vinode is not in the hash table
342 this->dentry_inode = found_vinode;
343 found_vinode->ref++;
344 hash_put_vinode(found_vinode);
345 }
346
347 hash_put_dentry(this);
348 }
349
350 // get next token
351 token = strtok(NULL, "/");
352 }
353 return this;
354 }
```
该函数用来对一个路径字符串进行目录查询， ， ， ， ， ， ， （ ） ， （ ： ） ， ， ， ； ， ， ， ， ， ：
```c
429 struct vinode *rfs_lookup(struct vinode *parent, struct dentry *sub_dentry) {
430 struct rfs_direntry *p_direntry = NULL;
431 struct vinode *child_vinode = NULL;
432
433 int total_direntrys = parent->size / sizeof(struct rfs_direntry);
434 int one_block_direntrys = RFS_BLKSIZE / sizeof(struct rfs_direntry);
435
436 struct rfs_device *rdev = rfs_device_list[parent->sb->s_dev->dev_id];
437
438 // browse the dir entries contained in a directory file
439 for (int i = 0; i < total_direntrys ; + + i ) {
440 if (i % one_block_direntrys == 0) { // read in the disk block at boundary
441 rfs_r1block(rdev, parent->addrs[i / one_block_direntrys]);
442 p_direntry = (struct rfs_direntry *)rdev->iobuffer;
443 }
444 if (strcmp(p_direntry->name, sub_dentry->name) == 0) { // found
445 child_vinode = rfs_alloc_vinode(parent->sb);
446 child_vinode->inum = p_direntry->inum;
447 if (rfs_update_vinode(child_vinode) != 0)
448 panic("rfs_lookup: read inode failed!");
449 break;
450 }
451 ++p_direntry;
452 }
453 return child_vinode;
454 }
```
重点关注第439--452行， （ ） ， （ ） ， （ ） ，
再回到lookup_final_dentry函数， ， ， ， ， （ ） ； ， ， （ ） ， ， ，
需要说明的是， ， ， ， ， ， ， ， ， ，
#### 6.1.4.5 VFS层的哈希缓存
VFS通过哈希链表的形式实现了对dentry与vinode两种结构的缓存（ ） ， （ ） ， ：
```c
16 struct hash_table dentry_hash_table;
17 struct hash_table vinode_hash_table;
```
首先讨论dentry的哈希缓存。dentry哈希缓存的主要作用是加快VFS中的路径查找过程。下面是其key类型定义（ ） ：
```c
64 struct dentry_key {
65 struct dentry *parent;
66 char *name;
67 };
```
从中可以看出， ， ， ， ， （ ） ：
```c
633 size_t dentry_hash_func(void *key) {
634 struct dentry_key *dentry_key = key;
635 char *name = dentry_key->name;
636
637 size_t hash = 5381;
638 int c;
639
640 while ((c = *name++)) hash = ((hash << 5) + hash) + c; // hash * 33 + c
641
642 hash = ((hash < < 5 ) + hash ) + ( size_t ) dentry_key- > parent;
643 return hash % HASH_TABLE_SIZE;
644 }
```
当查询dentry时发生哈希冲突时， ， （ ） ：
```c
623 int dentry_hash_equal(void *key1, void *key2) {
624 struct dentry_key *dentry_key1 = key1;
625 struct dentry_key *dentry_key2 = key2;
626 if (strcmp(dentry_key1->name, dentry_key2->name) == 0 & &
627 dentry_key1->parent == dentry_key2->parent) {
628 return 1;
629 }
630 return 0;
631 }
```
上述代码表明， ， （ ， ） ，
对于vinode哈希缓存， ：
1. 从文件路径字符串找到文件对应的dentry。在这个过程中dentry哈希缓存起到了加速作用。
2. 从文件dentry找到文件的vinode。由于每个dentry中都记录了对应vinode， ，
3. 通过vinode访问文件。
从这个过程中可以看出， ， ， ， ， ， ， ： （ ） ， ， （ ） ， ：
1. 判断新创建的vinode是否已经在VFS中存在了。
2. 对于1， ，
在VFS中， （ ） ， ， ， ， ； ， ， （ ）
下面同样给出vinode哈希表对应的key类型（ ） ：
```c
191 struct vinode_key {
192 int inum;
193 struct super_block *sb;
194 };
```
vinode的key值由disk inode号与文件系统对应的超级块构成。disk inode号在一个文件系统中具有唯一性， ， ， ， ， （ ， ， ）
< a name = "rfs" > < / a >
### 6.1.5 RFS文件系统
在本实验中， ， ， ， ， ，
#### 6.1.5.1 RFS的磁盘结构和格式化过程
下图给出了 PKE的RFS 整个文件系统的结构和块组的内容， ， ， ：
```c
/*
* RFS (Ramdisk File System) is a customized simple file system installed in the
* RAM disk. added @lab4_1 .
* Layout of the file system:
*
* ******** RFS MEM LAYOUT (112 BLOCKS) ** **************
* superblock | disk inodes | bitmap | free blocks *
* 1 block | 10 blocks | 1 | 100 *
* *****************************************************
*
* The disk layout of rfs is similar to the fs in xv6.
*/
```
RFS采用了类Linux文件系统（ ） ， ：
- *superblock*， ，
```c
29 struct rfs_superblock {
30 int magic; // magic number of the
31 int size; // size of file system image (blocks)
32 int nblocks; // number of data blocks
33 int ninodes; // number of inodes.
34 };
```
- *disk inodes*， ， ， ， ， （ ） ：
```c
37 struct rfs_dinode {
38 int size; // size of the file (in bytes)
39 int type; // one of R_FREE, R_FILE, R_DIR
40 int nlinks; // number of hard links to this file
41 int blocks; // number of blocks
42 int addrs[RFS_DIRECT_BLKNUM]; // direct blocks
43 };
```
- *bitmap*， ：
```c
int * freemap;
```
freemap[blkno]=1代表第blkno个数据块被使用了，
< img src = "pictures/lab4.bitmap.png" alt = "1660396457538" style = "zoom: 80%;" / >
- *free blocks*，磁盘上实际可以存储用户数据的区域。
PKE系统启动时， ， ， ：
```c
054 int rfs_format_dev(struct device *dev) {
055 struct rfs_device *rdev = rfs_device_list[dev->dev_id];
056
057 // ** first, format the superblock
058 // build a new superblock
059 struct super_block *super = (struct super_block * )rdev->iobuffer;
060 super->magic = RFS_MAGIC;
061 super->size =
062 1 + RFS_MAX_INODE_BLKNUM + 1 + RFS_MAX_INODE_BLKNUM * RFS_DIRECT_BLKNUM;
063 // only direct index blocks
064 super->nblocks = RFS_MAX_INODE_BLKNUM * RFS_DIRECT_BLKNUM;
065 super->ninodes = RFS_BLKSIZE / RFS_INODESIZE * RFS_MAX_INODE_BLKNUM;
066
067 // write the superblock to RAM Disk0
068 if (rfs_w1block(rdev, RFS_BLK_OFFSET_SUPER) != 0) // write to device
069 panic("RFS: failed to write superblock!\n");
070
071 // ** second, set up the inodes and write them to RAM disk
072 // build an empty inode disk block which has RFS_BLKSIZE/RFS_INODESIZE(=32)
073 // disk inodes
074 struct rfs_dinode *p_dinode = (struct rfs_dinode * )rdev->iobuffer;
075 for (int i = 0; i < RFS_BLKSIZE / RFS_INODESIZE ; + + i ) {
076 p_dinode->size = 0;
077 p_dinode->type = R_FREE;
078 p_dinode->nlinks = 0;
079 p_dinode->blocks = 0;
080 p_dinode = (struct rfs_dinode *)((char * )p_dinode + RFS_INODESIZE);
081 }
082
083 // write RFS_MAX_INODE_BLKNUM(=10) empty inode disk blocks to RAM Disk0
084 for (int inode_block = 0; inode_block < RFS_MAX_INODE_BLKNUM ; + + inode_block ) {
085 if (rfs_w1block(rdev, RFS_BLK_OFFSET_INODE + inode_block) != 0)
086 panic("RFS: failed to initialize empty inodes!\n");
087 }
088
089 // build root directory inode (ino = 0)
090 struct rfs_dinode root_dinode;
091 root_dinode.size = 0;
092 root_dinode.type = R_DIR;
093 root_dinode.nlinks = 1;
094 root_dinode.blocks = 1;
095 root_dinode.addrs[0] = RFS_BLK_OFFSET_FREE;
096
097 // write root directory inode to RAM Disk0 (ino = 0)
098 if (rfs_write_dinode(rdev, & root_dinode, 0) != 0) {
099 sprint("RFS: failed to write root inode!\n");
100 return -1;
101 }
102
103 // ** third, write freemap to disk
104 int *freemap = (int * )rdev->iobuffer;
105 memset(freemap, 0, RFS_BLKSIZE);
106 freemap[0] = 1; // the first data block is used for root directory
107
108 // write the bitmap to RAM Disk0
109 if (rfs_w1block(rdev, RFS_BLK_OFFSET_BITMAP) != 0) { // write to device
110 sprint("RFS: failed to write bitmap!\n");
111 return -1;
112 }
113
114 sprint("RFS: format %s done!\n", dev->dev_name);
115 return 0;
116 }
```
rfs_format_dev函数在第57--69行构建了RFS的超级块， （ ） ； ， ； ， （ ） ， （ ） ，
#### 6.1.5.2 RFS的dinode和目录项
文件系统除了要保存文件的内容， ， ， ， ， ， （ ） ， ， ， （ ） ，
值得注意的是， ， ， ， ： ， ：
```c
46 struct rfs_direntry {
47 int inum; // inode number
48 char name[RFS_MAX_FILE_NAME_LEN]; // file name
49 };
```
**注意rfs_direntry结构与VFS中的dentry完全不同**， ， ， （ ） ， ：
< img src = "pictures/lab4.rfs_dir_file.png" alt = "1660396457538" style = "zoom: 80%;" / >
rfs_direntry实际上起到了将文件名与文件dinode关联起来的作用， ， ， ， （ ） ， ， ，
#### 6.1.5.3 硬链接
硬链接是指多个目录项中的文件名不同， ， ， ， ， ， ， ， ，
RFS给每个文件都分配了一个硬链接数nlinks， （ ） ：
```c
37 struct rfs_dinode {
38 int size; // size of the file (in bytes)
39 int type; // one of R_FREE, R_FILE, R_DIR
40 int nlinks; // number of hard links to this file
41 int blocks; // number of blocks
42 int addrs[RFS_DIRECT_BLKNUM]; // direct blocks
43 };
```
文件的硬链接数等于引用这个文件的目录项数。当一个文件刚刚被创建时， ， ， ， ， ， ， ， ：
< img src = "pictures/lab4.hardlink.png" alt = "1660396457538" style = "zoom: 50%;" / >
上图中， ， ， ， （ ） ， ， （ ） ： （ ） ； ， ： ， ， ， ， ， ， ，
另外， ，
< a name = "lab4_1_file" > < / a >
## 6.2 lab4_1 文件
< a name = "lab4_1_app" > < / a >
#### 给定应用
- user/app_file.c
```c
01 #include "user_lib.h"
02 #include "util/string.h"
03 #include "util/types.h"
04
05 int main(int argc, char *argv[]) {
06 int fd;
07 int MAXBUF = 512;
08 char buf[MAXBUF];
09 char str[] = "hello world";
10 int fd1, fd2;
11
12 printu("\n======== Test 1: read host file ========\n");
13 printu("read: /hostfile.txt\n");
14
15 fd = open("/hostfile.txt", O_RDONLY);
16 printu("file descriptor fd: %d\n", fd);
17
18 read_u(fd, buf, MAXBUF);
19 printu("read content: \n%s\n", buf);
20
21 close(fd);
22
23 printu("\n======== Test 2: create/write rfs file ========\n");
24 printu("write: /RAMDISK0/ramfile\n");
25
26 fd = open("/RAMDISK0/ramfile", O_RDWR | O_CREAT);
27 printu("file descriptor fd: %d\n", fd);
28
29 write_u(fd, buf, strlen(buf));
30 printu("write content: \n%s\n", buf);
31 close(fd);
32
33 printu("\n======== Test 3: read rfs file ========\n");
34 printu("read: /RAMDISK0/ramfile\n");
35
36 fd = open("/RAMDISK0/ramfile", O_RDWR);
37 printu("file descriptor fd: %d\n", fd);
38
39 read_u(fd, buf, MAXBUF);
40 printu("read content: \n%s\n", buf);
41 close(fd);
42
43 printu("\n======== Test 4: open twice ========\n");
44
45 fd1 = open("/RAMDISK0/ramfile", O_RDWR | O_CREAT);
46 fd2 = open("/RAMDISK0/ramfile", O_RDWR | O_CREAT);
47
48 printu("file descriptor fd1(ramfile): %d\n", fd1);
49 printu("file descriptor fd2(ramfile): %d\n", fd2);
50
51 write_u(fd1, str, strlen(str));
52 printu("write content: \n%s\n", str);
53
54 read_u(fd2, buf, MAXBUF);
55 printu("read content: \n%s\n", buf);
56
57 close(fd1);
58 close(fd2);
59
60 printu("\nAll tests passed!\n\n");
61 exit(0);
62 return 0;
63 }
```
在这个应用中，我们打开了一个宿主机文件`/hostfile.txt`和一个RAM Disk文件`/RAMDISK0/ramfile`，从宿主机读入`hostfile.txt`的内容，写入`ramfile`，再从`ramfile`中读出，检查对应功能是否正确实现。
- （ ， ） ， ， ：
```
//切换到lab4_1
$ git checkout lab4_1_file
//继承lab4_1以及之前的答案
$ git merge lab3_3_rrsched -m "continue to work on lab4_1"
//重新构造
$ make clean; make
//运行构造结果
$ spike ./obj/riscv-pke ./obj/app_file
In m_start, hartid:0
HTIF is available!
(Emulated) memory size: 2048 MB
Enter supervisor mode...
PKE kernel start 0x0000000080000000, PKE kernel end: 0x000000008000d000, PKE kernel size: 0x000000000000d000 .
free physical memory address: [0x000000008000d000, 0x0000000087ffffff]
kernel memory manager is initializing ...
KERN_BASE 0x0000000080000000
physical address of _etext is: 0x0000000080007000
kernel page table is on
RAMDISK0: base address of RAMDISK0 is: 0x0000000087f37000
RFS: format RAMDISK0 done!
Switch to user mode...
in alloc_proc. user frame 0x0000000087f2f000, user stack 0x000000007ffff000, user kstack 0x0000000087f2e000
FS: created a file management struct for a process.
in alloc_proc. build proc_file_management successfully.
User application is loading.
Application: obj/app_file
CODE_SEGMENT added at mapped info offset:3
DATA_SEGMENT added at mapped info offset:4
Application program entry point (virtual address): 0x00000000000100b0
going to insert process 0 to ready queue.
going to schedule process 0 to run.
======== Test 1: read host file ========
read: /hostfile.txt
file descriptor fd: 0
read content:
This is an apple.
Apples are good for our health.
======== Test 2: create/write rfs file ========
write: /RAMDISK0/ramfile
You need to implement the code of populating a disk inode in lab4_1.
System is shutting down with exit code -1.
```
从以上运行结果来看， ， ， ，
在完成实验的过程中， ，
< a name = "lab4_1_content" > < / a >
#### 实验内容
在PKE操作系统内核中完善对文件的操作，
实验完成后的运行结果：
```
$ spike ./obj/riscv-pke ./obj/app_file
In m_start, hartid:0
HTIF is available!
(Emulated) memory size: 2048 MB
Enter supervisor mode...
PKE kernel start 0x0000000080000000, PKE kernel end: 0x000000008000e000, PKE kernel size: 0x000000000000e000 .
free physical memory address: [0x000000008000e000, 0x0000000087ffffff]
kernel memory manager is initializing ...
KERN_BASE 0x0000000080000000
physical address of _etext is: 0x0000000080008000
kernel page table is on
RAMDISK0: base address of RAMDISK0 is: 0x0000000087f37000
RFS: format RAMDISK0 done!
Switch to user mode...
in alloc_proc. user frame 0x0000000087f2f000, user stack 0x000000007ffff000, user kstack 0x0000000087f2e000
FS: created a file management struct for a process.
in alloc_proc. build proc_file_management successfully.
User application is loading.
Application: obj/app_file
CODE_SEGMENT added at mapped info offset:3
DATA_SEGMENT added at mapped info offset:4
Application program entry point (virtual address): 0x00000000000100b0
going to insert process 0 to ready queue.
going to schedule process 0 to run.
======== Test 1: read host file ========
read: /hostfile.txt
file descriptor fd: 0
read content:
This is an apple.
Apples are good for our health.
======== Test 2: create/write rfs file ========
write: /RAMDISK0/ramfile
file descriptor fd: 0
write content:
This is an apple.
Apples are good for our health.
======== Test 3: read rfs file ========
read: /RAMDISK0/ramfile
file descriptor fd: 0
read content:
This is an apple.
Apples are good for our health.
======== Test 4: open twice ========
file descriptor fd1(ramfile): 0
file descriptor fd2(ramfile): 1
write content:
hello world
read content:
hello world
All tests passed!
User exit with code:0.
no more ready processes, system shutdown now.
System is shutting down with exit code 0.
```
< a name = "lab4_1_guide" > < / a >
#### 实验指导
从程序的输出可以看出， ， ， ， ， ， ：
```c
88 ssize_t sys_user_open(char *pathva, int flags) {
89 char* pathpa = (char*)user_va_to_pa((pagetable_t)(current->pagetable), pathva);
90 return do_open(pathpa, flags);
91 }
```
该函数在对文件路径字符串地址进行虚地址到物理地址的转换后， ：
```c
76 //
77 // open a file named as "pathname" with the permission of "flags".
78 // return: -1 on failure; non-zero file-descriptor on success.
79 //
80 int do_open(char *pathname, int flags) {
81 struct file *opened_file = NULL;
82 if ((opened_file = vfs_open(pathname, flags)) == NULL) return -1;
83
84 int fd = 0;
85 struct file *pfile;
86 for (fd = 0; fd < MAX_FILES ; + + fd ) {
87 pfile = &(current->pfiles->opened_files[fd]);
88 if (pfile->status == FD_NONE) break;
89 }
90 if (pfile->status != FD_NONE) // no free entry
91 panic("do_open: no file entry for current process!\n");
92
93 // initialize this file structure
94 memcpy(pfile, opened_file, sizeof(struct file));
95
96 ++current->pfiles->nfiles;
97 return fd;
98 }
```
第82行， ， ； ， ， ；
其中82行调用的vfs_open函数是打开文件的关键， ， ， ：
```c
456 //
457 // create a file with "sub_dentry->name" at directory "parent" in rfs.
458 // return the vfs inode of the file being created.
459 //
460 struct vinode *rfs_create(struct vinode *parent, struct dentry *sub_dentry) {
461 struct rfs_device *rdev = rfs_device_list[parent->sb->s_dev->dev_id];
462
463 // ** find a free disk inode to store the file that is going to be created
464 struct rfs_dinode *free_dinode = NULL;
465 int free_inum = 0;
466 for (int i = 0; i < (RFS_BLKSIZE / RFS_INODESIZE * RFS_MAX_INODE_BLKNUM);
467 ++i) {
468 free_dinode = rfs_read_dinode(rdev, i);
469 if (free_dinode->type == R_FREE) { // found
470 free_inum = i;
471 break;
472 }
473 free_page(free_dinode);
474 }
475
476 if (free_dinode == NULL)
477 panic("rfs_create: no more free disk inode, we cannot create file.\n" );
478
479 // initialize the states of the file being created
480
481 // TODO (lab4_1): implement the code for populating the disk inode (free_dinode)
482 // of a new file being created.
483 // hint: members of free_dinode to be filled are:
484 // size, should be zero for a new file.
485 // type, see kernel/rfs.h and find the type for a rfs file.
486 // nlinks, i.e., the number of links.
487 // blocks, i.e., its block count.
488 // Note: DO NOT DELETE CODE BELOW PANIC.
489 panic("You need to implement the code of populating a disk inode in lab4_1.\n" );
490
491 // DO NOT REMOVE ANY CODE BELOW.
492 // allocate a free block for the file
493 free_dinode->addrs[0] = rfs_alloc_block(parent->sb);
494
495 // ** write the disk inode of file being created to disk
496 rfs_write_dinode(rdev, free_dinode, free_inum);
497 free_page(free_dinode);
498
499 // ** build vfs inode according to dinode
500 struct vinode *new_vinode = rfs_alloc_vinode(parent->sb);
501 new_vinode->inum = free_inum;
502 rfs_update_vinode(new_vinode);
503
504 // ** append the new file as a direntry to its parent dir
505 int result = rfs_add_direntry(parent, sub_dentry->name, free_inum);
506 if (result == -1) {
507 sprint("rfs_create: rfs_add_direntry failed");
508 return NULL;
509 }
510
511 return new_vinode;
512 }
```
第463--474行， ， ， ； ， ，
继续阅读剩下的代码， ； ； ， ； ，
**实验完毕后，记得提交修改（命令行中-m后的字符串可自行确定） ， ：
```bash
$ git commit -a -m "my work on lab4_1 is done."
```
< a name = "lab4_2_dir" > < / a >
## 6.3 lab4_2 目录文件
< a name = "lab4_2_app" > < / a >
#### **给定应用**
- user/app_directory.c
```c
01 #include "user_lib.h"
02 #include "util/string.h"
03 #include "util/types.h"
04
05 void ls(char *path) {
06 int dir_fd = opendir_u(path);
07 printu("------------------------------\n");
08 printu("ls \"%s\":\n", path);
09 printu("[name] [inode_num]\n");
10 struct dir dir;
11 int width = 20;
12 while(readdir_u(dir_fd, & dir) == 0) {
13 // we do not have %ms :(
14 char name[width + 1];
15 memset(name, ' ', width + 1);
16 name[width] = '\0';
17 if (strlen(dir.name) < width ) {
18 strcpy(name, dir.name);
19 name[strlen(dir.name)] = ' ';
20 printu("%s %d\n", name, dir.inum);
21 }
22 else
23 printu("%s %d\n", dir.name, dir.inum);
24 }
25 printu("------------------------------\n");
26 closedir_u(dir_fd);
27 }
28
29 int main(int argc, char *argv[]) {
30 char str[] = "hello world";
31 int fd;
32
33 printu("\n======== Test 1: open and read dir ========\n");
34
35 ls("/RAMDISK0");
36
37 printu("\n======== Test 2: make dir ========\n");
38
39 mkdir_u("/RAMDISK0/sub_dir");
40 printu("make: /RAMDISK0/sub_dir\n");
41
42 ls("/RAMDISK0");
43
44 // try to write a file in the new dir
45 printu("write: /RAMDISK0/sub_dir/ramfile\n");
46
47 fd = open("/RAMDISK0/sub_dir/ramfile", O_RDWR | O_CREAT);
48 printu("file descriptor fd: %d\n", fd);
49
50 write_u(fd, str, strlen(str));
51 printu("write content: \n%s\n", str);
52
53 close(fd);
54
55 ls("/RAMDISK0/sub_dir");
56
57 printu("\nAll tests passed!\n\n");
58 exit(0);
59 return 0;
60 }
```
该应用在Test 1中完成对目录文件的读取操作。目录文件的读取在ls函数中实现， ， ： ， ； ， ， ， ； ， ；
- （ ， ） ， ， ：
```
//切换到lab4_2
$ git checkout lab4_2_directory
//继承lab4_2以及之前的答案
$ git merge lab4_1_file -m "continue to work on lab4_2"
//重新构造
$ make clean; make
//运行构造结果
$ spike ./obj/riscv-pke ./obj/app_directory
In m_start, hartid:0
HTIF is available!
(Emulated) memory size: 2048 MB
Enter supervisor mode...
PKE kernel start 0x0000000080000000, PKE kernel end: 0x000000008000e000, PKE kernel size: 0x000000000000e000 .
free physical memory address: [0x000000008000e000, 0x0000000087ffffff]
kernel memory manager is initializing ...
KERN_BASE 0x0000000080000000
physical address of _etext is: 0x0000000080008000
kernel page table is on
RAMDISK0: base address of RAMDISK0 is: 0x0000000087f37000
RFS: format RAMDISK0 done!
Switch to user mode...
in alloc_proc. user frame 0x0000000087f2f000, user stack 0x000000007ffff000, user kstack 0x0000000087f2e000
FS: created a file management struct for a process.
in alloc_proc. build proc_file_management successfully.
User application is loading.
Application: obj/app_directory
CODE_SEGMENT added at mapped info offset:3
DATA_SEGMENT added at mapped info offset:4
Application program entry point (virtual address): 0x0000000000010186
going to insert process 0 to ready queue.
going to schedule process 0 to run.
======== Test 1: open and read dir ========
------------------------------
ls "/RAMDISK0":
[name] [inode_num]
------------------------------
======== Test 2: make dir ========
make: /RAMDISK0/sub_dir
------------------------------
ls "/RAMDISK0":
[name] [inode_num]
You need to implement the code for reading a directory entry of rfs in lab4_2.
System is shutting down with exit code -1.
```
从以上运行结果来看， ， ， ，
< a name = "lab4_2_content" > < / a >
#### 实验内容
在PKE操作系统内核中完善对目录文件的访问操作，
实验完成后的运行结果：
```
$ spike ./obj/riscv-pke ./obj/app_directory
In m_start, hartid:0
HTIF is available!
(Emulated) memory size: 2048 MB
Enter supervisor mode...
PKE kernel start 0x0000000080000000, PKE kernel end: 0x000000008000e000, PKE kernel size: 0x000000000000e000 .
free physical memory address: [0x000000008000e000, 0x0000000087ffffff]
kernel memory manager is initializing ...
KERN_BASE 0x0000000080000000
physical address of _etext is: 0x0000000080008000
kernel page table is on
RAMDISK0: base address of RAMDISK0 is: 0x0000000087f37000
RFS: format RAMDISK0 done!
Switch to user mode...
in alloc_proc. user frame 0x0000000087f2f000, user stack 0x000000007ffff000, user kstack 0x0000000087f2e000
FS: created a file management struct for a process.
in alloc_proc. build proc_file_management successfully.
User application is loading.
Application: obj/app_directory
CODE_SEGMENT added at mapped info offset:3
DATA_SEGMENT added at mapped info offset:4
Application program entry point (virtual address): 0x0000000000010186
going to insert process 0 to ready queue.
going to schedule process 0 to run.
======== Test 1: open and read dir ========
------------------------------
ls "/RAMDISK0":
[name] [inode_num]
------------------------------
======== Test 2: make dir ========
make: /RAMDISK0/sub_dir
------------------------------
ls "/RAMDISK0":
[name] [inode_num]
sub_dir 1
------------------------------
write: /RAMDISK0/sub_dir/ramfile
file descriptor fd: 0
write content:
hello world
------------------------------
ls "/RAMDISK0/sub_dir":
[name] [inode_num]
ramfile 2
------------------------------
All tests passed!
User exit with code:0.
no more ready processes, system shutdown now.
System is shutting down with exit code 0.
```
< a name = "lab4_2_guide" > < / a >
#### 实验指导
首先需要了解一下RFS读取目录文件的方式。RFS读取目录文件的方式与读取普通文件有很大的不同， ： ， ， ：
```c
125 int opendir_u(const char *dirname) {
126 return do_user_call(SYS_user_opendir, (uint64)dirname, 0, 0, 0, 0, 0, 0);
127 }
```
可见其对应SYS_user_opendir系统调用， ：
```c
160 ssize_t sys_user_opendir(char * pathva){
161 char * pathpa = (char* )user_va_to_pa((pagetable_t)(current->pagetable), pathva);
162 return do_opendir(pathpa);
163 }
```
该函数完成虚拟地址到物理地址的转换后， ：
```c
165 int do_opendir(char *pathname) {
166 struct file *opened_file = NULL;
167 if ((opened_file = vfs_opendir(pathname)) == NULL) return -1;
168
169 int fd = 0;
170 struct file *pfile;
171 for (fd = 0; fd < MAX_FILES ; + + fd ) {
172 pfile = &(current->pfiles->opened_files[fd]);
173 if (pfile->status == FD_NONE) break;
174 }
175 if (pfile->status != FD_NONE) // no free entry
176 panic("do_opendir: no file entry for current process!\n");
177
178 // initialize this file structure
179 memcpy(pfile, opened_file, sizeof(struct file));
180
181 ++current->pfiles->nfiles;
182 return fd;
183 }
```
该函数主要在第167行调用vfs_opendir函数完成打开目录文件的功能， ：
```c
279 struct file *vfs_opendir(const char *path) {
280 struct dentry *parent = vfs_root_dentry;
281 char miss_name[MAX_PATH_LEN];
282
283 // lookup the dir
284 struct dentry *file_dentry = lookup_final_dentry(path, & parent, miss_name);
285
286 if (!file_dentry || file_dentry->dentry_inode->type != DIR_I) {
287 sprint("vfs_opendir: cannot find the direntry!\n");
288 return NULL;
289 }
290
291 // allocate a vfs file with readable/non-writable flag.
292 struct file *file = alloc_vfs_file(file_dentry, 1, 0, 0);
293
294 // additional open direntry operations for a specific file system
295 // rfs needs duild dir cache.
296 if (file_dentry->dentry_inode->i_ops->viop_hook_opendir) {
297 if (file_dentry->dentry_inode->i_ops->
298 viop_hook_opendir(file_dentry->dentry_inode, file_dentry) != 0) {
299 sprint("vfs_opendir: hook opendir failed!\n");
300 }
301 }
302
303 return file;
304 }
```
该函数在第284行调用lookup_final_dentry在目录树中查找目标目录文件， ， ， （ ） ： ， ： ， ， ：
```c
577 //
578 // when a directory is opened, the contents of the directory file are read
579 // into the memory for directory read operations
580 //
581 int rfs_hook_opendir(struct vinode *dir_vinode, struct dentry *dentry) {
582 // allocate space and read the contents of the dir block into memory
583 void *pdire = NULL;
584 void *previous = NULL;
585 struct rfs_device *rdev = rfs_device_list[dir_vinode->sb->s_dev->dev_id];
586
587 // read-in the directory file, store all direntries in dir cache.
588 for (int i = dir_vinode->blocks - 1; i >= 0; i--) {
589 previous = pdire;
590 pdire = alloc_page();
591
592 if (previous != NULL & & previous - pdire != RFS_BLKSIZE)
593 panic("rfs_hook_opendir: memory discontinuity");
594
595 rfs_r1block(rdev, dir_vinode->addrs[i]);
596 memcpy(pdire, rdev->iobuffer, RFS_BLKSIZE);
597 }
598
599 // save the pointer to the directory block in the vinode
600 struct rfs_dir_cache *dir_cache = (struct rfs_dir_cache * )alloc_page();
601 dir_cache->block_count = dir_vinode->blocks;
602 dir_cache->dir_base_addr = (struct rfs_direntry *)pdire;
603
604 dir_vinode->i_fs_info = dir_cache;
605
606 return 0;
607 }
```
在第587--597行， （ ， ） ； ； ，
RFS的读目录函数由rfs_readdir实现（ ， ， ， ） ， ：
```c
624 //
625 // read a directory entry from the directory "dir", and the "offset" indicate
626 // the position of the entry to be read. if offset is 0, the first entry is read,
627 // if offset is 1, the second entry is read, and so on.
628 // return: 0 on success, -1 when there are no more entry (end of the list).
629 //
630 int rfs_readdir(struct vinode *dir_vinode, struct dir *dir, int *offset) {
631 int total_direntrys = dir_vinode->size / sizeof(struct rfs_direntry);
632 int one_block_direntrys = RFS_BLKSIZE / sizeof(struct rfs_direntry);
633
634 int direntry_index = *offset;
635 if (direntry_index >= total_direntrys) {
636 // no more direntry
637 return -1;
638 }
639
640 // reads a directory entry from the directory cache stored in vfs inode.
641 struct rfs_dir_cache *dir_cache =
642 (struct rfs_dir_cache *)dir_vinode->i_fs_info;
643 struct rfs_direntry *p_direntry = dir_cache->dir_base_addr + direntry_index;
644
645 // TODO (lab4_2): implement the code to read a directory entry.
646 // hint: in the above code, we had found the directory entry that located at the
647 // *offset, and used p_direntry to point it.
648 // in the remaining processing, we need to return our discovery.
649 // the method of returning is to popular proper members of "dir", more specifically,
650 // dir->name and dir->inum.
651 // note: DO NOT DELETE CODE BELOW PANIC.
652 panic("You need to implement the code for reading a directory entry of rfs in lab4_2.\n" );
653
654 // DO NOT DELETE CODE BELOW.
655 (*offset)++;
656 return 0;
657 }
```
在第641行， ； ， ， （ ； ， ，
完成目录的读取后， ，
**实验完毕后，记得提交修改（命令行中-m后的字符串可自行确定） ， ：
```bash
$ git commit -a -m "my work on lab4_2 is done."
```
< a name = "lab4_3_hardlink" > < / a >
## 6.4 lab4_3 硬链接
< a name = "lab4_3_app" > < / a >
#### **给定应用**
- user/app_hardlink.c
```c
01 #include "user_lib.h"
02 #include "util/string.h"
03 #include "util/types.h"
04
05 void ls(char *path) {
06 int dir_fd = opendir_u(path);
07 printu("------------------------------\n");
08 printu("ls \"%s\":\n", path);
09 printu("[name] [inode_num]\n");
10 struct dir dir;
11 int width = 20;
12 while(readdir_u(dir_fd, & dir) == 0) {
13 // we do not have %ms :(
14 char name[width + 1];
15 memset(name, ' ', width + 1);
16 name[width] = '\0';
17 if (strlen(dir.name) < width ) {
18 strcpy(name, dir.name);
19 name[strlen(dir.name)] = ' ';
20 printu("%s %d\n", name, dir.inum);
21 }
22 else
23 printu("%s %d\n", dir.name, dir.inum);
24 }
25 printu("------------------------------\n");
26 closedir_u(dir_fd);
27 }
28
29 int main(int argc, char *argv[]) {
30 int MAXBUF = 512;
31 char str[] = "hello world";
32 char buf[MAXBUF];
33 int fd1, fd2;
34
35 printu("\n======== establish the file ========\n");
36
37 fd1 = open("/RAMDISK0/ramfile", O_RDWR | O_CREAT);
38 printu("create file: /RAMDISK0/ramfile\n");
39 close(fd1);
40
41 printu("\n======== Test 1: hard link ========\n");
42
43 link_u("/RAMDISK0/ramfile", "/RAMDISK0/ramfile2");
44 printu("create hard link: /RAMDISK0/ramfile2 -> /RAMDISK0/ramfile\n");
45
46 fd1 = open("/RAMDISK0/ramfile", O_RDWR);
47 fd2 = open("/RAMDISK0/ramfile2", O_RDWR);
48
49 printu("file descriptor fd1 (ramfile): %d\n", fd1);
50 printu("file descriptor fd2 (ramfile2): %d\n", fd2);
51
52 // check the number of hard links to ramfile on disk
53 struct istat st;
54 disk_stat_u(fd1, &st);
55 printu("ramfile hard links: %d\n", st.st_nlinks);
56 if (st.st_nlinks != 2) {
57 printu("ERROR: the number of hard links to ramfile should be 2, but it is %d\n",
58 st.st_nlinks);
59 exit(-1);
60 }
61
62 write_u(fd1, str, strlen(str));
63 printu("/RAMDISK0/ramfile write content: \n%s\n", str);
64
65 read_u(fd2, buf, MAXBUF);
66 printu("/RAMDISK0/ramfile2 read content: \n%s\n", buf);
67
68 close(fd1);
69 close(fd2);
70
71 printu("\n======== Test 2: unlink ========\n");
72
73 ls("/RAMDISK0");
74
75 unlink_u("/RAMDISK0/ramfile");
76 printu("unlink: /RAMDISK0/ramfile\n");
77
78 ls("/RAMDISK0");
79
80 // check the number of hard links to ramfile2 on disk
81 fd2 = open("/RAMDISK0/ramfile2", O_RDWR);
82 disk_stat_u(fd2, &st);
83 printu("ramfile2 hard links: %d\n", st.st_nlinks);
84 if (st.st_nlinks != 1) {
85 printu("ERROR: the number of hard links to ramfile should be 1, but it is %d\n",
86 st.st_nlinks);
87 exit(-1);
88 }
89 close(fd2);
90
91 printu("\nAll tests passed!\n\n");
92 exit(0);
93 return 0;
94 }
```
该应用调用open创建一个文件 `/RAMDISK0/ramfile` ， ， `ramfile` 文件的硬链接数是否为2， `ramfile` 写入一段内容，再读取 `ramfile2` ，
在Test 2中， ，
- （ ， ） ， ， ：
```c
//切换到lab4_3
$ git checkout lab4_3_hardlink
//继承lab4_2以及之前的答案
$ git merge lab4_2_directory -m "continue to work on lab4_3"
//重新构造
$ make clean; make
//运行构造结果
$ spike ./obj/riscv-pke ./obj/app_hardlink
In m_start, hartid:0
HTIF is available!
(Emulated) memory size: 2048 MB
Enter supervisor mode...
PKE kernel start 0x0000000080000000, PKE kernel end: 0x000000008000e000, PKE kernel size: 0x000000000000e000 .
free physical memory address: [0x000000008000e000, 0x0000000087ffffff]
kernel memory manager is initializing ...
KERN_BASE 0x0000000080000000
physical address of _etext is: 0x0000000080008000
kernel page table is on
RAMDISK0: base address of RAMDISK0 is: 0x0000000087f37000
RFS: format RAMDISK0 done!
Switch to user mode...
in alloc_proc. user frame 0x0000000087f2f000, user stack 0x000000007ffff000, user kstack 0x0000000087f2e000
FS: created a file management struct for a process.
in alloc_proc. build proc_file_management successfully.
User application is loading.
Application: obj/app_hardlink
CODE_SEGMENT added at mapped info offset:3
DATA_SEGMENT added at mapped info offset:4
Application program entry point (virtual address): 0x0000000000010186
going to insert process 0 to ready queue.
going to schedule process 0 to run.
======== establish the file ========
create file: /RAMDISK0/ramfile
======== Test 1: hard link ========
You need to implement the code for creating a hard link in lab4_3.
System is shutting down with exit code -1.
```
从以上运行结果来看，
< a name = "lab4_3_content" > < / a >
#### 实验内容
在PKE操作系统内核中完善对文件的访问操作，
实验完成后的运行结果：
```
$ spike ./obj/riscv-pke ./obj/app_hardlink
In m_start, hartid:0
HTIF is available!
(Emulated) memory size: 2048 MB
Enter supervisor mode...
PKE kernel start 0x0000000080000000, PKE kernel end: 0x000000008000e000, PKE kernel size: 0x000000000000e000 .
free physical memory address: [0x000000008000e000, 0x0000000087ffffff]
kernel memory manager is initializing ...
KERN_BASE 0x0000000080000000
physical address of _etext is: 0x0000000080008000
kernel page table is on
RAMDISK0: base address of RAMDISK0 is: 0x0000000087f37000
RFS: format RAMDISK0 done!
Switch to user mode...
in alloc_proc. user frame 0x0000000087f2f000, user stack 0x000000007ffff000, user kstack 0x0000000087f2e000
FS: created a file management struct for a process.
in alloc_proc. build proc_file_management successfully.
User application is loading.
Application: obj/app_hardlink
CODE_SEGMENT added at mapped info offset:3
DATA_SEGMENT added at mapped info offset:4
Application program entry point (virtual address): 0x0000000000010186
going to insert process 0 to ready queue.
going to schedule process 0 to run.
======== establish the file ========
create file: /RAMDISK0/ramfile
======== Test 1: hard link ========
create hard link: /RAMDISK0/ramfile2 -> /RAMDISK0/ramfile
file descriptor fd1 (ramfile): 0
file descriptor fd2 (ramfile2): 1
ramfile hard links: 2
/RAMDISK0/ramfile write content:
hello world
/RAMDISK0/ramfile2 read content:
hello world
======== Test 2: unlink ========
------------------------------
ls "/RAMDISK0":
[name] [inode_num]
ramfile 1
ramfile2 1
------------------------------
unlink: /RAMDISK0/ramfile
------------------------------
ls "/RAMDISK0":
[name] [inode_num]
ramfile2 1
------------------------------
ramfile2 hard links: 1
All tests passed!
User exit with code:0.
no more ready processes, system shutdown now.
System is shutting down with exit code 0.
```
通过上述输出， ， ， ，
< a name = "lab4_3_guide" > < / a >
#### 实验指导
为了补全PKE文件系统的硬链接功能， ， ：
```c
211 int do_link(char *oldpath, char *newpath) {
212 return vfs_link(oldpath, newpath);
213 }
```
该函数直接调用了vfs_link， ：
```c
236 //
237 // make hard link to the file specified by "oldpath" with the name "newpath"
238 // return: -1 on failure, 0 on success.
239 //
240 int vfs_link(const char *oldpath, const char *newpath) {
241 struct dentry *parent = vfs_root_dentry;
242 char miss_name[MAX_PATH_LEN];
243
244 // lookup oldpath
245 struct dentry *old_file_dentry =
246 lookup_final_dentry(oldpath, & parent, miss_name);
247 if (!old_file_dentry) {
248 sprint("vfs_link: cannot find the file!\n");
249 return -1;
250 }
251
252 if (old_file_dentry->dentry_inode->type != FILE_I) {
253 sprint("vfs_link: cannot link a directory!\n");
254 return -1;
255 }
256
257 parent = vfs_root_dentry;
258 // lookup the newpath
259 // note that parent is changed to be the last directory entry to be accessed
260 struct dentry *new_file_dentry =
261 lookup_final_dentry(newpath, & parent, miss_name);
262 if (new_file_dentry) {
263 sprint("vfs_link: the new file already exists!\n");
264 return -1;
265 }
266
267 char basename[MAX_PATH_LEN];
268 get_base_name(newpath, basename);
269 if (strcmp(miss_name, basename) != 0) {
270 sprint("vfs_link: cannot create file in a non-exist directory!\n");
271 return -1;
272 }
273
274 // do the real hard-link
275 new_file_dentry = alloc_vfs_dentry(basename, old_file_dentry->dentry_inode, parent);
276 int err =
277 viop_link(parent->dentry_inode, new_file_dentry, old_file_dentry->dentry_inode);
278 if (err) return -1;
279
280 // make a new dentry for the new link
281 hash_insert(new_file_dentry);
282
283 return 0;
284 }
```
第245--246行在目录树中查找被链接的文件； ， ； ， ：
```c
579 //
580 // create a hard link under a direntry "parent" for an existing file of "link_node"
581 //
582 int rfs_link(struct vinode *parent, struct dentry *sub_dentry, struct vinode *link_node) {
583 // TODO (lab4_3): we now need to establish a hard link to an existing file whose vfs
584 // inode is "link_node". To do that, we need first to know the name of the new (link)
585 // file, and then, we need to increase the link count of the existing file. Lastly,
586 // we need to make the changes persistent to disk. To know the name of the new (link)
587 // file, you need to stuty the structure of dentry, that contains the name member;
588 // To incease the link count of the existing file, you need to study the structure of
589 // vfs inode, since it contains the inode information of the existing file.
590 //
591 // hint: to accomplish this experiment, you need to:
592 // 1) increase the link count of the file to be hard-linked;
593 // 2) append the new (link) file as a dentry to its parent directory; you can use
594 // rfs_add_direntry here.
595 // 3) persistent the changes to disk. you can use rfs_write_back_vinode here.
596 //
597 panic("You need to implement the code for creating a hard link in lab4_3.\n" );
598 }
```
此函数需要读者进行实现。根据注释的提示， ：
1. 将旧文件vinode的硬链接数加一；
2. 新创建硬链接的父目录文件中添加一个目录项： ： ；
3. 将vinode写回到RAM DISK中。
**实验完毕后，记得提交修改（命令行中-m后的字符串可自行确定） ， ：
```bash
$ git commit -a -m "my work on lab4_3 is done."
```
< a name = "lab4_challenge1_pwd" > < / a >
## 6.5 lab4_challenge1 相对路径（难度：★★★☆☆）
< a name = "lab4_challenge1_app" > < / a >
#### 给定应用
- user/app_relativepath.c
```c
1 #include "user_lib.h"
2 #include "util/string.h"
3 #include "util/types.h"
4
5 void pwd() {
6 char path[30];
7 read_cwd(path);
8 printu("cwd:%s\n", path);
9 }
10
11 void cd(const char *path) {
12 if (change_cwd(path) != 0)
13 printu("cd failed\n");
14 }
15
16 int main(int argc, char *argv[]) {
17 int fd;
18 int MAXBUF = 512;
19 char buf[MAXBUF];
20 char str[] = "hello world";
21 int fd1, fd2;
22
23 printu("\n======== Test 1: change current directory ========\n");
24
25 pwd();
26 cd("./RAMDISK0");
27 printu("change current directory to ./RAMDISK0\n");
28 pwd();
29
30 printu("\n======== Test 2: write/read file by relative path ========\n");
31 printu("write: ./ramfile\n");
32
33 fd = open("./ramfile", O_RDWR | O_CREAT);
34 printu("file descriptor fd: %d\n", fd);
35
36 write_u(fd, str, strlen(str));
37 printu("write content: \n%s\n", str);
38 close(fd);
39
40 fd = open("./ramfile", O_RDWR);
41 printu("read: ./ramfile\n");
42
43 read_u(fd, buf, MAXBUF);
44 printu("read content: \n%s\n", buf);
45 close(fd);
46
47 printu("\n======== Test 3: Go to parent directory ========\n");
48
49 pwd();
50 cd("..");
51 printu("change current directory to ..\n");
52 pwd();
53
54 printu("read: ./hostfile.txt\n");
55
56 fd = open("./hostfile.txt", O_RDONLY);
57 printu("file descriptor fd: %d\n", fd);
58
59 read_u(fd, buf, MAXBUF);
60 printu("read content: \n%s\n", buf);
61
62 close(fd);
63
64 printu("\nAll tests passed!\n\n");
65 exit(0);
66 return 0;
67 }
```
相对路径即形如：“`./file`”、“`./dir/file`”以及“`../dir/file`”的路径形式。与绝对路径总是从根目录开始逐级指定文件或目录在目录树中的位置不同，相对路径从进程的“当前工作目录“开始，对一个文件或目录在目录树中的位置进行描述。
从路径字符串形式的角度来看，相对路径的起始处总是为以下两种特殊的目录之一：”`.`“，”`..`“。其中”`.`“代指进程的当前工作目录，“`..`”代指进程当前工作目录的父目录。例如，“`./file`”的含义为： ； ：
从文件系统的角度来说，相对路径的实现首先依赖于每个进程中所维护的当前工作目录。其次，具体文件系统需要对相对路径访问方式提供支持。
如上的应用预期输出如下：
```c
In m_start, hartid:0
HTIF is available!
(Emulated) memory size: 2048 MB
Enter supervisor mode...
PKE kernel start 0x0000000080000000, PKE kernel end: 0x000000008000d000, PKE kernel size: 0x000000000000d000 .
free physical memory address: [0x000000008000d000, 0x0000000087ffffff]
kernel memory manager is initializing ...
KERN_BASE 0x0000000080000000
physical address of _etext is: 0x0000000080008000
kernel page table is on
RAMDISK0: base address of RAMDISK0 is: 0x0000000087f35000
RFS: format RAMDISK0 done!
Switch to user mode...
in alloc_proc. user frame 0x0000000087f29000, user stack 0x000000007ffff000, user kstack 0x0000000087f28000
FS: created a file management struct for a process.
in alloc_proc. build proc_file_management successfully.
User application is loading.
Application: obj/app_relativepath
CODE_SEGMENT added at mapped info offset:3
DATA_SEGMENT added at mapped info offset:4
Application program entry point (virtual address): 0x00000000000100ec
going to insert process 0 to ready queue.
going to schedule process 0 to run.
======== Test 1: change current directory ========
cwd:/
change current directory to ./RAMDISK0
cwd:/RAMDISK0
======== Test 2: write/read file by relative path ========
write: ./ramfile
file descriptor fd: 0
write content:
hello world
read: ./ramfile
read content:
hello world
======== Test 3: Go to parent directory ========
cwd:/RAMDISK0
change current directory to ..
cwd:/
read: ./hostfile.txt
file descriptor fd: 0
read content:
This is an apple.
Apples are good for our health.
All tests passed!
User exit with code:0.
no more ready processes, system shutdown now.
System is shutting down with exit code 0.
```
< a name = "lab4_challenge1_content" > < / a >
#### 实验内容
本实验为挑战实验， ：
- （ ， ） ：
```bash
//切换到lab4_challenge1_relativepath
$ git checkout lab4_challenge1_relativepath
//继承lab3_3以及之前的答案
$ git merge lab4_3_hardlink -m "continue to work on lab4_challenge1"
```
注意：**不同于基础实验，挑战实验的基础代码具有更大的不完整性，可能无法直接通过构造过程。**同样，不同于基础实验，我们在代码中也并未专门地哪些地方的代码需要填写，哪些地方的代码无须填写。这样，我们留给读者更大的“想象空间”。
- 本实验的具体要求为：
- 通过修改PKE文件系统代码， ， ，
- 完成用户层pwd函数（ ） （ ）
- 注意：最终测试程序可能和给出的用户程序不同，但都涉及工作目录的显示、工作目录切换以及相对路径的使用等相关操作。
< a name = "lab4_challenge1_guide" > < / a >
#### 实验指导
- 你对内核代码的修改可能包含以下内容：
- 添加系统调用，
- 修改文件系统对路径字符串的解析过程，使其能够正确处理相对路径。
- 对RFS进行适当的修改。
**注意：完成实验内容后，请读者另外编写应用，对自己的实现进行检测。**
**另外，后续的基础实验代码并不依赖挑战实验，所以读者可自行决定是否将自己的工作提交到本地代码仓库中（当然，提交到本地仓库是个好习惯，至少能保存自己的“作品”）。**
< a name = "lab4_challenge2_exec" > < / a >
## 6.6 lab4_challenge2 重载执行（难度：★★★★☆）
< a name = "lab4_challenge2_app" > < / a >
#### 给定应用
- user/app_exec.c
```c
01 #include "user_lib.h"
02 #include "util/types.h"
03
04 int main(int argc, char *argv[]) {
05 printu("\n======== exec /bin/app_ls in app_exec ========\n");
06 int ret = exec("/bin/app_ls");
07 if (ret == -1)
08 printu("exec failed!\n");
09
10 exit(0);
11 return 0;
12 }
```
- user/app_ls.c
```c
01 #include "user_lib.h"
02 #include "util/string.h"
03 #include "util/types.h"
04
05 int main(int argc, char *argv[]) {
06 char path[] = "/RAMDISK0";
07 int dir_fd = opendir_u(path);
08 printu("------------------------------\n");
09 printu("ls \"%s\":\n", path);
10 printu("[name] [inode_num]\n");
11 struct dir dir;
12 int width = 20;
13 while(readdir_u(dir_fd, & dir) == 0) {
14 // we do not have %ms :(
15 char name[width + 1];
16 memset(name, ' ', width + 1);
17 name[width] = '\0';
18 if (strlen(dir.name) < width ) {
19 strcpy(name, dir.name);
20 name[strlen(dir.name)] = ' ';
21 printu("%s %d\n", name, dir.inum);
22 }
23 else
24 printu("%s %d\n", dir.name, dir.inum);
25 }
26 printu("------------------------------\n");
27 closedir_u(dir_fd);
28
29 exit(0);
30 return 0;
31 }
```
以上给出了app_exec和app_ls两个程序。其中app_exec作为主程序， ）
exec函数用来在一个进程中启动另一个程序执行。其中可执行文件通过文件的路径名指定，
如上的应用预期输出如下：
```c
In m_start, hartid:0
HTIF is available!
(Emulated) memory size: 2048 MB
Enter supervisor mode...
PKE kernel start 0x0000000080000000, PKE kernel end: 0x000000008000d000, PKE kernel size: 0x000000000000d000 .
free physical memory address: [0x000000008000d000, 0x0000000087ffffff]
kernel memory manager is initializing ...
KERN_BASE 0x0000000080000000
physical address of _etext is: 0x0000000080008000
kernel page table is on
RAMDISK0: base address of RAMDISK0 is: 0x0000000087f35000
RFS: format RAMDISK0 done!
Switch to user mode...
in alloc_proc. user frame 0x0000000087f29000, user stack 0x000000007ffff000, user kstack 0x0000000087f28000
FS: created a file management struct for a process.
in alloc_proc. build proc_file_management successfully.
User application is loading.
Application: /bin/app_exec
CODE_SEGMENT added at mapped info offset:3
Application program entry point (virtual address): 0x0000000000010078
going to insert process 0 to ready queue.
going to schedule process 0 to run.
======== exec /bin/app_ls in app_exec ========
Application: /bin/app_ls
CODE_SEGMENT added at mapped info offset:3
DATA_SEGMENT added at mapped info offset:4
Application program entry point (virtual address): 0x00000000000100b0
------------------------------
ls "/RAMDISK0":
[name] [inode_num]
------------------------------
User exit with code:0.
no more ready processes, system shutdown now.
System is shutting down with exit code 0.
```
根据结果可以看出，
< a name = "lab4_challenge2_content" > < / a >
#### 实验内容
本实验为挑战实验， ：
- （ ， ） ：
```bash
//切换到lab4_challenge2_exec
$ git checkout lab4_challenge2_exec
//继承lab4_3以及之前的答案
$ git merge lab4_3_hardlink -m "continue to work on lab4_challenge2"
```
注意：**不同于基础实验，挑战实验的基础代码具有更大的不完整性，可能无法直接通过构造过程。**同样，不同于基础实验，我们在代码中也并未专门地哪些地方的代码需要填写，哪些地方的代码无须填写。这样，我们留给读者更大的“想象空间”。
- 本实验的具体要求为：
- 通过修改PKE内核和系统调用， ， ，
< a name = "lab4_challenge2_guide" > < / a >
#### 实验指导
- 你对内核代码的修改可能包含添加系统调用、在内核中实现exec函数的功能。
**注意： ， ， ， ， （ ） ， ，
**另外，后续的基础实验代码并不依赖挑战实验，所以读者可自行决定是否将自己的工作提交到本地代码仓库中（当然，提交到本地仓库是个好习惯，至少能保存自己的“作品”）。**
