blocking and unblocking mechanism for linux drivern code

概念：

1> 阻塞操作      是指在执行设备操作时，若不能获得资源，则挂起进程直到满足操作条件后再进行操作。被挂起的进程进入休眠，被从调度器移走，直到条件满足；

2> 非阻塞操作  在不能进行设备操作时，并不挂起，它或者放弃，或者不停地查询，直到可以进行操作。非阻塞应用程序通常使用select系统调用查询是否可以对设备进行无阻塞的访问最终会引发设备驱动中poll函数执行。

 
  1 /*
  * Theme for understanding the blocking and unblocking mechanism in device
  * driven module and difference of both modes
  *
  * Two aspects should be considered,firstly, when reading process is proceeding,
  * data must be existed in FIFO. Secconly, FIFO is non-full is prerequisite for
  * the writing process.
  *
  *Copyright (C) Continential- weizhen.diao@conti.engineering.com
  *
  */
 
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/sched.h>
 #include <linux/init.h>
 #include <linux/cdev.h>
 #include <linux/slab.h>
 #include <linux/poll.h>
 
 #define conti_globalfifo_SIZE    0x1000
 #define FIFO_CLEAR 0x1
 
 /*major devive number*/
 #define conti_globalfifo_MAJOR 231          
 
 static int conti_globalfifo_major = conti_globalfifo_MAJOR;
 module_param(conti_globalfifo_major, int, S_IRUGO);
 
 /*conti_globalfifo device struct*/
 struct conti_globalfifo_dev {
     struct cdev cdev;
     unsigned int current_len;
     unsigned char mem[conti_globalfifo_SIZE];
     struct mutex mutex;          //signal for concurrency control
     wait_queue_head_t r_wait;    //list of kernel bidirectional loops for blocking reading
     wait_queue_head_t w_wait;    //list of kernel bidirectional loops for blocking writing
 };
 
 struct conti_globalfifo_dev *conti_globalfifo_devp;
 
 static int conti_globalfifo_open(struct inode *inode, struct file *filp)
 {
     filp->private_data = conti_globalfifo_devp;
     return ;
 }
 
 static int conti_globalfifo_release(struct inode *inode, struct file *filp)
 {
     return ;
 }
 
 static long conti_globalfifo_ioctl(struct file *filp, unsigned int cmd,
                  unsigned long arg)
 {
     struct conti_globalfifo_dev *dev = filp->private_data;
 
     switch (cmd) {
     case FIFO_CLEAR:
         mutex_lock(&dev->mutex);
         dev->current_len = ;
         memset(dev->mem, , conti_globalfifo_SIZE);
         mutex_unlock(&dev->mutex);
 
         printk(KERN_INFO "conti_globalfifo is set to zero\n");
         break;
 
     default:
         return -EINVAL;
     }
     return ;
 }
 
 static unsigned int conti_globalfifo_poll(struct file *filp, poll_table * wait)
 {
     unsigned int mask = ;
     struct conti_globalfifo_dev *dev = filp->private_data;
 
     mutex_lock(&dev->mutex);
 
     poll_wait(filp, &dev->r_wait, wait);
     poll_wait(filp, &dev->w_wait, wait);
 
     if (dev->current_len != ) {
         mask |= POLLIN | POLLRDNORM;
     }
 
     if (dev->current_len != conti_globalfifo_SIZE) {
         mask |= POLLOUT | POLLWRNORM;
     }
 
     mutex_unlock(&dev->mutex);
     return mask;
 }
 
 static ssize_t conti_globalfifo_read(struct file *filp, char __user *buf,
                    size_t count, loff_t *ppos)
 {
     int ret;
     struct conti_globalfifo_dev *dev = filp->private_data;
     DECLARE_WAITQUEUE(wait, current);  
 
     mutex_lock(&dev->mutex);
     add_wait_queue(&dev->r_wait, &wait);
 
     while (dev->current_len == ) {
         if (filp->f_flags & O_NONBLOCK) {
             ret = -EAGAIN;
             goto out;
         }
         __set_current_state(TASK_INTERRUPTIBLE);
         mutex_unlock(&dev->mutex);
 
         schedule();
         if (signal_pending(current)) {
             ret = -ERESTARTSYS;
             goto out2;
         }
 
         mutex_lock(&dev->mutex);
     }
 
     if (count > dev->current_len)
         count = dev->current_len;
 
     if (copy_to_user(buf, dev->mem, count)) {
         ret = -EFAULT;
         goto out;
     } else {
         memcpy(dev->mem, dev->mem + count, dev->current_len - count);
         dev->current_len -= count;
         printk(KERN_INFO "read %d bytes(s),current_len:%d\n", count,
                dev->current_len);
 
         wake_up_interruptible(&dev->w_wait);
 
         ret = count;
     }
  out:
     mutex_unlock(&dev->mutex);
  out2:
     remove_wait_queue(&dev->w_wait, &wait);
     set_current_state(TASK_RUNNING);
     return ret;
 }
 
 static ssize_t conti_globalfifo_write(struct file *filp, const char __user *buf,
                 size_t count, loff_t *ppos)
 {
     struct conti_globalfifo_dev *dev = filp->private_data;
     int ret;
     DECLARE_WAITQUEUE(wait, current);
 
     mutex_lock(&dev->mutex);
     add_wait_queue(&dev->w_wait, &wait);
 
     while (dev->current_len == conti_globalfifo_SIZE) {
         if (filp->f_flags & O_NONBLOCK) {
             ret = -EAGAIN;
             goto out;
         }
         __set_current_state(TASK_INTERRUPTIBLE);
 
         mutex_unlock(&dev->mutex);
 
         schedule();
         if (signal_pending(current)) {
             ret = -ERESTARTSYS;
             goto out2;
         }
 
         mutex_lock(&dev->mutex);
     }
 
     if (count > conti_globalfifo_SIZE - dev->current_len)
         count = conti_globalfifo_SIZE - dev->current_len;
 
     if (copy_from_user(dev->mem + dev->current_len, buf, count)) {
         ret = -EFAULT;
         goto out;
     } else {
         dev->current_len += count;
         printk(KERN_INFO "written %d bytes(s),current_len:%d\n", count,
                dev->current_len);
 
         wake_up_interruptible(&dev->r_wait);
 
         ret = count;
     }
 
  out:
     mutex_unlock(&dev->mutex);
  out2:
     remove_wait_queue(&dev->w_wait, &wait);
     set_current_state(TASK_RUNNING);
     return ret;
 }
 
 static const struct file_operations conti_globalfifo_fops = {
     .owner = THIS_MODULE,
     .read = conti_globalfifo_read,
     .write = conti_globalfifo_write,
     .unlocked_ioctl = conti_globalfifo_ioctl,
     .poll = conti_globalfifo_poll,
     .open = conti_globalfifo_open,
     .release = conti_globalfifo_release,
 };
 
 static void conti_globalfifo_setup_cdev(struct conti_globalfifo_dev *dev, int index)
 {
     int err, devno = MKDEV(conti_globalfifo_major, index);
 
     cdev_init(&dev->cdev, &conti_globalfifo_fops);
     dev->cdev.owner = THIS_MODULE;
     err = cdev_add(&dev->cdev, devno, );
     if (err)
         printk(KERN_NOTICE "Error %d adding conti_globalfifo%d", err, index);
 }
 
 static int __init conti_globalfifo_init(void)
 {
     int ret;
     dev_t devno = MKDEV(conti_globalfifo_major, );
 
     if (conti_globalfifo_major)
         ret = register_chrdev_region(devno, , "conti_globalfifo");
     else {
         ret = alloc_chrdev_region(&devno, , , "conti_globalfifo");
         conti_globalfifo_major = MAJOR(devno);
     }
     if (ret < )
         return ret;
 
     conti_globalfifo_devp = kzalloc(sizeof(struct conti_globalfifo_dev), GFP_KERNEL);
     if (!conti_globalfifo_devp) {
         ret = -ENOMEM;
         goto fail_malloc;
     }
 
     conti_globalfifo_setup_cdev(conti_globalfifo_devp, );
 
     mutex_init(&conti_globalfifo_devp->mutex);
     init_waitqueue_head(&conti_globalfifo_devp->r_wait);
     init_waitqueue_head(&conti_globalfifo_devp->w_wait);
 
     return ;
 
 fail_malloc:
     unregister_chrdev_region(devno, );
     return ret;
 }
 module_init(conti_globalfifo_init);
 
 static void __exit conti_globalfifo_exit(void)
 {
     cdev_del(&conti_globalfifo_devp->cdev);
     kfree(conti_globalfifo_devp);
     unregister_chrdev_region(MKDEV(conti_globalfifo_major, ), );
 }
 module_exit(conti_globalfifo_exit);
 
 MODULE_AUTHOR(" <Hemingway <weizhen.diao@conti.engineering.com>>");

 MODULE_LICENSE("GPL v2");