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
    . All Rights Reserved.
======================================================================*/ #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #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);