linux中的fork函數是如何創建一個新的進程的

本篇文章為大家展示了linux中的fork函數是如何創建一個新的進程的，內容簡明扼要并且容易理解，絕對能使你眼前一亮，通過這篇文章的詳細介紹希望你能有所收獲。

前面已經談了內核加載與系統引導過程，下面我們來看看內核的 do_fork() 函數是如何創建一個新的進程的。


在 Linux 內核中,供用戶創建進程的系統調用fork()函數的響應函數是 sys_fork()、sys_clone()、sys_vfork()。這三個函數都是通過調用內核函數 do_fork() 來實現的。根據


調用時所使用的 clone_flags 參數不同，do_fork() 函數完成的工作也各異。


這部分內容簡單，我不打算就此而展開分析。下面我們重點來講解以下 do_fork() 函數的工作原理。


我們知道 do_fork() 函數生成一個新的進程，大致分為三個步驟。


1、建立進程控制結構并賦初值，使其成為進程映像。這個過程完成以下內容。

 

在內存中分配一個 task_struct 數據結構，以代表即將產生的新進程。

把父進程 PCB 的內容復制到新進程的 PCB 中。

為新進程分配一個唯一的進程標識號 PID 和 user_struct 結構。然后檢查用戶具有執行一個新進程所必須具有的資源。

重新設置 task_struct 結構中那些與父進程值不同的數據成員。

設置進程管理信息，根據所提供的 clone_flags 參數值，決定是否對父進程 task_struct 中的指針 fs 、files 指針等所選擇的部分進行拷貝，如果 clone_flags 參數指明的是


共享而不是拷貝，則將其計數器 count 的值加 1 ，否則就拷貝新進程所需要的相關信息內容 PCB 。這個地方是區分 sys_fork() 還是 sys_clone() 。

2、必須為新進程的執行設置跟蹤進程執行情況的相關內核數據結構。包括 任務數組、自由時間列表 tarray_freelist 以及 pidhash[] 數組。

這部分完成如下內容：

把新進程加入到進程鏈表中。

把新進程加入到 pidhash 散列表中，并增加任務計數值。

通過拷貝父進程的上、下文來初始化硬件的上下文（TSS段、LDT以及 GDT）。

3、啟動調度程序，使子進程獲得運行的機會。

這部分完成以下動作：

設置新的就緒隊列狀態 TASK_RUNING , 并將新進程掛到就緒隊列中，并重新啟動調度程序使其運行。

向父進程返回子進程的 PID，設置子進程從 do_fork() 返回 0 值。

下面就具體的 do_fork() 函數程序代碼進行分析（該代碼位于 kernel/fork.c 文件中）



int do_fork(unsigned long clone_flags,unsigned long stack_start, struct pt_regs *regs,

                unsigned long stack_size)

{

        int                   retval;

        struct  task_struct   *p;

        struct  completion    vfork;


        retval = -EPERM ;


        if ( clone_flags & CLONE_PID )

        {

              if ( current->pid )

                      goto fork_out;

        }


        reval = -ENOMEM ;

        

        p = alloc_task_struct();    // 分配內存建立新進程的 task_struct 結構

        if ( !p )

               goto fork_out;


        *p = *current ;  //將當前進程的 task_struct 結構的內容復制給新進程的 PCB結構


        retval = -EAGAIN;


        //下面代碼對父、子進程 task_struct 結構中不同值的數據成員進行賦值


        if ( atomic_read ( &p->user->processes ) >= p->rlim[RLIMIT_NPROC].rlim_cur

                && !capable( CAP_SYS_ADMIN ) && !capable( CAP_SYS_RESOURCE ))

                goto bad_fork_free;


        atomic_inc ( &p->user->__count);   //count 計數器加 1

        atomic_inc ( &p->user->processes); //進程數加 1


        if ( nr_threads >= max_threads )

               goto bad_fork_cleanup_count ;


        get_exec_domain( p->exec_domain );


        if ( p->binfmt && p->binfmt->module )

                  __MOD_INC_USE_COUNT( p->binfmt->module ); //可執行文件 binfmt 結構共享計數 + 1 

        p->did_exec = 0 ;                                   //進程未執行

        p->swappable = 0 ;                                  //進程不可換出

        p->state = TASK_UNINTERRUPTIBLE ;                   //置進程狀態

        copy_flags( clone_flags,p );                        //拷貝進程標志位

        p->pid = get_pid( clone_flags );                    //為新進程分配進程標志號

        p->run_list.next = NULL ;

        p->run_list.prev = NULL ;

        p->run_list.cptr = NULL ;


        init_waitqueue_head( &p->wait_childexit );          //初始化 wait_childexit 隊列


        p->vfork_done  = NULL ;


        if ( clone_flags & CLONE_VFORK ) {

               p->vfork_done = &vfork ; 

               init_completion(&vfork) ;

        }


        spin_lock_init( &p->alloc_lock );


        p->sigpending = 0 ;


        init_sigpending( &p->pending );

        p->it_real_value = p->it_virt_value = p->it_prof_value = 0 ; //初始化時間數據成員

        p->it_real_incr = p->it_virt_incr = p->it_prof_incr = 0 ;    //初始化定時器結構

        init_timer( &p->real_timer );

        p->real_timer.data = (unsigned long)p;

        p->leader = 0 ;

        p->tty_old_pgrp = 0 ;

        p->times.tms_utime = p->times.tms_stime = 0 ;                 //初始化進程的各種運行時間

        p->times.tms_cutime = p->times.tms_cstime = 0 ;

#ifdef CONFIG_SMP                 //初始化對稱處理器成員

   {

        int      i;

        p->cpus_runnable = ~0UL;

        p->processor = current->processor ;

        for( i = 0 ; i < smp_num_cpus ; i++ )

                 p->per_cpu_utime[ i ] = p->per_cpu_stime[ i ] = 0;

        spin_lock_init ( &p->sigmask_lock );

    }


#endif

        p->lock_depth = -1 ;        // 注意：這里 -1 代表 no ,表示在上下文切換時，內核不上鎖

        p->start_time = jiffies ;   // 設置進程的起始時間


        INIT_LIST_HEAD ( &p->local_pages );

        retval = -ENOMEM ;


        if ( copy_files ( clone_flags , p ))      //拷貝父進程的 files 指針，共享父進程已打開的文件

                goto bad_fork_cleanup ;


        if ( copy_fs ( clone_flags , p ))         //拷貝父進程的 fs 指針，共享父進程文件系統

                goto bad_fork_cleanup_files ;


        if ( copy_sighand ( clone_flags , p ))    //子進程共享父進程的信號處理函數指針

                goto bad_fork_cleanup_fs ;


        if ( copy_mm ( clone_flags , p ))

                goto bad_fork_cleanup_mm ;        //拷貝父進程的 mm 信息，共享存儲管理信息


        retval = copy_thread( 0 , clone_flags , stack_start, stack_size , p regs );

                                                  //初始化 TSS、LDT以及GDT項


        if ( retval )

                goto bad_fork_cleanup_mm ;


        p->semundo = NULL ;                       //初始化信號量成員


        p->prent_exec_id = p-self_exec_id ;


        p->swappable = 1 ;                        //進程占用的內存頁面可換出


        p->exit_signal = clone_flag & CSIGNAL ;


        p->pdeatch_signal = 0 ;                   //注意：這里是父進程消亡后發送的信號


        p->counter = (current->counter + 1) >> 1 ;//進程動態優先級，這里設置成父進程的一半,應注意的是，這里是采用位操作來實現的。


        current->counter >> =1;


        if ( !current->counter )

                current->need_resched = 1 ;        //置位重新調度標記，實際上從這個地方開始，分裂成了父子兩個進程。

        

        retval = p->pid ;


        p->tpid = retval ;

        INIT_LIST_HEAD( &p->thread_group );


        write_lock_irq( &tasklist_lock );


        p->p_opptr = current->p_opptr ;

        p->p_pptr = current->p_pptr ;


        if ( !( clone_flags & (CLONE_PARENT | CLONE_THREAD ))) {

                 p->opptr = current ;

                 if ( !(p->ptrace & PT_PTRACED) )

                         p->p_pptr = current ;

        }


        if ( clone_flags & CLONE_THREAD ){

                 p->tpid = current->tpid ;

                 list_add ( &p->thread_group,&current->thread_group );

        }


        SET_LINKS(p);


        hash_pid(p);

        nr_threads++;


        write_unlock_irq( &tasklist_lock );

        if ( p->ptrace & PT_PTRACED )

                  send_sig( SIGSTOP , p ,1 );

        wake_up_process(p);        //把新進程加入運行隊列，并啟動調度程序重新調度，使新進程獲得運行機會

        ++total_forks ; 

        if ( clone_flags & CLONE_VFRK )

                  wait_for_completion(&vfork);


        //以下是出錯處理部分

        fork_out:

                  return retval;

        bad_fork_cleanup_mm:

                  exit_mm(p);

        bad_fork_cleanup_sighand:

                  exit_sighand(p);

        bad_fork_cleanup_fs:

                  exit_fs(p);

        bad_fork_cleanup_files:

                  exit_files(p);


        bad_fork_cleanup:

                  put_exec_domain( p->exec_domain );


                  if ( p->binfmt && p->binfmt->module )

                                __MOD_DEC_USE_COUNT( p->binfmt->module );

        bad_fork_cleanup_count:

                  atomic_dec( &p->user->processes );

                  free_uid ( p->user );

        bad_fork_free:

                  free_task_struct(p);

                  goto fork_out;

}




PS:

代碼是分析完了，有兩個方面的體會：

一、這個函數重點是理解進程分裂的部分，其中兩次返回 pid 的值是理解的重中之重。

二、盡管我一直不主張在程序中大量使用 goto 語句，不得不承認，那些大牛的 goto 語句用在此處是恰到好處啊。^_^

上述內容就是linux中的fork函數是如何創建一個新的進程的，你們學到知識或技能了嗎？如果還想學到更多技能或者豐富自己的知識儲備，歡迎關注億速云行業資訊頻道。