操作系统实验一到实验九合集(哈工大李治军)（三）

实验七 地址映射与共享

实验目的

深入理解操作系统的段、页式内存管理，深入理解段表、页表、逻辑地址、线性地址、物理地址等概念；

实践段、页式内存管理的地址映射过程；

编程实现段、页式内存管理上的内存共享，从而深入理解操作系统的内存管理。

实验内容

用 Bochs 调试工具跟踪 Linux 0.11 的地址翻译（地址映射）过程，了解 IA-32 和 Linux 0.11 的内存管理机制；

在 Ubuntu 上编写多进程的生产者—消费者程序，用共享内存做缓冲区；

在信号量实验的基础上，为 Linux 0.11 增加共享内存功能，并将生产者—消费者程序移植到 Linux 0.11。

1 跟踪地址翻译过程

首先以汇编级调试的方式启动 Bochs，引导 Linux 0.11，在 0.11 下编译和运行 test.c。它是一个无限循环的程序，永远不会主动退出。然后在调试器中通过查看各项系统参数，从逻辑地址、LDT 表、GDT 表、线性地址到页表，计算出变量 i 的物理地址。最后通过直接修改物理内存的方式让 test.c 退出运行。

test.c 的代码如下：

#include <stdio.h>
int i = 0x12345678;
int main(void)
{
    printf("The logical/virtual address of i is 0x%08x", &i);
    fflush(stdout);
    while (i)
        ;
    return 0;
}

2 基于共享内存的生产者—消费者程序

本项实验在 Ubuntu 下完成，与信号量实验中的 pc.c 的功能要求基本一致，仅有两点不同：

不用文件做缓冲区，而是使用共享内存；

生产者和消费者分别是不同的程序。生产者是 producer.c，消费者是 consumer.c。两个程序都是单进程的，通过信号量和缓冲区进行通信。

Linux 下，可以通过 shmget() 和 shmat() 两个系统调用使用共享内存。

3 共享内存的实现

进程之间可以通过页共享进行通信，被共享的页叫做共享内存，结构如下图所示：

图 1 进程间共享内存的结构

本部分实验内容是在 Linux 0.11 上实现上述页面共享，并将上一部分实现的 producer.c 和 consumer.c 移植过来，验证页面共享的有效性。

具体要求在 mm/shm.c 中实现 shmget() 和 shmat() 两个系统调用。它们能支持 producer.c 和 consumer.c 的运行即可，不需要完整地实现 POSIX 所规定的功能。

shmget()

int shmget(key_t key, size_t size, int shmflg);

shmget() 会新建/打开一页内存，并返回该页共享内存的 shmid（该块共享内存在操作系统内部的 id）。

所有使用同一块共享内存的进程都要使用相同的 key 参数。

如果 key 所对应的共享内存已经建立，则直接返回 shmid。如果 size 超过一页内存的大小，返回 -1，并置 errno 为 EINVAL。如果系统无空闲内存，返回 -1，并置 errno 为 ENOMEM。

shmflg 参数可忽略。

shmat()

void *shmat(int shmid, const void *shmaddr, int shmflg);

shmat() 会将 shmid 指定的共享页面映射到当前进程的虚拟地址空间中，并将其首地址返回。

如果 shmid 非法，返回 -1，并置 errno 为 EINVAL。

shmaddr 和 shmflg 参数可忽略。

创建test.c

挂载hdc文件系统

切换到用户文件夹

编写 test.c

退出挂载

跟踪地址翻译过程

1.准备

./dbg-asm
c

在Bochs中编译运行 test.c

只要test.c不变，0x00003004这个值在任何人的机器上都是一样的。即使在同一个机器上多次运行test.c，也是一样的。

test.c是一个死循环，只会不停占用CPU，不会退出。

2.暂停

在命令行窗口按 Ctrl+c，Bochs 会暂停运行，进入调试状态

其中的 000f 如果是 0008，则说明中断在了内核里。那么就要 c，然后再 ctrl+c，直到变为 000f 为止。

如果显示的下一条指令不是 cmp ...（这里指语句以 cmp 开头），就用 n 命令单步运行几步，直到停在 cmp ...。

使用命令 u /8，显示从当前位置开始 8 条指令的反汇编代码，结构如下：

这就是 test.c 中从 while 开始一直到 return 的汇编代码。变量 i 保存在 ds:0x3004 这个地址，并不停地和 0 进行比较，直到它为 0，才会跳出循环。

现在，开始寻找 ds:0x3004 对应的物理地址。

3.段表

ds:0x3004 是虚拟地址，ds 表明这个地址属于 ds 段。首先要找到段表，然后通过 ds 的值在段表中找到 ds 段的具体信息，才能继续进行地址翻译。

每个在 IA-32 上运行的应用程序都有一个段表，叫 LDT，段的信息叫段描述符。

LDT 在哪里呢？ldtr 寄存器是线索的起点，通过它可以在 GDT（全局描述符表）中找到 LDT 的物理地址。

用 sreg 命令（是在调试窗口输入）：

可以看到 ldtr 的值是 0x0068=0000000001101000（二进制），表示 LDT 表存放在 GDT 表的 1101（二进制）=13（十进制）号位置（每位数据的意义参考后文叙述的段选择子）。

而 GDT 的位置已经由 gdtr 明确给出，在物理地址的 0x00005cb8。

用 xp /32w 0x00005cb8 查看从该地址开始，32 个字的内容，及 GDT 表的前 16 项，如下：

GDT 表中的每一项占 64 位（8 个字节），所以我们要查找的项的地址是 0x00005cb8+13*8。

输入 xp /2w 0x00005cb8+13*8，得到：

“0x52d00068 0x000082fd” 将其中的加粗数字组合为“0x00faa2d0”，这就是 LDT 表的物理地址（为什么这么组合，参考后文介绍的段描述符）。

xp /8w 0x00fd52d0，得到：

4.段描述符

在保护模式下，段寄存器有另一个名字，叫段选择子，因为它保存的信息主要是该段在段表里索引值，用这个索引值可以从段表中“选择”出相应的段描述符。

先看看 ds 选择子的内容，还是用 sreg 命令：

可以看到，ds 的值是 0x0017。段选择子是一个 16 位寄存器，它各位的含义如下图：

其中 RPL 是请求特权级，当访问一个段时，处理器要检查 RPL 和 CPL（放在 cs 的位 0 和位 1 中，用来表示当前代码的特权级），即使程序有足够的特权级（CPL）来访问一个段，但如果 RPL（如放在 ds 中，表示请求数据段）的特权级不足，则仍然不能访问，即如果 RPL 的数值大于 CPL（数值越大，权限越小），则用 RPL 的值覆盖 CPL 的值。

而段选择子中的 TI 是表指示标记，如果 TI=0，则表示段描述符（段的详细信息）在 GDT（全局描述符表）中，即去 GDT 中去查；而 TI=1，则去 LDT（局部描述符表）中去查。

看看上面的 ds，0x0017=0000000000010111（二进制），所以 RPL=11，可见是在最低的特权级（因为在应用程序中执行），TI=1，表示查找 LDT 表，索引值为 10（二进制）= 2（十进制），表示找 LDT 表中的第 3 个段描述符（从 0 开始编号）。

LDT 和 GDT 的结构一样，每项占 8 个字节。所以第 3 项 0x00003fff 0x10c0f300（上一步骤的最后一个输出结果中） 就是搜寻好久的 ds 的段描述符了。

用 sreg 输出中 ds 所在行的 dl 和 dh 值可以验证找到的描述符是否正确。

接下来看看段描述符里面放置的是什么内容：

可以看到，段描述符是一个 64 位二进制的数，存放了段基址和段限长等重要的数据。其中位 P（Present）是段是否存在的标记；位 S 用来表示是系统段描述符（S=0）还是代码或数据段描述符（S=1）；四位 TYPE 用来表示段的类型，如数据段、代码段、可读、可写等；DPL 是段的权限，和 CPL、RPL 对应使用；位 G 是粒度，G=0 表示段限长以位为单位，G=1 表示段限长以 4KB 为单位；其他内容就不详细解释了。

5.段基址和线性地址

组合规则见段描述符结构：其实就是将基地址进行组合

费了很大的劲，实际上我们需要的只有段基址一项数据，即段描述符 “0x00003fff 0x10c0f300” 中加粗部分组合成的 “0x10000000”。这就是 ds 段在线性地址空间中的起始地址。用同样的方法也可以算算其它段的基址，都是这个数。

段基址+段内偏移，就是线性地址了。所以 ds:0x3004 的线性地址就是：

0x10000000 + 0x3004 = 0x10003004

用 calc ds:0x3004 命令可以验证这个结果。

6.页表

从线性地址计算物理地址，需要查找页表。线性地址变成物理地址的过程如下：

首先需要算出线性地址中的页目录号、页表号和页内偏移，它们分别对应了 32 位线性地址的 10 位 + 10 位 + 12 位，所以 0x10003004 的页目录号是 64，页号 3，页内偏移是 4。

IA-32 下，页目录表的位置由 CR3 寄存器指引。“creg”命令可以看到：

说明页目录表的基址为 0。看看其内容，“xp /68w 0”：

页目录表和页表中的内容很简单，是 1024 个 32 位（正好是 4K）数。这 32 位中前 20 位是物理页框号，后面是一些属性信息（其中最重要的是最后一位 P）。其中第 65 个页目录项就是我们要找的内容，用“xp /w 0+64*4”查看：

这就是我们要找的页目录表

里面的内容是 0x00fa6027

具体分析一下里面的结构

页表所在的物理页框号为0x00fa6，即页表在物理内存为0x00fa6000处，从该位置开始查找3号页表项(每个页表项4个字节)，用命令:xp /w 0x00fa6000 + 3*4

7.物理地址

页表里所显示的即线性地址 0x10003004 对应的物理页框号为 0x00fa5，和页内偏移 0x004 连接在一起，得到 0x00fa5004，这就是变量 i 的物理地址。

可以用两种方法验证：

第一种方法是用命令 page 0x10003004

第二种方法是用命令 xp /w 0x00fa5004

现在，通过直接修改内存来改变 i 的值为 0，命令是： setpmem 0x00fa5004 4 0，表示从 0x00fa5004 地址开始的 4 个字节都设为 0。然后再用“c”命令继续 Bochs 的运行，可以看到 test 退出了，说明 i 的修改成功了，此项实验结束。

添加系统调用号

目录 oslab/linux-0.11/include

在 unistd.h 中添加下面代码

然后增加两个系统调用号

添加系统调用的定义

文件位置oslab/linux0.11/include/linux/sys.h

增加函数声明

改写系统调用数

文件位置：oslab/linux0.11/kernel/system_call.s

编写 shm.c

文件位置：oslab/linux0.11/kernel/shm.s

#define __LIBRARY__
#include <unistd.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/mm.h>
#include <errno.h>
static shm_ds shm_list[SHM_SIZE] = {{0, 0, 0}};
int sys_shmget(unsigned int key, size_t size)
{
    int i;
    unsigned long page;
    /* If the size exceeds the size of one page of memory */
    if (size > PAGE_SIZE)
    {
        printk("shmget: size %u cannot be greater than the page size %ud. \n", size, PAGE_SIZE);
        return -ENOMEM;
    }
    if (key == 0)
    {
        printk("shmget: key cannot be 0.\n");
        return -EINVAL;
    }
    for (i = 0; i < SHM_SIZE; i++)
    {
        if (shm_list[i].key == key)
        {
            return i;
        }
    }
    page = get_free_page();
    if (!page)
    {
        return -ENOMEM;
    }
    printk("shmget get memory's address is 0x%08x\n", page);
    for (i = 0; i < SHM_SIZE; i++)
    {
        if (shm_list[i].key == 0)
        {
            shm_list[i].key = 0;
            shm_list[i].size = size;
            shm_list[i].page = page;
            return i;
        }
    }
    return -1;
}
void *sys_shmat(int shmid)
{
    unsigned long data_base, brk;
    if (shmid < 0 || SHM_SIZE <= shmid || shm_list[shmid].page == 0 || shm_list[shmid].key <= 0)
    {
        return (void *)-EINVAL;
    }
    data_base = get_base(current->ldt[2]);
    printk("current's data_base = 0x%08x,new page = 0x%08x\n", data_base, shm_list[shmid].page);
    brk = current->brk + data_base;
    current->brk += PAGE_SIZE;
    if (put_page(shm_list[shmid].page, brk) == 0)
    {
        return (void *)-ENOMEM;
    }
    return (void *)(current->brk - PAGE_SIZE);
}

brk指针在哪里？可以参考下图。我们可以发现 brk 指针正好指向堆区顶部，我们可以利用这个指针帮我们定位需要申请的空间首地址。

在进程PCB当中记录了brk指针的 逻辑地址，然后加上进程开始处的虚拟地址就可以得到brk指针的虚拟地址或者叫线性地址（虚拟地址=段基址+逻辑地址）

修改工程文件的编译规则

文件位置：oslab/linux0.11/kernel/Makefile

进入主文件开始编译，编译完成。

编写消费者和生产者程序

sudo ./mount-hdc
cd /oslab/hdc/usr/root
vi producer.c
vi consumer.c
sudo umount hdc/

编写producer.c

/*producer.c*/
#define   __LIBRARY__
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <linux/sem.h>
_syscall2(sem_t*,sem_open,const char *,name,unsigned int,value);
_syscall1(int,sem_wait,sem_t*,sem);
_syscall1(int,sem_post,sem_t*,sem);
_syscall1(int,sem_unlink,const char *,name);
_syscall1(void*,shmat,int,shmid);
_syscall2(int,shmget,int,key,int,size);
/*_syscall1(int,shmget,char*,name);*/
#define NUMBER 520 /*打出数字总数*/
#define BUFSIZE 10 /*缓冲区大小*/
sem_t   *empty, *full, *mutex;
int main()
{
    int  i,shmid;
    int *p;
    int  buf_in = 0; /*写入缓冲区位置*/
    /*打开信号量*/
    if((mutex = sem_open("mutex",1)) == NULL)
    {
        perror("sem_open() error!\n");
        return -1;
    }
    if((empty = sem_open("empty",10)) == NULL)
    {
        perror("sem_open() error!\n");
        return -1;
    }
    if((full = sem_open("full",0)) == NULL)
    {
        perror("sem_open() error!\n");
        return -1;
    }
    /*shmid = shmget("buffer");*/
  shmid = shmget(1234, BUFSIZE);
  printf("shmid:%d\n",shmid);
    if(shmid == -1)
    {
        return -1;
    }
    p = (int*) shmat(shmid);
    /*生产者进程*/
  printf("producer start.\n");
  fflush(stdout);
    for( i = 0 ; i < NUMBER; i++)
    {
        sem_wait(empty);
        sem_wait(mutex);
        p[buf_in] = i;
        buf_in = ( buf_in + 1)% BUFSIZE;
        sem_post(mutex);
        sem_post(full);
    }
  printf("producer end.\n");
  fflush(stdout);
    /*释放信号量*/
    sem_unlink("full");
    sem_unlink("empty");
    sem_unlink("mutex");
    return 0;
}

编写consumer.c

/*consumer.c*/
#define   __LIBRARY__
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <linux/sem.h>
_syscall2(sem_t*,sem_open,const char *,name,unsigned int,value);
_syscall1(int,sem_wait,sem_t*,sem);
_syscall1(int,sem_post,sem_t*,sem);
_syscall1(int,sem_unlink,const char *,name);
_syscall1(void*,shmat,int,shmid);
_syscall2(int,shmget,int,key,int,size);
#define NUMBER 520 /*打出数字总数*/
#define BUFSIZE 10 /*缓冲区大小*/
sem_t  *empty, *full, *mutex;
int main()
{
    int  i,shmid,data;
    int *p;
    int  buf_out = 0; /*从缓冲区读取位置*/
    /*打开信号量*/
    if((mutex = sem_open("mutex",1)) == NULL)
    {
        perror("sem_open() error!\n");
        return -1;
    }
    if((empty = sem_open("empty",10)) == NULL)
    {
        perror("sem_open() error!\n");
        return -1;
    }
    if((full = sem_open("full",0)) == NULL)
    {
        perror("sem_open() error!\n");
        return -1;
    }
  printf("consumer start.\n");
    fflush(stdout);
    /*shmid = shmget("buffer");*/
  shmid = shmget(1234, BUFSIZE);
  printf("shmid:%d\n",shmid);
  if(shmid == -1)
    {
        return -1;
    }
    p = (int *)shmat(shmid);
    for( i = 0; i < NUMBER; i++ )
    {
        sem_wait(full);
        sem_wait(mutex);
        data = p[buf_out];
        buf_out = (buf_out + 1) % BUFSIZE;
        sem_post(mutex);
        sem_post(empty);
        /*消费资源*/
        printf("%d:  %d\n",getpid(),data);
        fflush(stdout);
    }
    printf("consumer end.\n");
    fflush(stdout);
    /*释放信号量*/
    sem_unlink("full");
    sem_unlink("empty");
    sem_unlink("mutex");
    return 0;
}

运行验证

报错原因找了好久，感觉该干的事情都干了。最后看到这篇文章添加了__NR_whoami编译还是不行，才恍然大悟。

将已经修改的 unistd.h 拷贝到linux-0.11系统中

sudo ./mount-hdc 
cp ./linux-0.11/include/unistd.h ./hdc/usr/include/
sudo umount hdc/

开始正式运行程序：

gcc -o producer producer.c
gcc -o consumer consumer.c
./producer > p.txt &
./consumer > c.txt

这个不影响。直接关闭虚拟机，挂载后查看 p.txt 和 c.txt

😉 实验成功!

天道酬勤

看到一条弹幕：“能看到这里的人，真的很不容易。”，我想，能写到这里的人，也很不容易。支持我到现在的动力，也许是因为我真的想学一些所谓无用的东西，无用之用，方为大用。就我个人而言，学到现在也没有学到什么特别具体的东西，手写OS只是妄想，甚至改改代码也要依靠别人的代码。但对我而言，我十分感谢这段痛苦的漫长的经历，它告诉我，写一个花哨的网页，跑一段机器学习，深度学习的代码，可能很酷，但其实只是虚假繁荣。我缺乏沉下心来做一件无趣的事情的能力。也就是所谓的坐得住的能力。通过这几个月的实验，我感觉自己越来越坚定了，知道自己想要做什么，我走了一条自己认为对的路，我不后悔。

实验八 终端设备的控制

实验目的

加深对操作系统设备管理基本原理的认识，实践键盘中断、扫描码等概念；

通过实践掌握 Linux 0.11 对键盘终端和显示器终端的处理过程。

实验内容

本实验的基本内容是修改 Linux 0.11 的终端设备处理代码，对键盘输入和字符显示进行非常规的控制。

在初始状态，一切如常。用户按一次 F12 后，把应用程序向终端输出所有字母都替换为“*”。用户再按一次 F12，又恢复正常。第三次按 F12，再进行输出替换。依此类推。

以 ls 命令为例：

正常情况：

# ls
hello.c hello.o hello

第一次按 F12，然后输入 ls：

# **
*****.* *****.* *****

第二次按 F12，然后输入 ls：

# ls
hello.c hello.o hello

第三次按 F12，然后输入 ls：

# **
*****.* *****.* *****

实验思路

这里列出其他博主的博客————参考博客

键盘中断初始化

键盘中断的初始化在boot/main.c文件的init()函数中，在这个函数中会调用tty_init()函数对显卡的变量等进行设置（如：video_size_row，vide_mem_start，video_port_reg，video_port_val，video_mem_end等等），并对键盘中断0x21设置，将中断过程指向keyboard_interrupt函数（这是通过set_trap_gate(0x21, &keyboard_interrupt)语句来实现的。

键盘中断发生

当键盘中断发生时，intb $0x60,%al 指令会取出键盘的扫描码，放在al寄存器中，然后查key_table表进行扫描码处理，key_table表中定义了相关所有扫描码对应键的处理函数(如do_self，func，alt，ctrl，none等)，比如f1-f12键的处理则要先运行一段处理函数func，调用sched.c中定义的show_stat函数显示当前进程情况，默认情况linux-0.11中所有的功能键都进行这样的动作，然后下一步将控制键以及功能键进行转义，比如ctrl_a将会被转义为^a，f1会被转义为esc[[A，f2被转义为esc[[B，而其他键也经过类似处理，处理完毕后将跳到put_queue，将扫描码放在键盘输入队列中，当然如果没有对应的扫描码被找到，则会通过none标签直接退回，不会被放入队列。然后再调用do_tty_interrupt函数进行最后的处理。do_tty_interrupt直接调用copy_to_cooked函数对队列中的字符进行判断处理，最后调用con_write函数将其输出到显卡内存。在此同时，也会将字符放入辅助队列中，以备缓冲区读写程序使用。

字符输出流程

无论是输出字符到屏幕上还是文件中，系统最终都会调用write函数来进行，而write函数则会调用sys_write系统调用来实现字符输出，如果是输出到屏幕上，则会调用tty_write函数，而tty_write最终也会调用con_write函数将字符输出；如果是输出到文件中，则会调用file_write函数直接将字符输出到指定的文件缓冲区中。所以无论是键盘输入的回显，还是程序的字符输出，那只需要修改con_write最终写到显存中的字符就可以了。但如果要控制字符输出到文件中，则需要修改file_write函数中输出到文件缓冲区中的字符即可。

读队列read_q 用于存放从键盘或串行终端输入的原始（raw）字符序列；写队列 write_q 用于存放写到控制台显示屏或串行终端去的数据；辅助队列 secondary 用于存放经过行规则程序处理（过滤）过的数据，或称为熟(cooked)模式数据。上层终端读函数tty_read用于读取secondary队列中的字符。

对于一个控制台，当用户在键盘上键入了一个字符时，会引起键盘中断响应（中断请求信号 IRQ1, 对应中断号 INT 33 ），此时键盘中断处理程序就会从键盘控制器读入对应的键盘扫描码，然后根据使用的键盘扫描码映射表译成相应字符，放入 tty 读队列 read_q中。然后调用中断处理程序的 C函数 do_tty_interrupt()，它又直接调用行规则函数 copy_to_cooked()对该字符进行过滤处理，并放入 tty 辅助队列 secondary 中，同时把该字符放入tty 写队列 write_q 中，并调用写控制台函数 con_write() 。此时如果该终端的回显（ echo ）属性是设置的，则该字符会显示到屏幕上。 do_tty_interrupt()和 copy_to_cooked()函数在tty_io.c中实现。

有关控制台终端操作的驱动程序，主要涉及两个程序。一个是键盘中断处理程序 keyboard.S ，主要用于读入用户键入的字符并放入 read_q缓冲队列中；另一个是屏幕显示处理程序 console.c，用于从 write_q队列中取出字符并显示在屏幕上。

添加F12功能键盘处理

文件位置 kernel/chr_drv/tty_io.c

文件末尾添加

文件位置 include/linux/tty.h

文件末尾添加

文件位置 kernel/chr_drv/keyboard.S

注意位置 525行注释掉，改成调用 press_f12_handle 函数

添加字符*显示处理

文件位置 linux-0.11/kernel/chr_drv/console.c

其实很简单，就是循环队列一个个取字符进行处理后放入显存

我们就在放入显存之前进行一次过滤，即 F12_flag == 1 时将字符转变为 *

编译运行

make all

run

😉 实验完成

实验问题

1.在原始代码中，按下F12，中断响应后，中断服务程序会调用func？它实现的是什么功能？

将F12转义成转义字符序列 [ [ L , 对F1-F12处理类似 [ [ A -> [ [ L

2.在你的实现中，是否把向文件输出的字符也过滤了？如果是，那么怎么能只过滤向终端输出的字符？如果不是，那么怎么能把向文件输出的字符也一并进行过滤？

没有把向文件输出的字符过滤，只过滤向终端输出的字符是通过con_write函数的修改来实现的。过滤向文件输出的字符则通过修改file_write函数来实现。

天道酬勤

这次实验十分简单，一个多小时就完成了。主要就是要捋顺文件之间的逻辑。

实验九 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 文件内。

procfs介绍

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

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

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

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

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

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

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

增加新文件类型

文件位置：include/sys/stat.h

#define S_IFPROC 0030000
#define S_ISPROC(m) (((m) & S_IFMT) ==  S_IFPROC)

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

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

if (S_ISBLK(mode) || S_ISCHR(mode) || S_ISPROC(mode))
     inode->i_zone[0] = dev;

procfs 的初始化工作

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

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

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

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

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

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

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

文件目录：init/main.c

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

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

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

让 proc 文件可读

文件位置：fs/read_write.c

添加extern，表示proc_read函数是从外部调用的

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

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

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 ——设备编号

buf，指向用户空间，就是 read() 的第二个参数，用来接收数据

count，就是 read() 的第三个参数，说明 buf 指向的缓冲区大小

&file->f_pos，f_pos 是上一次读文件结束时“文件位置指针”的指向。这里必须传指针，因为处理函数需要根据传给 buf 的数据量修改 f_pos 的值。

实现 proc_read 函数

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

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

malloc() 函数

free() 函数

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

文件位置：fs/proc.c

代码来自一位大佬的博客————参考代码

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

同时修改fs/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.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

编译运行

再次重新编译内核make all，然后运行内核，查看psinfo(当前系统进程状态信息)和hdinfo(硬盘信息)的信息：

天道酬勤

byez

终章

能看到这里的人，真的很不容易。只是起点，差的太多了，只能尽力而为。但行好事莫问前程！