307
原创作品转载请注明出处
本实验来源 https://github.com/mengning/linuxkernel/
一、阅读理解task_struct数据结构
代码：http://codelab.shiyanlou.com/xref/linux-3.18.6/include/linux/sched.h#1235
什么是进程？
<1> 进程是程序的一个执行实例
<2> 进程是正在执行的程序
<3> 进程是能分配处理器并由处理器执行的实体
为了管理进程，操作系统必须对每个进程所做的事情进行清楚的描述，为此，操作系统使用数据结构来代表处理不同的实体，这个数据结构就是通常所说的进程描述符或进程控制块（PCB）。
在linux操作系统下这就是task_struct结构 ，所属的头文件#include <sched.h>每个进程都会被分配一个task_struct结构，它包含了这个进程的所有信息，在任何时候操作系统都能够跟踪这个结构的信息。
task_struct结构中主要包含以下内容：
状态信息：如就绪、执行等状态
链接信息：用来描述进程之间的家庭关系，例如指向父进程、子进程、兄弟进程等PCB的指针 各种标识符：如进程标识符、用户及组标识符等
时间和定时器信息：进程使用CPU时间的统计等 调度信息：调度策略、进程优先级、剩余时间片大小等
处理机环境信息：处理器的各种寄存器以及堆栈情况等 虚拟内存信息：描述每个进程所拥有的地址空间
部分代码
struct task_struct{
pid_t pid; //进程id
uid_t uid,euid;
gid_t gid,egid;
volatile long state; //进程状态，0 running（运行/就绪）；1/2 均等待态，分别响应/不响应异步信号；4 僵尸态，Linux特有，为生命周期已终止，但PCB未释放；8 暂停态，可被恢复
int exit_state; //退出的状态
unsigned int rt_priority; //调度优先级
unsigned int policy; //调度策略
struct list_head tasks;
struct task_struct *real_parent;
struct task_struct *parent;
struct list_head children,sibling;
struct fs_struct *fs; //进程与文件系统管理，进程工作的目录与根目录
struct files_struct *files; //进程对所有打开文件的组织，存储指向文件的句柄们
struct mm_struct *mm; //内存管理组织，存储了进程在用户空间不同的地址空间，可能存的数据，可能代码段
struct signal_struct *signal; //进程间通信机制--信号
struct sighand_struct *sighand; //指向进程
cputime_t utime, stime; //进程在用户态、内核态下所经历的节拍数
struct timespec start_time; //进程创建时间
struct timespec real_start_time; //包括睡眠时间的创建时间
}
二、分析fork函数对应的内核处理过程 do_fork
1.代码如下：
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;
}
2.do_fork处理了以下内容：
do_fork()函数负责处理clone()、fork()和vfork()系统调用。
调用copy_process，将当期进程复制一份出来为子进程，并且为子进程设置相应地上下文信息。
初始化vfork的完成处理信息（如果是vfork调用）
调用wake_up_new_task，将子进程放入调度器的队列中，此时的子进程就可以被调度进程选中，得以运行。
3.进程的创建
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 赋值给新节点的栈。
static struct task_struct *dup_task_struct(struct task_struct *orig)
{
struct task_struct *tsk;
struct thread_info *ti;
int node = tsk_fork_get_node(orig);
int err;
tsk = alloc_task_struct_node(node); //申请进程描述符
if (!tsk)
return NULL;
ti = alloc_thread_info_node(tsk, node); // 申请线程描述符
if (!ti)
goto free_tsk;
//将父进程的进程描述符,线程描述符,内核栈的值赋值给子进程
err = arch_dup_task_struct(tsk, orig);
if (err)
goto free_ti;
tsk->stack = ti; //子进程的进程描述符的stack指针设为子进程的线程描述符
return tsk;
free_ti:
free_thread_info(ti);
free_tsk:
free_task_struct(tsk);
return NULL;
}
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寄存器的值，这是子进程的第一条指令。
问题：如何创建一个新进程
通过调用do_fork来实现进程的创建；
复制父进程PCB–task_struct来创建一个新进程，要给新进程分配一个新的内核堆栈;
修改复制过来的进程数据，比如pid、进程链表等等执行copy_process和copy_thread。
三、使用gdb跟踪分析一个fork系统调用内核处理函数do_fork 编译
rm menu -rf
git clone https://github.com/mengning/menu.git
cd menu
mv test_fork.c test.c
make rootfs
打开gdb进行调试，并设置断点
b sys_clone
b _do_fork
b dup_task_struct
b copy_process
最终结果
2.进入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_for
运行后首先停在sys_clone处
然后到do_fork
再到copy_process
进入copy_thread
在copy_thread中,我们可以查看p的值
四、理解编译链接的过程和ELF可执行文件格式
动态链接库(Dynamic Linked Library)： Windows为应用程序提供了丰富的函数调用，这些函数调用都包含在动态链接库中。其中有3个最重要的DLL，Kernel32.dll，它包含用于管理内存、进程和线程的各个函数；User32.dll，它包含用于执行用户界面任务(如窗口的创建和消息的传送)的各个函数；GDI32.dll，它包含用于画图和显示文本的各个函数。
静态库(Static Library)：
函数和数据被编译进一个二进制文件(通常扩展名为.LIB)。在使用静态库的情况下，在编译链接可执行文件时，链接器从库中复制这些函数和数据并把它们和应用程序的其它模块组合起来创建最终的可执行文件(.EXE文件)。
ELF文件由4部分组成，分别是ELF头（ELF header）、程序头表（Program header table）、节（Section）和节头表（Section header table）。实际上，一个文件中不一定包含全部内容，而且他们的位置也未必如同所示这样安排，只有ELF头的位置是固定的，其余各部分的位置、大小等信息由ELF头中的各项值来决定。
五、编程使用exec*库函数加载一个可执行文件，动态链接分为可执行程序装载时动态链接和运行时动态链接
在原fork函数上添加命令
execlp("/bin/ls",“ls”,NULL);
编译
六、使用gdb跟踪分析一个execve系统调用内核处理函数do_execve ，验证您对Linux系统加载可执行程序所需处理过程的理解
在实验楼提供的环境中，给qemu增加一个使用execve系统调用的菜单命令，如下所示：
在menu目录下执行如下命令：make rootfs启动MenuOS，结果如下所示：
使用GDB进行跟踪调试，设置如下断点：
在MenuOS中输入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 };
return do_execve_common(filename, argv, envp); // 此处调用do_execve_common
}
新的可执行程序是从哪里开始执行的？为什么execve系统调用返回后新的可执行程序能顺利执行？对于静态链接的可执行程序和动态链接的可执行程序execve系统调用返回时会有什么不同？
装载和启动一个可执行程序的大致流程如下所示： sys_execve -> do_execve-> do_execve_common->exec_binprm-> search_binary_handler -> load_elf_binary-> start_thread
对于静态链接的可执行文件，eip指向该文件的文件头e_entry所指的入口地址；对于动态链接的可执行文件，eip指向动态链接器。执行静态链接程序时，execve系统调用修改内核堆栈中保存的eip的值作为新的进程的起点。
新的可执行程序修改内核堆栈eip为新程序的起点，从new_ip开始执行，start_thread把返回到用户态的位置从int 0x80的下一条指令变成新的可执行文件的入口地址。
执行execve系统调用时，调用execve的可执行程序陷入内核态，使用execve加载的可执行文件覆盖当前进程的可执行程序，当execve系统调用返回时，返回新的可执行程序的起点（main函数），故新的可执行程序能够顺利执行。
七、理解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进程就成为当前进程而真正开始执行
这里借鉴大佬：https://blog.csdn.net/weixin_43389097/article/details/88743522
十、实验总结
通过系统调用，用户空间的应用程序就会进入内核空间，由内核代表该进程运行于内核空间，这就涉及到上下文的切换，用户空间和内核空间具有不同的地址映射，通用或专用的寄存器组，而用户空间的进程要传递很多变量、参数给内核，内核也要保存用户进程的一些寄存器、变量等，以便系统调用结束后回到用户空间继续执行，所谓的进程上下文，就是一个进程在执行的时候，CPU的所有寄存器中的值、进程的状态以及堆栈中的内容，当内核需要切换到另一个进程时，它需要保存当前进程的所有状态，即保存当前进程的进程上下文，以便再次执行该进程时，能够恢复切换时的状态，继续执行。 同理，硬件通过触发信号，导致内核调用中断处理程序，进入内核空间。这个过程中，硬件的一些变量和参数也要传递给内核，内核通过这些参数进行中断处理，中断上下文就可以理解为硬件传递过来的这些参数和内核需要保存的一些环境，主要是被中断的进程的环境。
200
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
