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

学号013
本实验来源 https://github.com/mengning/linuxkernel/

实验要求

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

实验步骤

1.进程

一个进程就是处于执行期的程序（目标码存放在某种存储介质上）。但进程并不仅仅局限于一段可执行程序代码，通常进程还包含其他资源，像打开的文件，挂起的信号，内核内部数据，处理器状态，地址空间及一个或多个执行线程，当然还包括用来存放全局变量的数据段等。
执行线程，简称线程，是在进程活动中的对象。每个线程都拥有一个独立的程序计数器、进程栈和一组进程寄存器。内核调度的对象是线程不是进程。

2. 阅读理解task_struct数据结构

参考：https://blog.csdn.net/My_heart_/article/details/52315640
内核把进程放在叫做任务队列的双向循环链表中。链表的每一项都是类型为task_struct，成为进程描述符的结构，该结构定义在<linux/sched.h>文件中，大概包含以下十种类型：

1. 进程状态 ,将纪录进程在等待,运行,或死锁
2. 调度信息, 由哪个调度函数调度,怎样调度等
3. 进程的通讯状况
4. 因为要插入进程树,必须有联系父子兄弟的指针
5. 时间信息, 比如计算好执行的时间, 以便cpu 分配
6. 标号 ,决定改进程归属
7. 可以读写打开的一些文件信息
8. 进程上下文和内核上下文
9. 处理器上下文
10. 内存信息

３.进程的创建

Linux操作系统产生进程的机制是首先在新的地址空间里创建进程，读入可执行文件，最后开始执行。Linux采用了与众不同的实现方式，将上述步骤分解到两个单独的函数中去执行。Fork()和exec().首先fork()通过拷贝当前进程创建一个子进程。子进程与父进程的区别仅仅在于PID、PPID和某些资源和统计量。Exec()函数负责读取可执行文件并将其载入地址空间开始运行。
Linux的fork()函数使用写时拷贝页实现。内核此时并不会复制整个进程地址空间，而是让父进程和子进程共享同一个拷贝。只有在需要写入的时候，数据才会被复制，从而使各个进程拥有各自的拷贝。也就是说资源的复制只有在需要重新写入的时候才会进行，再次之前，只是以只读的方式共享。
分析fork函数对应的内核处理过程do_fork，理解创建一个新进程如何创建和修改task_struct数据结构

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开始, 后者执行生成新的进程的实际工作, 并根据指定的标志复制父进程的数据。在子进程生成后, 内核必须执行下列收尾操作:

1.调用 copy_process 为子进程复制出一份进程信息
2.如果是 vfork（设置了CLONE_VFORK和ptrace标志）初始化完成处理信息
3.调用 wake_up_new_task 将子进程加入调度器，为之分配 CPU
4.如果是 vfork，父进程等待子进程完成 exec 替换自己的地址空间

copy_process流程

1.调用 dup_task_struct 复制当前的 task_struct
2.检查进程数是否超过限制
3.初始化自旋锁、挂起信号、CPU 定时器等
4.调用 sched_fork 初始化进程数据结构，并把进程状态设置为 TASK_RUNNING
5.复制所有进程信息，包括文件系统、信号处理函数、信号、内存管理等
6.调用 copy_thread_tls 初始化子进程内核栈
7.为新进程分配并设置新的 pid

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寄存器。

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


Q1.新进程是从哪里开始执行的
函数copy_process中的copy_thread()
Q2.为什么从那里能顺利执行下去
p->thread.ip = (unsigned long) ret_from_fork;将子进程的 ip 设置为 ret_form_fork 的首地址，因此子进程是从 ret_from_fork 开始执行的
Q3.即执行起点与内核堆栈如何保证一致
在ret_from_fork之前,也就是在copy_thread()函数中：*childregs = *current_pt_regs();
该句将父进程的regs参数赋值到子进程的内核堆栈,*childregs的类型为pt_regs,里面存放了SAVE ALL中压入栈的参数。故在之后的RESTORE ALL中能顺利执行下去。

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

一个C/C++文件要经过预处理(preprocessing)、编译(compilation)、汇编(assembly)、和连接(linking)才能变成可执行文件。

• 预处理就是将要包含(include)的文件插入原文件中、将宏定义展开、根据条件编译命令选择要使用的代码，最后将这些代码输出到一个“.i”文件中等待进一步处理.
• 编译就是把C/C++代码(比如上面的”.i”文件)“翻译”成汇编代码。
• 汇编就是将第二步输出的汇编代码翻译成符合一定格式的机器代码，在Linux系统上一般表现位ELF目标文件(OBJ文件)。
• 链接就是将汇编生成的OBJ文件、系统库的OBJ文件、库文件链接起来，最终生成可以在特定平台运行的可执行程序。
  
  ELF文件

1.可重定位（relocabtable）文件，保存着代码和适当的数据，用来和其他的object文件一起来创建一个可执行文件或者是一个共享文件。
2.可执行（executable）文件，保存着一个用来执行的程序，该文件指出了exec（BA_OS）如何来创建程序进程映像。
3.共享object文件，保存着代码和合适的数据，用来被下面的两个链接器链接。第一个是链接编辑器（静态链接），可以和其他的可重定位和共享object文件一起来创建object文件；第二个是动态链接器，联合一个可执行文件和其他的共享object文件来创建一个进程印象。

5.编程使用exec*库函数加载一个可执行文件

动态链接：动态链接使用动态链接库进行链接，生成的程序在执行的时候需要加载所需的动态库才能运行。 动态链接生成的程序体积较小，但是必须依赖所需的动态库，否则无法执行。
默认使用动态链接：gcc -o hello_shared hello.o

静态链接：静态链接使用静态库进行链接，生成的程序包含程序运行所需要的全部库，可以直接运行，不过静态链接生成的程序体积较大。 gcc -static -o hello_static hello.o
helloworld

// file helloword.c
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
int main()
{
    printf("Hello world!\n");
    pid_t pid = getpid();
    printf("pid of helloworld from helloword is %d\n", pid);
    return 0;
}
// end helloword.c

start_process

#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
int main(){
	pid_t pid;
	char *argv_execve[]={"helloworld",NULL};
	char *envp[]={"PATH=/home/","USER=sterben","STATUS=testing",NULL};
	pid=getpid();
	printf("pid of start_process is:%d\n",pid);
	printf("starting systemcall execve......\n");
	pid_t temp=fork();
	if(temp==0){
		printf("pid getted after fork() %d\n",getpid());
		if(execve("./helloworld",argv_execve,envp)<0){
			perror("Error on execve");
		}	
	}else{
		printf("return a posivate value %d,pid getted after fork() is %d\n",temp,getpid());	
	}
	return 0;
}

Q1.新的可执行程序是从哪里开始执行的？为什么execve系统调用返回后新的可执行程序能顺利执行？
新的可执行程序通过修改内核堆栈eip作为新程序的起点.从new_ip开始执行后start_thread把返回到用户态的位置从int 0x80的下一条指令变成新加载的可执行文件的入口位置。当执行到execve系统调用时，进入内核态，用execve()加载的可执行文件覆盖当前进程的可执行程序
Q2.对于静态链接的可执行程序和动态链接的可执行程序execve系统调用返回时会有什么不同？
静态链接：elf_entry指向可执行文件的头部，一般是main函数，是新程序执行的起点，一般地址为0x8048XXX的位置。
动态链接：elf_entry指向ld即动态链接器的起点load_elf_interp。

6.理解Linux系统中进程调度的时机

首先Linux系统中进程调度的过程主要是以下几个方面:

   1.从schedule()函数开始，进行调度选择
   2. 从CPU的值变化上，解读switch_to宏执行分析
   3.到堆栈发生切换位置，在切换堆栈前后，current_thread_info变化
   4.再到地址空间发生切换，解释地址空间的切换不会影响后续切换代码的执行
   5.Current宏代表的进程发生变化的源码位置
   6.任务状态段中关于内核堆栈的信息发生变化的源码位置

进程调度的时机：
1、进程状态转换的时刻：进程终止、进程睡眠；进程要调用sleep（）或exit（）等函数进行状态转换，这些函数会主动调用调度程序进行进程调度；
2、当前进程的时间片用完时（current->counter=0）；由于进程的时间片是由时钟中断来更新的，因此，这种情况和时机4是一样的。
3、设备驱动程序。当设备驱动程序执行长而重复的任务时，直接调用调度程序。在每次反复循环中，驱动程序都检查need_resched的值，如果必要，则调用调度程序schedule()主动放弃CPU。
4、进程从中断、异常及系统调用返回到用户态时；
进程切换
为了控制进程的执行，内核必须有能力挂起正在CPU上执行的进程，并恢复以前挂起的某个进程的执行，这叫做进程切换、任务切换、上下文切换；挂起正在CPU上执行的进程，与中断时保存现场是不同的，中断前后是在同一个进程上下文中，只是由用户态转向内核态执行；进程上下文包含了进程执行需要的所有信息
用户地址空间：包括程序代码，数据，用户堆栈等
控制信息：进程描述符，内核堆栈等
硬件上下文
进程上下文切换由以下4个步骤组成:
1)决定是否作上下文切换以及是否允许作上下文切换。包括对进程调度原因的检查分析，以及当前执行进程的资格和CPU执行方式的检查等。在操作系统中，上下文切换程序并不是每时每刻都在检查和分析是否可作上下文切换，它们设置有适当的时机。
(2)保存当前执行进程的上下文。这里所说的当前执行进程，实际上是指调用上下文切换程序之前的执行进程。如果上下文切换不是被那个当前执行进程所调用，且不属于该进程，则所保存的上下文应是先前执行进程的上下文，或称为“老”进程上下文。显然，上下文切换程序不能破坏“老”进程的上下文结构。
(3)使用进程调度算法，选择一处于就绪状态的进程。
(4)恢复或装配所选进程的上下文，将CPU控制权交到所选进程手中。

7.分析switch_to

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)

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进程就成为当前进程而真正开始执行