内核线程 kthread

无鸯 发布于 2011/10/31 16:01
阅读 1K+
收藏 0

参考文章:http://blog.csdn.net/maray/archive/2009/08/13/4442450.aspx

#include <linux/sched.h>   //wake_up_process()
#include <linux/kthread.h> //kthread_create()、kthread_run()
#include <err.h> //IS_ERR()、PTR_ERR()

2.       实现
2.1创建线程
在模块初始化时,可以进行线程的创建。使用下面的函数和宏定义:

struct task_struct *kthread_create(int (*threadfn)(void *data),
                            void *data,
                            const char namefmt[], ...);
#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;                                                     /
})

例如:

static struct task_struct *test_task;
static int test_init_module(void)
{
    int err;
    test_task = kthread_create(test_thread, NULL, "test_task");
    if(IS_ERR(test_task)){
      printk("Unable to start kernel thread./n");
      err = PTR_ERR(test_task);
      test_task = NULL;
      return err;
    }
    wake_up_process(test_task);
    return 0;
}
module_init(test_init_module);

注意的是:test_task = NULL;的使用,只能用在此处,如果是kthread_stop()后将之=NULL,将会出问题,因为此时NULL是个虚拟地址,在内核线程里面是不能这样做的。
2.2线程函数
在线程函数里,完成所需的业务逻辑工作。主要框架如下所示:

int threadfunc(void *data){
        …
        while(1){
               set_current_state(TASK_UNINTERRUPTIBLE);
               if(kthread_should_stop()) break;
               if(){//条件为真
                      //进行业务处理
               }
               else{//条件为假
                      //让出CPU运行其他线程,并在指定的时间内重新被调度
                      schedule_timeout(HZ);
               }
        }
        …
        return 0;
}

2.3结束线程
在模块卸载时,可以结束线程的运行。使用下面的函数:
int kthread_stop(struct task_struct *k);
例如:

static void test_cleanup_module(void)
{
            if(test_task){
                kthread_stop(test_task);
                //test_task = NULL; 会有问题
            }
}
module_exit(test_cleanup_module);


3.       注意事项
(1) 在调用kthread_stop函数时,线程函数不能已经运行结束。否则,kthread_stop函数会一直进行等待。
注意:在kthread_stop之后,test_task !=NULL,测试如果再次kthread_stop,会阻塞。
(2) 线程函数必须能让出CPU,以便能运行其他线程。同时线程函数也必须能重新被调度运行。在例子程序中,这是通过schedule_timeout()函数完成的。
4.性能测试
可以使用top命令来查看线程(包括内核线程)的CPU利用率。命令如下:
       top –p 线程号
可以使用下面命令来查找线程号:
       ps aux|grep 线程名
       注:线程名由kthread_create函数的第三个参数指定。
在驱动程序的设计时,如果应用程序被非法kill掉,release的方法会调用,如果已经调用过open的话。   
 
其他相关资料:
 
准确的说是不要在内核的栈中使用大的内存块,因为内核栈的大小是固定的,不像用户态中的程序,可以动态增长。在内核中用大的内存块,一般都在堆中分配,用kmalloc等函数。内核中写文件可以直接用sys_调用,如 sys_open, sys_write, sys_read等

其实, 借助与ioctl, 内核线程是可以杀死的。

int _exit_flag = 0;

int kernel_func(void *p)
{
    while(_exit_flag == 0)
   {
        ......
   }
}

int ioctl(....,int cmd, .........)
{
    switch(cmd)
    {
     case EXIT_KERNEL_THREAD:
          _exit_flag = 1;
          break;
    }
}

在linux下,线程和进程的区别就是看是否共享内存空间。而且linux内核只有线程,共享1G的内核空间(在32位上),内核的模块被许多线程执行(ps的名称现实里面加 "[]"的是内核线程)
Linux内核可以看作一个服务进程(管理软硬件资源,响应用户进程的种种合理以及不合理的请求)
内核需要多个执行流并行,为了防止可能的阻塞,多线程化是必要的;因为各个执行流共享地址空间,所以是多线程
在linux用户态,可以创建线程,更可以创建进程,线程采用写时复制方法,依靠线程运行库。
 
内核线程的分析:
我们知道Linux内核使用内核线程来将内核分成几个功能模块,
像kswapd,kflushd等,系统中的init进程也是由idle进程调用
kernel_thread()来实现产生的.

我们先来看看内核线程的实现,再来分析内核线程的性质.

int kernel_thread(int(*fn)(void*arg),void *arg,int flags) 
{ 
long retval,d0; /* 至少是两个局部变量 */ 

__asm__ __volitate__( 
"movl %%esp,%%esint" 
"int $0x80nt" 
"cmpl %%esp,%%esint" 
"je 1f nt" 
"movl %4,%%eaxnt" 
"pushl %%eaxnt" 
"call *%5nt" 
"movl %3,%0nt" 
"int $0x80nt" 
"1:t" 
:"=&a"(retval),"=&S"(d0) 
:"0"(__NR_clone),"i"(__NR_exit), 
"r"(arg),"r"(fn), 
"b"(flags | CLONE_VM) 
:"memory" 
); 

return retval; 
} 

这段代码翻译成直观的ASM码:

{ 
movl __NR_clone,%0; /* 将clone的系统调用号载入reg */ 
movl __NR_exit,%3; /* 将exit的系统调用号载入reg */ 
movl arg,%4; /* 将函数fn的参数载入reg */ 
movl fn,%5; /* 将函数fn的指针载入reg */ 
movl flags|CLONE_VM,%ebx; /* 将flags移入%ebx中 */ 
mov %%esp,%%esi; /* 将寄存器%esp保存在%esi中 */ 
int $0x80; /* 由于%eax中是clone的系统调用号,所以 
sys_clone会被调用,同时又由于系统调用门 
会把所有的寄存器压栈,所以子进程会在相应 
的寄存器中获取flags,fn,__NR_exit等,系统调用 
返回后,子进程几乎继承了父进程的一切,但是由 
我们对do_fork的分析可知,子进程将获取新的内核栈, 
栈上就是各寄存器的内容,同时修改TSS使: 
EIP=ret_from_fork, 
ESP=新的内核栈底-sizeof(pt_regs), 
SSO=__KERNEL_DS, 
ESP0=新的内核栈顶, 
(??)修改栈上的OLDESP=新的内核栈底 

子进程恢复执行后,加载eip,esp,当RESTORE_ALL执行后 
(pops,iret),寄存器被恢复了,同时我们知道当前的ESP 
与ESI已是不同了. 
*/ 

cmpl %%esp,%%esi; 
je 1f; /* %esp,%esi相同,则是父进程 */ 
movl %4,%%eax; /* 将参数载入EAX,这样不管fn是否使用-mregparam属性 
参看GCC manual for more information 
*/ 
pushl %%eax /* 将参数压栈 */ 
call *%5; /* 调用fn */ 
movl %3,%0; 
int $0x80; /* 系统调用exit退出 */ 
1: movl %%eax,retval /* 将子进程的pid付给retval(系统调用的返回值在%eax中) */ 
movl %%esi,d0 /* ?? */ 
} 

它的伪C码为:

int kernel_thread() 
{ 
pid=clone(flags); 
if(child) 
{ 
fn(arg); 
exit(0); 
} 
return pid; 
} 


从上面的代码可以看出,内核线程有以下性质:
1.
内核线程是通过系统调用clone()来实现的,使用CLONE_VM标志(用户还可以
提供其他标志,CLONE_PID,CLONE_FS,CLONE_FILES等),因此内核线程与调用
的进程(current)具有相同的进程空间.

2.
由于调用进程是在内核里调用kernel_thread(),因此当系统调用返回时,子进程也处于
内核态中,而子进程随后调用fn,当fn退出时,子进程调用exit()退出,所以子进程是在
内核态运行的.

3.
由于内核线程是在内核态运行的,因此内核线程可以访问内核中数据,调用内核函数.
运行过程中不能被抢占等等.

请注意在kernel_thread是如何调用系统调用的,我们知道kernel_thread是在内核中
调用,所以他是可以直接调用系统调用的,像sys_open()等,但是在这里kernel_thread
通过系统调用门(int$80)来间接调用clone()函数,就提出以下问题:
1.为什么这样?
2.如果我们直接调用sys_clone()会有什么样的结果呢?

int kernel_thread() 
{ 
int pid; 
pid=sys_clone(); 
if(!pid) 
{ 
/* child */ 
exit(); 
} 
return pid; 
} 

这样,当子进程获取CPU资源时(运行时),从ret_from_fork恢复执行,栈布局对于子进程而言
是不对的,问题在于当子进程运行到RESTORE_ALL的IRET,仔细想一想栈布局的变化.

由sys_clone()的申明可知调用sys_clone需要pt_regs的栈结构,如果我们直接调用sys_clone
是没用办法做到的(如果可以我们也需要精心为它准备栈,//:-(,真是伤神)
同理,其他的类似系统调用,我们也必须通过int$80的系统调用门来实现.
而对于sys_execl,sys_open,sys_close,sys_exit,则可以直接调用.//xixi,我们可以
改动kernel_thread来测试sys_exit是否可以直接调用,同时也可以使用sys_clone的直接调用
来证明我们的分析是否正确.

而如果我们使用系统调用门(int$80)来解决问题,我们使用同样的方法来分析:
A2)
ebx <-- ( esp after save all ,ready for syscalls )
ecx
...
oldeip <-- ( esp before SAVE_ALL which construct stack for syscalls )
oldcs
eflags
d0 <- ( space for local variables )
retval
fn <- ( arguments for kernel_thread )
arg
clone_flags
eip <- ( retore ip for kernel_thread )
..

由于kernel_thread在内核的代码段中,所以没有发生栈切换,所有的压栈/退栈都是在
内核栈中进行的.请注意这样栈中便没有(OLDSS,OLDESP),所以在kernel_thread声明了
两个局部参数(retval,d0),对于retval的意义是明显的,而d0大概是(dummy local
variable
0,...n)的意思吧,:)


B2)子进程运行前:
子进程的TSS,栈布局

ebx <- esp
ecx
...
oldeip
oldcs
eflags
d0 <- (局部变量d0)
retval <- (局部变量retval)


运行到RESTORE_ALL时,将恢复CPU各寄存器,当运行到IRET时,
由于在相同特权等级的转移,所以没有发生特权级切换,所以ESP,SS没有发生变化.

BTW,由上面的分析可知,kernel_thread创建的进程是不能转到用户态运行的。
系统启动时,它运行在核心态,此时系统只有一个初始化进程(init_task)在初始化的最后,他创建并启动一个内核线程(init),然后进入空循环。当系统没有其他可以运行的进程,系统会运行此空闲进程(init_task)。init在完成必要的初始化后,开始执行用户态的初始化。当init开始执行用户态程序时它变成系统中的第一个用户进程。init根据脚本创建新的用户进程,用户进程再创建其他进程,因此系统中的所有用户进程都是内核线程(init)的后代。关系讲的应该比较清楚了。

加载中
返回顶部
顶部