20189220 餘超《Linux核心原理與分析》第七週作業
阿新 • • 發佈：2018-11-25
分析Linux核心建立一個新程序的過程
基礎知識概括
- 作業系統核心實現作業系統的三大管理功能，即程序管理功能，記憶體管理和檔案系統。對應的三個抽象的概念是程序，虛擬記憶體和檔案。其中，作業系統最核心的功能是程序管理。
- 程序標識值：核心通過唯一的PID來標識每個程序。
- 程序狀態：程序描述符中state域描述了程序的當前狀態。
- iret與int 0x80指令對應，一個是離開系統呼叫彈出暫存器值，一個是進入系統呼叫壓入暫存器的值。
- fork()函式最大的特點就是被呼叫一次，返回兩次，在父程序中返回新建立子程序的 pid；在子程序中返回 0。
- 在Linux中，fork，vfork和clone這3個系統呼叫都通過do_fork來實現程序的建立
- 在Linux中1號程序是所有使用者態程序的祖先，2號程序是所有核心執行緒的祖先
程序控制塊PCB——task_struct，為了管理程序，核心必須對每個程序進行清晰的描述，程序描述符提供了核心所需瞭解的程序資訊。
struct task_struct { volatile long state; /* -1 unrunnable, 0 runnable, >0 stopped 程序狀態，-1表示不可執行，0表示可執行，大於1表示停止*/ void *stack; //核心堆疊 atomic_t usage; unsigned int flags; /* per process flags, defined below 程序識別符號 * / unsigned int ptrace;
程序的建立
1.道生一（start_ kernel...rest_init），一生二(kernel_ init和kthreadd)，二生三（即前面的0、1、2三個程序），三生萬物（1號程序是所有使用者態程序的祖先，2號程序是所有核心執行緒的祖先）start_ kernel建立了rest_init，也就是0號程序。而0號程序又建立了兩個執行緒，一個是kernel_ init，也就是1號程序，這個程序最終啟動了使用者態；另一個是kthreadd核心執行緒是所有核心執行緒的祖先，負責管理所有核心執行緒。0號程序是固定的程式碼，1號程序是通過複製0號程序PCB之後在此基礎上做修改得到的。
2.Linux中建立程序一共有三個函式：fork，建立子程序 vfork，與fork類似，但是父子程序共享地址空間，而且子程序先於父程序執行。 clone，主要用於建立執行緒。Linux中所有的程序建立都是基於複製的方式，Linux通過複製父程序來建立一個新程序,通過呼叫do_ fork來實現。然後對子程序做一些特殊的處理。而Linux中的執行緒，又是一種特殊的程序。根據程式碼的分析，do_ fork中，copy_ process管子程序執行的準備，wake_ up_ new_ task作為子程序forking的完成。
3.fork系統呼叫
vfork系統呼叫
clone系統呼叫
通過上面的程式碼我們可以看出來fork、vfork 和 clone 三個系統呼叫都可以建立一個新程序，而且都是通過 do_fork 來建立程序，只不過傳遞的引數不同。
4.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函式的作用：
- 呼叫copy_process，將當期程序複製一份出來為子程序，並且為子程序設定相應地上下文資訊。
- 初始化vfork的完成處理資訊（如果是vfork呼叫）
- 呼叫wake_up_new_task，將子程序放入排程器的佇列中，此時的子程序就可以被排程程序選中，得以執行。
- 如果是vfork呼叫，需要阻塞父程序，知道子程序執行exec。
5.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結構體，作為子程序的程序描述符。
- 複製所有的程序資訊
- 呼叫copy_thread，設定子程序的堆疊資訊，為子程序分配一個pid。
6.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;
// 分配一個task_struct結點
tsk = alloc_task_struct_node(node);
if (!tsk)
return NULL;
// 分配一個thread_info結點，其實內部分配了一個union，包含程序的核心棧
// 此時ti的值為棧底，在x86下為union的高地址處。
ti = alloc_thread_info_node(tsk, node);
if (!ti)
goto free_tsk;
err = arch_dup_task_struct(tsk, orig);
if (err)
goto free_ti;
// 將棧底的值賦給新結點的stack
tsk->stack = ti;
...
/*
* One for us, one for whoever does the "release_task()" (usually
* parent)
*/
// 將程序描述符的使用計數器置為2
atomic_set(&tsk->usage, 2);
#ifdef CONFIG_BLK_DEV_IO_TRACE
tsk->btrace_seq = 0;
#endif
tsk->splice_pipe = NULL;
tsk->task_frag.page = NULL;
account_kernel_stack(ti, 1);
// 返回新申請的結點
return tsk;
free_ti:
free_thread_info(ti);
free_tsk:
free_task_struct(tsk);
return NULL;
}通過上面的部分程式碼我們可知：
- 先呼叫alloc_task_struct_node分配一個task_struct結構體。
- 呼叫alloc_thread_info_node，分配了一個union。這裡分配了一個thread_info結構體，還分配了一個stack陣列。返回值為ti，實際上就是棧底。
- tsk->stack = ti將棧底的地址賦給task的stack變數。
- 最後為子程序分配了核心棧空間。
- 執行完dup_task_struct之後，子程序和父程序的task結構體，除了stack指標之外，完全相同
7.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;
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();
// 子程序的eax置為0，所以fork的子程序返回值為0
childregs->ax = 0;
if (sp)
childregs->sp = sp;
// 子程序從ret_from_fork開始執行
p->thread.ip = (unsigned long) ret_from_fork;
task_user_gs(p) = get_user_gs(current_pt_regs());
p->thread.io_bitmap_ptr = NULL;
tsk = current;
err = -ENOMEM;
// 如果父程序使用IO許可權點陣圖，那麼子程序獲得該點陣圖的一個拷貝
if (unlikely(test_tsk_thread_flag(tsk, TIF_IO_BITMAP))) {
p->thread.io_bitmap_ptr = kmemdup(tsk->thread.io_bitmap_ptr,
IO_BITMAP_BYTES, GFP_KERNEL);
if (!p->thread.io_bitmap_ptr) {
p->thread.io_bitmap_max = 0;
return -ENOMEM;
}
set_tsk_thread_flag(p, TIF_IO_BITMAP);
}
...
return err;
}copy_thread函式的主要作用為：
- 獲取子程序暫存器資訊的存放位置
- 對子程序的thread.sp賦值，將來子程序執行，這就是子程序的esp暫存器的值。
- 如果是建立核心執行緒，那麼它的執行位置是ret_from_kernel_thread， - 將這段程式碼的地址賦給thread.ip，之後準備其他暫存器資訊，退出
- 將父程序的暫存器資訊複製給子程序。
- 將子程序的eax暫存器值設定為0，所以fork呼叫在子程序中的返回值為0.
- 子程序從ret_from_fork開始執行，所以它的地址賦給thread.ip，也就是將來的eip暫存器。
8.最後是執行新程序：從ret_from_fork處開始執行
- dup_task_struct中為其分配了新的堆疊
- copy_process中呼叫了sched_fork，將其置為TASK_RUNNING
- copy_thread中將父程序的暫存器上下文複製給子程序，這是非常關鍵的一步，這裡保證了父子程序的堆疊資訊是一致的。
- 將ret_from_fork的地址設定為eip暫存器的值，這是子程序的第一條指令。
實驗過程
1.給MenuOS增加命令
2.用gdb進行除錯，請注意此時應該回到LinuxKernel的目錄下來進行
3.設定剛才所討論的函式的斷點
4.do_fork 系統核心呼叫：
5..copy_process 複製父程序的所有資訊給子程序，dup_task_struct 中為子程序分配了新的堆疊：
6.copy_thread系統呼叫函式：
copy_thread 這段程式碼為我們解釋了兩個相當重要的問題！
為什麼 fork 在子程序中返回0，原因是childregs->ax = 0;這段程式碼將子程序的 eax 賦值為0
p->thread.ip = (unsigned long) ret_from_fork;將子程序的 ip 設定為 ret_form_fork 的首地址，因此子程序是從 ret_from_fork 開始執行的。
7.最後通過函式syscall_exit退出
本章總結
建立一個新程序在核心中的執行過程大致如下:
使用系統呼叫Sys_clone(或fork,vfork)系統呼叫建立一個新程序，而且都是通過呼叫do_fork來實現程序的建立；
Linux通過複製父程序PCB的task_struct來建立一個新程序，要給新程序分配一個新的核心堆疊;
要修改複製過來的程序資料，比如pid、程序連結串列等等執行copy_process和copy_thread ；
p->thread.sp = (unsigned long) childregs; //排程到子程序時的核心棧頂 ；
p->thread.ip = (unsigned long) ret_from_fork; //排程到子程序時的第一條指令地址；