Linux系统调用:fork()

以Linux-v0.11为例。

目录结构
函数声明

在include/unistd.h文件中，声明fork()函数为：int fork(void)。说明fork()为无参函数，返回值为int型。在新版linux中声明方式为pid_t fork(void)。但在include/sys/types.h中，使用了typedef定义了pid_t：typedef int pid_t，所以本质上是一样的。

函数实现

实际上，在Linux-v0.11中并没有关于fork()的函数实现，Linus采用的是一种非常巧妙的函数实现方法。在include/unistd.h中，Linus使用了宏定义定义了如下一段代码：

1
2
3
4
5
6
7
8
9
10
11
12
#define _syscall0(type,name) \
type name(void) \
{ \
long __res; \
__asm__ volatile ("int $0x80" \
	: "=a" (__res) \
	: "0" (__NR_##name)); \
if (__res >= 0) \
	return (type) __res; \
errno = -__res; \
return -1; \
}

这里使用了两个标识符：type和name，并用标识符编写了一段通用的函数定义模板。

然后在/init/main.c中，即需要调用fork()函数作初始化的地方，Linus使用了static inline _syscall0(int,fork)将type和name传入，完成了fork()函数的函数实现。

所以fork()的函数实现应如下：

1
2
3
4
5
6
7
8
9
10
11
12
int fork(void)
{
    long __res;
    __asm__ volatile (
      "int $0x80" \
      : "=a" (__res) \
      : "0" (__NR_fork));
    if(__res >= 0)
        return int __res;
    errno = -__res;
    return -1;
}

函数调用过程(个人理解)

1
2
3
4
__asm__ volatile (
  "int $0x80" \
   : "=a" (__res) \
   : "0" (__NR_fork));

这一段为GCC的内联汇编语句，语法格式为__asm__　__volatile__("Instruction List" : Output : Input : Clobber/Modify)。

其中，__asm__为GCC关键字asm的宏定义，用来声明一个内联汇编表达式。__volatile__为GCC关键字volatile的宏定义，向GCC声明不允许对该内联汇编优化。Instruction List为汇编指令序列，可以为空
。Output指定当前内联汇编语句的输出。Input指定当前内联汇编语句的输入。Clobber/Modify向GCC声明当前内联汇编语句可能会对某些寄存器或者内存进行修改，希望GCC在编译时能将这一点考虑进去。一般发生在一个寄存器出现在Instruction List但却不在Output/Input表达式中出现的，仅做当前内联汇编临时使用寄存器的情况。

此处int $0x80为内部中断，传入"=a" (__res)用于存放返回值，"0" (__NR_fork)为对应的中断功能号。"=a"是GCC内联汇编的约束字，"="号为Output表达式特有，指定使用的寄存器为Write-Only，"a"表示使用eax寄存器存放Output返回值，即fork()函数的返回值会先存放到eax中，再由寄存器eax将值更新到__res中。"0"指定内联汇编表达式的第一个操作数，即Output语句的eax，即Input表达式也使用eax寄存器，只是与Output相反，先由__NR_fork将值更新到eax中，再由eax传给int 0x80中断处理函数。此处的"0"可以用"a"代替。具体参见GCC内联汇编手册：GCC-Inline-Assembly-HOWTO (ibiblio.org)中5.2 Operands这一节的内容。

而在/kernel/sched.c中，最后一段内联汇编：

1
2
3
4
5
6
7
8
9
10
	__asm__("pushfl ; andl $0xffffbfff,(%esp) ; popfl");
	ltr(0);
	lldt(0);
	outb_p(0x36,0x43);		/* binary, mode 3, LSB/MSB, ch 0 */
	outb_p(LATCH & 0xff , 0x40);	/* LSB */
	outb(LATCH >> 8 , 0x40);	/* MSB */
	set_intr_gate(0x20,&timer_interrupt);
	outb(inb_p(0x21)&~0x01,0x21);
	set_system_gate(0x80,&system_call);
}

其中的最后一句set_system_gate(0x80,&system_call)将0x80号中断与系统调用关联在一起，所以fork()函数此处调用的0x80号中断其实是系统调用。

在/kernel/system_call.s中，对系统调用进行了处理。调用部分：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
.align 2
_system_call:
	cmpl $nr_system_calls-1,%eax
	ja bad_sys_call
	push %ds
	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)
	pushl %eax
	movl _current,%eax
	cmpl $0,state(%eax)		# state
	jne reschedule
	cmpl $0,counter(%eax)		# counter
	je reschedule

其中nr_system_calls在此文件开头处定义为nr_system_calls = 72，为系统调用数量。cmpl $nr_system_calls-1,%eax即为比较eax中存放的中断功能号(系统调用号)与71(0~71共72个系统调用)的关系，若中断功能号大于71则ja跳转到bad_sys_call进行错误中断处理。若中断功能号合法，则保存现场准备进入系统调用程序。

call _sys_call_table(,%eax,4)这一句调用了在/include/linux/sys.h中定义的函数数组，%eax为传入的系统调用号，4表示4字节，因为系统调用表数组为int型数组，一个int型数据需要占用4字节。

查表获得对应的系统调用处理函数入口地址，然后查看当前进程状态，并运行进程调度函数reschedule准备转入系统调用处理函数。reschedule同样在/kernel/system_call.s中：

1
2
3
4
.align 2
reschedule:
	pushl $ret_from_sys_call
	jmp _schedule

第一句将同在system_call.s中的函数ret_from_sys_call的入口地址入栈($ret_from_sys_call表示取地址，因为这里的ret_from_sys_call是一个标号，而前面的$nr_system_calls-1表示的是取立即数，因为nr_system_calls可以认为是立即数72的宏定义，而在AT&T语法中取立即数也需要使用$符号)，然后第二句jmp跳转到进程调度函数schedule处执行，该函数在/kernel/sched.c中定义如下：

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
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)
				(*p)->state=TASK_RUNNING;
		}

/* 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;
		}
		if (c) break;
		for(p = &LAST_TASK ; p > &FIRST_TASK ; --p)
			if (*p)
				(*p)->counter = ((*p)->counter >> 1) +
						(*p)->priority;
	}
	switch_to(next);
}

进程调度这段还没仔细看。总之调度完成后返回ret_from_sys_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
ret_from_sys_call:
	movl _current,%eax		# task[0] cannot have signals
	cmpl _task,%eax
	je 3f
	cmpw $0x0f,CS(%esp)		# was old code segment supervisor ?
	jne 3f
	cmpw $0x17,OLDSS(%esp)		# was stack segment = 0x17 ?
	jne 3f
	movl signal(%eax),%ebx
	movl blocked(%eax),%ecx
	notl %ecx
	andl %ebx,%ecx
	bsfl %ecx,%ecx
	je 3f
	btrl %ecx,%ebx
	movl %ebx,signal(%eax)
	incl %ecx
	pushl %ecx
	call _do_signal
	popl %eax
3:	popl %eax
	popl %ebx
	popl %ecx
	popl %edx
	pop %fs
	pop %es
	pop %ds
	iret

这段也还没仔细看，不过这段完成之后应该就结束系统调用了，因为最后是个iret中断返回。

而调用sys_fork()中断处理函数应该是在schedule进程调度中完成的，其函数实现在/kernel/system_call.s中，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
.align 2
_sys_fork:
	call _find_empty_process
	testl %eax,%eax
	js 1f
	push %gs
	pushl %esi
	pushl %edi
	pushl %ebp
	pushl %eax
	call _copy_process
	addl $20,%esp
1:	ret

这里调用的find_empty_process和copy_process均为C函数，在/kernel/fork.c中定义：

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
int find_empty_process(void)
{
	int i;

	repeat:
		if ((++last_pid)<0) last_pid=1;
		for(i=0 ; i<NR_TASKS ; i++)
			if (task[i] && task[i]->pid == last_pid) goto repeat;
	for(i=1 ; i<NR_TASKS ; i++)
		if (!task[i])
			return i;
	return -EAGAIN;
}

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;

	p = (struct task_struct *) get_free_page();
	if (!p)
		return -EAGAIN;
	task[nr] = p;
	*p = *current;	/* NOTE! this doesn't copy the supervisor stack */
	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;
	p->tss.ss0 = 0x10;
	p->tss.eip = eip;
	p->tss.eflags = eflags;
	p->tss.eax = 0;
	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);
	p->tss.trace_bitmap = 0x80000000;
	if (last_task_used_math == current)
		__asm__("clts ; fnsave %0"::"m" (p->tss.i387));
	if (copy_mem(nr,p)) {
		task[nr] = NULL;
		free_page((long) p);
		return -EAGAIN;
	}
	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++;
	set_tss_desc(gdt+(nr<<1)+FIRST_TSS_ENTRY,&(p->tss));
	set_ldt_desc(gdt+(nr<<1)+FIRST_LDT_ENTRY,&(p->ldt));
	p->state = TASK_RUNNING;	/* do this last, just in case */
	return last_pid;
}

此处可以看到copy_process的函数操作使用了大量的指针，对原有进程进行了复制。同时需要注意的是由于此函数需要传递的参数过多，有部分参数是通过栈传递进来的，这就是为什么在call之前有四句pushl。

至于为何fork()函数能给子进程和父进程分别返回一个返回值目前还没有看懂，后续看懂了再进行补充。

本文作者： BBSD丿草丶帽
发布时间： 2021-04-27
最后更新： 2024-05-12
本文标题： Linux系统调用:fork()
本文链接： https://cloudflare.luhawxem.com/2021/04/27/Linux-syscall-fork/
版权声明： 本作品采用 CC BY-NC-SA 4.0 许可协议进行许可。转载请注明出处！

扫一扫，分享到微信

微信分享二维码

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