七、设备驱动中的阻塞与非阻塞 IO（二）
7.2 轮询
7.2.1 介绍
在用户程序中的 select() 和 poll() 函数最终会使设备驱动中的 poll() 函数被执行。
设备驱动程序中的轮询函数原型：
1 /** 用于询问设备是否可以非阻塞的读写。当询问条件未触发时，用户空间进行 select() 和 poll() 将引起进程阻塞 */ 2 unsigned int (*poll) (struct file *filp, struct poll_table_struct *wait);
- wait：轮询表指针。
- 这个函数应该进行两项工作：
- 对可能引起设备文件状态变化的等待队列调用 poll_wait() 函数，将对应的等待队列头部添加到 poll_table 中
- 返回表示是否能对设备进行无阻塞读、写访问的掩码
7.2.2 globalfifo 支持轮询
globalfifo.c
1 #include <linux/module.h> 2 #include <linux/fs.h> 3 #include <linux/init.h> 4 #include <linux/cdev.h> 5 #include <linux/slab.h> 6 #include <linux/uaccess.h> 7 #include <linux/mutex.h> 8 #include <linux/wait.h> 9 #include <linux/sched/signal.h> ///< 内核>5.0 使用 10 //#include <linux/sched.h> 11 #include <linux/poll.h> 12 13 #define GLOBALFIFO_SIZE 0x1000 14 #define MEM_CLEAR 0X1 15 //#define GLOBALFIFO_MAGIC 'g' 16 //#define MEM_CLEAR _IO(GLOBALFIFO_MAGIC, 0) 17 #define GLOBALFIFO_MAJOR 230 18 #define DEVICE_NUMBER 10 19 20 static int globalfifo_major = GLOBALFIFO_MAJOR; 21 module_param(globalfifo_major, int, S_IRUGO); 22 23 struct globalfifo_dev { 24 struct cdev cdev; 25 /** 26 * 目前 FIFO 中有效数据长度 27 * current_len = 0, 表示 FIFO 为空 28 * current_len = GLOBALFIFO_SIZE, 表示 FIFO 满 29 */ 30 unsigned int current_len; 31 unsigned char mem[GLOBALFIFO_SIZE]; 32 struct mutex mutex; 33 wait_queue_head_t r_wait; ///< 读等待队列头 34 wait_queue_head_t w_wait; ///< 写等待队列头 35 }; 36 37 struct globalfifo_dev *globalfifo_devp; 38 39 /** 40 * 这里涉及到私有数据的定义，大多数遵循将文件私有数据 pirvate_data 指向设备结构体， 41 * 再用 read write llseek ioctl 等函数通过 private_data 访问设备结构体。 42 * 对于此驱动而言，私有数据的设置是在 open 函数中完成的 43 */ 44 static int globalfifo_open(struct inode *inode, struct file *filp) 45 { 46 /** 47 * NOTA: 48 * container_of 的作用是通过结构体成员的指针找到对应结构体的指针。 49 * 第一个参数是结构体成员的指针 50 * 第二个参数是整个结构体的类型 51 * 第三个参数为传入的第一个参数(即结构体成员)的类型 52 * container_of 返回值为整个结构体指针 53 */ 54 struct globalfifo_dev *dev = container_of(inode->i_cdev, struct globalfifo_dev, cdev); 55 filp->private_data = dev; 56 return 0; 57 } 58 59 static int globalfifo_release(struct inode *inode, struct file *filp) 60 { 61 return 0; 62 } 63 64 static long globalfifo_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) 65 { 66 struct globalfifo_dev *dev = filp->private_data; 67 68 switch(cmd){ 69 case MEM_CLEAR: 70 mutex_lock(&dev->mutex); 71 memset(dev->mem, 0, GLOBALFIFO_SIZE); 72 printk(KERN_INFO "globalfifo is set to zero\n"); 73 mutex_unlock(&dev->mutex); 74 break; 75 default: 76 return -EINVAL; 77 } 78 79 return 0; 80 } 81 82 static unsigned int globalfifo_poll(struct file *filp, struct poll_table_struct *wait) 83 { 84 unsigned int mask = 0; 85 struct globalfifo_dev *dev = filp->private_data; 86 87 mutex_lock(&dev->mutex); 88 89 poll_wait(filp, &dev->r_wait, wait); 90 poll_wait(filp, &dev->w_wait, wait); 91 92 if(dev->current_len != 0) { 93 mask |= POLLIN | POLLRDNORM; 94 } 95 96 if(dev->current_len != GLOBALFIFO_SIZE){ 97 mask |= POLLIN | POLLWRNORM; 98 } 99 100 mutex_unlock(&dev->mutex); 101 return mask; 102 } 103 104 105 static loff_t globalfifo_llseek(struct file *filp, loff_t offset, int orig) 106 { 107 loff_t ret = 0; 108 switch(orig) { 109 case 0: /** 从文件开头位置 seek */ 110 if(offset < 0){ 111 ret = -EINVAL; 112 break; 113 } 114 if((unsigned int)offset > GLOBALFIFO_SIZE){ 115 ret = -EINVAL; 116 break; 117 } 118 filp->f_pos = (unsigned int)offset; 119 ret = filp->f_pos; 120 break; 121 case 1: /** 从文件当前位置开始 seek */ 122 if((filp->f_pos + offset) > GLOBALFIFO_SIZE){ 123 ret = -EINVAL; 124 break; 125 } 126 if((filp->f_pos + offset) < 0){ 127 ret = -EINVAL; 128 break; 129 } 130 filp->f_pos += offset; 131 ret = filp->f_pos; 132 break; 133 default: 134 ret = -EINVAL; 135 break; 136 } 137 138 return ret; 139 } 140 141 static ssize_t globalfifo_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos) 142 { 143 unsigned int count = size; 144 int ret = 0; 145 struct globalfifo_dev *dev = filp->private_data; 146 147 DECLARE_WAITQUEUE(wait, current); ///< 将当前进程加入到 wait 等待队列 148 mutex_lock(&dev->mutex); 149 add_wait_queue(&dev->w_wait, &wait); ///< 添加等待队列元到读队列头中 150 151 /** 判断设备是否可写 */ 152 while(dev->current_len == GLOBALFIFO_SIZE){ 153 /** 若是非阻塞访问, 设备忙时, 直接返回 -EAGAIN */ 154 if(filp->f_flags & O_NONBLOCK) { 155 ret = -EAGAIN; 156 goto out; 157 } 158 159 __set_current_state(TASK_INTERRUPTIBLE); ///<改变进程状态为睡眠 160 schedule(); 161 if(signal_pending(current)){ ///< 因为信号而唤醒 162 ret = -ERESTARTSYS; 163 goto out2; 164 } 165 } 166 167 if(count > GLOBALFIFO_SIZE - dev->current_len) 168 count = GLOBALFIFO_SIZE - dev->current_len; 169 170 if(copy_from_user(dev->mem + dev->current_len, buf, count)){ 171 ret = -EFAULT; 172 goto out; 173 } else { 174 dev->current_len += count; 175 printk(KERN_INFO "written %u bytes(s), current len:%d\n", count, dev->current_len); 176 177 wake_up_interruptible(&dev->r_wait); ///< 唤醒读等待队列 178 ret = count; 179 } 180 out: 181 mutex_unlock(&dev->mutex); 182 out2: 183 remove_wait_queue(&dev->w_wait, &wait); ///< 移除等待队列 184 set_current_state(TASK_RUNNING); 185 return ret; 186 } 187 188 /** 189 * *ppos 是要读的位置相对于文件开头的偏移，如果该偏移大于或等于 GLOBALFIFO_SIZE，意味着已经独到文件末尾 190 */ 191 static ssize_t globalfifo_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos) 192 { 193 unsigned int count = size; 194 int ret = 0; 195 struct globalfifo_dev *dev = filp->private_data; 196 197 DECLARE_WAITQUEUE(wait, current); ///< 将当前进程加入到 wait 等待队列 198 mutex_lock(&dev->mutex); 199 add_wait_queue(&dev->r_wait, &wait); ///< 添加等待队列元到读队列头中 200 201 /** 等待 FIFO 非空，即判断设备是否可读 */ 202 while(dev->current_len == 0) { 203 /** 若是非阻塞访问, 设备忙时, 直接返回 -EAGAIN */ 204 /** filp->f_flags 是用户空间 */ 205 if(filp->f_flags & O_NONBLOCK) { 206 ret = -EAGAIN; 207 goto out; 208 } 209 210 /** 211 * 阻塞访问，调度其他进程执行 212 * FIFO 为空的情况下，读进程阻塞，必须依赖写进程往 FIFO 里面写东西唤醒它； 213 * 但写的进程为了 FIFO，它必须拿到这个互斥体来访问 FIFO 这个临界资源； 214 * 如果读进程把自己调度出去之前不释放这个互斥体，那么读写进程之间就死锁了 215 */ 216 __set_current_state(TASK_INTERRUPTIBLE); ///<改变进程状态为睡眠 217 mutex_unlock(&dev->mutex); 218 schedule(); 219 if(signal_pending(current)){ ///< 因为信号而唤醒 220 ret = -ERESTARTSYS; 221 goto out2; 222 } 223 224 mutex_lock(&dev->mutex); 225 } 226 227 /** 要读取的字节数大于设备文件中的有效数据长度 */ 228 if(count > dev->current_len) 229 count = dev->current_len; 230 231 /** 从用户空间拷贝数据 */ 232 if(copy_to_user(buf, dev->mem, count)) { 233 ret = -EFAULT; 234 goto out; 235 } else { 236 /** FIFO 中数据前移 */ 237 memcpy(dev->mem, dev->mem + count, dev->current_len - count); 238 dev->current_len -= count; ///< 有效数据长度减少 239 printk(KERN_INFO "read %u bytes(s), current_len: %d\n", count, dev->current_len); 240 241 wake_up_interruptible(&dev->w_wait); ///< 唤醒写等待队列 242 243 ret = count; 244 } 245 out: 246 mutex_unlock(&dev->mutex); 247 out2: 248 remove_wait_queue(&dev->r_wait, &wait); ///< 移除等待队列 249 set_current_state(TASK_RUNNING); 250 return ret; 251 } 252 253 static const struct file_operations globalfifo_fops = { 254 .owner = THIS_MODULE, 255 .poll = globalfifo_poll, 256 .llseek = globalfifo_llseek, 257 .read = globalfifo_read, 258 .write = globalfifo_write, 259 .unlocked_ioctl = globalfifo_ioctl, 260 .open = globalfifo_open, 261 .release = globalfifo_release, 262 }; 263 264 265 /** 266 * @brief globalfifo_setup_cdev 267 * 268 * @param dev 269 * @param index 次设备号 270 */ 271 static void globalfifo_setup_cdev(struct globalfifo_dev *dev, int index) 272 { 273 int err; 274 int devno = MKDEV(globalfifo_major, index); 275 276 /** 使用 cdev_init 即是静态初始化了 cdev */ 277 cdev_init(&dev->cdev, &globalfifo_fops); 278 dev->cdev.owner = THIS_MODULE; 279 280 /** 设备编号范围设置为1，表示我们只申请了一个设备 */ 281 err = cdev_add(&dev->cdev, devno, 1); 282 if(err) 283 printk(KERN_NOTICE "Error %d adding globalfifo%d\n", err, index); 284 } 285 286 static int __init globalfifo_init(void) 287 { 288 int ret; 289 int i; 290 dev_t devno = MKDEV(globalfifo_major, 0); 291 292 if(globalfifo_major) 293 ret = register_chrdev_region(devno, DEVICE_NUMBER, "globalfifo"); 294 else { 295 ret = alloc_chrdev_region(&devno, 0, DEVICE_NUMBER, "globalfifo"); 296 globalfifo_major = MAJOR(devno); 297 } 298 299 if(ret < 0) 300 return ret; 301 302 globalfifo_devp = kzalloc(sizeof(struct globalfifo_dev), GFP_KERNEL); 303 if(!globalfifo_devp){ 304 ret = -ENOMEM; 305 goto fail_malloc; 306 } 307 308 for(i = 0; i < DEVICE_NUMBER; i++){ 309 globalfifo_setup_cdev(globalfifo_devp + i, i); 310 } 311 312 mutex_init(&globalfifo_devp->mutex); 313 314 /** 初始化读写等待队列 */ 315 init_waitqueue_head(&globalfifo_devp->r_wait); 316 init_waitqueue_head(&globalfifo_devp->w_wait); 317 318 fail_malloc: 319 unregister_chrdev_region(devno, 1); 320 return ret; 321 } 322 323 static void __exit globalfifo_exit(void) 324 { 325 int i; 326 for(i = 0; i < DEVICE_NUMBER; i++) { 327 cdev_del(&(globalfifo_devp + i)->cdev); 328 } 329 kfree(globalfifo_devp); 330 unregister_chrdev_region(MKDEV(globalfifo_major, 0), DEVICE_NUMBER); 331 } 332 333 module_init(globalfifo_init); 334 module_exit(globalfifo_exit);
epoll_test.c
1 } 2 3 epfd = epoll_create(1); 4 if(epfd < 0) { 5 perror("epoll_create()"); 6 return ; 7 } 8 9 bzero(&ev_globalfifo, sizeof(struct epoll_event)); 10 ev_globalfifo.events = EPOLLIN | EPOLLPRI; 11 err = epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev_globalfifo); 12 if(err < 0) { 13 perror("epoll_ctl()"); 14 return ; 15 } 16 err = epoll_wait(epfd, &ev_globalfifo, 1, 15000); 17 if(err < 0) { 18 perror("epoll_wait()"); 19 } else if(err == 0) { 20 printf("No data input in FIFO within 15 seconds.\n"); 21 } else { 22 printf("FIFO is not empty.\n"); 23 } 24 25 err = epoll_ctl(epfd, EPOLL_CTL_DEL, fd, &ev_globalfifo); 26 if(err < 0) { 27 perror("epoll_ctl()"); 28 return ; 29 } 30 31 return; 32 33 }
Makefile
1 .PHONY:all clean test 2 3 TEST_SRC := poll_test.c 4 TEST_TARGET := poll_test 5 6 ifneq ($(KERNELRELEASE),) 7 8 obj-m := globalfifo.o 9 10 else 11 LINUX_KERNEL := $(shell uname -r) 12 LINUX_KERNEL_PATH := /usr/src/linux-headers-$(LINUX_KERNEL) 13 CURRENT_PATH := $(shell pwd) 14 EXTRA_CFLAGS += -DDEBUG 15 16 all: 17 make -C $(LINUX_KERNEL_PATH) M=$(CURRENT_PATH) modules 18 clean: 19 rm -fr *.ko *.o *.mod.o *.mod.c *.symvers *.order .*.ko *.cmd .tmp_versions $(TEST_TARGET) 20 21 test: 22 gcc -o $(TEST_TARGET) $(TEST_SRC) 23 endif
