深入淺出Linux設(shè)備驅(qū)動之并發(fā)控制

在驅(qū)動程序中，當(dāng)多個(gè)線程同時(shí)訪問相同的資源時(shí)（驅(qū)動程序中的全局變量是一種典型的共享資源），可能會引發(fā)"競態(tài)"，因此我們必須對共享資源進(jìn)行并發(fā)控制。Linux內(nèi)核中解決并發(fā)控制的最常用方法是自旋鎖與信號量（絕大多數(shù)時(shí)候作為互斥鎖使用）。

　　自旋鎖與信號量"類似而不類"，類似說的是它們功能上的相似性，"不類"指代它們在本質(zhì)和實(shí)現(xiàn)機(jī)理上完全不一樣，不屬于一類。

　　自旋鎖不會引起調(diào)用者睡眠，如果自旋鎖已經(jīng)被別的執(zhí)行單元保持，調(diào)用者就一直循環(huán)查看是否該自旋鎖的保持者已經(jīng)釋放了鎖，"自旋"就是"在原地打轉(zhuǎn)"。而信號量則引起調(diào)用者睡眠，它把進(jìn)程從運(yùn)行隊(duì)列上拖出去，除非獲得鎖。這就是它們的"不類"。

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

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

　　與信號量相關(guān)的API主要有：

　　定義信號量

struct semaphore sem;　

　　初始化信號量

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

　　該函數(shù)初始化信號量，并設(shè)置信號量sem的值為val

void init_MUTEX (struct semaphore *sem);

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

void init_MUTEX_LOCKED (struct semaphore *sem);

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

　　獲得信號量

void down(struct semaphore * sem);

　　該函數(shù)用于獲得信號量sem，它會導(dǎo)致睡眠，因此不能在中斷上下文使用；

int down_interruptible(struct semaphore * sem);　

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

int down_trylock(struct semaphore * sem);

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

　　釋放信號量

void up(struct semaphore * sem);

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

　　與自旋鎖相關(guān)的API主要有：

　　定義自旋鎖

spinlock_t spin;

　　初始化自旋鎖

spin_lock_init(lock)

　　該宏用于動態(tài)初始化自旋鎖lock

　　獲得自旋鎖

spin_lock(lock)

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

spin_trylock(lock)

　　該宏嘗試獲得自旋鎖lock，如果能立即獲得鎖，它獲得鎖并返回真，否則立即返回假，實(shí)際上不再"在原地打轉(zhuǎn)"；

　　釋放自旋鎖

spin_unlock(lock)

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

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

下面進(jìn)入對并發(fā)控制的實(shí)戰(zhàn)。首先，在globalvar的驅(qū)動程序中，我們可以通過信號量來控制對int global_var的并發(fā)訪問，下面給出源代碼：

#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從內(nèi)核空間復(fù)制到用戶空間
　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;
　}

　//將用戶空間的數(shù)據(jù)復(fù)制到內(nèi)核空間的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的驅(qū)動程序增加open()和release()函數(shù)，并在其中借助自旋鎖來保護(hù)對全局變量int globalvar_count（記錄打開設(shè)備的進(jìn)程數(shù)）的訪問來實(shí)現(xiàn)設(shè)備只能被一個(gè)進(jìn)程打開（必須確保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);

　　為了上述驅(qū)動程序的效果，我們啟動兩個(gè)進(jìn)程分別打開/dev/globalvar。在兩個(gè)終端中調(diào)用./globalvartest.o測試程序，當(dāng)一個(gè)進(jìn)程打開/dev/globalvar后，另外一個(gè)進(jìn)程將打開失敗，輸出"device open failure".