linux信号量与自旋锁

在驅動程序中，當多個線程同時訪問相同的資源時（驅動程序中的全局變量是一種典型的共享資源），可能會引發"競態"，因此我們必須對共享資源進行並發控制。Linux內核中解決並發控制的最常用方法是自旋鎖與信號量（絕大多數時候作為互斥鎖使用）。

　　自旋鎖與信號量"類似而不類"，類似說的是它們功能上的相似性，"不類"指代它們在本質和實現機理上完全不一樣，不屬於一類。

　　自旋鎖不會引起調用者睡眠，如果自旋鎖已經被別的執行單元保持，調用者就一直循環查看是否該自旋鎖的保持者已經釋放了鎖，"自旋"就是"在原地打轉"。而信號量則引起調用者睡眠，它把進程從運行隊列上拖出去，除非獲得鎖。這就是它們的"不類"。

　　但是，無論是信號量，還是自旋鎖，在任何時刻，最多只能有一個保持者，即在任何時刻最多只能有一個執行單元獲得鎖。這就是它們的"類似"。

　　鑒於自旋鎖與信號量的上述特點，一般而言，自旋鎖適合於保持時間非常短的情況，它可以在任何上下文使用；信號量適合於保持時間較長的情況，會只能在進程上下文使用。如果被保護的共享資源只在進程上下文訪問，則可以以信號量來保護該共享資源，如果對共享資源的訪問時間非常短，自旋鎖也是好的選擇。但是，如果被保護的共享資源需要在中斷上下文訪問（包括底半部即中斷處理句柄和頂半部即軟中斷），就必須使用自旋鎖。

　　與信號量相關的API主要有：

　　定義信號量

struct semaphore sem;

　　初始化信號量

void sema_init (struct semaphore *sem, int val);

　　該函數初始化信號量，並設置信號量sem的值為val

void init_MUTEX (struct semaphore *sem);

　　該函數用於初始化一個互斥鎖，即它把信號量sem的值設置為1，等同於sema_init (struct semaphore *sem, 1)；

void init_MUTEX_LOCKED (struct semaphore *sem);

　　該函數也用於初始化一個互斥鎖，但它把信號量sem的值設置為0，等同於sema_init (struct semaphore *sem, 0)；

　　獲得信號量

void down(struct semaphore * sem);

　　該函數用於獲得信號量sem，它會導致睡眠，因此不能在中斷上下文使用；

int down_interruptible(struct semaphore * sem);

　　該函數功能與down類似，不同之處為，down不能被信號打斷，但down_interruptible能被信號打斷；

int down_trylock(struct semaphore * sem);

　　該函數嘗試獲得信號量sem，如果能夠立刻獲得，它就獲得該信號量並返回0，否則，返回非0值。它不會導致調用者睡眠，可以在中斷上下文使用。

　　釋放信號量

void up(struct semaphore * sem);

　　該函數釋放信號量sem，喚醒等待者。

　　與自旋鎖相關的API主要有：

　　定義自旋鎖

spinlock_t spin;

　　初始化自旋鎖

spin_lock_init(lock)

　　該宏用於動態初始化自旋鎖lock

　　獲得自旋鎖

spin_lock(lock)

　　該宏用於獲得自旋鎖lock，如果能夠立即獲得鎖，它就馬上返回，否則，它將自旋在那裏，直到該自旋鎖的保持者釋放；

spin_trylock(lock)

　　該宏嘗試獲得自旋鎖lock，如果能立即獲得鎖，它獲得鎖並返回真，否則立即返回假，實際上不再"在原地打轉"；

　　釋放自旋鎖

spin_unlock(lock)

　　該宏釋放自旋鎖lock，它與spin_trylock或spin_lock配對使用；

　　除此之外，還有一組自旋鎖使用於中斷情況下的API。

下面進入對並發控制的實戰。首先，在globalvar的驅動程序中，我們可以通過信號量來控制對int global_var的並發訪問，下面給出源代碼：

#include <linux/module.h> #include <linux/init.h> #include <linux/fs.h> #include <asm/uaccess.h> #include <asm/semaphore.h> MODULE_LICENSE("GPL"); #define MAJOR_NUM 254 static ssize_t globalvar_read(struct file *, char *, size_t, loff_t*); static ssize_t globalvar_write(struct file *, const char *, size_t, loff_t*); struct file_operations globalvar_fops = { 　read: globalvar_read, write: globalvar_write, }; static int global_var = 0; static struct semaphore sem; static int __init globalvar_init(void) { 　int ret; 　ret = register_chrdev(MAJOR_NUM, "globalvar", &globalvar_fops); 　if (ret) 　{ 　　printk("globalvar register failure"); 　} 　else 　{ 　　printk("globalvar register success"); 　　init_MUTEX(&sem); 　} 　return ret; } static void __exit globalvar_exit(void) { 　int ret; 　ret = unregister_chrdev(MAJOR_NUM, "globalvar"); 　if (ret) 　{ 　　printk("globalvar unregister failure"); 　} 　else 　{ 　　printk("globalvar unregister success"); 　} } static ssize_t globalvar_read(struct file *filp, char *buf, size_t len, loff_t *off) { 　//獲得信號量 　if (down_interruptible(&sem)) 　{ 　　return - ERESTARTSYS; 　} 　//將global_var從內核空間復制到用戶空間 　if (copy_to_user(buf, &global_var, sizeof(int))) 　{ 　　up(&sem); 　　return - EFAULT; 　} 　//釋放信號量 　up(&sem); 　return sizeof(int); } ssize_t globalvar_write(struct file *filp, const char *buf, size_t len, loff_t *off) { 　//獲得信號量 　if (down_interruptible(&sem)) 　{ 　　return - ERESTARTSYS; 　} 　//將用戶空間的數據復制到內核空間的global_var 　if (copy_from_user(&global_var, buf, sizeof(int))) 　{ 　　up(&sem); 　　return - EFAULT; 　} 　//釋放信號量 　up(&sem); 　return sizeof(int); } module_init(globalvar_init); module_exit(globalvar_exit);

　　接下來，我們給globalvar的驅動程序增加open()和release()函數，並在其中借助自旋鎖來保護對全局變量int globalvar_count（記錄打開設備的進程數）的訪問來實現設備只能被一個進程打開（必須確保globalvar_count最多只能為1）：

#include <linux/module.h> #include <linux/init.h> #include <linux/fs.h> #include <asm/uaccess.h> #include <asm/semaphore.h> MODULE_LICENSE("GPL"); #define MAJOR_NUM 254 static ssize_t globalvar_read(struct file *, char *, size_t, loff_t*); static ssize_t globalvar_write(struct file *, const char *, size_t, loff_t*); static int globalvar_open(struct inode *inode, struct file *filp); static int globalvar_release(struct inode *inode, struct file *filp); struct file_operations globalvar_fops = { 　read: globalvar_read, write: globalvar_write, open: globalvar_open, release: globalvar_release, }; static int global_var = 0; static int globalvar_count = 0; static struct semaphore sem; static spinlock_t spin = SPIN_LOCK_UNLOCKED; static int __init globalvar_init(void) { 　int ret; 　ret = register_chrdev(MAJOR_NUM, "globalvar", &globalvar_fops); 　if (ret) 　{ 　　printk("globalvar register failure"); 　} 　else 　{ 　　printk("globalvar register success"); 　　init_MUTEX(&sem); 　} 　return ret; } static void __exit globalvar_exit(void) { 　int ret; 　ret = unregister_chrdev(MAJOR_NUM, "globalvar"); 　if (ret) 　{ 　　printk("globalvar unregister failure"); 　} 　else 　{ 　　printk("globalvar unregister success"); 　} } static int globalvar_open(struct inode *inode, struct file *filp) { 　//獲得自選鎖 　spin_lock(&spin); 　//臨界資源訪問 　if (globalvar_count) 　{ 　　spin_unlock(&spin); 　　return - EBUSY; 　} 　globalvar_count++; 　//釋放自選鎖 　spin_unlock(&spin); 　return 0; } static int globalvar_release(struct inode *inode, struct file *filp) { 　globalvar_count--; 　return 0; } static ssize_t globalvar_read(struct file *filp, char *buf, size_t len, loff_t *off) { 　if (down_interruptible(&sem)) 　{ 　　return - ERESTARTSYS; 　} 　if (copy_to_user(buf, &global_var, sizeof(int))) 　{ 　　up(&sem); 　　return - EFAULT; 　} 　up(&sem); 　return sizeof(int); } static ssize_t globalvar_write(struct file *filp, const char *buf, size_t len, loff_t *off) { 　if (down_interruptible(&sem)) 　{ 　　return - ERESTARTSYS; 　} 　if (copy_from_user(&global_var, buf, sizeof(int))) 　{ 　　up(&sem); 　　return - EFAULT; 　} 　up(&sem); 　return sizeof(int); } module_init(globalvar_init); module_exit(globalvar_exit);

　　為了上述驅動程序的效果，我們啟動兩個進程分別打開/dev/globalvar。在兩個終端中調用./globalvartest.o測試程序，當一個進程打開/dev/globalvar後，另外一個進程將打開失敗，輸出"device open failure"，如下圖：