Linux 内核学习笔记：进程 1 的创建及执行（第 1 部分） —— 进程派生

Linux 0.11 初始化好设备环境和激活进程 0 后就开始创建进程 1。接下来几篇博文将关注进程 1 的创建及执行。

注：比较完整的进程创建案例可参考《Linux 内核设计的艺术》（第 2 版）第 6.3 节“一个用户进程从创建到退出的完整过程”。这个小节写的相当不错！

调用 fork

进程 0 现在已经工作在 3 特权级，即进程状态，可以调用 fork 函数创建子进程。它创建的第一个子进程是进程 1： 

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
// include/unistd.h ----------------------------	// unistd -> unix standard
#define __NR_fork	2
......

#define _syscall0(type,name) \
type name(void) \
{ \
long __res; \
__asm__ volatile ("int $0x80" \		// int 0x80 是所有系统调用函数的总入口，fork() 是其中之一
					// 它将导致 CPU 硬件自动将 ss esp eflags cs eip 按序压栈
					// 在这里，压栈的 eip 指向的是下一条语句 if (__res >= 0)
	: "=a" (__res) \		// 返回值存放到 %eax
	: "0" (__NR_##name)); \		// __NR_fork -> %eax
if (__res >= 0) \			// int 0x80 中断返回后，将执行这一句
	return (type) __res; \
errno = -__res; \
return -1; \
}
......

int fork(void);

// init/main.c ---------------------------------
static inline _syscall0(int,fork)	// fork 函数
......

void main(void)
{
	......
	sti();
	move_to_user_mode();
	if (!fork()) {		/* we count on this going ok */
		init();
	}
}

int 0x80 中断发生后，CPU 从 3 特权级的进程 0 代码调到 0 特权级内核代码执行。需要注意的是，此时 ss esp eflags cs eip 已经按序压到进程 0 的内核栈，它们都是 copy_process() 函数的参数。

题外：进程的用户栈和内核栈

对进程的用户栈和内核栈，博文进程内核栈、用户栈有一段简明的阐述：

  • 进程的栈
    • 内核在创建进程的时候，在创建 task_struct 的同时，会为进程创建相应的栈。每个进程会有两个栈，一个用户栈，存在于用户空间，一个内核栈，存在于内核空间。当进程在用户空间运行时，CPU 堆栈指针寄存器里面的内容是用户堆栈地址，使用用户栈；当进程在内核空间时，CPU 堆栈指针寄存器里面的内容是内核栈空间地址，使用内核栈。
  • 进程用户栈和内核栈的切换
    • 当进程因为中断或者系统调用而陷入内核态时，进程所使用的堆栈也要从用户栈转到内核栈。
    • 进程陷入内核态后，先把用户栈的地址保存在内核栈之中，然后设置堆栈指针寄存器的内容为内核栈的地址，这样就完成了用户栈向内核栈的转换；当进程从内核态恢复到用户态时，将保存在内核栈里面的用户栈的地址恢复到堆栈指针寄存器即可。这样就实现了内核栈和用户栈的互转。
    • 那么，我们知道从内核态转到用户态时，用户栈的地址是在陷入内核的时候保存在内核栈里面的，但是在陷入内核的时候，我们是如何知道内核栈的地址的呢？
    • 关键在进程从用户态转到内核态的时候，进程的内核栈总是空的。这是因为，当进程在用户态运行时，使用的是用户栈，当进程陷入到内核态时，内核栈保存进程在内核态运行的相关信息，但是一旦进程返回到用户态后，内核栈中保存的信息无效，会全部恢复，因此每次进程从用户态陷入内核的时候得到的内核栈都是空的。所以在进程陷入内核的时候，直接把内核栈的栈顶地址给堆栈指针寄存器就可以了。

具体地，在 Linux 0.11，内核用于管理进程的结构 task_union 在提供了进程描述符 task_struct 的存储空间同时，也提供了进程内核栈的空间，如进程 0 的 task_union 如下图所示；而对于进程的用户栈，要从虚拟地址空间角度来理解。

图片来源：《Linux 内核设计的艺术》

对于 task_union，《Linux 内核设计的艺术》有一个简要的评论：

task_union 的设计颇具匠心。前面是 task_struct，后面是内核栈，增长的方向正好相反，正好占用一页，顺应分页机制，分配内存非常方便。而且操作系统设计者肯定经过反复测试，保证内核代码所有可能的调用导致压栈的最大长度都不会覆盖前面的 task_struct。因为内核代码都是操作系统设计者设计的，可以做到心中有数。相反，假如用这个方法为用户进程提供栈空间，恐怕要出大问题了。

另外，除了进程 0，其他进程的内核栈都是建立在内存 1MB 区域之外，即内核代码和数据区域之外的页面（copy_process 函数 -> p = (struct task_struct *) get_free_page()）。但这个页面都没有映射到进程的线性地址空间（即没有调用 put_page 函数），所以进程是无法访问这个页面的，只有内核可以访问。

调用 sys_fork

在之前博文 Linux 内核学习笔记：初始化程序（第 3 部分），我们知道 int80 绑定的中断服务程序是 system_call，所以 fork 函数还是要通过 system_call 来实现。不过 system_call 是一个总的入口服务程序，对于具体的服务还是要由具体的服务程序来完成，如 fork 函数最终要通过具体的服务程序 _sys_fork 来实现。关于 fork 函数的执行流程如下代码所示： 

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
// kenel/system_call.s -------------------------
.align 2
_system_call:
	......
	push %ds	# 下面 6 个 push 都是 copy_process() 的参数
	push %es
	push %fs
	pushl %edx
	pushl %ecx		# push %ebx,%ecx,%edx as parameters
	pushl %ebx		# to the system call
	movl $0x10,%edx		# set up ds,es to kernel space	# 下边两句其实非常重要，说明了要切换到内核空间
	mov %dx,%ds
	mov %dx,%es
	movl $0x17,%edx		# fs points to local data space
	mov %dx,%fs
	call _sys_call_table(,%eax,4)	# sys_call_table 定义在 include/linux/sys.h
					# 调用地址 = _sys_call_table + %eax * 4
					# 在这里，%eax = __NR_fork，所以调用地址为 _sys_call_table + 8，查 sys_call_table 可知，该地址刚好指向 sys_fork
					# 调用 call _sys_call_table(,%eax,4) 本身也会压栈保护现场。这个压栈体现在 copy_process() 函数的第 6 个参数 `long none`。
					# call 指令会导致下一指令的 EIP 被压栈，以便 call 返回后从下一指令处开始执行。在这里，这个 EIP 就是 copy_process() 函数的参数 none
	......

// include/linux/sys.h -------------------------
extern int sys_fork();
......

fn_ptr sys_call_table[] = {  sys_setup, sys_exit, sys_fork, ... };

// kenel/system_call.s -------------------------
.align 2
_sys_fork:
	call _find_empty_process
	testl %eax,%eax		# 如果返回的是 -EAGAIN(11)，则说明已有 64 个进程在运行
	js 1f
	push %gs		# 下面 5 个 push 都是 copy_process() 的参数
	pushl %esi
	pushl %edi
	pushl %ebp
	pushl %eax		# find_empty_process 函数返回的是任务号 i（注意不是进程号），
				# 是 copy_process 函数的第一个参数 nr
	call _copy_process
	addl $20,%esp		# 丢弃这里所有的压栈内容（gs esi edi ebp eax）
1:	ret

代码的执行过程如下图所示：
图片来源：《Linux 内核设计的艺术》

注意：在调用 _sys_fork 之前，进程 0 的内核栈又按序压入了 ds es fs edx ecx ebx。另外，调用 call _sys_call_table(,%eax,4) 本身也会压栈保护现场。这个压栈体现在 _sys_fork 调用的 copy_process 函数的第 6 个参数 long none。

调用 find_empty_process

进入 _sys_fork 服务程序后，第一步就是为进程 1 寻找一个可用的进程号和 task[64] 中的一个可用位置（任务号）。这个过程是由 find_empty_process 函数来实现的，其定义如下： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// kenel/fork.c --------------------------------
long last_pid=0;
......

int find_empty_process(void)
{
	int i;

	repeat:
		if ((++last_pid)<0) last_pid=1;		// 如 ++ 后 last_pid 溢出，则置 1
		for(i=0 ; i<NR_TASKS ; i++)		// 为新建进程寻找一个可用进程号 last_pid
			if (task[i] && task[i]->pid == last_pid) goto repeat;
	for(i=1 ; i<NR_TASKS ; i++)	// 为新建进程在 task[64] 寻找一个可用位置，即任务号
		if (!task[i])
			return i;
	return -EAGAIN;	// EAGAIN=11
}

上述代码中，全局变量 last_pid 用来存放系统自开机以来累计的进程数，也将此变量用作新建进程的进程号。

注意：在调用 copy_process 函数之前，进程 0 的内核栈又按序压入了 gs esi edi ebp eax，它们都是 copy_process 函数的参数。其中 %eax 保存的是 find_empty_process 函数返回的进程 1 的任务号（注意跟进程号的区别），是 copy_process 函数的第一个参数 nr。

调用 copy_process

对于函数参数压栈，《Linux 内核设计的艺术》对此有一简单说明：

一个函数的参数不是由函数定义的，而是由函数定义以外的程序通过压栈的方式“做”出来的，是操作系统底层代码与应用程序代码写作手法的差异之一。运行时，C 语言的函数的参数存在于栈中。模仿这个原理，操作系统的设计者可以将前面程序所压栈的值，按序“强行”认定为函数的参数；当 call 这个函数时，这些值就可以当做参数用。

这说明，之前压栈的数可作为 copy_process 函数的实际输入参数。之前压栈（进程 0 内核栈）的数为： 

1
2
// 高地址 -> 低地址
ss esp eflags cs eip ds es fs edx ecx ebx none gs esi edi ebp eax

按“低地址 -> 高地址”方向将这些数一一“弹出”（不是真正弹出，这些数还留在栈中），作为 copy_process 函数的参数： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// kenel/fork.c --------------------------------
int copy_process(int nr,long ebp,long edi,long esi,long gs,long none,
		long ebx,long ecx,long edx,
		long fs,long es,long ds,
		long eip,long cs,long eflags,long esp,long ss)
{
	struct task_struct *p;
	int i;
	struct file *f;

	// get_free_page 函数从主内存末端向低地址端查找可用页。现在是开机以来，内核
	// 第一次为进程在主内存申请空闲页面，申请到的空闲页面肯定在主内存的最末端
	// 强制类型转换的潜台词是将这个页当作 task_union 用
	p = (struct task_struct *) get_free_page();	
	if (!p)
		return -EAGAIN;
	task[nr] = p;	// 这里 nr=%eax，潜台词是将这个页当作 task_union 用
	......
}

调用 get_free_page

注：对于内核而言，它不按用户态下的分页系统来寻址，而是按照“段（选择子）+偏移”的方法。它能寻址整个内存。

如果能找到空闲页，get_free_page 返回该页在内存中的实际起始位置；反之返回 0。

该函数定义如下： 

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
// mm/memory.c ---------------------------------
/*
 * Get physical address of first (actually last :-) free page, and mark it
 * used. If no free pages left, return 0.
 */
unsigned long get_free_page(void)
{
register unsigned long __res asm("ax");

__asm__("std ; repne ; scasb\n\t"	// 反向扫描串（mem_map[]），al （=0） 与 es:edi 所指向内存内容 不等则重复
	"jne 1f\n\t"			// 找不到空闲页，跳转到 1
	"movb $1,1(%%edi)\n\t"
	"sall $12,%%ecx\n\t"		// 页面数 * 4KB = 相对页面起始地址
	"addl %2,%%ecx\n\t"		// 再加上低端内存地址（LOW_MEM=1MB），获得页面实际物理地址
	"movl %%ecx,%%edx\n\t"		// 将页面实际起始地址 -> edx
	"movl $1024,%%ecx\n\t"		// 循环次数为 1024。每次复制 4 个字节，共 1024*4=4092 个字节，恰好是一个页面的大小。
	"leal 4092(%%edx),%%edi\n\t"	// 将该页面的末端 4092+edx -> edi
	"rep ; stosl\n\t"		// 将该页面从高地址向低地址方向清零（eax 为 0）
	"movl %%edx,%%eax\n"		// 将页面实际起始位置 -> eax
	"1:"
	:"=a" (__res)
	:"0" (0),"i" (LOW_MEM),"c" (PAGING_PAGES),
	"D" (mem_map+PAGING_PAGES-1)
	:"di","cx","dx");
return __res;		// 返回空闲页面实际地址
}

注：

  • scasb：Scan String Byte 的缩写。还有类似的 scasw。
    • ecx 控制循环次数
    • 每次循环比较 al 与 es:edi （es 为段选择子）所指向内存内容（因为比较的是 Byte，所以用 al）
    • 若 EFLAGS 中的方向标志位 DF=0 （使用 cld 指令），则 edi 自增 1 （因为比较的是 Byte，所以递增 1）；若 DF=1（使用 std 指令），则 edi 自减 1
    • repne 表示当 ecx > 0 并且 ZF=0 （al 与 es:edi 所指向内存内容不相等）时，循环继续；反之停止
    • 在这个程序开头，al=0，ecx=PAGING_PAGES，es=0x10（选择子，在 _system_call 中所赋的值），edi=mem_map+PAGING_PAGES-1，DF=1（std）。所以，程序开头的”std ; repne ; scasb”表示的是反方向扫描串，al 与 es:edi 所指向内存内容不等则重复，直到条件不满足（ecx<=0 或者 ZF=1）。实际上，它表示的是按 mem_map[PAGING_PAGES-1]…mem_map[0] 方向扫描，如果找到值为 0 的 mem_map 项（表示该项指向的物理页没有使用过），则停止循环。反之，则说明已经没有可用的空闲页。
  • stosl：每次保存的是 4 个字节。
    • ecx 控制循环次数
    • 每次循环将 eax 的值保存到 es:edi （es 为段选择子）指向的内存
    • 若 EFLAGS 中的方向标志位 DF=0 （使用 cld 指令），则 edi 自增 4 （因为每次操作大小是 Long，所以递增 4）；若 DF=1（使用 std 指令），则 edi 自减 4
    • rep 表示当 ecx>0 时，循环继续；反之停止
    • 在这个程序中，每循环 1 次，清零的内存范围是 4 字节；循环 1024 次，清零的内存范围是 1024*4=4096 字节，恰好是一个页。而且该页是主内存区最末端的页。
  • 字符串处理指令
    • lodsb、lodsw：把 ds:si 指向的存储单元中的数据装入 al 或 ax，然后根据 df 标志增减 si
    • stosb、stosw：把 al 或 ax 中的数据装入 es:di 指向的存储单元，然后根据 df 标志增减 di
    • movsb、movsw：把 ds:si 指向的存储单元中的数据装入 es:di 指向的存储单元中，然后根据 df 标志分别增减 si 和 di
    • scasb、scasw：把 al 或 ax 中的数据与 es:di 指向的存储单元中的数据相减，影响标志位，然后根据 df 标志分别增减 si 和 di
    • cmpsb、cmpsw：把 ds:si 指向的存储单元中的数据与 es:di 指向的存储单元中的数据相减，影响标志位，然后根据 df 标志分别增减 si 和 di
    • rep：重复其后的串操作指令。重复前先判断 cx 是否为 0，为 0 就结束重复，否则 cx 减 1，重复其后的串操作指令。主要用在movs和stos 前。一般不用在 lods 前。
    • 上述指令涉及的寄存器：段寄存器 ds 和 es、变址寄存器 si 和 di、累加器 ax、计数器 cx
    • 涉及的标志位：DF、AF、CF、OF、PF、SF、ZF

复制父进程 task_struct

这部分代码如下： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// kenel/fork.c --------------------------------
int copy_process(int nr,long ebp,long edi,long esi,long gs,long none,
		long ebx,long ecx,long edx,
		long fs,long es,long ds,
		long eip,long cs,long eflags,long esp,long ss)
{
	......
	p = (struct task_struct *) get_free_page();
	if (!p)
		return -EAGAIN;
	task[nr] = p;
	*p = *current;	/* NOTE! this doesn't copy the supervisor stack */
	......
}

上述代码中的 current 指向当前进程的 task_struct 的指针，当前进程是进程 0。*p = *current 表示将父进程的 task_struct 复制给子进程。这是父子进程创建机制的重要体现。这行代码执行后，父子进程的 task_struct 完全一样。如下图所示：
图片来源：《Linux 内核设计的艺术》

不过需要注意的是，进程 0 的 task_struct 的信息不一定完全适合进程 1，所以需要进行一些调整： 

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
// kenel/fork.c --------------------------------
int copy_process(int nr,long ebp,long edi,long esi,long gs,long none,
		long ebx,long ecx,long edx,
		long fs,long es,long ds,
		long eip,long cs,long eflags,long esp,long ss)
{
	......
	// 在内核执行过程中，Linux 0.11 不允许进行进程切换，在这里不设置进程状态都可以
	// 但“如果”允许进程在内核执行时切换，这里就有必要设置为不可中断等待状态了。这是因为进程 task_struct 结构已经
	// 挂接在 task[64] 结构中了。如果在个性化设置中发生时钟中断，就会轮转到该进程，而此时其个性化设置尚未完成，一旦
	// 切换到该进程去执行，就会引起进程执行的混乱。
	p->state = TASK_UNINTERRUPTIBLE;

	p->pid = last_pid;
	p->father = current->pid;
	p->counter = p->priority;
	p->signal = 0;
	p->alarm = 0;
	p->leader = 0;		/* process leadership doesn't inherit */
	p->utime = p->stime = 0;
	p->cutime = p->cstime = 0;
	p->start_time = jiffies;
	p->tss.back_link = 0;
	p->tss.esp0 = PAGE_SIZE + (long) p;	// 重要！esp0 是内核指针。见本文前头的 task_union 部分
	p->tss.ss0 = 0x10;
	p->tss.eip = eip;	// 重要！就是参数的 eip，是 int 0x80 压栈的，指向的是：if (__res >= 0)
	p->tss.eflags = eflags;
	p->tss.eax = 0;		// 重要！决定 main 函数中 if(!fork()) 后面的分支走向
	p->tss.ecx = ecx;
	p->tss.edx = edx;
	p->tss.ebx = ebx;
	p->tss.esp = esp;
	p->tss.ebp = ebp;
	p->tss.esi = esi;
	p->tss.edi = edi;
	p->tss.es = es & 0xffff;
	p->tss.cs = cs & 0xffff;
	p->tss.ss = ss & 0xffff;
	p->tss.ds = ds & 0xffff;
	p->tss.fs = fs & 0xffff;
	p->tss.gs = gs & 0xffff;
	p->tss.ldt = _LDT(nr);	// 挂接子进程的 LDT
	p->tss.trace_bitmap = 0x80000000;
	if (last_task_used_math == current)
		__asm__("clts ; fnsave %0"::"m" (p->tss.i387));
	......
}

设置分页管理系统

这部分代码如下： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// kenel/fork.c --------------------------------
int copy_process(int nr,long ebp,long edi,long esi,long gs,long none,
		long ebx,long ecx,long edx,
		long fs,long es,long ds,
		long eip,long cs,long eflags,long esp,long ss)
{
	......
	if (copy_mem(nr,p)) {
		task[nr] = NULL;
		free_page((long) p);
		return -EAGAIN;
	}
	......
}

int copy_mem(int nr,struct task_struct * p)
{
	......
}

设置代码、数据段基地址

这部分代码如下： 

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
// kenel/fork.c --------------------------------
int copy_mem(int nr,struct task_struct * p)
{
	......
	// 获取父进程的代码段、数据段段限长
	code_limit=get_limit(0x0f);	// 0x0f 即 1 111：（进程 0）代码段、LDT、3 特权级
	data_limit=get_limit(0x17);	// 0x17 即 10 111：（进程 0）数据段、LDT、3 特权级

	// 获取父进程的代码段、数据段段基址
	old_code_base = get_base(current->ldt[1]);
	old_data_base = get_base(current->ldt[2]);
	if (old_data_base != old_code_base)	// Linux 0.11 不支持代码段和数据段分立的情况
		panic("We don't support separate I&D");
	if (data_limit < code_limit)
		panic("Bad data_limit");
	new_data_base = new_code_base = nr * 0x4000000;
	p->start_code = new_code_base;
	set_base(p->ldt[1],new_code_base);
	set_base(p->ldt[2],new_data_base);
	......
}
// 我们在 copy_mem 函数并没有看到设置新进程 LDT 中的代码段和数据段的段限长的代码，而是沿用父进程的（*p = *current）。
// 这主要是因为新进程在刚创建的时候还没有加载自己的程序（或许以后也不用加载），而是共用父进程的代码和数据，所以新进程
// 执行的是父进程的代码，数据也来自父进程。沿用父进程中 LDT 的段限长的信息是为了共享父进程的全部代码和数据。
// 不过，在新进程加载（exceve）自己的程序后，它就会更改这些数据。这方面可参考博文
// “Linux 内核学习笔记：进程 2 的创建及执行（第 2 部分）” 中提到的 change_ldt 函数。
// 博文链接：http://xiehongfeng100.github.io/2016/03/03/linux-kenel-0-11-topic-process-two-part2/

// include/linux/sched.h -----------------------
#define _set_base(addr,base) \
__asm__("movw %%dx,%0\n\t" \
	"rorl $16,%%edx\n\t" \
	"movb %%dl,%1\n\t" \
	"movb %%dh,%2" \
	::"m" (*((addr)+2)), \
	  "m" (*((addr)+4)), \
	  "m" (*((addr)+7)), \
	  "d" (base) \
	:"dx")
......

#define set_base(ldt,base) _set_base( ((char *)&(ldt)) , base )
......

#define _get_base(addr) ({\
unsigned long __base; \
__asm__("movb %3,%%dh\n\t" \
	"movb %2,%%dl\n\t" \
	"shll $16,%%edx\n\t" \
	"movw %1,%%dx" \
	:"=d" (__base) \
	:"m" (*((addr)+2)), \
	 "m" (*((addr)+4)), \
	 "m" (*((addr)+7))); \
__base;})

#define get_base(ldt) _get_base( ((char *)&(ldt)) )

#define get_limit(segment) ({ \
unsigned long __limit; \
__asm__("lsll %1,%0\n\tincl %0":"=r" (__limit):"r" (segment)); \
__limit;})

这部分代码是提取进程 0 的代码段、数据段的段基址以及段限长的信息，并设置进程 1 的代码段、数据段的段基址。下边分两部分对这段代码进行解释：

  • 对于 _get_base 和 _set_base 两个函数的汇编，只要参照段描述符的结构就足够了：
    图片来源：《Linux 内核设计的艺术》
    （注：也可参考之前博文 Linux 内核学习笔记：预备知识之“存储器管理基础”“存储段描述符”部分）

  • get_limit 函数的汇编有点难理解。这个函数的参数 segment 是段选择子。当 segment 为 0x0f 时，表示选中进程 0 的 LDT 中的代码段；0x17 表示选中进程 0 的 LDT 中的数据段。通过 lsll 命令取出来的段限长需要加 “1” 才是真正的段限长。例如，当 segment 为 0x0f （该代码段描述符定义在 INIT_TASK），求出的段限长为 636KB，而实际上应该是 640KB，所以需要加 “1”： (unsigned long)(636KB+1)=640KB。

  • Linux 0.11 内核中人工定义系统支持的最大任务数位 64，每个进程空间的虚拟地址空间是 64MB，并且每个进程的虚拟地址起始位置是”任务号*64MB”。因此所有进程所使用的虚拟地址空间是 64MB*64=4GB，如下图所示：
    图片来源：《Linux 内核设计的艺术》

  • Linux 0.11 进程虚拟地址空间：
    图片来源：《Linux 内核设计的艺术》

  • 但需要注意的是，Linux 0.11 的实际物理内存如下图：
    图片来源：《Linux 内核设计的艺术》

复制页表

Linux 0.11 中只有一个页表目录，为所有进程共享。每个进程都有自己对应的页表目录项，也即都有自己对应的页表。

复制页表的代码如下： 

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
// kenel/fork.c --------------------------------
int copy_mem(int nr,struct task_struct * p)
{
	......
	if (copy_page_tables(old_data_base,new_data_base,data_limit)) {
		free_page_tables(new_data_base,data_limit);
		return -ENOMEM;
	}
	return 0;
}

// mm/memory.c ---------------------------------
#define invalidate() \		// 重置 CR3 为 0，刷新“页变换高速缓冲”
__asm__("movl %%eax,%%cr3"::"a" (0))
......

int copy_page_tables(unsigned long from,unsigned long to,long size)
{
	unsigned long * from_page_table;
	unsigned long * to_page_table;
	unsigned long this_page;
	unsigned long * from_dir, * to_dir;
	unsigned long nr;

	// （虚拟地址空间）源地址和目的地址都需要在 4MB 的边界地址上，否则出错，死机
	if ((from&0x3fffff) || (to&0x3fffff))	
		panic("copy_page_tables called with wrong alignment");

	// 取得（虚拟地址空间）源地址和目的地址在页表目录中目录项指针（from_dir 和 to_dir）
	// 以“目的地址”为例，计算方法为：
	// 1. 参照线性地址格式（页目录项（10 位）-页表项（10 位）-页内偏移值（12 位））
	// 2. 先计算 to = to >> 22 取得该地址在页表目录中的序号
	// 3. 因为每个页表目录项大小为 4 个字节，所以该地址在页表目录中的实际物理地址 to_dir = to * 4 = to << 2
	// 这种计算方法跟 (to>>20) & 0xffc 的计算方法是一致的（0xc = 0b1100）
	from_dir = (unsigned long *) ((from>>20) & 0xffc); /* _pg_dir = 0 */
	to_dir = (unsigned long *) ((to>>20) & 0xffc);

	// 计算要复制的页表目录项数，也即页表数
	size = ((unsigned) (size+0x3fffff)) >> 22;

	for( ; size-->0 ; from_dir++,to_dir++) {
		// 页表目录项的格式为：页表号（20 位）-属性（12 位，最低位为 P，为 1 表示对应的页表已经存在，反之不存在）
		// 所以 1 & *to_dir 表示：如果目的地址的页表目录项指定的页表已经存在，则出错，死机
		// !(1 & *from_dir) 表示：如果源页表目录项未被使用，则不用复制页表，跳过
		if (1 & *to_dir)
			panic("copy_page_tables: already exist");
		if (!(1 & *from_dir))
			continue;

		// 页表目录项的格式为：页表号（20 位）-属性（12 位)
		// 将 *from_dir 低 12 位置 0，这样 *from_dir 表示页表的物理地址
		// 参考博文 Linux 内核学习笔记：预备知识之“存储器模型”：http://xiehongfeng100.github.io/2016/01/22/linux-kenel-0-11-topic-necessary-preparation-part3/
		from_page_table = (unsigned long *) (0xfffff000 & *from_dir);
		
		// 为新进程申请一个物理页，用于存放页表
		// 并将该页表的物理地址存放到页表目录中
		if (!(to_page_table = (unsigned long *) get_free_page()))
			return -1;	/* Out of memory, see freeing */
		*to_dir = ((unsigned long) to_page_table) | 7;	// 7 是属性，看成 111，表示 Usr,R/W,P

		// 针对当前处理的页表，设置需复制的页表项数（因为采用了“写时复制”技术，所以并没有实际复制页表）
		// 如果是在内核空间，则仅需复制前 160 个页表项（表示内存区域为 160*4KB=640KB）
		// 否则需要复制 1 个页表的所有 1024 个页表项
		nr = (from==0)?0xA0:1024;

		for ( ; nr-- > 0 ; from_page_table++,to_page_table++) {
			this_page = *from_page_table;	// 取源页表项内容
			if (!(1 & this_page))	// 如果当前源页面没有使用，则不用复制
				continue;
			this_page &= ~2;	// 复位页表项中的 R/W 标志（置 0），表示只读。2 是 010，~2 是 101。
			*to_page_table = this_page;	// 将该页表项复制到目的页表中

			// 在 Linux 0.11，物理内存 1MB （LOW_MEM） 并不采用用户态下的分页系统来寻址，而是按照“段（选择子）+偏移”的方法
			// 1MB 以上，采用分页管理系统
			if (this_page > LOW_MEM) {
				*from_page_table = this_page;	// 令源页表项也只读
				this_page -= LOW_MEM;
				this_page >>= 12;
				mem_map[this_page]++;	// 增加引用计数，见 init/main.c -> mem_init()
			}
		}
	}
	invalidate();	// 重置 CR3 为 0，刷新“页变换高速缓冲”
	return 0;
}

对 copy_page_tables 函数，上边已经有详细的注释。其中，需要注意的是：

  • boot/head.s 文件设置并初始化了分页管理系统；而 sched_init() 函数虽然对进程 0 进行了初始化，但并没有设置进程 0 的分页系统。对于进程 0，其起始线性地址（0x0000 0000）刚好能够映射到页表目录的第 1 项；整个虚拟地址空间（64MB）可以映射到页表目录的第 1 ~ 16 项。而这些页表目录项已经在 boot/head.s 设置好，所以就相当于进程 0 的页表系统早在进程 0 被创建之前就已经设置好了。进程 1 映射的第 1 个页表目录项在页表目录中算第 17 个。

  • Linux 0.11 只有一个页表目录

  • 页面复制时采用了写时复制的技术

  • 进程 1 只复制了进程 0 页表的前 160 项。这 160 项能表示的实际内存范围为 160*4KB=640KB，恰好是实际内存中“内核+缓冲区低端”所占的区域

  • 在 Linux 0.11，物理内存 1MB （LOW_MEM） 并不采用用户态下的分页系统来寻址，而是按照“段（选择子）+偏移”的方法。1MB 以上，才采用分页管理系统。

  • 这里还有一个没有解决的问题是：size = ((unsigned) (size+0x3fffff)) >> 22; 中的 0x3fffff 是怎么来的？有待下次解决。

copy_page_tables 的执行结果可用下图表示：
图片来源：《Linux 内核设计的艺术》

小结

进程 1 的分页系统设置可用图总结如下：
图片来源：《Linux 内核设计的艺术》

共享文件

进程 1 共享进程 0 文件的代码如下： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// kenel/fork.c --------------------------------
int copy_process(int nr,long ebp,long edi,long esi,long gs,long none,
		long ebx,long ecx,long edx,
		long fs,long es,long ds,
		long eip,long cs,long eflags,long esp,long ss)
{
	......
	for (i=0; i<NR_OPEN;i++)
		if (f=p->filp[i])
			f->f_count++;
	if (current->pwd)
		current->pwd->i_count++;
	if (current->root)
		current->root->i_count++;
	if (current->executable)
		current->executable->i_count++;
	......
}

设置 TSS 及 GDT

这部分代码如下： 

1
2
3
4
5
6
7
8
9
10
11
// kenel/fork.c --------------------------------
int copy_process(int nr,long ebp,long edi,long esi,long gs,long none,
		long ebx,long ecx,long edx,
		long fs,long es,long ds,
		long eip,long cs,long eflags,long esp,long ss)
{
	......
	set_tss_desc(gdt+(nr<<1)+FIRST_TSS_ENTRY,&(p->tss));
	set_ldt_desc(gdt+(nr<<1)+FIRST_LDT_ENTRY,&(p->ldt));
	......
}

进入就绪态

将进程 1 的状态设置为就绪态，使它可以参加进程调度： 

1
2
3
4
5
6
7
8
9
10
// kenel/fork.c --------------------------------
int copy_process(int nr,long ebp,long edi,long esi,long gs,long none,
		long ebx,long ecx,long edx,
		long fs,long es,long ds,
		long eip,long cs,long eflags,long esp,long ss)
{
	......
	p->state = TASK_RUNNING;	/* do this last, just in case */
	return last_pid;
}

上述代码返回值 last_pid 保存在寄存器 eax。

返回 fork 函数

返回 sys_fork

从 copy_process 函数返回后，开始执行下边代码： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// kenel/system_call.s -------------------------
.align 2
_sys_fork:
	call _find_empty_process
	testl %eax,%eax		# 如果返回的是 -EAGAIN(11)，则说明已有 64 个进程在运行
	js 1f
	push %gs		# 下面 5 个 push 都是 copy_process() 的参数
	pushl %esi
	pushl %edi
	pushl %ebp
	pushl %eax		# find_empty_process 函数返回的是任务号 i（注意不是进程号），
				# 是 copy_process 函数的第一个参数 nr
	call _copy_process
	addl $20,%esp		# 丢弃这里所有的压栈内容（gs esi edi ebp eax）
1:	ret

返回 system_call

sys_fork 返回后，跳转到 system_call 中执行： 

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
// kenel/system_call.s -------------------------
/*
 ......
 * 
 * Stack layout in 'ret_from_system_call':
 * 
 *	 0(%esp) - %eax
 *	 4(%esp) - %ebx
 *	 8(%esp) - %ecx
 *	 C(%esp) - %edx
 *	10(%esp) - %fs
 *	14(%esp) - %es
 *	18(%esp) - %ds
 *	1C(%esp) - %eip
 *	20(%esp) - %cs
 *	24(%esp) - %eflags
 *	28(%esp) - %oldesp
 *	2C(%esp) - %oldss
 */
......

state	= 0		# these are offsets into the task-struct.
counter	= 4
......

.align 2
_system_call:
	......
	call _sys_call_table(,%eax,4)
	pushl %eax			# sys_fork 函数返回到这里执行。eax 保存的是 copy_process 函数返回值 last_pid
	movl _current,%eax		# 当前进程是 0
	cmpl $0,state(%eax)		# state
	jne reschedule			# 如果进程 0 不是处于就绪态，则进行进程调度
	cmpl $0,counter(%eax)		# counter
	je reschedule			# 如果进程没有时间片，则进行进程调度
ret_from_sys_call:
	movl _current,%eax		# task[0] cannot have signals
	cmpl _task,%eax			# _task 对应 include/linux/sched.h 中定义的 task[] 数组，
					# 直接引用 _task，相当于引用 task[0]
	je 3f				# 如果当前进程是进程 0，则跳转到 3 处执行。当前进程恰好是进程 0。f:forward; b:backword。
	......
3:	popl %eax			# eax 存储的是进程 1 的进程号 1（注意跟任务号的区别）
	popl %ebx
	popl %ecx
	popl %edx
	pop %fs
	pop %es
	pop %ds
	iret	# iret 将导致之前因为 int 0x80 压栈的 ss esp eflags cs eip 出栈到对应的寄存器
		# cs:eip 指向 _syscall0(int,fork) 中 int 0x80 的下一行 if(__res >=0)

返回 fork

system_call 返回后，cs:eip 指向 fork() 中 int 0x80 的下一行，即从 if(__res >=0) 处开始执行： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// include/unistd.h ----------------------------	// unistd -> unix standard
#define __NR_fork	2
......

#define _syscall0(type,name) \
type name(void) \
{ \
long __res; \
__asm__ volatile ("int $0x80" \		// int 0x80 是所有系统调用函数的总入口，fork() 是其中之一
					// 它将导致 CPU 硬件自动将 ss esp eflags cs eip 按序压栈
					// 在这里，压栈的 eip 指向的是下一条语句 if (__res >= 0)
	: "=a" (__res) \		// 返回值存放到 %eax
	: "0" (__NR_##name)); \		// __NR_fork -> %eax
if (__res >= 0) \			// int 0x80 中断返回后，将执行这一句
	return (type) __res; \
errno = -__res; \
return -1; \
}
......

int fork(void);

// init/main.c ---------------------------------
static inline _syscall0(int,fork)	// fork 函数。fork 是一个函数指针常量，有地址含义

因为 eax 保存的值是进程 1 的进程号 1，所以 __res >= 0 为真，fork() 函数返回 1，并开始执行下述代码： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// init/main.c ---------------------------------
void main(void)
{
	......
	sti();
	move_to_user_mode();
	if (!fork()) {		/* we count on this going ok */
		init();
	}
/*
 *   NOTE!!   For any other task 'pause()' would mean we have to get a
 * signal to awaken, but task0 is the sole exception (see 'schedule()')
 * as task 0 gets activated at every idle moment (when no other tasks
 * can run). For task0 'pause()' just means we go check if some other
 * task can run, and if not we return here.
 */
	for(;;) pause();
}

上述代码可用下图表示：
图片来源：《Linux 内核设计的艺术》

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 开发。