免费注册 查看新帖 |

Chinaunix

  平台 论坛 博客 文库
› 论坛 › 操作系统 › 移动操作系统 › 字符驱动学习二（阻塞I/O）
最近访问板块 发新帖
查看: 857 | 回复: 0
打印 上一主题 下一主题

字符驱动学习二（阻塞I/O） [复制链接]

chituhuan

论坛徽章:
0
跳转到指定楼层
1楼 [收藏(0)] [报告]
发表于 2011-12-21 08:41 |只看该作者 |倒序浏览
     上次调试好了一个基本的字符驱动，支持并发控制。在实际的使用中，read 和 write 系统调用要支持阻塞访问的。这次使用等待队列实现阻塞。在实现阻塞的代码中涉及进程调度的内容。下面是read和write 函数：

  1. static ssize_t cfifo_read(struct file *filp, char __user *buf, size_t count, loff_t *fpos)
  2.     62    {
  3.     63        int ret = 0;
  4.     64        struct cfifo_t *dev = filp->private_data;
  5.     65        DECLARE_WAITQUEUE(wait, current);
  6.     66    
  7.     67        down(&dev->sem);
  8.     68        add_wait_queue(&dev->r_wait, &wait);
  9.     69    
  10.     70        while(dev->current_len == 0){
  11.     71            if(filp->f_flags & O_NONBLOCK){
  12.     72                ret = -EAGAIN;
  13.     73                goto out;
  14.     74            }
  15.     75    
  16.     76            __set_current_state(TASK_INTERRUPTIBLE);
  17.     77            up(&dev->sem);
  18.     78    
  19.     79            schedule(); /*调度其他进程运行*/
  20.     80            if(signal_pending(current)){
  21.     81                ret = -ERESTARTSYS;
  22.     82                goto out2;
  23.     83            }
  24.     84    
  25.     85            down(&dev->sem);
  26.     86        }
  27.     87    
  28.     88        if(count > dev->current_len)
  29.     89            count = dev->current_len;
  30.     90    
  31.     91        if(copy_to_user(buf, (void*)(dev->mem), count)){
  32.     92            ret = -EFAULT;
  33.     93            goto out;
  34.     94        } else{
  35.     95            memcpy(dev->mem, dev->mem + count, dev->current_len - count);
  36.     96            dev->current_len -= count;
  37.     97            *fpos =dev->current_len;
  38.     98    
  39.     99            wake_up_interruptible(&dev->w_wait);
  40.    100            ret =count;
  41.    101    
  42.    102            printk(KERN_INFO "read %s %d bites \n", buf, count);
  43.    103        }
  44.    104    
  45.    105    out:
  46.    106        up(&dev->sem);
  47.    107    out2:
  48.    108        remove_wait_queue(&dev->r_wait, &wait);
  49.    109        set_current_state(TASK_RUNNING);
  50.    110    
  51.    111        return ret;
  52.    112    }
  53.    113
  1. static ssize_t cfifo_write(struct file *filp, const char __user *buf, size_t count, loff_t *fpos)
  2.    115    {
  3.    116        int ret = 0;
  4.    117        struct cfifo_t *dev = filp->private_data;
  5.    118        DECLARE_WAITQUEUE(wait, current);
  6.    119    
  7.    120        down(&dev->sem);
  8.    121        add_wait_queue(&dev->w_wait, &wait);
  9.    122    
  10.    123        while(dev->current_len >= GLOBALMEM_SIZE){
  11.    124            if(filp->f_flags & O_NONBLOCK){             
  12.    125                ret = -EAGAIN;
  13.    126                goto out;
  14.    127            }
  15.    128    
  16.    129            __set_current_state(TASK_INTERRUPTIBLE);    /* 进程状态，定义在 linux/sched.h */
  17.    130            up(&dev->sem);                              /* 释放信号量，避免死锁 */
  18.    131    
  19.    132            schedule();                                 /* 调度其他进程运行*/
  20.    133            if(signal_pending(current)){                
  21.    134                ret = -ERESTARTSYS;
  22.    135                goto out2;
  23.    136            }
  24.    137    
  25.    138            down(&dev->sem);
  26.    139        }
  27.    140    
  28.    141        if(count > GLOBALMEM_SIZE - dev->current_len)
  29.    142            count = GLOBALMEM_SIZE - dev->current_len;
  30.    143    
  31.    144    
  32.    145        if(copy_from_user(dev->mem+dev->current_len, buf, count)){
  33.    146            ret = - EFAULT;
  34.    147            goto out;
  35.    148        }
  36.    149        else{
  37.    150            dev->current_len += count;
  38.    151            *fpos = dev->current_len;
  39.    152            ret = count;
  40.    153    
  41.    154            wake_up_interruptible(&dev->r_wait);
  42.    155            printk(KERN_INFO "write %s %d bites \n", buf, count);
  43.    156        }
  44.    157    
  45.    158    out:
  46.    159        up(&dev->sem);
  47.    160    out2:
  48.    161        remove_wait_queue(&dev->w_wait, &wait);
  49.    162        set_current_state(TASK_RUNNING);
  50.    163    
  51.    164        return ret;
  52.    165    }
  开始读，这时设备中没有内容，read函数会阻塞在79行。然后向设备中写入内容，write函数运行到154行时，会唤醒写的进程，和65行代码有关

  1. DECLARE_WAITQUEUE(wait, current)
下面是验证：
  1. root@wang:/work/wanghuan/drives# ls
  2. cdev.c cfifo.c cfifo.ko Makefile modules.order
  3. root@wang:/work/wanghuan/drives# insmod cfifo.ko
  4. root@wang:/work/wanghuan/drives# ls /dev/cfifo*
  5. /dev/cfifo0 /dev/cfifo1
  6. root@wang:/work/wanghuan/drives# cat /dev/cfifo0 &
  7. [1] 2889
  8. root@wang:/work/wanghuan/drives# ps
  9.   PID TTY TIME CMD
  10.  2046 pts/0 00:00:00 bash
  11.  2889 pts/0 00:00:00 cat
  12.  2890 pts/0 00:00:00 ps
  13. root@wang:/work/wanghuan/drives# ls > /dev/cfifo0
  14. cdev.c
  15. cfifo.c
  16. cfifo.ko
  17. Makefile
  18. modules.order
  19. root@wang:/work/wanghuan/drives# ls > /dev/cfifo1
  20. cdev.c
  21. cfifo.c
  22. cfifo.ko
  23. Makefile
  24. modules.order
  25. root@wang:/work/wanghuan/drives
下面是完整的源码：
  1. /**
  2.  * =====================================================================================
  3.  * Filename: cfifo.c
  4.  * Description: 字符设备驱动模型 阻塞I/O
  5.  * Version: 1.0
  6.  * Created: 2011年06月12日 17时19分50秒
  7.  * Revision: none
  8.  * Compiler: gcc
  9.  *
  10.  * Author: wanghuan,
  11.  * Company:
  12.  * =====================================================================================
  13.  */

  15. #include <linux/module.h>
  16. #include <linux/types.h>
  17. #include <linux/fs.h>         /* file_operation */
  18. #include <linux/errno.h>     /* Error number */
  19. #include <linux/mm.h>    
  20. #include <linux/sched.h>    
  21. #include <linux/slab.h>    
  22. #include <linux/init.h>     /* __init __exit */
  23. #include <linux/device.h>
  24. #include <linux/cdev.h>    
  25. #include <asm/io.h>    
  26. #include <asm/system.h>    
  27. #include <asm/uaccess.h>     /* copy_to_user, copy_from_user */
  28. #include <linux/kernel.h>     /* printk() */

  30. #define GLOBALMEM_SIZE 0x1000
  31. #define MEM_CLEAN 0x1
  32. #define DEV_NAME "cfifo"
  33. #define MEM_CLEAR _IO(GLOBALMEM_SIZE, 0)

  35. static int MAJOR_NR = 255;        /* Driver Major Number */
  36. //static int MINOR_NR = 0;        /* Driver Major Number */

  38. struct cfifo_t{
  39.     struct cdev cdev;
  40.     unsigned char mem[GLOBALMEM_SIZE];
  41.     struct semaphore sem;

  43.     unsigned int current_len;
  44.     wait_queue_head_t r_wait;
  45.     wait_queue_head_t w_wait;
  46. };
  47. static struct cfifo_t *cfifo_p;

  49. static int cfifo_open(struct inode *inode, struct file *filp)
  50. {
  51.     struct cfifo_t *dev;
  52.     dev = container_of(inode->i_cdev, struct cfifo_t, cdev);
  53.     filp->private_data = dev;
  54.     return 0;
  55. }
  56. static int cfifo_release(struct inode *inode, struct file *filp)
  57. {
  58.     filp->private_data = NULL;
  59.     return 0;
  60. }
  61. static ssize_t cfifo_read(struct file *filp, char __user *buf, size_t count, loff_t *fpos)
  62. {
  63.     int ret = 0;
  64.     struct cfifo_t *dev = filp->private_data;
  65.     DECLARE_WAITQUEUE(wait, current);
  66.     
  67.     down(&dev->sem);
  68.     add_wait_queue(&dev->r_wait, &wait);

  70.     while(dev->current_len == 0){
  71.         if(filp->f_flags & O_NONBLOCK){
  72.             ret = -EAGAIN;
  73.             goto out;
  74.         }

  76.         __set_current_state(TASK_INTERRUPTIBLE);
  77.         up(&dev->sem);

  79.         schedule(); /*调度其他进程运行*/
  80.         if(signal_pending(current)){
  81.             ret = -ERESTARTSYS;
  82.             goto out2;
  83.         }

  85.         down(&dev->sem);
  86.     }

  88.     if(count > dev->current_len)
  89.         count = dev->current_len;

  91.     if(copy_to_user(buf, (void*)(dev->mem), count)){
  92.         ret = -EFAULT;
  93.         goto out;
  94.     } else{
  95.         memcpy(dev->mem, dev->mem + count, dev->current_len - count);
  96.         dev->current_len -= count;
  97.         *fpos =dev->current_len;

  99.         wake_up_interruptible(&dev->w_wait);
  100.         ret =count;

  102.         printk(KERN_INFO "read %s %d bites \n", buf, count);
  103.     }

  105. out:
  106.     up(&dev->sem);
  107. out2:
  108.     remove_wait_queue(&dev->r_wait, &wait);
  109.     set_current_state(TASK_RUNNING);

  111.     return ret;
  112. }

  114. static ssize_t cfifo_write(struct file *filp, const char __user *buf, size_t count, loff_t *fpos)
  115. {
  116.     int ret = 0;
  117.     struct cfifo_t *dev = filp->private_data;
  118.     DECLARE_WAITQUEUE(wait, current);

  120.     down(&dev->sem);
  121.     add_wait_queue(&dev->w_wait, &wait);

  123.     while(dev->current_len >= GLOBALMEM_SIZE){
  124.         if(filp->f_flags & O_NONBLOCK){
  125.             ret = -EAGAIN;
  126.             goto out;
  127.         }

  129.         __set_current_state(TASK_INTERRUPTIBLE); /* 进程状态，定义在 linux/sched.h */
  130.         up(&dev->sem); /* 释放信号量，避免死锁 */

  132.         schedule(); /* 调度其他进程运行*/
  133.         if(signal_pending(current)){
  134.             ret = -ERESTARTSYS;
  135.             goto out2;
  136.         }

  138.         down(&dev->sem);
  139.     }

  141.     if(count > GLOBALMEM_SIZE - dev->current_len)
  142.         count = GLOBALMEM_SIZE - dev->current_len;


  145.     if(copy_from_user(dev->mem+dev->current_len, buf, count)){
  146.         ret = - EFAULT;
  147.         goto out;
  148.     }
  149.     else{
  150.         dev->current_len += count;
  151.         *fpos = dev->current_len;
  152.         ret = count;

  154.         wake_up_interruptible(&dev->r_wait);
  155.         printk(KERN_INFO "write %s %d bites \n", buf, count);
  156.     }

  158. out:
  159.     up(&dev->sem);
  160. out2:
  161.     remove_wait_queue(&dev->w_wait, &wait);
  162.     set_current_state(TASK_RUNNING);

  164.     return ret;
  165. }

  167. static loff_t cfifo_llseek(struct file *filp, loff_t offset, int orig)
  168. {
  169.     loff_t ret;
  170.     switch(orig){
  171.         case 0:
  172.             if(offset < 0){
  173.                 ret = -EFAULT;
  174.                 break;
  175.             }
  176.             if((unsigned int)offset > GLOBALMEM_SIZE){
  177.                 ret = -EFAULT;
  178.                 break;
  179.             }

  181.             filp->f_pos = (unsigned int)offset;
  182.             ret = filp->f_pos;
  183.             break;
  184.         case 1:
  185.             if(filp->f_pos + offset > GLOBALMEM_SIZE){
  186.                 ret = -EFAULT;
  187.                 break;
  188.             }

  190.             if(filp->f_pos + offset < 0){
  191.                 ret = -EFAULT;
  192.                 break;
  193.             }

  195.             filp->f_pos += offset;
  196.             ret = filp->f_pos;
  197.             break;
  198.         default:
  199.             ret = -EFAULT;
  200.     }
  201.     return ret;
  202. }

  204. static int cfifo_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
  205. {
  206.     struct cfifo_t *dev = filp->private_data;
  207.     switch(cmd){
  208.         case MEM_CLEAR:
  209.             if(down_interruptible(&dev->sem))
  210.                 return -ERESTARTSYS;

  212.             memset(dev->mem, 0, GLOBALMEM_SIZE);

  214.             up(&dev->sem);
  215.             printk(KERN_INFO "globalmem is set to zero \n");
  216.             break;
  217.         default:
  218.             return -EINVAL;
  219.     }

  221.     return 0;
  222. }

  224. static const struct file_operations cfifo_fops = {
  225.     .owner = THIS_MODULE,
  226.     .open = cfifo_open,
  227.     .release = cfifo_release,
  228.     .read = cfifo_read,
  229.     .write = cfifo_write,
  230.     .ioctl = cfifo_ioctl,
  231.     .llseek = cfifo_llseek,
  232. };

  234. static void cfifo_setup_cdev(struct cfifo_t *cfifo_cdev, int minor)
  235. {
  236.     int err;
  237.     dev_t devno = MKDEV(MAJOR_NR, minor);
  238.     
  239.     cdev_init(&cfifo_cdev->cdev, &cfifo_fops);
  240.     cfifo_p->cdev.owner = THIS_MODULE;
  241.     err = cdev_add(&cfifo_cdev->cdev, devno, 1);
  242.     if(err != 0)
  243.         printk(KERN_NOTICE "Error %d adding gmen", err);

  245.     cfifo_cdev->current_len = 0;
  246.     init_MUTEX(&cfifo_cdev->sem);
  247.     init_waitqueue_head(&cfifo_cdev->r_wait);
  248.     init_waitqueue_head(&cfifo_cdev->w_wait);
  249. }

  251. static struct class *cdev_class;
  252. static int __init cfifo_cdev_init(void)
  253. {
  254.     int result;
  255.     dev_t devno = MKDEV(MAJOR_NR, 0);

  257.     if(0 != MAJOR_NR){
  258.         result = register_chrdev_region(devno, 1, DEV_NAME); //注册设备 支持两个设备，此设备号从0开始
  259.     } else {
  260.         result = alloc_chrdev_region(&devno, 0, 1, DEV_NAME);
  261.         MAJOR_NR = MAJOR(devno);
  262.     }

  264.     printk(KERN_CRIT"hello cfifo\n");
  265.     if(result < 0)
  266.         return result;

  268.     cfifo_p = kmalloc(2*sizeof(struct cfifo_t), GFP_KERNEL);
  269.     if(NULL == cfifo_p){
  270.         unregister_chrdev_region(MKDEV(MAJOR_NR, 0), 1);
  271.         result = -ENOMEM;
  272.     }

  274.     memset(cfifo_p, 0, 1*sizeof(struct cfifo_t));
  275.     cfifo_setup_cdev(&cfifo_p[0], 0);
  276.     cfifo_setup_cdev(&cfifo_p[0], 1);

  278.     cdev_class = class_create(THIS_MODULE, DEV_NAME);
  279.     if(IS_ERR(cdev_class))
  280.         return PTR_ERR(cdev_class);

  282.     device_create(cdev_class, NULL, MKDEV(MAJOR_NR, 0),    NULL, DEV_NAME"%d", 0);
  283.     device_create(cdev_class, NULL, MKDEV(MAJOR_NR, 1),    NULL, DEV_NAME"%d", 1);
  284.     return 0;
  285. }

  287. void cfifo_cdev_exit(void)
  288. {
  289.     cdev_del(&cfifo_p[0].cdev);
  290.     cdev_del(&cfifo_p[0].cdev);

  292.     device_destroy(cdev_class, MKDEV(MAJOR_NR, 0)); //delete device node under /dev
  293.     device_destroy(cdev_class, MKDEV(MAJOR_NR, 1)); //delete device node under /dev
  294.     class_destroy(cdev_class); //delete class created by us

  296.     kfree(cfifo_p);
  297.     unregister_chrdev_region(MKDEV(MAJOR_NR, 0), 1); //由于注册了两个设备，最后一个参数为 2
  298. }

  300. module_init(cfifo_cdev_init);
  301. module_exit(cfifo_cdev_exit);
  302. MODULE_LICENSE("GPL");
  303. MODULE_AUTHOR("wanghuan");

Makefile：
  1. #===============================================================================
  2. # Filename: Makefile
  3. # Description:
  4. #
  5. # Author: wanghuan
  6. # Company:
  7. #
  8. #==============================================================================

  10. obj-m :=cfifo.o #目标文件
  11. KDIR :=/lib/modules/2.6.35-22-generic/build #内核路径
  12. PWD := $(shell pwd) #模块源文件路径
  13. all:    
  14.     $(MAKE) -C $(KDIR) SUBDIRS=$(PWD) modules
  15.     @rm -rf *.mod.*
  16.     @rm -rf .*.cmd
  17.     @rm -rf *.o
  18.     @rm -rf Module.*
  19.     chmod a+x cfifo.ko
  20. clean:
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则 发表回复

  

北京盛拓优讯信息技术有限公司. 版权所有 京ICP备16024965号-6 北京市公安局海淀分局网监中心备案编号：11010802020122 niuxiaotong@pcpop.com 17352615567
未成年举报专区
中国互联网协会会员  联系我们：huangweiwei@itpub.net
感谢所有关心和支持过ChinaUnix的朋友们 转载本站内容请注明原作者名及出处

清除 Cookies - ChinaUnix - Archiver - WAP - TOP