阅读 157

带您进入内核开发的大门 | 内核中的线程

内核线程是直接由内核本身启动的进程。内核线程实际上是将内核函数委托给独立的进程,它与内核中的其他进程”并行”执行。内核线程经常被称之为内核守护进程。内核线程是被调度的实体,它被加入到某种数据结构中,调度程序根据实际情况进行线程的调度。 内核线程与用户态线程的作用类似,通常用于执行某些周期性的计算任务,或者在后台执行需要大量计算的任务。

linux kernel
本文主要介绍一下内核线程操作相关的API的使用,以及内核线程的实现基本原理,更深入的内容在后续文章中介绍。

内核线程操作函数

内核线程操作涉及的函数(API)主要是创建、调度和停止等函数。操作起来也是比较简单的。下面分别介绍一下这些接口的定义。 创建线程 创建线程的函数为kthread_create,如下是函数的原型,该函数实际上是函数kthread_create_on_node的一个宏定义。后者则是在某个CPU上创建一个线程。该函数的前两个参数分别是线程主函数指针和函数的参数,而后面的参数通过变参数的方式为线程命名。

#define kthread_create(threadfn, data, namefmt, arg...) \
       kthread_create_on_node(threadfn, data, NUMA_NO_NODE, namefmt, ##arg)
复制代码

唤醒线程

通过该函数创建的线程处于非运行状态,需要调用wake_up_process函数将其唤醒后才可以在CPU上运行。

int wake_up_process(struct task_struct *p)
复制代码

创建并运行线程

在内核的API中有另外一个接口可以直接创建一个处于运行状态的线程,其定义如下。这里其实就是调用了上文描述的两个函数。

#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;                                                               \
})
复制代码

停止线程

线程也可以被停止,此时主函数将会退出,当然需要主函数的实现考虑该问题。如下是停止线程的函数接口。

int kthread_stop(struct task_struct *k) 
复制代码

线程的调度

内核线程创建完成后将一直运行下去,除非遇到了阻塞事件或者自己将自己调度出去。通过下面函数,线程可以将自己调度出去。调度出去的含义就是将CPU让给其它线程

asmlinkage __visible void __sched schedule(void)
复制代码

简单内核线程使用

前面介绍了内核线程基本原理及相关的API,下面我们将开发一个内核线程的基本实例。 这个实例是在一个内核模块中启动一个内核线程。内核线程的作用很简单,就是定时的向系统日志中输出一个字符串。本例的目的主要是介绍如何创建、使用和销毁一个内核线程。

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/mm.h>

#include <linux/in.h>
#include <linux/inet.h>
#include <linux/socket.h>
#include <net/sock.h>
#include <linux/kthread.h>
#include <linux/sched.h>

#define BUF_SIZE 1024
struct task_struct *main_task;

/* 这个函数用于将内核线程置于休眠状态,也就是将其调度出
 * 队列。*/
static inline void sleep(unsigned sec)
{
        __set_current_state(TASK_INTERRUPTIBLE);
        schedule_timeout(sec * HZ);
}

/* 线程函数, 这个是线程执行的主体 */
static int multhread_server(void *data)
{
        int index = 0;

        /* 在线程没有被停止的情况下,循环向系统日志输出
         * 内容, 完成后休眠1秒。*/
        while (!kthread_should_stop()) {
                printk(KERN_NOTICE "thread run %d\n", index);
                index ++; 
                sleep(1);
        }

        return 0;
}


static int multhread_init(void)
{
        ssize_t ret = 0;

        printk("Hello, thread! \n");
        /* 创建并启动一个内核线程, 这里参数为线程函数,
         * 函数的参数(NULL),和线程名称。 */
        main_task = kthread_run(multhread_server,
                                  NULL,
                                  "multhread_server");
        if (IS_ERR(main_task)) {
                ret = PTR_ERR(main_task);
                goto failed;
        }

failed:
        return ret;
}

static void multhread_exit(void)
{
        printk("Bye thread!\n");
        /* 停止线程 */
        kthread_stop(main_task);

}

module_init(multhread_init);
module_exit(multhread_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("SunnyZhang<shuningzhang@126.com>");
复制代码

基本实现原理

创建线程

无论是用户态的进程还是内核线程,在内核态都是线程。在Linux操作系统,创建线程实质是是对父进程(线程)进行克隆的过程。 目前,在3.x以后的版本中,内核线程的创建都有一个名为kthreadd的后台线程操作完成。创建线程的接口只是用于创建任务,并加到任务列表中,并等待后台线程的具体处理。 前文中创建线程的函数kthread_create或者kthread_run调用的函数是__kthread_create_on_node,也就是在某个CPU上创建线程。该函数其实只是创建一个创建线程的请求,如下是裁剪的代码,核心内容如下:

struct task_struct *__kthread_create_on_node(int (*threadfn)(void *data),
                                                    void *data, int node,
                                                    const char namefmt[],
                                                    va_list args)
{
        DECLARE_COMPLETION_ONSTACK(done);
        struct task_struct *task;
        struct kthread_create_info *create = kmalloc(sizeof(*create),
                                                     GFP_KERNEL);

        if (!create)
                return ERR_PTR(-ENOMEM);
        create->threadfn = threadfn;
        create->data = data;
        create->node = node;
        create->done = &done;

        spin_lock(&kthread_create_lock);
        /* 将创建任务添加到链表中 */
        list_add_tail(&create->list, &kthread_create_list);
        spin_unlock(&kthread_create_lock);

        wake_up_process(kthreadd_task);
        ... ...
}
复制代码

具体创建工作在名为kthreadd的后台线程中进行,该线程会从队列中获取创建请求,并逐个创建线程。创建线程调用的接口为kernel_thread,该函数实现从父线程克隆子线程的操作,并建立父子线程的关联关系。

线程调度

Linux的线程管理和调度是一个非常复杂的话题,很难用一篇文章说清楚,我们这里只是介绍一下基本原理。目前Linux操作系统默认使用的是CFS调度算法,该算法是基于优先级和时间片的算法,这个算法包含4部分的内容:

  • 时间记账
  • 进程选择
  • 调度器入口
  • 睡眠和唤醒 时间记账用于记录进程运行的虚拟时间,而进程选择则是根据策略选择应该将那个进程调度到CPU上运行。进程选择使用的数据结构是红黑树,红黑树是一个自平衡二叉树,也就是其中的数据是有序的,这样可以很容易的找到目的数据。Linux内核在具体实现的时候又使用了一个技巧,也就是将下一个要调度的进程放入缓存中,这样就可以直接找到该进程进行调度,降低了检索时间。 Linux内核的调度入口是schedule函数,当线程调用该函数时将触发线程调度。这个函数实现本身很简单,但其内部调用context_switch函数实现真正的调度,在调用该函数之前会通过调度类获取目的进程。
static __always_inline struct rq * 
context_switch(struct rq *rq, struct task_struct *prev,
               struct task_struct *next, struct rq_flags *rf) 
复制代码

这样,通过context_switch函数就可以将当前进程调度出去,而将新的进程调度进来。context_switch最终会调度到一个平台相关的函数,而这个函数是汇编语言实现的,主要实现寄存器和堆栈的处理,并最终完成进程的切换。

关注下面的标签,发现更多相似文章
评论