对进程创建、可执行文件的加载和进程执行进程切换分析

学号后三位061
原创作品转载请注明出处 + https://github.com/mengning/linuxkernel/

1.实验目标

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

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

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

2.实验环境

VM14pro虚拟机

ubuntu系统（ubuntu-18.04.2-desktop-amd64）

3.实验步骤

1.阅读理解task_struct数据结构
什么是进程？
<1>进程是程序的一个执行的实例；
<2>进程是正在执行的程序
<3>进程是能分配处理器并由处理器执行的实体

为了管理进程，操作系统必须对每个进程所做的事情进行清楚的描述，为此，操作系统使用数据结构来代表处理不同的实体，这个数据结构就是通常所说的进程描述符或进程控制块（PCB）。
在linux操作系统下这就是task_struct结构 ，所属的头文件#include <sched.h>每个进程都会被分配一个task_struct结构，它包含了这个进程的所有信息，在任何时候操作系统都能够跟踪这个结构的信息.

进程信息：

/* -1 unrunnable, 0 runnable, >0 stopped: 进程状态 **/
 volatile long state;
 unsigned int flags;  // 进程状态标志
 /** 进程退出 */
 int exit_state; int exit_code; int exit_signal;
 /** 进程标识号 */
 pid_t pid; pid_t tgid;
 struct pid *thread_pid;
 struct hlist_node pid_links[PIDTYPE_MAX];
 
 /** 用于通知LSM是否被do_execve()函数所调用 */
 unsigned in_execve:1;
 
 /** 在执行do_fork()时，如果给定特别标志，则vfork_done会指向一个特殊地址*/
 struct completion *vfork_done;
 /* CLONE_CHILD_SETTID: */
 int __user *set_child_tid;
 /* CLONE_CHILD_CLEARTID: */
 int __user *clear_child_tid;

进程调度信息：

/* 进程调度优先级 **/
 int prio, static_prio, normal_prio;
 unsigned int rt_priority; // 实时进程的优先级
 const struct sched_class *sched_class; // 进程调度类
 struct sched_entity se; // 普通进程调度实体
 struct sched_rt_entity rt; // 实时进程调度实体
 unsigned int policy;      // 调度策略       

2.fork函数

Linux中创建进程一共有三个函数
fork，创建子进程
vfork，与fork类似，但是父子进程共享地址空间，而且子进程先于父进程运行。
clone，主要用于创建线程

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处理了以下内容：
调用copy_process，将当期进程复制一份出来为子进程，并且为子进程设置相应地上下文信息。
初始化vfork的完成处理信息（如果是vfork调用）
调用wake_up_new_task，将子进程放入调度器的队列中，此时的子进程就可以被调度进程选中，得以运行。
如果是vfork调用，需要阻塞父进程，知道子进程执行exec。

3.使用gdb跟踪分析一个fork系统调用内核处理函数do_fork
1.在 test.c 文件中添加使用 fork 系统调用的函数；

    int testFork(int argc, char *argv[]){
         pid_t fpid; 
         int count=0;  
         fpid=fork();   
         if (fpid < 0)   
             printf("error in fork!");   
         else if (fpid == 0) {  
             printf("i am the child process, my process id is %d\n",getpid());        
             count++;  
         }  
         else {  
             printf("i am the parent process, my process id is %d\n",getpid());   
             count++;  
         }  
         printf("result: %d\n",count);  
         return 0;  
     }   

2.在 menu 目录下使用 make rootfs 生成文件系统， 然后使用qemu、重新挂载内核。
3.新建一个 shell 窗口，用 gdb 调试该 fork 调用；用以下命令在可能运行的函数处添加断点，跟踪fork执行过程；

 b __ia32_sys_fork
 b _do_fork     
 b sys_clone  
 b ret_from_fork 
 b copy_process   

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

ELF 文件:
在计算机科学中，是一种用于二进制文件、可执行文件、目标代码、共享库和核心转储格式文件;
ELF有四种不同的类型: 可重定位文件、可执行文件、共享对象文件、核心转储文件。通过 man elf 命令可查看 elf 文件详细内容。

动态链接库(Dynamic Linked Library)：
Windows为应用程序提供了丰富的函数调用，这些函数调用都包含在动态链接库中。其中有3个最重要的DLL，Kernel32.dll，它包含用于管理内存、进程和线程的各个函数；User32.dll，它包含用于执行用户界面任务(如窗口的创建和消息的传送)的各个函数；GDI32.dll，它包含用于画图和显示文本的各个函数。

静态库(Static Library)：
函数和数据被编译进一个二进制文件(通常扩展名为.LIB)。在使用静态库的情况下，在编译链接可执行文件时，链接器从库中复制这些函数和数据并把它们和应用程序的其它模块组合起来创建最终的可执行文件(.EXE文件)。

5.编程使用exec*库函数加载一个可执行文件
在原fork函数上添加命令
execlp("/bin/ls",“ls”,NULL);
重新编译。

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

在 schedule 处打断点，然后跟踪：

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

总结

对Linux系统的执行过程的理解：

在调度时机方面，内核线程可以直接调用schedule()进行进程切换，也可以在中断处理过程中进行调度，也就是说内核线程作为一类的特殊的进程可以主动调度，也可以被动调度。
schedule()函数实现进程调度，context_ switch完成进程上下文切换，switch_ to完成寄存器的切换。
用户态进程无法实现主动调度，仅能通过陷入内核态后的某个时机点进行调度，即在中断处理过程中进行调度