一 、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;二 、课本笔记
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秒后唤醒,被延迟的任务并将其重新放回运行队列。