spin_lock_init()用来初始化动态创建的自旋锁。

  1. #ifdef CONFIG_DEBUG_SPINLOCK
  2.   extern void __spin_lock_init(spinlock_t *lock, const char *name,
  3.                    struct lock_class_key *key);
  4. # define spin_lock_init(lock)                   \
  5. do {                                \
  6.     static struct lock_class_key __key;         \
  7.                                 \
  8.     __spin_lock_init((lock), #lock, &__key);        \
  9. } while (0)
  10.  
  11. #else
  12. # define spin_lock_init(lock)                   \
  13.     do { *(lock) = SPIN_LOCK_UNLOCKED; } while (0)
  14. #endif
  15.  
  16. #ifdef CONFIG_DEBUG_SPINLOCK
  17.   extern void __rwlock_init(rwlock_t *lock, const char *name,
  18.                 struct lock_class_key *key);
  19. # define rwlock_init(lock)                  \
  20. do {                                \
  21.     static struct lock_class_key __key;         \
  22.                                 \
  23.     __rwlock_init((lock), #lock, &__key);           \
  24. } while (0)
  25. #else
  26. # define rwlock_init(lock)                  \
  27.     do { *(lock) = RW_LOCK_UNLOCKED; } while (0)
  28. #endif
  29.  
  1. #define spin_is_locked(lock)    __raw_spin_is_locked(&(lock)->raw_lock)
  1. #define spin_trylock(lock)      __cond_lock(lock, _spin_trylock(lock))

spin_trylock()试图获得某个特定的自旋锁，如果该锁已经被争用，那么立刻返回非0值，而不会自旋等待锁被释放；如果获得这个自旋锁，返回0。

spin_is_locked()用于检查特定的锁当前是否已被占用，如被占用返回非0，否则返回0。

  1. #define spin_lock(lock)         _spin_lock(lock)
  2. /*
  3.  * We inline the unlock functions in the nondebug case:
  4.  */
  5. #if defined(CONFIG_DEBUG_SPINLOCK) || defined(CONFIG_PREEMPT) || \
  6.     !defined(CONFIG_SMP)
  7. # define spin_unlock(lock)      _spin_unlock(lock)
  8. #else
  9. # define spin_unlock(lock) \
  10.     do {__raw_spin_unlock(&(lock)->raw_lock); __release(lock); } while (0)
  11.  

自旋锁和下半部

函数spin_lock_bh()用于获取指定锁，同时它会禁止所有下半部的执行。spin_unlock_bh()函数执行相反的操作。

  1. #define spin_lock_bh(lock)      _spin_lock_bh(lock)
  2. #define spin_unlock_bh(lock)        _spin_unlock_bh(lock)
  3.  
  4. void __lockfunc _spin_lock_bh(spinlock_t *lock)
  5. {
  6.     local_bh_disable();
  7.     preempt_disable();
  8.     spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
  9.     _raw_spin_lock(lock);
  10. }
  11.  
  12. void __lockfunc _spin_unlock_bh(spinlock_t *lock)
  13. {
  14.     spin_release(&lock->dep_map, 1, _RET_IP_);
  15.     _raw_spin_unlock(lock);
  16.     preempt_enable_no_resched();
  17.     local_bh_enable_ip((unsigned long)__builtin_return_address(0));
  18. }
  19.  
  由于下半部可以抢占进程上下文中的代码，所以当下半部和进程上下文共享数据时，必须对进程上下文中的共享数据进行包含，所以需要加锁的同时还要禁止下半部执行。同样，由于中断处理程序可以抢占下半部，所以如果中断处理程序和下半部共享数据，那么就必须在获取恰当的锁的同时还有禁止中断。
————————————————————————————————————————————————

自旋锁与互斥锁有点类似，只是自旋锁不会引起调用者睡眠，如果自旋锁已经被别的执行单元保持，调用者就一直循环在那里看是否该自旋锁的保持者已经释放了锁，"自旋"一词就是因此而得名。

由于自旋锁使用者一般保持锁时间非常短，因此选择自旋而不是睡眠是非常必要的，自旋锁的效率远高于互斥锁。

信号量和读写信号量适合于保持时间较长的情况，它们会导致调用者睡眠，因此只能在进程上下文使用（_trylock的变种能够在中断上下文使用），而自旋锁适合于保持时间非常短的情况，它可以在任何上下文使用。

如果被保护的共享资源只在进程上下文访问，使用信号量保护该共享资源非常合适，如果对共巷资源的访问时间非常短，自旋锁也可以。但是如果被保护的共享资源需要在中断上下文访问（包括底半部即中断处理句柄和顶半部即软中断），就必须使用自旋锁。

自旋锁保持期间是抢占失效的，而信号量和读写信号量保持期间是可以被抢占的。自旋锁只有在内核可抢占或SMP的情况下才真正需要，在单CPU且不可抢占的内核下，自旋锁的所有操作都是空操作。

跟互斥锁一样，一个执行单元要想访问被自旋锁保护的共享资源，必须先得到锁，在访问完共享资源后，必须释放锁。如果在获取自旋锁时，没有任何执行单元保持该锁，那么将立即得到锁；如果在获取自旋锁时锁已经有保持者，那么获取锁操作将自旋在那里，直到该自旋锁的保持者释放了锁。

无论是互斥锁，还是自旋锁，在任何时刻，最多只能有一个保持者，也就说，在任何时刻最多只能有一个执行单元获得锁。

自旋锁的API有：

de>spin_lock_init(x)de>

该宏用于初始化自旋锁x。自旋锁在真正使用前必须先初始化。该宏用于动态初始化。

de>DEFINE_SPINLOCK(x)de>

该宏声明一个自旋锁x并初始化它。该宏在2.6.11中第一次被定义，在先前的内核中并没有该宏。

de>SPIN_LOCK_UNLOCKEDde>

该宏用于静态初始化一个自旋锁。

de>DEFINE_SPINLOCK(x)等同于spinlock_t x = SPIN_LOCK_UNLOCKEDspin_is_locked(x)de>

该宏用于判断自旋锁x是否已经被某执行单元保持（即被锁），如果是，返回真，否则返回假。

de>spin_unlock_wait(x)de>

该宏用于等待自旋锁x变得没有被任何执行单元保持，如果没有任何执行单元保持该自旋锁，该宏立即返回，否则将循环在那里，直到该自旋锁被保持者释放。

de>spin_trylock(lock)de>

该宏尽力获得自旋锁lock，如果能立即获得锁，它获得锁并返回真，否则不能立即获得锁，立即返回假。它不会自旋等待lock被释放。

de>spin_lock(lock)de>

该宏用于获得自旋锁lock，如果能够立即获得锁，它就马上返回，否则，它将自旋在那里，直到该自旋锁的保持者释放，这时，它获得锁并返回。总之，只有它获得锁才返回。

de>spin_lock_irqsave(lock, flags)de>

该宏获得自旋锁的同时把标志寄存器的值保存到变量flags中并失效本地中断。

de>spin_lock_irq(lock)de>

该宏类似于spin_lock_irqsave，只是该宏不保存标志寄存器的值。

de>spin_lock_bh(lock)de>

该宏在得到自旋锁的同时失效本地软中断。

de>spin_unlock(lock)de>

该宏释放自旋锁lock，它与spin_trylock或spin_lock配对使用。如果spin_trylock返回假，表明没有获得自旋锁，因此不必使用spin_unlock释放。

de>spin_unlock_irqrestore(lock, flags)de>

该宏释放自旋锁lock的同时，也恢复标志寄存器的值为变量flags保存的值。它与spin_lock_irqsave配对使用。

de>spin_unlock_irq(lock)de>

该宏释放自旋锁lock的同时，也使能本地中断。它与spin_lock_irq配对应用。

de>spin_unlock_bh(lock)de>

该宏释放自旋锁lock的同时，也使能本地的软中断。它与spin_lock_bh配对使用。

de>spin_trylock_irqsave(lock, flags)de>

 
该宏如果获得自旋锁lock，它也将保存标志寄存器的值到变量flags中，并且失效本地中断，如果没有获得锁，它什么也不做。 

因此如果能够立即获得锁，它等同于spin_lock_irqsave，如果不能获得锁，它等同于spin_trylock。如果该宏获得自旋锁lock，那需要使用spin_unlock_irqrestore来释放。

de>spin_trylock_irq(lock)de>

该宏类似于spin_trylock_irqsave，只是该宏不保存标志寄存器。如果该宏获得自旋锁lock，需要使用spin_unlock_irq来释放。

de>spin_trylock_bh(lock)de>

该宏如果获得了自旋锁，它也将失效本地软中断。如果得不到锁，它什么也不做。因此，如果得到了锁，它等同于spin_lock_bh，如果得不到锁，它等同于spin_trylock。如果该宏得到了自旋锁，需要使用spin_unlock_bh来释放。

de>spin_can_lock(lock)de>

该宏用于判断自旋锁lock是否能够被锁，它实际是spin_is_locked取反。如果lock没有被锁，它返回真，否则，返回假。该宏在2.6.11中第一次被定义，在先前的内核中并没有该宏。

获得自旋锁和释放自旋锁有好几个版本，因此让读者知道在什么样的情况下使用什么版本的获得和释放锁的宏是非常必要的。

如果被保护的共享资源只在进程上下文访问和软中断上下文访问，那么当在进程上下文访问共享资源时，可能被软中断打断，从而可能进入软中断上下文来对被保护的共享资源访问，因此对于这种情况，对共享资源的访问必须使用spin_lock_bh和spin_unlock_bh来保护。

当然使用spin_lock_irq和spin_unlock_irq以及spin_lock_irqsave和spin_unlock_irqrestore也可以，它们失效了本地硬中断，失效硬中断隐式地也失效了软中断。但是使用spin_lock_bh和spin_unlock_bh是最恰当的，它比其他两个快。

如果被保护的共享资源只在进程上下文和tasklet或timer上下文访问，那么应该使用与上面情况相同的获得和释放锁的宏，因为tasklet和timer是用软中断实现的。

如果被保护的共享资源只在一个tasklet或timer上下文访问，那么不需要任何自旋锁保护，因为同一个tasklet或timer只能在一个CPU上运行，即使是在SMP环境下也是如此。实际上tasklet在调用tasklet_schedule标记其需要被调度时已经把该tasklet绑定到当前CPU，因此同一个tasklet决不可能同时在其他CPU上运行。

timer也是在其被使用add_timer添加到timer队列中时已经被帮定到当前CPU，所以同一个timer绝不可能运行在其他CPU上。当然同一个tasklet有两个实例同时运行在同一个CPU就更不可能了。

如果被保护的共享资源只在两个或多个tasklet或timer上下文访问，那么对共享资源的访问仅需要用spin_lock和spin_unlock来保护，不必使用_bh版本，因为当tasklet或timer运行时，不可能有其他tasklet或timer在当前CPU上运行。

如果被保护的共享资源只在一个软中断（tasklet和timer除外）上下文访问，那么这个共享资源需要用spin_lock和spin_unlock来保护，因为同样的软中断可以同时在不同的CPU上运行。

如果被保护的共享资源在两个或多个软中断上下文访问，那么这个共享资源当然更需要用spin_lock和spin_unlock来保护，不同的软中断能够同时在不同的CPU上运行。

如果被保护的共享资源在软中断（包括tasklet和timer）或进程上下文和硬中断上下文访问，那么在软中断或进程上下文访问期间，可能被硬中断打断，从而进入硬中断上下文对共享资源进行访问，因此，在进程或软中断上下文需要使用spin_lock_irq和spin_unlock_irq来保护对共享资源的访问。

而在中断处理句柄中使用什么版本，需依情况而定，如果只有一个中断处理句柄访问该共享资源，那么在中断处理句柄中仅需要spin_lock和spin_unlock来保护对共享资源的访问就可以了。

因为在执行中断处理句柄期间，不可能被同一CPU上的软中断或进程打断。但是如果有不同的中断处理句柄访问该共享资源，那么需要在中断处理句柄中使用spin_lock_irq和spin_unlock_irq来保护对共享资源的访问。

在使用spin_lock_irq和spin_unlock_irq的情况下，完全可以用spin_lock_irqsave和spin_unlock_irqrestore取代，那具体应该使用哪一个也需要依情况而定，如果可以确信在对共享资源访问前中断是使能的，那么使用spin_lock_irq更好一些。

因为它比spin_lock_irqsave要快一些，但是如果你不能确定是否中断使能，那么使用spin_lock_irqsave和spin_unlock_irqrestore更好，因为它将恢复访问共享资源前的中断标志而不是直接使能中断。

当然，有些情况下需要在访问共享资源时必须中断失效，而访问完后必须中断使能，这样的情形使用spin_lock_irq和spin_unlock_irq最好。

需要特别提醒读者，spin_lock用于阻止在不同CPU上的执行单元对共享资源的同时访问以及不同进程上下文互相抢占导致的对共享资源的非同步访问，而中断失效和软中断失效却是为了阻止在同一CPU上软中断或中断对共享资源的非同步访问。