关于内核线程(kernel_thread)

我们知道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创建的进程是不能转到用户态运行的