linux驱动之并发与竟态

一、并发与竞态
  1、中断屏蔽
    1.1中断屏蔽使用方法
    
      local_irq_disable()  //屏蔽中断  
      .........
      critical section  //临界区
      .........
      local_irq_enable()  //开中断
      ----------------------------------------
      
      local_irq_save(flags)    //除屏蔽中断外，还能保存目前CPU的中断信息
      local_irq_restore(flags)  //与上行相反的操作
      
      ----------------------------------------
      
      local_bh_disable()  //禁止中断的低半部
      local_bh_enable()  //使能中断的低半部
      
      说明：上面方法只能禁止和使能本CPU内的中断，不能解决SMP多CPU引发的竟态；
      
  2、原子操作
    2.1整形原子操作
    
      2.1.1 设置原子变量的值
        void atomic_set(atomic_t *v, int i);  //设置原子变量的值为i
        atomic_t v = ATOMIC_INIT(0);      //定义原子变量V，并初始化为0
      
      2.1.2 获取原子变量的值
        atomic_read(atomic_t *v);        //返回原子变量的值
      
      2.1.3 原子变量加减
        void atomic_add(int i, atomic_t *v);  //原子变量加
        void atomic_sub(int i, atomic_t *v);  //原子变量减
        
      2.1.4 原子变量自增、自减
        void atomic_inc(atomic_t *v);
        void atomic_dec(atomic_t *v);
        
      2.1.5 操作并测试
        void atomic_inc_and_test(atomic_t *v);
        void atomic_dec_and_test(atomic_t *v);
        void atomic_sub_test_(int i, atomic_t *v);
        
      2.1.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);
      
    2.2位原子操作
    
      2.2.1 设置位
        void set_bit(nr, void *addr);    //设置addr的第nr位，即将该位写1
        
      2.2.2 清除位
        void clear_bit(nr, void *addr);    //清除addr的第nr位，即将该位写0
      
      2.2.3 改变位
        void change_bit(nr, void *addr);  //对addr的第nr位进行反置
        
      2.2.4 测试位
        test_bit(nr, void *addr);      //返回addr地址的第nr位
        
      2.2.5 测试并操作
        int test_and_set_bit(nr, void *addr);  //
        int test_and_clear_bit(nr, void *addr);
        int test_and_change_bit(nr, void *addr);
  3、自旋锁【获取不到锁时将在原地打转，占用CPU资源，用于SMP CPU、多任务，被锁临界区小，备注：一般用自旋锁解决多CPU】
    
    3.1 自旋锁的使用
    
      3.1.1 定义自旋锁
        spinlock_t spin;
        
      3.1.2 初始化自旋锁
        spin_lock_init(lock);
        
      3.1.3 获得自旋锁
        spin_lock(lock);    //在原地打转
        spin_try_lock(lock);  //获得锁就返回真，否则就返回假，不在原地打转
        
      3.1.4 释放自旋锁
        spin_unlock(lock);    //释放自旋锁
      
      虽然自旋锁可以保证临界区不受别的CPU和本CPU内的抢占进程打扰，但是得到锁的代码容易受到中断和低半部(BH)的影响，所以的到自旋锁衍生；
      3.1.5 获得自旋锁、禁止中断
        spin_lock_irq() = spin_lock() + local_irq_disable();
      
      3.1.6 释放自旋锁、释放中断
        spin_unlock_irq() = spin_unlock() + local_irq_enable();
      
      3.1.7 获得自旋锁、保存中断标识
        spin_lock_irqsave() = spin_lock() + local_irq_save();
        
      3.1.8 释放自旋锁、还原中断标识
        spin_unlock_irqrestore() = spin_unlock() + local_irq_restore();
      
      3.1.9 获得自旋锁、禁止低半部
        spin_lock_hb() = spin_lock() + local_bh_disable();
        
      3.1.10 释放自旋锁、使能低半部
        spin_unlock_hb() = spin_unlock() + local_bh_enable();
      
    3.2 读写自旋锁
      
      3.2.1 定义和初始化读写自旋锁
        rwlock_t my_rwlock = RW_LOCK_UNLOCKED;  //静态初始化
        
        rwlock_t my_rwlock;
        rwlock_init(&my_rwlock);        //动态初始化
      
      3.2.2 读锁定
        void read_lock(rwlock_t * lock);
        void read_lock_irqsave(rwlock_t *lock, unsigned long flags);
        void read_lcok_irq(rwlock_t * lock);
        void read_lcok_bh(rwlock_t * lock);
      
      3.2.3 读解锁
        void read_unlock(rwlock_t * lock);
        void read_unlock_irqsave(rwlock_t *lock, unsigned long flags);
        void read_unlcok_irq(rwlock_t * lock);
        void read_unlcok_bh(rwlock_t * lock);
        
      3.2.2 写锁定
        void write_lock(rwlock_t * lock);
        void write_lock_irqsave(rwlock_t *lock, unsigned long flags);
        void write_lcok_irq(rwlock_t * lock);
        void write_lcok_bh(rwlock_t * lock);
      
      3.2.5 写解锁
        void write_unlock(rwlock_t * lock);
        void write_unlock_irqsave(rwlock_t *lock, unsigned long flags);
        void write_unlcok_irq(rwlock_t * lock);
        void write_unlcok_bh(rwlock_t * lock);
        
    3.3 顺序锁
      3.3.1 获得顺序锁
        void write_seqlock(seqlock_t *sl);
        int write_tryseqlock(seqlock_t *sl);
        void write_seqlock_irqsave(seqlock_t *sl, flags);
        int write_seqlock_irq(seqlock_t *sl);
        int write_seqlock_bh(seqlock_t *sl);
        
      3.3.2 释放顺序锁
        void write_sequnlock(seqlock_t *sl);
        int write_trysequnlock(seqlock_t *sl);
        void write_sequnlock_irqsave(seqlock_t *sl, flags);
        int write_sequnlock_irq(seqlock_t *sl);
        int write_sequnlock_bh(seqlock_t *sl);
      
  
  4、信号量【获取不到锁时将进入休眠，不占用CPU资源, 用于SMP CPU、多任务，被锁临界区大，备注：用于多个进程之间对资源的互斥】
    
    4.1 信号量的使用
      
      4.1.1 定义信号量
        struct semaphore sem;
      
      4.1.2 初始化信号量
        void sema_init(struct semaphore *sem, int val);    //初始化信号量，并设置信号量的值为val
        void init_MUTEX(struct semaphore *sem);        //初始化信号量，并设置信号量为1
        void init_MUTEX_LOCKED(struct semaphore *sem);    //初始化信号量，并设置信号量为0
        下面是定义并初始化信号量的“快捷方式”
        DECLARE_MUTEX(name);
        DECLARE_MUTEX_LOCKED(name);
        
      4.1.3 获得信号量
        void down(struct semaphore *sem);          //该函数用于获得信号量，会导致休眠，不能用于中断上下文
        int down_interruptible(struct semaphore *sem);    //该函数用于获得信号量，会导致休眠，可以中断
        int down_trylock(struct semaphore *sem);
        
      4.1.4 释放信号量
        void up(struct semaphore *sem);
        
      4.1.5 读写信号量
        
        4.1.5.1 定义和初始化读写信号量
          
          struct rw_semaphore my_rws;            //定义信号量
          void init_rwsem(struct rw_semaphore *sem);    //初始化信号量
        
        4.1.5.2 读信号量获取
          void down_read(struct rw_semaphore *sem);
          int down_read_trylock(struct rw_semaphore *sem);
        
        4.1.5.3 读信号量释放
          void up_read(struct rw_semaphore *sem);
          
        4.1.5.4 写信号量获取
          void down_write(struct rw_semaphore *sem);
          int down_write_trylock(struct rw_semaphore *sem);
        
        4.1.5.5 写信号量释放
          void up_write(struct rw_semaphore *sem);
  
  5、完成量用于同步【比信号量更好的同步机制】
  
  6、互斥体
    
    6.1 定义并初始化
      struct mutex my_mutex;
      mutex_init(&my_mutex);
    
    6.2 获取互斥体
      void fastcall mutex_lock(struct mutex *lock);
      void fastcall mutex_lock_interruptible(struct mutex *lock);
      void fastcall mutex_trylock(struct mutex *lock);
      
    6.3 释放互斥体
      void fastcall mutex_unlock(struct mutex *lock);