深入淺出Linux設備驅動之阻塞與非阻塞

 

深入淺出Linux設備驅動之阻塞與非阻塞

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

注: 該系列文章轉載自arm+linux chinaunix博客圈圈主之博客——http://blog.chinaunix.net/u/22630 /article_54997.html   爲了適合我的編譯環境，源代碼有改動，但是相信我更改後的代碼更加適合現在大多數讀者的pc環境。


阻塞操作是指，在執行設備操作時，若不能獲得資源，則進程掛起直到滿足可操作的條件再進行操作。被掛起的進程進入sleep狀態，被從調度器的運行隊列移走，直到等待的條件被滿足。非阻塞操作的進程在不能進行設備操作時，並不掛起。比如socket裏面的read，如果客戶端不發送數據，那麼服務端就要一直等下去。

在Linux驅動程序中，我們可以使用等待隊列（wait queue）來實現阻塞操作。wait queue很早就作爲一個基本的功能單位出現在Linux內核裏了，它以隊列爲基礎數據結構，與進程調度機制緊密結合，能夠用於實現核心的異步事件通知機制。等待隊列可以用來同步對系統資源的訪問，上節中所講述Linux信號量在內核中也是由等待隊列來實現的。

wait的API：

wait_event(queue, condition)

wait_event_interruptible(queue, condition)

wait_event_timeout(queue, condition, timeout)

wait_event_interruptible_timeout(queue, condition, timeout)

等待condition變爲true，否則一直睡眠

condition可以在任何地方被改變，但改變時須wake_up 等待隊列wq裏面的process。

喚醒函數：

void wake_up(wait_queue_head_t *queue);   //喚醒所有

void wake_up_interruptible(wait_queue_head_t *queue); //喚醒interruptible

下面我們重新定義設備"globalvar"，它可以被多個進程打開，但是每次只有當一個進程寫入了一個數據之後本進程或其它進程纔可以讀取該數據，否則一直阻塞。

1. #ifndef __KERNEL__
2. #define __KERNEL__
4. #endif
5. #ifndef MODULE
6. #define MODULE
7. #endif
9. #include <linux/module.h>
11. #include <linux/init.h>
13. #include <linux/fs.h>
15. #include <linux/wait.h>
17. #include <linux/sched.h>
19. #include <asm/uaccess.h>
21. #include <asm/semaphore.h>
23. MODULE_LICENSE("GPL");
25. #define MAJOR_NUM 250 //主設備號
27. static ssize_t globalvar_read(struct file *, char *, size_t, loff_t*);
29. static ssize_t globalvar_write(struct file *, const char *, size_t, loff_t*);
31. static int globalvar_open(struct inode *,struct file *);
33. static int globalvar_release(struct inode *,struct file *);
36. //初始化字符設備驅動的file_operations結構體
38. struct file_operations globalvar_fops =
39. {
40.     read:globalvar_read,
41.     write:globalvar_write,
42.     open:globalvar_open,
43.     release:globalvar_release,
44. };
46. static int global_var = 0; //"globalvar"設備的全局變量
47. static int global_count=0;
48. static wait_queue_head_t wait_q;    //定義等待隊列頭部
49. static int flag=0;      //這個是讀寫標誌
50. static struct semaphore sem;
51. static spinlock_t spin=SPIN_LOCK_UNLOCKED;
53. static int __init globalvar_init(void)
54. {
56.     int ret;
57.     //註冊設備驅動
58.     ret = register_chrdev(MAJOR_NUM, "globalvar", &globalvar_fops);
59.     if (ret)
60.         printk("globalvar register failure!/n");
61.     else
62.     {
63.         printk("globalvar register success!/n");
64.         init_MUTEX(&sem);
65.         init_waitqueue_head(&wait_q);
66.     }
67.     return ret;
68. }
70. static void __exit globalvar_exit(void)
71. {
72.     printk("globalvar unregister!/n");
73.     unregister_chrdev(MAJOR_NUM, "globalvar");
74. }
76. static int globalvar_open(struct inode *inode,struct file *filep)
77. {
78.     spin_lock(&spin);   //這裏就限制了只能一個進程
79.     if(global_count)
80.     {
81.         spin_unlock(&spin);
82.         return -EBUSY;
83.     }
84.     global_count++;
85.     spin_unlock(&spin);
86.     return 0;
87. }
89. static int globalvar_release(struct inode *inode,struct file *filep)
90. {
91.     global_count--;
92.     return 0;
93. }
95. static ssize_t globalvar_read(struct file *filp, char *buf, size_t len, loff_t *off)
96. {
97.     printk("0/n");   //這是我作調試用的 
98.     if(wait_event_interruptible(wait_q,flag!=0))//注意 這裏等待的條件flag==0 只要flag!=0 執行write進程會馬上喚醒這個進程
99.     {
100.         return -ERESTARTSYS;
101.     }
102.     
103.     if(down_interruptible(&sem))
104.         return -ERESTARTSYS;
105.     printk("1/n");
106.     if (copy_to_user(buf, &global_var, sizeof(int)))
107.     {
108.         up(&sem);
109.         return -EFAULT;
110.     }
111.     printk("2/n");
112.     flag=0;
113.     up(&sem);
114.     printk("3/n");
115.     return sizeof(int);
116. }
118. static ssize_t globalvar_write(struct file *filp,const char *buf,size_t len,loff_t *off)
119. {
120.     if(down_interruptible(&sem))
121.         return -ERESTARTSYS;
122. //將用戶空間的數據複製到內核空間的global_var
123.     if (copy_from_user(&global_var, buf, sizeof(int)))
124.     {
125.         up(&sem);
126.         return -EFAULT;
127.     }
128.     up(&sem);
129.     flag=1;
130.     wake_up_interruptible(&wait_q);
131.     return sizeof(int);
132. }
135. module_init(globalvar_init);
136. module_exit(globalvar_exit);
138. MODULE_LICENSE("GPL");
139. MODULE_AUTHOR("neo");

下面是測試程序，同樣，我自己改了下。最好自己寫，這樣加深瞭解   [刺蝟]

1. #include <sys/types.h>
2. #include <sys/stat.h>
3. #include <stdio.h>
4. #include <fcntl.h>
5. #include <unistd.h>
7. //#define DEBUG 
9. int main()
10. {
11.     int fd,readnum=13,writenum=22;
12.     int pid=1;
14.     if((fd=open("/dev/test",O_RDWR, S_IRUSR | S_IWUSR))==-1)
15.     {
16.         perror("damn! failed");
17.         return -1;
18.     }
20. #ifndef DEBUG
21.     if((pid=fork())==-1)
22.         return -1;
23. #endif
24.     sleep(3);
25.     if(pid)
26.     {
27.         printf("I am a parent! /nMy work is to read the globalvar device/n");
28.         sleep(3);
29.         printf("now read ... until one of my children write into it/n");
30.         read(fd,&readnum,sizeof(int));
31.         printf("at last ! someone's written %d my job's done/n",readnum);
32.     }
33.     else
34.     {
35.         printf("I am a child/nMy work is to write/n");
36.         sleep(2);
37.         printf("now write!/n");
38.         write(fd,&writenum,sizeof(int));
39.         printf("done! I write %d",writenum);
40.         sleep(8);
41.     }
42.     return 0;
43. }