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

系统调用流程简述

• 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 在内核中作了什么

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

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

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

其中 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()

• 建立 task_struct 结构体指针；
• 检查参数；
• 调用 dup_task_struct() ，将父进程 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 结构体和内核栈）
  

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_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()

• 复制父进程每一个 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