Linux核心是如何建立一個新程式的？

程式描述

程式描述符（task_struct）

用來描述程式的資料結構，可以理解為程式的屬性。比如程式的狀態、程式的標識（PID）等，都被封裝在了程式描述符這個資料結構中，該資料結構被定義為task_struct

程式控制塊（PCB）

是作業系統核心中一種資料結構，主要表示程式狀態。

程式狀態

fork()

fork()在父、子程式各返回一次。在父程式中返回子程式的 pid，在子程式中返回0。

fork一個子程式的程式碼

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(int argc, char * argv[])
{
  int pid;
  /* fork another process */

  pid = fork();
  if (pid < 0) 
  { 
      /* error occurred */
      fprintf(stderr,"Fork Failed!");
      exit(-1);
  } 
  else if (pid == 0) 
  {
      /* child process */
      printf("This is Child Process!\n");
  } 
  else 
  {  
      /* parent process  */
      printf("This is Parent Process!\n");
      /* parent will wait for the child to complete*/
      wait(NULL);
      printf("Child Complete!\n");
  }
}

程式建立

大致流程

fork 通過0×80中斷（系統呼叫）來陷入核心，由系統提供的相應系統呼叫來完成程式的建立。

fork.c

//fork
#ifdef __ARCH_WANT_SYS_FORK
SYSCALL_DEFINE0(fork)
{
#ifdef CONFIG_MMU
	return do_fork(SIGCHLD, 0, 0, NULL, NULL);
#else
	/* can not support in nommu mode */
	return -EINVAL;
#endif
}
#endif

//vfork
#ifdef __ARCH_WANT_SYS_VFORK
SYSCALL_DEFINE0(vfork)
{
	return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, 0,
			0, NULL, NULL);
}
#endif

//clone
#ifdef __ARCH_WANT_SYS_CLONE
#ifdef CONFIG_CLONE_BACKWARDS
SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp,
		 int __user *, parent_tidptr,
		 int, tls_val,
		 int __user *, child_tidptr)
#elif defined(CONFIG_CLONE_BACKWARDS2)
SYSCALL_DEFINE5(clone, unsigned long, newsp, unsigned long, clone_flags,
		 int __user *, parent_tidptr,
		 int __user *, child_tidptr,
		 int, tls_val)
#elif defined(CONFIG_CLONE_BACKWARDS3)
SYSCALL_DEFINE6(clone, unsigned long, clone_flags, unsigned long, newsp,
		int, stack_size,
		int __user *, parent_tidptr,
		int __user *, child_tidptr,
		int, tls_val)
#else
SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp,
		 int __user *, parent_tidptr,
		 int __user *, child_tidptr,
		 int, tls_val)
#endif
{
	return do_fork(clone_flags, newsp, 0, parent_tidptr, child_tidptr);
}
#endif

通過看上邊的程式碼，我們可以清楚的看到，不論是使用 fork 還是 vfork 來建立程式，最終都是通過 do_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)
{
		//建立程式描述符指標
		struct task_struct *p;

		//……

		//複製程式描述符，copy_process()的返回值是一個 task_struct 指標。
		p = copy_process(clone_flags, stack_start, stack_size,
			 child_tidptr, NULL, trace);

		if (!IS_ERR(p)) {
			struct completion vfork;
			struct pid *pid;

			trace_sched_process_fork(current, p);

			//得到新建立的程式描述符中的pid
			pid = get_task_pid(p, PIDTYPE_PID);
			nr = pid_vnr(pid);

			if (clone_flags & CLONE_PARENT_SETTID)
				put_user(nr, parent_tidptr);

			//如果呼叫的 vfork()方法，初始化 vfork 完成處理資訊。
			if (clone_flags & CLONE_VFORK) {
				p->vfork_done = &vfork;
				init_completion(&vfork);
				get_task_struct(p);
			}

			//將子程式加入到排程器中，為其分配 CPU，準備執行
			wake_up_new_task(p);

			//fork 完成，子程式即將開始執行
			if (unlikely(trace))
				ptrace_event_pid(trace, pid);

			//如果是 vfork，將父程式加入至等待佇列，等待子程式完成
			if (clone_flags & CLONE_VFORK) {
				if (!wait_for_vfork_done(p, &vfork))
					ptrace_event_pid(PTRACE_EVENT_VFORK_DONE, pid);
			}

			put_pid(pid);
		} else {
			nr = PTR_ERR(p);
		}
		return nr;
}

do_fork 流程

• 呼叫 copy_process 為子程式複製出一份程式資訊
• 如果是 vfork 初始化完成處理資訊
• 呼叫 wake_up_new_task 將子程式加入排程器，為之分配 CPU
• 如果是 vfork，父程式等待子程式完成 exec 替換自己的地址空間

copy_process 流程

追蹤copy_process 程式碼（部分）

static 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)
{
	int retval;

	//建立程式描述符指標
	struct task_struct *p;

	//……

	//複製當前的 task_struct
	p = dup_task_struct(current);

	//……

	//初始化互斥變數	
	rt_mutex_init_task(p);

	//檢查程式數是否超過限制，由作業系統定義
	if (atomic_read(&p->real_cred->user->processes) >=
			task_rlimit(p, RLIMIT_NPROC)) {
		if (p->real_cred->user != INIT_USER &&
		    !capable(CAP_SYS_RESOURCE) && !capable(CAP_SYS_ADMIN))
			goto bad_fork_free;
	}

	//……

	//檢查程式數是否超過 max_threads 由記憶體大小決定
	if (nr_threads >= max_threads)
		goto bad_fork_cleanup_count;

	//……

	//初始化自旋鎖
	spin_lock_init(&p->alloc_lock);
	//初始化掛起訊號
	init_sigpending(&p->pending);
	//初始化 CPU 定時器
	posix_cpu_timers_init(p);

	//……

	//初始化程式資料結構，並把程式狀態設定為 TASK_RUNNING
	retval = sched_fork(clone_flags, p);

	//複製所有程式資訊，包括檔案系統、訊號處理函式、訊號、記憶體管理等
	if (retval)
		goto bad_fork_cleanup_policy;

	retval = perf_event_init_task(p);
	if (retval)
		goto bad_fork_cleanup_policy;
	retval = audit_alloc(p);
	if (retval)
		goto bad_fork_cleanup_perf;
	/* copy all the process information */
	shm_init_task(p);
	retval = copy_semundo(clone_flags, p);
	if (retval)
		goto bad_fork_cleanup_audit;
	retval = copy_files(clone_flags, p);
	if (retval)
		goto bad_fork_cleanup_semundo;
	retval = copy_fs(clone_flags, p);
	if (retval)
		goto bad_fork_cleanup_files;
	retval = copy_sighand(clone_flags, p);
	if (retval)
		goto bad_fork_cleanup_fs;
	retval = copy_signal(clone_flags, p);
	if (retval)
		goto bad_fork_cleanup_sighand;
	retval = copy_mm(clone_flags, p);
	if (retval)
		goto bad_fork_cleanup_signal;
	retval = copy_namespaces(clone_flags, p);
	if (retval)
		goto bad_fork_cleanup_mm;
	retval = copy_io(clone_flags, p);

	//初始化子程式核心棧
	retval = copy_thread(clone_flags, stack_start, stack_size, p);

	//為新程式分配新的 pid
	if (pid != &init_struct_pid) {
		retval = -ENOMEM;
		pid = alloc_pid(p->nsproxy->pid_ns_for_children);
		if (!pid)
			goto bad_fork_cleanup_io;
	}

	//設定子程式 pid	
	p->pid = pid_nr(pid);

	//……

	//返回結構體 p
	return p;

• 呼叫 dup_task_struct 複製當前的 task_struct
• 檢查程式數是否超過限制
• 初始化自旋鎖、掛起訊號、CPU 定時器等
• 呼叫 sched_fork 初始化程式資料結構，並把程式狀態設定為 TASK_RUNNING
• 複製所有程式資訊，包括檔案系統、訊號處理函式、訊號、記憶體管理等
• 呼叫 copy_thread 初始化子程式核心棧
• 為新程式分配並設定新的 pid

dup_task_struct 流程

static struct task_struct *dup_task_struct(struct task_struct *orig)
{
	struct task_struct *tsk;
	struct thread_info *ti;
	int node = tsk_fork_get_node(orig);
	int err;

	//分配一個 task_struct 節點
	tsk = alloc_task_struct_node(node);
	if (!tsk)
		return NULL;

	//分配一個 thread_info 節點，包含程式的核心棧，ti 為棧底
	ti = alloc_thread_info_node(tsk, node);
	if (!ti)
		goto free_tsk;

	//將棧底的值賦給新節點的棧
	tsk->stack = ti;

	//……

	return tsk;

}

呼叫alloc_task_struct_node分配一個 task_struct 節點

呼叫alloc_thread_info_node分配一個 thread_info 節點，其實是分配了一個thread_union聯合體,將棧底返回給 ti

union thread_union {
   struct thread_info thread_info;
  unsigned long stack[THREAD_SIZE/sizeof(long)];
};

最後將棧底的值 ti 賦值給新節點的棧

最終執行完dup_task_struct之後，子程式除了tsk->stack指標不同之外，全部都一樣！

sched_fork 流程

core.c

int sched_fork(unsigned long clone_flags, struct task_struct *p)
{
	unsigned long flags;
	int cpu = get_cpu();

	__sched_fork(clone_flags, p);

	//將子程式狀態設定為 TASK_RUNNING
	p->state = TASK_RUNNING;

	//……

	//為子程式分配 CPU
	set_task_cpu(p, cpu);

	put_cpu();
	return 0;
}

我們可以看到sched_fork大致完成了兩項重要工作，一是將子程式狀態設定為 TASK_RUNNING，二是為其分配 CPU

copy_thread 流程

int copy_thread(unsigned long clone_flags, unsigned long sp,
	unsigned long arg, struct task_struct *p)
{
	//獲取暫存器資訊
	struct pt_regs *childregs = task_pt_regs(p);
	struct task_struct *tsk;
	int err;

	p->thread.sp = (unsigned long) childregs;
	p->thread.sp0 = (unsigned long) (childregs+1);
	memset(p->thread.ptrace_bps, 0, sizeof(p->thread.ptrace_bps));

	if (unlikely(p->flags & PF_KTHREAD)) {
		//核心執行緒
		memset(childregs, 0, sizeof(struct pt_regs));
		p->thread.ip = (unsigned long) ret_from_kernel_thread;
		task_user_gs(p) = __KERNEL_STACK_CANARY;
		childregs->ds = __USER_DS;
		childregs->es = __USER_DS;
		childregs->fs = __KERNEL_PERCPU;
		childregs->bx = sp;	/* function */
		childregs->bp = arg;
		childregs->orig_ax = -1;
		childregs->cs = __KERNEL_CS | get_kernel_rpl();
		childregs->flags = X86_EFLAGS_IF | X86_EFLAGS_FIXED;
		p->thread.io_bitmap_ptr = NULL;
		return 0;
	}

	//將當前暫存器資訊複製給子程式
	*childregs = *current_pt_regs();

	//子程式 eax 置 0，因此fork 在子程式返回0
	childregs->ax = 0;
	if (sp)
		childregs->sp = sp;

	//子程式ip 設定為ret_from_fork，因此子程式從ret_from_fork開始執行
	p->thread.ip = (unsigned long) ret_from_fork;

	//……

	return err;
}

copy_thread 這段程式碼為我們解釋了兩個相當重要的問題！

一是，為什麼 fork 在子程式中返回0，原因是childregs->ax = 0;這段程式碼將子程式的 eax 賦值為0

二是，p->thread.ip = (unsigned long) ret_from_fork;將子程式的 ip 設定為 ret_form_fork 的首地址，因此子程式是從 ret_from_fork 開始執行的

總結

新程式的執行源於以下前提：

• dup_task_struct中為其分配了新的堆疊
• 呼叫了sched_fork，將其置為TASK_RUNNING
• copy_thread中將父程式的暫存器上下文複製給子程式，保證了父子程式的堆疊資訊是一致的
• 將ret_from_fork的地址設定為eip暫存器的值

最終子程式從ret_from_fork開始執行