标签：
郭垚 原创作品转载请注明出处 《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000
【学习视频时间：1小时 撰写博客时间：2小时】
【学习内容：进程创建的过程、使用gdb跟踪分析内核处理函数sys_clone】
1. 进程控制块PCB——task_struct
为了管理进程，内核必须对每个进程进行清晰的描述，进程描述符提供了内核所需了解的进程信息。
struct task_struct{
volatile long state; //进程状态，-1表示不可执行，0表示可执行，大于1表示停止
void *stack; //内核堆栈
atomic_t usage;
unsigned int flags; //进程标识符
unsigned int ptrace;
……
}
struct task_ struct数据结构很庞大
Linux进程状态转换图
1242#ifdef CONFIG_SMP //条件编译，多处理器会用到 1243 struct llist_node wake_entry; 1244 int on_cpu; 1245 struct task_struct *last_wakee; 1246 unsigned long wakee_flips; 1247 unsigned long wakee_flip_decay_ts; 1248 1249 int wake_cpu; 1250#endif 1251 int on_rq; 1252 1253 int prio, static_prio, normal_prio; 1254 unsigned int rt_priority; //与优先级相关 1255 const struct sched_class *sched_class; 1256 struct sched_entity se; 1257 struct sched_rt_entity rt; …… 1295 struct list_head tasks; //进程链表 1296#ifdef CONFIG_SMP 1297 struct plist_node pushable_tasks; 1298 struct rb_node pushable_dl_tasks; 1299#endif
Linux的状态图
1301 struct mm_struct *mm, *active_mm; //内存管理进程的地址空间 1302#ifdef CONFIG_COMPAT_BRK 1303 unsigned brk_randomized:1; 1304#endif 1305 /* per-thread vma caching */ 1306 u32 vmacache_seqnum; 1307 struct vm_area_struct *vmacache[VMACACHE_SIZE]; 1308#if defined(SPLIT_RSS_COUNTING) 1309 struct task_rss_stat rss_stat; 1310#endif 1311/* task state */ 1312 int exit_state; //任务的状态 1313 int exit_code, exit_signal; 1314 int pdeath_signal; /* The signal sent when the parent dies */ 1315 unsigned int jobctl; /* JOBCTL_*, siglock protected */ 1316 1317 /* Used for emulating ABI behavior of previous Linux versions */ 1318 unsigned int personality; 1319 1320 unsigned in_execve:1; /* Tell the LSMs that the process is doing an 1321 * execve */ 1322 unsigned in_iowait:1; …… 1337 //进程的父子关系 1338 * pointers to (original) parent process, youngest child, younger sibling, 1339 * older sibling, respectively. (p->father can be replaced with 1340 * p->real_parent->pid) 1341 */ 1342 struct task_struct __rcu *real_parent; /* real parent process */ 1343 struct task_struct __rcu *parent; /* recipient of SIGCHLD, wait4() reports */ 1344 /* 1345 * children/sibling forms the list of my natural children 1346 */ 1347 struct list_head children; /* list of my children */ 1348 struct list_head sibling; /* linkage in my parent‘s children list */ 1349 struct task_struct *group_leader; /* threadgroup leader */
1356 struct list_head ptraced; //调试 1357 struct list_head ptrace_entry; 1358 1359 /* PID/PID hash table linkage. */ 1360 struct pid_link pids[PIDTYPE_MAX]; 1361 struct list_head thread_group; 1362 struct list_head thread_node; //将进程链表连接起来 …… 1411/* 与当前任务CPU状态相关，对进程上下文切换有关键性作用 */ 1412 struct thread_struct thread; 1413/* filesystem information */ 1414 struct fs_struct *fs; 1415/* 打开文件描述符列表 */ 1416 struct files_struct *files; 1417/* namespaces */ 1418 struct nsproxy *nsproxy; 1419/* 信号处理 */ 1420 struct signal_struct *signal; 1421 struct sighand_struct *sighand; 1422 1423 sigset_t blocked, real_blocked; 1424 sigset_t saved_sigmask; /* restored if set_restore_sigmask() was used */ 1425 struct sigpending pending; …… 1598 struct pipe_inode_info *splice_pipe; 1599 //与管道相关 1600 struct page_frag task_frag; 1601 1602#ifdef CONFIG_TASK_DELAY_ACCT 1603 struct task_delay_info *delays; 1604#endif 1605#ifdef CONFIG_FAULT_INJECTION 1606 int make_it_fail; 1607#endif
回顾：
fork一个子进程的代码
#include <stdio.h> #include <stdlib.h> #include <unistd.h> int main(int argc, char * argv[]) { int pid; /* fork another process */ pid = fork(); if (pid < 0) { /* error occurred */ fprintf(stderr,"Fork Failed!"); exit(-1); } else if (pid == 0) //pid == 0和下面的else都会被执行到（一个是在父进程中即pid ==0的情况，一个是在子进程中，即pid不等于0） { /* child process */ printf("This is Child Process!\n"); } else { /* parent process */ printf("This is Parent Process!\n"); /* parent will wait for the child to complete*/ wait(NULL); printf("Child Complete!\n"); } }
Linux中创建进程一共有三个函数：
这里值得注意的是，Linux中得线程是通过模拟进程实现的，较新的内核使用的线程库一般都是NPTL。
复制一个PCB——task_struct
err = arch_dup_task_struct(tsk, orig);
给新进程分配一个新的内核堆栈
ti = alloc_ thread_ info_ node(tsk, node); tsk->stack = ti; setup_ thread_ stack(tsk, orig); //这里只是复制thread_ info，而非复制内核堆栈
通过之前的学习，我们知道fork是通过触发0x80中断，陷入内核，来使用内核提供的提供调用：
SYSCALL_DEFINE0(fork) { return do_fork(SIGCHLD, 0, 0, NULL, NULL); } #endif SYSCALL_DEFINE0(vfork) { return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, 0, 0, NULL, NULL); } SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp, int __user *, parent_tidptr, int __user *, child_tidptr, int, tls_val) { return do_fork(clone_flags, newsp, 0, parent_tidptr, child_tidptr); }
通过以上精简后的代码，我们可以看出，fork、vfork和clone这三个函数最终都是通过do_ 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); // 如果使用的是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大概做了如下几件事：
抛开vfork，进程创建的大部分过程都在copy_ process函数中copy_process的代码非常复杂，这里我精简了大部分，只留下最重要的一些：
/* 创建进程描述符以及子进程所需要的其他所有数据结构 为子进程准备运行环境 */ static struct task_struct *copy_process(unsigned long clone_flags, unsigned long stack_start, unsigned long stack_size, int __user *child_tidptr, struct pid *pid, int trace) { int retval; struct task_struct *p; // 分配一个新的task_struct，此时的p与当前进程的task，仅仅是stack地址不同 p = dup_task_struct(current); // 检查该用户的进程数是否超过限制 if (atomic_read(&p->real_cred->user->processes) >= task_rlimit(p, RLIMIT_NPROC)) { // 检查该用户是否具有相关权限，不一定是root if (p->real_cred->user != INIT_USER && !capable(CAP_SYS_RESOURCE) && !capable(CAP_SYS_ADMIN)) goto bad_fork_free; } retval = -EAGAIN; // 检查进程数量是否超过 max_threads，后者取决于内存的大小 if (nr_threads >= max_threads) goto bad_fork_cleanup_count; // 初始化自旋锁 // 初始化挂起信号 // 初始化定时器 // 完成对新进程调度程序数据结构的初始化，并把新进程的状态设置为TASK_RUNNING retval = sched_fork(clone_flags, p); // ..... // 复制所有的进程信息 // copy_xyz // 初始化子进程的内核栈 retval = copy_thread(clone_flags, stack_start, stack_size, p); if (retval) goto bad_fork_cleanup_io; if (pid != &init_struct_pid) { retval = -ENOMEM; // 这里为子进程分配了新的pid号 pid = alloc_pid(p->nsproxy->pid_ns_for_children); if (!pid) goto bad_fork_cleanup_io; } /* ok, now we should be set up.. */ // 设置子进程的pid p->pid = pid_nr(pid); // 如果是创建线程 if (clone_flags & CLONE_THREAD) { p->exit_signal = -1; // 线程组的leader设置为当前线程的leader p->group_leader = current->group_leader; // tgid是当前线程组的id，也就是main进程的pid p->tgid = current->tgid; } else { if (clone_flags & CLONE_PARENT) p->exit_signal = current->group_leader->exit_signal; else p->exit_signal = (clone_flags & CSIGNAL); // 创建的是进程，自己是一个单独的线程组 p->group_leader = p; // tgid和pid相同 p->tgid = p->pid; } if (clone_flags & (CLONE_PARENT|CLONE_THREAD)) { // 如果是创建线程，那么同一线程组内的所有线程、进程共享parent p->real_parent = current->real_parent; p->parent_exec_id = current->parent_exec_id; } else { // 如果是创建进程，当前进程就是子进程的parent p->real_parent = current; p->parent_exec_id = current->self_exec_id; } // 将pid加入PIDTYPE_PID这个散列表 attach_pid(p, PIDTYPE_PID); // 递增 nr_threads的值 nr_threads++; // 返回被创建的task结构体指针 return p; }
根据这份精简代码，我总结出copy_process的大体流程：
一个新创建的子进程，（当它获得CPU之后）是从哪一行代码进程执行的？
这涉及子进程的内核堆栈数据状态和task_ struct中thread记录的sp和ip的一致性问题，这是在copy_ thread in copy_ process设定的
*childregs = *current_pt_regs(); //复制内核堆栈 childregs->ax = 0; //子进程的fork返回0 p->thread.sp = (unsigned long) childregs; //调度到子进程时的内核栈顶 p->thread.ip = (unsigned long) ret_from_fork; //调度到子进程时的第一条指令地址
1. 更新menu，删除test_fork.c和test.c文件，重新执行make rootfs
2. 编译内核查看fork命令
3. 启动gdb调试，并对主要的函数设置断点
执行一个fork，会发现只输出一个fork的命令描述，后面并没有执行，因为它停在了sys_ clone这个位置。
4. 特别关注新进程是从哪里开始执行的？为什么从哪里能顺利执行下去？即执行起点与内核堆栈如何保证一致。
答：ret_ from_ fork决定了新进程的第一条指令地址。子进程从ret_ from_ fork处开始执行。因为在ret_ from_ fork之前,也就是在copy_ thread()函数中* childregs = * current_ pt_ regs();该句将父进程的regs参数赋值到子进程的内核堆栈。* childregs的类型为pt_ regs,里面存放了SAVE_ ALL中压入栈的参数,因此在之后的RESTORE ALL中能顺利执行下去。
Linux中所有的进程创建都是基于复制的方式，Linux通过复制父进程来创建一个新进程,通过调用do_ fork来实现。然后对子进程做一些特殊的处理。而Linux中的线程，又是一种特殊的进程。根据代码的分析，do_ fork中，copy_ process管子进程运行的准备，wake_ up_ new_ task作为子进程forking的完成。fork()函数最大的特点就是被调用一次，返回两次。
标签：
原文地址：http://www.cnblogs.com/20135228guoyao/p/5334985.html
