在前面的筆記中，學習了Linux設備驅動中的併發控制，其中有中斷屏蔽、原子操作、自旋鎖、信號量、互斥體及完成量。這幾種併發控制的技術就是解決多進程或多CPU之間對共享資源的同時訪問引起的競態問題。它們之間根據各自的性質使用在不同的場合中，這裏就不重複的介紹了，下面來分析《Linux設備驅動開發詳解》中舉例的併發控制。
（1）首先要知道我們在Linux簡單的驅動中使用的globalmem設備的例子，其實是一段虛擬的內存，我們進行讀寫操作。有兩個函數很重要，copy_from_user(), copy_to_user()。一個是從用戶空間copy 數據，一個是將內核空間的數據copy到用戶空間，這兩個函數能夠導致阻塞，併發控制技術自旋鎖是一種原地等待的、不進行進程休眠的方法，因此不能使用自旋鎖來進行併發控制，而互斥體比較恰當使用。
我們通過例子來看：
/*自定義的設備結構體*/
//包括字符設備結構體、資源、和互斥體
struct globalmem_dev {
struct cdev cdev;
unsigned char mem[GLOBALMEM_SIZE];
struct mutex mutex; //互斥體先定義
};
/*模塊加載函數*/
static int __init globalmem_init(void)
{
int ret;
dev_t devno = MKDEV(globalmem_major, 0);
if (globalmem_major)
ret = register_chrdev_region(devno, 1, "globalmem");
else {
ret = alloc_chrdev_region(&devno, 0, 1, "globalmem");
globalmem_major = MAJOR(devno);
}
if (ret < 0)
return ret;
globalmem_devp = kzalloc(sizeof(struct globalmem_dev), GFP_KERNEL);
if (!globalmem_devp) {
ret = -ENOMEM;
goto fail_malloc;
}
//互斥體初始化
mutex_init(&globalmem_devp->mutex);
globalmem_setup_cdev(globalmem_devp, 0);
return 0;
fail_malloc:
unregister_chrdev_region(devno, 1);
return ret;
}
module_init(globalmem_init);
/*讀函數*/
static ssize_t globalmem_read(struct file *filp, char __user * buf, size_t size,loff_t * ppos)
{
unsigned long p = *ppos;
unsigned int count = size;
int ret = 0;
struct globalmem_dev *dev = filp->private_data;
if (p >= GLOBALMEM_SIZE)
return 0;
if (count > GLOBALMEM_SIZE - p)
count = GLOBALMEM_SIZE - p;
// 互斥體的使用
mutex_lock(&dev->mutex);
if (copy_to_user(buf, dev->mem + p, count)) {
ret = -EFAULT;
} else {
*ppos += count;
ret = count;
printk(KERN_INFO "read %u bytes(s) from %lu\n", count, p);
}
//互斥體釋放
mutex_unlock(&dev->mutex);
return ret;
}
/*寫函數*/
static ssize_t globalmem_write(struct file *filp, const char __user * buf,
size_t size, loff_t * ppos)
{
unsigned long p = *ppos;
unsigned int count = size;
int ret = 0;
struct globalmem_dev *dev = filp->private_data;
if (p >= GLOBALMEM_SIZE)
return 0;
if (count > GLOBALMEM_SIZE - p)
count = GLOBALMEM_SIZE - p;
// 互斥體使用
mutex_lock(&dev->mutex);
if (copy_from_user(dev->mem + p, buf, count))
ret = -EFAULT;
else {
*ppos += count;
ret = count;
printk(KERN_INFO "written %u bytes(s) from %lu\n", count, p);
}
//互斥體釋放
mutex_unlock(&dev->mutex);
return ret;
}
/*ioctl控制函數*/
static long globalmem_ioctl(struct file *filp, unsigned int cmd,
unsigned long arg)
{
struct globalmem_dev *dev = filp->private_data; /* μ éè± á11ì */
switch (cmd) {
case MEM_CLEAR:
//互斥體的使用
mutex_lock(&dev->mutex);
memset(dev->mem, 0, GLOBALMEM_SIZE);
// 互斥體的釋放
mutex_unlock(&dev->mutex);
printk(KERN_INFO "globalmem is set to zero\n");
break;
default:
return -EINVAL;
}
return 0;
}
上面的代碼除了使用了互斥體開控制dev->mem的讀寫訪問外，其他的和簡單例子沒有什麼差別，我們看到在我們訪問dev->mem這段數組的時候，不管是讀還是寫操作都使用了互斥體來保護這段臨界區。而這個互斥體在模塊加載函數中進行了初始化。
所以在以後的使用中：
（1）我們首先在自定義的設備結構體中定義一個互斥體。
（2）在模塊加載函數中初始化互斥體。
（3）在讀寫函數中使用互斥體，這就是基本的對臨界區域的訪問實行併發控制。
總結：
（1）互斥體允許臨界區阻塞。
（2） 自旋鎖不進行進程切換，一直會等待，因此要求臨界區很小。
（3） 中斷屏蔽很危險，一般不使用。
（4）原子操作只對整數進行操作。
（5） 信號量可以用於同步和互斥。