代码改变世界

Linux 系统调用 —— fork 内核源码剖析

2019-12-01 23:16  陈心朔  阅读(328)  评论(0编辑  收藏

系统调用流程简述

  • fork() 函数是系统调用对应的 API,这个系统调用会触发一个int 0x80 的中断;
    当用户态进程调用 fork() 时,先将 eax(寄存器) 的值置为 2(即 __NR_fork 系统调用号);
     

  • 执行 int $0x80,cpu 进入内核态;
     

  • 执行 SAVE_ALL,保存所有寄存器到当前进程内核栈中;
     

  • 进入 sys_call,将 eax 的值压栈,根据系统调用号查找 system_call_table ,调用对应的函数;
     

  • 函数返回,执行 RESTORE_ALL,恢复保存的寄存器;执行 iret,cpu 切换至用户态;
     

  • 从 eax 中取出返回值,fork() 返回;

详见:系统调用的工作机制

 
 
 

fork 在内核中做了什么

sys_call

当我们调用 fork()、clone()、vfork() 时,实际上在内核中调用的都是同一个函数 —— do_fork()

do_fork()

这里的三个系统调用的区别就在于调用 do_fork() 时传入的参数不同

do_fork() 中第一个参数 clone_flags 是一个 32bit 的标志,其中不同的 bit 置 1 代表不同的选项,表示新的子进程与父进程之间共享哪些资源

clone_flags

其中 sys_fork() 调用 do_fork() 只设置了 SIGCHLD 选项,sys_vfork() 设置了 CLONE_VM | CLONE_VFORK | SIGCHLD 选项,而 sys_clone() 的参数来自上层,通过 ebx 传入;

下面简述下 do_fork() 的执行过程

do_fork()

  • 查找 pidmap_array 位图,为子进程分配新的 pid;
  • 调用 copy_process() ,将新的 pid 传入参数,这个函数是创建进程的关键步骤,该函数返回新的 task_struct 地址;

copy_process()

copy_process()

  • 创建 task_struct 结构体指针;
  • 检查参数;
  • 调用 dup_task_struct() ,将父进程 task_struct 传入参数,为子进程获取进程描述符;

dup_task_struct()

dup_task_struct()

  • 创建 task_struct 、thread_info 结构体指针;
struct task_struct *tsk;
struct thread_info *ti;
  • 调用 alloc_task_struct() 宏为新进程获取进程描述符,并保存至 tsk 中;
tsk = alloc_task_struct();
if (!tsk)
	return NULL;
  • 调用 alloc_thread_info() 宏获取一块空闲内存区,保存在 ti 中(这块内存的大小为 8K/4k,用来存放新进程的 thread_info 结构体和内核栈)
    stack

thread_info

struct task_struct
{
	struct thread_info * thread_info; // 指向 thread_info 的指针
	struct mm_struct * mm; // 进程地址空间
	pid_t pid;
	struct list_head children; // 子进程链表
	...
}

struct thread_info
{
	struct task_struct task; // 指向 task_struct 的指针
	_u32 cpu; // 当前所在的cpu
	mm_segment_t addr_limit; // 线程地址空间
	// user_thread   0-0xBFFFFFFF
	// kernel_thread 0-0xFFFFFFFF
	...
}

// thread_info 和 stack 共享一块内存
union thread_union
{
    struct thread_info thread_info;
    unsigned long stack[THREAD_SIZE/sizeof(long)];
};
  • 复制进程描述符和 thread_info,并将两者中的互指指针初始化;
*ti = *current->thread_info;
ti->task = tsk;
  • 将新进程描述符的使用计数器 usage 置为2,表示描述符正在被使用而其对应的进程处于活动状态;

新进程的进程描述符创建完成,返回至 copy_process()

  • 检查当前用户所拥有的进程数是否超过了限制的值(1024),有root权限除外;若超过了限制则返回错误码,否则增加用户拥有的进程计数;
atomic_inc(p->user->process);
  • 检查系统中的进程数量是否超过了 max_threads;
    max_threads的数量由系统内存容量决定,所有的thread_info描述符和内核栈所占用空间不能超过系统内存的1/8;

  • 拷贝所有的进程信息:

copy all process information

  • 其中最重要的是 copy_mm() ,该函数通过建立新进程所有页表和内存描述符来创建进程地址空间;
    copy_mm()
struct mm_struct
{
	struct vm_area_struct * mmap; // 指向线性区对象的链表头
	struct rb_root mm_rb; // 指向线性区对象的红黑树的根
	pgd_t * pgd; // 指向页全局目录
	atomic_t mm_users; // 次使用计数器,存放共享 mm_struct 数据结构轻量级进程的个数
	atomic_t mm_count; // 主使用计数器,每当 mm_count 递减,内核就要检查它是否为0,如果是就要解除这个内存描述符
}

copy_mm()

  • 创建 mm_struct * mm, oldmm 结构体指针(内存描述符);
	oldmm = current->mm; //oldmm 初始化为父进程的 mm_struct
  • 检查 clone_flags 是否设置了 CLONE_VM 位;
    若设置了 CLONE_VM 位,则表示创建线程,与父进程共享地址空间
atomic_inc(&oldmm->mm_users);	// 父进程的地址空间引用计数加一
mm = oldmm;			// 将父进程地址空间赋给子进程
  • 否则,就要创建新的地址空间,并从当前进程复制 mm 的内容
mm = allocate_mm();
memcpy(mm, oldmm, sizeof(*mm));
  • 调用 dup_mmap() 复制父进程的线性区和页表

dup_mmap()

dup_mmap()

  • 复制父进程每个 vm_area_struct 线性区描述符,插入到子进程的线性区链表和红黑树中;
struct vm_area_struct
{
	struct mm_struct * vm_mm; // 指向线性区所在的内存描述符
	unsigned long vm_start; // 当前线性区起始地址
	unsigned long vm_end; // 线性区尾地址
	struct vm_area_struct * vm_next; // 下一个线性区
	pgprot_t vm_page_prot; // 线性区访问权限
	struct rb_node vm_rb; // 用于红黑树搜索的节点
}
  • 用 copy_page_range() 创建新的页表,在新的 vm_area_struct 中链接并复制父进程的页表条目;
copy_page_range()
  • 创建新的页表;
  • 复制父进程的页表来初始化子进程的新页表;
    私有/可写的页( VM_SHARED 标志关闭/ VM_MAYWRITE 标志打开)所对应的权限父子进程都设为只读,以便于 Copy-on-write 机制处理。

新进程的线性区和页表复制完成,返回至copy_process()

  • 调用 copy_thread() 用父进程的内核栈初始化子进程的内核栈

copy_thread()

  • 将eax的值强制设为0(fork / clone 系统调用的返回值)
childregs->eax = 0;

sched_fork()

  • 调用 sched_fork() 完成对新进程调度程序数据结构的初始化,将新进程状态设为 TASK_RUNNING
  • 为了公平起见,父子进程共享父进程的时间片

进程创建完成,返回至 do_fork()

  • 如果设置 CLONE_STOPPED,就将子进程设置 TASK_STOPPED 状态并挂起;
    否则调用 wake_up_new_task() 调整父子进程的调度参数;

wake_up_new_task()

  • 如果父子进程运行在同一个 cpu 上,并且不能共享同一组页表 (CLONE_VM 位为 0),就把子进程插入运行队列中的父进程之前;
    如果子进程创建之后调用 exec 执行新程序,就可以避免写时拷贝机制执行不必要的页面复制;
    否则,如果运行在不同的cpu上,或父子共享同一组页表,就将子进程插入运行队列的队尾。

返回至 do_fork()

  • 返回子进程的 pid

2017/8/3 补充

  • fork() 和 vfork() 参数是写死的,而 clone() 是可选的,它可以选择当前创建的进程哪些部分是共享的,哪些部分是独立的;

  • vfork() 是历史的产物,当调用 fork() 的时候,需要将父进程的线性区和页表都拷贝一份,而调用 exec() 执行新程序后,又要把所有页表删除重置新的页表,建立映射关系,效率很低;

  • 所以要有 vfork(),vfork() 的 clone_flags 位置了 CLONE_VM ,表示共享父进程的地址空间,vfork() 中创建的进程没有分配自己的地址空间,而是通过一个 mm_struct 指针指向父进程的地址空间,这个进程是为了在之后调用 exec() 执行新的程序;

  • 而在有了 Copy-on-write 技术后,fork() 出的子进程只创建了自己的地址空间,然后用父进程的地址空间初始化,每个页表的项置为父进程的页表项,共享父进程的物理页面,并将所有 私有/可写 页面改为只读;

  • 当我们改变父子进程的数据后,cpu 在运行过程中会发生一个缺页错误,cpu 转交控制权给操作系统,操作系统查找 VMA 发现该页权限为只读,但所在段又是可写的,产生一个矛盾,这就是识别 Copy-on-write 的方法,接着 OS 给子进程分配一个新的物理页,并将页表该页的地址修改成新的物理页地址;

  • 这样 fork() 后再调用 exec() 就不用那么麻烦了,可以直接将新的物理页与子进程的虚拟空间建立映射
     

小结

综上,fork 在创建子进程时,主要做了这些工作

  1. 为子进程分配新的 pid,并通过父进程 PCB(task_struct)创建新的子进程 PCB
  2. 检查进程数是否达到上限(分别检查用户限制和系统限制)
  3. 拷贝所有的进程信息(打开的文件 / 信号处理 / 进程地址空间等),这里需要拷贝的选项由调用 do_fork() 时传入的参数 clone_flags 决定
  4. 用父进程的内核栈初始化子进程的内核栈,设置子进程的返回值为 0(eax = 0)
  5. 设置新进程的状态(TASK_RUNNING / TASK_STOPPED),调整父子进程调度
  6. 父进程 fork 返回子进程的 pid