linux设备驱动中的并发控制

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

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);