linux創建進程do_fork()詳解

fork()

fork 通過0x80中斷（系統調用）來陷入內核，由系統提供的相應系統調用來完成進程的創建。

//fork
#ifdef __ARCH_WANT_SYS_FORK
SYSCALL_DEFINE0(fork)
{
#ifdef CONFIG_MMU
	return do_fork(SIGCHLD, 0, 0, NULL, NULL); //do_fork()後文進行講解
#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

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()函數將fork()之前的信息複製一份給子進程。
如果是vfork的話，直接初始化完成處理信息。
用wake_up_new_task()函數將新創建的進程加入到調度器中，爲其分配CPU。
如果是vfork(),父進程會等待子進程結束或者子進程調用exec函數族。

下面來看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;

copy_process()函數的執行流程

首先創建進程指針
複製當前的task_struct(下面會將到dup_task_struct()函數)
初始化互斥變量
檢查進程數是否超過限制，由操作系統完成。
初始化一些變量
初始化進程數據結構，將進程狀態設置爲TASK_RUNNING
複製創建進程所需要的父進程的信息。如文件系統，信號，內存管理等
初始化子進程內核棧
最後設置子進程ID

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

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_from_fork的首地址，因此子進程是從ret_from_fork開始執行的。在用戶看來就是從fork()返回後開始執行。

閱讀do_frok源碼後，可以讓我們更加了解內核中是如何創建一個新的進程。也可以讓我們對書上的概念理解的更深。
本文參考鏈接點我

linux創建進程do_fork()詳解

fork()

do_fork()

下面來看copy_process()函數源碼

dup_task_struct()

sched_fork()

copy_thread()

教你用Perl實現Smgp協議

如何通過前端表格控件在10分鐘內完成一張分組報表？

win11關閉自動檢測病毒刪文件

千兆寬帶實際網速能到達多少？

線程同步機制——POSIX信號量、互斥量、條件變量

c++11線程的使用坑點總結

linux創建進程do_fork()詳解

Muduo學習筆記—Eventloop Channel EPollPoller類

線程池（linux）

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結