丁春阳+原创作品转载请注明出处 + https://github.com/mengning/linuxkernel/
一、实验步骤及分析
进程描述
我们通过进程控制块来描述来描述进程，又称其为进程描述符，他提供了进程相关的所有信息,例如状态、进程双向链表管理、控制台、文件系统、内存管理、进程间通信等等。
struct task_struct {
volatile long state; /* -1 unrunnable, 0 runnable, >0 stopped */
void *stack;
atomic_t usage;
unsigned int flags; /* per process flags, defined below */
unsigned int ptrace;
...
}进程状态转换图
使用fork进程创建子进程后，新进程的状态是TASK_RUNNING，将此进程从就绪队列调度执行时状态也是TASK_RUNNING。
进程创建
0号进程初始化是通过硬编码固定下来的，init_task为0号进程的进程描述符的结构体变量。init_task初始化如下：
struct task_struct init_task = INIT_TASK(init_task);
EXPORT_SYMBOL(init_task);rest_init调用kernel_thread创建1号进程和2号进程,一个是kernel_init，init用户进程；另一个是kthreadd进程，是所有内核进程的祖先，管理内核进程。
static noinline void __init_refok rest_init(void){
....
kernel_thread(kernel_init,NULL,CLONE_FILES);
....
pid = kernel_thread(kthreadd,NULL,CLONE_FS|CLONE_FILES);
....
}使用fork函数创建进程
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
int main()
{
int pid;
pid = fork();
if(pid < 0)
{
fprintf("stderr","failed!");
}
else if(pid == 0)
{
printf("This is child process!\n");
}
else
{
printf("This is parent process!\n");
wait(NULL);
printf("child complete!\n");
}
return 0;
}
fork系统调用把当前进程又复制了一个子进程，此时两个进程执行相同的代码，只是父进程和子进程的返回值不同，而两个进程输出信息在一个终端。
fork系统调用
fork系统调用时，用户态用int $0x80指令触发中断机制，cpu自动从用户态堆栈转为内核态堆栈,将ss：esp，cs:eip以及eflags压到当前进程内核堆栈中，接下来执行system_call,其用于保存现场，调用系统调用内核函数，处理完后返回，恢复现场。最后iret将ss：esp，cs:eip以及eflags从内核堆栈恢复到相应寄存器中。
fork，vfork以及clone 、kernel_thread函数都是通过do_fork来创建一个进程，参考代码如下
1696pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
1697{
1698 return do_fork(flags|CLONE_VM|CLONE_UNTRACED, (unsigned long)fn,
1699 (unsigned long)arg, NULL, NULL);
1700}
1701
1702#ifdef __ARCH_WANT_SYS_FORK
1703SYSCALL_DEFINE0(fork)
1704{
1705#ifdef CONFIG_MMU
1706 return do_fork(SIGCHLD, 0, 0, NULL, NULL);
1707#else
1708 /* can not support in nommu mode */
1709 return -EINVAL;
1710#endif
1711}
1712#endif
1713
1714#ifdef __ARCH_WANT_SYS_VFORK
1715SYSCALL_DEFINE0(vfork)
1716{
1717 return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, 0,
1718 0, NULL, NULL);
1719}
1720#endif
1721
1722#ifdef __ARCH_WANT_SYS_CLONE
1723#ifdef CONFIG_CLONE_BACKWARDS
1724SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp,
1725 int __user *, parent_tidptr,
1726 int, tls_val,
1727 int __user *, child_tidptr)
1728#elif defined(CONFIG_CLONE_BACKWARDS2)
1729SYSCALL_DEFINE5(clone, unsigned long, newsp, unsigned long, clone_flags,
1730 int __user *, parent_tidptr,
1731 int __user *, child_tidptr,
1732 int, tls_val)
1733#elif defined(CONFIG_CLONE_BACKWARDS3)
1734SYSCALL_DEFINE6(clone, unsigned long, clone_flags, unsigned long, newsp,
1735 int, stack_size,
1736 int __user *, parent_tidptr,
1737 int __user *, child_tidptr,
1738 int, tls_val)
1739#else
1740SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp,
1741 int __user *, parent_tidptr,
1742 int __user *, child_tidptr,
1743 int, tls_val)
1744#endif
1745{
1746 return do_fork(clone_flags, newsp, 0, parent_tidptr, child_tidptr);
1747}
1748#endif
1749do_fork 函数代码如下，便于理解为其添加注释。
long do_fork(unsigned long clone_flags,
1624 unsigned long stack_start,
1625 unsigned long stack_size,
1626 int __user *parent_tidptr,
1627 int __user *child_tidptr)
1628{
1629 struct task_struct *p;//进程描述符指针
1630 int trace = 0;
1631 long nr;//子进程id
1632
1633 /*
1634 * Determine whether and which event to report to ptracer. When
1635 * called from kernel_thread or CLONE_UNTRACED is explicitly
1636 * requested, no event is reported; otherwise, report if the event
1637 * for the type of forking is enabled.
1638 */
1639 if (!(clone_flags & CLONE_UNTRACED)) {
1640 if (clone_flags & CLONE_VFORK)
1641 trace = PTRACE_EVENT_VFORK;
1642 else if ((clone_flags & CSIGNAL) != SIGCHLD)
1643 trace = PTRACE_EVENT_CLONE;
1644 else
1645 trace = PTRACE_EVENT_FORK;
1646
1647 if (likely(!ptrace_event_enabled(current, trace)))
1648 trace = 0;
1649 }
1650
1651 p = copy_process(clone_flags, stack_start, stack_size,
1652 child_tidptr, NULL, trace);//创建子进程描述符
1653 /*
1654 * Do this prior waking up the new thread - the thread pointer
1655 * might get invalid after that point, if the thread exits quickly.
1656 */
1657 if (!IS_ERR(p)) {//copy_prpcess执行成功
1658 struct completion vfork;
1659 struct pid *pid;
1660
1661 trace_sched_process_fork(current, p);
1662
1663 pid = get_task_pid(p, PIDTYPE_PID);//获得task结构体的pid
1664 nr = pid_vnr(pid);//根据pid结构体获得进程pid
1665
1666 if (clone_flags & CLONE_PARENT_SETTID)
1667 put_user(nr, parent_tidptr);
1668
1669 if (clone_flags & CLONE_VFORK) {
1670 p->vfork_done = &vfork;
1671 init_completion(&vfork);
1672 get_task_struct(p);
1673 }
1674
1675 wake_up_new_task(p);//将子进程添加到调度器的队列
1676
1677 /* forking complete and child started to run, tell ptracer */
1678 if (unlikely(trace))
1679 ptrace_event_pid(trace, pid);
1680
1681 if (clone_flags & CLONE_VFORK) {
1682 if (!wait_for_vfork_done(p, &vfork))
1683 ptrace_event_pid(PTRACE_EVENT_VFORK_DONE, pid);
1684 }
1685
1686 put_pid(pid);
1687 } else {
1688 nr = PTR_ERR(p);//异常处理
1689 }
1690 return nr;//返回子进程pid
1691}do_fork函数主要完成了以下工作：
- 通过调用copy_process()复制父进程信息，创建描述符及其他的数据结构
- 获得pid
- 调用wake_up_new_task(p)将子进程加入调度器队列，等待cpu资源运行
copy_process函数
static struct task_struct *copy_process(unsigned long clone_flags,
1183 unsigned long stack_start,
1184 unsigned long stack_size,
1185 int __user *child_tidptr,
1186 struct pid *pid,
1187 int trace)
1188{
1189 int retval;
1190 struct task_struct *p;
...
1235 retval = security_task_create(clone_flags);//安全性检查
...
1240 p = dup_task_struct(current);//核心语句，复制pcb，内核栈
...
1252 retval = -EAGAIN;
//检查用户进程数是否超过限制
1253 if (atomic_read(&p->real_cred->user->processes) >=
1254 task_rlimit(p, RLIMIT_NPROC)) {
1255 if (p->real_cred->user != INIT_USER &&
1256 !capable(CAP_SYS_RESOURCE) && !capable(CAP_SYS_ADMIN))
1257 goto bad_fork_free;
1258 }
...
//检查进程数量是否超过max_threads
1271 if (nr_threads >= max_threads)
1272 goto bad_fork_cleanup_count;
1273
1274 if (!try_module_get(task_thread_info(p)->exec_domain->module))
1275 goto bad_fork_cleanup_count;
1276
...
1360 retval = sched_fork(clone_flags, p);//初始化新进程调度数据结构，将新进程状态设置为TASK_RUNNING
1361 if (retval)
1362 goto bad_fork_cleanup_policy;
1363
1364 retval = perf_event_init_task(p);
1365 if (retval)
1366 goto bad_fork_cleanup_policy;
1367 retval = audit_alloc(p);
1368 if (retval)
1369 goto bad_fork_cleanup_perf;
1370 /* copy all the process information */
1371 shm_init_task(p);
1372 retval = copy_semundo(clone_flags, p);
1373 if (retval)
1374 goto bad_fork_cleanup_audit;
1375 retval = copy_files(clone_flags, p);
1376 if (retval)
1377 goto bad_fork_cleanup_semundo;
1378 retval = copy_fs(clone_flags, p);
1379 if (retval)
1380 goto bad_fork_cleanup_files;
1381 retval = copy_sighand(clone_flags, p);
1382 if (retval)
1383 goto bad_fork_cleanup_fs;
1384 retval = copy_signal(clone_flags, p);
1385 if (retval)
1386 goto bad_fork_cleanup_sighand;
1387 retval = copy_mm(clone_flags, p);
1388 if (retval)
1389 goto bad_fork_cleanup_signal;
1390 retval = copy_namespaces(clone_flags, p);
1391 if (retval)
1392 goto bad_fork_cleanup_mm;
1393 retval = copy_io(clone_flags, p);
1394 if (retval)
1395 goto bad_fork_cleanup_namespaces;
1396 retval = copy_thread(clone_flags, stack_start, stack_size, p);//初始化子进程内核栈
...
1548
1549 return p;//返回被创建的子进程描述符指针p
...
}
copy_process函数主要完成以下工作:
- 调用dup_task_struct复制父进程描述符
- 调用copy_thread初始化子进程内核栈
- 将子进程置为就绪态
- 采用写时复制技术复制其他进程资源
- 设置子进程pid
dup_task_struct函数
305static struct task_struct *dup_task_struct(struct task_struct *orig)
306{
307 struct task_struct *tsk;
308 struct thread_info *ti;
309 int node = tsk_fork_get_node(orig);
310 int err;
311
312 tsk = alloc_task_struct_node(node);//为子进程创建进程描述符分配存储空间
313 if (!tsk)
314 return NULL;
315
316 ti = alloc_thread_info_node(tsk, node);//创建两个页，一部分存放thread_info,另一部分存放内核堆栈
317 if (!ti)
318 goto free_tsk;
319
320 err = arch_dup_task_struct(tsk, orig);//复制父进程task_struct
321 if (err)
322 goto free_ti;
323
324 tsk->stack = ti;//将栈底的值赋给新节点的stack
325#ifdef CONFIG_SECCOMP
326 /*
327 * We must handle setting up seccomp filters once we're under
328 * the sighand lock in case orig has changed between now and
329 * then. Until then, filter must be NULL to avoid messing up
330 * the usage counts on the error path calling free_task.
331 */
332 tsk->seccomp.filter = NULL;
333#endif
334//初始化子进程的thread_info
335 setup_thread_stack(tsk, orig);
336 clear_user_return_notifier(tsk);
337 clear_tsk_need_resched(tsk);
338 set_task_stack_end_magic(tsk);
339
340#ifdef CONFIG_CC_STACKPROTECTOR
341 tsk->stack_canary = get_random_int();
342#endif
343
344 /*
345 * One for us, one for whoever does the "release_task()" (usually
346 * parent)
347 */
348 atomic_set(&tsk->usage, 2);
349#ifdef CONFIG_BLK_DEV_IO_TRACE
350 tsk->btrace_seq = 0;
351#endif
352 tsk->splice_pipe = NULL;
353 tsk->task_frag.page = NULL;
354
355 account_kernel_stack(ti, 1);
356
357 return tsk;
358
359free_ti:
360 free_thread_info(ti);
361free_tsk:
362 free_task_struct(tsk);
363 return NULL;
364}dup_task_struct函数创建两个页，一部分存放thread_info,另一部分存放内核堆栈，复制父进程task_struct ，thread_info结构，然后将task指针指向子进程的进程描述符。
copy_thread函数
int copy_thread(unsigned long clone_flags, unsigned long sp,
133 unsigned long arg, struct task_struct *p)
134{
135 struct pt_regs *childregs = task_pt_regs(p);
136 struct task_struct *tsk;
137 int err;
138
139 p->thread.sp = (unsigned long) childregs;
140 p->thread.sp0 = (unsigned long) (childregs+1);
141 memset(p->thread.ptrace_bps, 0, sizeof(p->thread.ptrace_bps));
142
143 if (unlikely(p->flags & PF_KTHREAD)) {//内核线程
144 /* kernel thread */
145 memset(childregs, 0, sizeof(struct pt_regs));
//内核进程，从ret_from_kernel_thread开始执行
146 p->thread.ip = (unsigned long) ret_from_kernel_thread;
147 task_user_gs(p) = __KERNEL_STACK_CANARY;
148 childregs->ds = __USER_DS;
149 childregs->es = __USER_DS;
150 childregs->fs = __KERNEL_PERCPU;
151 childregs->bx = sp; /* function */
152 childregs->bp = arg;
153 childregs->orig_ax = -1;
154 childregs->cs = __KERNEL_CS | get_kernel_rpl();
155 childregs->flags = X86_EFLAGS_IF | X86_EFLAGS_FIXED;
156 p->thread.io_bitmap_ptr = NULL;
157 return 0;
158 }
//复制内核堆栈(复制父进程寄存器信息)
159 *childregs = *current_pt_regs();
160 childregs->ax = 0;//子进程eax =0,返回值为0
161 if (sp)
162 childregs->sp = sp;
163//从ret_from_fork执行
164 p->thread.ip = (unsigned long) ret_from_fork;
165 task_user_gs(p) = get_user_gs(current_pt_regs());
166
167 p->thread.io_bitmap_ptr = NULL;
168 tsk = current;
169 err = -ENOMEM;
170
171 if (unlikely(test_tsk_thread_flag(tsk, TIF_IO_BITMAP))) {
172 p->thread.io_bitmap_ptr = kmemdup(tsk->thread.io_bitmap_ptr,
173 IO_BITMAP_BYTES, GFP_KERNEL);
174 if (!p->thread.io_bitmap_ptr) {
175 p->thread.io_bitmap_max = 0;
176 return -ENOMEM;
177 }
178 set_tsk_thread_flag(p, TIF_IO_BITMAP);
179 }
180
181 err = 0;
182
183 /*
184 * Set a new TLS for the child thread?
185 */
186 if (clone_flags & CLONE_SETTLS)
187 err = do_set_thread_area(p, -1,
188 (struct user_desc __user *)childregs->si, 0);
189
190 if (err && p->thread.io_bitmap_ptr) {
191 kfree(p->thread.io_bitmap_ptr);
192 p->thread.io_bitmap_max = 0;
193 }
194 return err;
195}
196copy_thread函数是对内核信息的初始化。子进程开始执行的起点分为两种情况，内核进程从ret_from_kernel_thread开始执行，用户态进程从ret_from_fork执行。
使用gdb调试fork
使用以下指令启动menuOS
cd LinuxKernel
rm menu -rf
git clone https://github.com/mengning/menu.git
cd menu
mv test_fork.c test.c
make rootfs
打开另一个shell窗口，将当前目录设为LinuxKernel,进行gdb调试
cd LinuxKernel
gdb
file linux-3.18.6/vmlinux
target remote:1234
分别在sys_clone、do_fork、dup_task_struct、copy_process、copy_thread、ret_from_fork出设置断点。
停在断点 sys_clone处。
停在断点do_fork处
停在断点dup_task_struct处
停在断点copy_process处
停在断点copy_thread处
编程使用exec*库函数加载一个可执行文件
编辑文件myexec.c,生成预处理文件myexec.cpp,编译成汇编代码myexec.s,编译成目标代码，即二进制文件myexec.o,链接成可执行文件myexec，运行./myexec。
编译链接的过程和ELF可执行文件格式
编译链接过程
ELF可执行文件格式
可重定位文件：一般是中间文件，需要和其他文件一起来创建可执行文件、静态库文件、共享目标文件。
可执行文件：文件中保存着一个用来执行的文件。
共享目标文件：指可以被可执行文件或其他库文件使用的目标。
execve函数过程描述
整体调用关系为 execve->sys_execve->do_execve() -> do_execve_common()->exec_binprm()->search_binary_handler()->load_elf_binary()->start_thread()。
大致处理过程如下：
- sys_execve中的do_execve() 读取128个字节的文件头部，判断可执行文件的类型
- 调用search_binary_handler()搜索和匹配合适的可执行文件装载处理过程。
- ELF文件由load_elf_binary()函数负责装载，load_elf_binary()函数调用了start_thread函数，创建新进程的堆栈。
使用gdb跟踪分析一个execve系统调用内核处理函数do_execve
分别在sys_execve、do_execve() 、do_execve_common()、exec_binprm()、search_binary_handler()、load_elf_binary()、start_thread()设置断点
断点 do _execve处，可以看出其调用do_execve_common(）函数。
新的可执行程序执行起点以及为什么execve系统调用返回后新的可执行程序能顺利执行？
新的可执行程序开始执行的起点在于修改的调用 execve系统调用时压入内核堆栈的EIP的值,此时标志着当前进程可执行文件已经完全替换成新的可执行文件。
对于静态链接的可执行程序和动态链接的可执行程序execve系统调用返回时会有什么不同？
静态链接：elf_entry指向可执行文件的头部，一般是main函数，是新程序执行的起点，一般地址为0x8048XXX的位置。
动态链接：elf_entry指向ld即动态链接器的起点load_elf_interp。
使用gdb调试一个schedule()函数
分别在schedule，pick_next_task，context_switch，__switch_to设置断点
schedule调用_schedule,_schedule调用pick_next_task，context_switch函数，context_switch函数调用__switch_to。pick_next_task函数是根据调度策略和调度算法选择下一进程,context_switch函数负责进程的切换。
分析switch_to中的汇编代码，理解进程上下文的切换机制，以及与中断上下文切换的关系
#define switch_to(prev, next, last) \
32do { \
33 /* \
34 * Context-switching clobbers all registers, so we clobber \
35 * them explicitly, via unused output variables. \
36 * (EAX and EBP is not listed because EBP is saved/restored \
37 * explicitly for wchan access and EAX is the return value of \
38 * __switch_to()) \
39 */ \
40 unsigned long ebx, ecx, edx, esi, edi; \
41 \
42 asm volatile("pushfl\n\t" /* 保存当前进程flags */
43 "pushl %%ebp\n\t" /* 保存当前进程的堆栈基址EBP */
44 "movl %%esp,%[prev_sp]\n\t" /* 保存当前栈顶ESP */
45 "movl %[next_sp],%%esp\n\t" /* 将下一栈栈顶保存到esp中 */
//完成内核堆栈的切换
46 "movl $1f,%[prev_ip]\n\t" /* 保存当前进程的EIP */
47 "pushl %[next_ip]\n\t" /* 把next进程的起点EIP压入堆栈 */
48 __switch_canary
//next_ip一般是$if，对于新创建的子进程是ret_from_fork
49 "jmp __switch_to\n" /* prev进程中，设置next进程堆栈 */
50 "1:\t" //next进程开始执行
51 "popl %%ebp\n\t" /* restore EBP */ \
52 "popfl\n" /* restore flags */ \
53 \
54 /* output parameters */ \
55 : [prev_sp] "=m" (prev->thread.sp), \
56 [prev_ip] "=m" (prev->thread.ip), \
57 "=a" (last), \
58 \
59 /* clobbered output registers: */ \
60 "=b" (ebx), "=c" (ecx), "=d" (edx), \
61 "=S" (esi), "=D" (edi) \
62 \
63 __switch_canary_oparam \
64 \
65 /* input parameters: */ \
66 : [next_sp] "m" (next->thread.sp), \
67 [next_ip] "m" (next->thread.ip), \
68 \
69 /* regparm parameters for __switch_to(): */ \
70 [prev] "a" (prev), \
71 [next] "d" (next) \
72 \
73 __switch_canary_iparam \
74 \
75 : /* reloaded segment registers */ \
76 "memory"); \
77} while (0)
首先在当前进程prev的内核栈中保存esi,edi及ebp寄存器的内容。然后将prev的内核堆栈指针esp存入prev->thread.esp中。
把将next进程的内核栈指针next->thread.esp置入esp寄存器中，将当前进程的地址保存在prev->thread.eip中，这个地址就是prev下一次被调度，通过jmp指令转入一个函数__switch_to，__switch_to中jmp与return的匹配，return 会弹出返回地址，因为jmp不会压栈，return弹出的则是栈顶地址即$1f标识之处。恢复next上次被调离时推进堆栈的内容。next进程开始执行。
进程上下文及与中断上下文切换的关系
进程上下文切换需要保存切换进程的相关信息（thread.sp和thread.ip）；中断上下文的切换是在一个进程的用户态到一个进程的内核态，或从进程的内核态到用户态，切换进程需要在不同的进程间切换，但一般进程上下文切换是套在中断上下文切换中的。例如，系统调用作为中断陷入内核，，调用schedule函数发生进程上下文切换，系统调用返回，完成中断上下文的切换。
三、总结
linux执行过程
- 运行用户态进程U
- 发生中断：save cs:eip/ss:eip/eflags,加载当前进程内核堆栈，跳转至中断处理程序
- SAVE_ALL,保存现场，完成中断上下文的切换。
- 中断处理过程若调用了schedule函数，其中switch_to做进程上下文的切换。（假设由进程U到进程M）
- $1f之后，运行用户态进程M
- restore_all,恢复现场
- iret 从U进程内核堆栈弹出硬件完成的压栈内容，完成中断上下文的切换，即U的内核态到用户态。
- 继续运行U。