2017-2018-1 20179202《Linux内核原理与分析》第七周作业
一 、Linux内核创建一个新进程的过程
1. 知识准备
- 操作系统内核三大功能是进程管理，内存管理，文件系统，最核心的是进程管理
- linux 进程的状态和操作系统原理的描述进程状态有所不同，比如就绪状态和运行状态都是TASK_RUNNING。（这个表示它是可运行的，但是实际上有没有在运行取决于它是否占有 CPU ）
- fork 被调用一次，能够返回两次。在父进程中返回新创建子进程的 pid；在子进程中返回 0
- 调用 fork 之后，数据、堆、栈有两份，代码仍然为一份（这个代码段成为两个进程的共享代码段）。当父子进程有一个想要修改数据或者堆栈时，两个进程真正分裂。
2. 内核代码分析
SYSCALL_DEFINE0(fork)
{
#ifdef CONFIG_MMU
return do_fork(SIGCHLD, 0, 0, NULL, NULL);
#else
return -EINVAL;
#endif
}
SYSCALL_DEFINE0(vfork)
{
return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, 0,
0, NULL, NULL);
}
#ifdef __ARCH_WANT_SYS_CLONE
#ifdef CONFIG_CLONE_BACKWARDS
SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp,
int __user *, parent_tidptr,
int, tls_val,
int __user *, child_tidptr)
#elif defined(CONFIG_CLONE_BACKWARDS2)
SYSCALL_DEFINE5(clone, unsigned long, newsp, unsigned long, clone_flags,
int __user *, parent_tidptr,
int __user *, child_tidptr,
int, tls_val)
#elif defined(CONFIG_CLONE_BACKWARDS3)
SYSCALL_DEFINE6(clone, unsigned long, clone_flags, unsigned long, newsp,
int, stack_size,
int __user *, parent_tidptr,
int __user *, child_tidptr,
int, tls_val)
#else
SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp,
int __user *, parent_tidptr,
int __user *, child_tidptr,
int, tls_val)
#endif
{
return do_fork(clone_flags, newsp, 0, parent_tidptr, child_tidptr);
}
#endif
通过上面的代码可以看出 fork、vfork 和 clone 三个系统调用都可以创建一个新进程，而且都是通过 do_fork 来创建进程，只不过传递的参数不同。
（1）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)
首先了解一下 do_fork () 的参数：
- clone_flags：子进程创建相关标志，通过此标志可以对父进程的资源进行有选择的复制。
-
stack_start：子进程用户态堆栈的地址。
-
regs：指向 pt_regs 结构体（当系统发生系统调用时，pt_regs 结构体保存寄存器中的值并按顺序压入内核栈）的指针。
-
stack_size：用户态栈的大小，通常是不必要的，总被设置为0。
-
parent_tidptr 和 child_tidptr：父进程、子进程用户态下 pid 地址。
为方便理解，下述为精简关键代码：
struct task_struct *p; //创建进程描述符指针
int trace = 0;
long nr; //子进程pid
...
p = copy_process(clone_flags, stack_start, stack_size,
child_tidptr, NULL, trace); //创建子进程的描述符和执行时所需的其他数据结构
if (!IS_ERR(p)) //如果 copy_process 执行成功
struct completion vfork; //定义完成量（一个执行单元等待另一个执行单元完成某事）
struct pid *pid;
...
pid = get_task_pid(p, PIDTYPE_PID); //获得task结构体中的pid
nr = pid_vnr(pid); //根据pid结构体中获得进程pid
...
// 如果 clone_flags 包含 CLONE_VFORK 标志，就将完成量 vfork 赋值给进程描述符中的vfork_done字段，此处只是对完成量进行初始化
if (clone_flags & CLONE_VFORK) {
p->vfork_done = &vfork;
init_completion(&vfork);
get_task_struct(p);
}
wake_up_new_task(p); //将子进程添加到调度器的队列，使之有机会获得CPU
/* forking complete and child started to run, tell ptracer */
...
// 如果 clone_flags 包含 CLONE_VFORK 标志，就将父进程插入等待队列直至程直到子进程释调用exec函数或退出，此处是具体的阻塞
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; //返回子进程pid（父进程的fork函数返回的值为子进程pid的原因）
}
do_fork()主要完成了调用 copy_process() 复制父进程信息、获得pid、调用 wake_up_new_task 将子进程加入调度器队列，为之分配 CPU、通过 clone_flags 标志做一些辅助工作。其中 copy_process()是创建一个进程内容的主要的代码。
（2）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;
...
retval = security_task_create(clone_flags);//安全性检查
...
p = dup_task_struct(current); //复制PCB,为子进程创建内核栈、进程描述符
ftrace_graph_init_task(p);
···
retval = -EAGAIN;
// 检查该用户的进程数是否超过限制
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;
}
...
// 检查进程数量是否超过 max_threads，后者取决于内存的大小
if (nr_threads >= max_threads)
goto bad_fork_cleanup_count;
if (!try_module_get(task_thread_info(p)->exec_domain->module))
goto bad_fork_cleanup_count;
...
spin_lock_init(&p->alloc_lock); //初始化自旋锁
init_sigpending(&p->pending); //初始化挂起信号
posix_cpu_timers_init(p); //初始化CPU定时器
···
retval = sched_fork(clone_flags, p); //初始化新进程调度程序数据结构，把新进程的状态设置为TASK_RUNNING,并禁止内核抢占
...
// 复制所有的进程信息
shm_init_task(p);
retval = copy_semundo(clone_flags, p);
...
retval = copy_files(clone_flags, p);
...
retval = copy_fs(clone_flags, p);
...
retval = copy_sighand(clone_flags, p);
...
retval = copy_signal(clone_flags, p);
...
retval = copy_mm(clone_flags, p);
...
retval = copy_namespaces(clone_flags, p);
...
retval = copy_io(clone_flags, p);
...
retval = copy_thread(clone_flags, stack_start, stack_size, p);// 初始化子进程内核栈
...
//若传进来的pid指针和全局结构体变量init_struct_pid的地址不相同，就要为子进程分配新的pid
if (pid != &init_struct_pid) {
retval = -ENOMEM;
pid = alloc_pid(p->nsproxy->pid_ns_for_children);
if (!pid)
goto bad_fork_cleanup_io;
}
...
p->pid = pid_nr(pid); //根据pid结构体中获得进程pid
//若 clone_flags 包含 CLONE_THREAD标志，说明子进程和父进程在同一个线程组
if (clone_flags & CLONE_THREAD) {
p->exit_signal = -1;
p->group_leader = current->group_leader; //线程组的leader设为子进程的组leader
p->tgid = current->tgid; //子进程继承父进程的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; //子进程的组leader就是它自己
p->tgid = p->pid; //组号tgid是它自己的pid
}
...
if (likely(p->pid)) {
ptrace_init_task(p, (clone_flags & CLONE_PTRACE) || trace);
init_task_pid(p, PIDTYPE_PID, pid);
if (thread_group_leader(p)) {
...
// 将子进程加入它所在组的哈希链表中
attach_pid(p, PIDTYPE_PGID);
attach_pid(p, PIDTYPE_SID);
__this_cpu_inc(process_counts);
} else {
...
}
attach_pid(p, PIDTYPE_PID);
nr_threads++; //增加系统中的进程数目
}
...
return p; //返回被创建的子进程描述符指针P
...
}
copy_process 主要完成了调用 dup_task_struct 复制当前的 task_struct、信息检查、初始化、把进程状态设置为 TASK_RUNNING、复制所有进程信息、调用 copy_thread 初始化子进程内核栈、设置子进程pid。
（3）dup_task_struct
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); //为子进程创建进程描述符
...
ti = alloc_thread_info_node(tsk, node); //实际上是创建了两个页，一部分用来存放 thread_info，一部分就是内核堆栈
...
err = arch_dup_task_struct(tsk, orig); //复制父进程的task_struct信息
...
tsk->stack = ti; // 将栈底的值赋给新结点的stack
setup_thread_stack(tsk, orig);//对子进程的thread_info结构进行初始化(复制父进程的thread_info 结构，然后将 task 指针指向子进程的进程描述符)
...
return tsk; // 返回新创建的进程描述符指针
...
}
（4）copy_thread
dup_task_struct 只是为子进程创建一个内核栈，copy_thread 才真正完成赋值。
int copy_thread(unsigned long clone_flags, unsigned long sp,
unsigned long arg, struct task_struct *p)
{
struct pt_regs *childregs = task_pt_regs(p);
struct task_struct *tsk;
int err;
p->thread.sp = (unsigned long) childregs;
p->thread.sp0 = (unsigned long) (childregs+1);
memset(p->thread.ptrace_bps, 0, sizeof(p->thread.ptrace_bps));
if (unlikely(p->flags & PF_KTHREAD)) {
/* kernel thread */
memset(childregs, 0, sizeof(struct pt_regs));
p->thread.ip = (unsigned long) ret_from_kernel_thread; //如果创建的是内核线程，则从ret_from_kernel_thread开始执行
task_user_gs(p) = __KERNEL_STACK_CANARY;
childregs->ds = __USER_DS;
childregs->es = __USER_DS;
childregs->fs = __KERNEL_PERCPU;
childregs->bx = sp; /* function */
childregs->bp = arg;
childregs->orig_ax = -1;
childregs->cs = __KERNEL_CS | get_kernel_rpl();
childregs->flags = X86_EFLAGS_IF | X86_EFLAGS_FIXED;
p->thread.io_bitmap_ptr = NULL;
return 0;
}
*childregs = *current_pt_regs();//复制内核堆栈（复制父进程的寄存器信息，即系统调用SAVE_ALL压栈的那一部分内容）
childregs->ax = 0; //子进程的eax置为0，所以fork的子进程返回值为0
...
p->thread.ip = (unsigned long) ret_from_fork;//ip指向 ret_from_fork，子进程从此处开始执行
task_user_gs(p) = get_user_gs(current_pt_regs());
...
return err;
4. gdb调试
在刚才分析的关键点处分别设置断点：
现在 sys_clone 停下，再在 do_fork 停下，继续单步执行：
继续在 copy_process 停下，在 copy_thread 处停下，在这个地方可以查看 p 的值：
最后 ret_from_fork 跟踪到 syscall_exit 后无法继续。
5. 遇到的问题及解决
（1） thread_info 是什么？
通过搜索得知，它被称为小型的进程描述符，内存区域大小是8KB，占据连续的两个页框。该结构通过 task 指针指向进程描述符。内核栈是由高地址到低地址增长，thread_info 结构由低地址到高地址增长。内核通过屏蔽 esp 的低13位有效位获得 thread_info 结构的基地址。内核栈、thread_info结构、进程描述符之间的关系如下图所示（在较新的内核代码中，task_struct 结构中没有直接指向 thread_info 结构的指针，而是用一个 void 指针类型的成员表示，然后通过类型转换来访问 thread_info 结构）。
内核栈和 thread_info 结构是被定义在一个联合体当中，alloc_thread_info_node 分配的实则是一个联合体，即既分配了 thread_info 结构又分配了内核栈。
union thread_union {
struct thread_info thread_info;
unsigned long stack[THREAD_SIZE/sizeof(long)];
};
我们想要获得的一般是进程描述符而不是 thread_info，可以用 current 宏获取进程描述符（用task指针找到进程描述符）
static inline struct task_struct * get_current(void)
{
return current_thread_info()->task;
}
（2）do_fork 中，pid = get_task_pid(p, PIDTYPE_PID)不是就获取了 pid值吗？怎么后面还有一句 nr = pid_vnr(pid) ?
参考Linux 内核进程管理之进程ID，了解到PID命名空间相关知识。
pid结构体：
struct pid {
struct hlist_head tasks; //指回 pid_link 的 node
int nr; //PID
struct hlist_node pid_chain; //pid hash 散列表结点
};
pid_vnr：
pid_t pid_vnr(struct pid*pid)
{
return pid_nr_ns(pid,current->nsproxy->pid_ns); //current->nsproxy->pid_ns是当前pid_namespace
}
获得 pid 实例之后，再根据 pid 中的numbers 数组中 uid 信息，获得局部PID。
pid_t pid_nr_ns(struct pid *pid, struct pid_namespace *ns)
{
struct upid *upid;
pid_t nr = 0;
if (pid && ns->level <= pid->level) {
upid = &pid->numbers[ns->level];
if (upid->ns == ns)
nr = upid->nr;
}
return nr;
}
由于PID命名空间的层次性，父命名空间能看到子命名空间的内容，反之则不能。因此函数中需要确保当前命名空间的level 小于等于产生局部PID的命名空间的level（全局ID：在内核本身和初始命名空间中唯一的ID，在系统启动期间开始的 init 进程即属于该初始命名空间。系统中每个进程都对应了该命名空间的一个PID，叫全局ID，保证在整个系统中唯一；局部ID：对于属于某个特定的命名空间，它在其命名空间内分配的ID为局部ID，该ID也可以出现在其他的命名空间中）。
二 、课本笔记
1.定时器和时间管理
- 内核在硬件的帮助下计算和管理时间。
- 系统定时器以某种频率自行触发时钟中断，称为节拍率。
- 连续两次时钟中断的间隔时间，成为节拍（节拍率分之一）
- 墙上时间（实际时间）和系统运行时间（自系统启动开始所经的时间）根据时钟间隔来计算。
- 全局变量jiffies用来记录自系统启动以来产生的节拍总数。启动时内核将它初始化为0，此后每次时钟中断处理程序增加该变量的值。每一秒钟中断次数HZ，jiffies一秒内增加的值就是HZ，系统运行时间（以秒为单位） 为 jiffie/HZ。
- 比较时间的几个宏：
time_after(unknown, known) //unknown after known ? true : false;
time_before(unknown, known) //unknown before known ? true : false;
time_after_eq(unknown, known) //unknown after or eq known ? true : false;
time_before_eq(unknown, known) //unknown before or eq known ? true : false;
- 实时时钟 RTC 是用来持久存放系统时间的设备.
- 定时器是管理内核流逝的时间的基础。只需执行初始化工作，设置一个超时时间，指定超时发生后执行的函数，然后激活定时器就可以了。定时器不周期运行，它在超时后自行撤退。定时器由以下结构表示：
struct timer_list {
struct list_head entry;//定时器链表的入口
unsigned long expires;//基于jiffies的定时值
struct tvec_base *base;//定时器内部值
void (*function)(unsigned long);//定时器处理函数
...
};
定时器处理函数的函数原型：
void my_timer_function(unsigned long data);
add_timer(&my_timer); //激活定时器
mod_timer(&my_timer, jiffies + new_dalay); //改变指定定时器的超时时间
//如果定时器未被激活，mod_timer会激活该定时器
//如果调用时定时器未被激活，该函数返回0；否则返回1.
del_timer(&my_timer); //在定时器超时前停止定时器
//被激活或未被激活的定时器都可以使用该函数
//如果调用时定时器未被激活，该函数返回0；否则返回1.
//不需要为已经超时的定时器调用该函数，因为他们会自动删除
- 延迟执行不应该在持有锁时或禁止中断时发生
- 最简单的延迟方法是忙等待（延迟时间是节拍的整数倍或者精确率要求不高可以使用）
- 短延迟的延迟时间精确到毫秒，微妙；短暂等待某个动作完成时,比时钟节拍更短，需要依靠数次循环达到延迟效果。
- schedule_timeout() 使执行的任务睡眠指定时间达到延迟.调用它的代码必须处于进程上下文中，并且不能持有锁。
set_current_state(state); //将任务设置为可中断睡眠状态或不可中断睡眠状态
schedule_timeout(s*HZ); //S秒后唤醒,被延迟的任务并将其重新放回运行队列。
2.内存管理
- 虚拟地址又叫线性地址。linux没有采用分段机制，所以逻辑地址和虚拟地址（线性地址）是一个概念。内核的虚拟地址和物理地址大部分只差一个线性偏移量。用户空间的虚拟地址和物理地址则采用了多级页表进行映射，但仍称之为线性地址。
- 在x86结构中，Linux内核虚拟地址空间划分03G为用户空间，34G为内核空间。内核把物理页作为内存管理的基本单元，内核虚拟空间（3G~4G）把页又划分为三种类型的区：
ZONE_DMA 3G之后起始的16MB
ZONE_NORMAL 16MB~896MB
ZONE_HIGHMEM 896MB ~1G
- 由于内核的虚拟和物理地址只差一个偏移量：物理地址 = 逻辑地址 – 0xC0000000。所以如果1G内核空间完全用来线性映射，物理内存也只能访问到1G区间。HIGHMEM可以解决此问题，专门开辟的一块不必线性映射，可以灵活定制映射，以便访问1G以上物理内存的区域。
- 最核心的分配页面函数为：
struct page * alloc_pages(unsigned int gfp_mask, unsigned int order)
- 给定的页转为逻辑地址：
void * page_address(struct page * page)
- 初始化为0的页面：
unsigned long get_zeroed_page(unsigned int gfp_mask)
- 释放页，只能释放属于你的页：
void _free_pages(struct page * page, unsigned int order) //释放page结构体指向的连续2的order次方个页面
void free_pages(unsigned long addr, unsigned int order) //释放从地址addr开始的，连续2的order次方个页面
void free_page(unsigned long addr) //释放地址addr的一个页
- kmalloc分配的内存虚拟、物理地址都是连续的，vmalloc分配的内存虚拟地址连续，而物理地址无需连续
- 当代码需要一个新的数据结构的实例时，slab分配器就从一个slab列表中分配一个这样大小的单元出去，而当要释放时，将其重新保存在该列表中，而不是释放它。
- slab分配器为每种对象分配一个高速缓存，这个缓存可以看做是同类型对象的一种储备。每个高速缓存所占的内存区又被划分多个slab，每个 slab是由一个或多个连续的页框组成。每个页框中包含若干个对象，既有已经分配的对象，也包含空闲的对象。
- 每个高速缓存通过kmem_cache结构来描述，这个结构中包含了对当前高速缓存各种属性信息的描述。所有的高速缓存通过双链表组织在一起，形成 高速缓存链表cache_chain。每个kmem_cache结构中并不包含对具体slab的描述，而是通过kmem_list3结构组织各个 slab。该结构的定义如下：
struct kmem_list3 {
struct list_head slabs_partial; //包含空闲对象和已经分配对象的slab描述符
struct list_head slabs_full;//只包含非空闲的slab描述符
struct list_head slabs_free;//只包含空闲的slab描述符
unsigned long free_objects; /*高速缓存中空闲对象的个数*/
unsigned int free_limit; //空闲对象的上限
unsigned int colour_next; /* Per-node cache coloring *//*即将要着色的下一个*/
spinlock_t list_lock;
struct array_cache *shared; /* shared per node */
struct array_cache **alien; /* on other nodes */
unsigned long next_reap; /* updated without locking *//**/
int free_touched; /* updated without locking */
};
- 每个slab处于三个状态之一：满、部分满、空。非空闲对象的slab链表 slabs_full、部分空闲对象的slab链表slabs_partial、空闲对象的slab链表slabs_free。当内核的某一部分需要一个新的对象时，先从 slabs_partial 分配，没有部分满的slab,就从 slabs_free 中分配。若没有空的 slab，就要创建一个 slab。
