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

学号后三位098
原创作品转载请注明出处 + 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数据结构

什么是进程

进程是程序的一个执行实例。

进程是正在执行的程序。

进程是能分配处理器并由处理器执行的实体。

为了管理进程，操作系统必须对每个进程所做的事情进行清楚的描述，为此，操作系统使用数据结构来代表处理不同的实体，这个数据结构就是通常所说的进程描述符或进程控制块（PCB）。在Linux中,task_struct其实就是通常所说的PCB。该结构定义位于:/include/linux/sched.h。

Linux 的进程描述符在 linux/include/linux/sched.h 文件中定义的名为 task_struct 的结构体（以 linux-5.0.1 内核为例，以下相同）。该结构体内容庞大繁杂，包含了一系列和进程运行相关的内容。

进程信息：

/* -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;      // 调度策略       

其他的还包括对进程通信，内存管理，死锁检测和设备管理等相关部分。可看到进程是操作系统基本组成部分，是资源分配、调度，设备管理的基本单位，在操作系统运行中发挥重要的作用。

通过阅读源码，我们可以发现，为了完成进程各种复杂的工作，PCB的结构十分复杂，大致包括：

• 进程基本信息
• 调度信息
• 文件系统信息
• 内存信息
• I/O信息
• 资源信息
• 现场控制
• 环境信息
• 等

2.分析fork函数

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

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、重新挂载内核。

 sudo ../bin/qemu-system-x86_64 -kernel linux-5.0.1/arch/x86_64/boot/bzImage -initrd rootfs.img -s -S -append nokaslr 

 

3.新建一个 shell 窗口，用 gdb 调试该 fork 调用；用以下命令在可能运行的函数处添加断点，跟踪fork执行过程；

 b __ia32_sys_fork
 b _do_fork     
 b sys_clone  
 b ret_from_fork 
 b copy_process         

 

 

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

1. 概念

• 1.1 ELF 文件

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

• 1.2 动态链接

  动态链接，在可执行文件装载时或运行时，由操作系统的装载程序加载库。

• 1.3 静态链接

  静态链接是由链接器在链接时将库的内容加入到可执行程序中的做法。

• 1.4 编译链接过程
  源文件 -> 预处理 -> 编译 -> 汇编 -> 链接 -> 可执行文件

2. exec 调用

• 2.1 使用 execve 库函数加载一个可执行文件

  • execve 函数如下定义：

    #include 
    int execve(const char *filename, char *const argv[],
              char *const envp[]);          
    

    filename：可执行文件名
    argv: 执行参数
    envp: 参数序列，一般来说他是一种键值对的形式 key=value. 作为我们是新程序的环境

  • 编写调用 execve 的程序：

    int testExecve(int argc, char *argv[]){    
        execve("./hello",NULL,NULL);
        execve("time",NULL,NULL);
    }
    

  • 将其添加到 menu 中的 test.c 文件，并重新编译执行，得到结果，并且用 gdb 跟踪得到：

    // 在 execve 等执行函数处打断点      
    b sys_execve
    b __do_execve_file  
    b do_execveat_common        
    

• 2.2 execve 处理过程

  • execve 的调用处理最终都归结到 linux-5.0.1/fs/exec.c 文件中的 __do_execve_file 函数，声明如下：

    static int __do_execve_file(int fd, struct filename *filename, struct user_arg_ptr argv, struct user_arg_ptr envp, int flags, struct file *file)    
    // fd : 文件号       
    // filename: 文件名称
    // argv：执行参数        
    // envp: 新程序执行环境参数     
    // file：可执行文件具体内容          
    

  • 函数功能及部分代码如下：

    // 判断文件存在性
    if (IS_ERR(filename))
    return PTR_ERR(filename);           
    // 复制一份文件表；           
    retval = prepare_bprm_creds(bprm);        
    // 在堆上为文件分配相应空间；
    bprm = kzalloc(sizeof(*bprm), GFP_KERNEL);    
    // 查找并打开二进制文件      
    if (!file)
    file = do_open_execat(fd, filename, flags);   
    // 等待 CPU 调度来执行该二进制文件      
    sched_exec();       
    // 当CPU准备好之后，为该文件执行过程
    // 初始化二进制文件描述结构体 linux_binprm    
    bprm->file = file;       
    if (!filename) {
    bprm->filename = "none";     
    } else if (fd == AT_FDCWD || filename->name[0] == '/0'){          bprm->filename = filename->name;        
    } else {        
        if (filename->name[0] == '\0')
    	pathbuf = kasprintf(GFP_KERNEL, "/dev/fd/%d", fd);
    else
    	pathbuf = kasprintf(GFP_KERNEL, "/dev/fd/%d/%s",  fd, filename->name);
    if (!pathbuf) {
    	retval = -ENOMEM;
    	goto out_unmark;
    }
    if (close_on_exec(fd, rcu_dereference_raw(current->files->fdt)))
    	bprm->interp_flags |= BINPRM_FLAGS_PATH_INACCESSIBLE;
    bprm->filename = pathbuf;       
    }
    bprm->interp = bprm->filename;      
    // 创建进程的内存地址空间    
    retval = bprm_mm_init(bprm);          
    // 填充 linux_binrpm 中的参数     
    retval = prepare_arg_pages(bprm, argv, envp);   
    // 检查该二进制文件的可执行权限   
    retval = prepare_binprm(bprm);   
    // 从内核空间获取二进制文件的路径名称      
    retval = copy_strings_kernel(1, &bprm->filename, bprm);  
    // 调用copy_string()从用户空间拷贝环境变量及命令 
    retval = copy_strings(bprm->envc, envp, bprm);   
    //  调用copy_string()从用户空间拷贝命令行参数
    retval = copy_strings(bprm->argc, argv, bprm);  
    // 以上已经打开了二进制可执行文件
    
    // 最终执行该二进制文件
    retval = exec_binprm(bprm);
    
    // 后半部分为执行成功的收尾工作  
    ...
    

四、进程调度

1. 进程调度的时机

• 当进程发生系统调用时，会产生中断，通过中断处理程序，发生进程被动调度，调用 schedule() ；
• 特殊的进程——内核线程，可以主动发生进程调度，直接调用 sechedule(), 或者发生中断，在中断处理过程中对进程进行调度；

2. 跟踪 schedule()

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

• 通过打断点，跟踪到 schedule() 出现在 linux-5.0.1/kernel/core.c 中，该函数中，阻止进程被抢占，然后调用 _schedule() 函数执行进程调度；

• 在 linux-5.0.1/kernel/core.c 中的 _schedule(bool preempt) 中根据处理器获得进程的就绪队列，加锁，屏蔽中断信号，然后获得当前进程描述符 prev 和接下来运行的进程描述符 next，然后交换跟踪者所跟踪的进程为 next , 并且交换进程上下文；

    trace_sched_switch(preempt, prev, next);
    rq = context_switch(rq, prev, next, &rf);        
  

• 接下来跟踪 context_switch , 该函数主要交换两个进程的线性区 ；

    struct mm_struct *mm, *oldmm;
    mm = next->mm;
    oldmm = prev->active_mm;
    ...
    switch_mm_irqs_off(oldmm, mm, next);
    /* Here we just switch the register state and the stack. */
    switch_to(prev, next, prev);         
  

• 之后是 arch/x86/include/asm/switch_to.h 中的 switch_to, 交换寄存器和进程栈；

    // 获得下一个进程的 sp    
    READ_ONCE(*(unsigned char *)next->thread.sp);       
  

• 在 arch/x86/entry/entry_64.S 中用汇编代码编写，来交换两个进程的栈

    /*  %rdi: 当前进程栈，%rsi: next task ：下一个进程栈 */
    ENTRY(__switch_to_asm)
        UNWIND_HINT_FUNC
            /* 将当前寄存器值压栈 */
            pushq	%rbp
            pushq	%rbx
            pushq	%r12
            pushq	%r13
            pushq	%r14
            pushq	%r15
            /* 交换进程栈指针 */
            movq	%rsp, TASK_threadsp(%rdi)  // 将当前进程 sp 值放到本进程栈中   
            movq	TASK_threadsp(%rsi), %rsp  // 让 sp 指向下一个进程栈地址 
            ...
            /* 从下一个进程栈中取出上次因为调度而保存的寄存器值 */
            popq	%r15
            popq	%r14
            popq	%r13
            popq	%r12
            popq	%rbx
            popq	%rbp
            jmp	__switch_to
    END(__switch_to_asm)               
  

• 接着 arch/x86/kernel/process_64.h 中的 __switch_to 中交换段寄存器的内容；

    savesegment(es, prev->es);  
    savesegment(ds, prev->ds);       
  

• 最后调用其他函数完结整个进程调度过程.

4.总结

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

5.参考

1.https://github.com/mengning/linuxkernel/

2.https://www.lsry.xyz/2019/process.html

3.https://blog.csdn.net/weixin_43956968/article/details/88808503

4.https://blog.csdn.net/weixin_42107987/article/details/88811448