从整理上理解进程创建、可执行文件的加载和进程执行进程切换，重点理解分析fork、execve和进程切换...

• 原创作品转载请注明出处 + https://github.com/mengning/linuxkernel/
  • 进程的创建
    1. 阅读理解task_struct数据结构
    2. 分析fork函数对应的内核处理过程do_fork，理解创建一个新进程如何创建和修改task_struct数据结构
    3. 使用gdb跟踪分析一个fork系统调用内核处理函数do_fork
  • 可执行文件的加载
    1. 理解编译链接的过程和ELF可执行文件格式
    2. 编程使用exec*库函数加载一个可执行文件，动态链接分为可执行程序装载时动态链接和运行时动态链接
    3. 使用gdb跟踪分析一个execve系统调用内核处理函数do_execve
  • 进程切换
    1. 分析一个schedule()函数

　　　　　　　　2.  仔细分析switch_to中的汇编代码

　　

1.task_struct分析

• 进程在TASK_RUNNING下是可运行的，但它有没有运行取决于它有没有获得cpu的控制权，即这个进程有没有在cpu上实际的执行
• 进程的标示pid
• 程序创建的进程具有父子关系，在编程时往往需要引用这样的父子关系。进程描述符中有几个域用来表示这样的关系

2.分析fork函数对应的内核处理过程do_fork()

fork、vfork和clone三个系统调用都可以创建一个新进程，而且都是通过调用do_fork来实现进程的创建；
具体过程如下：fork() -> sys_clone() -> do_fork() -> dup_task_struct() -> copy_process() -> copy_thread() -> ret_from_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;
    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。

　　进程如何创建？

1. 通过调用do_fork()来实现进程的创建；
2. 复制父进程PCB–task_struct来创建一个新进程，要给新进程分配一个新的内核堆栈;
3. 修改复制过来的进程数据，比如pid、进程链表等等执行copy_process和copy_thread
4. 成功创建新进程

3.使用gdb跟踪分析一个fork系统调用内核处理函数do_fork

• cd LinuxKernel 
• rm menu -rf
• git clone https://github.com/mengning/menu.git
• cd menu
• mv test_fork.c test.c
• make rootfs

打断点

• gdb
• file linux-3.18.6/vmlinux
• target remote:123

追踪断点

1. 新进程是从哪里开始执行的？为什么从哪里能顺利执行下去？

int copy_thread(unsigned long clone_flags, unsigned long sp,
    unsigned long arg, struct task_struct *p)
{
    ...
    *childregs = *current_pt_regs();
    childregs->ax = 0;
    if (sp)
        childregs->sp = sp;
    p->thread.ip = (unsigned long) ret_from_fork;
    ...
}

childregs->ax = 0;这段代码将子进程的 eax 赋值为0

子进程执行ret_from_fork

ENTRY(ret_from_fork)
    CFI_STARTPROC
    pushl_cfi %eax
    call schedule_tail
    GET_THREAD_INFO(%ebp)
    popl_cfi %eax
    pushl_cfi $0x0202       # Reset kernel eflags
    popfl_cfi
    jmp syscall_exit
    CFI_ENDPROC
END(ret_from_fork)

p->thread.ip = (unsigned long) ret_from_fork;这句代码将子进程的 ip 设置为 ret_form_fork 的首地址，因此子进程是从 ret_from_fork 开始执行的。
因此，函数copy_process中的copy_thread()决定了子进程从系统调用中返回后的执行。
　　2.执行起点与内核堆栈如何保证一致?

在ret_from_fork之前,也就是在copy_thread()函数中：*childregs = *current_pt_regs();
该句将父进程的regs参数赋值到子进程的内核堆栈,*childregs的类型为pt_regs,里面存放了SAVE ALL中压入栈的参数。故在之后的RESTORE ALL中能顺利执行下去

 

4.理解编译链接的过程和ELF可执行文件格式

修改MenuOS中test.c源文件，加入execlp("/bin/ls","ls",NULL);重新编译后使用gdb追踪

 

do_execve断点

静态链接
　  在编译链接时直接将需要的执行代码复制到最终可执行文件中，有点是代码的装在速度块，执行速度也比较快，对外部环境依赖度低。编译时它会把需要的所有代码都链接进去，应用程序相对较大。
动态链接
　  动态链接是在程序运行时由操作系统将需要的动态库加载到内存中。动态链接分为装载时动态链接和运行时动态链接。

5.编程使用exec*库函数加载一个可执行文件，动态链接分为可执行程序装载时动态链接和运行时动态链接

exec函数主要工作是根据指定的文件名找到可执行的文件，并用他取代调用进程的内容。换句话说，就是在调用进程内部执行一个可执行文件。这里的可执行文件既可以是二进制文件，也可以是任何Linux下可执行的脚本文件。

6.使用gdb跟踪分析一个schedule()函数

schedule主要完成的工作内容如下：
（1）sched_submit_work用于检测当前进程是否有plugged io需要处理，由于当前进程执行schedule后，有可能会进入休眠，所以在休眠之前需要把plugged io处理掉放置死锁。
（2）执行__schedule()这个函数是调度的核心处理函数，当前CPU会选择到下一个合适的进程去执行了。
（3）need_resched()执行到这里时说明当前进程已经被调度器再次执行了，此时要判断是否需要再次执行调度

7.特别关注新的可执行程序是从哪里开始执行的？为什么execve系统调用返回后新的可执行程序能顺利执行？对于静态链接的可执行程序和动态链接的可执行程序execve系统调用返回时会有什么不同？

新的可执行程序通过修改内核堆栈eip作为新程序的起点，
从new_ip开始执行后start_thread把返回到用户态的位置从int 0x80的下一条指令变成新加载的可执行文件的入口位置。

当execve系统调用返回时，返回新的可执行程序的执行起点（main函数），所以execve系统调用返回后新的可执行程序能顺利执行。

 

8.理解Linux系统中进程调度的时机，可以在内核代码中搜索schedule()函数，看都是哪里调用了schedule()，判断我们课程内容中的总结是否准确

中断处理过程（包括时钟中断、I/O中断、系统调用和异常）中，直接调用schedule()，或者返回用户态时根据need_resched标记调用schedule()
内核线程可以直接调用schedule()进行进程切换，也可以在中断处理过程中进行调度，也就是说内核线程作为一类的特殊的进程可以主动调度，也可以被动调度；
用户态进程无法实现主动调度，仅能通过陷入内核态后的某个时机点进行调度，即在中断处理过程中进行调度。

9.使用gdb跟踪分析一个schedule()函数 ，验证对Linux系统进程调度与进程切换过程的理解

首先设几个断点分别是schedule，pick_next_task，context_switch，__switch_to

context_switch在__schedule函数中

pick_next_task

context_switch

 

总结

1.“Linux系统创建一个新进程”的理解

Linux通过复制父进程来创建一个新进程,通过调用do_fork来实现并为每个新创建的进程动态地分配一个task_struct结构。为了把内核中的所有进程组织起来，Linux提供了几种组织方式，其中哈希表和双向循环链表方式是针对系统中的所有进程（包括内核线程），而运行队列和等待队列是把处于同一状态的进程组织起来。

fork()函数被调用一次，但返回两次。

可以通过fork，复制一个已有的进程，进而产生一个子进程，新进程几乎但不完全与父进程相同。子进程得到和父进程用户级虚拟地址空间相同的一份拷贝，包括代码段，数据段和bss段，堆以及用户栈。子进程还获得和父进程任何打开文件描述符相同的拷贝，最大的区别就是在于他们拥有不同的PID.

 2.“Linux内核装载和启动一个可执行程序” 

linux通过sys_execve()系统调用从文件系统中读取、识别并加载elf。

调用sys_execve后,执行过程:

do_execve -> do_execve_common -> exec_binprm->load_elf_binary()->sys_close

根据elf的库类型,elf_entry是不一样的。load_elf_binary通过解析器将不同的入口地址写入。

3.对“Linux系统一般执行过程”的理解

1.在调度时机方面，内核线程可以直接调用schedule()进行进程切换，也可以在中断处理过程中进行调度，也就是说内核线程作为一类的特殊的进程可以主动调度，也可以被动调度。

2.schedule()函数实现进程调度，context_ switch完成进程上下文切换，switch_ to完成寄存器的切换。

3.用户态进程无法实现主动调度，仅能通过陷入内核态后的某个时机点进行调度，即在中断处理过程中进行调度。

转载于:https://www.cnblogs.com/lubaobao/p/10603149.html