[linux内核] 4.进程控制块和进程创建

学习内容来自庖丁解牛，仅作为个人学习研究用途，如作者认为侵权请联系第一时间删除。

1. 进程控制块

进程控制块也叫进程描述符，涵盖了进程相关的所有信息。
进程控制块PCB的定义位置在/linux3.18.6/include/linux/sched.h#1234，
起名为struct task_struct

下图为进程结构体示意图

---

1.1 进程状态信息

在PCB中的变量定义：volatile long state;

操作系统原理一书中提到进程分三态，就绪、运行、阻塞。实际linux系统有稍微区别。

当使用fork()系统调用来创建一个新进程时，新进程的状态是TASK_RUNNING（就绪态，但是没有在运行）。当调度器选择这个新创建的进程运行时，新创建的进程就切换到运行态，它也是TASK_RUNNING。进程是TASK_RUNNING状态时，它是可运行的，是否在运行取决于它有没有在CPU中实际执行。如果在CPU中实际执行了，进程状态就是运行态；如果被内核调度出去了，在等待队列里就是就绪态。

对于一个正在运行的进程，调用用户态库函数exit()会陷入内核执行该内核函数do_exit()，也就是终止进程，会进入TASK_ZOMBIE状态，即进程的终止状态。TASK_ZOMBIE状态的进程一般叫作僵尸进程，Linux 内核会在适当的时候把僵尸进程给处理掉，处理掉之后进程描述符被释放了，该进程才从 Linux 系统里消失

阻塞态也有两种：TASK_INTERRUPTIBLE和TASK_UNINTERRUPTIBLE。
TASK_INTERRUPTIBLE 可以被信号和 wake_up()唤醒，当信号到来时，进程会被设置为 TASK_RUNNING。
TASK_UNINTERRUPTIBLE 只能被 wake_up()唤醒。

内核中描述的进程状态的代码在linux-3.18.6/include/sched.h#203

/*
 * Task state bitmask. NOTE! These bits are also
 * encoded in fs/proc/array.c: get_task_state().
 *
 * We have two separate sets of flags: task->state
 * is about runnability, while task->exit_state are
 * about the task exiting. Confusing, but this way
 * modifying one set can't modify the other one by
 * mistake.
 */
#define TASK_RUNNING		0
#define TASK_INTERRUPTIBLE	1
#define TASK_UNINTERRUPTIBLE	2
#define __TASK_STOPPED		4
#define __TASK_TRACED		8
/* in tsk->exit_state */
#define EXIT_DEAD		16
#define EXIT_ZOMBIE		32
#define EXIT_TRACE		(EXIT_ZOMBIE | EXIT_DEAD)
/* in tsk->state again */
#define TASK_DEAD		64
#define TASK_WAKEKILL		128
#define TASK_WAKING		256
#define TASK_PARKED		512
#define TASK_STATE_MAX		1024

---

1.2 进程标识符

在PCB中的变量定义： pid_t pid; pid_t tgid;

pid和tgid标识进程。
pid => process id
tgid => thread group id

---

1.3 进程间的父子兄弟关系

在PCB中的变量定义

/*
	 * pointers to (original) parent process, youngest child, younger sibling,
	 * older sibling, respectively.  (p->father can be replaced with
	 * p->real_parent->pid)
	 */
	struct task_struct __rcu *real_parent; /* real parent process */
	struct task_struct __rcu *parent; /* recipient of SIGCHLD, wait4() reports */
	/*
	 * children/sibling forms the list of my natural children
	 */
	struct list_head children;	/* list of my children */
	struct list_head sibling;	/* linkage in my parent's children list */
	struct task_struct *group_leader;	/* threadgroup leader */

---

1.4 管理进程的双向链表

在PCB中的变量定义： struct list_head tasks;
struct list_head 数据结构定义在/linux-3.18.6/include/linux/ types.h#186，把所有的进程用双向循环链表链起来。

struct list_head { 
	struct list_head *next, *prev; 
}; 

---

1.5 保存进程上下文中CPU相关的状态信息的数据结构

在PCB中的变量定义：struct thread_struct thread;

---

---

1.6 内存管理

在PCB中的变量定义： struct mm_struct *mm, *active_mm;

mm 和 active_mm 是和进程地址空间、内存管理相关的数据结构指针。

---

2. 进程的创建

---

2.1 0号进程的初始化

0号进程的初始化是通过宏定义的硬编码方式固定下来的。除此之外，所有其他进程的初始化都是通过 do_fork 复制父进程的方式初始化的。

struct task_struct init_task = INIT_TASK(init_task);

2.2 进程创建过程

进程的创建就是把当前进程的描述符等相关进程资源复制一份，从而产生一个子进程，并根据子进程的需要对复制的进程描述符做一些修改，然后把创建好的子进程放入运行队列（操作系统原理中的就绪队列）。在进程调度时，新创建的子进程处于就绪状态有机会被调度执行。

注意fork一个子进程的过程中，复制父进程的资源时采用了Copy On Write（写时复制）技术，不需要修改进程资源，父子进程是共享内存存储空间的。

根据系统调用号表可以看到fork函数和sys_fork系统函数绑定，但是实际上fork函数会经过系统调用执行sys_clone，在sys_clone内核函数中再进入do_fork函数。

---

2.2.1 do_fork()函数

分析/linux-3.18.6/kernel/fork.c#1617处的do_fork函数

调用创建子进程函数，并根据需要把它放到不同的队列中

/*
 *  Ok, this is the main fork-routine.
 *
 * It copies the process, and if successful kick-starts
 * it and waits for it to finish using the VM if required.
 */
long do_fork(unsigned long clone_flags,
	      unsigned long stack_start,
	      unsigned long stack_size,
	      int __user *parent_tidptr,
	      int __user *child_tidptr)
/*
clone_flags:子进程创建相关标志，通过此标志可以对父进程的资源进行有选择的复制
stack_start:子进程用户态堆栈的地址。
regs：指向 pt_regs 结构体的指针。pt_regs是int和SAVE_ALL时压入栈的结构体
stack_size：用户态栈的大小，总被设置为 0。
parent_tidptr 和 child_tidptr：父进程、子进程用户态下的 pid 地址。
*/
{
	struct task_struct *p; //创建进程描述符指针
	int trace = 0;
	long nr;

	/*
	 * Determine whether and which event to report to ptracer.  When
	 * called from kernel_thread or CLONE_UNTRACED is explicitly
	 * requested, no event is reported; otherwise, report if the event
	 * for the type of forking is enabled.
	 */
	if (!(clone_flags & CLONE_UNTRACED)) {
		if (clone_flags & CLONE_VFORK)
			trace = PTRACE_EVENT_VFORK;
		else if ((clone_flags & CSIGNAL) != SIGCHLD)
			trace = PTRACE_EVENT_CLONE;
		else
			trace = PTRACE_EVENT_FORK;

		if (likely(!ptrace_event_enabled(current, trace)))
			trace = 0;
	}

	p = copy_process(clone_flags, stack_start, stack_size,
			 child_tidptr, NULL, trace);    //创建子进程的描述符和执行时所需的其他数据结构
	/*
	 * Do this prior waking up the new thread - the thread pointer
	 * might get invalid after that point, if the thread exits quickly.
	 */
	if (!IS_ERR(p)) {		//如果 copy_process 执行成功
		struct completion vfork;	//定义完成量（一个执行单元等待另一个执行单元完成某事）
		struct pid *pid;

		trace_sched_process_fork(current, p);

		pid = get_task_pid(p, PIDTYPE_PID);	//获得task结构体中的pid
		nr = pid_vnr(pid);			//根据pid结构体中获得进程pid 

		if (clone_flags & CLONE_PARENT_SETTID)
			put_user(nr, parent_tidptr);
		
		// 如果 clone_flags 包含 CLONE_VFORK 标志，就将完成量 vfork 赋值给进程描述符中的vfork_done字段，此处只是对完成量进行初始化

		if (clone_flags & CLONE_VFORK) {
			p->vfork_done = &vfork;
			init_completion(&vfork);
			get_task_struct(p);
		}

		wake_up_new_task(p); //将子进程添加到调度器的队列，使之有机会获得CPU

		/* forking complete and child started to run, tell ptracer */
		if (unlikely(trace))
			ptrace_event_pid(trace, pid);
		// 如果 clone_flags 包含 CLONE_VFORK 标志，就将父进程插入等待队列直到子进程调用exec函数或退出，此处是具体的阻塞
		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;	//返回子进程pid（父进程的fork函数返回的值为子进程pid的原因）
}

2.2.2 copy_process()函数

分析do_fork函数中的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; 
    ... 
    retval = security_task_create(clone_flags);//安全性检查
    ... 
    p = dup_task_struct(current); //复制PCB，为子进程创建内核栈、进程描述符
    ftrace_graph_init_task(p); 
    ··· 
 
    retval = -EAGAIN; 
    // 检查该用户的进程数是否超过限制
    if (atomic_read(&p->real_cred->user->processes) >= task_rlimit(p, RLIMIT_NPROC)) { 
        // 检查该用户是否具有相关权限，不一定是root 
        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; 
    if (!try_module_get(task_thread_info(p)->exec_domain->module)) 
        goto bad_fork_cleanup_count; 
    ... 
    spin_lock_init(&p->alloc_lock); //初始化自旋锁
    init_sigpending(&p->pending); //初始化挂起信号 
    posix_cpu_timers_init(p); //初始化CPU定时器
    ··· 
    retval = sched_fork(clone_flags, p); //初始化新进程调度程序数据结构，把新进程的状态设置为TASK_RUNNING，并禁止内核抢占
     ... 
    // 复制所有的进程信息
    shm_init_task(p); 
    retval = copy_semundo(clone_flags, p); 
    ... 
    retval = copy_files(clone_flags, p); 
    ... 
    retval = copy_fs(clone_flags, p); 
    ... 
    retval = copy_sighand(clone_flags, p); 
    ...
    retval = copy_signal(clone_flags, p); 
    ... 
    retval = copy_mm(clone_flags, p); 
    ... 
    retval = copy_namespaces(clone_flags, p); 
    ... 
    retval = copy_io(clone_flags, p); 
    ... 
    retval = copy_thread(clone_flags, stack_start, stack_size, p);// 初始化子进程内核栈
    ... 
    //若传进来的pid指针和全局结构体变量init_struct_pid的地址不相同，就要为子进程分配新的pid 
    if (pid != &init_struct_pid) { 
        retval = -ENOMEM; 
        pid = alloc_pid(p->nsproxy->pid_ns_for_children); 
        if (!pid) 
            goto bad_fork_cleanup_io; 
    } 
    ... 
    p->pid = pid_nr(pid); //根据pid结构体中获得进程pid 
    //若 clone_flags 包含 CLONE_THREAD标志，说明子进程和父进程在同一个线程组
    if (clone_flags & CLONE_THREAD) { 
        p->exit_signal = -1; 
        p->group_leader = current->group_leader; //将线程组的leader设为子进程的组leader 
        p->tgid = current->tgid; //子进程继承父进程的tgid 
    } else { 
        if (clone_flags & CLONE_PARENT) 
            p->exit_signal = current->group_leader->exit_signal; 
        else 
            p->exit_signal = (clone_flags & CSIGNAL); 
        p->group_leader = p; //子进程的组leader就是它自己
        p->tgid = p->pid; //组号tgid是它自己的pid 
    } 
    ... 
 
    if (likely(p->pid)) { 
        ptrace_init_task(p, (clone_flags & CLONE_PTRACE) || trace); 
        init_task_pid(p, PIDTYPE_PID, pid); 
        if (thread_group_leader(p)) { 
            ... 
            // 将子进程加入它所在组的散列链表中
            attach_pid(p, PIDTYPE_PGID); 
            attach_pid(p, PIDTYPE_SID); 
            __this_cpu_inc(process_counts); 
        } else { 
            ... 
        } 
        attach_pid(p, PIDTYPE_PID); 
        nr_threads++; //增加系统中的进程数目
    } 
    ... 
    return p; //返回被创建的子进程描述符指针P 
    ... 
} 

copy_process 函数主要完成了调用 dup_task_struct 复制当前进程（父进程）描述符task_struct、信息检查、初始化、把进程状态设置为TASK_RUNNING（此时子进程置为就绪态）、采用写时复制技术逐一复制所有其他进程资源、调用 copy_thread 初始化子进程内核栈、设置子进程 pid 等。

---

2.2.3 dup_task_struct()函数分析

dup_task_struct函数分析

复制父进程的task_struct信息和thread_info信息

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; 
    tsk = alloc_task_struct_node(node); //为子进程创建进程描述符分配存储空间
    ... 
    ti = alloc_thread_info_node(tsk, node); //实际上创建了两个页，一部分用来存放 thread_info，另一部分就是内核堆栈
    ... 
    err = arch_dup_task_struct(tsk, orig); //复制父进程的task_struct信息
    tsk->stack = ti; // 将栈底的值赋给新结点的stack 
 
    //对子进程的thread_info结构进行初始化(复制父进程的thread_info 结构，然后将 task 指针指向子进程的进程描述符) 
    setup_thread_stack(tsk, orig); 
    ... 
    return tsk; // 返回新创建的进程描述符指针
    ... 
} 

---

补充

thread_info 结构被称为小型的进程描述符。该结构通过 task 指针指向进程描述符。
thread_info完整定义如下

struct thread_info {
	struct task_struct	*task;		/* main task structure */
	struct exec_domain	*exec_domain;	/* execution domain */
	__u32			flags;		/* low level flags */
	__u32			status;		/* thread synchronous flags */
	__u32			cpu;		/* current CPU */
	int			saved_preempt_count;
	mm_segment_t		addr_limit;
	struct restart_block    restart_block;
	void __user		*sysenter_return;
	unsigned int		sig_on_uaccess_error:1;
	unsigned int		uaccess_err:1;	/* uaccess failed */
};

内核通过屏蔽 ESP 寄存器的低 13 位有效位获得 thread_info 结构的基地址。

内核栈和 thread_info 结构被定义在一个联合体当中，alloc_ thread_info_node 分配的实则是一个联合体，既分配了 thread_info 结构，又分配了内核栈。thread_union 联合体定义如下

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

---

2.2.4 copy_thread()函数

copy_progress函数中的copy_thread 函数分析

用于保存cpu寄存器(上下文)相关信息

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)) {
		/* kernel thread */
		memset(childregs, 0, sizeof(struct pt_regs));
        //如果创建的是内核线程，则从ret_from_kernel_thread开始执行
		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;
	}
    //复制内核堆栈（复制父进程的寄存器信息，即系统调用int指令和SAVE_ALL压栈的那一部分内容）
	*childregs = *current_pt_regs();
	childregs->ax = 0;  //将子进程的eax置0，所以fork的子进程返回值为0 
	if (sp)
		childregs->sp = sp;
    //ip指向 ret_from_fork，子进程从此处开始执行
	p->thread.ip = (unsigned long) ret_from_fork;
	task_user_gs(p) = get_user_gs(current_pt_regs());

	...
	return err;
}

2.2.5 fork调用图示