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

    <[email protected]>. 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);