linux设备驱动开发-设备阻塞访问的简单实现

当我们读取一个空的命名管道文件是，会阻塞等待，知道有新数据写入管道中。访问阻塞在设备驱动中非常常见，而且也是非常必要的一种功能。

而我们实现设备驱动的阻塞访问通常是通过等待队列的机制实现。

等待队列的使用比较简单。下面是申明和定义一个等待队列的两种方法：

1.静态

DECLARE_WAIT_QUEUE_HEAD(wq);

2.动态

wait_queue_head_t wq；

init_waitqueue_head(&wq);

3.使用

wait_event_interruptible(wq, condition);//加入等待   或者其他等价的接口

wake_up_interruptible(&wq);  //唤醒等待队列     或者其他等价的接口

下面的例子能够更好的说明等待队列的用法

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>

#define SIZE 1024
#define NR   4

static int major = 100, minor = 0;
module_param(major, int, 0400);
module_param(minor, int, 0400);

// =================================================================
struct mypipe_t {
    char buf[SIZE];
    int in, out;
};

static void mypipe_init(struct mypipe_t *pipe)
{
    pipe->in = pipe->out = 0;
}

static int mypipe_is_full(struct mypipe_t *pipe)
{
    return (pipe->in + 1) % SIZE == pipe->out;
}

static int mypipe_is_empty(struct mypipe_t *pipe)
{
    return pipe->in == pipe->out;
}

static int mypipe_read_one_char(struct mypipe_t *pipe, char *ch)
{
    if (mypipe_is_empty(pipe))
    {
        return -1;
    }

    *ch = pipe->buf[pipe->out];
    pipe->out = (pipe->out + 1) % SIZE;

    return 0;
}

static int mypipe_write_one_char(struct mypipe_t *pipe, char ch)
{
    if (mypipe_is_full(pipe))
    {
        return -1;
    }

    pipe->buf[pipe->in] = ch;
    pipe->in = (pipe->in + 1) % SIZE;

    return 0;
}

// =================================================================

struct mydev_t {
    dev_t devno;
    struct cdev cdev;

    wait_queue_head_t rq, wq;
    struct mypipe_t pipe;
};
struct mydev_t mydev[NR];

//==================================================================

static int myopen(struct inode *inode, struct file *filp)
{
#if 0
    //MINOR(inode->i_rdev);
    int index = iminor(inode);

    filp->private_data = &mydev[index];
#else
    filp->private_data = container_of(inode->i_cdev, struct mydev_t, cdev);
#endif

    return 0;
}

static ssize_t myread(struct file *filp, char __user *buf,
     size_t len, loff_t *off)
{
    int i, ret;
    char ch;
    struct mydev_t *devp = filp->private_data;

    ret = wait_event_interruptible(devp->rq, !mypipe_is_empty(&devp->pipe));
    if (ret != 0)
    {
        return -EINTR;
    }

    for (i = 0; i < len; ++i)
    {
        ret = mypipe_read_one_char(&devp->pipe, &ch);
        if (ret != 0) break;

        //buf[i] = ch;
        //copy_to_user(&buf[i], &ch, 1);
        put_user(ch, &buf[i]);
    }

    wake_up_interruptible(&devp->wq);

    return i;
}

static ssize_t mywrite(struct file *filp, const char __user *buf,
     size_t len, loff_t *off)
{
    int i, ret;
    char ch;
    struct mydev_t *devp = filp->private_data;

    ret = wait_event_interruptible(devp->wq, !mypipe_is_full(&devp->pipe));
    if (ret != 0)
    {
        return -EINTR;
    }

    for (i = 0; i < len; ++i)
    {
        get_user(ch, &buf[i]);

        ret = mypipe_write_one_char(&devp->pipe, ch);
        if (ret != 0) break;
    }

    wake_up_interruptible(&devp->rq);

    return i;
}

static int myrelease(struct inode *inode, struct file *filp)
{
    return 0;
}

struct file_operations pipe_ops = {
    .open    = myopen,
    .release = myrelease,
    .read    = myread,
    .write   = mywrite,
};

//==================================================================

static int __init test_init(void)
{
    int i;
    dev_t devno;
    struct mydev_t *devp;

    devno = MKDEV(major, minor);
    register_chrdev_region(devno, NR, "mypipe");

    for (i = 0; i < NR; ++i)
    {
        devp = &mydev[i];

        init_waitqueue_head(&devp->rq);
        init_waitqueue_head(&devp->wq);

        mypipe_init(&devp->pipe);

        cdev_init(&devp->cdev, &pipe_ops);

        devno = MKDEV(major, minor + i);
        cdev_add(&devp->cdev, devno, 1);
    }

    return 0;
}

static void __exit test_exit(void)
{
    int i;
    dev_t devno;
    struct mydev_t *devp;

    for (i = 0; i < NR; ++i)
    {
        devp = &mydev[i];

        cdev_del(&devp->cdev);
    }

    devno = MKDEV(major, minor);
    unregister_chrdev_region(devno, NR);
}

module_init(test_init);
module_exit(test_exit);

MODULE_LICENSE("GPL");