2018-2019-1 20189203 《Linux核心原理與分析》第七週作業
第一部分 實驗
- 增加fork命令,執行MenuOS 如下:
- 設定斷點:
跟蹤除錯過程:
停在的do_fork()的位置上
停在copy_process
停在dup_task_struct
停在copy_thread
第二部分 程式碼分析
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 3個系統呼叫和kernel_thread核心函式都可以建立一個新程序,而且都是通過 do_fork 函式來建立程序的,只不過傳遞的引數不同。
程序建立的主要過程
首先了解一下do_fork () 的引數:
- clone_flags:子程序建立相關標誌,通過此標誌可以對父程序的資源進行有選擇的複製。
- stack_start:子程序使用者態堆疊的地址。
- regs:指向 pt_regs 結構體(當系統發生系統呼叫時,pt_regs 結構體儲存暫存器中的值並按順序壓入核心棧)的指標。
- stack_size:使用者態棧的大小,通常是不必要的,總被設定為0。
- parent_tidptr 和 child_tidptr:父程序、子程序使用者態下 pid 地址。
下面是精簡後的do_fork函式體關鍵程式碼:
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()是建立一個程序內容的主要的程式碼。
下面分析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。其中比較關鍵的是dup_task_struct複製當前程序(父程序)描述符task_struct和copy_thread初始化子程序核心棧。
下面具體看dup_task_struct和copy_thread。
如下為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; // 返回新建立的程序描述符指標
...
}
如下為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;
總的來說,程序的建立過程大致是複製程序描述符、一一複製其他程序資源(採用寫時複製技術)、分配子程序的核心堆疊並對核心堆疊關鍵資訊進行初始化。
第三部分 課本知識
Linux程序執行狀態
- 執行狀態(TASK_RUNNING)
當程序正在被CPU執行,或已經準備就緒隨時可由排程程式執行,則稱該程序為處於執行狀態(running)。程序可以在核心態執行,也可以在使用者態執行。當系統資源已經可用時,程序就被喚醒而進入準備執行狀態,該狀態稱為就緒態。這些狀態(圖中中間一列)在核心中表示方法相同,都被成為處於TASK_RUNNING狀態。 - 可中斷睡眠狀態(TASK_INTERRUPTIBLE)
當程序處於可中斷等待狀態時,系統不會排程該進行執行。當系統產生一箇中斷或者釋放了程序正在等待的資源,或者程序收到一個訊號,都可以喚醒程序轉換到就緒狀態(執行狀態)。 - 暫停狀態(TASK_STOPPED)
當程序收到訊號SIGSTOP、SIGTSTP、SIGTTIN或SIGTTOU時就會進入暫停狀態。可向其傳送SIGCONT訊號讓程序轉換到可執行狀態。 - 僵死狀態(TASK_ZOMBIE)
當程序已停止執行,但其父程序還沒有詢問其狀態時,則稱該程序處於僵死狀態。 - 不可中斷睡眠狀態(TASK_UNINTERRUPTIBLE)
與可中斷睡眠狀態類似。但處於該狀態的程序只有被使用wake_up()函式明確喚醒時才能轉換到可執行的就緒狀態。
當一個程序的執行時間片用完,系統就會使用排程程式強制切換到其它的程序去執行。另外,如果程序在核心態執行時需要等待系統的某個資源,此時該程序就會呼叫
sleep_on()或sleep_on_interruptible()自願地放棄CPU的使用權,而讓排程程式去執行其它程序。程序則進入睡眠狀
態(TASK_UNINTERRUPTIBLE或TASK_INTERRUPTIBLE)。
只有當程序從“核心執行態”轉移到“睡眠狀態”時,核心才會進行程序切換操作。在核心態下執行的程序不能被其它程序搶佔,而且一個程序不能改變另一個程序的狀態。為了避免程序切換時造成核心資料錯誤,核心在執行臨界區程式碼時會禁止一切中斷。