《Linux内核分析》第六周学习总结

学习内容：分析Linux内核建立一个新进程的过程

1. 阅读理解task_struct数据结构
   

2. 分析fork函数对应的内核处理过程sys_clone，理解建立一个新进程如何建立和修改task_struct数据结构；

3. 使用gdb跟踪分析一个fork系统调用内核处理函数sys_clone ，验证对Linux系统建立一个新进程的理解,

4. 特别关注新进程是从哪里开始执行的？为何从哪里能顺利执行下去？即执行起点与内核堆栈如何保证一致。

一.进程分析

(一)进程控制块PCB——task_struct

对于一个进程来讲，PCB就好像是他的记帐先生，当一个进程被建立时PCB就被分配，而后有关进程的全部信息就全都存储在PCB中，例如，打开的文件，页表基址寄存器，进程号等等。在linux中PCB是用结构task_struct来表示的，咱们首先来看一下task_struct的组成（代码位于linux/include/linux/Sched.h）

代码以下：

struct task_struct { long state; //表示进程的状态，-1表示不可执行，0表示可执行，>0表示中止
    long counter;/* 运行时间片,以jiffs递减计数 */
    long priority; /* 运行优先数,开始时,counter = priority,值越大,表示优先数越高,等待时间越长. */
    long signal;/* 信号.是一组位图,每个bit表明一种信号. */
    struct sigaction sigaction[32]; /* 信号响应的数据结构, 对应信号要执行的操做和标志信息 */
    long blocked;   /* 进程信号屏蔽码(对应信号位图) */
/* various fields */
    int exit_code; /* 任务执行中止的退出码,其父进程会取 */ unsigned long start_code,end_code,end_data,brk,start_stack;/* start_code代码段地址,end_code代码长度(byte), end_data代码长度+数据长度(byte),brk总长度(byte),start_stack堆栈段地址 */
    long pid,father,pgrp,session,leader;/* 进程号,父进程号 ,父进程组号,会话号,会话头(发起者)*/ unsigned short uid,euid,suid;/* 用户id 号,有效用户 id 号,保存用户 id 号*/ unsigned short gid,egid,sgid;/* 组标记号 (组id),有效组 id,保存的组id */
    long alarm;/* 报警定时值 (jiffs数) */
    long utime,stime,cutime,cstime,start_time;/* 用户态运行时间 (jiffs数), 系统态运行时间 (jiffs数),子进程用户态运行时间,子进程系统态运行时间,进程开始运行时刻 */ unsigned short used_math;/* 是否使用了协处理器 */
/* file system info */
    int tty;        /* 进程使用tty的子设备号. -1表示设有使用 */ unsigned short umask; /* 文件建立属性屏蔽位 */
    struct m_inode * pwd; /* 当前工做目录 i节点结构 */
    struct m_inode * root; /* 根目录i节点结构 */
    struct m_inode * executable;/* 执行文件i节点结构 */ unsigned long close_on_exec; /* 执行时关闭文件句柄位图标志. */
    struct file * filp[NR_OPEN]; /* 文件结构指针表,最多32项. 表项号便是文件描述符的值 */
    struct desc_struct ldt[3]; /* 任务局部描述符表.0-空,1-cs段,2-Ds和Ss段 */
    struct tss_struct tss; /* 进程的任务状态段信息结构 */ };

 

PCB task_struct中包含

1.  进程状态
2.  进程打开的文件
3.  进程优先级信息

理解这一个过程能够用一个想象的框架：Linux经过复制父进程来建立一个新进程，复制一个PCB——task_struct

 err = arch_dup_task_struct(tsk, orig);

  要给新进程分配一个新的内核堆栈

ti = alloc_thread_info_node(tsk, node); tsk->stack = ti; setup_thread_stack(tsk, orig); //这里只是复制thread_info，而非复制内核堆栈

建立一个新进程在内核中的执行过程：fork、vfork和clone三个系统调用均可以建立一个新进程，并且都是经过调用do_fork来实现进程的建立；

1. fork，建立子进程

2. vfork，与fork相似，可是父子进程共享地址空间，并且子进程先于父进程运行。

3. clone，主要用于建立线程

这三个代码分别是:

SYSCALL_DEFINE0(fork) { return do_fork(SIGCHLD, 0, 0, NULL, NULL); } #endif SYSCALL_DEFINE0(vfork) { return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, 0, 0, NULL, NULL); } SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp, int __user *, parent_tidptr, int __user *, child_tidptr, int, tls_val) { return do_fork(clone_flags, newsp, 0, parent_tidptr, child_tidptr); }

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; int trace = 0; long nr;// 复制进程描述符，返回建立的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); // 取出task结构体内的pid
        pid = get_task_pid(p, PIDTYPE_PID); nr = pid_vnr(pid); if (clone_flags & CLONE_PARENT_SETTID) put_user(nr, parent_tidptr); // 若是使用的是vfork，那么必须采用某种完成机制，确保父进程后运行
        if (clone_flags & CLONE_VFORK) { p->vfork_done = &vfork; init_completion(&vfork); get_task_struct(p); } // 将子进程添加到调度器的队列，使得子进程有机会得到CPU
 wake_up_new_task(p);// 若是设置了 CLONE_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的事情：

1. 调用copy_process，将当期进程复制一份出来为子进程，而且为子进程设置相应地上下文信息。

2. 初始化vfork的完成处理信息（若是是vfork调用）

3. 调用wake_up_new_task，将子进程放入调度器的队列中，此时的子进程就能够被调度进程选中，得以运行。

4. 若是是vfork调用，须要阻塞父进程，知道子进程执行exec。

 

 理解这一个过程提供一个想象的框架：Linux经过复制父进程来建立一个新进程，复制一个PCB——task_struct

 err = arch_dup_task_struct(tsk, orig);

  要给新进程分配一个新的内核堆栈

ti = alloc_thread_info_node(tsk, node); tsk->stack = ti; setup_thread_stack(tsk, orig); //这里只是复制thread_info，而非复制内核堆栈

 

从用户态的代码看fork();函数返回了两次，即在父子进程中各返回一次，父进程从系统调用中返回比较容易理解，子进程从系统调用中返回，那它在系统调用处理过程当中的哪里开始执行的呢？这就涉及子进程的内核堆栈数据状态和task_struct中thread记录的sp和ip的一致性问题，这是在哪里设定的？copy_thread in copy_process

 

*childregs = *current_pt_regs(); //复制内核堆栈

childregs->ax = 0; //为何子进程的fork返回0，这里就是缘由！

p->thread.sp = (unsigned long) childregs; //调度到子进程时的内核栈顶

p->thread.ip = (unsigned long) ret_from_fork; //调度到子进程时的第一条指令地址

 

（二）进程建立的关键

（1）copy_process函数：在进程建立的do_fork函数中调用，主要完成进程数据结构，各类资源的初始化。初始化方式能够从新分配，也能够共享父进程资源，

大致流程：

1. 检查各类标志位 2. 调用dup_task_struct复制一份task_struct结构体，做为子进程的进程描述符。 3. 检查进程的数量限制。 4. 初始化定时器、信号和自旋锁。 5. 初始化与调度有关的数据结构，调用了sched_fork，这里将子进程的state设置为TASK_RUNNING。 6. 复制全部的进程信息，包括fs、信号处理函数、信号、内存空间（包括写时复制）等。 7. 调用copy_thread，这又是关键的一步，这里设置了子进程的堆栈信息。 8. 为子进程分配一个pid9. 设置子进程与其余进程的关系，以及pid、tgid等

关键地方:

tsk = alloc_task_struct_node(node);//为task_struct开辟内存 
ti = alloc_thread_info_node(tsk, node);//ti指向thread_info的首地址，同时也是系统为新进程分配的两个连续页面的首地址。 
err = arch_dup_task_struct(tsk, orig);//复制父进程的task_struct信息到新的task_struct里, (dst = src;) 
tsk->stack = ti;task的对应栈 setup_thread_stack(tsk, orig);//初始化thread info结构 
set_task_stack_end_magic(tsk);//栈结束的地址设置数据为栈结束标示(for overflow detection)

代码以下：

/* 建立进程描述符以及子进程所须要的其余全部数据结构 为子进程准备运行环境 */
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与当前进程的task，仅仅是stack地址不一样
    p = dup_task_struct(current); // 检查该用户的进程数是否超过限制
    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; } retval = -EAGAIN; // 检查进程数量是否超过 max_threads，后者取决于内存的大小
    if (nr_threads >= max_threads) goto bad_fork_cleanup_count; // 初始化自旋锁 // 初始化挂起信号 // 初始化定时器 // 完成对新进程调度程序数据结构的初始化，并把新进程的状态设置为TASK_RUNNING
    retval = sched_fork(clone_flags, p); // ..... // 复制全部的进程信息 // copy_xyz // 初始化子进程的内核栈
    retval = copy_thread(clone_flags, stack_start, stack_size, p); if (retval) goto bad_fork_cleanup_io; if (pid != &init_struct_pid) { retval = -ENOMEM; // 这里为子进程分配了新的pid号
        pid = alloc_pid(p->nsproxy->pid_ns_for_children); if (!pid) goto bad_fork_cleanup_io; } /* ok, now we should be set up.. */
    // 设置子进程的pid
    p->pid = pid_nr(pid); // 若是是建立线程
    if (clone_flags & CLONE_THREAD) { p->exit_signal = -1; // 线程组的leader设置为当前线程的leader
        p->group_leader = current->group_leader; // tgid是当前线程组的id，也就是main进程的pid
        p->tgid = current->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; // tgid和pid相同
        p->tgid = p->pid; } if (clone_flags & (CLONE_PARENT|CLONE_THREAD)) { // 若是是建立线程，那么同一线程组内的全部线程、进程共享parent
        p->real_parent = current->real_parent; p->parent_exec_id = current->parent_exec_id; } else { // 若是是建立进程，当前进程就是子进程的parent
        p->real_parent = current; p->parent_exec_id = current->self_exec_id; } // 将pid加入PIDTYPE_PID这个散列表
 attach_pid(p, PIDTYPE_PID); // 递增 nr_threads的值
    nr_threads++; // 返回被建立的task结构体指针
    return p; }

（2）copy_thread函数：为子进程准备了上下文堆栈信息

copy_thread的流程以下：

1. 获取子进程寄存器信息的存放位置 2. 对子进程的thread.sp赋值，未来子进程运行，这就是子进程的esp寄存器的值。 3. 若是是建立内核线程，那么它的运行位置是ret_from_kernel_thread，将这段代码的地址赋给thread.ip，以后准备其余寄存器信息，退出。 4. 将父进程的寄存器信息复制给子进程。 5. 将子进程的eax寄存器值设置为0，因此fork调用在子进程中的返回值为0。 6. 子进程从ret_from_fork开始执行，因此它的地址赋给thread.ip，也就是未来的eip寄存器。

// 初始化子进程的内核栈
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)); // 内核线程开始执行的位置
        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; // 子进程从ret_from_fork开始执行
    p->thread.ip = (unsigned long) ret_from_fork; task_user_gs(p) = get_user_gs(current_pt_regs()); return err; }

从流程中看出，子进程复制了父进程的上下文信息，仅仅对某些地方作了改动，运行逻辑和父进程彻底一致。

子进程从ret_from_fork处开始执行。

（3）dup_ task_ struct函数

流程以下：

1.先调用分配一个结构体。alloc_task_struct_nodetask_struct

2.调用，分配了一个union。这里分配了一个结构体，还分配了一个stack数组。返回值为ti，实际上就是栈底。alloc_thread_info_nodethread_info

将栈底的地址赋给task的stack变量。3.tsk->stack = ti

4.最后为子进程分配了内核栈空间。

5.执行完以后，子进程和父进程的task结构体，除了stack指针以外，彻底相同。dup_task_struct

（三）新进程的执行

新进程从ret_from_fork处开始执行，子进程的运行是由这几处保证的：

子进程系统调用处理过程1. dup_task_struct中为其分配了新的堆栈 2. copy_process中调用了sched_fork，将其置为TASK_RUNNING 3. copy_thread中将父进程的寄存器上下文复制给子进程，这是很是关键的一步，这里保证了父子进程的堆栈信息是一致的。 4. 将ret_from_fork的地址设置为eip寄存器的值，这是子进程的第一条指令。

（四）

*childregs = *current_pt_regs(); //复制内核堆栈
childregs->ax = 0; //子进程的fork返回0的缘由
p->thread.sp = (unsigned long) childregs; //调度到子进程时的内核栈顶
p->thread.ip = (unsigned long) ret_from_fork; //调度到子进程时的第一条指令地址

 

实践：使用gdb跟踪分析一个fork系统调用内核处理函数sys_clone 

启动MenuOS和gdb调试

cd LinuxKernel rm menu -rf git clone https://github.com/mengning/menu.git
cd menu mv test_fork.c test.c make rootfs qemu -kernel linux-3.18.6/arch/x86/boot/bzImage -initrd rootfs.img -s -S


在新窗口中启动调试
gdb 
file linux-3.18.6/vmlinux 
target remote:1234

实验截图以下：

 

 

 

 

 

4、总结

能够将上面繁琐的进程建立过程总结为一下的几步：

一、调用fork（）函数引起0x80中断 
二、调用sys_fork 
三、经过find_empty_process为新进程分配一个进程号 
四、经过copy_process函数使子进程复制父进程的资源，并进行一些个性化设置后，返回进程号。