学号:293 转载请注明出处https://github.com/mengning/linuxkernel/

一、阅读理解task_struct数据结构

代码地址

进程

• 进程是程序的一个执行实例
• 进程是正在执行的程序
• 进程是能分配处理器并由处理器执行的实体

系统为了管理进程需要对每个进程所做的事情进行描述。一般，操作系统使用数据结构来代表不同的实体，这个数据结构就是通常所说的进程控制块PCB。在linux中即是task_struct。结构定义位于

/include/linux/sched.h

操作系统

• 进程管理
• 内存管理
• 文件系统

进程控制块PCB--task_struct

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

重要参数

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)。

​ 进程描述符中有指向mm_struct结构体的指针mm，这个结构体是对该进程用户空间的描述；也有指向fs_struct结构体的指针fs，这个结构体是对进程当前所在目录的描述；也有指向files_struct结构体的指针files，这个结构体是对该进程已打开的所有文件进行描述；另外还有一个小型的进程描述符(low-level information)—thread_info。在这个结构体中，也有指向该进程描述符的指针task。因此，这两个结构体是相互关联的。

二、分析ｆｏｒｋ函数对应的内核处理过程

fork、vfork、 clone三个系统调用都可以创建一个新进程，而且都是通过调用do_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结构体内的pidpid = 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);}// 将子进程添加到调度器的队列，使得子进程有机会获得CPUwake_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。

当执行fork系统调用时，操作系统会执行以下步骤:

1.内核确保有创建新进程所需的充足的系统资源。其完成过程如下:

（1）内核确保系统可以处理多个将要调度的进程，而且调度程序上的负载是可以管理的。

（2）内核确保这个特定的用户当前没有运行过多垄断使用现有资源的进程。

（3）内核确保为新进程提供足够的内存空间。
操作系统已经知道：此时新进程和父进程在各个方面都是相同的。这还包括内存要求。在交换系统中，整个内存都要是可用的。在纯分页系统中，需要大量用于保存整个地址空间和页面映射表的内存空间。在请求分页调度中，启动进程，至少页面映射表必不可少。在请求分页调度方法中，地址空间中更多的页面可以通过缺页错误累计得到。如果内存空间不足，内核检查磁盘上是否有空间，如果有，就占用该空间的交换区。像前面在进程状态转移中讨论的一样，据此确定子进程的状态。

2.内核现在从进程表中找到一个位置，然后开始构造子进程的上下文。

3.内核维护"下一个可用的ID号"的全局值。任何时候，当fork系统调用创建新进程时，内核将该ID分配给新的子进程，并将该编号加1。内核还要设置一个最大值，当设置超过这个值的时候，系统就不能处理任何进程。如果该编号等于或大于这个最大值，内核从0重新分配编号，但是另一方面希望pid等于0的进程已经终止运行。

4.内核初始化子进程的进程表插槽中的字段，如下：

（1） 内核将真实有效的用户ID从父进程的进程表插槽中复制到子进程对应的位置。

（2）内核还要将父进程的准确值复制给子进程。

（3）内核通过将父进程ID复制到子进程插槽，从而链接进程树结构中的子进程。

（4）内核初始化子进程插槽中不同的调度字段和统计字段，如初始优先级、CPU使用情况等。

（5）内核将该子进程的状态设置为"正在创建"。

5.现在，内核搜索父进程u区（进程信息交换区）中的文件描述符，并沿着指针从用户打开文件描述符到文件表条目，同时将文件表中那些条目的引用计数增加1。

6.内核为子进程的u区、区域表、页表等分配内存空间。

7.现在，除了子进程u区指向进程表插槽的指针要做适当的调整之外，内核将父进程的u区复制给子进程。这是因为父进程和子进程在进程表中有两个不同的条目。因此，指向这两个不同条目的指针也不相同。此时，所有其他内容是相同的。

8.内核将数据和堆栈区(非共享的部分)复制到子进程的另一个内存区，并调整区域表条目。然而，它只保存文本区的一个副本，因为文本区是共享的。诚如所示，此时文本包含相同的程序代码。

9.内核在子进程上下文的静态部分后面创建动态内容。它复制父进程上下文包含保存Fork系统调用的寄存器和内核堆栈的第一层。此时，父进程和子进程的内核堆栈的内容完全相同。

10/内核创建子进程第2层的伪程序上下文，这个伪程序上下文包括第1层保存的寄存器上下文。它在寄存器内容保存区中设置程序计数器(PC)和其他寄存器，这样就可以在适当的位置"重新开始"执行子进程。

11.现在，内核将子进程状态从"准备就绪"变成"准备运行"(根据情况要么在内存中，要么被交换)。它将子进程ID返回给用户。

12.调度程序最终调度子进程。在程序中，调度程序检查它是不是子进程。因为如果是子进程，它会执行"Exec"系统调用，由此将新程序加载到子进程的地址空间中。

3.1 do_fork()流程

首先调用copy_process()为子进程复制出一份进程信息，如果是vfork()则初始化完成处理信息；
然后调用wake_up_new_task将子进程加入调度器，为之分配CPU，如果是vfork()，则父进程等待子进程完成exec替换自己的地址空间。

3.2 copy_process()流程

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

3.3 dup_task_struct()流程

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

3.4 copy_thread的流程

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

3.5 新进程从ret_from_fork处开始执行，子进程的运行是由这几处保证的

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

三.使用GDB分析

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

添加到menuconfig中

然后重新生成文件系统，使用qemu重新挂载内核，然后(承接上次)

make rootfs

然后重开一个shell进入linux内核的文件夹进行gdb。

gdb vmlinux
target remote:1234
b sys_clone
b do_fork
b dup_task_struct
b copy_process
b copy_thread
b ret_from_for

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

Elf可执行文件的过程

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

流程图

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

编辑一个test.c文件

#include<stdio.h>
#include<stdlib.h>
int main(){printf("hello world!\n");return 0;
}

然后进行编译

test.static 明显大于test。

静态链接方式：在程序运行之前完成所有的组装工作，生成一个可执行的目标文件

动态链接方式：在程序已经为了执行被装载入内存之后完成链接工作，并且在内存中一般只保留该编译单元的一份拷贝

动态链接库的两种链接方式:装载时动态链接、运行时动态链接

六、使用gdb跟踪分析一个execve系统调用内核处理函数do_execve,验证您对linux系统加载可执行程序所需过程的理解

1.设置断点

2.中断情况如下

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()函数 ，验证对Linux系统进程调度与进程切换过程的理解

首先设几个断点分别是schedule，pick_next_task，context_switch，__switch_to

schdule调用和函数

两个重要的函数context_switch和pick_next_task函数都在schedule函数中

pick_next_task

context_switch

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

1.关键函数的调用关系:

schedule() --> context_switch() --> switch_to --> __switch_to()

2.汇编代码分析

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

总结

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

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

参考

https://blog.csdn.net/weixin_43389097/article/details/88743522

https://blog.csdn.net/m0_37962600/article/details/79943461

https://blog.csdn.net/pjz000/article/details/88818849

https://blog.csdn.net/qq_31209133/article/details/88817974

https://blog.csdn.net/qq_30417071/article/details/88809270