Linux操作系统：进程的创建

创建进程使用 fork

fork 是一个系统调用&＃xff0c;根据系统调用的流程&＃xff0c;流程的最后会在 sys_call_table 中找到相应的系统调用 sys_fork。

根据 SYSCALL_DEFINE0 这个宏的定义 &＃xff0c;下面代码就定义了 sys_fork


SYSCALL_DEFINE0(fork)
{
......return _do_fork(SIGCHLD, 0, 0, NULL, NULL, 0);
}


sys_fork 会调用 _do_fork

long _do_fork(unsigned long clone_flags,unsigned long stack_start,unsigned long stack_size,int __user *parent_tidptr,int __user *child_tidptr,unsigned long tls)
{struct task_struct *p;int trace &＃61; 0;long nr;......p &＃61; copy_process(clone_flags, stack_start, stack_size,child_tidptr, NULL, trace, tls, NUMA_NO_NODE);
......if (!IS_ERR(p)) {struct pid *pid;pid &＃61; get_task_pid(p, PIDTYPE_PID);nr &＃61; pid_vnr(pid);if (clone_flags & CLONE_PARENT_SETTID)put_user(nr, parent_tidptr);......wake_up_new_task(p);
......put_pid(pid);}
......


fork 的第一件大事就是复制结构&＃xff0c;_do_fork 里面做的第一件大事就是 copy_process, 所有数据结构从头创建一份太麻烦了&＃xff0c;还不如 copy 一份其他进程的。

这是 copy 的 task_struct 结构&＃xff1a;


static __latent_entropy struct task_struct *copy_process(unsigned long clone_flags,unsigned long stack_start,unsigned long stack_size,int __user *child_tidptr,struct pid *pid,int trace,unsigned long tls,int node)
{int retval;struct task_struct *p;
......p &＃61; dup_task_struct(current, node);


dup_task_struct 主要做了下面几件事情&＃xff1a;

• 调用 alloc_task_struct 分配一个 task_struct 结构&＃xff1b;
• 调用 alloc_thread_stack_node 来创建内核栈&＃xff0c;着里面调用 __vmalloc_node_range 分配一个连续的 THREAD_SIZE 的内存空间&＃xff0c;赋值给 task_struct 的 void *stack 成员变量&＃xff1b;
• 调用 arch_dup_task_struct(struct task_struct *dst, struct task_struct *src), 将 task_struct 进行复制&＃xff0c;其实就是调用 memcpy;
• 调用 setup_thread_stack 设置 thread_info。

到这里&＃xff0c;整个 task_struct 复制了一份&＃xff0c;而且内核栈也创建好了。

接着再看 copy_process


retval &＃61; copy_creds(p, clone_flags);


轮到权限相关了&＃xff0c; copy_creds 主要做了下面几件事情&＃xff1a;

• 调用 prepare_creds, 准备一个新的 struct cred *new&＃xff0c;如何准备呢&＃xff1f;其实还是从内存中分配一个新的 struct cred 结构&＃xff0c; 然后调用 memcpy 复制一份父进程的 cred;
• 接着 p->cred &＃61; p->real_cred &＃61; get_cred(new), 将新进程的“我能操作谁”和“谁能操作我”两个权限都指向新的 cred。

接下来&＃xff0c; cpoy_process 重新设置进程运行的统计量。


p->utime &＃61; p->stime &＃61; p->gtime &＃61; 0;
p->start_time &＃61; ktime_get_ns();
p->real_start_time &＃61; ktime_get_boot_ns();


接下来&＃xff0c;copy_process 开始设置调度相关的变量。

retval &＃61; sched_fork(clone_flags, p);


sched_fork 主要做了下面几件事情&＃xff1a;

• 调用 __sched_fork, 在这里面将 on_rq 设为 0&＃xff0c;初始化 sched_entity, 将里面的 exec_start、sum_exec_runtime、prev_sum_exec_runtime、vruntime 都设为 0。 这几个变量涉及进程的实际运行时间和虚拟运行时间。
• 设置进程的状态 p->state &＃61; TASK_NEW;
• 初始化优先级 piro、normal_prio、static_prio;
• 设置调度类&＃xff0c;如果是普通进程&＃xff0c;就设置 p->sched_class &＃61; &fair_sched_class;
• 调用调度类的 task_fork 函数&＃xff0c;对于 CFS 来讲&＃xff0c;就是调用 task_fork_fair。在这个函数里&＃xff0c;先调用 update_curr&＃xff0c;对于当前的进程进程统计更新&＃xff0c;然后把子进程和父进程的 vruntime 设成一样&＃xff0c;最后调用 place_entity ,初始化 sched_entity。这里有一个变量 sysctl_sched_child_runs_first, 可以设置父进程和子进程谁先运行。如果设置了子进程先运行&＃xff0c;即便两个 vruntime 一样&＃xff0c;也要把子进程的 sched_entity 放在前面&＃xff0c;然后调用 resched_curr&＃xff0c;标记当前运行的进程 TIF_NEED_RESCHED, 也就是说&＃xff0c;把父进程设置为应该被调度&＃xff0c;这样下次调度的时候&＃xff0c;父进程会被子进程抢占。

接下来&＃xff0c;copy_process 开始初始化与文件和文件系统相关的变量。


retval &＃61; copy_files(clone_flags, p);
retval &＃61; copy_fs(clone_flags, p);


copy_files 主要用于复制一个进程打开的信息。这些信息用一个结构 files_struct 来维护&＃xff0c;每个打开的文件都有一个文件描述符。在 copy_files 函数里面调用 dup_fd&＃xff0c;在这里面会创建一个新的 files_struct, 然后将所有的文件描述符数组 fdtable 拷贝一份。

copy_fs 主要用于复制一个进程的目录信息。这些信息用一个结构 fs_struct 来维护。一个进程有自己的根目录和根文件系统 root, 也有当前目录 pwd 和当前目录的文件系统&＃xff0c;都在 fs_struct 里面维护。copy_fs 函数里面调用 copy_fs_struct, 创建一个新的 fs_struct, 并复制原来进程的 fs_struct。

接下来&＃xff0c;copy_process 开始初始化与信号相关的变量。


init_sigpending(&p->pending);
retval &＃61; copy_sighand(clone_flags, p);
retval &＃61; copy_signal(clone_flags, p);


copy_sighand 会分配一个新的 sighand_struct。这里最主要的是维护信号处理函数&＃xff0c;在 copy_sighand 里面会调用 memcpy, 将信号处理函数 sighand->action 从父进程复制到子进程。

init_sigpending 和 copy_signal 用于初始化&＃xff0c;并且复制用于维护发给这个进程的信号的数据结构。copy_signal 函数会分配一个新的 signal_struct, 并进行初始化。

接下来&＃xff0c;copy_process 开始复制进程内存空间。


retval &＃61; copy_mm(clone_flags, p);


进程都有自己的内存空间&＃xff0c;用 mm_struct 结构来表示。copy_mm 函数调用 dup_mm, 分配一个新的 mm_struct 结构&＃xff0c;调用 memcpy 复制这个结构。dup_mmap 用于复制内存空间中内存映射的部分。前面讲系统调用的时候说过&＃xff0c;mmap 可以分配大块的内存&＃xff0c;其实 mmap 也可以将一个文件映射到内存中&＃xff0c;方便可以像写内存一样读写文件。

接下来&＃xff0c;copy_process 开始分配 pid, 设置 tid, group_leader&＃xff0c;并且建立进程之间的亲缘关系。

INIT_LIST_HEAD(&p->children);INIT_LIST_HEAD(&p->sibling);
......p->pid &＃61; pid_nr(pid);if (clone_flags & CLONE_THREAD) {p->exit_signal &＃61; -1;p->group_leader &＃61; current->group_leader;p->tgid &＃61; current->tgid;} else {if (clone_flags & CLONE_PARENT)p->exit_signal &＃61; current->group_leader->exit_signal;elsep->exit_signal &＃61; (clone_flags & CSIGNAL);p->group_leader &＃61; p;p->tgid &＃61; p->pid;}
......if (clone_flags & (CLONE_PARENT|CLONE_THREAD)) {p->real_parent &＃61; current->real_parent;p->parent_exec_id &＃61; current->parent_exec_id;} else {p->real_parent &＃61; current;p->parent_exec_id &＃61; current->self_exec_id;}


fork 的第二件大事&＃xff0c;就是唤醒新进程。
_do_fork 做的第二件大事是 wake_up_new_task。新任务的建立&＃xff0c;有没有机会抢占别人&＃xff0c;获得 CPU 呢&＃xff1f;


void wake_up_new_task(struct task_struct *p)
{struct rq_flags rf;struct rq *rq;
......p->state &＃61; TASK_RUNNING;
......activate_task(rq, p, ENQUEUE_NOCLOCK);p->on_rq &＃61; TASK_ON_RQ_QUEUED;trace_sched_wakeup_new(p);check_preempt_curr(rq, p, WF_FORK);
......
}


首先&＃xff0c;需要将进程的状态设置为 TASK_RUNNING。

activate_task 函数中会调用 enqueue_task.


static inline void enqueue_task(struct rq *rq, struct task_struct *p, int flags)
{
.....p->sched_class->enqueue_task(rq, p, flags);
}


如果是 CFS 的调度类&＃xff0c;则指向相应的 enqueue_task_fair。


static void
enqueue_task_fair(struct rq *rq, struct task_struct *p, int flags)
{struct cfs_rq *cfs_rq;struct sched_entity *se &＃61; &p->se;
......cfs_rq &＃61; cfs_rq_of(se);enqueue_entity(cfs_rq, se, flags);
......cfs_rq->h_nr_running&＃43;&＃43;;
......
}


在 enqueue_task_fair 中取出的队列就是 cfs_rq, 然后调用 enqueue_entity。

在 enqueue_entity 函数里面&＃xff0c;会调用 update_curr, 更新运行的统计量&＃xff0c;然后调用 __enqueue_entity, 将 sched_entity 加入到红黑树里面&＃xff0c;然后将 se->on_rq &＃61; 1 设置在队列上。

回到 enqueue_task_fair 后&＃xff0c;将这个队列上运行的进程数目加一。然后&＃xff0c;wake_up_new_task 会调用 check_preempt_curr, 看是否能够抢占当前进程。

在 check_preempt_curr 中&＃xff0c;会调用相应的调度类的 rq->curr->sched_class->check_preempt_curr(rq, p, flags)。对于 CFS 来讲&＃xff0c;调用的是 check_preempt_wakeup。


static void check_preempt_wakeup(struct rq *rq, struct task_struct *p, int wake_flags)
{struct task_struct *curr &＃61; rq->curr;struct sched_entity *se &＃61; &curr->se, *pse &＃61; &p->se;struct cfs_rq *cfs_rq &＃61; task_cfs_rq(curr);
......if (test_tsk_need_resched(curr))return;
......find_matching_se(&se, &pse);update_curr(cfs_rq_of(se));if (wakeup_preempt_entity(se, pse) &＃61;&＃61; 1) {goto preempt;}return;
preempt:resched_curr(rq);
......
}


在 check_preempt_wakeup 函数中&＃xff0c;前面调用 task_fork_fair 的时候&＃xff0c;设置 sysctl_sched_child_runs_first 了&＃xff0c;已经将当前父进程的 TIF_NEED_RESCHED 设置了&＃xff0c;则直接返回。

否则&＃xff0c;check_preempt_wakeup 还是会调用 update_curr 更新一次统计量&＃xff0c;然后 wakeup_preempt_entity 将父进程和子进程 PK 一次&＃xff0c;看是不是要抢占&＃xff0c;如果要则调用 resched_curr 标记父进程为 TIF_NEED_RESCHED。

如果新创建的进程应该抢占父进程&＃xff0c;在什么时间抢占呢&＃xff1f;fork 是一个系统调用&＃xff0c;从系统调用返回的时候&＃xff0c;是抢占的一个好时机&＃xff0c;如果父进程判断自己已经被设置为 TIF_NEED_RESCHED&＃xff0c; 就让子进程先跑&＃xff0c;抢占自己。

总结
fork 系统调用包含两个重要的事件&＃xff0c;一个是将 task_struct 结构复制一份并且初始化&＃xff0c;另一个是试图唤醒新创建的子进程。

参考&＃xff1a;
趣谈 Linux 操作系统