Linux 设备驱动并发控制实例

在前面的笔记中，学习了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） 信号量可以用于同步和互斥。