Linux设备驱动中的并发控制-linux 设备驱动

[[208856]]

并发指的是多个执行单元同时、并行被执行，而并发的执行单元对共享资源的访问则很容易导致竞态。

linux内核中主要竞态

1.多对称处理器的多个CPU

2.单CPU内进程与抢占它的进程

3.中断(硬中断、软中断、Tasklet、下半部)与进程之间

访问共享内存资源的代码区称为“临界区”，临界区需要被以某种互斥机制加以保护，中断屏蔽、原子操作、自旋锁和信号量等，是linux设备驱动中可采用的互斥途径。

这几个互斥的介绍：

1.中断屏蔽，这个主要用于单CPU，中断屏蔽将使得中断和进程之间的并发不再发生。

使用方法：

local_irq_disable();//屏蔽中断 
... 
... 
临界区 
... 
local_irq_enable();//开中断

由于linux的异步IO、进程调度等很多重要的操作都依赖于中断，中断对于内核的运行非常重要，在屏蔽中断期间所有的中断都无法处理，因此长时间的屏蔽中断很危险，有可能导致数据丢失甚至系统崩溃。所以这个不作为重点讨论。

**********************************************************************************************************************************************************

2.原子操作，原子操作是一系列的不能被打断的操作。

linux内核提供了一系列的函数来实现内核中的原子操作，这些函数分为2类，分别针对位和整型变量进行原子操作。

实现原子操作的步骤：

1).定义原子变量并设置变量值

void atomic_set(atomic_t *v , int i); //设置原子变量值为i 
 
atomic_t v = ATOMIC_INIT(0); //定义原子变量v，初始化为0

2).获取原子变量的值

atomic_read(atomic_t *v);

3).原子变量加减操作

void atomic_add(int i,atomic_t *v);//原子变量加i 
 
void atomic_sub(int i ,atomic_t *v);//原子变量减i

4).原子变量自增/自减

void atomic_inc(atomic_t *v);//自增1 
 
void atomic_dec(atomic_t *v);//自减1

5).操作并测试：对原子变量执行自增、自减后(没有加)测试其是否为0，如果为0返回true，否则返回false。

int atomic_inc_and_test(atomic_t *v); 
 
int atomic_dec_and_test(atomic_t *v); 
 
int atomic_sub_and_test(int i ,atomic_t *v);

6).操作并返回

int atomic_add_return(int i , atomic_t *v); 
 
int atomic_sub_return(int i , atomic_t *v); 
 
int atomic_inc_return(atomic_t * v); 
 
int atomic_dec_return(atomic_t * v);

**********************************************************************************************************************************************************

3.自旋锁

自旋锁是一个忙锁，它在一个小的循环内不断的重复测试并设置的操作。

自旋锁保护临界区的特点：临界区要小，并且临界区内不能有导致睡眠的操作，否则可能引起系统崩溃。自旋锁可能导致系统死锁，引发这个问题最常见的情况是递归使用一个自旋锁。

自旋锁的操作步骤：

1).定义自旋锁

spinlock_t lock;

2).初始化自旋锁

spin_lock_init(lock); //这是个宏，它用于动态初始化自旋锁lock;

3).获得自旋锁

spin_lock(lock);//该宏用于加锁，如果能够立即获得锁，它就能马上返回，否则，他将自旋在那里，直到该自旋锁的保持者释放。 
 
spin_trylock(lock);//能够获得，则返回真，否则返回假，实际上是不在原地打转而已。

4).释放自旋锁

spin_unlock(lock);

与上面的两个配对使用。

例子：

spinlock_t lock; 
 
spin_lock_init(&lock); 
 
spin_lock(&lock); //获取自旋锁，保护临界区。。。。临界区 
 
spin_unlock(&lock);//释放自旋锁

自旋锁不关心锁定的临界区究竟是如何执行的。不管是读操作还是写操作，实际上，对共享资源进行读取的时候是应该可以允许多个执行单元同时访问的，那么这样的话，自旋锁就有了弊端。于是便衍生出来一个读写锁。

它保留了自旋的特性，但在对操作上面可以允许有多个单元进程同时操作。当然，读和写的时候不能同时进行。

现在又有问题了，如果我第一个进程写共享资源，第二个进程读的话，一旦写了，那么就读不到了，可能写的东西比较多，但是第二个进程读很小，那么能不能第一个进程写的同时，我第二个进程读呢?

当然可以，那么引出了顺序锁的概念。都是一样的操作。

**********************************************************************************************************************************************************

4.信号量

是用于保护临界区的一种常用的方法，它的使用与自旋锁差不多，但是它不在原地打转，当获取不到信号量时候，进程会进入休眠等待状态。

主要操作：

1).定义sem信号量

struct semaphore sem;

2).初始化信号量

void sema_init(struct semaphore *sem, int val);

初始化信号量，并设置sem的值为val

初始化的时候还可以这样用，init_MUTEX(sem),这是个宏 #define init_MUTEX(sem) sema_init(sem , 1)

init_MUTEX_LOCKED(sem),这是个宏 #define init_MUTEX_LOCKED(sem) sema_init(sem , 0)

3).获得信号量

void down(struct semaphore * sem);

该函数用于获得信号量sem，他会导致睡眠，所以不能在中断中使用。

int down_interruptible(struct semaphore* sem);

与上面功能类似，因为down进入睡眠状态的进程不能被信号打断，而它能被信号打断，信号也会导致该函数返回。

int down_trylock(struct semaphore * sem);

4).释放信号量

void up(struct semaphore * sem);

该函数用于释放信号量，同时唤醒等待者。

信号量一般这样使用：

DECLARE_MUTEX(sem); 
 
down(&sem); 
 
.....临界区 
 
up(&sem);

linux自旋锁和信号量采用的“获取锁-访问临界区-释放锁”的方式。

*************************************************************************************************************************

5.互斥体

互斥体和信号量基本上差不多。不介绍了。

总结：

并发和竞态广泛存在，这几个机制是解决问题的好方法，中断屏蔽很少单独使用，原子操作只能针对整数进行，因此，自旋锁和信号量应用最为广泛。

自旋锁会导致死循环，锁定期间不允许阻塞，因此要求锁定的临界区要小。信号量允许临界区阻塞，可以适用于临界区较大的情况。读写自旋锁和读写信号量是放宽了条件的自旋锁和信号量，他们允许多个进程并发的读取共享空间。

一个fifo的综合例子

/*====================================================================== 
    A globalfifo driver as an example of char device drivers   
    This example is to introduce poll,blocking and non-blocking access 
       
    The initial developer of the original code is Baohua Song 
    <author@linuxdriver.cn>. All Rights Reserved. 
======================================================================*/#include <linux/module.h>#include <linux/types.h>#include <linux/fs.h>#include <linux/errno.h>#include <linux/mm.h>#include <linux/sched.h>#include <linux/slab.h>#include <linux/init.h>#include <linux/cdev.h>#include <asm/io.h>#include <asm/system.h>#include <asm/uaccess.h>#include <linux/poll.h>#include <linux/time.h>#include <linux/timer.h>#include <linux/kernel.h>#include <linux/spinlock.h>#include <linux/interrupt.h>#define GLOBALFIFO_SIZE 0x1000 /*全局fifo最大4K字节*/#define FIFO_CLEAR 0x1  /*清0全局内存的长度*/#define GLOBALFIFO_MAJOR 250    /*预设的globalfifo的主设备号*/static int globalfifo_major = GLOBALFIFO_MAJOR;/*globalfifo设备结构体*/struct globalfifo_dev                                      
{                                                         
  struct cdev cdev; /*cdev结构体*/                        
  unsigned int current_len;    /*fifo有效数据长度*/ 
  unsigned char mem[GLOBALFIFO_SIZE]; /*全局内存*/         
  struct semaphore sem; /*并发控制用的信号量*/            
  wait_queue_head_t r_wait; /*阻塞读用的等待队列头*/      
  wait_queue_head_t w_wait; /*阻塞写用的等待队列头*/      
  struct tasklet_struct tlet; 
};struct globalfifo_dev *globalfifo_devp; /*设备结构体指针*//*文件打开函数*/int globalfifo_open(struct inode *inode, struct file *filp) 
{  /*将设备结构体指针赋值给文件私有数据指针*/ 
  filp->private_data = globalfifo_devp;  return 0; 
}/*文件释放函数*/int globalfifo_release(struct inode *inode, struct file *filp) 
{  return 0; 
}/* ioctl设备控制函数 */static int globalfifo_ioctl(struct inode *inodep, struct file *filp, unsigned  int cmd, unsigned long arg) 
{  struct globalfifo_dev *dev = filp->private_data;/*获得设备结构体指针*/ 
 
  switch (cmd) 
  {    case FIFO_CLEAR: 
     down(&dev->sem); //获得信号量      
      dev->current_len = 0; 
      memset(dev->mem,0,GLOBALFIFO_SIZE); 
      up(&dev->sem); //释放信号量          
      printk(KERN_INFO "globalfifo is set to zero\n");       
      break;    default:      return  - EINVAL; 
  }  return 0; 
}static unsigned int globalfifo_poll(struct file *filp, poll_table *wait) 
{ 
  unsigned int mask = 0;  struct globalfifo_dev *dev = filp->private_data; /*获得设备结构体指针*/ 
   
  down(&dev->sem); 
   
  poll_wait(filp, &dev->r_wait, wait); 
  poll_wait(filp, &dev->w_wait, wait);   
  /*fifo非空*/ 
  if (dev->current_len != 0) 
  { 
    mask |= POLLIN | POLLRDNORM; /*标示数据可获得*/ 
  }  /*fifo非满*/ 
  if (dev->current_len != GLOBALFIFO_SIZE) 
  { 
    mask |= POLLOUT | POLLWRNORM; /*标示数据可写入*/ 
  } 
      
  up(&dev->sem);  return mask; 
}/*globalfifo读函数*/static ssize_t globalfifo_read(struct file *filp, char __user *buf, size_t count, 
  loff_t *ppos) 
{  int ret;  struct globalfifo_dev *dev = filp->private_data; //获得设备结构体指针 
  DECLARE_WAITQUEUE(wait, current); //定义等待队列 
  down(&dev->sem); //获得信号量 
  add_wait_queue(&dev->r_wait, &wait); //进入读等待队列头 
 
  /* 等待FIFO非空 */ 
  if (dev->current_len == 0) 
  {    if (filp->f_flags &O_NONBLOCK) 
    { 
      ret =  - EAGAIN;      goto out; 
    }  
    __set_current_state(TASK_INTERRUPTIBLE); //改变进程状态为睡眠 
    up(&dev->sem); 
 
    schedule(); //调度其他进程执行 
    if (signal_pending(current))    //如果是因为信号唤醒    { 
      ret =  - ERESTARTSYS;      goto out2; 
    } 
 
    down(&dev->sem); 
  }  /* 拷贝到用户空间 */ 
  if (count > dev->current_len) 
    count = dev->current_len;  if (copy_to_user(buf, dev->mem, count)) 
  { 
    ret =  - EFAULT;    goto out; 
  }  else 
  { 
    memcpy(dev->mem, dev->mem + count, dev->current_len - count); //fifo数据前移 
    dev->current_len -= count; //有效数据长度减少 
    printk(KERN_INFO "read %d bytes(s),current_len:%d\n", count, dev->current_len); 
      
    wake_up_interruptible(&dev->w_wait); //唤醒写等待队列     
    ret = count; 
  }  out: up(&dev->sem); //释放信号量 
  out2:remove_wait_queue(&dev->w_wait, &wait); //从附属的等待队列头移除  set_current_state(TASK_RUNNING);  return ret; 
}/*globalfifo写操作*/static ssize_t globalfifo_write(struct file *filp, const char __user *buf, 
  size_t count, loff_t *ppos) 
{  struct globalfifo_dev *dev = filp->private_data; //获得设备结构体指针 
  int ret; 
  DECLARE_WAITQUEUE(wait, current); //定义等待队列 
  down(&dev->sem); //获取信号量 
  add_wait_queue(&dev->w_wait, &wait); //进入写等待队列头 
 
  /* 等待FIFO非满 */ 
  if (dev->current_len == GLOBALFIFO_SIZE) 
  {    if (filp->f_flags &O_NONBLOCK)    //如果是非阻塞访问    { 
      ret =  - EAGAIN;      goto out; 
    }  
    __set_current_state(TASK_INTERRUPTIBLE); //改变进程状态为睡眠 
    up(&dev->sem); 
 
    schedule(); //调度其他进程执行 
    if (signal_pending(current))    //如果是因为信号唤醒    { 
      ret =  - ERESTARTSYS;      goto out2; 
    } 
 
    down(&dev->sem); //获得信号量  }  /*从用户空间拷贝到内核空间*/ 
  if (count > GLOBALFIFO_SIZE - dev->current_len) 
    count = GLOBALFIFO_SIZE - dev->current_len;  if (copy_from_user(dev->mem + dev->current_len, buf, count)) 
  { 
    ret =  - EFAULT;    goto out; 
  }  else 
  { 
    dev->current_len += count; 
    printk(KERN_INFO "written %d bytes(s),current_len:%d\n", count, dev      ->current_len); 
 
    wake_up_interruptible(&dev->r_wait); //唤醒读等待队列     
    ret = count; 
  } 
 
 
tasklet_schedule(&dev->tlet); 
printk("in write jiffies=%ld\n",jiffies);  out: up(&dev->sem); //释放信号量 
  out2:remove_wait_queue(&dev->w_wait, &wait); //从附属的等待队列头移除  set_current_state(TASK_RUNNING);  return ret; 
}/*文件操作结构体*/static const struct file_operations globalfifo_fops ={ 
  .owner = THIS_MODULE, 
  .read = globalfifo_read, 
  .write = globalfifo_write, 
  .ioctl = globalfifo_ioctl, 
  .poll = globalfifo_poll, 
  .open = globalfifo_open, 
  .release = globalfifo_release, 
};/*初始化并注册cdev*/static void globalfifo_setup_cdev(struct globalfifo_dev *dev, int index) 
{  int err, devno = MKDEV(globalfifo_major, index); 
 
  cdev_init(&dev->cdev, &globalfifo_fops); 
  dev->cdev.owner = THIS_MODULE; 
  dev->cdev.ops = &globalfifo_fops; 
  err = cdev_add(&dev->cdev, devno, 1);  if (err) 
    printk(KERN_NOTICE "Error %d adding LED%d", err, index); 
}void jit_tasklet_fn(unsigned long arg) 
{ 
 printk("in jit_tasklet_fn  jiffies=%ld\n",jiffies); 
}/*设备驱动模块加载函数*/int globalfifo_init(void) 
{  int ret; 
  dev_t devno = MKDEV(globalfifo_major, 0);  /* 申请设备号*/ 
  if (globalfifo_major) 
    ret = register_chrdev_region(devno, 1, "globalfifo");  else  /* 动态申请设备号 */ 
 
  { 
    ret = alloc_chrdev_region(&devno, 0, 1, "globalfifo"); 
    globalfifo_major = MAJOR(devno); 
  }  if (ret < 0)    return ret;  /* 动态申请设备结构体的内存*/ 
  globalfifo_devp = kmalloc(sizeof(struct globalfifo_dev), GFP_KERNEL);  if (!globalfifo_devp)    /*申请失败*/ 
  { 
    ret =  - ENOMEM;    goto fail_malloc; 
  } 
 
  memset(globalfifo_devp, 0, sizeof(struct globalfifo_dev)); 
 
  globalfifo_setup_cdev(globalfifo_devp, 0); 
 
  init_MUTEX(&globalfifo_devp->sem);   /*初始化信号量*/ 
  init_waitqueue_head(&globalfifo_devp->r_wait); /*初始化读等待队列头*/ 
  init_waitqueue_head(&globalfifo_devp->w_wait); /*初始化写等待队列头*/ 
 /* register the tasklet */ 
 tasklet_init(&globalfifo_devp->tlet, jit_tasklet_fn, (unsigned long)globalfifo_devp);  return 0; 
 
  fail_malloc: unregister_chrdev_region(devno, 1);  return ret; 
}/*模块卸载函数*/void globalfifo_exit(void) 
{ 
  cdev_del(&globalfifo_devp->cdev);   /*注销cdev*/ 
  kfree(globalfifo_devp);     /*释放设备结构体内存*/ 
  unregister_chrdev_region(MKDEV(globalfifo_major, 0), 1); /*释放设备号*/} 
 
MODULE_AUTHOR("Song Baohua"); 
MODULE_LICENSE("Dual BSD/GPL"); 
 
module_param(globalfifo_major, int, S_IRUGO); 
 
module_init(globalfifo_init); 
module_exit(globalfifo_exit);