非同步通知的意思是：一旦裝置就緒，則主動通知應用程式，這樣應用程式就根本不需要查詢裝置的狀態，

這一點非常類似於硬體上的“中斷”的概念，比較準確的稱謂是“訊號驅動的非同步I/O”。訊號是在軟體層次上對

中斷機制的一種模擬，在原理上一個程序接收到一個訊號與處理器接收到一箇中斷請求是一樣的。

1>在把驅動從2.6.32 移植到2.6.36時 報錯

/home/kernel_test/globalfifo/globalfifo.c:240:2: error: unknown field 'ioctl' specified in initializer

才發現2.6.36的file_operations結構發生了重大變化。（但基本的思想還是不變的）

取消了原有的ioctl成員，新增來新的成員(變化部分在下面原始碼中用綠色字型)

1.         long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
   
2.         long (*compat_ioctl) (struct file *, unsigned int, unsigned long);

2>/home/kernel_test/globalfifo/globalfifo.c:245:2: warning: initialization from incompatible pointer type

出現此種warnning 的原因  “不

相容的指標型別初始化”

是你定義的函式型別與介面函式的型別不一樣如 把 把返回值 long 定義成了 int

要看清差異
ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);

ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);

少寫const 也會引起 warning 因為在這裡const所起的作用是 避免函式使用指標去改變了傳進來的值

以下是增加（紅色字型）非同步通知後的globalfifo 的驅動程式：

  1 /*
  2  * a globalfifo driver as example of char device drivers
  3  * This example is to introduce poll, blocking and non-blocking access
  4  *
  5  *The initial developer of the original code is Baohua Song
  6  *<

[email protected]>. All Rights Reserved
  7  *
  8  * 1>只當FIFO 中有資料時（有程序把資料寫到這個 FIFO而且沒有被 讀程序 讀空）
  9  *   讀程序才能把資料讀出，讀出後資料 從 FIFO 中拿掉
 10  * 2>只有當FIFO 非滿時（即還有空間未被讀寫或滿後被讀程序讀出了資料）
 11  *   寫程序才能往裡面寫資料，
 12  * 這樣 讀喚醒寫 寫喚醒讀
 13  */
 14
 15 #include<linux/module.h>
 16 #include<linux/types.h>
 17 #include<linux/fs.h>  /*非同步通知機制 fasync*/
 18 #include<linux/errno.h>
 19 #include<linux/mm.h>
 20 #include<linux/sched.h>
 21 #include<linux/init.h>
 22 #include<linux/cdev.h>
 23 #include<asm/io.h>
 24 #include<asm/system.h>
 25 #include<asm/uaccess.h>
 26 #include<linux/poll.h>
 27 #include <linux/ioctl.h>
 28
 29 /*不加此標頭檔案在linux-2.6.36會報錯但在linux-2.6.32.2不會*/
 30 /*使用的是arm-linux-gcc-4.5.1編譯器*/
 31 #include<linux/slab.h>
 32
 33 #define DEBUG
 34
 35 #define GLOBALFIFO_SIZE  10             /*全域性fifo最大10位元組 方便測試寫滿*/
 36 #define FIFO_CLEAR 0X1                  /*清0全域性記憶體的長度*/
 37 #define GLOBALFIFO_MAJOR 249            /*預設的globalfifo 的主裝置號*/
 38
 39 static int globalfifo_major = GLOBALFIFO_MAJOR;
 40
 41 /*globalfifo裝置結構體*/
 42 struct globalfifo_dev{
 43     struct cdev cdev;                   /*cdev結構體*/
 44     unsigned int current_len;           /*fifo有效資料長度*/
 45     unsigned char mem[GLOBALFIFO_SIZE];  /*全域性記憶體*/
 46     struct semaphore sem;               /*併發控制用的訊號量*/
 47     wait_queue_head_t r_wait;           /*阻塞讀用的等待佇列 核心 雙向 迴圈     連結串列 都可以 為頭*/
 48     wait_queue_head_t w_wait;           /*阻塞寫用的等待佇列頭*/
 49     struct fasync_struct *async_queue; /*非同步結構體指標，用於讀*/
 50 };
 51
 52 struct globalfifo_dev *globalfifo_devp; /*裝置結構體指標*/
 53
 54 /*增加支援非同步通知的函式 在release 函式中呼叫 */
 55 static int globalfifo_fasync(int fd, struct file *filp, int mode)
 56 {

 57    struct globalfifo_dev *dev = filp->private_data;

 58

 59     /*將檔案從非同步通知列表（相關程序列表）中刪除*/

 60     return fasync_helper(fd, filp, mode, &dev->async_queue);
 61 }
 62
 63 /*globalfifo讀函式*/
 64 static ssize_t globalfifo_read(struct file *filp, char __user *buf, size_t c    ount, loff_t *ppos)
 65 {
 66     int ret;
 67     struct globalfifo_dev *dev = filp->private_data;
 68     DECLARE_WAITQUEUE(wait, current);
 69
 70     down(&dev->sem);                     /*獲得訊號量*/
 71     add_wait_queue(&dev->r_wait, &wait); /*加入讀等待佇列頭 到核心*/
 72
 73     /*等待FIFO 非空*/
 74     if(dev->current_len == 0){
 75         if(filp->f_flags & O_NONBLOCK){   /*如果程序為 非阻塞開啟 裝置檔案*/
 76             ret = -EAGAIN;
 77             goto out;
 78         }
 79         __set_current_state(TASK_INTERRUPTIBLE); /*改變程序狀態為睡眠*/
 80         up(&dev->sem);                           /*釋放訊號量*/
 81
 82         schedule();                              /*排程其他程序執行*/
 83         if(signal_pending(current)){
 84                                                 /*如果是因為訊號喚醒*/
 85             ret = -ERESTARTSYS;
 86             goto out2;
 87         }
 88         down(&dev->sem);
 89     }
 90
 91     /*拷貝到使用者空間*/
 92     if(count > dev->current_len)
 93         count = dev->current_len;
 94     if(copy_to_user(buf, dev->mem, count)){
 95         ret = -EFAULT;
 96         goto out;
 97     }else{
 98         memcpy(dev->mem, dev->mem + count, dev->current_len - count);/*fifo>    資料前移*/
 99         dev->current_len -= count; /*有效資料長度減少*/
100         printk(KERN_INFO"read %d bytes(s),current_len:%d\n",count, dev->curr    ent_len);
101
102         wake_up_interruptible(&dev->w_wait); /*喚醒寫等待佇列*/
103         ret = count;
104     }
105 out:
106     up(&dev->sem); /*釋放訊號量*/
107 out2:
108     remove_wait_queue(&dev->w_wait, &wait); /*從屬的等待佇列頭移除*/
109     set_current_state(TASK_RUNNING);
110     return ret;
111 }
112
113 /*globalfifo 寫操作*/
114 static ssize_t globalfifo_write(struct file *filp, const char __user *buf, s    ize_t count, loff_t *ppos)
115 {
116     struct globalfifo_dev *dev = filp->private_data;
117     int ret;
118     DECLARE_WAITQUEUE(wait, current);    /*定義等待佇列*/
119
120     down(&dev->sem);                     /*獲得訊號量*/
121     add_wait_queue(&dev->w_wait, &wait); /*進入寫等待佇列頭*/
122
123     /*等待FIFO非滿*/
124     if(dev->current_len == GLOBALFIFO_SIZE){
125         if(filp->f_flags & O_NONBLOCK){   /*如果程序非阻塞開啟的檔案*/
126             ret = -EAGAIN;
127             goto out;
128         }
129
130         __set_current_state(TASK_INTERRUPTIBLE); /*改變程序狀態為睡眠*/
131         up(&dev->sem);                     /*釋放訊號量*/
132
133         schedule();                         /*排程其他程序執行*/
134         if(signal_pending(current)){
135                                             /*如果是因為訊號喚醒*/
136             ret = -ERESTARTSYS;
137             goto out2;
138         }
139         down(&dev->sem);                    /*獲得訊號量*/
140     }
141
142     /*從使用者空間拷貝資料到核心空間*/
143     if(count > GLOBALFIFO_SIZE - dev->current_len){
144         /*如果要拷貝的資料大於 剩餘有效記憶體長度
145          *則 只拷貝最大 能裝下的長度
146          */
147         count = GLOBALFIFO_SIZE - dev->current_len;
148     }
149     if(copy_from_user(dev->mem + dev->current_len, buf, count)){
150         ret = -EFAULT;
151         goto out;
152     }else {
153         dev->current_len += count;
154         printk(KERN_INFO"written %d bytes(s), current_len: %d\n",count, dev-    >current_len);
155
156         wake_up_interruptible(&dev->r_wait); /*喚醒讀等待佇列*/
157
158         /*產生非同步讀訊號通知相關程序 把要傳送的SIGIO 訊號傳送出去*/
159         if(dev->async_queue){
160             kill_fasync(&dev->async_queue, SIGIO, POLL_IN);
161 #ifdef DEBUG
162             printk("<0>%s kill SIGIO\n", __func__);
163 #endif
164         }
165         ret = count;
166     }
167     out:
168         up(&dev->sem); /*釋放訊號量*/
169     out2:
170         remove_wait_queue(&dev->w_wait, &wait); /*從附屬的等待佇列頭移除*/
171         set_current_state(TASK_RUNNING);
172         return ret;
173 }
174
175
176 /*ioctl 裝置控制函式*/
177 //static int globalfifo_ioctl(struct inode *inodep, struct file *filp, unsig    ned int cmd, unsigned long arg)
178 static long globalfifo_ioctl(struct file *filp, unsigned int cmd, unsigned l    ong arg)
179 {
180     struct globalfifo_dev *dev = filp->private_data;/*獲得裝置結構體指標*/
181
182     switch(cmd){
183         case FIFO_CLEAR:
184             down(&dev->sem);                        /*獲得訊號量*/
185             dev->current_len = 0;
186             memset(dev->mem, 0, GLOBALFIFO_SIZE);
187             up(&dev->sem);                          /*釋放訊號量*/
188
189             printk(KERN_INFO"globalfifo is set to zero\n");
190             break;
191
192         default:
193             return -EINVAL;
194     }
195     return 0;
196 }
197
198 /*在驅動中的增加輪詢操作*/
199 static unsigned int globalfifo_poll(struct file *filp, poll_table *wait)
200 {
201     unsigned int mask = 0;
202     struct globalfifo_dev *dev = filp->private_data;/*獲得裝置結構體指標*/
203
204     down(&dev->sem);
205     poll_wait(filp, &dev->r_wait, wait);
206     poll_wait(filp, &dev->w_wait, wait);
207
208     /*fifo非空*/
209     if(dev->current_len != 0){
210         mask |= POLLIN | POLLRDNORM; /*標示資料可以獲得*/
211     }
212
213     /*fifo 非滿*/
214     if(dev->current_len != GLOBALFIFO_SIZE){
215         mask |= POLLOUT | POLLWRNORM ; /*標示資料可以寫入*/
216     }
217
218     up(&dev->sem);
219     return mask; /*返回驅動是否可讀 或可寫的 狀態*/
220 }
221
222 /*檔案開啟函式*/
223 int globalfifo_open(struct inode *inode, struct file *filp)
224 {
225     /**/
226     filp->private_data = globalfifo_devp;
227     return 0;
228 }
229
230 /*檔案釋放函式*/
231 int globalfifo_release(struct inode *inode, struct file *filp)
232 {
233     /*將檔案從非同步通知列表中刪除*/
234     globalfifo_fasync(-1, filp, 0);
235     return 0;
236 }
237
238 /*檔案操作結構體*/
239 static const struct file_operations globalfifo_fops = {
240     .owner = THIS_MODULE,
241     .read = globalfifo_read,
242     .write = globalfifo_write,
243     //.ioctl = globalfifo_ioctl,
244     .unlocked_ioctl = globalfifo_ioctl,
245     .poll = globalfifo_poll,
246     .fasync = globalfifo_fasync, /*不要完了在這裡也要加上 與核心聯絡的介面*/
247     .open = globalfifo_open,
248     .release = globalfifo_release,
249 };
250
251 /*初始化並註冊cdev*/
252 static void globalfifo_setup_cdev(struct globalfifo_dev *dev, int index)
253 {
254     int err, devno = MKDEV(globalfifo_major, index);
255
256     cdev_init(&dev->cdev, &globalfifo_fops);
257     dev->cdev.owner = THIS_MODULE;
258     err = cdev_add(&dev->cdev, devno, 1);
259     if(err)
260         printk(KERN_NOTICE "Error %d adding LED %d", err, index);
261 }
262
263 /*裝置驅動模組載入函式*/
264 int globalfifo_init(void)
265 {
266     int ret;
267     dev_t devno = MKDEV(globalfifo_major, 0);
268
269     /*申請裝置號*/
270     if(globalfifo_major)
271         ret = register_chrdev_region(devno, 1, "globalfifo");
272     else{/*動態申請裝置號*/
273         ret = alloc_chrdev_region(&devno, 0, 1, "globalfifo");
274         globalfifo_major = MAJOR(devno);
275     }
276
277     if(ret < 0)
278         return ret;
279
280     /*動態申請裝置結構體的記憶體*/
281     globalfifo_devp = kmalloc(sizeof(struct globalfifo_dev), GFP_KERNEL);
282     if(!globalfifo_devp){
283         ret = - ENOMEM;
284 goto fail_malloc;
285     }
286
287     memset(globalfifo_devp, 0, sizeof(struct globalfifo_dev));
288
289     globalfifo_setup_cdev(globalfifo_devp, 0);
290
291     init_MUTEX(&globalfifo_devp->sem);              /*初始化訊號量*/
292     init_waitqueue_head(&globalfifo_devp->r_wait);  /*初始化讀等待佇列頭*/
293     init_waitqueue_head(&globalfifo_devp->w_wait);  /*初始化寫等待佇列頭*/
294
295     return 0;
296
297 fail_malloc: unregister_chrdev_region(devno, 1);
298              return ret;
299 }
300
301 void globalfifo_exit(void)
302 {
303     cdev_del(&globalfifo_devp->cdev); /*登出cdev*/
304     kfree(globalfifo_devp); /*釋放裝置結構體記憶體*/
305     unregister_chrdev_region(MKDEV(globalfifo_major, 0), 1); /*釋放裝置號*/
306 }
307
308 MODULE_AUTHOR("Song Baohua");
309 MODULE_LICENSE("Dual BSD/GPL");
310
311 //module_param()
312
313 module_init(globalfifo_init);
314 module_exit(globalfifo_exit);