实验9 proc文件系统的实现

1.实验目的

掌握虚拟文件系统的实现原理；
实践文件、目录、文件系统等概念。

2.实验内容

/proc文件系统是了解系统信息的一个窗口，它不是普通意义上的文件系统，它是一个到运行中进程地址空间的访问接口。通过/proc，可以用标准Unix系统调用(比如open()、read()、write()等等)访问，就象访问一个普通文件一样。事实上，许多操作系统中的ps命令正是利用/proc来获取进程状态的。因此/proc文件系统是虚拟的文件系统，看似存在的文件实际并没有在硬盘上。其实，/proc是你了解自己系统的一个窗口，它实际存在于内存。

在 Linux 0.11 上实现 procfs（proc 文件系统）内的 psinfo 结点。当读取此结点的内容时，可得到系统当前所有进程的状态信息。例如，用 cat 命令显示 /proc/psinfo 的内容，可得到：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


$ cat /proc/psinfo
pid    state    father    counter    start_time
0    1    -1    0    0
1    1    0    28    1
4    1    1    1    73
3    1    1    27    63
6    0    4    12    817
$ cat /proc/hdinfo
total_blocks:    62000;
free_blocks:    39037;
used_blocks:    22963;
...

procfs 及其结点要在内核启动时自动创建。

相关功能实现在 fs/proc.c 文件内。

3.实验报告

完成实验后，在实验报告中回答如下问题：

如果要求你在 psinfo 之外再实现另一个结点，具体内容自选，那么你会实现一个给出什么信息的结点？为什么？
一次 read() 未必能读出所有的数据，需要继续 read()，直到把数据读空为止。而数次 read() 之间，进程的状态可能会发生变化。你认为后几次 read() 传给用户的数据，应该是变化后的，还是变化前的？
- 如果是变化后的，那么用户得到的数据衔接部分是否会有混乱？如何防止混乱？
- 如果是变化前的，那么该在什么样的情况下更新 psinfo 的内容？

4.实验提示

本实验文档在 Linux 0.11 上实现 procfs（proc 文件系统）内的 psinfo 结点。当读取 psinfo 结点的内容时，可得到系统当前所有进程的状态信息。

最后还给出来 hdinfo 结点实现的提示。

4.1 procfs 简介

正式的 Linux 内核实现了 procfs，它是一个虚拟文件系统，通常被 mount（挂载）到 /proc 目录上，通过虚拟文件和虚拟目录的方式提供访问系统参数的机会，所以有人称它为 “了解系统信息的一个窗口”。

这些虚拟的文件和目录并没有真实地存在在磁盘上，而是内核中各种数据的一种直观表示。虽然是虚拟的，但它们都可以通过标准的系统调用（open()、read() 等）访问。

例如，/proc/meminfo 中包含内存使用的信息，可以用 cat 命令显示其内容：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


$ cat /proc/meminfo
MemTotal:       384780 kB
MemFree:         13636 kB
Buffers:         13928 kB
Cached:         101680 kB
SwapCached:        132 kB
Active:         207764 kB
Inactive:        45720 kB
SwapTotal:      329324 kB
SwapFree:       329192 kB
Dirty:               0 kB
Writeback:           0 kB
……

其实，Linux 的很多系统命令就是通过读取 /proc 实现的。例如 uname -a 的部分信息就来自 /proc/version，而 uptime 的部分信息来自 /proc/uptime 和 /proc/loadavg。

关于 procfs 更多的信息请访问：http://en.wikipedia.org/wiki/Procfs

4.2 基本思路

Linux 是通过文件系统接口实现 procfs，并在启动时自动将其 mount 到 /proc 目录上。

此目录下的所有内容都是随着系统的运行自动建立、删除和更新的，而且它们完全存在于内存中，不占用任何外存空间。

Linux 0.11 还没有实现虚拟文件系统，也就是，还没有提供增加新文件系统支持的接口。所以本实验只能在现有文件系统的基础上，通过打补丁的方式模拟一个 procfs。

Linux 0.11 使用的是 Minix 的文件系统，这是一个典型的基于 inode 的文件系统，《注释》一书对它有详细描述。它的每个文件都要对应至少一个 inode，而 inode 中记录着文件的各种属性，包括文件类型。文件类型有普通文件、目录、字符设备文件和块设备文件等。在内核中，每种类型的文件都有不同的处理函数与之对应。我们可以增加一种新的文件类型——proc 文件，并在相应的处理函数内实现 procfs 要实现的功能。

4.3 增加新文件类型

在 include/sys/stat.h 文件中定义了几种文件类型和相应的测试宏：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


#define S_IFMT  00170000

// 普通文件
#define S_IFREG  0100000

// 块设备
#define S_IFBLK  0060000

// 目录
#define S_IFDIR  0040000

// 字符设备
#define S_IFCHR  0020000
#define S_IFIFO  0010000
//……

// 测试 m 是否是普通文件
#define S_ISREG(m)      (((m) & S_IFMT) == S_IFREG)

// 测试 m 是否是目录
#define S_ISDIR(m)      (((m) & S_IFMT) == S_IFDIR)

// 测试 m 是否是字符设备
#define S_ISCHR(m)      (((m) & S_IFMT) == S_IFCHR)

// 测试 m 是否是块设备
#define S_ISBLK(m)      (((m) & S_IFMT) == S_IFBLK)
#define S_ISFIFO(m)     (((m) & S_IFMT) == S_IFIFO)

增加新的类型的方法分两步：

（1）定义一个类型宏 S_IFPROC，其值应在 0010000 到 0100000 之间，但后四位八进制数必须是 0（这是 S_IFMT 的限制，分析测试宏可知原因），而且不能和已有的任意一个 S_IFXXX 相同；
（2）定义一个测试宏 S_ISPROC(m)，形式仿照其它的 S_ISXXX(m)

注意，C 语言中以 “0” 直接接数字的常数是八进制数。

4.4 让 mknod() 支持新的文件类型

psinfo 结点要通过 mknod() 系统调用建立，所以要让它支持新的文件类型。

直接修改 fs/namei.c 文件中的 sys_mknod() 函数中的一行代码，如下：

1
2
3


if (S_ISBLK(mode) || S_ISCHR(mode) || S_ISPROC(mode))
     inode->i_zone[0] = dev;
// 文件系统初始化

内核初始化的全部工作是在 main() 中完成，而 main() 在最后从内核态切换到用户态，并调用 init()。

init() 做的第一件事情就是挂载根文件系统：

1
2
3
4
5
6


void init(void)
{
//    ……
    setup((void *) &drive_info);
//    ……
}

procfs 的初始化工作应该在根文件系统挂载之后开始。它包括两个步骤：

（1）建立 /proc 目录；建立 /proc 目录下的各个结点。本实验只建立 /proc/psinfo。
（2）建立目录和结点分别需要调用 mkdir() 和 mknod() 系统调用。因为初始化时已经在用户态，所以不能直接调用 sys_mkdir() 和 sys_mknod()。必须在初始化代码所在文件中实现这两个系统调用的用户态接口，即 API：

1
2
3
4
5
6


#ifndef __LIBRARY__
#define __LIBRARY__
#endif

_syscall2(int,mkdir,const char*,name,mode_t,mode)
_syscall3(int,mknod,const char*,filename,mode_t,mode,dev_t,dev)

mkdir() 时 mode 参数的值可以是 “0755”（对应 rwxr-xr-x），表示只允许 root 用户改写此目录，其它人只能进入和读取此目录。

procfs 是一个只读文件系统，所以用 mknod() 建立 psinfo 结点时，必须通过 mode 参数将其设为只读。建议使用 S_IFPROC|0444 做为 mode 值，表示这是一个 proc 文件，权限为 0444（r–r–r–），对所有用户只读。

mknod() 的第三个参数 dev 用来说明结点所代表的设备编号。对于 procfs 来说，此编号可以完全自定义。proc 文件的处理函数将通过这个编号决定对应文件包含的信息是什么。例如，可以把 0 对应 psinfo，1 对应 meminfo，2 对应 cpuinfo。

如此项工作完成得没有问题，那么编译、运行 0.11 内核后，用 ll /proc 可以看到：

1
2
3


# ll /proc
total 0
?r--r--r--   1 root     root              0 ??? ??  ???? psinfo

此时可以试着读一下此文件：

1
2
3


# cat /proc/psinfo
(Read)inode->i_mode=XXX444
cat: /proc/psinfo: EINVAL

inode->i_mode 就是通过 mknod() 设置的 mode。信息中的 XXX 和你设置的 S_IFPROC 有关。通过此值可以了解 mknod() 工作是否正常。这些信息说明内核在对 psinfo 进行读操作时不能正确处理，向 cat 返回了 EINVAL 错误。因为还没有实现处理函数，所以这是很正常的。

这些信息至少说明，psinfo 被正确 open() 了。所以我们不需要对 sys_open() 动任何手脚，唯一要打补丁的，是 sys_read()。

4.5 让 proc 文件可读

open() 没有变化，那么需要修改的就是 sys_read() 了。

首先分析 sys_read（在文件 fs/read_write.c 中）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


int sys_read(unsigned int fd,char * buf,int count)
{
    struct file * file;
    struct m_inode * inode;
//    ……
    inode = file->f_inode;
    if (inode->i_pipe)
        return (file->f_mode&1)?read_pipe(inode,buf,count):-EIO;
    if (S_ISCHR(inode->i_mode))
        return rw_char(READ,inode->i_zone[0],buf,count,&file->f_pos);
    if (S_ISBLK(inode->i_mode))
        return block_read(inode->i_zone[0],&file->f_pos,buf,count);
    if (S_ISDIR(inode->i_mode) || S_ISREG(inode->i_mode)) {
        if (count+file->f_pos > inode->i_size)
            count = inode->i_size - file->f_pos;
        if (count<=0)
            return 0;
        return file_read(inode,file,buf,count);
    }

    printk("(Read)inode->i_mode=%06o\n\r",inode->i_mode);    //这条信息很面善吧？
    return -EINVAL;
}

显然，要在这里一群 if 的排比中，加上 S_IFPROC() 的分支，进入对 proc 文件的处理函数。需要传给处理函数的参数包括：

inode->i_zone[0]，这就是 mknod() 时指定的 dev ——设备编号
buf，指向用户空间，就是 read() 的第二个参数，用来接收数据
count，就是 read() 的第三个参数，说明 buf 指向的缓冲区大小
&file->f_pos，f_pos 是上一次读文件结束时“文件位置指针”的指向。这里必须传指针，因为处理函数需要根据传给 buf 的数据量修改 f_pos 的值。

4.6 proc 文件的处理函数

proc 文件的处理函数的功能是根据设备编号，把不同的内容写入到用户空间的 buf。写入的数据要从 f_pos 指向的位置开始，每次最多写 count 个字节，并根据实际写入的字节数调整 f_pos 的值，最后返回实际写入的字节数。当设备编号表明要读的是 psinfo 的内容时，就要按照 psinfo 的形式组织数据。

实现此函数可能要用到如下几个函数：

malloc() 函数
free() 函数

包含 linux/kernel.h 头文件后，就可以使用 malloc() 和 free() 函数。它们是可以被核心态代码调用的，唯一的限制是一次申请的内存大小不能超过一个页面。

4.7 实现 sprintf() 函数

Linux 0.11 没有 sprintf()，可以参考 printf() 自己实现一个。

可以借鉴如下代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <stdarg.h>
//……
int sprintf(char *buf, const char *fmt, ...)
{
    va_list args; int i;
    va_start(args, fmt);
    i=vsprintf(buf, fmt, args);
    va_end(args);
    return i;
}

4.8 cat 命令的实现

cat 是 Linux 下的一个常用命令，功能是将文件的内容打印到标准输出。

它核心实现大体如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <stdio.h>
#include <unistd.h>
int main(int argc, char* argv[])
{
    char buf[513] = {'\0'};
    int nread;

    int fd = open(argv[1], O_RDONLY, 0);
    while(nread = read(fd, buf, 512))
    {
        buf[nread] = '\0';
        puts(buf);
    }

    return 0;
}

4.9 psinfo 的内容

进程的信息就来源于内核全局结构数组 struct task_struct * task[NR_TASKS] 中，具体读取细节可参照 sched.c 中的函数 schedule()。

可以借鉴一下代码：

1
2
3
4


for(p = &LAST_TASK ; p > &FIRST_TASK ; --p)

if (*p)
   (*p)->counter = ((*p)->counter >> 1)+...;

4.10 hdinfo 的内容

硬盘总共有多少块，多少块空闲，有多少 inode 等信息都放在 super 块中，super 块可以通过 get_super() 函数获得。

其中的信息可以借鉴如下代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


struct super_block * sb;
sb = get_super(inode->i_dev);

struct buffer_head * bh;
total_blocks = sb->s_nzones;

for(i=0; is_zmap_blocks; i++)
{

    bh = sb->s_zmap[i];
    p=(char *)bh->b_data;
}

5.实验步骤

1.修改include/sys/stat.h文件

增加新文件类型，在此文件内新增proc文件的宏定义以及测试宏。

1
2
3
4
5
6
7
8
9


//已有的宏定义
#define S_IFMT 00170000 //文件类型(都是8进制表示)
#define S_IFREG 0100000	//普通文件
#define S_IFCHAR 0020000 //字符设备文件
#define S_ISREG(m)  (((m) & S_IFMT) == S_IFREG) //测试m是否是普通文件
#define S_ISCHAR(m) (((m) & S_IFMT) == S_IFCHAR) //测试m是否是字符设备文件
//proc文件的宏定义/宏函数
#define S_IFPROC 0030000
#define S_ISPROC(m) (((m) & S_IFMT) ==  S_IFPROC) //测试m是否是proc文件

截图如下：

2.修改namei.c文件

文件/proc/psinfo以及/proc/hdinfo索引节点需要通过mknod()系统调用建立，这里需要让它支持新的文件类型。可直接修改fs/namei.c文件中的sys_mknod()函数的一行代码，在其中增加关于proc文件系统的判断:

1
2
3
4
5
6


if (S_ISBLK(mode) || S_ISCHR(mode) || S_ISPROC(mode))
     inode->i_zone[0] = dev;
// 文件系统初始化
inode->i_mtime = inode->i_atime = CURRENT_TIME;
inode->i_dirt = 1;
bh = add_entry(dir,basename,namelen,&de);

截图如下：

3.修改init/main.c文件

main()函数在init后直接挂载了根文件系统，挂载之后就可以创建proc文件了，首先创建/proc文件目录，然后再建立该目录下的各个proc文件节点。在建立这些节点和目录时需要调用系统调用mkdir和mknod，因为初始化时在用户态了，所以不能直接调用，必须在初始化代码所在的文件中实现这两个系统调用的用户态接口。修改init/main.c，新增两个系统调用用户接口并接着修改init函数实现对其的调用：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


static inline _syscall0(int,fork)
static inline _syscall0(int,pause)
static inline _syscall1(int,setup,void *,BIOS)
static inline _syscall0(int,sync)
/*新增mkdir和mknode系统调用*/
_syscall2(int,mkdir,const char*,name,mode_t,mode)
_syscall3(int,mknod,const char *,filename,mode_t,mode,dev_t,dev)
    
//.......   
    
	setup((void *) &drive_info);
	(void) open("/dev/tty0",O_RDWR,0);
	(void) dup(0);
	(void) dup(0);
	mkdir("/proc",0755);
	mknod("/proc/psinfo",S_IFPROC|0444,0);
	mknod("/proc/hdinfo",S_IFPROC|0444,1);
	mknod("/proc/inodeinfo",S_IFPROC|0444,2);

截图如下：

mkdir()时mode参数的值可以是“0755”（rwxr-xr-x），表示只允许root用户改写此目录，其它人只能进入和读取此目录。

procfs是一个只读文件系统，所以用mknod()建立psinfo结点时，必须通过mode参数将其设为只读。建议使用S_IFPROC|0444做为mode值，表示这是一个proc文件，权限为0444（r–r–r–），对所有用户只读。

mknod()的第三个参数dev用来说明结点所代表的设备编号。对于procfs来说，此编号可以完全自定义。proc文件的处理函数将通过这个编号决定对应文件包含的信息是什么。例如，可以把0对应psinfo，1对应hdinfo，2对应inodeinfo。现在可以重新编译运行系统，使用ll /proc可观察到下面的结果：

这些信息说明内核在对 psinfo 进行读操作时不能正确处理，向 cat 返回了 EINVAL 错误。因为还没有实现处理函数，所以这是很正常的。这些信息至少说明，psinfo被正确open()了。所以我们不需要对sys_open()动任何手脚，唯一要打补丁的，是sys_read()。

4.修改fs/read_write.c文件

为了让proc文件可读，修改fs/read_write.c添加extern，表示proc_read函数是从外部调用的。

1
2


/*新增proc_read函数外部调用*/
extern int proc_read(int dev,unsigned long *pos,char* buf,int count);

截图如下：

然后在sys_read函数中仿照其他if语句，加上 S_IFPROC() 的分支，添加proc文件的proc_read()调用：

1
2
3
4
5
6
7


	if (inode->i_pipe)
		return (file->f_mode&1)?read_pipe(inode,buf,count):-EIO;
	/*新增proc_read调用*/
	if (S_ISPROC(inode->i_mode))
		return proc_read(inode->i_zone[0],&file->f_pos,buf,count);
	if (S_ISCHR(inode->i_mode))
		return rw_char(READ,inode->i_zone[0],buf,count,&file->f_pos);

截图如下：

需要传给处理函数的参数包括：

inode->i_zone[0]，这就是 mknod() 时指定的 dev ——设备编号
&file->f_pos，f_pos 是上一次读文件结束时“文件位置指针”的指向。这里必须传指针，因为处理函数需要根据传给 buf 的数据量修改 f_pos 的值。
buf，指向用户空间，用来接收数据
count，说明 buf 指向的缓冲区大小

5.新增/fs/proc.c文件

proc文件的处理函数的功能是根据设备编号，把不同的内容写入到用户空间的buf。写入的数据要从 f_pos 指向的位置开始，每次最多写count个字节，并根据实际写入的字节数调整 f_pos 的值，最后返回实际写入的字节数。当设备编号表明要读的是psinfo的内容时，就要按照 psinfo 的形式组织数据。在fs目录下新增proc.c文件，文件信息如下：

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124


#include <linux/kernel.h>
#include <linux/sched.h>
#include <asm/segment.h>
#include <linux/fs.h>
#include <stdarg.h>
#include <unistd.h>

#define set_bit(bitnr,addr) ({ \
register int __res ; \
__asm__("bt %2,%3;setb %%al":"=a" (__res):"a" (0),"r" (bitnr),"m" (*(addr))); \
__res; })

char proc_buf[4096] ={'\0'};

extern int vsprintf(char * buf, const char * fmt, va_list args);

//Linux0.11没有sprintf()，该函数是用于输出结果到字符串中的，所以就实现一个，这里是通过vsprintf()实现的。
int sprintf(char *buf, const char *fmt, ...)
{
	va_list args; int i;
	va_start(args, fmt);
	i=vsprintf(buf, fmt, args);
	va_end(args);
	return i;
}

int get_psinfo()
{
	int read = 0;
	read += sprintf(proc_buf+read,"%s","pid\tstate\tfather\tcounter\tstart_time\n");
	struct task_struct **p;
	for(p = &FIRST_TASK ; p <= &LAST_TASK ; ++p)
 	if (*p != NULL)
 	{
 		read += sprintf(proc_buf+read,"%d\t",(*p)->pid);
 		read += sprintf(proc_buf+read,"%d\t",(*p)->state);
 		read += sprintf(proc_buf+read,"%d\t",(*p)->father);
 		read += sprintf(proc_buf+read,"%d\t",(*p)->counter);
 		read += sprintf(proc_buf+read,"%d\n",(*p)->start_time);
 	}
 	return read;
}

/*
*  参考fs/super.c mount_root()函数
*/
int get_hdinfo()
{
	int read = 0;
	int i,used;
	struct super_block * sb;
	sb=get_super(0x301);  /*磁盘设备号 3*256+1*/
	/*Blocks信息*/
	read += sprintf(proc_buf+read,"Total blocks:%d\n",sb->s_nzones);
	used = 0;
	i=sb->s_nzones;
	while(--i >= 0)
	{
		if(set_bit(i&8191,sb->s_zmap[i>>13]->b_data))
			used++;
	}
	read += sprintf(proc_buf+read,"Used blocks:%d\n",used);
	read += sprintf(proc_buf+read,"Free blocks:%d\n",sb->s_nzones-used);
	/*Inodes 信息*/
	read += sprintf(proc_buf+read,"Total inodes:%d\n",sb->s_ninodes);
	used = 0;
	i=sb->s_ninodes+1;
	while(--i >= 0)
	{
		if(set_bit(i&8191,sb->s_imap[i>>13]->b_data))
			used++;
	}
	read += sprintf(proc_buf+read,"Used inodes:%d\n",used);
	read += sprintf(proc_buf+read,"Free inodes:%d\n",sb->s_ninodes-used);
 	return read;
}

int get_inodeinfo()
{
	int read = 0;
	int i;
	struct super_block * sb;
	struct m_inode *mi;
	sb=get_super(0x301);  /*磁盘设备号 3*256+1*/
	i=sb->s_ninodes+1;
	i=0;
	while(++i < sb->s_ninodes+1)
	{
		if(set_bit(i&8191,sb->s_imap[i>>13]->b_data))
		{
			mi = iget(0x301,i);
			read += sprintf(proc_buf+read,"inr:%d;zone[0]:%d\n",mi->i_num,mi->i_zone[0]);
			iput(mi);
		}
		if(read >= 4000) 
		{
			break;
		}
	}
 	return read;
}

int proc_read(int dev, unsigned long * pos, char * buf, int count)
{
	
 	int i;
	if(*pos % 1024 == 0)
	{
		if(dev == 0)
			get_psinfo();
		if(dev == 1)
			get_hdinfo();
		if(dev == 2)
			get_inodeinfo();
	}
 	for(i=0;i<count;i++)
 	{
 		if(proc_buf[i+ *pos ] == '\0')  
          break; 
 		put_fs_byte(proc_buf[i+ *pos],buf + i+ *pos);
 	}
 	*pos += i;
 	return i;
}

新增过程截图如下：

6.修改fs/Makefile文件

1
2
3
4
5
6
7
8


OBJS=	open.o read_write.o inode.o file_table.o buffer.o super.o \
	block_dev.o char_dev.o file_dev.o stat.o exec.o pipe.o namei.o \
	bitmap.o fcntl.o ioctl.o truncate.o proc.o
//......
### Dependencies:
proc.o : proc.c ../include/linux/kernel.h ../include/linux/sched.h \
  ../include/linux/head.h ../include/linux/fs.h ../include/sys/types.h \
  ../include/linux/mm.h ../include/signal.h ../include/asm/segment.h

截图如下：

7.运行验证

重新编译运行linux-0.11

查看psinfo(当前系统进程状态信息)和hdinfo(硬盘信息)的信息，发现符合预期。

回答问题

meminfo，可以获得内存相关信息，看那些程序占用内存较多，方便管理。
是变化前的，==在读取位置f_pos为0时才更新psinfo内容==。该inode对应的i_zone[0]依然存在。也就是说，只是从inode映射中取消映射该inode，但是实际上硬盘上的数据还在。

1.实验目的#

2.实验内容#

3.实验报告#

4.实验提示#

4.1 procfs 简介#

4.2 基本思路#

4.3 增加新文件类型#

4.4 让 mknod() 支持新的文件类型#

4.5 让 proc 文件可读#

4.6 proc 文件的处理函数#

4.7 实现 sprintf() 函数#

4.8 cat 命令的实现#

4.9 psinfo 的内容#

4.10 hdinfo 的内容#

5.实验步骤#

1.修改include/sys/stat.h文件#

2.修改namei.c文件#

3.修改init/main.c文件#

4.修改fs/read_write.c文件#

5.新增/fs/proc.c文件#

6.修改fs/Makefile文件#

7.运行验证#

回答问题#

1.实验目的

2.实验内容

3.实验报告

4.实验提示

4.1 procfs 简介

4.2 基本思路

4.3 增加新文件类型

4.4 让 mknod() 支持新的文件类型

4.5 让 proc 文件可读

4.6 proc 文件的处理函数

4.7 实现 sprintf() 函数

4.8 cat 命令的实现

4.9 psinfo 的内容

4.10 hdinfo 的内容

5.实验步骤

1.修改include/sys/stat.h文件

2.修改namei.c文件

3.修改init/main.c文件

4.修改fs/read_write.c文件

5.新增/fs/proc.c文件

6.修改fs/Makefile文件

7.运行验证

回答问题