Linux设备驱动程序--并发和竞态(信号量和原子操作)

1610阅读　0评论2014-01-07　wangtisheng
分类：嵌入式

                        Linux设备驱动程序
                            --并发和竞态（信号量和原子操作）
一、并发和竞态、信号量

    这部分内容tekkamanninja在其博客Linux设备驱动程序学习（3）-并发和竞态中作了较为全面的描述，结合国嵌中的一个例子，进行了简单的实验，后结合韦东山老师第一期教程的最后一课进行了更新，增加了按键驱动信号量的操作。并发：多个执行单元同时被执行。竞态：并发的执行单元对共享资源(硬件资源和软件上的全局变量等)的访问导致的竞争状态。
    竞态通常作为对资源的共享访问结果而产生。设计自己的驱动程序时，应该避免资源的共享。访问管理的常见技术称为“锁定”或者“互斥”--确保一次只有一个执行线程可操作共享资源。内核提供了锁定机制避免资源的共享，但并不是所有的锁定机制都可用，合适的机制是信号量。
    信号量（semaphore）是用于保护临界区的一种常用方法，只有得到信号量的进程才能执行临界区代码。当获取不到信号量时，进程进入休眠等待状态。--- 韦东山视频教程。
 
        SMP: Symmetric Multiprocessing(对称多处理)。

二、Linux信号量的实现
    要使用信号量，内核代码必须包括下面头文件
            #include         
    ① 信号量的定义，相关的类型：
            struct semaphore sem;
    ② 信号量必须在设备对系统其他部分可用前被初始化。
            static inline void sema_init(struct semaphore *sem, int val);    //直接创建信号量
        2.6.25及以后的linux内核版本废除了init_MUTEX函数，老版本内核扔可以使用。
            static inline void init_MUTEX(struct semaphore *sem);

        信号量用于互斥模式：
            定义一个互斥锁，并初始化为1
                #define DECLARE_MUTEX(name) __DECLARE_SEMAPHORE_GENERIC(name,1)
            定义一个互斥锁，并初始化为0
                #define DECLARE_MUTEX_LOCKED(name) __DECLARE_SEMAPHORE_GENERIC(name,0)
    ③ 信号量的获取，在Open方法中使用，
            static inline void down(struct semaphore * sem);
            static inline int down_interruptible (struct semaphore * sem); //建议使用
            static inline int down_trylock(struct semaphore *sem);
        2.6.25及以后的linux内核版本
            int down_killable(struct semaphore *sem)

    ④ 信号量的释放，在close方法中实现。该函数释放信号量sem，唤醒等待者。
        static inline void up(struct semaphore * sem);
下图截取自《Linux设备驱动开发详解》第二版
                  
    互斥锁，只允许只有一个持有者的信号量。

三、信号量使用示例

    信号量的一个例子，来自国嵌semaphore.rar
    信号量的另一个例子，使用信号量实现设备只能被一个进程打开，实验平台：mini2440，完整代码buttons_int_semaphore.rar。
        ①.  static DECLARE_MUTEX(button_lock);     //第一步：定义信号量(互斥锁)；
        ②.  down_interruptible(&button_lock);      //open方法中获取信号量；
        ③.  up(&button_lock);                      //close方法中释放信号量；
驱动程序buttons_int_semaphore_drv.c

点击(此处)折叠或打开

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/fs.h>
  4. #include <linux/init.h>
  5. #include <linux/device.h>
  6. #include <linux/irq.h>
  7. #include <linux/interrupt.h>
  8. #include <linux/poll.h>
  9. #include <asm/arch/regs-gpio.h>
  10. #include <asm/hardware.h>
  11. #include <linux/uaccess.h>

  13. #define        DEVICE_NAME        "mini2440_buttons" //设备名称

  15. static struct class *buttons_int_semaphore_drv_class;
  16. static struct class_device *buttons_int_semaphore_drv_class_dev;

  18.   
  19.     
  20. static DECLARE_WAIT_QUEUE_HEAD(button_waitq);    //等待队列:当没有按键被按下时，如果有进程调用buttons_int_fasync_drv_read函数，它将休眠
  21. static volatile int ev_press = 0;                //中断事件标志, 中断服务程序将它置1，s3c24xx_buttons_read将它清0
  22. static unsigned char key_val;                    //保存键值

  24. //static DECLARE_MUTEX(button_lock); //第一步：定义信号量(互斥锁)
  25. struct semaphore button_lock;
  26. static struct fasync_struct *buttons_async;

  28. //引脚描述结构体
  29. struct pin_desc{
  30.     unsigned int pin;
  31.     unsigned int key_value;
  32. };
  33. //管脚数组，按键赋键值，按下时是0x01,松开是0x81(最高位为1)
  34. struct pin_desc pins_desc[6] = {
  35.         {S3C2410_GPG0, 0x01},
  36.         {S3C2410_GPG3, 0x02},
  37.         {S3C2410_GPG5, 0x03},
  38.         {S3C2410_GPG6, 0x04},
  39.         {S3C2410_GPG7, 0x05},
  40.         {S3C2410_GPG11,0x06},
  41. };

  43. //确定按键值
  44. static irqreturn_t buttons_irq(int irq, void *dev_id)
  45. {
  46.     //printk("irq = %d\n",irq);
  47.     struct pin_desc *pindesc = (struct pin_desc *)dev_id;
  48.     unsigned int pinval;
  49.     pinval = s3c2410_gpio_getpin(pindesc->pin);
  50.     if(pinval)
  51.     {
  52.         //松开
  53.         key_val = 0x80 | pindesc->key_value;
  54.     }
  55.     else
  56.     {
  57.         //按下
  58.         key_val = pindesc->key_value;
  59.     }    
  60.     ev_press = 1;     
  61.     wake_up_interruptible(&button_waitq);
  62.     //kill_fasync(struct fasync_struct * * fp, int sig, int band)
  63.     kill_fasync (&buttons_async, SIGIO, POLL_IN);
  64.     return IRQ_HANDLED;
  65. }

  67. static int buttons_int_semaphore_drv_open(struct inode *inode, struct file *file)
  68. {
  69.     int ret;
  70.     /*open方法中获取信号量，第一次执行可以获取信号量，第二个进程在第一个进程没有释放信号量是无法open*/
  71.     down_interruptible(&button_lock);
  72.     ret = request_irq(IRQ_EINT8, buttons_irq,IRQT_BOTHEDGE,"KEY1",&pins_desc[0]);    //pins_desc[0]传递给buttons_irq
  73.     ret = request_irq(IRQ_EINT11,buttons_irq,IRQT_BOTHEDGE,"KEY2",&pins_desc[1]);
  74.     ret = request_irq(IRQ_EINT13,buttons_irq,IRQT_BOTHEDGE,"KEY3",&pins_desc[2]);
  75.     ret = request_irq(IRQ_EINT14,buttons_irq,IRQT_BOTHEDGE,"KEY4",&pins_desc[3]);
  76.     ret = request_irq(IRQ_EINT15,buttons_irq,IRQT_BOTHEDGE,"KEY5",&pins_desc[4]);
  77.     ret = request_irq(IRQ_EINT19,buttons_irq,IRQT_BOTHEDGE,"KEY6",&pins_desc[5]);
  78.     return 0;
  79. }

  81. ssize_t buttons_int_semaphore_drv_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
  82. {        
  83.     int ret;
  84.     if(size != 1)            //读取单个按键
  85.         return -EINVAL;
  86.     
  87.     wait_event_interruptible(button_waitq, ev_press);    //如果没有按键动作，休眠，让出CPU
  88.     ret = copy_to_user(buf, &key_val, 1);                //返回键值
  89.     ev_press = 0;
  90.     return 1;        
  91. }

  93. int buttons_int_semaphore_drv_close(struct inode *inode, struct file *file)
  94. {
  95.     free_irq(IRQ_EINT8, &pins_desc[0]);
  96.     free_irq(IRQ_EINT11,&pins_desc[1]);
  97.     free_irq(IRQ_EINT13,&pins_desc[2]);
  98.     free_irq(IRQ_EINT14,&pins_desc[3]);
  99.     free_irq(IRQ_EINT15,&pins_desc[4]);
  100.     free_irq(IRQ_EINT19,&pins_desc[5]);
  101.     up(&button_lock);
  102.     return 0;
  103. }

  105. static unsigned buttons_int_semaphore_drv_poll(struct file *file, poll_table *wait)
  106. {
  107.     unsigned int mask = 0;
  108.     poll_wait(file, &button_waitq, wait);                 // 不会立即休眠

  110.     if (ev_press)
  111.         mask |= POLLIN | POLLRDNORM;

  113.     return mask;
  114. }

  116. static int buttons_int_semaphore_drv_fasync(int fd, struct file *filp, int on)
  117. {
  118.     printk("driver:buttons_int_fasync_drv_fasync\n");
  119.     return fasync_helper (fd, filp, on, &buttons_async);
  120. }

  122. static struct file_operations buttons_int_fasync_drv_fops = {
  123.     .owner = THIS_MODULE,
  124.     .open = buttons_int_semaphore_drv_open,
  125.     .read = buttons_int_semaphore_drv_read,
  126.     .release = buttons_int_semaphore_drv_close,
  127.     .poll = buttons_int_semaphore_drv_poll,
  128.     .fasync = buttons_int_semaphore_drv_fasync,
  129. };

  131. int major;
  132. static int __init buttons_int_semaphore_drv_init(void)
  133. {
  134.     major = register_chrdev(0, DEVICE_NAME, &buttons_int_fasync_drv_fops);
  135.     if(major < 0)
  136.     {
  137.         printk(DEVICE_NAME "\t can't register major number!\n");
  138.     }
  139.     buttons_int_semaphore_drv_class = class_create(THIS_MODULE, DEVICE_NAME);
  140.     buttons_int_semaphore_drv_class_dev = class_device_create(buttons_int_semaphore_drv_class, NULL, MKDEV(major, 0), NULL, DEVICE_NAME); /* /dev/mini2440_buttons */
  141.     sema_init(&button_lock,1);
  142.     printk(DEVICE_NAME"\t initialized!\n");
  143.     return 0;
  144. }
  145. static void __exit buttons_int_semaphore_drv_exit(void)
  146. {
  147.     unregister_chrdev(major, DEVICE_NAME);
  148.     class_device_unregister(buttons_int_semaphore_drv_class_dev);
  149.     class_destroy(buttons_int_semaphore_drv_class);
  150. }

  152. module_init(buttons_int_semaphore_drv_init);
  153. module_exit(buttons_int_semaphore_drv_exit);
  154. MODULE_LICENSE("GPL");
测试程序buttons_int_semaphore_drv_test.c

点击(此处)折叠或打开

  1. #include <fcntl.h>
  2. #include <stdio.h>
  3. #include <poll.h>
  4. #include <signal.h>
  5. #include <sys/types.h>
  6. #include <unistd.h>

  8. int fd;            //全局变量

  10. void my_signal_fun(int signum)
  11. {
  12.     unsigned char key_val;
  13.     read(fd,&key_val,1);
  14.     printf("key_val:0x%x\n",key_val);
  15. }

  17. int main(int argc,char **argv)
  18. {
  19.     int ret;
  20.     int Oflags;

  22.     signal(SIGIO,my_signal_fun);

  24.     fd = open("/dev/mini2440_buttons", O_RDWR);
  25.     if(fd < 0)
  26.     {
  27.         printf("can't open\n");
  28.         return -1;            //无法打开
  29.     }
  30.     //fcntl(fd, F_SETOWN, getpid()); // 告诉内核，发给谁
  31.     //Oflags = fcntl(fd, F_GETFL);
  32.     //fcntl(fd, F_SETFL, Oflags | FASYNC); // 改变fasync标记，最终会调用到驱动的faync > fasync_helper：初始化/释放fasync_struct
  33.     
  34.     while(1)
  35.     {
  36.         //sleep(1000);
  37.     }
  38.     return 0;
  39. }
测试结果：
        
        执行两个application时，两个进程一个是可执行的R状态，一个是休眠的S状态，当把第一个可执行的进程杀掉之后释放信号量，第二个进程获得信号量变为可执行的R状态。验证了上面的分析。

四、原子操作
    原子操作指的是在执行过程中不会被别的代码路径所中断的操作。
    Linux 内核提供了一系列函数来实现内核中的原子操作，这些函数又分为两类，分别针对位和整型变量进行原子操作。
它们的共同点是在任何情况下操作都是原子的，内核代码可以安全地调用它们而不被打断。位和整型变量原子操作都依赖底层CPU 的原子操作来实现，
因此所有这些函数都与CPU架构密切相关。--- 《Linux设备驱动开发详解》。
    
 原子变量的一个示例atomic.rar

结果可以看出只有一个应用程序可以打开设备。                
上一篇：嵌入式系统 Boot Loader 技术内幕
下一篇：Linux设备驱动程序——高级字符驱动程序操作(ioctl)