字符设备驱动程序之按键—同步互斥阻塞

字符设备驱动程序之按键—同步互斥阻塞  

我们知道在之前的应用程序中，如果我们同时运行两次应用程序的话，则两次都可以同时打开设备，这就是说我们的按键资源同时被两个进程使用。显然这不是我们想要的，那么下面我们就要引入互斥的概念。

关于互斥其实现很简单，就是采用一些标志，当文件被一个进程打开后，就会设置该标志，使其他进程无法打开设备文件。下面，我们就完全靠自己去实现一个互斥，代码修改如下：
首先定义一个全局变量：

static int canread=1;

然后在open函数开始处加入如下代码：

 if(--canread!=0)

    {       

      canread++;

      return -EBUSY;

    }

在close函数里面加入如下代码：

anread++;

我们可以先分析一下，当进程A打开设备文件时，因为初始值canread=1，canread减1后正好等于0，不会出错返回，成功打开了。此时当进程B再来打开该设备文件时，因canread=0，canread减1不为0，所以会出错出错返回，且canread加1，canread=0。当进程A关闭后，canread加1，canread=1；这时如果B进程运行，会成功打开设备文件。看上去似乎完美得实现了互斥，其实这其中是有问题的。因为其实对于：

 --canread!

这行代码来说，它分为3的步骤，包括：读取canread值，修改canread值，写回canread的值。

但是不要忘记了，我们的linux系统是一个多任务的系统，假如当A读取了canread的值为1时，还没来得及减1，就已经切换到了进程B，进程B读出的canread的值也是1，这样的话，B就成功打开了设备文件。如果这时再切换回了A，因为之前A已经读出了canread为1，这时会将canread当作1来进行后续处理，也可以打开文件。这可不是我们想要的，那么有没有其他办法呢？答案是肯定的，下面来介绍两种方法：

 

方法一：原子操作

定义：原子操作指的是在执行过程中不会被别的代码路径所中断的操作。

下面是几个常用原子操作函数：

atomic_t v = ATOMIC_INIT(0);   //定义原子变量v并初始化为0

atomic_read(atomic_t *v);     //返回原子变量的值

void atomic_inc(atomic_t *v);   //原子变量增加1

void atomic_dec(atomic_t *v);   //原子变量减少1

int atomic_dec_and_test(atomic_t *v); //自减操作后测试其是否为0，为0则返回true，否则返回false。

修改代码：
首先定义全局原子变量：

static atomic_t canread= ATOMIC_INIT(1);

然后在open函数开始处加入如下代码：

   if(!atomic_dec_and_test(&canread))

    {       

      atomic_inc(&canread);

      return -EBUSY;

    }

 

在close函数里面加入如下代码：

atomic_inc(&canread);

 

方法二：信号量

定义：信号量（semaphore）是用于保护临界区的一种常用方法，只有得到信号量的进程才能执行临界区代码。当获取不到信号量时，进程进入休眠等待状态。

下面是几个常用的信号量相关的函数：

 

2. 信号量

信号量（semaphore）是用于保护临界区的一种常用方法，只有得到信号量的进程才能执行临界区代码。

当获取不到信号量时，进程进入休眠等待状态。

定义信号量

struct semaphore sem;

初始化信号量

void sema_init (struct semaphore *sem, int val); ;//将信号量sem的值初始化为val

void init_MUTEX(struct semaphore *sem);//将信号量初始化为1

static DECLARE_MUTEX(button_lock);   //定义互斥锁,实际上定义一个名为button_lock的信号量并初始化为1

获得信号量

void down(struct semaphore * sem);                    //休眠后不能被信号量打断

int down_interruptible(struct semaphore * sem);      //休眠后可被信号打断

int down_trylock(struct semaphore * sem);         //获取信号量，从不休眠

释放信号量

void up(struct semaphore * sem);

 

关于信号量，将下后面章节进行记录分析

 

修改代码：

首先定义全局互斥锁：

static DECLARE_MUTEX(button_lock);

在open函数中获得信号量：

down(&button_lock);

在close函数中释放信号量：
up(&button_lock);

我们测试时第一次运行应用程序，发现其状态时S，第二次运行，其状态时D，S表示睡眠状态，是因为没有按键按下而产生睡眠，而D表示一种僵死状态，或者也可以说是一种睡眠状态，不过它是因为没有获取信号量而进入僵死。那么第二个进程什么时候才能从僵死状 态唤醒呢？那就要等到第一个进程释放信号量。我们将第一个进程杀死，发现第二个进程的状态变成了S，从而验证了我们的说法。

 

下面我们再来谈一下阻塞和非阻塞的问题：

阻塞操作：是指在执行设备操作时若不能获得资源则挂起进程，直到满足可操作的条件后再进行操作。被挂起的进程进入休眠状态，被从调度器的运行队列移走，直到等待的条件被满足。

非阻塞操作：进程在不能进行设备操作时并不挂起，它或者放弃，或者不停地查询，直至可以进行操作为止。

我们在驱动程序中修改代码：

在open函数中加入如下代码：

if (file->f_flags & O_NONBLOCK)

{

 if (down_trylock(&button_lock))          //非阻塞操作，即使获取信号量失败也不会休眠

  return -EBUSY;

}

else

{

 down(&button_lock);          //阻塞操作若获取信号量失败，则进入休眠，否则往下执行  

}

我们在read函数中加入如下代码：

if (filp->f_flags & O_NONBLOCK)

{

 if (!ev_press)  //如果没有按键按下返回

 return -EAGAIN;

}

else

{

 wait_event_interruptible(button_waitq, ev_press);//阻塞操作无按键按下则休眠

}

将ev_press相关的定义添加上

添加定义：static DECLARE_WAIT_QUEUE_HEAD(button_waitq);

在中断中补上这一句：wake_up_interruptible(&button_waitq);

 

测试程序如下：

#include

#include

#include

#include

#include

#include

#include

#include

#include

 

int main(int argc, char **argv)

{

   int fd;

    unsigned char key_val;

   

 fd = open("/dev/keys", O_RDWR);

 if (fd < 0)

 {

 printf("can't open!\n");

 }

 

 while (1)

 {

    read(fd, &key_val, 1);

    printf("key_val: 0x%x\n", key_val);

 }

 

 return 0;

}

默认情况下是阻塞方式打开的，运行测试程序，当我们没有按下按键时会休眠，但不会返回。

我们将： fd = open("/dev/keys", O_RDWR);改为 fd = open("/dev/keys", O_RDWR | O_NONBLOCK);

会变成非阻塞方式打开，这时没有按键按下会返回。为方便测试，我们在循环里加入：sleep(5);