现在的位置: 首页 > 综合 > 正文

深入浅出Linux设备驱动之并发控制

2013年10月10日 ⁄ 综合 ⁄ 共 4943字 ⁄ 字号 评论关闭

深入浅出Linux设备驱动之并发控制

刺猬@http://blog.csdn.net/littlehedgehog

注:
该系列文章转载自arm+linux
chinaunix博客圈圈主之博客——http://blog.chinaunix.net/u/22630
/article_54997.html   为了适合我的编译环境,源代码有改动,但是相信我更改后的代码更加适合现在大多数读者的pc环境。

 
    在驱动程序中,当多个线程同时访问相同的资源时(驱动程序中的全局变量是一种典型的共享资源),可能会引发"竞态",因此我们必须对共享资源进行并发控制。Linux内核中解决并发控制的最常用方法是自旋锁与信号量(绝大多数时候作为互斥锁使用)。

  自旋锁与信号量"类似而不类",类似说的是它们功能上的相似性,"不类"指代它们在本质和实现机理上完全不一样,不属于一类。

  自旋锁不会引起调用者睡眠,如果自旋锁已经被别的执行单元保持,调用者就一直循环查看是否该自旋锁的保持者已经释放了锁,"自旋"就是"在原地打转"。而信号量则引起调用者睡眠,它把进程从运行队列上拖出去,除非获得锁。这就是它们的"不类"。[最好的理解是读源码 read the fucking source code!]

  但是,无论是信号量,还是自旋锁,在任何时刻,最多只能有一个保持者,即在任何时刻最多只能有一个执行单元获得锁。这就是它们的"类似"。

  鉴于自旋锁与信号量的上述特点,一般而言,自旋锁适合于保持时间非常短的情况,它可以在任何上下文使用;信号量适合于保持时间较长的情况,只能在进程上下文使用。如果被保护的共享资源只在进程上下文访问,则可以以信号量来保护该共享资源,如果对共享资源的访问时间非常短,自旋锁也是好的选择。但是,如果被保护的共享资源需要在中断上下文访问(包括底半部即中断处理句柄和顶半部即软中断),就必须使用自旋锁。

与信号量相关的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配对使用;

   

  1. #ifndef __KERNEL__
  2. #define __KERNEL__
  3. #endif
  4. #ifndef MODULE
  5. #define MODULE
  6. #endif
  7. #include <linux/module.h>
  8. #include <linux/init.h>
  9. #include <linux/fs.h>
  10. #include <asm/uaccess.h>
  11. #include <asm/semaphore.h>
  12. MODULE_LICENSE("GPL");
  13. #define MAJOR_NUM 250 //主设备号
  14. static ssize_t globalvar_read(struct file *, char *, size_t, loff_t*);
  15. static ssize_t globalvar_write(struct file *, const char *, size_t, loff_t*);
  16. static int globalvar_open(struct inode *,struct file *);
  17. static int globalvar_release(struct inode *,struct file *);
  18. //初始化字符设备驱动的file_operations结构体
  19. struct file_operations globalvar_fops =
  20. {
  21.     read:globalvar_read,
  22.     write:globalvar_write,
  23.     open:globalvar_open,
  24.     release:globalvar_release,
  25. };
  26. static int global_var = 0; //"globalvar"设备的全局变量
  27. static int global_count=0;
  28. static struct semaphore sem;
  29. static spinlock_t spin=SPIN_LOCK_UNLOCKED;
  30. static int __init globalvar_init(void)
  31. {
  32.     int ret;
  33.     //注册设备驱动
  34.     ret = register_chrdev(MAJOR_NUM, "globalvar", &globalvar_fops);
  35.     if (ret)
  36.         printk("globalvar register failure!/n");
  37.     else
  38.     {
  39.         printk("globalvar register success!/n");
  40.         init_MUTEX(&sem);
  41.     }
  42.     return ret;
  43. }
  44. static void __exit globalvar_exit(void)
  45. {
  46.     printk("globalvar unregister!/n");
  47.     unregister_chrdev(MAJOR_NUM, "globalvar");
  48. }
  49. static int globalvar_open(struct inode *inode,struct file *filep)
  50. {
  51.     spin_lock(&spin);   //这里就限制了只能一个进程
  52.     if(global_count)
  53.     {
  54.         spin_unlock(&spin);
  55.         return -EBUSY;
  56.     }
  57.     global_count++;
  58.     spin_unlock(&spin);
  59.     return 0;
  60. }
  61. static int globalvar_release(struct inode *inode,struct file *filep)
  62. {
  63.     global_count--;
  64.     return 0;
  65. }
  66. static ssize_t globalvar_read(struct file *filp, char *buf, size_t len, loff_t *off)
  67. {
  68.     if(down_interruptible(&sem))
  69.         return -ERESTARTSYS;
  70.     if (copy_to_user(buf, &global_var, sizeof(int)))
  71.     {
  72.         up(&sem);
  73.         return -EFAULT;
  74.     }
  75.     up(&sem);
  76.     return sizeof(int);
  77. }
  78. static ssize_t globalvar_write(struct file *filp,const char *buf,size_t len,loff_t *off)
  79. {
  80.     if(down_interruptible(&sem))
  81.         return -ERESTARTSYS;
  82. //将用户空间的数据复制到内核空间的global_var
  83.     if (copy_from_user(&global_var, buf, sizeof(int)))
  84.     {
  85.         up(&sem);
  86.         return -EFAULT;
  87.     }
  88.     up(&sem);
  89.     return sizeof(int);
  90. }
  91. module_init(globalvar_init);
  92. module_exit(globalvar_exit);
  93. MODULE_LICENSE("GPL");
  94. MODULE_AUTHOR("neo");


为了上述驱动程序的效果,我们启动两个进程分别打开/dev/globalvar。当一个进程打开/dev/globalvar后,另外一个进程将打开失败。[注意  测试程序我全部改写了一下,原作者的测试程序有点让人摸不着头脑]

  1. #include <sys/types.h>
  2. #include <sys/stat.h>
  3. #include <stdio.h>
  4. #include <fcntl.h>
  5. #include <unistd.h>
  6. //#define DEBUG 1
  7. int main()
  8. {
  9.     int fd,num,test=22;
  10.     int pid;
  11. #ifndef DEBUG
  12.     if((pid=fork())==-1)
  13.         return -1;
  14. #endif
  15.     sleep(3);   //这里休息下 是为了更好的模拟并发  不信  你可以注释掉这句   很可能父子进程都会成功地获取文件描述符 
  16.     if(!pid)
  17.         printf("I am a child /n");
  18.     else
  19.         printf("I am a parent/n");
  20.     if((fd=open("/dev/test",O_RDWR, S_IRUSR | S_IWUSR))!=-1)
  21.     {
  22.         printf("welldone!/n");
  23.         read(fd,&num,sizeof(int));
  24.         printf("the init value is %d/nnow we need to change it/n",num);
  25.         write(fd,&test,sizeof(int));
  26.         read(fd,&num,sizeof(int));
  27.         printf("%d/n",num);
  28.     }
  29.     else
  30.     {
  31.         printf("damn,we failed!/n");
  32.         perror("reason ");
  33.     }
  34.     return 0;
  35. }

抱歉!评论已关闭.