字符设备驱动------同步互斥阻塞

引入　

当设备被一个程序打开时，存在被另一个程序打开的可能，如果两个或多个程序同时对设备文件进行写操作，这就是说我们的设备资源同时被多个进程使用,对共享资源（硬件资源、和软件上的全局变量、静态变量等）的访问则很容易导致竞态。

显然这不是我们想要的,所以本节引入互斥的概念:实现同一时刻,只能一个应用程序使用驱动程序

互斥其实现很简单，就是采用一些标志，当文件被一个进程打开后，就会设置该标志，使其他进程无法打开设备文件

目的

同一时刻，只允许驱动程序被一个进程打开

1.其中的标志需要使用函数来操作,不能直接通过判断变量来操作标志

eg:

open中记录打开的次数，can_open_cnt表示运行打开的次数，定义为1表示只允许一个设备打开.

但是在汇编中一个c代码的加减实际上是分为a.读----b.修改----c.写回的过程，

当A程序执行上述的a语句时，切换到B程序执行此程序，也执行到此语句的a.读，

由于A并未修改can_open_cnt = 0，B也能正常打开，B关闭后，can_open_cnt++ = 1

继续执行A。由此看来，使用判断变量来操作标志存在篡改的过程。

1 int can_open_cnt =1;
2 // open
3 if (--can_open_cnt != 0)　//先减后判断
4 {　　//0-->无进程访问驱动， <0 -->已有进程访问
5     can_open_cnt++;
6     return _EBUSY
7 }
8 //close
9 can_open_cnt++;

1.1所以采用某种函数来实现,保证执行过程不被其他行为打断,有两种类型函数可以实现:

　　原子操作(像原子一样不可再细分不可被中途打断)

当多个进程同时访问同一个驱动时,只能有一个进程访问成功,其它进程会退出

　　互斥信号量操作

比如:A、B进程同时访问同一个驱动时,只有A进程访问成功了,B进程进入休眠等待状态,当A进程执行完毕释放后,等待状态的B进程又来访问，保证一个一个进程都能访问

2. 原子操作详解

1 常用原子操作函数举例：
2 atomic_t v = ATOMIC_INIT(0);     //定义原子变量v并初始化为0
3 atomic_read(atomic_t *v);        //返回原子变量的值
4 void atomic_inc(atomic_t *v);    //原子变量增加1
5 void atomic_dec(atomic_t *v);    //原子变量减少1
6 int atomic_dec_and_test(atomic_t *v); //自减操作后测试其是否为0，为0则返回true，否则返回false。

2.1修改驱动程序

定义原子变量:

1 /*定义原子变量canopen并初始化为1 */
2 atomic_t canopen = ATOMIC_INIT(1); 

在.open成员函数里添加:

1 /*自减操作后测试其是否为0，为0则返回true，否则返回false   */
2 if(!atomic_dec_and_test(&canopen))
3  {
4   atomic_inc(&canopen);       //++,复位
5   return -1;
6  }

在. release成员函数里添加:

 atomic_inc(&canopen);       //++,复位

驱动程序：

  1 #include <linux/module.h>
  2 #include <linux/kernel.h>
  3 #include <linux/fs.h>
  4 #include <linux/init.h>
  5 #include <linux/delay.h>
  6 #include <linux/irq.h>
  7 #include <asm/uaccess.h>
  8 #include <asm/irq.h>
  9 #include <asm/io.h>
 10 #include <asm/arch/regs-gpio.h>
 11 #include <asm/hardware.h>
 12 #include <linux/poll.h>
 13
 14
 15 static struct class *sixthdrv_class;
 16 static struct class_device    *sixthdrv_class_dev;
 17
 18 volatile unsigned long *gpfcon;
 19 volatile unsigned long *gpfdat;
 20
 21 volatile unsigned long *gpgcon;
 22 volatile unsigned long *gpgdat;
 23
 24
 25 static DECLARE_WAIT_QUEUE_HEAD(button_waitq);
 26
 27 /* 中断事件标志, 中断服务程序将它置1，sixth_drv_read将它清0 */
 28 static volatile int ev_press = 0;
 29
 30 static struct fasync_struct *button_async;
 31
 32
 33 struct pin_desc{
 34     unsigned int pin;
 35     unsigned int key_val;
 36 };
 37
 38
 39 /* 键值: 按下时, 0x01, 0x02, 0x03, 0x04 */
 40 /* 键值: 松开时, 0x81, 0x82, 0x83, 0x84 */
 41 static unsigned char key_val;
 42
 43 struct pin_desc pins_desc[4] = {
 44     {S3C2410_GPF0, 0x01},
 45     {S3C2410_GPF2, 0x02},
 46     {S3C2410_GPG3, 0x03},
 47     {S3C2410_GPG11, 0x04},
 48 };
 49
 50 static atomic_t canopen = ATOMIC_INIT(1);    //定义原子变量并初始化为1
 51 //static DECLARE_MUTEX(button_lock);     //定义互斥锁
 52
 53 /*
 54   * 确定按键值
 55   */
 56 static irqreturn_t buttons_irq(int irq, void *dev_id)
 57 {
 58     struct pin_desc * pindesc = (struct pin_desc *)dev_id;
 59     unsigned int pinval;
 60
 61     pinval = s3c2410_gpio_getpin(pindesc->pin);
 62
 63     if (pinval)
 64     {
 65         /* 松开 */
 66         key_val = 0x80 | pindesc->key_val;
 67     }
 68     else
 69     {
 70         /* 按下 */
 71         key_val = pindesc->key_val;
 72     }
 73
 74     ev_press = 1;                  /* 表示中断发生了 */
 75     wake_up_interruptible(&button_waitq);   /* 唤醒休眠的进程 */
 76
 77     kill_fasync (&button_async, SIGIO, POLL_IN);
 78
 79     return IRQ_RETVAL(IRQ_HANDLED);
 80 }
 81
 82 static int sixth_drv_open(struct inode *inode, struct file *file)
 83 {
 84
 85     if (!atomic_dec_and_test(&canopen))    //自减操作
 86     {
 87         atomic_inc(&canopen);    //原子变量加1
 88         return -EBUSY;
 89     }
 90
 91     /* 配置GPF0,2为输入引脚 */
 92     /* 配置GPG3,11为输入引脚 */
 93     request_irq(IRQ_EINT0,  buttons_irq, IRQT_BOTHEDGE, "S2", &pins_desc[0]);
 94     request_irq(IRQ_EINT2,  buttons_irq, IRQT_BOTHEDGE, "S3", &pins_desc[1]);
 95     request_irq(IRQ_EINT11, buttons_irq, IRQT_BOTHEDGE, "S4", &pins_desc[2]);
 96     request_irq(IRQ_EINT19, buttons_irq, IRQT_BOTHEDGE, "S5", &pins_desc[3]);
 97
 98     return 0;
 99 }
100
101 ssize_t sixth_drv_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
102 {
103     if (size != 1)
104         return -EINVAL;
105
106     if (file->f_flags & O_NONBLOCK)
107     {
108         if (!ev_press)
109             return -EAGAIN;
110     }
111     else
112     {
113         /* 如果没有按键动作, 休眠 */
114         wait_event_interruptible(button_waitq, ev_press);
115     }
116
117     /* 如果有按键动作, 返回键值 */
118     copy_to_user(buf, &key_val, 1);
119     ev_press = 0;
120
121     return 1;
122 }
123
124
125 int sixth_drv_close(struct inode *inode, struct file *file)
126 {
127     atomic_inc(&canopen);    //原子变量加1
128     free_irq(IRQ_EINT0, &pins_desc[0]);
129     free_irq(IRQ_EINT2, &pins_desc[1]);
130     free_irq(IRQ_EINT11, &pins_desc[2]);
131     free_irq(IRQ_EINT19, &pins_desc[3]);
132     //up(&button_lock);
133     return 0;
134 }
135
136 static unsigned sixth_drv_poll(struct file *file, poll_table *wait)
137 {
138     unsigned int mask = 0;
139     poll_wait(file, &button_waitq, wait); // 不会立即休眠
140
141     if (ev_press)
142         mask |= POLLIN | POLLRDNORM;
143
144     return mask;
145 }
146
147 static int sixth_drv_fasync (int fd, struct file *filp, int on)
148 {
149     printk("driver: sixth_drv_fasync\n");
150     return fasync_helper (fd, filp, on, &button_async);
151 }
152
153
154 static struct file_operations sencod_drv_fops = {
155     .owner   =  THIS_MODULE,    /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
156     .open    =  sixth_drv_open,
157     .read     =    sixth_drv_read,
158     .release =  sixth_drv_close,
159     .poll    =  sixth_drv_poll,
160     .fasync     =  sixth_drv_fasync,
161 };
162
163
164 int major;
165 static int sixth_drv_init(void)
166 {
167     major = register_chrdev(0, "sixth_drv", &sencod_drv_fops);
168
169     sixthdrv_class = class_create(THIS_MODULE, "sixth_drv");
170
171     sixthdrv_class_dev = class_device_create(sixthdrv_class, NULL, MKDEV(major, 0), NULL, "buttons"); /* /dev/buttons */
172
173     gpfcon = (volatile unsigned long *)ioremap(0x56000050, 16);
174     gpfdat = gpfcon + 1;
175
176     gpgcon = (volatile unsigned long *)ioremap(0x56000060, 16);
177     gpgdat = gpgcon + 1;
178
179     return 0;
180 }
181
182 static void sixth_drv_exit(void)
183 {
184     unregister_chrdev(major, "sixth_drv");
185     class_device_unregister(sixthdrv_class_dev);
186     class_destroy(sixthdrv_class);
187     iounmap(gpfcon);
188     iounmap(gpgcon);
189     return 0;
190 }
191
192
193 module_init(sixth_drv_init);
194
195 module_exit(sixth_drv_exit);
196
197 MODULE_LICENSE("GPL");

sixth_drv.c

测试程序：

 1 #include <sys/types.h>
 2 #include <sys/stat.h>
 3 #include <fcntl.h>
 4 #include <stdio.h>
 5 #include <poll.h>
 6 #include <signal.h>
 7 #include <sys/types.h>
 8 #include <unistd.h>
 9 #include <fcntl.h>
10
11
12 /* sixthdrvtest
13   */
14 int fd;
15
16 void my_signal_fun(int signum)
17 {
18     unsigned char key_val;
19     read(fd, &key_val, 1);
20     printf("key_val: 0x%x\n", key_val);
21 }
22
23 int main(int argc, char **argv)
24 {
25     unsigned char key_val;
26     int ret;
27     int Oflags;
28
29     //signal(SIGIO, my_signal_fun);
30
31     //fd = open("/dev/buttons", O_RDWR | O_NONBLOCK);
32     fd = open("/dev/buttons", O_RDWR);
33     if (fd < 0)
34     {
35         printf("can‘t open!\n");
36         return -1;
37     }
38
39     //fcntl(fd, F_SETOWN, getpid());
40
41     //Oflags = fcntl(fd, F_GETFL);
42
43     //fcntl(fd, F_SETFL, Oflags | FASYNC);
44
45
46     while (1)
47     {
48         ret = read(fd, &key_val, 1);
49         printf("key_val: 0x%x, ret = %d\n", key_val, ret);
50         sleep(5);
51     }
52
53     return 0;
54 }

sixthdrvtest.c

如下图,可以看到第一个进程访问驱动成功,后面的就再也不能访问成功了

3.互斥信号量详解

互斥信号量（semaphore）是用于保护临界区的一种常用方法，

应用程序在操作之前，要先申请信号量，申请不到的话，要么返回，要么等休眠

如果能申请到信号量，进程才能继续操作，操作完毕后，要释放信号量。

释放了之后，如果有其他的应用程序等待获取此信号量的话，就要去唤醒那个应用程序。

3.1信号量函数如下:

/*注意: 在2.6.36版本后这个函数DECLARE_MUTEX修改成DEFINE_SEMAPHORE了*/
1)static DECLARE_MUTEX(button_lock);     　　　　//定义互斥锁button_lock,被用来后面的down和up用

2)void down(struct semaphore * sem);            // 获取不到就进入不被中断的休眠状态(down函数中睡眠)

3)int down_interruptible(struct semaphore * sem);  //获取不到就进入可被中断的休眠状态(down函数中睡眠)

4)int down_trylock(struct semaphore * sem);       //试图获取信号量，获取不到则立刻返回正数

5)void up(struct semaphore * sem);               //释放信号量

3.2修改驱动程序(以down函数获取为例)

(1)定义互斥锁变量:

/*定义互斥锁button_lock,被用来后面的down()和up()使用 */
static DECLARE_MUTEX(button_lock); 

(2)在.open成员函数里添加:

/* 获取不到就进入不被中断的休眠状态(down函数中睡眠) */
          down(&button_lock);

(3)在. release成员函数里添加:

 /*         释放信号量          */
          up(&button_lock);     

驱动程序如下：

  1 #include <linux/module.h>
  2 #include <linux/kernel.h>
  3 #include <linux/fs.h>
  4 #include <linux/init.h>
  5 #include <linux/delay.h>
  6 #include <linux/irq.h>
  7 #include <asm/uaccess.h>
  8 #include <asm/irq.h>
  9 #include <asm/io.h>
 10 #include <asm/arch/regs-gpio.h>
 11 #include <asm/hardware.h>
 12 #include <linux/poll.h>
 13
 14
 15 static struct class *sixthdrv_class;
 16 static struct class_device    *sixthdrv_class_dev;
 17
 18 volatile unsigned long *gpfcon;
 19 volatile unsigned long *gpfdat;
 20
 21 volatile unsigned long *gpgcon;
 22 volatile unsigned long *gpgdat;
 23
 24
 25 static DECLARE_WAIT_QUEUE_HEAD(button_waitq);
 26
 27 /* 中断事件标志, 中断服务程序将它置1，sixth_drv_read将它清0 */
 28 static volatile int ev_press = 0;
 29
 30 static struct fasync_struct *button_async;
 31
 32
 33 struct pin_desc{
 34     unsigned int pin;
 35     unsigned int key_val;
 36 };
 37
 38
 39 /* 键值: 按下时, 0x01, 0x02, 0x03, 0x04 */
 40 /* 键值: 松开时, 0x81, 0x82, 0x83, 0x84 */
 41 static unsigned char key_val;
 42
 43 struct pin_desc pins_desc[4] = {
 44     {S3C2410_GPF0, 0x01},
 45     {S3C2410_GPF2, 0x02},
 46     {S3C2410_GPG3, 0x03},
 47     {S3C2410_GPG11, 0x04},
 48 };
 49
 50 static DECLARE_MUTEX(button_lock);    //定义互斥锁
 51 /*
 52  * 确定按键值
 53  */
 54 static irqreturn_t buttons_irq(int irq, void *dev_id)
 55 {
 56     struct pin_desc * pindesc = (struct pin_desc *)dev_id;
 57     unsigned int pinval;
 58
 59     pinval = s3c2410_gpio_getpin(pindesc->pin);
 60
 61     if (pinval)
 62     {
 63         /* 松开 */
 64         key_val = 0x80 | pindesc->key_val;
 65     }
 66     else
 67     {
 68         /* 按下 */
 69         key_val = pindesc->key_val;
 70     }
 71
 72     ev_press = 1;                  /* 表示中断发生了 */
 73     wake_up_interruptible(&button_waitq);   /* 唤醒休眠的进程 */
 74
 75     kill_fasync (&button_async, SIGIO, POLL_IN);
 76
 77     return IRQ_RETVAL(IRQ_HANDLED);
 78 }
 79
 80 static int sixth_drv_open(struct inode *inode, struct file *file)
 81 {
 82 #if 0
 83     if (!atomic_dec_and_test(&canopen))    //自减操作
 84     {
 85         atomic_inc(&canopen);    //原子变量加1
 86         return -EBUSY;
 87     }
 88 #endif
 89     /*获取信号量*/
 90     down(&button_lock);
 91     //若为第一次执行，则会获得信号量，第二次打开的话，就会进入休眠
 92
 93     /* 配置GPF0,2为输入引脚 */
 94     /* 配置GPG3,11为输入引脚 */
 95     request_irq(IRQ_EINT0,  buttons_irq, IRQT_BOTHEDGE, "S2", &pins_desc[0]);
 96     request_irq(IRQ_EINT2,  buttons_irq, IRQT_BOTHEDGE, "S3", &pins_desc[1]);
 97     request_irq(IRQ_EINT11, buttons_irq, IRQT_BOTHEDGE, "S4", &pins_desc[2]);
 98     request_irq(IRQ_EINT19, buttons_irq, IRQT_BOTHEDGE, "S5", &pins_desc[3]);
 99
100     return 0;
101 }
102
103 ssize_t sixth_drv_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
104 {
105     if (size != 1)
106         return -EINVAL;
107
108     if (file->f_flags & O_NONBLOCK)
109     {
110         if (!ev_press)
111             return -EAGAIN;
112     }
113     else
114     {
115         /* 如果没有按键动作, 休眠 */
116         wait_event_interruptible(button_waitq, ev_press);
117     }
118
119     /* 如果有按键动作, 返回键值 */
120     copy_to_user(buf, &key_val, 1);
121     ev_press = 0;
122
123     return 1;
124 }
125
126
127 int sixth_drv_close(struct inode *inode, struct file *file)
128 {
129     free_irq(IRQ_EINT0, &pins_desc[0]);
130     free_irq(IRQ_EINT2, &pins_desc[1]);
131     free_irq(IRQ_EINT11, &pins_desc[2]);
132     free_irq(IRQ_EINT19, &pins_desc[3]);
133     up(&button_lock);    /*释放信号量*/
134     return 0;
135 }
136
137 static unsigned sixth_drv_poll(struct file *file, poll_table *wait)
138 {
139     unsigned int mask = 0;
140     poll_wait(file, &button_waitq, wait); // 不会立即休眠
141
142     if (ev_press)
143         mask |= POLLIN | POLLRDNORM;
144
145     return mask;
146 }
147
148 static int sixth_drv_fasync (int fd, struct file *filp, int on)
149 {
150     printk("driver: sixth_drv_fasync\n");
151     return fasync_helper (fd, filp, on, &button_async);
152 }
153
154
155 static struct file_operations sencod_drv_fops = {
156     .owner   =  THIS_MODULE,    /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
157     .open    =  sixth_drv_open,
158     .read     =    sixth_drv_read,
159     .release =  sixth_drv_close,
160     .poll    =  sixth_drv_poll,
161     .fasync     =  sixth_drv_fasync,
162 };
163
164
165 int major;
166 static int sixth_drv_init(void)
167 {
168     major = register_chrdev(0, "sixth_drv", &sencod_drv_fops);
169
170     sixthdrv_class = class_create(THIS_MODULE, "sixth_drv");
171
172     sixthdrv_class_dev = class_device_create(sixthdrv_class, NULL, MKDEV(major, 0), NULL, "buttons"); /* /dev/buttons */
173
174     gpfcon = (volatile unsigned long *)ioremap(0x56000050, 16);
175     gpfdat = gpfcon + 1;
176
177     gpgcon = (volatile unsigned long *)ioremap(0x56000060, 16);
178     gpgdat = gpgcon + 1;
179
180     return 0;
181 }
182
183 static void sixth_drv_exit(void)
184 {
185     unregister_chrdev(major, "sixth_drv");
186     class_device_unregister(sixthdrv_class_dev);
187     class_destroy(sixthdrv_class);
188     iounmap(gpfcon);
189     iounmap(gpgcon);
190     return 0;
191 }
192
193
194 module_init(sixth_drv_init);
195
196 module_exit(sixth_drv_exit);
197
198 MODULE_LICENSE("GPL");

sixdrv2.c

测试程序同上一个。

测试：

下图，只有831进程在处于静止状态（没有中断触发）

832进程处于down休眠状态，直至831释放掉信号

灭掉进程831

多个信号量访问时, 会一个一个进程来排序访问

4.阻塞与非阻塞

4.1概念

1. 阻塞,

　　　　如果不满足条件会挂起,直到满足可操作的条件后再进行操作。

　　　　被挂起的进程进入休眠状态，被从调度器的运行队列移走，直到等待的条件被满足。

　　  2. 非阻塞,

　　　　不满足条件返回,进程在不能进行设备操作时并不挂起，它或者放弃，或者不停地查询，直至可以进行操作为止

4.2 怎么来判断阻塞与非阻塞操作？

1.在用户层open时，默认为阻塞操作,如果添加了” O_NONBLOCK”,表示使open()、read()、write()不被阻塞

实例:

fd = open("/dev/buttons",O_RDWR);    //使用阻塞操作
fd = open("/dev/buttons ", O_RDWR | O_NONBLOCK);   //非阻塞操作   

2.然后在驱动设备中,通过file_operations成员函数.open、.read、.write带的参数file->f_flags 来查看用户层访问时带的参数

实例:

1  if(  file->f_flags & O_NONBLOCK )   //非阻塞操作,获取不到则退出
2   {
3      ... ...
4   }
5   else   //阻塞操作，获取不到则进入休眠
6   {
7      ... ...
8   

4.3 修改应用程序，通过判断file->f_flags来使用阻塞操作还是非阻塞操作

(1)定义互斥锁变量:

/*定义互斥锁button_lock,被用来后面的down()和up()使用 */
static DECLARE_MUTEX(button_lock); 

(2)在.open成员函数里添加:

if( file->f_flags & O_NONBLOCK )   //非阻塞操作
  {
   if(down_trylock(&button_lock) )       //尝试获取信号量,获取不到则退出
            return -1;
  }
else   //阻塞操作
  {
     down(&button_lock);         //获取信号量,获取不到则进入休眠
  }

（3）在read成员函数里添加

ssize_t sixth_drv_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
{
    if (size != 1)
        return -EINVAL;

    if (file->f_flags & O_NONBLOCK)
    {    /*非阻塞*/
        if (!ev_press)
            return -EAGAIN;
    }
    else
    {    /*阻塞*/
        /* 如果没有按键动作, 休眠 */
        wait_event_interruptible(button_waitq, ev_press);
    }

    /* 如果有按键动作, 返回键值 */
    copy_to_user(buf, &key_val, 1);
    ev_press = 0;

    return 1;
}

(4)在. release成员函数里添加:

  /*释放信号量*/
  up(&button_lock);     

测试阻塞：

 1 int main(int argc,char **argv)
 2 {
 3   int oflag;
 4   unsigned int val=0;
 5   fd=open("/dev/buttons",O_RDWR);           //使用阻塞操作
 6   if(fd<0)
 7        {printf("can‘t open, fd=%d\n",fd);
 8        return -1;}
 9   else
10        {
11        printf("can open,PID=%d\n",getpid());    //打开成功,打印pid进程号
12        }
13
14    while(1)
15    {
16     val=read( fd, &ret, 1);              //读取驱动层数据
17      printf("key_vale=0X%x,retrun=%d\r\n",ret,val);
18    }
19    return 0;

测试非阻塞：

上面的测试程序

第5行：

fd=open("/dev/buttons",O_RDWR | O_NONBLOCK);

参考

原文地址：https://www.cnblogs.com/y4247464/p/10113869.html