首页 手机软件 手机游戏 单机游戏 资讯文章 专题下载 游戏合集 文章合集 php下载 php教程 电脑软件
+ -
当前位置：首页 → 问答吧 → 一个简单字符驱动例子的问题

一个简单字符驱动例子的问题

时间：2010-11-20

来源：互联网

我写了一个简单的字符驱动，代码如下：
  1. /*一、功能：
  2. *测试自旋锁
  3. *这里，在open中使用了最简单的自旋锁。
  4. *添加自旋锁之后，对临界资源xxx_count的访问就只限一个进程
  5. *如果没有spinlock/spin_unlock那么，可能多个进程同时访问xxx_count.
  6. *例如这个例子中，a访问xxx_count确认是否进入if(xxx_count)，确认是不进入，在修改xxx_count前被b打断；
  7. *然后b也访问此时a还没修改的xxx_count,所以b也不进入，而这里本意是b要进入if分支的。
  8. *关于spinlock文档，参考内核源代码：Documentation/spinlocks.txt
  9. *在spinlock持有期间，进程一直占用cpu并不切换出去，这一点和信号不同。
  10.        

  12. *二、一般驱动简易使用说明：
  13. *1)编译
  14. *$make
  15. *2)插入模块
  16. *insmod simplespinlock.ko
  17. *可以通过"cat /proc/devices"得知设备的主从号码
  18. *3)创建设备文件
  19. *#mknod mytest c <主设备号> 0
  20. *4)卸载模块
  21. *rmmod simplespinlock

  23. *查看驱动信息：
  24. $modinfo simplespinlock.ko
  25. *
  26. *问题：
  27. *不知道为什么，使用echo good>/dev/mytest会循环打印write没有结束。
  28. */

  30. #include <linux/module.h>
  31. #include <linux/types.h>
  32. #include <linux/fs.h>
  33. #include <linux/errno.h>
  34. #include <linux/mm.h>
  35. #include <linux/sched.h>
  36. #include <linux/init.h>
  37. #include <linux/cdev.h>
  38. #include <asm/io.h>
  39. #include <asm/system.h>
  40. #include <asm/uaccess.h>

  42. /*+++使用自旋锁，必须包含这个头文件*/
  43. #include <linux/spinlock.h>


  46. #define simpledrv_SIZE 0x1000
  47. #define simpledrv_MAJOR 1025

  49. /*module info*/
  50. MODULE_LICENSE("Dual BSD/GPL");
  51. MODULE_AUTHOR("Quiet Heart");
  52. MODULE_DESCRIPTION("This is a simple spinlock module.");
  53. MODULE_ALIAS("spinlock module");

  55. /*simpledrv*/
  56. struct simpledrv_dev
  57. {
  58.         struct cdev cdev;
  59. };

  61. /*function*/
  62. int simpledrv_open(struct inode *inode, struct file *filp);
  63. int simpledrv_release(struct inode *inode, struct file *filp);
  64. static ssize_t simpledrv_read(struct file *filp, char __user *buf,
  65.                                                         size_t count, loff_t *ppos);
  66. static ssize_t simpledrv_write(struct file *filp, const char __user *buf,
  67.                                                         size_t count, loff_t *ppos);
  68. static loff_t simpledrv_llseek(struct file *filp, loff_t offset, int orig);
  69. static int simpledrv_ioctl(struct inode *inodep, struct file *filp,
  70.                                         unsigned int cmd, unsigned long arg);

  72. /*variable*/
  73. static int simpledrv_major = simpledrv_MAJOR;
  74. struct simpledrv_dev *devp;

  76. int xxx_count = 0;/*record the count of open*/
  77. spinlock_t count_lock;

  79. static const struct file_operations simpledrv_fops =
  80. {
  81.         .owner = THIS_MODULE,

  83.         .llseek = simpledrv_llseek,
  84.         .read = simpledrv_read,
  85.         .write = simpledrv_write,
  86.         .ioctl = simpledrv_ioctl,
  87.         .open = simpledrv_open,
  88.         .release = simpledrv_release,
  89. };


  92. /*impl*/
  93. int simpledrv_open(struct inode *inode, struct file *filp)
  94. {
  95.        
  96.         /*+++加锁，访问临界资源，释放锁*/
  97.         spin_lock(&count_lock);
  98.         if(xxx_count)
  99.         {
  100.                 spin_unlock(&count_lock);
  101.                 printk(KERN_ALERT "device is busy!\n");
  102.                 return - EBUSY;
  103.         }
  104.         ++xxx_count;
  105.         spin_unlock(&count_lock);
  106.         printk(KERN_ALERT "device open!\n");
  107.         filp->private_data = devp;
  108.         return 0;
  109. }

  111. int simpledrv_release(struct inode *inode, struct file *filp)
  112. {
  113.         /*+++加锁，访问临界资源，释放锁*/
  114.         spin_lock(&count_lock);
  115.         --xxx_count;
  116.         spin_unlock(&count_lock);
  117.         printk(KERN_ALERT "device close!\n");
  118.         return 0;
  119. }

  121. static ssize_t simpledrv_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
  122. {
  123.         printk(KERN_ALERT "read\n");

  125.         return 1;
  126. }

  128. static ssize_t simpledrv_write(struct file *filp, const char __user *buf, size_t count, loff_t *ppos)
  129. {
  130.         struct simpledrv_dev *dev;
  131.         dev = filp->private_data;
  132.         printk(KERN_ALERT "write!\n");

  134.         return 1;
  135. }

  137. static loff_t simpledrv_llseek(struct file *filp, loff_t offset, int orig)
  138. {
  139.         printk(KERN_ALERT "llseek!\n");
  140.         return 0;
  141. }

  143. static int simpledrv_ioctl(struct inode *inodep, struct file *filp, unsigned int cmd, unsigned long arg)
  144. {
  145.         struct simpledrv_dev *dev;
  146.         dev = filp->private_data;
  147.         printk(KERN_ALERT "ioctl!\n");

  149.         return 0;
  150. }

  152. int simpledrv_init(void)
  153. {
  154.         int result;
  155.         int err;
  156.         dev_t devno = MKDEV(simpledrv_major,0);

  158.         result = alloc_chrdev_region(&devno, 0,1, "simplespinlock");
  159.         simpledrv_major = MAJOR(devno);
  160.         if(result < 0)
  161.         {
  162.                 printk(KERN_ALERT "Error register simpledrv result:%d\n", result);
  163.                 return result;
  164.         }

  166.         devp = kmalloc(sizeof(struct simpledrv_dev),GFP_KERNEL);
  167.         if(!devp)
  168.         {
  169.                 result = -ENOMEM;
  170.                 unregister_chrdev_region(devno,1);
  171.                 return 0;
  172.         }
  173.         memset(devp, 0, sizeof(struct simpledrv_dev));

  175.         cdev_init(&devp->cdev, &simpledrv_fops);
  176.         devp->cdev.owner = THIS_MODULE;
  177.         err = cdev_add(&devp->cdev, devno, 1);
  178.         if(err)
  179.         {
  180.                 printk(KERN_ALERT "Error %d adding simpledrv", err);
  181.         }

  183.         /*other initialize*/
  184.         /*+++初始化自旋锁*/
  185.         spin_lock_init(&count_lock);
  186.         printk(KERN_ALERT "driver initialize!\n");
  187.         return 0;
  188. }

  190. void simpledrv_exit(void)
  191. {
  192.         cdev_del(&devp->cdev);

  194.         kfree(devp);
  195.         unregister_chrdev_region(MKDEV(simpledrv_major, 0), 1);
  196.         printk(KERN_ALERT "driver exit!\n");
  197. }

  199. module_init(simpledrv_init);
  200. module_exit(simpledrv_exit);
复制代码
但是，这个驱动有个严重的问题：
当我使用
mknod /dev/mytest c <major> <minor>
echo test /dev/mytest
的时候，查看dmesg发现,
1)没有open地方的log
2)总是不断的打印write!好象进入了死循环。
请问，这到底是怎么回事呢？
谢谢好心朋友的解答以及回复。^_^

作者: vaqeteart   发布时间: 2010-11-20

好长，看着太累了

作者: EZWORD   发布时间: 2010-11-20

只是测试了下，结果如下：
# insmod spin.ko
driver initialize!

# echo good >/dev/simplespinlock
device open!
write!
write!
write!
write!
write!
device close!

作者: EZWORD   发布时间: 2010-11-20

相关阅读 更多

热门阅读

热门下载

更多
关于本站 免责申明 联系我们

Copyright 2006-2020 php爱好者(phpfans.net) All Rights Reserved.备案号：湘ICP备2023016114号-2

本站为非盈利性网站，不接受任何广告。本站所有资源均由网友上传，如有侵权，请发邮件至 [email protected] phpfans.net