Linux 内核学习笔记：进程 2 的创建及执行（第 3 部分） —— 重建 shell 进程

本文是上一博文 Linux 内核学习笔记：进程 2 的创建及执行（第 2 部分）续篇。

创建 update 进程

在上一博文 Linux 内核学习笔记：进程 2 的创建及执行（第 2 部分）中，我们提到在进程 2 刚开始执行时，进程 2 关闭了标准输入设备文件 /dev/tty0 并用 /etc/rc 文件代替之。现在是 /etc/rc 文件占据了进程描述符 task_struct 的 filp[20] 的第 1 项，即 0 项。

创建 update 进程

shell 程序开始执行后，要读取标准输入设备文件上的信息，即进程描述符的 filp[20] 的第 1 项。因为标准设备输入文件 /dev/tty0 已经被 /etc/rc 替换，所以 shell 程序开始读取 /etc/rc 文件内容。

/etc/rc 文件的内容可以通过运行 Linux 0.11 系统来得到： 

1
2
3
/etc/update &
echo "/dev/hd1" > /etc/mtab
ehco "OK. "

根据 /etc/rc 文件的第一条命令 /etc/update &，shell 程序先创建一个新进程。这个新进程的进程号是 3，任务号也是 3（之前已有进程 0、1、2）。创建完毕后，加载 update 程序，并最终将执行权转交给 update 进程，由它去执行。关于进程创建和程序加载，请参考之前博文：

update 进程作用

对于 update 进程，《Linux 内核设计的艺术》有一个简要的阐述：

update 进程有一项很重要的任务：将缓冲区中的数据同步到外设（软盘、硬盘等）上。由于主机与外设的数据交换速度远低于主机内部的数据处理速度，因此，当内核需要往外设上写数据的时候，为了提高系统的整体执行效率，并不把数据直接写入外设上，而是先写入缓冲区，之后，根据实际情况，再将数据从缓冲区同步到外设。

每个一段时间，update 进程就会被唤醒，把数据往外设上同步一次，之后这个进程会被挂起，即被设置为可中断等待状态，等待着下一次被唤醒后继续执行，如此周而复始。

updata 进程执行后，并没有同步任务，于是该进程被挂起，系统进行调度，最终切换到 shell 进程执行。

此时，各进程状态如下图所示：
图片来源：《Linux 内核设计的艺术》

切换到 shell 进程（原进程 2）

shell 程序读取 /etc/rc 文件的第一条命令并创建 update 进程后，开始读取并处理该文件的第二条命令 echo "/dev/hd1" > /etc/mtab，即将字符串 “/dev/hd1” 写入虚拟盘中的 /etc/mtab 文件。执行完毕后，shell 程序会继续循环调用 read 函数读取 /etc/rc 文件上的内容。read 函数对应的系统调用函数是 sys_read。

由于 /etc/rc 是普通文件，读取结束后，read 函数返回 -ERROR。这个返回值将导致 shell 进程退出。退出将执行 exit 函数： 

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
// init/main.c ---------------------------------
void init(void)
{
	int pid,i;
	
	......
	if (!(pid=fork())) {
		......
		execve("/bin/sh",argv_rc,envp_rc);
		_exit(2);
	}
	......
}

// lib/_exit.c --------------------------------
volatile void _exit(int exit_code)
{
	__asm__("int $0x80"::"a" (__NR_exit),"b" (exit_code));
}

// kernel/exit.c ------------------------------
int sys_exit(int error_code)
{
	return do_exit((error_code&0xff)<<8);
}

int do_exit(long code)
{
	int i;

	free_page_tables(get_base(current->ldt[1]),get_limit(0x0f));
	free_page_tables(get_base(current->ldt[2]),get_limit(0x17));
	for (i=0 ; i<NR_TASKS ; i++)
		if (task[i] && task[i]->father == current->pid) {
			task[i]->father = 1;	// 将该进程的子进程的父进程设为进程 1
			if (task[i]->state == TASK_ZOMBIE)	// 如果该进程的子进程状态为 TASK_ZOMBIE
				/* assumption task[1] is always init */
				(void) send_sig(SIGCHLD, task[1], 1);	// 向进程 1 发送子进程终止信号 SIGCHLD
		}
	for (i=0 ; i<NR_OPEN ; i++)
		if (current->filp[i])
			sys_close(i);
	iput(current->pwd);	// 释放该 i 节点（只是 inode->i_count--）。对于 inode_table[32] 而言，每次打开的文件的 i 节点
				// 信息都要存放在 inode_table[32] 中。当 inode->i_count = 0 的时候，该 i 节点所在 inode_table[32] 的
				// 位置就空出来，可以给其他文件的 i 节点使用
	current->pwd=NULL;
	iput(current->root);
	current->root=NULL;
	iput(current->executable);
	current->executable=NULL;
	if (current->leader && current->tty >= 0)
		tty_table[current->tty].pgrp = 0;
	if (last_task_used_math == current)
		last_task_used_math = NULL;
	if (current->leader)
		kill_session();
	current->state = TASK_ZOMBIE;	// 将该进程状态设置为 TASK_ZOMBIE
	current->exit_code = code;
	tell_father(current->father);	// 给父进程发信号，说自己即将退出
	schedule();		// 任务调度
	return (-1);	/* just to suppress warnings */
}

static void tell_father(int pid)
{
	int i;

	if (pid)
		for (i=0;i<NR_TASKS;i++) {
			if (!task[i])
				continue;
			if (task[i]->pid != pid)
				continue;
			task[i]->signal |= (1<<(SIGCHLD-1));
			return;
		}
/* if we don't find any fathers, we just release ourselves */
/* This is not really OK. Must change it to make father 1 */
	printk("BAD BAD - no father found\n\r");
	release(current);
}

// 向指定任务（*p）发送信号（sig），权限为 priv
static inline int send_sig(long sig,struct task_struct * p,int priv)
{
	if (!p || sig<1 || sig>32)
		return -EINVAL;
	// 若有权或进程有效用户标识符（euid）就是指定进程的 euid 或者是超级用户，则在进程位图中添加该
	// 信号，否则出错退出。其中 suser() 定义为 （current->euid == 0)，用于判断是否是超级用户
	if (priv || (current->euid==p->euid) || suser())
		p->signal |= (1<<(sig-1));
	else
		return -EPERM;
	return 0;
}

任务调度

tell_father 函数执行完毕后，开始执行 schedule 函数，进行任务调度。此时，各进程状态如下图所示：
图片来源：《Linux 内核设计的艺术》

虽然没有进程处于就绪态，但 schedule 函数对信号的检测，影响到了进程切换： 

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
// kernel/sched.c -----------------------------
void schedule(void)
{
	int i,next,c;
	struct task_struct ** p;

/* check alarm, wake up any interruptible tasks that have got a signal */

	for(p = &LAST_TASK ; p > &FIRST_TASK ; --p)
		if (*p) {
			if ((*p)->alarm && (*p)->alarm < jiffies) {
					(*p)->signal |= (1<<(SIGALRM-1));
					(*p)->alarm = 0;
				}
			if (((*p)->signal & ~(_BLOCKABLE & (*p)->blocked)) &&
			(*p)->state==TASK_INTERRUPTIBLE)	// 发现进程 1 接收到了信号并且处于可中断等待状态
				(*p)->state=TASK_RUNNING;	// 将进程 1 设置为就绪态
		}

/* this is the scheduler proper: */

	while (1) {
		c = -1;
		next = 0;
		i = NR_TASKS;
		p = &task[NR_TASKS];
		while (--i) {
			if (!*--p)
				continue;
			if ((*p)->state == TASK_RUNNING && (*p)->counter > c)
				c = (*p)->counter, next = i;	// 发现只有进程 1 处于就绪态
		}
		if (c) break;
		for(p = &LAST_TASK ; p > &FIRST_TASK ; --p)
			if (*p)
				(*p)->counter = ((*p)->counter >> 1) +
						(*p)->priority;
	}
	switch_to(next);	// 切换到进程 1 执行
}

处理僵死子进程

之前从进程 1 切换到进程 2 是在执行 sys_waitpid 时，调用 schedule 函数实现的。所以从进程 2 切换回进程 1 后，会继续执行 schdule 函数，并最终回到 sys_waitpid 函数：

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
// kernel/exit.c ------------------------------
int sys_waitpid(pid_t pid,unsigned long * stat_addr, int options)
{
	int flag, code;
	struct task_struct ** p;

	verify_area(stat_addr,4);
repeat:
	flag=0;
	// #define FIRST_TASK task[0]
	// #define LAST_TASK task[NR_TASKS-1]
	for(p = &LAST_TASK ; p > &FIRST_TASK ; --p) {
		......
	}

	if (flag) {
		if (options & WNOHANG)
			return 0;
		current->state=TASK_INTERRUPTIBLE;
		schedule();	// 执行完毕后回到 sys_waitpid

		// 检测到 SIGCHLD 信号，确定有子进程要退出
		if (!(current->signal &= ~(1<<(SIGCHLD-1))))
			goto repeat;	// 重新处理子进程问题
		else
			return -EINTR;
	}
	return -ECHILD;
}

回到 repeat 处继续执行后，对僵死的进程 2 进行处理： 

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
// kernel/exit.c ------------------------------
int sys_waitpid(pid_t pid,unsigned long * stat_addr, int options)
{
	int flag, code;
	struct task_struct ** p;

	verify_area(stat_addr,4);
repeat:
	flag=0;
	// #define FIRST_TASK task[0]
	// #define LAST_TASK task[NR_TASKS-1]
	for(p = &LAST_TASK ; p > &FIRST_TASK ; --p) {
		if (!*p || *p == current)
			continue;
		if ((*p)->father != current->pid)	// 筛选出当前进程的子进程，此时子进程是进程 2
			continue;
		......

		// 判断子进程的状态并进行处理
		switch ((*p)->state) {
			......
			case TASK_ZOMBIE:
				current->cutime += (*p)->utime;
				current->cstime += (*p)->stime;
				flag = (*p)->pid;
				code = (*p)->exit_code;
				release(*p);
				put_fs_long(code,stat_addr);
				return flag;	// 此时 flag = 2
			......
		}
	}

	......
}

跳出循环

进程 1 中，sys_waitpid 函数返回的值为 2，也即 wait 函数要返回的值为 2。而进程 2 的进程号 pid = 2，所以返回 init 函数后就跳出 while 循环： 

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
// init/main.c ---------------------------------
void init(void)
{
	int pid,i;
	
	......
	if (pid>0)
		while (pid != wait(&i))	// 2 != 2 为假
			/* nothing */;
	while (1) {		// 重启 shell 进程
		if ((pid=fork())<0) {
			printf("Fork failed in init\r\n");
			continue;
		}
		if (!pid) {
			close(0);close(1);close(2);
			setsid();
			(void) open("/dev/tty0",O_RDWR,0);
			(void) dup(0);
			(void) dup(0);
			_exit(execve("/bin/sh",argv,envp));
		}
		while (1)
			if (pid == wait(&i))
				break;
		printf("\n\rchild %d died with code %04x\n\r",pid,i);
		sync();
	}
	_exit(0);	/* NOTE! _exit, not exit() */
}

重建 shell 进程

进程 1 接着执行，重建 shell 进程： 

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
// init/main.c ---------------------------------
void init(void)
{
	int pid,i;
	
	......
	if (pid>0)
		while (pid != wait(&i))	// 2 != 2 为假
			/* nothing */;
	while (1) {		// 重启 shell 进程
		if ((pid=fork())<0) {	// 进程 1 创建进程 4，即重建 shell 进程
			printf("Fork failed in init\r\n");
			continue;
		}
		if (!pid) {
			close(0);close(1);close(2);	// 新的 shell 进程关闭所有打开的文件
			setsid();	// 创建新的会话
			(void) open("/dev/tty0",O_RDWR,0);	// 重新打开标准输入设备文件
			(void) dup(0);	// 重新打开标准输出设备文件
			(void) dup(0);	// 重新打开标准错误输出设备文件
			_exit(execve("/bin/sh",argv,envp));	// 加载 shell 进程
		}
		while (1)
			if (pid == wait(&i))	// 进程 1 等待子进程退出。在这里，子进程是 shell 进程。只要 shell 进程不退出，while(1) 循环就一直继续。
				break;
		printf("\n\rchild %d died with code %04x\n\r",pid,i);
		sync();
	}
	_exit(0);	/* NOTE! _exit, not exit() */
}

轮转到新的进程 shell 进程执行时，shell 程序重新打开标准输入设备文件 /dev/tty0 （之前是 /etc/rc），这使得 shell 程序开始执行后，不再退出。并通过调用 rw_char 函数将 shell 进程的状态设置为可中断等待状态。这样所有的进程都处于可中断等待状态，系统再次切换到进程 0 去执行，系统实现怠速。

按《Linux 内核设计的艺术》的说法：

怠速以后，操作系统用户将通过 shell 进程提供的平台与计算机进行交互。shell 进程处理用户指令的工作原理如下：用户通过键盘输入信息，存储在指定的字符缓冲队列上。该缓冲队列上的内容，就是 tty0 文件的内容。shell 进程会不断读取缓冲队列上的信息。如果用户没有下达指令，缓冲队列就不会有数据，shell 进程将会被设置为可中断等待状态，即被挂起。如果用户通过键盘下达指令，将产生键盘中断，中断服务程序会将字符信息存储在缓冲队列上，并给 shell 进程发信号，信号将导致 shell 进程被设置为就绪态，即被唤醒。唤醒后的 shell 进程继续从缓冲队列中读取信息并处理。处理完毕后，shell 进程将再次被挂起，等待下一次键盘中断被唤醒。

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

谢宏峰，毕业于暨南大学（2009 - 2013）、中国科学院（2013 - 2016），现就职于深信服科技，从事 OpenStack 开发。