1. 程式人生 > >2018-2019-1 20189203 《Linux內核原理與分析》第七周作業

2018-2019-1 20189203 《Linux內核原理與分析》第七周作業

bps rom 方法 set done files 強制 正在 完成

第一部分 實驗

  • 增加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)。
    只有當進程從“內核運行態”轉移到“睡眠狀態”時,內核才會進行進程切換操作。在內核態下運行的進程不能被其它進程搶占,而且一個進程不能改變另一個進程的狀態。為了避免進程切換時造成內核數據錯誤,內核在執行臨界區代碼時會禁止一切中斷。

2018-2019-1 20189203 《Linux內核原理與分析》第七周作業