1. 自旋鎖

1.1 概念：

自旋鎖是一種典型的對臨界資源進行互斥訪問的手段，其名稱來源於它的工作方式。為了獲得一個自旋鎖，在某 CPU 上執行的程式碼需先執行一個原子操作，該操作測試並設定某個記憶體變數，如果測試結果表示鎖已經空閒，則程式獲得這個自旋鎖並繼續執行，如果測試結果表明鎖仍被佔用，程式將在一個小的迴圈內重複這個"測試並設定"操作。當然當鎖的持有者通過重置該變數釋放這個鎖後，某個等待的操作向其使用者報告鎖已釋放。

理解鎖最簡單的方法是把它作為一個變數看待。

使用的時候需要注意一下的問題：

1. 自旋鎖是忙等鎖。使用時要求短平快
2. 可能導致系統死鎖。如果一個已經擁有某個自旋鎖的 CPU 想第二次獲得這個自旋鎖，該CPU 將鎖死。
3. 鎖定期間不能呼叫可能引起程序排程的函式。如果程序獲得自旋鎖之後再阻塞(如呼叫copy_from_user()、copy_to_user()、kmalloc()、msleep等函式)可能導致核心崩潰。

1. 2 函式：

spinlock_t lock;

spin_lock_init(lock);

spin_lock(lock);

功能：

獲得自旋鎖，

獲得，返回

不能獲得，自旋在那裡

spin_trylock(lock);

嘗試獲得自旋鎖，

能立即獲得鎖，獲得鎖返回 真

不能獲得，返回 假

spin_unlock(lock);

自旋鎖主要針對 SMP 或單 CPU 單核心支援可搶佔的情況，使臨界區不受別的 CPU 和本 CPU 內的搶佔程序打擾，但是得到鎖的程式碼路徑在執行臨界區的時候，還可能受到中斷和底半部的影響。解決辦法是：

spin_lock_irq() = spin_lock() + local_irq_disable() /* 關中斷加鎖 */

spin_unlock_irq() = spin_unlock() + local_irq_enable()

spin_lock_irqsave() = spin_lock() + local_irq_save()

spin_lock_irqrestore() = spin_unlock() + local_irq_restore()

spin_lock_bh() = spin_lock() + local_bh_disable() /* 關底半部加鎖 */

spin_unlock_bh() = spin_unlock() + local_bh_enable()

1.3 例子：

使用自旋鎖實現一個裝置只能被一個程序開啟：

int flag = 0;

struct hello_device
{
    char data[128];
    spinlock_t lock;
    struct cdev cdev;
} hello_device;


static int hello_open (struct inode *inode, struct file *file)
{
    spin_lock(&hello_device.lock);
    if ( flag )
    {
        spin_unlock(&hello_device.lock);
        return -EBUSY;
    }
    flag++;
    spin_unlock(&hello_device.lock);

    printk (KERN_INFO "Hey! device opened\n");

    return 0;
}

static int hello_release (struct inode *inode, struct file *file)
{
    spin_lock(&hello_device.lock);
    flag--;
    spin_unlock(&hello_device.lock);
    printk (KERN_INFO "Hmmm... device closed\n");

    return 0;
}

2. 讀寫自旋鎖：

對共享資源併發訪問時，多個執行單元同時讀取是沒有問題的，只要保證寫的時候只能有一個寫程序就行。

2.1定義和初始化：

rwlock_t my_rwlock = RW_LOCK_UNLOCKED; /* 靜態初始化 */

rwlock_t my_rwlock;

rwlock_init(&my_rwlock); /* 動態初始化 */

2.2讀鎖定：

void read_lock(rwlock_t *lock);

void read_lock_irqsave(rwlock_t *lock, unsigned long flags);

void read_lock_irq(rwlock_t *lock);

void read_lock_bh(rwlock_t *lock);

2.3讀解鎖：

void read_unlock(rwlock_t *lock);

void read_unlock_irqresore(rwlock_t *lock, unsigned long flags);

void read_unlock_irq(rwlock_t *lock);

void read_unlock_bh(rwlock_t *lock);

2.4寫鎖定：

void write_lock(rwlock_t *lock);

void write_lock_irqsave(rwlock_t *lock, unsigned long flags);

void write_lock_irq(rwlock_t *lock);

void write_lock_bh(rwlock_t *lock);

void write_trylock(rwlock_t *lock);

2.5寫解鎖：

void write_unlock(rwlock_t *lock);

void write_unlock_irqrestore(rwlock_t *lock, unsigned long flags);

void write_unlock_irq(rwlock_t *lock);

void write_unlock_bh(rwlock_t *lock);

在對共享資源進行寫之前，應該先呼叫寫鎖定函式，完成後應呼叫寫解鎖函式

3. 順序鎖： -- 解決的是讀寫同時進行的小的概率情況

• 如果有寫執行單元在進行寫操作，其他寫執行單元必須自旋在那裡，直到寫執行單元釋放了順序鎖
• 如果讀執行單元在讀操作期間，寫執行單元已經發生了寫操作，那麼，讀執行單元必須重新讀取資料

要求被保護的共享資源不含指標，因為寫執行單元可能使得指標失效，但讀執行單元如果正在訪問該指標，將導致 oops。

3.1 寫執行單元：

void write_seqlock(seqlock *sl); void write_tryseqlock(seqlock *sl); write_seqlock_irqsave(lock, flags); = local_irq_save() + write_seqlock() write_seqlock_irq(lock, flags); = local_irq_disable() + write_seqlock() write_seqlock_bh(lock, flags); = local_bh_disable() + write_seqlock()

void write_sequnlock(seqlock *sl); write_sequnlock_irqrestore(lock, flags); = write_sequnlock() + local_irq_restore() write_sequnlock_irq(lock, flags); = write_sequnlock() + local_irq_enable() write_sequnlock_bh(lock, flags); = write_sequnlock() + local_bh_enable()

3.2 讀執行單元：

unsigned read_seqbegin(const seqlock_t *sl); read_seqbegin_irqsave(lock, flags); = local_irq_save() + read_seqbegin()

int read_seqretry(const seqlock_t *sl, unsigned iv); read_seqretry_irqrestore(lock, iv, flags); = read_seqretry() + local_irq_restore()

do{

seqnum = read_seqbegin(&seqlock_a);

/* 讀操作程式碼塊 */

...

}while (read_seqretry(&seqlock_a, seqnum));

4. RCU：

RCU 是 Read-Copy Update 的縮寫，讀-拷貝-更新，他是基於其原理命名的，對於被 RCU 保護的共享資源，讀執行單元不需要獲得任何鎖就可以訪問它，不使用原子執行，而且在除alpha的所有架構上也不需要記憶體屏障，因此不會導致鎖競爭、記憶體延遲以及流水線停滯。

使用 RCU 的寫執行單元在訪問他前需要首先拷貝一個副本，然後對副本進行修改，最後使用一個回撥機制在適當的時機吧指向原來資料的指標重新指向新的被修改的資料，這個時機就是所有引用該資料 CPU 都退出對共享資料的操作的時候，讀執行單元沒有任何的同步開銷，寫執行單元的同步開銷則取決於使用的寫執行單元之間同步機制。