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

知乎Markdown适配不可，希望在我的博客中检察文章

作者寄语

操纵系统尝试的进修是一个循序渐进的进程，初度看linux-0.11中的代码，看着满屏的汇编说话，确切头疼。但经过进修赵炯博士的Linux内核0.11完全正文，连系着王爽教员的汇编说话一书，我逐步了解每段汇编说话的寄义和感化。本文主如果经过对哈工大李治军配套尝试的实现，侧重诠释每一段的汇编代码，使读者对尝试的整体头绪有一个初步的熟悉，不再由于害怕汇编而不放弃尝试。本文只是举一反三，希望读者可以深入研讨我下文供给的参考材料，做到理论与理论兼具。

参考材料

• 视频:操纵系统
• 书籍:现代操纵系统
• 尝试:操纵系统道理与理论
• 书籍:霸道操纵系统
• 书籍:Linux内核完全正文
• 书籍:汇编说话(第3版) 王爽著

目录

[TOC]

尝试一 熟悉尝试情况

只是熟悉尝试情况，我没有益用蓝桥云课的尝试情况，而是经过阿里云办事器搭建了linux情况，有需要的可以看以下2篇文章

• 阿里云办事器Ubuntu14.04（64位）安装图形化界面_leoabcd12的博客-CSDN博客
• 阿里云ubuntu系统设置linux-0.11（哈工大 李治军）尝试情况搭建_leoabcd12的博客-CSDN博客

尝试二 操纵系统的指导

Linux 0.11 文件夹中的 boot/bootsect.s、boot/setup.s 和 tools/build.c 是本尝试会触及到的源文件。它们的功用详见《Linux内核0.11完全正文》的 6.2、6.3 节和 16 章。

汇编常识

简要整理了一下此次尝试所需的根本汇编常识，可以鄙人文阅读代码是碰到再回过甚来看！

int 0x10

留意，这里ah要先有值，代表内部子法式的编号

功用号 ah=0x03​​​，感化是读取光标的位置

• 输入：bh = 页号
• 返回：ch = 扫描起头线；cl = 扫描竣事线；dh = 行号；dl = 列号

功用号 ah=0x13，感化是显现字符串

• 输入：al = 放置光标的方式及规定属性，下文 al＝1，暗示方针字符串仅仅包括字符，属性在BL中包括，光标停在字符串结尾处；es:bp = 字符串肇端位置；cx = 显现的字符串字符数；bh = 页号；bl = 字符属性，下文 bl = 07H，暗示一般的黑底白字；dh = 行号；dl = 列号

功用号 ah=0x0e​，感化是显现字符

• 输入：al = 字符

int 0x13

在DOS等实形式操纵系统下，挪用INT 13h会跳转到计较机的ROM-BIOS代码中停止低级磁盘办事，对法式停止基于物理扇区的磁盘读写操纵。

功用号 ah=0x02，感化是读磁盘扇区到内存

• 输入：
  

• 返回：ah = 出错码（00H暗示无错，01H暗示不法号令，02H暗示地址方针未发现...）；CF为进位标志位，假如没有出错 CF=0​

功用号 ah=0x00​，感化是磁盘系统复位

• 输入：dl = 驱动器
• 返回：假如操纵成功———— CF=0​​，ah=00H​​

这里我只挑了下文需要的先容，更多内容可以参考这篇博客BIOS系统办事 —— 间接磁盘办事（int 0x13）

int 0x15

功用号 ah=0x88，感化是获得系统所含扩大内存巨细

• 输入：ah = 0x88
• 返回：ax = 从0x100000(1M)处起头的拓展内存巨细(KB)。若出错则CF置位，ax = 出错码。

int 0x41

在PC机中BIOS设定的中断向量表中int 0x41的中断向量位置 (4*0x41 = 0x0000:0x0104​​​)寄存的并不是中断法式的地址,而是第一个硬盘的根基参数表。对于100%兼容的BIOS来说,这里寄存着硬盘参数表阵列的首地址0xF000:0E401，第二个硬盘的根基参数表进口地址存于int 0x46中断向量位置处.每个硬盘参数表有16个字节巨细.

CF

方法会CF，首先要晓得寄存器中有一种特别的寄存器————标志寄存器，其中存储的信息凡是被称为法式状态字。以下简称为flag寄存器。

flag和其他寄存器纷歧样，其他寄存器是用来寄存数据的，都是全部寄存用具有一个寄义。而flag寄存器是按位起感化的，也就是说，它的每一位都有专门的寄义，记录特定的信息。

flag的1、3、5、12、13、14、15位在8086CPU中没有益用，不具有任何寄义。而0、2、4、6、7、8、9、10、11位都具有特别的寄义。

CF就是flag的第0位————进位标志位。在停止==无标记数==运算的时辰，它记录了运算成果的最高有用位向更高位的==进位值==，或从更高位的借位值。

jnc

在 CF=0​​​ 的时辰，停止跳转，即不进位则跳转，下文就是在读入没有出错时，跳转到ok_load_setup

jl

小于则跳转

lds

格式： LDS reg16，mem32

其意义是同时给一个段寄存器和一个16位通用寄存器同时赋值

举例：

可以把上述代码了解为这样一个进程，但现实上不能这么写

即把低字(2B)置为偏移地址，高字(2B)置为段地址

DF标志和串传送指令

flag的第10位是DF,偏向标志位。在串处置指令中，控制每次操纵后si、di的增减。

• df=0：每次操纵后si、di递增
• df=1：每次操纵后si、di递加

来看一个串传送指令

• 格式：movsb
• 功用：相当于履行了以下2步操纵
  

1. ((es)*16+(di))=((ds)*16+si)
2. 假如df=0：(si)=(si)+1,(di)=(di)+1
   假如df=1：(si)=(si)-1,(di)=(di)-1

可以看出，movsb的功用是将 ds:si 指向的内存单元中的字节送入 es:di中，然后按照标志寄存器df位的值，将si和di递增或递加。

也可以传送一个字

• 格式：movsw
• 功用：相当于履行了以下2步操纵
  

1. ((es)*16+(di))=((ds)*16+si)
2. 假如df=0：(si)=(si)+2,(di)=(di)+2
   假如df=1：(si)=(si)-2,(di)=(di)-2

可以看出，movsw的功用是将 ds:si 指向的内存单元中的字节送入 es:di​中，然后按照标志寄存器df位的值， 将si和di递增2或递加2。

movsb和movsw停止的是串传送操纵的一个步调，一般配合rep利用

格式以下：rep movsb

用汇编语法描写：

可见rep的感化是按照cx的值，反复履行串传送指令。由于每履行一次movsb指令si和di城市递增或递加指向前面一个单元或前面一个单元，则 rep movsb便可以循环实现(cx)个字符的传送。

call

(1) 将当前IP或CS和IP压入栈中

(2) 转移

CPU履行“call 标号”时，相当于停止：

ret

ret指令用栈中的数据，点窜IP的内容，从而实现近转移

(1) (IP)=((ss)*16+(sp))

(2) (sp)=(sp)+2​

CPU履行ret指令时，相当于停止：

改写bootsect.s

翻开 bootsect.s

Loading system ...就是开机时显现在屏幕上的字，共16字符，加上3个换行+回车，一共是24字符。我将要点窜他为 Hello OS world, my name is WCF，30字符，加上3个换行+回车，共36字符。所以图一代码点窜成mov cx.#36。

将 .org 508 点窜成 .org 510，是由于这里不需要 root_dev: .word ROOT_DEV，为了保证 boot_flag 一定在指导扇区最初两个字节，所以要点窜 .org。.org 510 暗示下面语句从地址510(0x1FE)起头，用来强迫要求boot_flag一定在指导扇区的最初2个字节中（第511和512字节）。

完整的代码以下：

Ubuntu 上先从终端进入 ~/oslab/linux-0.11/boot/目录

履行下面两个号令编译和链接 bootsect.s：

其中 bootsect.o 是中心文件。bootsect 是编译、链接后的方针文件。

需要留意的文件是 bootsect 的文件巨细是 544 字节，而指导法式必必要恰好占用一个磁盘扇区，即 512 个字节。形成多了 32 个字节的缘由是 ld86 发生的是 Minix 可履行文件格式，这样的可履行文件处置文本段、数据段等部分之外，还包括一个 Minix 可履行文件头部，它的结构以下：

6 char（6 字节）+ 1 short（2 字节） + 6 long（24 字节）= 32，恰好是 32 个字节，去掉这 32 个字节后便可以放入指导扇区了。

对于上面的 Minix 可履行文件，其 a_magic[0]=0x01，a_magic[1]=0x03，a_flags=0x10（可履行文件），a_cpu=0x04（暗示 Intel i8086/8088，假如是 0x17 则暗示 Sun 公司的 SPARC），所以 bootsect 文件的头几个字节应当是 01 03 10 04。为了考证一下，Ubuntu 下用号令hexdump -C bootsect可以看到：

去掉这 32 个字节的文件头部

天生的 Image 就是去掉文件头的 bootsect。

去掉这 32 个字节后，将天生的文件拷贝到 linux-0.11 目录下，并一定要命名为“Image”（留意巨细写）。然后就“run”吧！

bootsect.s读入setup.s

首先编写一个 setup.s，该 setup.s 可以就间接拷贝前面的 bootsect.s（还需要简单的调剂），然后将其中的显现的信息改成：“Now we are in SETUP”。

和前面根基一样，就不正文了。

接下来需要编写 bootsect.s 中载入 setup.s 的关键代码

一切需要的功用在原版 bootsect.s 中都是存在的，我们要做的仅仅是将这些代码增加到新的 bootsect.s 中去。

除了新增代码，我们还需要去掉在 bootsect.s 增加的无穷循环。

再次编译

有 Error！这是由于 make 按照 Makefile 的指引履行了 tools/build.c，它是为天生全部内核的镜像文件而设想的，没斟酌我们只需要 bootsect.s 和 setup.s 的情况。它在向我们要 “系统” 的焦点代码。为完成尝试，接下来给它打个小补钉。c

build.c 从号令行参数获得 bootsect、setup 和 system 内核的文件名，将三者做简单的整理后一路写入 Image。其中 system 是第三个参数（argv[3]）。当 “make all” 大概 “makeall” 的时辰，这个参数传过来的是正确的文件名，build.c 会翻开它，将内容写入 Image。而 “make BootImage” 时，传过来的是字符串 "none"。所以，革新 build.c 的思绪就是当 argv[3] 是"none"的时辰，只写 bootsect 和 setup，疏忽一切与 system 有关的工作，大概在该写 system 的位置都写上 “0”。

点窜工作首要集合在 build.c 的尾部，可长度以参考下面的方式，将圈起来的部分正文掉。

重新编译

setup.s获得根基硬件参数

这里把一些难以了解的代码零丁列出来

1. 获得磁盘参数

这里花了我很长时候，缘由是概念没有搞清楚，我感觉教员在尝试指导书上写的也不是很清楚，CSDN上都只是草草复制的代码，感受他们可以压根没有了解这一段。

先往返顾一下上文的一个概念：int 0x41

在PC机中BIOS设定的中断向量表中int 0x41的中断向量位置 (4*0x41 = 0x0000:0x0104​)寄存的并不是中断法式的地址,而是第一个硬盘的根基参数表。对于100%兼容的BIOS来说,==这里寄存着硬盘参数表阵列的首地址0xF000:0E401==，第二个硬盘的根基参数表进口地址存于int 0x46中断向量位置处.每个硬盘参数表有16个字节巨细.

这段话是重点，我之前误了解为磁盘参数就寄存在以0x0000:0x0104为首地址的单元中，总共占16个字节，但现实上，只存了4个字节，里面寄存的是磁盘参数表的偏移地址和段地址，也就是上文所说==这里寄存着硬盘参数表阵列的首地址0xF000:0E401==。

再看这行代码便可以了解了，这里是把0x0000:0x0104单元寄存的值（暗示硬盘参数表阵列的首地址的偏移地址）赋给si寄存器，把0x0000:0x0106单元寄存的值（暗示硬盘参数表阵列的首地址的段地址）赋给ds寄存器。

1. 参数以十六进制方式显现

先说说浪费我很长时候的我的毛病：我想的是一个ASCII码8位，为什么答案里是4位4位输出，这里是搞清楚显现的目标。显现的是存在内存单元里的16进制数，例如某个字(2个字节)中的数值为 019A​，我所要显现的不是01和9A暗示的ASCII码，而是显现019A自己，所以要4位4位显现。

以十六进制方式显现比力简单。这是由于十六进制与二进制有很好的对应关系（每 4 位二进制数和 1 位十六进制数存在逐一对应关系），显现时只需将原二进制数每 4 位划成一组，按组求对应的 ASCII 码送显现器即可。ASCII 码与十六进制数字的对应关系为：0x30 ～ 0x39 对应数字 0 ～ 9，0x41 ～ 0x46 对应数字 a ～ f。从数字 9 到 a，其 ASCII 码间隔了 7h，这一点在转换时要出格留意。为使一个十六进制数能按高位到低位依次显现，现实编程中，需对 bx 中的数每次循环左移一组（4 位二进制），然后屏障掉当前高 12 位，对当前余下的 4 位（即 1 位十六进制数）求其 ASCII 码，要判定它是 0 ～ 9 还是 a ～ f，是前者则加 0x30 得对应的 ASCII 码，后者则要加 0x37 才行，最初送显现器输出。以上步调反复 4 次，便可以完成 bx 中数以 4 位十六进制的形式显现出来。

下面是供给的参考代码

经过冗长的调试，获得以下成果

Memory Size 是 0x3C00KB，算一算恰好是 15MB（扩大内存），加上 1MB 恰好是 16MB，看看 Bochs 设置文件 bochs/bochsrc.bxrc：

这些都和上面打出的参数符合，暗示此次尝试是成功的。

天道酬勤

尝试二总共花费25小时，由于没有汇编根本，花费了大量时候在了解代码上，希望下面的尝试可以越做越快吧。

尝试三 系统挪用

提醒

此次尝试触及的宏过于复杂，加上本人才能有限，我也没有花大量时候去研讨每一段代码，只是了解到每一段代码做了什么这一水平。

尝试目标

此次尝试的根基内容是：在 Linux 0.11 上增加两个系统挪用，并编写两个简单的利用法式测试它们。

1. iam()
   第一个系统挪用是 iam()，其原型为：
   int iam(const char * name);
   
   完成的功用是将字符串参数 name 的内容拷贝到内核中保存下来。要求 name 的长度不能跨越 23 个字符。返回值是拷贝的字符数。假如 name 的字符个数跨越了 23，则返回 “-1”，并置 errno 为 EINVAL。
2. whoami()
   第二个系统挪用是 whoami()，其原型为：
   int whoami(char* name, unsigned int size);
   
   它将内核中由 iam() 保存的名字拷贝到 name 指向的用户地址空间中，同时确保不会对 name 越界访存（name 的巨细由 size 说明）。返回值是拷贝的字符数。假如 size 小于需要的空间，则返回“-1”，并置 errno 为 EINVAL。

利用法式若何挪用系统挪用

在凡是情况下，挪用系统挪用和挪用一个普通的自界说函数在代码上并没有什么区分，但挪用后发生的工作有很大分歧。

挪用自界说函数是经过 call 指令间接跳转到该函数的地址，继续运转。

而挪用系统挪用，是挪用系统库中为该系统挪用编写的一个接口函数，叫 API（APPlication Programming Interface）。API 并不能完成系统挪用的真正功用，它要做的是去挪用实在的系统挪用，进程是：

• 把系统挪用的编号存入 EAX；
• 把函数参数存入别的通用寄存器；
• 触发 0x80 号中断（int 0x80）。

linux-0.11 的 lib 目录下有一些已经实现的 API。Linus 编写它们的缘由是在内核加载终了后，会切换到用户形式下，做一些初始化工作，然后启动 shell。而用户形式下的很多工作需要依靠一些系统挪用才能完成，是以在内核中实现了这些系统挪用的 API。

我们无妨看看 lib/close.c，研讨一下 close() 的 API：

其中 _syscall1 是一个宏，在 include/unistd.h 中界说。

将 _syscall1(int,close,int,fd) 停止宏展开，可以获得：

这就是 API 的界说。它先将宏 __NR_close 存入 EAX，将参数 fd 存入 EBX，然落后行 0x80 中断挪用。挪用返回后，从 EAX 取出返回值，存入 __res，再经过对 __res 的判定决议传给 API 的挪用者什么样的返回值。

其中 __NR_close 就是系统挪用的编号，在 include/unistd.h 中界说：

在 0.11 情况下编译 C 法式，包括的头文件都在 /usr/include 目录下。

该目录下的 unistd.h 是标准头文件（它和 0.11 源码树中的 unistd.h 并不是同一个文件，虽然内容能够不异），没有 __NR_whoami 和 __NR_iam 两个宏，需要手工加上它们，也可以间接从修悔改的 0.11 源码树中拷贝新的 unistd.h 过来。

从“int 0x80”进入内核函数

int 0x80 触发后，接下来就是内核的中断处置了。先领会一下 0.11 处置 0x80 号中断的进程。

在内核初始化时，主函数在 init/main.c 中，挪用了 sched_init() 初始化函数：

sched_init() 在 kernel/sched.c 中界说为：

set_system_gate 是个宏，在 include/asm/system.h 中界说为：

_set_gate 的界说是：

虽然看起来挺麻烦，但现实上很简单，就是填写 IDT（中断描写符表），将 system_call 函数地址写到 0x80 对应的中断描写符中，也就是在中断 0x80 发生后，自动挪用函数 system_call。

接下来看 system_call。该函数纯汇编打造，界说在 kernel/system_call.s 中：

system_call 用 .globl 修饰为其他函数可见。

call sys_call_table(,%eax,4) 之前是一些压栈庇护，点窜段挑选子为内核段，call sys_call_table(,%eax,4) 以后是看看能否需要重新调剂，这些都与本尝试没有间接关系，此处只关心 call sys_call_table(,%eax,4) 这一句。

按照汇编寻址方式它现实上是：call sys_call_table + 4 * %eax，其中 eax 中放的是系统挪用号，即 __NR_xxxxxx。

明显，sys_call_table 一定是一个函数指针数组的肇端地址，它界说在 include/linux/sys.h 中：

增加尝试要求的系统挪用，需要在这个函数表中增加两个函数援用 ——sys_iam 和 sys_whoami。固然该函数在 sys_call_table 数组中的位置必须和 __NR_xxxxxx 的值对应上。

同时还要模仿此文件中前面各个系统挪用的写法，加上：

否则，编译会出错的。

实现 sys_iam() 和 sys_whoami()

增加系统挪用的最初一步，是在内核中实现函数 sys_iam() 和 sys_whoami()。

每个系统挪用都有一个 sys_xxxxxx() 与之对应，它们都是我们进修和模仿的好工具。

比如在 fs/open.c 中的 sys_close(int fd)：

它没有什么特此外，都是实实在在地做 close() 该做的工作。

所以只要自己建立一个文件：kernel/who.c，然后实现两个函数就高枕无忧了。

依照上述逻辑点窜响应文件

经过上文描写，我们已司理清楚了要点窜的地方在那里

1. 增加iam和whoami系统挪用编号的宏界说(_NR_xxxxxx)，文件：include/unistd.h
   

1. 点窜系统挪用总数, 文件：kernel/system_call.s
   

1. 为新增的系统挪用增加系统挪用名并保护系统挪用表，文件：include/linux/sys.h
   

1. 为新增的系统挪用编写代码实现，在linux-0.11/kernel目录下，建立一个文件 who.c
   #include <asm/segment.h>#include <errno.h>#include <string.h>char _myname[24];int sys_iam(const char *name){ char str[25]; int i = 0; do { // get char from user input str[i] = get_fs_byte(name + i); } while (i <= 25 && str[i++] != '\0'); if (i > 24) { errno = EINVAL; i = -1; } else { // copy from user mode to kernel mode strcpy(_myname, str); } return i;}int sys_whoami(char *name, unsigned int size){ int length = strlen(_myname); printk("%s\n", _myname); if (size < length) { errno = EINVAL; length = -1; } else { int i = 0; for (i = 0; i < length; i++) { // copy from kernel mode to user mode put_fs_byte(_myname[i], name + i); } } return length;}
   

点窜 Makefile

要想让我们增加的 kernel/who.c 可以和别的 Linux 代码编译链接到一路，必必要点窜 Makefile 文件。

Makefile 里记录的是一切源法式文件的编译、链接法则，《正文》3.6 节有简单先容。我们之所以简单地运转 make 便可以编译全部代码树，是由于 make 完全依照 Makefile 里的指示工作。

Makefile 在代码树中有很多，别离负责分歧模块的编译工作。我们要点窜的是 kernel/Makefile。需要点窜两处。

（1）第一处

改成：

增加了 who.o。

（2）第二处

改成：

增加了 who.s who.o: who.c ../include/linux/kernel.h ../include/unistd.h。

Makefile 点窜后，战争常一样 make all 就能自动把 who.c 加入到内核中了。

编写测试法式

到此为止，内核中需要点窜的部分已经完成，接下来需要编写测试法式来考证新增的系统挪用能否已经被编译到linux-0.11内核可供挪用。首先在oslab目录下编写iam.c，whoami.c

以上两个文件需要放到启动后的linux-0.11操纵系统上运转，考证新增的系统挪用能否有用，那若何才能将这两个文件从宿主机转到稍后虚拟机中启动的linux-0.11操纵系统上呢？这里我们采用挂载方式实现宿主机与虚拟机操纵系统的文件同享，在 oslab 目录下履行以下号令挂载hdc目录到虚拟机操纵系统上。

再经过以下号令将上述两个文件拷贝到虚拟机linux-0.11操纵系统/usr/root/目录下，号令在oslab/目录下履行：

假如方针目录下存在对应的两个文件则可启动虚拟机停止测试了。

• 编译
  [/usr/root]# gcc -o iam iam.c
  [/usr/root]# gcc -o whoami whoami.c
  
• 运转测试
  [/usr/root]# ./iam wcf
  [/usr/root]# ./whoami
  

号令履行后，极能够会报以下毛病：

这代表==虚拟机==操纵系统中/usr/include/unistd.h文件中没有新增的系统挪用挪用号

为新增系统挪用设备挪用号

再次履行：

尝试成功

• 为什么这里会打印2次？
• 由于在系统内核中履行了 printk() 函数，在用户形式下又履行了一次 printf() 函数。

要晓得到，printf() 是一个只能在用户形式下履行的函数，而系统挪用是在内核形式中运转，所以 printf() 不成用，要用 printk()。

printk() 和 printf() 的接口和功用基底细同，只是代码上有一点点分歧。printk() 需要出格处置一下 fs 寄存器，它是公用于用户形式的段寄存器。

天道酬勤

尝试三总共花费7小时，看的不是出格仔细，没有出格深入的进修宏展开和内联汇编。但根基了解了系统挪用的目标和方式，Linus永久的神！

尝试四 进程运转轨迹的跟踪与统计

尝试目标

• 把握 Linux 下的多进程编程技术；
• 经过对进程运转轨迹的跟踪来形象化进程的概念；
• 在进程运转轨迹跟踪的根本上停止响应的数据统计，从而能对进程调剂算法停止现实的量化评价，更进一步加深对换剂和调剂算法的了解，获得能在现实操纵系统上对换剂算法停止尝试数据对照的间接经历。

尝试内容

进程从建立（Linux 下挪用 fork()）到竣事的全部进程就是进程的生命期，进程在其生命期中的运转轨迹现实上就表示为进程状态的屡次切换，如进程建立今后会成为停当态；当该进程被调剂今后会切换到运转态；在运转的进程中假如启动了一个文件读写操纵，操纵系统会将该进程切换到阻塞态（期待态）从而让出 CPU；当文件读写终了今后，操纵系统会在将其切换成停当态，期待进程调剂算法来调剂该进程履行……

本次尝试包括以下内容：

• 基于模板 process.c 编写多进程的样本法式，实现以下功用： + 一切子进程都并交运转，每个子进程的现实运转时候一般不跨越 30 秒； + 父进程向标准输出打印一切子进程的 id，并在一切子进程都退出后才退出；
• 在 Linux0.11 上实现进程运转轨迹的跟踪。 + 根基使命是在内核中保护一个日志文件 /var/process.log，把从操纵系统启动到系统关机进程中一切进程的运转轨迹都记录在这一 log 文件中。
• 在修悔改的 0.11 上运转样本法式，经过度析 log 文件，统计该法式建立的一切进程的期待时候、完成时候（周转时候）和运转时候，然后计较均匀期待时候，均匀完成时候和吞吐量。可以自己编写统计法式停止统计。
• 点窜 0.11 进程调剂的时候片，然后再运转一样的样本法式，统计一样的时候数据，和原本的情况对照，体味分歧时候片带来的差别。

/var/process.log 文件的格式必须为：

其中：

• pid 是进程的 ID；
• X 可所以 N、J、R、W 和 E 中的肆意一个，别离暗示进程新建(N)、进入停当态(J)、进入运转态(R)、进入阻塞态(W) 和退出(E)；
• time 暗示 X 发生的时候。这个时候不是物理时候，而是系统的滴答时候(tick)；

三个字段之间用制表符分隔。例如：

编写process.c文件

提醒

在 Ubuntu 下，top 号令可以监视立即的进程状态。在 top 中，按 u，再输入你的用户名，可以限制只显现以你的身份运转的进程，更方便观察。按 h 可获得帮助。

在 Ubuntu 下，ps 号令可以显现那时各个进程的状态。ps aux 会显现一切进程；ps aux | grep xxxx 将只显现名为 xxxx 的进程。更具体的用法叨教 man。

在 Linux 0.11 下，按 F1 可以立即显现当前一切进程的状态。

文件首要感化

process.c文件首要实现了一个函数：

下面是 4 个利用的例子：

点窜此模板，用 fork() 建立多少个同时运转的子进程，父进程期待一切子进程退出后才退出，每个子进程依照你的志愿做分歧或不异的 cpuio_bound()，从而完成一个本性化的样本法式。

它可以用来检验有关 log 文件的点窜能否正确，同时还是数据统计工作的根本。

wait() 系统挪用可以让父进程期待子进程的退出。

关键函数诠释

fork()

这里摘录某位博主的详解操纵系统之 fork() 函数详解 - 简书 (jianshu.com)

fork（）函数经过系统挪用建立一个与本来进程几近完全不异的进程，也就是两个进程可以做完全不异的事，但假如初始参数大概传入的变量分歧，两个进程也可以做分歧的事。

一个进程挪用fork（）函数后，系统先给新的进程分派资本，例如存储数据和代码的空间。然后把本来的进程的一切值都复制到新的新进程中，只要少数值与本来的进程的值分歧。相当于克隆了一个自己。

运转成果：

在语句fpid=fork()之前，只要==一个==进程在履行这段代码，但在这条语句以后，就酿成==两个==进程在履行了，这两个进程的几近完全不异，将要履行的下一条语句都是==if(fpid<0)==

为什么两个进程的fpid分歧呢，这与fork函数的特征有关。fork挪用的一个奇妙之处就是它仅仅被挪用一次，却可以返回两次，它能够有三种分歧的返回值：
1）在父进程中，fork返回新建立子进程的进程ID；
2）在子进程中，fork返回0；
3）假如出现毛病，fork返回一个负值；

在fork函数履行终了后，假如建立新进程成功，则出现两个进程，一个是子进程，一个是父进程。在子进程中，fork函数返回0，在父进程中，fork返回新建立子进程的进程ID。我们可以经过fork返回的值来判定当进步程是子进程还是父进程。

援用一位网友的话来诠释fpid的值为什么在父子进程平分歧。“实在就相当于链表，进程构成了链表，父进程的fpid(p 意味point)指向子进程的进程id, 由于子进程没有子进程，所以其fpid为0.
　 fork出错能够有两种缘由：
　1）当前的进程数已经到达了系统规定的上限，这时errno的值被设备为EAGAIN。
　2）系统内存不敷，这时errno的值被设备为ENOMEM。
　建立新进程成功后，系统中出现两个根基完全不异的进程，这两个进程履行没有牢固的前后顺序，哪个进程先履行要看系统的进程调剂战略。
　每个进程都有一个怪异（互不不异）的进程标识符（process ID），可以经过getpid（）函数获得，还有一个记录父进程pid的变量，可以经过getppid（）函数获得变量的值。
　 fork履行终了后，出现两个进程

有人说两个进程的内容完全一样啊，怎样打印的成果纷歧样啊，那是由于判定条件的缘由，上面罗列的只是进程的代码和指令，还有变量啊。
　履行完fork后，进程1的变量为count=0，fpid！=0（父进程）。进程2的变量为count=0，fpid=0（子进程），这两个进程的变量都是自力的，存在分歧的地址中，不是共用的，这点要留意。可以说，我们就是经过fpid来识别和操纵父子进程的。
　还有人能够迷惑为什么不是从#include处起头复制代码的，这是由于fork是把进程当前的情况拷贝一份，履行fork时，进程已经履行完了int count=0;fork只拷贝下一个要履行的代码到新的进程。

struct tms 结构体

struct tms 结构体界说在 <sys/times.h> 头文件里，具体界说以下：

用户CPU时候和系统CPU时候之和为CPU时候，即号令占用CPU履行的时候总和。现实时候要大于CPU时候，由于Linux是多使命操纵系统，常常在履行一条号令时，系统还要处置其他使命。另一个需要留意的题目是即使每次履行不异的号令，所花费的时候也纷歧定不异，由于其花费的时候与系统运转相关。

数据范例 clock_t

关于该数据范例的界说以下：

clock_t 是一个长整型数。

在 time.h 文件中，还界说了一个常量 CLOCKS_PER_SEC ，它用来暗示一秒钟会有几多个时钟计时单元，其界说以下：

下文就模拟cpu操纵，界说 HZ=100​​，内核的标定时候是jiffy,一个jiffy就是一个内部时钟周期,而内部时钟周期是由100HZ的频次所发生中的,也就是一个时钟滴答,间隔时候是10毫秒(ms).计较出来的时候也并非实在时候，而是时钟滴答次数，乘以10ms可以获得实在的时候。

代码实现

下面给出代码：

答疑

:question: 为什么说它可以用来检验有关 log 文件的点窜能否正确，同时还是数据统计工作的根本？

• 每个子进程都经过 cpuio_bound 函数实现了占用CPU和I/O时候的操纵，而且可以切确的晓得每个操纵的时候。所以下面的 log 文件（日志文件）正确与否可以借此推算。

尽早翻开log文件

操纵系统启动后先要翻开 /var/process.log，然后在每个进程发生状态切换的时辰向 log 文件内写入一笔记录，其进程和用户态的利用法式没什么两样。但是，由于内核状态的存在，使进程中的很多细节变得完全纷歧样。

为了能尽夙起头记录，该当在内核启动时就翻开 log 文件。内核的进口是 init/main.c 中的 main()，其中一段代码是：

这段代码在进程 0 中运转，先切换到用户形式，然后全系统第一次挪用 fork() 建立进程 1。进程 1 挪用 init()。

在 init()中：

这段代码建立了文件描写符 0、1 和 2，它们别离就是 stdin、stdout 和 stderr。这三者的值是系统标准（Windows 也是如此），不成改变。

可以把 log 文件的描写符关联到 3。文件系统初始化，描写符 0、1 和 2 关联以后，才能翻开 log 文件，起头记录进程的运转轨迹。

为了能尽早拜候 log 文件，我们要让上述工作在进程 0 中就完成。所以把这一段代码从 init() 移动到 main() 中，放在 move_to_user_mode() 以后（不能再靠前了），同时加上翻开 log 文件的代码。

点窜后的 main() 以下：

翻开 log 文件的参数的寄义是建立只写文件，假如文件已存在则清空已有内容。文件的权限是一切人可读可写。

这样，文件描写符 0、1、2 和 3 就在进程 0 中建立了。按照 fork() 的道理，进程 1 会继续这些文件描写符，所以 init() 中就不必再 open() 它们。尔后一切新建的进程都是进程 1 的子孙，也会继续它们。但现实上，init() 的后续代码和 /bin/sh