linux设备驱动程序之并发和竞态（二）

        其实这blog都是阅读ldd3时的一些总结，巩固自己的学习，也方便后期的使用。大家也可以直接阅读ldd3原文。

锁陷阱

        所谓的锁陷阱就是防止死锁。

        不明确的规则：

        1、不论是信号量还是 自旋锁，都不允许锁拥有者第二次获得这个锁（会死锁）。

        2、系统直接调用的那些函数要获得信号量，保护要访问的设备结构。而内部函数的访问则可以根据需要上锁。

        锁顺序规则：

        1、如果都要获取一系列锁的话，那么可以按照一定顺序规则来获取锁，即：获取多个锁时，锁的顺序一直；

        2、如果要获取自己的局部锁和系统的中心锁，则先获取自己的局部锁，然后再去获取中心锁；

        3、如果要获取信号量和自旋锁，则需要先获取信号量，因为释放信号量的函数down有可能会休眠；

        免锁算法：

        有很多的免锁算法，ldd3中提到一种循环缓存区，感觉很有用（工作中也遇到过）。

        循环缓冲区：就是比如一个数组A[9]为临界区，可以从A[0]端往A[9]端方向读取数据，从A[9]端往A[0]端写入数据。就是一个互相追逐的算法，这样可以不用锁就能保证数据的一致性；

        工作中也遇到过这种缓冲区，把请求结构体往一个循环队列中放，而内核在队列的另外一端读取请求结构体去执行。

原子操作

        原子操作在内核源代码中使用非常频繁，其实这个原子操作主要是对变量操作的。在本质上来说这也是一种锁，因为如果我们用一种锁机制去锁住一个变量，这样就有点浪费了。毕竟锁还是要耗费cpu的一些时间的，为了一个小小的变量，动用锁，不值当。所以原子操作就应运而生了。

        头文件 <asm/atomic.h>，数据结构为：atomic_t

        void  atomic_set(atomic_t  *v,  int  i); // 动态初始化，就是原子赋值：v = i

        atomic_t  v  = ATOMIC_INIT(o);// 静态初始化，在编译时初始化

        int  atomic_read(atomic_t  *v);// 返回V的当前值

        void  atomic_add(int i,  atomic_t  *v);// 将i 加到V指向的原子变量上，返回为void，是因为大多数情况下不需要这个返回值，所以不返回，降低函数成本；

        void  atomic_sub(in  i,  atomic_t  *v);// 和上面函数功能相反

        void  atomic_inc(atomic_t  *v);// 自增

        void  atomic_dec(atomic_t  *v);// 自减

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

       执行操作并测试结果：如果操作后，原子值为0，则返回true；否则返回false；

       int atomic_add_negative(int  i,  atomic_t  *v);// 将i加到v上，如果结果为负数，返回true，否则为false；

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

        执行上面对应的操作，然后返回操作后的新值V

位操作

        和原子操作类似，位操作其本质也算是一种锁机制，只是相对来说粒度会小些。信号量和自旋锁是对一段代码，一块内存等进行保护的；原子操作是对变量进行保护的；而位操作是对变量中的各个位进行设置的，当然这也是原子操作。因为原子操作非常快，可以用单个机器指令来执行，所以不用禁止中断。

        nr参数一般被定义为int，但也有些不同的系统定位为unsigned long等；        

        void  set_bit(nr,  void *addr);// 设置addr指向的数据项的第nr位

        void  clear_bit(nr,  void *addr);//清楚addr指向的数据项的第nr位

        void  change_bit(nr,  void *addr);// 切换指定位

        test_bit(nr,  void *addr);//返回当前值

        int   test_and_set_bit(nr,  void *addr);

        int   test_and_clear_bit(nr,  void *addr);

        int   test_and_change_bit(nr,  void *addr);

        执行对应的操作，并且返回  先前  的值

seqlock

        seqlock可对共享资源的快速、免锁访问。当要保护的资源很小、很简单、会频繁被访问而且写入访问很少发生且必须快速时，就可以使用seqlock。seqlock允许读取者自由访问，但要检查是否和写入者发生冲突，当发生冲突时，要重新读取数据；seqlock不保护含有指针的数据结构，因为在写入 者修改该数据的时候，读取者可能会读取一个无效的指针；

        头文件 <linux/seqlock.h> 

        初始化：

        seqlock_t   lock1 = SEQLOCK_UNLOCKED;//静态初始化

        seqlock_t   lock2;

        seqlock_init(&lock2);// 动态初始化

        读取者在访问临界区时，先获取一个无符号整数，然后完成自己的操作，退出时再获取下该整数，对比下看是否相等；如果不相等，则需要重新获取个整数==》完成操作==》退出获取参数比较；代码如下：

        unsigned  int seq;

        do {

               seq = read_seqbegin(&the_lock);

               /* 完成相应的工作 */

        }while (read_seqretry(&the_lock,  seq));

        这类锁只是用来保护简单的计算，但是需要数据一致性，所以不一致就必须重新读取数据；

        如果在中断处理例程中使用seqlock，则应该使用IRQ安全的版本：

        unsigned int read_seqbegin_irqsave(seqlock_t *lock, unsigned  long flags);

        int read_seqretry_irqrestore(seqlock_t *lock,unsigned int seq,  unsigned  long flags);

        写入者进入由seqlock保护的临界区时必须获得一个互斥量：

        void  write_seqlock(seqlock_t  *lock);

        void  write_sequnlock(seqlock_t  *lock);

        由于写入锁使用自旋锁实现，自旋锁控制写入访问，所以自旋锁的常见变种都可以使用：

        void  write_seqlock_irqsave(seqlock_t  *lock, unsigned long  flags); 

        void  write_seqlock_irq(seqlock_t  *lock);

        void  write_seqlock_bh(seqlock_t  *lock);

        void  write_sequnlock_irqrestore(seqlock_t  *lock, unsigned long  flags);

        void  write_sequnlock_irq(seqlock_t  *lock,);

        void  write_sequnlock_bh(seqlock_t  *lock);

        转载地址：http://blog.csdn.net/yuzhihui_no1/article/details/46762723