相信很多写程序的人都写过 socket 的程序。当我们 open 一个 socket 之后,接着去读取这个 socket,如果此时没有任何资料可供读取,那 read 就会 block 住。(这是没有加上 O_NONBLOCK 的情形),直到有资料可读取才会传回来。在 Linux kernel 里有一个数据结构可以帮助我们做到这样的功能。这个数据结构就是这里要跟各位介绍的 wait queue。在 kernel 里,wait_queue 的应用很广,举凡 device driver semaphore 等方面都会使用到 wait_queue 来 implement。所以,它算是 kernel 里蛮基本的一个数据结构。
接下来,我要跟各位介绍一下 wait_queue 的用法,以及用一个例子来说明如何使用 wait_queue。最后,我会带各位去 trace 一下 wait_queue 的原始程序代码,看看 wait_queue 是如何做到的。
首先需要明白Linux在user space和kernel space上的差异。我们知道linux是multi-tasking的环境,同时可以有很多人执行很多的程序。这是从user的观点来看的。如果就kernel的观点来看,是没有所谓的multi-tasking的。在kernel里,只有single-thread。也就是说,如果你的kernel code正在执行,那系统里只有那部分在执行。不会有另一部分的kernel code也在运作。当然,这是指单核的情况下。在windows3.1环境下,每个程序都必须适当的将CPU让给别的程序使用。如果有个程序里面有一个while(1)的话,那保证系统就停在那里了。这种的多任务叫做non-preemptive。它多任务的特性是由各个程序相互合作造成的。在Linux的user space下,则是所谓的Preeemptive,各个preocess喜欢什么就执行什么,就算你在你的程序里加上 while(1); 这一行也不会影响系统的运作。反正时间到了,系统自动就会将你的程序停住,让别的程序去执行。这是在 user space 的情况下,在 kernel 这方面,就跟 Windows 3.1 程序是一样的。在 kernel 里,你必须适当的将 CPU 的执行权释放出来。如果你在 kernel里加入 while(1); 这一行。那系统就会跟 Windows 3.1 一样。卡在那里。当然啦,我是没试过这样去改 kernel,有兴趣的人可以去试试看,如果有不同的结果,请记得告诉我。
假设我们在 kernel 里产生一个 buffer,user 可以经由 read,write 等 system call 来读取或写资料到这个 buffer 里。如果有一个 user 写资料到 buffer 时,此时 buffer 已经满了。那请问你要如何去处理这种情形呢 ? 第一种,传给 user 一个错误讯息,说 buffer 已经满了,不能再写入。第二种,将 user 的要求 block 住,等有人将 buffer 内容读走,留出空位时,再让 user 写入资料。但问题来了,你要怎么将 user 的要求 block 住。难道你要用:
while ( is_full );
write_to_buffer;
这 样的程序代码吗? 想想看,如果你这样做会发生什么事? 第一,kernel会一直在这个 while 里执行。第二个,如果 kernel 一直在这个 while 里执行,表示它没有办法去 maintain系统的运作。那此时系统就相当于宕掉了。在这里 is_full 是一个变量,当然,你可以让 is_full 是一个 function,在这个 function里会去做别的事让 kernel 可以运作,那系统就不会宕。这是一个方式。但是,如果我们使用 wait_queue 的话,那程序看起来会比较漂亮,而且也比较让人了解,如下所示:
struct wait_queue *wq = NULL; /* global variable */
while ( is_full ) {
interruptible_sleep_on( &wq );
}
write_to_buffer();
interruptible_sleep_on( &wq )是用来将目前的Process,也就是要求写资料到buffer的process放到wq这个wait_queue里。在interruptible_sleep_on里,则是最后会呼叫schedule()来做schedule的动作,也就是去找另一个Process来执行以维持系统的运作。当执行完interruptible_sleep_on之后,要求write的process就会被block住。那什么时候会恢复执行呢?这个process之所以被block住是因为buffer的空间满了,无法写入。但是如果有人将buffer的资料读取掉,则buffer就有控件可以让人写入。所以,有关于叫醒process的动作应该是在read buffer这方面的程序代码做的。
extern struct wait_queue *wq;
if ( !is_empty ) {
read_from_buffer();
wake_up_interruptible( &wq );
}
....
以 上的程序代码应该要放在 read buffer 这部分的程序代码里,当 buffer 有多余的空间时,我们就呼叫 wake_up_interruptible( &wq ) 来将挂在 wq 上的所有 process 叫醒。请记得,我是说将 wq 上的所有 process 叫醒,所以,如果如果有10个 process 挂在 wq 上的话,那这 10 个都会被叫醒。之后,至于谁先执行。则是要看 schedule 是怎么做的。就是因为这 10 个都会被叫醒。如果 A 先执行,而且万一很不凑巧的,A 又把 buffer 写满了,那其它 9 个 process 要怎么办呢? 所以在 write buffer 的部分,需要用一个 while 来检查 buffer 目前是否满了.如果是的话,那就继续挂在 wq 上面。
上面所谈的就是wait_queue的用法。接下来,再介绍一下wait_queue提供哪些function让我们使用。让我再重申一次。wait_queue应设为global variable,比方叫wq,只要任何的Process想将自己挂在上面,就可以直接呼叫sleep_on等function。要将wq上的process叫醒,只要呼叫wake_up等function就可以了。
据我所知,wait_queue提供4个function可以使用,两个是用来将process加到wait_queue的。
sleep_on( struct wait_queue **wq );
interruptible_sleep_on( struct wait_queue **wq );
另外两个则是将process从wait_queue上叫醒的。
wake_up( struct wait_queue **wq );
wake_up_interruptible( struct wait_queue **wq );
为什么会有两组呢?有interruptible的那一组是这样子的。当我们去read一个没有资料可供读取的socket时,process会block在那里。如果我们此时按下ctrl+c,那read()就会传回EINTR。像这种的block IO就是使用interruptible_sleep_on()做到的。也就是说,如果你是用interruptible_sleep_on()来讲process放到wait_queue时,如果有人送一个signal给这个process,那它就会自动从wait_quue中醒来。但是如果你使用sleep_on()把process放到wq中的话,那不管你送任何signal给它,它还是不会理你的。除非你是使用wake_up()将它叫醒。
wakeup也有两组,wake_up_interruptible()会将wq中使用interruptible_sleep_on()的process
叫醒。至于wake_ip()则是会将wq中所有的process叫醒,包括使用interruptibal_sleep_on()的process。
在使用wait_queue之前有一点需要特别的小心,呼叫Interruptible_sleep_on()和sleep_on()的function必须要是reentrant。简单的说,reentrant的意思是说此function不会改变任何的global variable,或者是不会depend on任何的global variable,或者是在呼叫interruptible_sleep_on() 或 sleep_on() 之后不会 depend on 任何的 global variable。因为当此function呼叫sleep_on()时,目前的process会被暂停执行。可能另外一个process又会呼叫此function。若之前的process将某些information存在global variable,等它恢复执行时要使用,结果第二个进程来了,又把这个global variable改掉了。等第一个process恢复执行时,放在global variable中的information都变了。产生的结果恐怕就不是我们所能想象了。其实,从process执行执行到此function中所呼叫的function都应该是要reentrant的。不然,很有可能还是会有上述的情形发生。
由于wait_queue是kernel所提供的,所以,这个例子必须要要放到kernel里去执行。我使用的这个例子是一个简单的driver。它会maintain一个buffer,大小是8192bytes。提供read跟write的功能。当buffer中没有资料时,read()会马上传回,也就是说不做block IO。而当write buffer时,如果呼叫write()时,空间已满或写入的资料比buffer大时,就会被block住,直到有人将buffer里的资料读出来为止。在write buffer的程序代码中,我们使用wait_queue来做到block IO的功能。在这里,我会将此driver写成module,方便加载kernel。
第一步:这个driver是一个简单的character device driver。所以,我们先在/dev下产生一个character device。major number我们找一个比较没人使用的,像是54,minor number就用0,接着下一个命令:mknod /dev/buf c 54 0
mknod是用来产生special file的command。/dev/buf表示要产生叫buf的档案,位于/dev下。c 表示它是一个 character device。54 为其 major number,0 则是它的 minor number。
第二步,我们要写一个 module,底下是这个 module 的程序代码:
buf.c
#define MODULE
#include
#include
#include
#include
#include
#define BUF_LEN 8192
int flag; /* when rp = wp,flag = 0 for empty,flag = 1 for
non-empty */
char *wp,*rp;
char buffer[BUF_LEN];
EXPORT_NO_SYMBOLS; /* don't export anything */
static ssize_t buf_read( struct file *filp,char *buf,size_t count,
loff_t *ppos )
{
return count;
}
static ssize_t buf_write( struct file *filp,const char *buf,size_t count,
loff_t *ppos )
{
return count;
}
static int buf_open( struct inode *inode,struct file *filp )
{
MOD_INC_USE_COUNT;
return 0;
}
static int buf_release( struct inode *inode,struct file *filp )
{
MOD_DEC_USE_COUNT;
return 0;
}
static struct file_operations buf_fops = {
NULL, /* lseek */
buf_read,
buf_write,
NULL, /* readdir */
NULL, /* poll */
NULL, /* ioctl */
NULL, /* mmap */
buf_open, /* open */
NULL, /* flush */
buf_release, /* release */
NULL, /* fsync */
NULL, /* fasync */
NULL, /* check_media_change */
NULL, /* revalidate */
NULL /* lock */
};
static int buf_init()
{
int result;
flag = 0;
wp = rp = buf;
result = register_chrdev( 54,"buf",&buf_fops );
if ( result < 0 ) {
printk( "<5>buf: cannot get major 54 " );
return result;
}
return 0;
}
static void buf_clean()
{
if ( unregister_chrdev( 54,"buf" ) ) {
printk( "<5>buf: unregister_chrdev error " );
}
}
int init_module( void )
{
return buf_init();
}
void cleanup_module( void )
{
buf_clean();
}
有 关 module 的写法,请各位自行参考其它的文件,最重要的是要有 init_module()和 cleanup_module() 这两个 function。我在这两个 function 里分别做 initialize 和 finalize 的动作。现在分别解释一下。在 init_module() 里,只有呼叫 buf_init() 而己。其实,也可以将 buf_init() 的 code 写到 init_module() 里。只是我觉得这样比较好而已。
flag = 0;
wp = rp = buf;
result = register_chrdev( 54,"buf",&buf_fops );
if ( result < 0 ) {
printk( "<5>buf: cannot get major 54 " );
return result;
}
return 0;
init_buf()做的事就是去注册一个character device driver。在注册一个character device driver之前,必须要先准备一个型为file_operations结构的变量,里面包含了一些function pointer。driver的作者必须自己写这些function。并将function address放到这个结构里。如此以来,当user去读取这个device时,kernel才有办法呼叫对应这个driver的function。
register_chrdev() 看名字就大概知道是要注册 character device driver。第一个参数是此 device 的 major number。第二个是它的名字。名字你可以随便取。第三个的参数就是一个 file_operations 变量的地址。init_module() 必须要传回 0,module 才会被加载。
在 cleanup_module() 的部分,我们也是只呼叫 buf_clean() 而已。它做的事是 unregister 的动作。
if ( unregister_chrdev( 54,"buf" ) ) {
printk( "<5>buf: unregister_chrdev error " );
}
也就是将原本记录在 device driver table 上的资料洗掉。第一个参数是 major number。第二个则是此 driver 的名称,这个名字必须要跟 register_chrdev() 中所给的名字一样才行。
现在我们来看看此 driver 所提供的 file_operations 是那些。
static struct file_operations buf_fops = {
NULL, /* lseek */
buf_read,
buf_write,
NULL, /* readdir */
NULL, /* poll */
NULL, /* ioctl */
NULL, /* mmap */
buf_open, /* open */
NULL, /* flush */
buf_release, /* release */
NULL, /* fsync */
NULL, /* fasync */
NULL, /* check_media_change */
NULL, /* revalidate */
NULL /* lock */
};
在 此,我们只打算 implement buf_read(),buf_write(),buf_open,和 buf_release()等 function 而已。当 user 对这个 device 呼叫 open() 的时候,buf_open() 会在最后被 kernel 呼叫。相同的,当呼叫 close(),read(),和 write() 时,buf_release(),buf_read(),和 buf_write() 也都会分别被呼叫。首先,我们先来看看 buf_open()。
static int buf_open( struct inode *inode,struct file *filp )
MOD_INC_USE_COUNT;
return 0;
}
buf_open() 做的事很简单。就是将此 module 的 use count 加一。这是为了避免当此 module 正被使用时不会被从 kernel 移除掉。相对应的,在 buf_release() 中,我们应该要将 use count 减一。就像开启档案一样。有 open(),就应该要有对应的 close() 才行。如果 module 的 use count 在不为 0 的话,那此 module 就无法从 kernel 中移除了。
static int buf_release( struct inode *inode,struct file *filp )
{
MOD_DEC_USE_COUNT;
return 0;
}
接下来,我们要看一下buf_read()和buf_write()。
static ssize_t buf_read( struct file *filp,char *buf,size_t count,
loff_t *ppos )
{
return count;
}
static ssize_t buf_write( struct file *filp,const char *buf,
size_t count,loff_t *ppos )
{
return count;
}
在 此,我们都只是回传 user 要求读取或写入的字符数目而已。在此,我要说明一下这些参数的意义。filp 是一个 file 结构的 pointer。也就是指我们在 /dev 下所产生的 buf 档案的 file 结构。当我们呼叫 read() 或 write() 时,必须要给一个 buffer 以及要读写的长度。Buf 指的就是这个 buffer,而 count 指的就是长度。至于 ppos 是表示目前这个档案的 offset 在那里。这个值对普通档案是有用的。也就是跟 lseek() 有关系。由于在这里是一个 drvice。所以 ppos 在此并不会用到。
有一点要小心的是,上面参数buf是一个地址,而且还是一个user space的地址,当kernel呼叫buf_read()时,程序在位于kernel space。所以你不能直接读写资料到buf里。
Makefile
P = buf
OBJ = buf.o
INCLUDE = -I/usr/src/linux/include/linux
CFLAGS = -D__KERNEL__ -DMODVERSIONS -DEXPORT_SYMTAB -O $(INCLUDE)
-include /usr/src/linux/include/linux/modversions.h
CC = gcc
$(P): $(OBJ)
ld -r $(OBJ) -o $(P).o
.c.o:
$(CC) -c $(CFLAGS) $<
clean:
rm -f *.o *~ $(P)
加 入上面这个 Makefile,打入 make 之后,就会产生一个 buf.o 的档案。利用 insmod 将 buf.o 载到 kernel 里。相信大家应该都用过 /dev/zero 这个 device。去读取这个 device,只会得到空的内容。写资料到这个 device 里也只会石沈大海。现在你可以去比较 buf 和 zero 这两个 device。两者的行为应该很类似才是。
第三步:我们在第二步中实现一个像zero的device driver。我们现在要经由修改它来使用wait_queue。首先我们先加入一个global variable write_wq,并把它设置为NULL。
struct wait_queue *write_wq = NULL;
然后,在 buf_read() 里,我们要改写成这个样子。
static ssize_t buf_read( struct file *filp,char *buf,size_t count,
loff_t *ppos )
{
int num,nRead;
nRead = 0;
while ( ( wp == rp ) && !flag ) { /* buffer is empty */
return 0;
}
repeate_reading:
if ( rp < wp ) {
num = min( count,( int ) ( wp-rp ) );
}
else {
num = min( count,( int ) ( buffer+BUF_LEN-rp ) );
}
copy_to_user( buf,rp,num );
rp += num;
count -= num;
nRead += num;
if ( rp == ( buffer + BUF_LEN ) )
rp = buffer;
if ( ( rp != wp ) && ( count > 0 ) )
goto repeate_reading;
flag = 0;
wake_up_interruptible( &write_wq );----唤醒被阻塞进程
return nRead;
}
在 前头我有提到,buf 的地址是属于 user space 的。在 kernel space 中,你不能像普通写到 buffer 里一样直接将资料写到 buf 里,或直接从 buf 里读资料。Linux 里使用 FS 这个 register 来当作 kernel space 和 user space 的切换。所以,如果你想手动的话,可以这样做:
mm_segment_t fs;
fs = get_fs();
set_fs( USER_DS );
write_data_to_buf( buf );
set_fs( fs );
也 就是先切换到 user space,再写资料到 buf 里。之后记得要切换回来 kernel space。这种自己动手的方法比较麻烦,所以 Linux 提供了几个 function,可以让我们直接在不同的 space 之间做资料的搬移。诚如各位所见,copy_to_user() 就是其中一个。
顾 名思义,copy_to_user() 就是将资料 copy 到 user space 的 buffer 里,也就是从 to 写到 from,n 为要 copy 的 byte 数。相同的,copy_from_user() 就是将资料从 user space 的 from copy 到位于 kernel 的 to 里,长度是 n bytes。在以前的 kernel 里,这两个 function 的前身是 memcpy_tofs() 和 memcpy_fromfs(),不知道为什么到了 kernel 2.2.1之后,名字就被改掉了。至于它们的程序代码有没有更改就不太清楚了。至于到那一版才改的。我没有仔细去查,只知道在 2.0.36 时还没改,到了 2.2.1 就改了。这两个 function 是 macro,都定义在 里。要使用前记得先 include 进来。
相信 buf_read() 的程序代码应当不难了解才对。不知道各位有没有看到,在buf_read() 的后面有一行的程序,就是:
wake_up_interruptible( &write_wq );
write_wq 是我们用来放那些想要写资料到 buffer,但 buffer 已满的 process。这一行的程序会将挂在此 queue 上的 process 叫醒。当 queue 是空的时,也就是当 write_wq 为 NULL 时,wake_up_interruptible() 并不会造成任何的错误。接下来,我们来看看更改后的 buf_write()。
static ssize_t buf_write( struct file *filp,const char *buf,size_t count,loff_t *ppos )
{
int num,nWrite;
nWrite = 0;
while ( ( wp == rp ) && flag ) {
interruptible_sleep_on( &write_wq );
}
repeate_writing:
if ( rp > wp ) {
num = min( count,( int ) ( rp - wp ) );
}
else {
num = min( count,( int ) ( buffer + BUF_LEN - wp ) );
}
copy_from_user( wp,buf,num );
wp += num;
count -= num;
nWrite += num;
if ( wp == ( buffer + BUF_LEN ) ) {
wp = buffer;
}
if ( ( wp != rp ) && ( count > 0 ) ) {
goto repeate_writing;
}
flag = 1;
return nWrite;
}
我们把 process 丢到 write_wq 的动作放在 buf_write() 里。当 buffer 已满时,就直接将 process 丢到 write_wq 里.
while ( ( wp == rp ) && flag ) {
interruptible_sleep_on( &write_wq );
}