kernel_thread

內核線程實際上就是一個共享父進程地址空間的進程,它有自己的系統堆棧.

內核線程和進程都是通過do_fork()函數來產生的，系統中規定的最大進程數與
線程數由fork_init來決定:

[/arch/kernel/process.c/fork_init()]
void __init fork_init(unsigned long mempages)
{
#ifndef __HAVE_ARCH_TASK_STRUCT_ALLOCATOR
#ifndef ARCH_MIN_TASKALIGN
#define ARCH_MIN_TASKALIGN   L1_CACHE_BYTES
#endif
   /* 在slab高速緩存中建立task_struct結構專用的緩衝區隊列 */
   task_struct_cachep =
       kmem_cache_create("task_struct", sizeof(struct task_struct),
           ARCH_MIN_TASKALIGN, SLAB_PANIC, NULL, NULL);
#endif

   /*
       把默認線程數設置到一個安全值,因爲內核中總的線程佔用的空間
           可能要內存一半還要多.
       參數mempages系統中總的物理內存結構大小，它等於mempages/PAGESIZE.
       比如我機器的內存是512m，那麼在我的系統最多能同時產生線程數爲            
       (512*2^20/2^12) / 2^3 = 512*2^5 = 16384
   */
   max_threads = mempages / (8 * THREAD_SIZE / PAGE_SIZE);

   /*
   * 啓動系統的時候至少需要20個線程
   */
   if(max_threads < 20)
       max_threads = 20;

   /*
   * 每個進程最多產生max_threads/2,也就是線程總數的一半,在我的機器上爲8192.
         */
   init_task.signal->rlim[RLIMIT_NPROC].rlim_cur = max_threads/2;
   init_task.signal->rlim[RLIMIT_NPROC].rlim_max = max_threads/2;
}

kernel_thread原形在/arch/kernel/process.c中.
(*fn)(void *)爲要執行的函數的指針,arg爲函數參數，flags爲do_fork產生線程時的標誌.

int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
{
   struct pt_regs regs;

   memset(&regs, 0, sizeof(regs));

   regs.ebx = (unsigned long) fn;   /* ebx指向函數地址 */
   regs.edx = (unsigned long) arg;   /* edx指向參數 */

   regs.xds = __USER_DS;
   regs.xes = __USER_DS;
   regs.orig_eax = -1;
   regs.eip = (unsigned long) kernel_thread_helper;
   regs.xcs = __KERNEL_CS;
   regs.eflags = X86_EFLAGS_IF | X86_EFLAGS_SF | X86_EFLAGS_PF | 0x2;

   /* 利用do_fork來產生一個新的線程,共享父進程地址空間,並且不允許調試子進程 */
   return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, &regs, 0, NULL, NULL);
}

[/arch/i386/kernel/process.c/kernel_thread_helper]

extern void kernel_thread_helper(void); /* 定義成全局變量 */
__asm__(".section .text/n"
   ".align 4/n"
   "kernel_thread_helper:/n/t"
   "movl %edx,%eax/n/t"
   "pushl %edx/n/t"   /* edx指向參數,壓入堆棧 */
   "call *%ebx/n/t"   /* ebx指向函數地址,執行函數 */
   "pushl %eax/n/t"
   "call do_exit/n"   /* 結束線程 */
   ".previous");

在kernel_thread中調用了do_fork，那麼do_fork是怎樣轉入kernel_thread_helper去執行的呢，繼續跟蹤下do_fork函數.

[kernel/fork.c/do_fork()]

long do_fork(unsigned long clone_flags,
          unsigned long stack_start,
          struct pt_regs *regs,
          unsigned long stack_size,
          int __user *parent_tidptr,
          int __user *child_tidptr)
{
....
....
   p = copy_process(clone_flags, stack_start, regs, stack_size, parent_tidptr, child_tidptr, pid);
....
....
}


它調用copy_process函數來向子進程拷貝父進程的進程環境和全部寄存器副本.
[kernel/fork.c/do_fork()->copy_process]

static task_t *copy_process(unsigned long clone_flags,
               unsigned long stack_start,
               struct pt_regs *regs,
               unsigned long stack_size,
               int __user *parent_tidptr,
               int __user *child_tidptr,
               int pid)
{
...
...
retval = copy_thread(0, clone_flags, stack_start, stack_size, p, regs);
...
...
}

它又調用copy_thread來拷貝父進程的系統堆棧並做相應的調整.
[/arch/i386/kernel/process.c/copy_thread]:

int copy_thread(int nr, unsigned long clone_flags, unsigned long esp,
   unsigned long unused,
   struct task_struct * p, struct pt_regs * regs)
{
...
...
   p->thread.eip = (unsigned long) ret_from_fork;
}
在這裏把ret_from_fork的地址賦值給p->thread.eip,p->thread.eip表示當進程下一次調度時的指令開始地址，
所以當線程創建後被調度時，是從ret_from_fork地址處開始的.

[/arch/i386/kernel/entry.s]

到這裏說明，新的線程已經產生了.
ENTRY(ret_from_fork)
   pushl %eax
   call schedule_tail
   GET_THREAD_INFO(%ebp)
   popl %eax
   jmp syscall_exit

syscall_exit:
...
work_resched:
   call schedule
...
當它從ret_from_fork退出時，會從堆棧中彈出原來保存的ip，而ip指向kernel_thread_helper,
至此kernel_thread_helper被調用，它就可以運行我們的指定的函數了.