不可睡眠锁：自旋锁spinlock编码学习

开源力量学习笔记

自旋锁（spinlock）简介
自旋锁是内核的一种同步机制，在同一时刻只能被最多一个内核任务持有，所以一个时刻只有一个线程允许存在于临界区中。
内核可以通过自旋锁占有某些资源，直到使用完后再释放锁。如果该资源已经被其他的任务占有了，那内核会不断等待，直到获得该资源。
这点可以应用在多处理机器、或运行在单处理器上的抢占式内核中需要的锁定服务。

自旋锁（spinlock）的基本形式API
初始化：   
    在编译时定义：DEFINE_SPINLOCK();
    在运行时初始化：spin_lock_init();
持有锁和释放锁：
    spin_lock();
//临界区
    spin_unlock();

自旋锁代码编程示例：

1. #include <linux/module.h>
   
2. #include <linux/kthread.h>
   
3. #include <linux/delay.h>
   
4. 
   
5. MODULE_LICENSE("GPL");
   
6. MODULE_AUTHOR("Chen");
   
7. MODULE_DESCRIPTION("The module is only used for test.");
   
8. 
   
9. //static DEFINE_SPINLOCK(threads_lock);
   
10. static spinlock_t threads_lock;
    
11. 
    
12. static void threads_lock_init(void)
    
13. {
    
14.     spin_lock_init(&threads_lock);
    
15. }
    
16. 
    
17. struct our_data{
    
18.     int count1;
    
19.     int count2;
    
20. };
    
21. 
    
22. static struct our_data my_data;
    
23. 
    
24. static void show_my_data(void)
    
25. {
    
26.     printk("count1 %d,count2 %d\n", my_data.count1, my_data.count2);
    
27. }
    
28. 
    
29. #define MAX_KTHREAD 10
    
30. 
    
31. static struct task_struct *threads[MAX_KTHREAD];
    
32. 
    
33. static int thread_do(void *data)
    
34. {
    
35.     printk("run ...\n");
    
36.     while(!kthread_should_stop()){
    
37.         spin_lock(&threads_lock);
    
38.         my_data.count1++;
    
39.         my_data.count2 += 10;
    
40.         spin_unlock(&threads_lock);
    
41. 
    
42.         msleep(10);
    
43.     }
    
44.     return 0;
    
45. }
    
46. 
    
47. static int create_threads(void)
    
48. {
    
49.     int i;
    
50.     for(i=0 ; i < MAX_KTHREAD; i++)
    
51.     {
    
52.         struct task_struct *thread;
    
53.         thread = kthread_run(thread_do, NULL, "thread-%d", i);
    
54.         if(IS_ERR(thread))
    
55.             return -1;
    
56. 
    
57.         threads[i] = thread;
    
58.     }
    
59.     return 0;
    
60. }
    
61. 
    
62. static void cleanup_threads(void)
    
63. {
    
64.     int i;
    
65. 
    
66.     for (i = 0; i < MAX_KTHREAD; i++)
    
67.         if(threads[i])
    
68.             kthread_stop(threads[i]);
    
69. }
    
70. 
    
71. static __init int minit(void)
    
72. {
    
73.     printk("call %s.\n",__FUNCTION__);
    
74.     threads_lock_init();
    
75.     if (create_threads())
    
76.         goto err;
    
77.     return 0;
    
78. 
    
79. err:
    
80.     cleanup_threads();
    
81.     return -1;
    
82. }
    
83. 
    
84. static __exit void mfini(void)
    
85. {
    
86.     printk("call %s.\n",__FUNCTION__);
    
87.     cleanup_threads();
    
88.     show_my_data();
    
89. }
    
90. 
    
91. module_init(minit);
    
92. module_exit(mfini); 

运行结果：

1. chen@ubuntu:~/mygit/module/exam1$ dmesg
   
2. [ 3475.623885] call minit.
   
3. [ 3475.625348] run ...
   
4. [ 3475.625363] run ...
   
5. [ 3475.625375] run ...
   
6. [ 3475.625386] run ...
   
7. [ 3475.625397] run ...
   
8. [ 3475.625546] run ...
   
9. [ 3475.625562] run ...
   
10. [ 3475.625574] run ...
    
11. [ 3475.625594] run ...
    
12. [ 3475.627184] run ...
    
13. [ 3480.215762] call mfini.
    
14. [ 3480.353601] count1 2899,count2 28990