Linux内核多线程

Linux内核多线程

前言：

从内核的角度来说，它并没有线程这个概念。Linux把所有线程都当做进程来实现。内核并没有准备特别的调度算法或者定义特别的数据结构来表示线程。相反，线程仅仅被视为一个与其他进程共享某些资源的进程。每个线程都拥有唯一属于自己的task_struct，所以在内核中，它看起来就像是一个普通的进程（只是该进程和其他一些进程共享某些资源，如地址空间）。

一.内核线程

 1.内核经常需要在后台执行一些操作。这种任务可以通过内核线程 （kernel thread）完成。

 2.内核线程和普通的进程间的区别在于内核线程没有独立的地址空间，（实际它的mm指针被设置为NULL）

 3.内核线程只在内核空间运行，从来不切换到用户空间去。内核进程和 普通进程一样，可以被调度，也可以被抢占

 4.内核线程也只能由其他内核线程创建。在现有内核线程中创建一个新的内核线程的方法如下：

int kernel_thread(int (*fn)(void *),void *arg, unsigned long flags)

新的任务也是通过向普通的clone()系统调用传递特定的flags参数而创建的。在上面的函数返回时，父线程退出，并返回一个指向子线程task_struct的指针。子线程开始运行fn指向的函数，arg是运行时需要用到的参数。

 5.一般情况下，内核线程会将它在创建时得到的函数永远执行下去（除非系统重启）。改函数通常由一个循环构成，在需要的时候，这个内核线程就会被唤醒和执行，完成了当前任务，它会自行休眠。

二.内核线程相关函数

内核线程（thread）或叫守护进程(daemon)，在操作系统中占据相当大的比例，当Linux操作系统启动以后，你可以用”ps -ef”命令查看系统中的进程，这时会发现很多以”d”结尾的进程名，确切说名称显示里面加 "[]"的，这些进程就是内核线程。

创建内核线程最基本的两个接口函数是：

kthread_run(threadfn, data, namefmt, ...)    

和

kernel_thread(int(* fn)(void *),void * arg,unsigned long flags)

这里我们主要介绍kthread_run，后面会专门分析这两个函数的异同。

kthread_run 事实上是一个宏定义：

/**

 * kthread_run - create and wake a thread.

 * @threadfn: the function to run until signal_pending(current).

 * @data: data ptr for @threadfn.

 * @namefmt: printf-style name for the thread.

 *

 * Description: Convenient wrapper for kthread_create() followed by

 * wake_up_process().  Returns the kthread or ERR_PTR(-ENOMEM).

 */

#define kthread_run(threadfn, data, namefmt, ...)                   \
({                                                  \

      struct task_struct *__k                                    \

           = kthread_create(threadfn, data, namefmt, ## __VA_ARGS__); \

      if (!IS_ERR(__k))                                \

           wake_up_process(__k);                              \

      __k;                                               \

})

 

 kthread_run()负责内核线程的创建，它由kthread_create()和wake_up_process()两部分组成，这样的好处是用kthread_run()创建的线程可以直接运行。外界调用kthread_run创建运行线程。kthread_run是个宏定义，首先调用kthread_create()创建线程，如果创建成功，再调用wake_up_process()唤醒新创建的线程。kthread_create()根据参数向kthread_create_list中发送一个请求，并唤醒kthreadd，之后会调用wait_for_completion(&create.done)等待线程创建完成。新创建的线程开始运行后，入口在kthread()，kthread()调用complete(&create->done)唤醒阻塞的模块进程，并使用schedule()调度出去。kthread_create()被唤醒后，设置新线程的名称，并返回到kthread_run中。kthread_run调用wake_up_process()重新唤醒新创建线程，此时新线程才开始运行kthread_run参数中的入口函数。

在介绍完如何创建线程之后，下面来介绍另外两个基本的函数：

int kthread_stop(struct task_struct *k);

 

int kthread_should_stop(void);

 

 kthread_stop()负责结束创建的线程，参数是创建时返回的task_struct指针。kthread设置标志should_stop，并等待线程主动结束，返回线程的返回值。在调用 kthread_stop()结束线程之前一定要检查该线程是否还在运行（通过 kthread_run 返回的 task_stuct 是否有效），否则会造成灾难性的后果。kthread_run的返回值tsk。不能用tsk是否为NULL进行检查，而要用IS_ERR()宏定义检查，这是因为返回的是错误码，大致从0xfffff000~0xffffffff。

 kthread_should_stop()返回should_stop标志（参见 struct kthread ）。它用于创建的线程检查结束标志，并决定是否退出。

kthread() (注：原型为：static int kthread(void *_create) )的实现在kernel/kthread.c中，头文件是include/linux/kthread.h。内核中一直运行一个线程kthreadd，它运行kthread.c中的kthreadd函数。在kthreadd()中，不断检查一个kthread_create_list链表。kthread_create_list中的每个节点都是一个创建内核线程的请求，kthreadd()发现链表不为空，就将其第一个节点退出链表，并调用create_kthread()创建相应的线程。create_kthread()则进一步调用更深层的kernel_thread()创建线程，入口函数设在kthread()中。

      外界调用kthread_stop()删除线程。kthread_stop首先设置结束标志should_stop，然后调用wake_for_completion(&kthread->exited)上，这个其实是新线程task_struct上的vfork_done，会在线程结束调用do_exit()时设置。

附：

struct kthread {

       int should_stop;

       struct completion exited;

};

int kthreadd(void *unused)
{

       struct task_struct *tsk = current;


       /* Setup a clean context for our children to inherit. */

       set_task_comm(tsk, "kthreadd");

       ignore_signals(tsk);

       set_cpus_allowed_ptr(tsk, cpu_all_mask);

       set_mems_allowed(node_states[N_HIGH_MEMORY]);


       current->flags |= PF_NOFREEZE | PF_FREEZER_NOSIG;

 
       for (;;) {

              set_current_state(TASK_INTERRUPTIBLE);

              if (list_empty(&kthread_create_list))

                     schedule();

              __set_current_state(TASK_RUNNING);

 
              spin_lock(&kthread_create_lock);

              while (!list_empty(&kthread_create_list)) {

                     struct kthread_create_info *create;

                     create = list_entry(kthread_create_list.next,

                                       struct kthread_create_info, list);

                     list_del_init(&create->list);

                     spin_unlock(&kthread_create_lock);

 

                     create_kthread(create);

 

                     spin_lock(&kthread_create_lock);

              }

              spin_unlock(&kthread_create_lock);

       }

       return 0;
}

/**

 * kthread_stop - stop a thread created by kthread_create().

 * @k: thread created by kthread_create().

 *

 * Sets kthread_should_stop() for @k to return true, wakes it, and

 * waits for it to exit. This can also be called after kthread_create()

 * instead of calling wake_up_process(): the thread will exit without

 * calling threadfn().

 *

 * If threadfn() may call do_exit() itself, the caller must ensure

 * task_struct can't go away.

 *

 * Returns the result of threadfn(), or %-EINTR if wake_up_process()

 * was never called.

 */

int kthread_stop(struct task_struct *k)
{

       struct kthread *kthread;

       int ret;

 
       trace_sched_kthread_stop(k);

       get_task_struct(k);

 
       kthread = to_kthread(k);

       barrier(); /* it might have exited */

       if (k->vfork_done != NULL) {

              kthread->should_stop = 1;

              wake_up_process(k);

              wait_for_completion(&kthread->exited);

       }

       ret = k->exit_code;

       put_task_struct(k);

       trace_sched_kthread_stop_ret(ret);

       return ret;

}

参考来源：

1. http://blog.csdn.net/tigerjb/article/details/8299686

2. http://www.cnblogs.com/zhuyp1015/archive/2012/06/11/2545624.html