LDD3源码分析之阻塞型I/O

作者：刘昊昱 

博客：http://blog.csdn.net/liuhaoyutz

编译环境：Ubuntu 10.10

内核版本：2.6.32-38-generic-pae

LDD3源码路径：examples/scull/pipe.c  examples/scull/main.c

 

本文分析LDD3第六章介绍的scullpipe设备是如何实现阻塞I/O的。另外，我发现scullpipe的实现代码有一个问题，在文章的最后，对这个问题进行了说明，并给出了修正代码。

 

一、scullpipe设备实现阻塞I/O分析

scuoopipe设备被实现为具有类似管道特性，用以演示如何实现阻塞型和非阻塞型I/O。实际的设备驱动中，这通常通过硬件中断的方式实现：当等待事件发生时，硬件发出一个中断，然后在中断处理程序中，驱动程序会唤醒等待进程。作为一个演示程序，scullpipe没有利用中断，而是选择使用另一个进程来产生数据并唤醒读取进程，类似的，利用读取进程来唤醒等待缓冲区可用的写入进程。

scullpipe的主体实现在examples/scull/pipe.c中，但是也利用了examples/scull/main.c中的一些代码。我们分析scullpipe的起点在main.c中，首先看main.c中的如下代码：

648        /* Initialize each device. */
649    for (i = 0; i < scull_nr_devs; i++) {
650        scull_devices[i].quantum = scull_quantum;
651        scull_devices[i].qset = scull_qset;
652        init_MUTEX(&scull_devices[i].sem);
653        scull_setup_cdev(&scull_devices[i], i);
654    }
655
656        /* At this point call the init function for any friend device */
657    dev = MKDEV(scull_major, scull_minor + scull_nr_devs);
658    dev += scull_p_init(dev);
659    dev += scull_access_init(dev);

649 - 654行，我们在分析第三章中的scull设备时已经分析过了，用for循环初始化scull0 - scull3，但当时657 - 659行我们跳过没有分析。

现在来看657行，scull_major和scull_minor的默认值都是0，scull_nr_devs的默认值是4。dev变量在618行定义，它是dev_t类型，注意dev_t类型用来保存设备编号，包括主设备号和次设备号。所以，657行，我们通过MKDEV宏得到一个主设备号为0，次设备号为4的设备编号保存在dev中。这里之所以让次设备号为4，是因为前面已经注册了scull0 - scull3，它们的主设备号均为系统分配值，次设备号分别是0，1，2，3。虽然我们还没有看后面的代码，但我们由此可以推测出作者的意图，要创建scullpipe0 - scullpipe3，其主设备号均为系统分配值，次设备号分别为4，5，6，7。

658行是我们要分析的重点。而659行以后才会涉及，在本文中不分析659行。注意，658行，把657行生成的设备编号dev做为参数传递给scull_p_init函数，现在看这个函数的实现，在examples/scull/pipe.c文件中：

343/*
344 * Initialize the pipe devs; return how many we did.
345 */
346int scull_p_init(dev_t firstdev)
347{
348    int i, result;
349
350    result = register_chrdev_region(firstdev, scull_p_nr_devs, "scullp");
351    if (result < 0) {
352        printk(KERN_NOTICE "Unable to get scullp region, error %d\n", result);
353        return 0;
354    }
355    scull_p_devno = firstdev;
356    scull_p_devices = kmalloc(scull_p_nr_devs * sizeof(struct scull_pipe), GFP_KERNEL);
357    if (scull_p_devices == NULL) {
358        unregister_chrdev_region(firstdev, scull_p_nr_devs);
359        return 0;
360    }
361    memset(scull_p_devices, 0, scull_p_nr_devs * sizeof(struct scull_pipe));
362    for (i = 0; i < scull_p_nr_devs; i++) {
363        init_waitqueue_head(&(scull_p_devices[i].inq));
364        init_waitqueue_head(&(scull_p_devices[i].outq));
365        init_MUTEX(&scull_p_devices[i].sem);
366        scull_p_setup_cdev(scull_p_devices + i, i);
367    }
368#ifdef SCULL_DEBUG
369    create_proc_read_entry("scullpipe", 0, NULL, scull_read_p_mem, NULL);
370#endif
371    return scull_p_nr_devs;
372}

350行，调用register_chrdev_region函数申请从firstdev开始的scull_p_nr_devs个设备编号，firstdev是scull_p_init函数的形参，所以firstdev是前面main.c中658行传的设备编号。而scull_p_nr_devs的默认值为4.

355行，scull_p_devno = firstdev; scull_p_devno用于记录第一个scullpipe设备的设备编号。

356行，为scullpipe0 - scullpipe3的设备结构体分配内存空间。scullpipe设备由scull_pipe结构体表示，其定义如下：

33struct scull_pipe {
34        wait_queue_head_t inq, outq;        /* read and write queues */
35        char *buffer, *end;                 /* begin of buf, end of buf */
36        int buffersize;                      /* used in pointer arithmetic */
37        char *rp, *wp;                     /* where to read, where to write */
38        int nreaders, nwriters;               /* number of openings for r/w */
39        struct fasync_struct *async_queue;    /* asynchronous readers */
40        struct semaphore sem;              /* mutual exclusion semaphore */
41        struct cdev cdev;                   /* Char device structure */
42};

361行，将scull_pipe结构体数组的内容清0。

362 - 367行，初始化scullpipe设备对应的scull_pipe结构体。每次for循环初始化一个scullpipe设备。

363 - 364行，初始化两个等待队列头scull_p_devices[i].inq和scull_p_devices[i].outq，这两个等待队列头分别代表休眠在scullpipe设备上的等待读取和等待写入的进程。

365行初始化信号量scull_p_devices[i].sem。

366行，调用scull_p_setup_cdev函数完成进一步的初始化。下面看这个函数的实现：

326/*
327 * Set up a cdev entry.
328 */
329static void scull_p_setup_cdev(struct scull_pipe *dev, int index)
330{
331    int err, devno = scull_p_devno + index;
332
333    cdev_init(&dev->cdev, &scull_pipe_fops);
334    dev->cdev.owner = THIS_MODULE;
335    err = cdev_add (&dev->cdev, devno, 1);
336    /* Fail gracefully if need be */
337    if (err)
338        printk(KERN_NOTICE "Error %d adding scullpipe%d", err, index);
339}

333行，调用cdev_init函数初始化dev->cdev，指定设备操作函数集是scull_pipe_fops。

335行，调用cdev_add函数将dev->cdev注册到系统中, devno是对应的设备编号。

至此，scullpipe设备就初始化完毕并且注册到系统中。

再回到scull_p_init函数，368 - 370行，注册了scullpipe的/proc接口。因为本文主要分析阻塞型I/O,所以不讨论这个接口。但需要注意的是，scullpipe的/proc接口实现与scull的/proc接口实现不一样，主要是start参数相关的问题，有兴趣可以仔细研究一下。

371行，返回注册的scullpipe设备个数。

下面我们来看scullpipe的read函数，即scull_p_read函数，其代码如下所示：

118static ssize_t scull_p_read (struct file *filp, char __user *buf, size_t count,
119                loff_t *f_pos)
120{
121    struct scull_pipe *dev = filp->private_data;
122
123    if (down_interruptible(&dev->sem))
124        return -ERESTARTSYS;
125
126    while (dev->rp == dev->wp) { /* nothing to read */
127        up(&dev->sem); /* release the lock */
128        if (filp->f_flags & O_NONBLOCK)
129            return -EAGAIN;
130        PDEBUG("\"%s\" reading: going to sleep\n", current->comm);
131        if (wait_event_interruptible(dev->inq, (dev->rp != dev->wp)))
132            return -ERESTARTSYS; /* signal: tell the fs layer to handle it */
133        /* otherwise loop, but first reacquire the lock */
134        if (down_interruptible(&dev->sem))
135            return -ERESTARTSYS;
136    }
137    /* ok, data is there, return something */
138    if (dev->wp > dev->rp)
139        count = min(count, (size_t)(dev->wp - dev->rp));
140    else /* the write pointer has wrapped, return data up to dev->end */
141        count = min(count, (size_t)(dev->end - dev->rp));
142    if (copy_to_user(buf, dev->rp, count)) {
143        up (&dev->sem);
144        return -EFAULT;
145    }
146    dev->rp += count;
147    if (dev->rp == dev->end)
148        dev->rp = dev->buffer; /* wrapped */
149    up (&dev->sem);
150
151    /* finally, awake any writers and return */
152    wake_up_interruptible(&dev->outq);
153    PDEBUG("\"%s\" did read %li bytes\n",current->comm, (long)count);
154    return count;
155}

126行,当读指针dev->rp与写指针 dev->wp相等时，说明缓冲区中没有数据可读。这种情况下，要根据用户指定的标志位决定是进入休眠等待还是直接返回。

127行，进入休眠之前，要将已经获得的锁释放掉。

128 - 129行，如果用户空间的read函数指定了O_NONBLOCK标志，则不阻塞进程，直接退出。

131 - 132行，调用wait_event_interruptible函数休眠在dev->inq等待队列上，注意被唤醒的条件是(dev->rp != dev->wp)，即缓冲区中有数据可读。由这一句也可以看出，用户空间的read进程对应的等待队列是dev->inq。另外，wait_event_interruptible的返回值有两种，返回0表示缓冲区中有数据可读，被唤醒。返回非0值表示休眠被某个信号中断，这时，132行直接返回-ERESTARTSYS。

134 - 135行，休眠被唤醒后，首先重新获得互斥锁，然后返回到while循环开始处判断是否有数据可读。

138 - 141行，确认有数据可读后，退出while循环，根据读写指针的位置位及count值，决定要读多少数据。

142行，读数据到用户空间。

146 - 148行，更新读指针的位置。

149行，释放互斥锁。

152行，读取结束后，就有缓冲区空间可以进行写操作了。所以唤醒所有休眠在dev->outq上的写进程，唤醒函数是wake_up_interruptible。

154行，返回读取的字节数。

注意，scull_p_read在142行调用copy_to_user将数据拷贝到用户空间过程中，可能会休眠。此时，虽然进程拥有互斥锁，但这种情况下拥有互斥锁休眠是可以接受的，因为我们知道内核会把数据复制到用户空间并唤醒我们，同时不会试图锁上同一个信号量。

下面我们来看scullpipe的write函数，即scull_p_write函数，其代码如下所示：

188static ssize_t scull_p_write(struct file *filp, const char __user *buf, size_t count,
189                loff_t *f_pos)
190{
191    struct scull_pipe *dev = filp->private_data;
192    int result;
193
194    if (down_interruptible(&dev->sem))
195        return -ERESTARTSYS;
196
197    /* Make sure there's space to write */
198    result = scull_getwritespace(dev, filp);
199    if (result)
200        return result; /* scull_getwritespace called up(&dev->sem) */
201
202    /* ok, space is there, accept something */
203    count = min(count, (size_t)spacefree(dev));
204    if (dev->wp >= dev->rp)
205        count = min(count, (size_t)(dev->end - dev->wp)); /* to end-of-buf */
206    else /* the write pointer has wrapped, fill up to rp-1 */
207        count = min(count, (size_t)(dev->rp - dev->wp - 1));
208    PDEBUG("Going to accept %li bytes to %p from %p\n", (long)count, dev->wp, buf);
209    if (copy_from_user(dev->wp, buf, count)) {
210        up (&dev->sem);
211        return -EFAULT;
212    }
213    dev->wp += count;
214    if (dev->wp == dev->end)
215        dev->wp = dev->buffer; /* wrapped */
216    up(&dev->sem);
217
218    /* finally, awake any reader */
219    wake_up_interruptible(&dev->inq);  /* blocked in read() and select() */
220
221    /* and signal asynchronous readers, explained late in chapter 5 */
222    if (dev->async_queue)
223        kill_fasync(&dev->async_queue, SIGIO, POLL_IN);
224    PDEBUG("\"%s\" did write %li bytes\n",current->comm, (long)count);
225    return count;
226}

与scull_p_read采用简单休眠不同，scull_p_write采用了手工休眠的方式。

194行，获得互斥锁。

198行，调用scull_getwritespace函数。下面看这个函数的定义：

157/* Wait for space for writing; caller must hold device semaphore.  On
158 * error the semaphore will be released before returning. */
159static int scull_getwritespace(struct scull_pipe *dev, struct file *filp)
160{
161    while (spacefree(dev) == 0) { /* full */
162        DEFINE_WAIT(wait);
163
164        up(&dev->sem);
165        if (filp->f_flags & O_NONBLOCK)
166            return -EAGAIN;
167        PDEBUG("\"%s\" writing: going to sleep\n",current->comm);
168        prepare_to_wait(&dev->outq, &wait, TASK_INTERRUPTIBLE);
169        if (spacefree(dev) == 0)
170            schedule();
171        finish_wait(&dev->outq, &wait);
172        if (signal_pending(current))
173            return -ERESTARTSYS; /* signal: tell the fs layer to handle it */
174        if (down_interruptible(&dev->sem))
175            return -ERESTARTSYS;
176    }
177    return 0;
178}

161行，使用spacefree函数判断是否有空间可写，该函数定义如下：

180/* How much space is free? */
181static int spacefree(struct scull_pipe *dev)
182{
183    if (dev->rp == dev->wp)
184        return dev->buffersize - 1;
185    return ((dev->rp + dev->buffersize - dev->wp) % dev->buffersize) - 1;
186}

如果spacefree函数返回值为0，说明现在scullpipe设备缓冲区已满，没有空间可以写入。写进程需要根据调用者设置的标志位决定是否休眠等待。

162行，使用DEFINE_WAIT函数创建并初始化一个等待队列入口。

164行，在进入休眠前，释放互斥锁。

165 - 166行，如果调用者设置了O_NONBLOCK标志位，则直接退出。

168行，调用prepare_to_wait(&dev->outq, &wait, TASK_INTERRUPTIBLE)函数，将等待队列入口wait插入到dev->outq等待队列中，并设置进程状态为TASK_INTERRUPTIBLE。

169 - 170行，再次调用spacefree(dev)判断是否有空间可写，如果还是确认没有空间，则调用170行的schedule()进行进程调度。这里需要注意的是，如果在169行的if判断和170行的调度之间，有了可写入空间，那么会发生什么情况？这种情况下没有任何问题，只要进程已经把自己放到了等待队列中并修改了进程状态，就不会有任何问题，schedule会把进程状态重新设置为TASK_RUNNING，并返回。

171行，调用finish_wait执行清理操作。

172 - 173行，判断是否是因为收到信号而醒来的，如果是返回-ERESTARTSYS。

174 - 176行，重新申请互斥锁，再次回到while开始处确认是否有空间写入。

177行，如果有空间可写入，返回0。

下面执行流程回到scull_p_write函数的198行，如果有可写入的空间，scull_getwritespace返回值为0，如果是因为收到信号而醒来的，scull_getwritespace返回非0值。

202 - 207行，计算可写入数据的大小。

209 - 212行，将数据从用户空间拷贝到内核空间。

213 - 215行，调整写入指针的位置。

216行，释放互斥锁。

219行，唤醒所有在读取等待队列上休眠的进程。

222 - 223行，是异步通知相关的操作，这里不讨论，后面在相关文章中再分析。

225行，返回写入的字节数。

scullpipe的测试需要打开两个终端窗口，安装好scullpipe后，在一个终端窗口上运行cat /dev/scullpipe0，因为缓冲区中没有可读内容，所以cat操作会休眠等待，如下图所示：

然后在另外一个终端窗口上执行echo “hello” > /dev/scullpipe0，将hello写入scullpipe0，可以看到cat进程会被唤醒，读出并打印”hello”。再次执行ls work/ >/dev/scullpipe0，会把work目录下的内容写入/dev/scullpipe0，同时，cat会被再次唤醒并打印输出work目录下的内容。

 

二、scullpipe源码中的一个问题

LDD3提供的scullpipe的代码有一个问题，不知道大家发现了没有，列出大家讨论一下。

首先看下图所示的执行步骤出现的问题：

上图中，先向/dev/scullpipe写入字符串”hello”，然后用cat命令读/dev/scullpipe，正常情况下应该能读出”hello”才对，但是从上图我们可以看出，cat被阻塞住了。原因是什么呢？我们先看scull_p_open函数的实现：

 61static int scull_p_open(struct inode *inode, struct file *filp)
 62{
 63    struct scull_pipe *dev;
 64
 65    dev = container_of(inode->i_cdev, struct scull_pipe, cdev);
 66    filp->private_data = dev;
 67
 68    if (down_interruptible(&dev->sem))
 69        return -ERESTARTSYS;
 70    if (!dev->buffer) {
 71        /* allocate the buffer */
 72        dev->buffer = kmalloc(scull_p_buffer, GFP_KERNEL);
 73        if (!dev->buffer) {
 74            up(&dev->sem);
 75            return -ENOMEM;
 76        }
 77    }
 78    dev->buffersize = scull_p_buffer;
 79    dev->end = dev->buffer + dev->buffersize;
 80    dev->rp = dev->wp = dev->buffer; /* rd and wr from the beginning */
 81
 82    /* use f_mode,not  f_flags: it's cleaner (fs/open.c tells why) */
 83    if (filp->f_mode & FMODE_READ)
 84        dev->nreaders++;
 85    if (filp->f_mode & FMODE_WRITE)
 86        dev->nwriters++;
 87    up(&dev->sem);
 88
 89    return nonseekable_open(inode, filp);
 90}

70 - 80行，如果dev->buffer为NULL，则给dev->buffer分配内存空间，然后设置缓冲区大小和结束位置，以及读写指针位置。

关键在第80行，这行将读写指针位置dev->rp和dev->wp设置为同时指向缓冲区的开始处，而在scullpipe设备中，dev->rp等于dev->wp表明缓冲区中没有数据。

所以，问题的原因就找到了，我们向scullpipe中写入了字符串，但是执行cat /dev/scullpipe时，cat命令会调用open打开/dev/scullpipe文件，这时，就会将dev->rp和dev->wp设置为指向缓冲区的开始处，然后，cat读/dev/scullpipe的时候，就会认为该文件中没有数据可读，就会阻塞住。直到下次有数据写入时，cat才能被唤醒并读出数据。

另外，这个scull_p_open函数的逻辑有问题。在open时给dev->buffer分配内存，就是说，每次打开scullpipe设备，都会为它分配内存，这本来就不合理，尽管70行加了一个判断，只有当dev->buffer为空时，才分配内存。合理的位置应该是在初始化函数中完成这些操作。所以，我修改了scull_p_open函数和scull_p_setup_cdev函数，把对缓冲区的初始化工作放在了scull_p_setup_cdev函数中，该函数由初始化函数scull_p_init调用。列出这两个函数如下：

static int scull_p_open(struct inode *inode, struct file *filp)
{
        struct scull_pipe *dev;

        dev = container_of(inode->i_cdev, struct scull_pipe, cdev);
        filp->private_data = dev;

        if (down_interruptible(&dev->sem))
                return -ERESTARTSYS;

        /* use f_mode,not  f_flags: it's cleaner (fs/open.c tells why) */
        if (filp->f_mode & FMODE_READ)
                dev->nreaders++;
        if (filp->f_mode & FMODE_WRITE)
                dev->nwriters++;
        up(&dev->sem);

        return nonseekable_open(inode, filp);
}

 

/*
 * Set up a cdev entry.
 */
static void scull_p_setup_cdev(struct scull_pipe *dev, int index)
{
        int err, devno;

        /* allocate the buffer */
        dev->buffer = kmalloc(scull_p_buffer, GFP_KERNEL);
        if (!dev->buffer)
                return -ENOMEM;

        dev->buffersize = scull_p_buffer;
        dev->end = dev->buffer + dev->buffersize;
        dev->rp = dev->wp = dev->buffer; /* rd and wr from the beginning */

        devno = scull_p_devno + index;
        cdev_init(&dev->cdev, &scull_pipe_fops);
        dev->cdev.owner = THIS_MODULE;
        err = cdev_add (&dev->cdev, devno, 1);
        /* Fail gracefully if need be */
        if (err)
                printk(KERN_NOTICE "Error %d adding scullpipe%d", err, index);
}

由于把分配缓冲区的工作从scull_p_open函数移到了模块初始化函数中，连锁反应，还有一个函数需要修改，那就是scull_p_release，修改后的代码如下：

static int scull_p_release(struct inode *inode, struct file *filp)
{
        struct scull_pipe *dev = filp->private_data;

        /* remove this filp from the asynchronously notified filp's */
        scull_p_fasync(-1, filp, 0);
        down(&dev->sem);
        if (filp->f_mode & FMODE_READ)
                dev->nreaders--;
        if (filp->f_mode & FMODE_WRITE)
                dev->nwriters--;
//      if (dev->nreaders + dev->nwriters == 0) {
//              kfree(dev->buffer);
//              dev->buffer = NULL; /* the other fields are not checked on open */
//      }
        up(&dev->sem);
        return 0;
}

因为原来在scull_p_open中分配缓冲区，所以在scull_p_release中释放缓冲区，现在scull_p_open中不再分配缓冲区了，所以scull_p_release也就不再释放缓冲区了。所以必须屏蔽掉scull_p_release函数中释放缓冲区的4条语句。

用上面的列出的scull_p_open、scull_p_setup_cdev、scull_p_release函数替换原来的函数，上面的问题就解决了，执行结果如下图所示：