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

最新推荐文章于 2021-04-28 17:10:54 发布

原创最新推荐文章于 2021-04-28 17:10:54 发布 · 341 阅读

0 ·

CC 4.0 BY-SA版权

本文深入解析Linux进程管理，涵盖进程创建、可执行文件加载、进程调度等核心内容。详细分析fork、execve系统调用及进程切换机制，揭示任务结构task_struct的作用与内部实现。

原创作品转载请注明出处 + https://github.com/mengning/linuxkernel/
学号 358
本次实验从整体上理解进程创建、可执行文件的加载和进程执行进程切换，重点理解分析fork、execve和进程切换

阅读理解task_struct数据结构http://codelab.shiyanlou.com/xref/linux-3.18.6/include/linux/sched.h#1235；
分析fork函数对应的内核处理过程do_fork，理解创建一个新进程如何创建和修改task_struct数据结构；
使用gdb跟踪分析一个fork系统调用内核处理函数do_fork ，验证您对Linux系统创建一个新进程的理解,特别关注新进程是从哪里开始执行的？为什么从那里能顺利执行下去？即执行起点与内核堆栈如何保证一致。
理解编译链接的过程和ELF可执行文件格式；
编程使用exec*库函数加载一个可执行文件，动态链接分为可执行程序装载时动态链接和运行时动态链接；
使用gdb跟踪分析一个execve系统调用内核处理函数do_execve ，验证您对Linux系统加载可执行程序所需处理过程的理解；
特别关注新的可执行程序是从哪里开始执行的？为什么execve系统调用返回后新的可执行程序能顺利执行？对于静态链接的可执行程序和动态链接的可执行程序execve系统调用返回时会有什么不同？
理解Linux系统中进程调度的时机，可以在内核代码中搜索schedule()函数，看都是哪里调用了schedule()，判断我们课程内容中的总结是否准确；
使用gdb跟踪分析一个schedule()函数，验证您对Linux系统进程调度与进程切换过程的理解；
特别关注并仔细分析switch_to中的汇编代码，理解进程上下文的切换机制，以及与中断上下文切换的关系；

阅读理解task_struct数据结构

http://codelab.shiyanlou.com/xref/linux-3.18.6/include/linux/sched.h#1235；
操作系统的三大管理功能包括：进程管理、内存管理、文件系统。在Linux中,task_struct其实就是通常所说的PCB。该结构定义位于:/include/linux/sched.h。PCB task_struct中包含：进程状态、进程打开的文件、进程优先级信息
task_struct结构体分析：

    volatile long state;  //进程的状态
    unsigned long flags; //调用fork时候给出的进程号
    long nice; //进程的基本时间片
    unsigned long policy; //进程的调度策略
    struct mm_struct *mm; //进程内存管理信息
    struct list_head run_list; //指向运行队列的指针
    unsigned long sleep_time; //进程的睡眠时间
    struct task_struct *next_task, *prev_task; //用于将系统中所有的进程连接成一个双向循环链表
    pid_t pid;//进程标识符,用来代表一个进程
    pid_t pgrp;//进程组标识,表示进程所属的进程组
    pid_t tty_old_pgrp;//进程控制终端所在的组标识
    pid_t session;//进程的会话标识
    pid_t tgid;
    struct list_head thread_group; //线程链表
    struct task_struct *pidhash_next;//用于将进程链入HASH表pidhash
    struct task_struct **pidhash_pprev;
    wait_queue_head_t wait_chldexit; //供wait4()使用
    struct completion *vfork_done; // 供vfork() 使用
    unsigned long rt_priority;//实时优先级
    struct fs_struct *fs; //文件系统信息
    struct files_struct *files; //打开文件信息

分析fork函数对应的内核处理过程do_fork

Linux中创建进程一共有三个函数：fork，经常使用到的，创建子进程。vfork，同样也是常见子进程，区别在于父子进程共享地址空间，而且子进程先于父进程运行。clone，主要用于创建线程。而这三个函数最终都是利用do_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处理了以下内容：

调用copy_process，复制当前的进程的上下文信息给子进程
使用vfork调用时，初始化vfork的完成处理信息
调用wake_up_new_task，将子进程放入调度器的队列中，此时的子进程就可以被调度进程选中，得以运行。
如果是vfork调用，需要阻塞父进程，知道子进程执行exec。
上面的过程对vfork稍微做了处理，因为vfork必须保证子进程优先运行，执行exec，替换自己的地址空间。抛开vfork，进程创建的大部分过程都在copy_process函数中。

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

int ForkProcess()
{
	int pid;
	/* fork another process */
	pid = fork();
	if (pid<0)
	{
	/* error occurred */
	printf("Fork Failed!");
	//exit(-1);
	}
	else if (pid==0)
	{
	/*  child process */
	//execlp("/bin/ls","ls",NULL);
	printf("This is child Process!,my PID is %d\n",pid);
	}
	else
	{
	/* parent process  */
	/* parent will wait for the child to complete*/
	printf("THis is parent process!,my process is %d\n",pid);	
	//wait(NULL);
	printf("Child Complete!");
	//exit(0);
	}
	return 0;
}

在这里插入图片描述
设置断点

在copy_thread中,我们可以查看p的值

那么新进程是从哪里开始执行的？为什么从哪里能顺利执行下去？
函数copy_process中的copy_thread()

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;
    ...
}

子进程执行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)

childregs->ax = 0;这段代码将子进程的 eax 赋值为0。p->thread.ip = (unsigned long) ret_from_fork;这句代码将子进程的 ip 设置为 ret_form_fork 的首地址，因此子进程是从 ret_from_fork 开始执行的。因此，函数copy_process中的copy_thread()决定了子进程从系统调用中返回后的执行。

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

编译过程，图片来源于孟宁老师课件
在这里插入图片描述
ELF可执行文件格式
ELF全称Executable and Linkable Format,可执行连接格式，ELF格式的文件用于存储Linux程序。ELF文件（目标文件）格式主要三种：

可重定向文件：文件保存着代码和适当的数据，用来和其他的目标文件一起来创建一个可执行文件或者是一个共享目标文件。（目标文件或者静态库文件，即linux通常后缀为.a和.o的文件）
可执行文件：文件保存着一个用来执行的程序。（例如bash，gcc等）
共享目标文件：共享库。文件保存着代码和合适的数据，用来被下连接编辑器和动态链接器链接。（linux下后缀为.so的文件。）
目标文件既要参与程序链接又要参与程序执行：
一般的 ELF 文件包括三个索引表：ELF header，Program header table，Section header table。
ELF header：在文件的开始，保存了路线图，描述了该文件的组织情况。
Program header table：告诉系统如何创建进程映像。用来构造进程映像的目标文件必须具有程序头部表，可重定位文件不需要这个表。
Section header table：包含了描述文件节区的信息，每个节区在表中都有一项，每一项给出诸如节区名称、节区大小这类信息。用于链接的目标文件必须包含节区头部表，其他目标文件可以有，也可以没有这个表。

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

1）linux系统中，可执行程序一般要经过预处理、编译、汇编、链接、执行等步骤。
2）c代码，经过预处理，变成汇编代码；经过汇编器，变成目标代码；连接成可执行文件；加载到内核中执行。
3）编译连接流程：execve->do_execve->search_binary_handle->load_binary

编写测试文件test.c，按照上述步骤生成预处理文件、汇编代码、目标代码和可执行文件

gcc -E -o test.cpp test.c -m32
gcc -x cpp-output -S -o test.s test.cpp -m32
gcc -c test.s -o test.o -m32
gcc -o test test.o -m32
./test

在这里插入图片描述
也可以通过静态编译，把所有需要执行所依赖的东西放到程序内部

gcc -o hello.static hello.o -m32 -static
./hello.static

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

动态链接
动态链接是在程序运行时由操作系统将需要的动态库加载到内存中。动态链接分为装载时动态链接和运行时动态链接。

使用gdb跟踪分析一个execve系统调用内核处理函数do_execve

在下面位置打上断点

sys_execv
load_elf_binary

在这里插入图片描述
do_execve

int do_execve(struct filename *filename,
          const char __user *const __user *__argv,
          const char __user *const __user *__envp)
      {
          struct user_arg_ptr argv = { .ptr.native = __argv };
          struct user_arg_ptr envp = { .ptr.native = __envp };
          //调用do_execve_common
          return do_execve_common(filename, argv, envp);
      }

进程调度的时机

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

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

设置断点，准备调试
在这里插入图片描述
分别在schedule函数、pick_next_task函数、context_switch函数和__switch_to函数处打断点并继续执行观察函数调用的过程。发现context_switch和pick_next_task函数都在__schedule函数中。
schedul函数选择一个新的进程来运行，并调用context_switch进行上下文的切换。context_switch首先调用switch_mm切换CR3，然后调用宏switch_to来进行硬件上的上下文切换。
分析switch_to中的汇编代码，理解上下文的切换机制，以及与中断上下文切换的关系
switch_to实现了进程之间的切换：
分析switch_to中的汇编代码，理解上下文的切换机制，以及与中断上下文切换的关系

switch_to实现了进程之间的切换
首先在当前进程prev的内核栈中保存esi,edi及ebp寄存器的内容。
然后将prev的内核堆栈指针ebp存入prev->thread.esp中。
把将要运行进程next的内核栈指针next->thread.esp置入esp寄存器中
将popl指令所在的地址保存在prev->thread.eip中，这个地址就是prev下一次被调度
通过jmp指令（而不是call指令）转入一个函数__switch_to()
恢复next上次被调离时推进堆栈的内容。从现在开始，next进程就成为当前进程而真正开始执行

汇编代码分析

asm volatile("pushfl\n\t"      /* 保存当前进程的标志位 */   
         "pushl %%ebp\n\t"        /* 保存当前进程的堆栈基址EBP   */ 
         "movl %%esp,%[prev_sp]\n\t"  /* 保存当前栈顶ESP   */ 
         "movl %[next_sp],%%esp\n\t"  /* 把下一个进程的栈顶放到esp寄存器中，完成了内核堆栈的切换，从此往下压栈都是在next进程的内核堆栈中。   */ 
       

		 "movl $1f,%[prev_ip]\n\t"    /* 保存当前进程的EIP   */ 
         "pushl %[next_ip]\n\t"   /* 把下一个进程的起点EIP压入堆栈   */    
         __switch_canary                   
         "jmp __switch_to\n"  /* 因为是函数所以是jmp，通过寄存器传递参数，寄存器是prev-a，next-d，当函数执行结束ret时因为没有压栈当前eip，所以需要使用之前压栈的eip，就是pop出next_ip。  */ 


		 "1:\t"               /* 认为next进程开始执行。 */         
		 "popl %%ebp\n\t"     /* restore EBP   */    
		 "popfl\n"         /* restore flags */  
                                    
		 /* output parameters 因为处于中断上下文，在内核中
		 prev_sp是内核堆栈栈顶
		 prev_ip是当前进程的eip */                
		 : [prev_sp] "=m" (prev->thread.sp),     
		 [prev_ip] "=m" (prev->thread.ip),  //[prev_ip]是标号        
		 "=a" (last),                 
                                    
		/* clobbered output registers: */     
		 "=b" (ebx), "=c" (ecx), "=d" (edx),      
		 "=S" (esi), "=D" (edi)             
                                       
		 __switch_canary_oparam                
                                    
		 /* input parameters: 
		 next_sp下一个进程的内核堆栈的栈顶
		 next_ip下一个进程执行的起点，一般是$1f，对于新创建的子进程是ret_from_fork*/                
		 : [next_sp]  "m" (next->thread.sp),        
		 [next_ip]  "m" (next->thread.ip),       
                                        
	     /* regparm parameters for __switch_to(): */  
		 [prev]     "a" (prev),              
		 [next]     "d" (next)               
                                    
		 __switch_canary_iparam                
                                    
		 : /* reloaded segment registers */           
		 "memory");                  
} while (0)

实验总结

内核线程既可以实现主动调度也可以实现被动调度，主动调度是直接调schedule函数进行调度，被动调度是在中断处理过程中进行调度。而用户态进程无法实现主动调度，只能在中断处理过程中进行调度schedule()函数实现进程调度，context_ switch完成进程上下文切换，switch_ to完成寄存器的切换。