学号300原创作品转载请注明出处
本实验来源 https://github.com/mengning/linuxkernel/

一、实验要求

从整理上理解进程创建、可执行文件的加载和进程执行进程切换，重点理解分析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数据结构

1. 相关参数

volatile long state;//表示进程的当前状态:
unsigned long flags;  //进程标志:
long priority;  //进程优先级。 Priority的值给出进程每次获取CPU后可使用的时间(按jiffies计)。优先级可通过系统调用sys_setpriorty改变(在kernel/sys.c中)。
long counter;  //在轮转法调度时表示进程当前还可运行多久。
unsigned long policy;  //该进程的进程调度策略，可以通过系统调用sys_sched_setscheduler()更改(见kernel/sched.c)。

1. 进程控制块PCB——task_struct

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

三、分析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);

1eee0
// 如果使用的是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()则初始化完成处理信息；
• 然后调用wake_up_new_task将子进程加入调度器，为之分配CPU，如果是vfork()，则父进程等待子进程完成exec替换自己的地址空间。

copy_process()流程

• 首先调用dup_task_struct()复制当前的task_struct，检查进程数是否超过限制；
• 接着初始化自旋锁、挂起信号、CPU 定时器等；
• 然后调用sched_fork初始化进程数据结构，并把进程状态设置为TASK_RUNNING，复制所有进程信息，包括文件系统、信号处理函数、信号、内存管理等；
• 调用copy_thread()初始化子进程内核栈，为新进程分配并设置新的pid。

dup_task_struct()流程

• 调用alloc_task_struct_node()分配一个 task_struct 节点；
• 调用alloc_thread_info_node()分配一个 thread_info 节点，其实是分配了一个thread_union联合体,将栈底返回给 ti；
• 最后将栈底的值 ti 赋值给新节点的栈。

copy_thread的流程

• 获取子进程寄存器信息的存放位置,对子进程的thread.sp赋值，将来子进程运行，这就是子进程的esp寄存器的值。
• 如果是创建内核线程，那么它的运行位置是ret_from_kernel_thread，将这段代码的地址赋给thread.ip，之后准备其他寄存器信息，退出
• 将父进程的寄存器信息复制给子进程。将子进程的eax寄存器值设置为0，所以fork调用在子进程中的返回值为0.
• 子进程从ret_from_fork开始执行，所以它的地址赋给thread.ip，也就是将来的eip寄存器

新进程从ret_from_fork处开始执行

• dup_task_struct中为其分配了新的堆栈,copy_process中调用了sched_fork，将其置为TASK_RUNNING
• copy_thread中将父进程的寄存器上下文复制给子进程，这是非常关键的一步，这里保证了父子进程的堆栈信息是一致的。
  将ret_from_fork的地址设置为eip寄存器的值，这是子进程的第一条指令

小结：如何创建一个新进程

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

四、基于实验楼的实验环境跟踪fork的系统调用

启动MenuOS
cd LinuxKernel
rm -rf menu
git clone https://github.com/mengning/menu.git
cd menu
mv test_fork.c test.c
qemu -kernel …/linux-3.18.6/arch/x86/boot/bzImage -initrd …/rootfs.img -s -S

另外打开一终端，进入LinuxKernel文件夹，进入gdb调试模式
gdb
file linux-3.18.6/vmlinux
target remote:1234
设断点
b sys_clone
b do_fork
b dup_task_struct
b copy_process
b copy_thread
b ret_from_fork

跟踪do_fork

跟踪copy_process

跟踪copy_thread

到此就一直循环执行，最后执行ret_from_fork。

Linux通过复制父进程创建新进程，fork、vfork、clone都是通过do_exit实现进程的创建。

• 复制一个PCB

• 给新进程分配一个新的内核堆栈（复制了thread_info，不是复制了内核堆栈）

• 修改复制的数据，即子进程初始化

五、理解编译链接过程和ELF可执行文件

1. 编译链接过程
   
   2.ELF可执行文件

• 一个可重定位(relocatable)文件保存着代码和适当的数据，用来和其他的object文件一起来创建一个可执行文件或者是一个共享文件。
• 一个可执行(executable)文件保存着一个用来执行的程序；该文件指出了exec(BA_OS)如何来创建程序进程映象。
• 一个共享object文件保存着代码和合适的数据，用来被不同的两个链接器链接。

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

先编辑一个300.c
生成预处理文件300.cpp（预处理负责把include的文件包含进来及宏替换等工作）
编译成汇编代码300.s
编译成目标代码，得到二进制文件300.o
链接成可执行文件300，（它是二进制文件）
运行一下./300

可知：
静态链接方式：在程序运行之前完成所有的组装工作，生成一个可执行的目标文件
动态链接方式：在程序已经为了执行被装载入内存之后完成链接工作，并且在内存中一般只保留该编译单元的一份拷贝

动态链接库的两种链接方法：装载时动态链接；运行时动态链接

七、使用gdb跟踪分析一个execve系统调用内核处理函数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);
}

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

新的可执行程序通过修改内核堆栈eip作为新程序的起点，从new_ip开始执行后start_thread把返回到用户态的位置从int 0x80的下一条指令变成新加载的可执行文件的入口位置。当执行到execve系统调用时，进入内核态，用execve()加载的可执行文件覆盖当前进程的可执行程序。当execve系统调用返回时，返回新的可执行程序的执行起点（main函数），所以execve系统调用返回后新的可执行程序能顺利执行。execve系统调用返回时，如果是静态链接，elf_entry指向可执行文件规定的头部（main函数对应的位置0x8048***）；如果需要依赖动态链接库，elf_entry指向动态链接器的起点。动态链接主要是由动态链接器ld来完成的。

九、理解Linux系统中进程调度的时机，可以在内核代码中搜索schedule()函数，看都是哪里调用了schedule()

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

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

设置断点：
b schedule
b pick_next_task
b context_switch
b __switch_to

十一、分析switch_to中的汇编代码，理解进程上下文的切换机制，以及与中断上下文切换的关系

1.关键函数调用：schedule() --> context_switch() --> switch_to --> __switch_to(）
2.asm代码分析

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

参考博客：
https://www.geek-share.com/detail/2764262954.html
https://blog.csdn.net/weixin_43956968/article/details/88808503