等待队列例程

# 文件名：Makefile

# 说明：kpipe 例程 Makefile



# 模块名

MOD_NAME := kpipe



# 模块源码（不能出现与模块名相同的文件名）

SRCS := \



EXTRA_CFLAGS = -DDEBUG



OBJS := $(SRCS:.c=.o)



ifeq ($(KERNELRELEASE),)



KERNELDIR ?= /lib/modules/$(shell uname -r)/build

PWD := $(shell pwd)



default:

$(MAKE) -C $(KERNELDIR) M=$(PWD) modules



clean:

-rm -f $(MOD_NAME).ko

-rm -f $(MOD_NAME).o

-rm -f $(OBJS)

-rm -rf .tmp_versions

-rm -f .*.cmd

-rm -f *.mod.c

-rm -f *.mod.o

-rm -f Module.symvers

-rm -f modules.order



else



$(MOD_NAME)-objs := $(OBJS)

obj-m := $(MOD_NAME).o



endif

/* 文件名：kpipe.c */
/* 说明：等待队列例程 */

#include <linux/module.h> /* 模块编程 */
#include <linux/fs.h> /* 设备号、文件操作接口 */
#include <linux/cdev.h> /* 字符设备编程接口 */
#include <linux/uaccess.h> /* 访问用户态内存接口 */
#include <linux/sched.h> /* 进程调度相关 */
#include <linux/wait.h> /* 等待队列接口 */

MODULE_LICENSE("GPL"); /* 版权声明 */

#define BUF_SIZE 256 /* 内核缓冲区的大小 */

/* 以下类型表示 kpipe 设备 */
struct kpipe_dev {
    struct cdev cdev; /* 内嵌一个字符设备作为代表向内核注册 */
    char *buf; /* 保存内核缓冲区的首地址 */
    int len; /* 保存内核缓冲区的长度 */
    int head; /* 环形缓冲区头指针 */
    int tail; /* 环形缓冲区尾指针 */
    dev_t dev; /* 保存对应的设备号 */
    wait_queue_head_t rq; /* 读等待队列 */
    wait_queue_head_t wq; /* 写等待队列 */
    struct mutex lock; /* 同步变量 */
};

/* 判断设备缓冲区是否空 */
static inline int is_empty(const struct kpipe_dev *dev)
{
    return dev->head == dev->tail;
}

/* 判断设备缓冲区是否满 */
static inline int is_full(const struct kpipe_dev *dev)
{
    /* 让缓冲区的实际容量是 BUF_SIZE-1, 以避免无法区分空与满的情况，
     * 当尾指针正好在头指针之前时就认为缓冲区满 */
    return dev->tail+1 == dev->head ||
        (dev->tail == BUF_SIZE-1 && dev->head == 0);
}

/* 判断设备缓冲区中数据是否回绕 */
static inline int is_rewind(const struct kpipe_dev *dev)
{
    return dev->head > dev->tail;
}

/* 得到设备缓冲区中的数据个数 */
static inline int nr_bytes(const struct kpipe_dev *dev)
{
    if (is_rewind(dev)) {
        return dev->len - dev->head + dev->tail;
    } else {
        return dev->tail - dev->head;
    }
}

/* 得到设备缓冲区中的空位个数 */
static inline int nr_holes(const struct kpipe_dev *dev)
{
    if (is_rewind(dev)) {
        return dev->head - dev->tail - 1;
    } else {
        return dev->len - dev->tail + dev->head - 1;
    }
}

/* 打开操作 */
static int kpipe_open(struct inode *inode, struct file *file)
{
    /* 由 inode 对应的字符设备指针得到 kpipe 设备的地址 */
    struct kpipe_dev *dev = container_of(inode->i_cdev,
            struct kpipe_dev, cdev);
    pr_debug("kpipe_open: be called!\n");
    /* 将 kpipe 设备的地址保存在打开的文件中 */
    file->private_data = dev;
    /* 返回 0 表示打开成功 */
    return 0;
}

/* 关闭操作 */
static int kpipe_release(struct inode *inode, struct file *file)
{
    pr_debug("kpipe_release: be called!\n");
    /* 无操作，返回 0 表示成功 */
    return 0;
}

/* 读操作 */
static ssize_t kpipe_read(struct file *file, char __user *buf,
        size_t count, loff_t *pos)
{
    int err; /* 用于暂存错误码 */
    int bytes; /* 用于保存读取的字节数 */
    /* 从 file 中得到对应的 kpipe 设备 */
    struct kpipe_dev *dev = (struct kpipe_dev *)file->private_data;
    pr_debug("kpipe_read: count = %d.\n", count);
    /* 参数合法性检查 */
    if (count < 0) return -EINVAL; /* 非法参数 */
    if (count == 0) return 0; /* 直接返回 0 */
    if (is_empty(dev)) { /* 缓冲区为空 */
        /* 非阻塞方式下返回 -EAGAIN */
        if (file->f_flags & O_NONBLOCK) return -EAGAIN;
        /* 等待直到缓冲区不空 */
        err = wait_event_interruptible(dev->rq, !is_empty(dev));
        /* 发生信号则返回 -EINTR */
        if (err == -ERESTARTSYS) return -EINTR;
    }
    /* 以下进入临界区，不允许多个进程同时修改头尾指针 */
    mutex_lock(&dev->lock); /* 加锁 */
    /* 限制读取的个数不超过缓冲区中数据的个数 */
    if (count > nr_bytes(dev)) count = nr_bytes(dev);
    bytes = 0; /* 已读取的字节数为 0 */
    if (is_rewind(dev) && count > dev->len-dev->head) {
        /* 读取的区域经过缓冲区末尾，需要读两次 */
        bytes = dev->len-dev->head; /* 计算要读取的字节数 */
        if (copy_to_user(buf, dev->buf+dev->head, bytes) > 0) {
            pr_debug("kpipe_read: copy_to_user() FAILED!\n");
            return -EFAULT;
        }
        dev->head = 0; /* 重设头指针使后续的读取从头开始 */
    }
    /* 如果是第二次读，目标地址应后移 bytes, 读取个数减少 bytes */
    if (copy_to_user(buf+bytes, dev->buf+dev->head, count-bytes) > 0) {
        pr_debug("kpipe_read: copy_to_user() FAILED!\n");
        return -EFAULT;
    }
    /* 更新头指针位置 */
    dev->head += count-bytes;
    mutex_unlock(&dev->lock); /* 解锁 */
    /* 唤醒写操作阻塞的进程 */
    wake_up_interruptible(&dev->wq);
    return count;
}

/* 写操作 */
static ssize_t kpipe_write(struct file *file, const char __user *buf,
        size_t count, loff_t *pos)
{
    int err; /* 用于暂存错误码 */
    int bytes; /* 用于保存写入的字节数 */
    /* 从 file 中得到对应的 kpipe 设备 */
    struct kpipe_dev *dev = (struct kpipe_dev *)file->private_data;
    pr_debug("kpipe_write: count = %d.\n", count);
    /* 参数合法性检查 */
    if (count < 0) return -EINVAL; /* 非法参数 */
    if (count == 0) return 0; /* 直接返回 0 */
    if (is_full(dev)) {
        /* 非阻塞方式下返回 -EAGAIN */
        if (file->f_flags & O_NONBLOCK) return -EAGAIN;
        /* 等待直到缓冲区不满 */
        err = wait_event_interruptible(dev->wq, !is_full(dev));
        /* 发生信号则返回 -EINTR */
        if (err == -ERESTARTSYS) return -EINTR;
    }
    /* 以下进入临界区，不允许多个进程同时修改头尾指针 */
    mutex_lock(&dev->lock); /* 加锁 */
    /* 限制写入的个数不超过缓冲区中空位的个数 */
    if (count > nr_holes(dev)) count = nr_holes(dev);
    bytes = 0; /* 已写入的字节数为 0 */
    if (!is_rewind(dev) && count > dev->len-dev->tail) {
        /* 写入的区域经过缓冲区末尾，需要写两次 */
        bytes = dev->len-dev->tail; /* 计算要写入的字节数 */
        if (copy_from_user(dev->buf+dev->tail, buf, bytes) > 0) {
            pr_debug("kpipe_read: copy_from_user() FAILED!\n");
            return -EFAULT;
        }
        dev->tail = 0; /* 重设尾指针使后续的写入从头开始 */
    }
    /* 如果是第二次写，目标地址应后移 bytes, 写入个数减少 bytes */
    if (copy_from_user(dev->buf+dev->tail, buf+bytes, count-bytes) > 0) {
        pr_debug("kpipe_read: copy_from_user() FAILED!\n");
        return -EFAULT;
    }
    /* 更新尾指针位置 */
    dev->tail += count-bytes;
    mutex_unlock(&dev->lock); /* 解锁 */
    /* 唤醒读操作阻塞的进程 */
    wake_up_interruptible(&dev->rq);
    return count;
}

/* 定位操作 */
static loff_t kpipe_llseek(struct file *file, loff_t offset, int whence)
{
    /* 因为 kpipe 设备类似于 FIFO, 没有读写位置的概念，故直接返回错误码 */
    return -ESPIPE;
}

/* 设备的文件操作，全局变量 */
static struct file_operations kpipe_fops = {
    .owner = THIS_MODULE, /* 所属模块 */
    .open = kpipe_open, /* 打开操作 */
    .release = kpipe_release, /* 关闭操作 */
    .read = kpipe_read, /* 读操作 */
    .write = kpipe_write, /* 写操作 */
    .llseek = kpipe_llseek, /* 定位操作 */
};

/* 全局变量，表示一个 kpipe 设备 */
static struct kpipe_dev kpipe;

/* 模块的初始化函数 */
static __init int kpipe_init(void)
{
    int err; /* 用于保存错误码 */
    pr_debug("kpipe_init: be called!\n");
    /* 初始化互斥体 */
    mutex_init(&kpipe.lock);
    /* 分配设备号 */
    if ((err = alloc_chrdev_region(&kpipe.dev, 0, 1, "kpipe")) < 0) {
        pr_debug("kpipe_init: alloc_chrdev_region() ERR = %d!\n", -err);
        goto alloc_chrdev_region_fail;
    }
    pr_debug("kpipe_init: dev = (%d, %d).\n",
            MAJOR(kpipe.dev), MINOR(kpipe.dev));
    /* 分配内核缓冲区 */
    if ((kpipe.buf = kmalloc(BUF_SIZE, GFP_KERNEL)) == NULL) {
        pr_debug("kpipe_init: kmalloc() ERR!\n");
        err = -ENOMEM; /* 此错误号表示内存不足 */
        goto kmalloc_kpipe_buf_fail;
    }
    /* 保存缓冲区的长度 */
    kpipe.len = BUF_SIZE;
    /* 初始化缓冲区头尾指针 */
    kpipe.head = 0;
    kpipe.tail = 0;
    /* 初始化等待队列 */
    init_waitqueue_head(&kpipe.rq);
    init_waitqueue_head(&kpipe.wq);
    /* 初始化字符设备 */
    cdev_init(&kpipe.cdev, &kpipe_fops);
    kpipe.cdev.owner = kpipe_fops.owner;
    /* 注册字符设备 */
    if ((err = cdev_add(&kpipe.cdev, kpipe.dev, 1)) < 0) {
        pr_debug("kpipe_init: cdev_add() ERR = %d!\n", -err);
        goto cdev_add_fail;
    }
    return 0; /* 返回 0 表示初始化成功 */
/* 以下为出错处理，各个清理操作按初始化时的倒序排列，出错时跳转到相应的位置，
 * 这是驱动编程中常用的做法 */
cdev_add_fail:
    kfree(kpipe.buf); /* 释放所分配的内存 */
kmalloc_kpipe_buf_fail:
    unregister_chrdev_region(kpipe.dev, 1); /* 注销所注册的设备号 */
alloc_chrdev_region_fail:
    mutex_destroy(&kpipe.lock); /* 销毁互斥体 */
    return err;
}
module_init(kpipe_init); /* 指定 kpipe_init 为模块的初始化函数 */

/* 模块的退出函数 */
static __exit void kpipe_exit(void)
{
    pr_debug("kpipe_exit: be called!\n");
    /* 模块退出时进行清理，按初始化时的倒序操作 */
    cdev_del(&kpipe.cdev); /* 注销字符设备 */
    kfree(kpipe.buf); /* 释放所分配的内存 */
    unregister_chrdev_region(kpipe.dev, 1); /* 注销所注册的设备号 */
    mutex_destroy(&kpipe.lock); /* 销毁互斥体 */
}
module_exit(kpipe_exit); /* 指定 kpipe_exit 为模块的退出函数 */