操作系统原理与实践10--proc文件系统实现

proc文件系统的实现

难度系数：★★★☆☆

实验目的

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

实验内容

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

# 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文件内。

实验报告

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

评分标准

自动创建/proc, /proc/psinfo;/proc/hdinfo;/proc/inodeinfo，20%
psinfo内容可读，内容符合题目要求，40%
hdinfo内容可读，符合题目要求，30%
实验报告，10%

实验提示

procfs简介

正式的Linux内核实现了procfs，它是一个虚拟文件系统，通常被mount到/proc目录上，通过虚拟文件和虚拟目录的方式提供访问系统参数的机会，所以有人称它为“了解系统信息的一个窗口”。这些虚拟的文件和目录并没有真实地存在在磁盘上，而是内核中各种数据的一种直观表示。虽然是虚拟的，但它们都可以通过标准的系统调用（open()、read()等）访问。

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

$ 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
基本思路

Linux是通过文件系统接口实现procfs，并在启动时自动将其mount到/proc目录上。此目录下的所有内容都是随着系统的运行自动建立、删除和更新的，而且它们完全存在于内存中，不占用任何外存空间。

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

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

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

#define S_IFMT  00170000
#define S_IFREG  0100000    //普通文件
#define S_IFBLK  0060000    //块设备
#define S_IFDIR  0040000    //目录
#define S_IFCHR  0020000    //字符设备
#define S_IFIFO  0010000
……

#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)    //测试m是否是块设备
#define S_ISFIFO(m)     (((m) & S_IFMT) == S_IFIFO)

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

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

定义一个测试宏S_ISPROC(m)，形式仿照其它的S_ISXXX(m)

注意，C语言中以“0”直接接数字的常数是八进制数。
让mknod()支持新的文件类型

psinfo结点要通过mknod()系统调用建立，所以要让它支持新的文件类型。直接修改fs/namei.c文件中的sys_mknod()函数中的一行代码，如下：

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

内核初始化的全部工作是在main()中完成，而main()在最后从内核态切换到用户态，并调用init()。init()做的第一件事情就是挂载根文件系统：

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

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

建立/proc目录；

建立/proc目录下的各个结点。本实验只建立/proc/psinfo。

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

#include
#define __LIBRARY__
#include

_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”可以看到：

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

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

# 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()。

让proc文件可读

open()没有变化，那么需要修改的就是sys_read()了。首先分析sys_read（在文件fs/read_write.c中）：

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的值。

proc文件的处理函数

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

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

malloc()和free()

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

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

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

cat命令

cat是Linux下的一个常用命令，功能是将文件的内容打印到标准输出。它核心实现大体如下：

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

psinfo的内容

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

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

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

hdinfo的内容

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

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;

实验报告：

一、文件视图的分析

Linux0.11系统中很重要的一个就是将外设均虚拟化为文件访问，通过统一的文件视图接口来实现所有外设的访问，包括硬盘的读写，键盘及打印机等的使用，均使用统一的文件视图接口来完成。这样如果有新的设备添加进来，那么访问的新外设的方法也是统一的。这些可以通过下面对文件视图的代码分析清楚地了解。

1、实验分析及实现代码

对设备进行读写均通过open函数来完成，包括对显示的输出。系统提供了一个sys_open()函数来完成。其代码如下：

int sys_open(const char * filename,int flag,int mode)
{
struct m_inode * inode;
struct file * f;
int i,fd;

mode &= 0777 & ~current->umask;
for(fd=0 ; fd<NR_OPEN ; fd++)
if (!current->filp[fd])
break;
if (fd>=NR_OPEN)
return -EINVAL;
current->close_on_exec &= ~(1<<fd);
f=0+file_table;
for (i=0 ; i<NR_FILE ; i++,f++)
if (!f->f_count) break;
if (i>=NR_FILE)
return -EINVAL;
(current->filp[fd]=f)->f_count++;
if ((i=open_namei(filename,flag,mode,&inode))<0) {
current->filp[fd]=NULL;
f->f_count=0;
return i;
}
/* ttys are somewhat special (ttyxx major==4, tty major==5) */
//如果是字符设备，则对tty设备进行处理，
if (S_ISCHR(inode->i_mode)) {
if (MAJOR(inode->i_zone[0])==4) {
if (current->leader && current->tty<0) {
current->tty = MINOR(inode->i_zone[0]);
tty_table[current->tty].pgrp = current->pgrp;
}
} else if (MAJOR(inode->i_zone[0])==5)
if (current->tty<0) {
iput(inode);
current->filp[fd]=NULL;
f->f_count=0;
return -EPERM;
}
}
/* Likewise with block-devices: check for floppy_change */
//如果是块设备，则交由块设备处理函数进行相应处理
if (S_ISBLK(inode->i_mode))
check_disk_change(inode->i_zone[0]);
f->f_mode = inode->i_mode;
f->f_flags = flag;
f->f_count = 1;
f->f_inode = inode;
f->f_pos = 0;
return (fd);
}

对所有设备进行访问之前均需要进行open操作，比如，在系统初始化时对终端设备的操作(void) open("/dev/tty0",O_RDWR,0); //打开终端

所以对内存文件的操作也一样如此进行，只要程序在打开文件时可以找到相应的INODE节点就可以进行文件打开操作。所以对此次实验而言，只要可以正确创建inode节点，就可以正确打开文件。所以要对创建节点的函数进行修正已支持新的内存文件类型。由于内存文件中在系统启动时自动添加的，所以还要在系统初始化硬盘后对内存文件的目录节点以及实现了的内存文件进行相应的添加，这个可以通过在根节点下添加一个proc子节点来实现，并且在新的子节点下新建两个已实现的内存文件：psinfo及hdinfo以显示进程和硬盘的信息。但打开后对文件的读操作（内存文件不能进行写操作）却要进行相应修正，因为我们的文件不是存在于硬盘上，而是在内存中生成的，所以要相应修改sys_read操作。当然，在读取inode节点时要对节点的类型进行判断并正确处理，所以也要对namei函数进行相应修正，添加我们的proc文件类型。所以要对stat.h文件中的文件类型进行添加以保证可以顺利读取内存类型文件。这样当系统打开一个内存文件时，会转到内存文件的处理函数中进行相应处理。

\\include\sys\stat.h
#define S_IFMT  00170000
#define S_IFREG  0100000
#define S_IFBLK  0060000
#define S_IFDIR  0040000
/*添加的内存文件类型*/
#define S_IFPROC 0030000
/*添加完毕*/
#define S_IFCHR  0020000
#define S_IFIFO  0010000
#define S_ISUID  0004000
#define S_ISGID  0002000
#define S_ISVTX  0001000

#define S_ISREG(m)    (((m) & S_IFMT) == S_IFREG)
#define S_ISDIR(m)    (((m) & S_IFMT) == S_IFDIR)
/*添加的内存文件类型判断*/
#define S_ISPROC(m)     (((m) & S_IFMT) == S_IFPROC)
/*添加完毕*/
#define S_ISCHR(m)    (((m) & S_IFMT) == S_IFCHR)
#define S_ISBLK(m)    (((m) & S_IFMT) == S_IFBLK)
#define S_ISFIFO(m)    (((m) & S_IFMT) == S_IFIFO)

\\fs\read_write.c
/*修改读文件函数，添加内存文件的读取流程*/
int sys_read(unsigned int fd,char * buf,int count)
{
struct file * file;
struct m_inode * inode;

if (fd>=NR_OPEN || count<0 || !(file=current->filp[fd]))
return -EINVAL;
if (!count)
return 0;
verify_area(buf,count);
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);
}
/*如果是内存文件，则调用内存文件读取函数*/
if(S_ISPROC(inode->i_mode))
return proc_read(inode->i_zone[0],&file->f_pos,buf,count);
/*添加完毕*/
printk("(Read)inode->i_mode=%06o\n\r",inode->i_mode);
return -EINVAL;
}

\\fs\proc_dev.c
/*添加的对内存文件进行处理的函数*/
/*
* linux/fs/proc_dev.c
* 2015-10-22 melon add for procs system
*/

#include <errno.h>

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

/*
#include <stddef.h>
#include <linux/kernel.h>
*/
extern int vsprintf(char * buf, const char * fmt, va_list args);

/*static char psbuf[2048];*/
/*
* sprintk for print the info for psinfo
*/
int sprintk(char * buf, const char *fmt, ...)
{
va_list args;
int i;

va_start(args, fmt);
i=vsprintf(buf,fmt,args);
va_end(args);
return i;
}

/*
* psinfo  to show the info of process
*/
int psinfo(unsigned long * pos, char * buf, int count)
{
struct task_struct ** p;
int output_count=0;
char * psbuf=NULL;
int chars=0;
int offset=*pos;

if((psbuf=(char *)malloc(sizeof(char *)*1024))==NULL)
{
printk("psinfo - malloc error!\n");
return -EINVAL;
}

chars=sprintk(psbuf,"pid\tstate\tfather\tcounter\tstart_time\n");

for(p = &LAST_TASK ; p >= &FIRST_TASK ; --p)
{
if(*p)
{
chars+=sprintk(psbuf+chars,"%d\t%d\t%d\t%d\t%d\n",(*p)->pid,(*p)->state,(*p)->father,(*p)->counter,(*p)->start_time);
}
}

*(psbuf+chars)='\0';

while(count>0)
{
if(offset>chars)
{
break;
}

put_fs_byte(*(psbuf+offset),buf++);
offset++;
output_count++;
count--;

}

(*pos)+=output_count;

free(psbuf);
return output_count;
}

int hdinfo(unsigned long * pos, char * buf, int count)
{
struct super_block * sb;
struct buffer_head * bh;
int total_blocks;
int total_inodes;
int used_blocks=0;
int free_blocks=0;
int i,j,z;
char * p=NULL;

int chars=0;
int offset=*pos;
int output_count=0;
char * hdbuf=NULL;

sb=get_super(current->root->i_dev);
total_blocks = sb->s_nzones;
total_inodes=sb->s_ninodes;
for(i=0;i<sb->s_zmap_blocks;i++)
{
bh=sb->s_zmap[i];
p=(char*)bh->b_data;
for(j=0;j<1024;j++)
{
for(z=1;z<=8;z++)
{
if((used_blocks+free_blocks)>=total_blocks)
break;
if( *(p+j) & z)
used_blocks++;
else
free_blocks++;
}
}
}

hdbuf=(char*)malloc(sizeof(char*)*512);
chars=sprintk(hdbuf,"s_imap_blocks:%d\ns_zmap_blocks:%d\n",sb->s_imap_blocks,sb->s_zmap_blocks);
chars+=sprintk(hdbuf+chars,"total_blocks:%d\nfree_blcoks:%d\nused_blocks:%d\ntotal_indoes:%d\n",total_blocks,free_blocks,used_blocks,total_inodes);
//*(hduf+chars)='\n';

while(count>0)
{
if(offset>chars)
break;

put_fs_byte(*(hdbuf+offset),buf++);
offset++;
output_count++;
count--;
}

(*pos)+=output_count;
free(hdbuf);
return output_count;

}

int proc_read(int dev, unsigned long * pos, char * buf, int count)
{
if(dev==0)
{
return psinfo(pos,buf,count);
}
if(dev==1)
{
return hdinfo(pos,buf,count);
}

return 0;
}

\\添加了新的文件后要相应修改Makefile文件将新文件添加到内核

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_dev.o

### Dependencies:
bitmap.o: bitmap.c ../include/string.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/linux/kernel.h
block_dev.o: block_dev.c ../include/errno.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/linux/kernel.h \
../include/asm/segment.h ../include/asm/system.h
proc_dev.o: proc_dev.c ../include/errno.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/linux/kernel.h \
../include/asm/segment.h ../include/asm/system.h ../include/stdarg.h

\\在系统初始化时创建新的节点以及两个内存文件
\\init\main.c
\*由于要在main文件中使用创建节点的函数，所以在这里也要添加对mkdir以及mknod的引用*\
_syscall2(int,mkdir,const char*, name,mode_t,mode)
_syscall3(int,mknod,const char*,filename,mode_t,mode,dev_t,dev)

\\init\main.c\main

setup((void *) &drive_info); //初始化磁盘工作
/*在根节点下创建一个新的子节点，并新建两个内存文件*/
mkdir("proc",0755);
mknod("/proc/psinfo",S_IFPROC|0444,0);
mknod("/proc/hdinfo",S_IFPROC|0444,1);
/*melon - 2015-10-22*/
(void) open("/dev/tty0",O_RDWR,0);  //打开终端

至此就完成此次实验。

2、实验截图







3、实验中的难点

此次实验难度并不算高，只要了解了文件视图的工作流程和实现原理，完成此次实验并不困难。在实验过程中，遇到的问题主要在于对硬盘信息的读取上。硬盘信息在系统mount_root时已经进行了挂载，所以该硬盘的super_block已经保存在系统中，直接调用就可以了。但这里一定要清楚知道文件系统的实现方式，比如minix1.0文件系统由如下信息组成：

|启动区|超级块|inode节点位图|zblock节点位图|inode节点数据区|文件数据区|

而系统中super_block结构中已经记录了相应的信息，同时也保存着缓冲区对应的指针信息。如znone位图的缓冲区指针以及inode位图的缓冲区指针，通过对这些指针的操作就可以取得相应的硬盘信息。

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

如果要求你在psinfo之外再实现另一个结点，具体内容自选，那么你会实现一个给出什么信息的结点？为什么？

如果再实现另一个结点，我想会选内存使用的信息情况，因为内存是整个系统中最重要的资源，系统的运行要靠内存的支持，能及时了解内存的使用情况是有意义的。

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

按照目前的实现方法，如果在几次read之间进程状态发生变化，后几次传递给用户的是变化后的信息，那么可能会导致信息混乱。如果要防止混乱发生，可以考虑将取到的进程信息保存在硬盘的一个文件中，读取时只要该文件存在，就从文件中直接读取，而不是每次read都重新生成进程信息，而一次读动作完成后（返回0）就将硬盘上的文件删除。这样下次再时再次生成文件。这样可以保证传递的数据是一致的。