Kernel Thread 的创建

在 Linux 中有很多的内核线程,可以通过 ps command 查看到,比如: kthreadd ksoftirqd watchdog 等等等 … 它们都是由内核从无到有创建的,通过它们的 pid 以及 ppid 可以得出以下几点:

  • 在内核初始化 rest_init 函数中,由进程 0 (swapper 进程)创建了两个 process
    1. init 进程 (pid = 1, ppid = 0)
    2. kthreadd (pid = 2, ppid = 0)
  • 所有其它的内核线程的 ppid 都是 2,也就是说它们都是由 kthreadd thread 创建的
  • 所有的内核线程在大部分时间里都处于阻塞状态(TASK_INTERRUPTIBLE)只有在系统满足进程需要的某种资源的情况下才会运行

创建一个内核 thread 的接口函数是:

kthread_create()
kthread_run()

这两个函数的区别就是 kthread_run() 函数中封装了前者,由 kthread_create() 创建的 thread 不会立即运行,而后者创建的 thread 会立刻运行,原因是在 kthread_run() 中调用了 wake_up_process().用什么函数看你自己的需求,如果你要让你创建的 thread 运行在指定的 cpu 上那必须用前者(因为它创建的 thread 不会运行),然后再用 kthread_bind() 完成绑定,最后 wake up.

下面就大概说一下内核 thread 创建的过程.

kthreadd

rest_init()
{
    pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);
    kthreadd_task = find_task_by_pid(pid);
}

kernel thread

kthread_create(usb_stor_control_thread, us, "usb-storage")

struct task_struct *kthread_create(int (*threadfn)(void *data),
                               void *data,
                               const char namefmt[],
                               ...)
{

    struct kthread_create_info create;

    create.threadfn = threadfn;
    新创建的线程运行的函数
    create.data = data;
    init_completion(&create.done);
    初始化一个 completion 用于一个线程告诉其它线程某个工作已经完成

    spin_lock(&kthread_create_lock);
    list_add_tail(&create.list, &kthread_create_list);
    加到待创建 thread list 中去
    spin_unlock(&kthread_create_lock);

    wake_up_process(kthreadd_task);
    唤醒 kthreadd 线程来创建新的内核线程 
    wait_for_completion(&create.done);
    等待新的线程创建完毕(睡眠在等待队列中)

    ......

}

kthreadd 是一个死循环,大部分时间在睡眠,只有创建内核线程时才被唤醒.

int kthreadd(void *unused)
{
    关注循环体

        for (;;) {
            set_current_state(TASK_INTERRUPTIBLE);
            if (list_empty(&kthread_create_list))
                    schedule();
            首先将线程状态设置为 TASK_INTERRUPTIBLE, 如果当前
            没有要创建的线程则主动放弃 CPU 完成调度.此进程变为阻塞态

            __set_current_state(TASK_RUNNING);
            运行到此表示 kthreadd 线程被唤醒(就是我们当前)
            设置进程运行状态为 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);
                    从链表中取得 kthread_create_info 结构的地址,在上文中已经完成插入操作(将
                    kthread_create_info 结构中的 list 成员加到链表中,此时根据成员 list 的偏移
                    获得 create)  

                    list_del_init(&create->list);
                    取出后从列表删除
                    spin_unlock(&kthread_create_lock);

                    create_kthread(create);
                    完成真正线程的创建

                    spin_lock(&kthread_create_lock);
            }

            spin_unlock(&kthread_create_lock);
       }

}

create_kthread 函数完成真正线程的创建

static void create_kthread(struct kthread_create_info *create)
{       
    int pid;

    pid = kernel_thread(kthread, create, CLONE_FS | CLONE_FILES | SIGCHLD);
    其实就是调用首先构造一个假的上下文执行环境,最后调用 do_fork()
    返回进程 id, 创建后的线程执行 kthread 函数
    if (pid < 0) {
            create->result = ERR_PTR(pid);
            complete(&create->done);
    }
}

此时回到 kthreadd thread,它在完成了进程的创建后继续循环,检查 kthread_create_list 链表,如果为空,则 kthreadd 内核线程昏睡过去 ……

当前有三个线程:

  1. kthreadd thread 已经光荣完成使命,睡眠
  2. 唤醒 kthreadd 的线程由于新创建的线程还没有创建完毕而继续睡眠 (在 kthread_create 函数中)
  3. 新创建的线程已经正在运行 kthread,但是由于还有其它工作没有做所以还没有最终创建完成.

新创建的线程 kthread 函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
static int kthread( void *_create)
{
     struct kthread_create_info *create = _create;
     // create 指向 kthread_create_info 中的 kthread_create_info
     int (*threadfn)( void *data) = create->threadfn;
     // 新的线程创建完毕后执行的函数
     void *data = create->data;
     struct kthread self;
     int ret;
 
     self.should_stop = 0;
     // 在 kthread_should_stop() 函数中会检查这个值,表示当前线程是否
     // 运行结束. kthread_should_stop() 常被用于线程函数中.
     init_completion(&self.exited);
     current->vfork_done = &self.exited;
 
     /* OK, tell user we're spawned, wait for stop or wakeup */
     __set_current_state(TASK_UNINTERRUPTIBLE);
     // 设置运行状态为 TASK_UNINTERRUPTIBLE
     create->result = current;
     // current 表示当前新创建的 thread 的 task_struct 结构
     complete(&create->done);
     // new thread 创建完毕
 
     schedule();
     // 执行任务切换,让出 CPU
 
     ......
 
}

线程创建完毕:

  • 创建新 thread 的进程恢复运行 kthread_create() 并且返回新创建线程的任务描述符
  • 新创建的线程由于执行了 schedule() 调度,此时并没有执行.

最后唤醒新创建的线程 :

wake_up_process(p);

当线程被唤醒后,继续 kthread()

    ret = -EINTR;
    if (!self.should_stop)
            ret = threadfn(data);
    执行相应的线程函数

    do_exit(ret);
    最后退出

总结

  • 任何一个内核线程入口都是 kthread()
  • 通过 kthread_create() 创建的内核线程不会立刻运行.需要手工 wake up.
  • 通过 kthread_create() 创建的内核线程有可能不会执行相应线程函数threadfn而直接退出

最后写了一个创建内核线程的模块仅供参考:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
#include <linux/init.h>
#include <linux/time.h>
#include <linux/errno.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/kthread.h>
#include <linux/cpumask.h>
 
#define sleep_millisecs 1000*60
 
static int thread ( void *arg)
{
     long ns1, ns2, delta;
     unsigned int cpu;
     struct timespec ts1, ts2;
 
     cpu = *((unsigned int *)arg);
 
     printk(KERN_INFO "### [thread/%d] test start \n" , cpu);
 
     while (!kthread_should_stop()) {
                 /*
                  * Do What you want
                  */
         schedule_timeout_interruptible(
                 msecs_to_jiffies(1));
     }
 
     printk(KERN_INFO "### [thread/%d] test end \n" , cpu);
 
     return 0;
}
 
static int __init XXXX( void )
{
     int cpu;
     unsigned int cpu_count = num_online_cpus();
     unsigned int parameter[cpu_count];
     struct task_struct *t_thread[cpu_count];
 
     for_each_present_cpu(cpu){
         parameter[cpu] = cpu;
 
         t_thread[cpu] = kthread_create( thread , ( void *) (parameter+cpu), "thread/%d" , cpu);
 
         if (IS_ERR(t_thread[cpu])) {
             printk(KERN_ERR "[thread/%d]: creating kthread failed\n" , cpu);
 
             goto out;
         }
 
         kthread_bind(t_thread[cpu], cpu);
         wake_up_process(t_thread[cpu]);
     }
 
     schedule_timeout_interruptible(
             msecs_to_jiffies(sleep_millisecs));
 
     for (cpu = 0; cpu < cpu_count; cpu++) {
         kthread_stop(t_thread[cpu]);
     }
 
out:
     return 0;
}
 
static void __exit XXXX_exit( void )
{
}
 
module_init(XXXX);
module_exit(XXXX_exit);
 
MODULE_LICENSE( "GPL" );
MODULE_AUTHOR( "bluezd" );
MODULE_DESCRIPTION( "Kernel study" );
This entry was posted in  general,  kernel,  process and tagged  general,  kernel,  process.

你可能感兴趣的:(thread,kernel)