linux輸入子系統(Input Subsystem)

        Linux 的輸入子系統不僅支持鼠標、鍵盤等常規輸入設備,而且還支持蜂鳴器、觸摸屏等設備。本章將對 Linux 輸

入子系統進行詳細的分析。

一    前言

        輸入子系統又叫 input 子系統。其構建非常靈活,只需要調用一些簡單的函數,就可以將一個輸入設備的功能呈現

給應用程序。

二   設備驅動層

        本節將講述一個簡單的輸入設備驅動實例。

        這個輸入設備只有一個按鍵,按鍵被連接到一條中斷線上,當按鍵被按下時,將產生一個中斷,內核將檢測到這個中

斷,并對其進行處理。該實例的代碼如下:

#include <asm/io.h>

 }

        button_dev = input_allocate_device();     /*分配一個設備結構體*/

        //input_allocate_device()函數在內存中為輸入設備結構體分配一個空間,并對其主要的成員進行了初始化.    

         if (!button_dev)

         }

         button_dev->keybit[BIT_Word(BTN_0)] = BIT_MASK(BTN_0);

       //分別用來設置設備所產生的事件以及上報的按鍵值。Struct iput_dev中有兩個成員，一個是evbit.一個是keybit.分別用

       //表示設備所支持的動作和鍵值。

        return 0;

         input_free_device(button_dev);

}

      這個實例程序代碼比較簡單,在初始化函數 button_init()中注冊了一個中斷處理函數,然后調用

input_allocate_device()函數分配了一個 input_dev 結構體,并調用 input_register_device()函數對其進行了注冊。在中

斷處理函數 button_interrupt()中,實例將接收到的按鍵信息上報給 input 子系統。從而通過 input 子系統,向用戶態程序

提供按鍵輸入信息。本實例采用了中斷方式,除了中斷相關的代碼外,實例中包含了一些 input 子系統提供的函數,現對

其中一些重要的函數進行分析。

三  核心層

input_allocate_device()函數,驅動開發人員為了更深入的了解 input 子系統,應該對其代碼有一點的認識,該函數的代碼

如下:

struct input_dev *input_allocate_device(void){        struct input_dev *dev;        dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL);  /*分配一個 input_dev 結構體,并初始化為 0*/       if (dev) 

       {              dev->dev.type = &input_dev_type;   /*初始化設備的類型*/

             dev->dev.class = &input_class;  

             device_initialize(&dev->dev); 

             mutex_init(&dev->mutex);   // 初始話互斥鎖

             spin_lock_init(&dev->event_lock);  // 初始化自旋鎖

             INIT_LIST_HEAD(&dev->h_list);   //初始化鏈表

             INIT_LIST_HEAD(&dev->node);  

             __module_get(THIS_MODULE);      }

      return dev;

}

        該函數返回一個指向 input_dev 類型的指針,該結構體是一個輸入設備結構體,包含了輸入設備的一些相關信息,如

設備支持的按鍵碼、設備的名稱、設備支持的事件等。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

Input設備注冊的接口為：input_register_device()。代碼如下：

         __set_bit(EV_SYN, dev->evbit); 

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

調用__set_bit()函數設置 input_dev 所支持的事件類型。事件類型由 input_dev 的evbit 成員來表示,在這里將其 EV_SYN 置位,表示設

備支持所有的事件。注意,一個設備可以支持一種或者多種事件類型。常用的事件類型如下:

1. #define EV_SYN     0x00   /*表示設備支持所有的事件*/2. #define EV_KEY     0x01  /*鍵盤或者按鍵,表示一個鍵碼*/3. #define EV_REL     0x02  /*鼠標設備,表示一個相對的光標位置結果*/4. #define EV_ABS     0x03  /*手寫板產生的值,其是一個絕對整數值*/5. #define EV_MSC     0x04  /*其他類型*/6. #define EV_LED     0x11   /*LED 燈設備*/7. #define EV_SND     0x12  /*蜂鳴器,輸入聲音*/8. #define EV_REP     0x14   /*允許重復按鍵類型*/9. #define EV_PWR     0x16   /*電源管理事件*/

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

                   dev->setkeycode = input_default_setkeycode;

//檢查 getkeycode()函數和 setkeycode()函數是否被定義,如果沒定義,則使用默認的處理函數,這兩個函數為

//input_default_getkeycode()和 input_default_setkeycode()。input_default_getkeycode()函數用來得到指定位置的鍵

//值。input_default_setkeycode()函數用來設置鍵值。具體啥用處，我也沒搞清楚？

//設置 input_dev 中的 device 的名字,名字以 input0、input1、input2、input3、input4等的形式出現在 sysfs

//文件系統中.         error = device_add(&dev->dev); 

                   return error; 

//使用 device_add()函數將 input_dev 包含的 device 結構注冊到 Linux 設備模型中,并可以在 sysfs

//文件系統中表現出來。

         list_add_tail(&dev->node, &input_dev_list);

//調用 list_add_tail()函數將 input_dev 加入 input_dev_list 鏈表中,input_dev_list 鏈

//表中包含了系統中所有的 input_dev 設備。

                   input_attach_handler(dev, handler);

//將input device 掛到input_dev_list鏈表上.然后，對每一個掛在input_handler_list的handler調用

//input_attach_handler().在這里的情況有好比設備模型中的device和driver的匹配。所有的input device都掛在

//input_dev_list鏈上。所有的handler都掛在input_handler_list上。

====================================================================================

匹配是在input_attach_handler()中完成的。代碼如下：static int input_attach_handler(struct input_dev *dev, struct input_handler *handler){          const struct input_device_id *id;          int error;            if (handler->blacklist && input_match_device(handler->blacklist, dev))                    return -ENODEV; 

//首先判斷 handler的 blacklist 是否被賦值,如果被賦值,則匹配 blacklist 中的數據跟 dev->id 的數據是否匹配。blacklist

//是一個 input_device_id*的類型,其指向 input_device_ids的一個表,這個表中存放了驅動程序應該忽略的設備。即使在

//id_table 中找到支持的項,也應該忽略這種設備。         id = input_match_device(handler->id_table, dev);

//調用 input_match_device()函數匹配 handler->>id_table 和 dev->id 中的數據。如果不成功則返回。

handle->id_table 也是一個 input_device_id 類型的指針,其表示驅動支持的設備列表。

         if (!id)                    return -ENODEV;            error = handler->connect(handler, dev, id);

//如果匹配成功,則調用 handler->connect()函數將 handler 與 input_dev 連接起來。

// 在connect() 中會調用input_register_handle，而這些都需要handler的注冊。

         if (error && error != -ENODEV)                    printk(KERN_ERR                             "input: failed to attach handler %s to device %s, "                             "error: %d/n",                             handler->name, kobject_name(&dev->dev.kobj), error);            return error; } //如果handler的blacklist被賦值。要先匹配blacklist中的數據跟dev->id的數據是否匹配。匹配成功過后再來匹配

//handle->id和dev->id中的數據。如果匹配成功，則調用handler->connect().

====================================================================================

//匹配設備廠商的信息,設備號的信息。

                   MATCH_BIT(swbit,  SW_MAX); 

--------------------------------------------------------------------------------------------------------------------------------------

--------------------------------------------------------------------------------------------------------------------------------------

//簡而言之,注冊input device的過程就是為input device設置默認值，并將其掛以input_dev_list.與掛載在//input_handler_list中的handler相匹配。如果匹配成功，就會調用handler的connect函數.

====================================================================================

        這一條線先講到這里因為接下去就要講handler ，那就是事件層的東西了， 我們先把核心層的東西講完，

在前面的設備驅動層中的中斷響應函數里面，有input_report_key 函數 ，下面我們來看看他。

         input_report_key()函數向輸入子系統報告發生的事件,這里就是一個按鍵事件。在 button_interrupt()中斷函數中,

不需要考慮重復按鍵的重復點擊情況,input_report_key()函數會自動檢查這個問題,并報告一次事件給輸入子系統。該

函數的代碼如下:

{        input_event(dev, EV_KEY, code, !!value);

}      該函數的第 1 個參數是產生事件的輸入設備, 2 個參數是產生的事件, 3 個參數是事件的值。需要注意的是, 第2 個

參數可以取類似 BTN_0、 BTN_1、BTN_LEFT、BTN_RIGHT 等值,這些鍵值被定義在 include/linux/input.h 文件中。

當第 2 個參數為按鍵時,第 3 個參數表示按鍵的狀態,value 值為 0 表示按鍵釋放,非 0 表示按鍵按下。＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

        在 input_report_key()函數中正在起作用的函數是 input_event()函數,該函數用來向輸入子系統報告輸入設備產生

的事件,這個函數非常重要,它的代碼如下:

 void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value) {        unsigned long flags;        if (is_event_supported(type, dev->evbit, EV_MAX)) {  //檢查輸入設備是否支持該事件        spin_lock_irqsave(&dev->event_lock, flags);        add_input_randomness(type, code, value);

//函數對事件發送沒有一點用處,只是用來對隨機數熵池增加一些貢獻,因為按鍵輸入是一種隨機事件,

//所以對熵池是有貢獻的。        input_handle_event(dev, type, code, value);

//調用 input_handle_event()函數來繼續輸入子系統的相關模塊發送數據。        spin_unlock_irqrestore(&dev->event_lock, flags);}====================================================================================

        input_handle_event()函數向輸入子系統傳送事件信息。第 1 個參數是輸入設備 input_dev,第 2 個參數是事件的類

型,第 3 個參數是鍵碼,第 4 個參數是鍵值。

        瀏覽一下該函數的大部分代碼,主要由一個 switch 結構組成。該結構用來對不同的事件類型,分別處理。其中 case

語句包含了 EV_SYN、 EV_KEY、EV_SW、EV_SW、EV_SND 等事件類型。在這么多事件中,本例只要關注

EV_KEY 事件,因為本節的實例發送的是鍵盤事件。其實,只要對一個事件的處理過程了解后,對其他事件的處理過程也

就清楚了。該函數的代碼如下:

static void input_handle_event(struct input_dev *dev,{        unsigned int type, unsigned int code, int value)        int disposition = INPUT_IGNORE_EVENT; 

//定義了一個 disposition 變量,該變量表示使用什么樣的方式處理事件        switch (type) {                case EV_SYN:                        switch (code)

                     {                                case SYN_CONFIG:                                        disposition = INPUT_PASS_TO_ALL;                                        break;                                case SYN_REPORT:                                if (!dev->sync) 

                            {                                        dev->sync = 1;                                        disposition = INPUT_PASS_TO_HANDLERS;                                }                                break;                        }                               break;               case EV_KEY:                         if (is_event_supported(code, dev->keybit, KEY_MAX) &&!!test_bit(code, dev->key) != value)

                           //函數判斷是否支持該按鍵

                     {                                if (value != 2) 

                            {                                        __change_bit(code, dev->key);                                        if (value)                                                input_start_autorepeat(dev, code);   //處理重復按鍵的情況                                  }                                disposition = INPUT_PASS_TO_HANDLERS;

 //將 disposition變量設置為 INPUT_PASS_TO_HANDLERS,表示事件需要 handler 來處理。

---------------------------------------------------------------------------------------------------------------------

disposition 的取值有如下幾種:1. #define INPUT_IGNORE_EVENT           02. #define INPUT_PASS_TO_HANDLERS         13. #define INPUT_PASS_TO_DEVICE         24. #define INPUT_PASS_TO_ALL                 (INPUT_PASS_TO_HANDLERS | INPUT_PASS_TO_DEVICE)

            INPUT_IGNORE_EVENT  表示忽略事件,不對其進行處理。

           INPUT_PASS_ TO_HANDLERS  表示將事件交給 handler 處理。           INPUT_PASS_TO_DEVICE  表示將事件交給 input_dev 處理。           INPUT_PASS_TO_ALL 表示將事件交給 handler 和 input_dev 共同處理。

--------------------------------------------------------------------------------------------------------------------

                     }                        break;                case EV_SW:                        if (is_event_supported(code, dev->swbit, SW_MAX) &&!!test_bit(code, dev->sw) != value)

                     {                                __change_bit(code, dev->sw);                                disposition = INPUT_PASS_TO_HANDLERS;                         }                        break;                case EV_ABS:                                if (is_event_supported(code, dev->absbit, ABS_MAX))

                            {                                        value = input_defuzz_abs_event(value,                                        dev->abs[code], dev->absfuzz[code]);                                        if (dev->abs[code] != value)

                                   {                                                dev->abs[code] = value;                                                disposition = INPUT_PASS_TO_HANDLERS;

                                     }

                            }

                             break;                case EV_REL:                        if (is_event_supported(code, dev->relbit, REL_MAX) && value)                                disposition = INPUT_PASS_TO_HANDLERS;                        break;                case EV_MSC:                        if (is_event_supported(code, dev->mscbit, MSC_MAX))                                disposition = INPUT_PASS_TO_ALL;                        break;                case EV_LED:                        if (is_event_supported(code, dev->ledbit, LED_MAX) &&!!test_bit(code, dev->led) != value)

                     {                                __change_bit(code, dev->led);                                disposition = INPUT_PASS_TO_ALL;                        }                      break;                case EV_SND:                        if (is_event_supported(code, dev->sndbit, SND_MAX))

                     {                                if (!!test_bit(code, dev->snd) != !!value)                                        __change_bit(code, dev->snd);                                disposition = INPUT_PASS_TO_ALL;                        }                        break;                case EV_REP:                        if (code <= REP_MAX && value >= 0 && dev->rep[code] != value)

                     {                             dev->rep[code] = value;                             disposition = INPUT_PASS_TO_ALL;                      }                      break;               case EV_FF:                      if (value >= 0)                             disposition = INPUT_PASS_TO_ALL;                             break;                      case EV_PWR:                             disposition = INPUT_PASS_TO_ALL;                      break;        }        if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)              dev->sync = 0;        if ((disposition &INPUT_PASS_TO_DEVICE) && dev->event)               dev->event(dev, type, code, value);

//首先判斷 disposition 等于 INPUT_PASS_TO_DEVICE,然后判斷 dev->event 是否對其指定了一個處理函數,如果這些

//條件都滿足,則調用自定義的 dev->event()函數處理事件。

//有些事件是發送給設備,而不是發送給 handler 處理的。event()函數用來向輸入子系統報告一個將要發送給設備的事

//件,例如讓 LED 燈點亮事件、蜂鳴器鳴叫事件等。當事件報告給輸入子系統后,就要求設備處理這個事件。

       if (disposition & INPUT_PASS_TO_HANDLERS)               input_pass_event(dev, type, code, value);}

====================================================================================

        struct input_handle *handle;

       rcu_read_lock();

       handle = rcu_dereference(dev->grab);

//得到 dev->grab 的指針。grab 是強制為 input device 的 handler,這時要調用 handler的 event 函數。

       if (handle)

              handle->handler->event(handle, type, code, value);        else

              list_for_each_entry_rcu(handle, &dev->h_list, d_node)  //一般情況下走這里        if (handle->open) 

              handle->handler->event(handle,type, code, value);

//如果該 handle 被打開,表示該設備已經被一個用戶進程使用。就會調用與輸入設備對應的 handler 的 event()函數。

//注意,只有在 handle 被打開的情況下才會接收到事件,這就是說,只有設備被用戶程序使用時,才有必要向用戶空間導出

//信息

//此處亦是用到了handle ，核心層就到此為止，前面也講過在device和handler  connect() 時會調用

//input_register_handle，而這些都需要handler的注冊,所以接下來我們看看事件層        rcu_read_unlock(); }

四   事件層

        input_handler 是輸入子系統的主要數據結構,一般將其稱為 handler 處理器,表示對輸入事件的具體處理。

input_handler 為輸入設備的功能實現了一個接口,輸入事件最終傳遞到handler 處理器,handler 處理器根據一定的規則,

然后對事件進行處理,具體的規則將在下面詳細介紹。        輸入子系統由驅動層、輸入子系統核心層(Input Core)和事件處理層(Event Handler)3 部分組成。一個輸入事件,

如鼠標移動,鍵盤按鍵按下等通過驅動層->系統核心層->事件處理層->用戶空間的順序到達用戶空間并傳給應用程序使

用。其中 Input Core 即輸入子系統核心層由 driver/input/input.c 及相關頭文件實現。其對下提供了設備驅動的接口,對

上提供了事件處理層的編程接口。輸入子系統主要設計 input_dev、input_handler、input_handle 等數據結構.

struct input_dev物理輸入設備的基本數據結構,包含設備相關的一些信息

struct input_handler 事件處理結構體,定義怎么處理事件的邏輯

        在evdev.c 中：

--------------------------------------------------------------------------------------------------------------------------------

 struct input_handler {

void *private; 

void (*event)(struct input_handle *handle, unsigned int type,

unsigned int code, int value);

const struct input_device_id *id_table; //定義了一個 name, 表示 handler 的名字,顯示在/proc/bus/input/handlers 目錄 

                                                             //中。

--------------------------------------------------------------------------------------------------------------------------------

//事件層注冊

====================================================================================

int input_register_handler(struct input_handler *handler)

        int retval;

        INIT_LIST_HEAD(&handler->h_list);

//其中的 handler->minor 表示對應 input 設備結點的次設備號。 handler->minor以右移 5 位作為索引值插入到 //input_table[ ]中

        if (handler->fops != NULL)

        {

               if (input_table[handler->minor >> 5])

               {

        }

        list_add_tail(&handler->node, &input_handler_list);

//調用 list_add_tail()函數,將 handler 加入全局的 input_handler_list 鏈表中,該鏈表包含了系統中所有的 input_handler

        input_attach_handler(dev, handler);

//主 要 調 用 了 input_attach_handler() 函 數 。 該 函 數 在 input_register_device()函數的第 35 行曾詳細的介紹過。//input_attach_handler()函數的作用是匹配 input_dev_list 鏈表中的 input_dev 與 handler。如果成功會將 input_dev 

//與 handler 聯系起來。也就是說在注冊handler和dev時都會去調用該函數。

====================================================================================

        ok下面我們來看下handle的注冊，在前面evdev_handler結構體中，有一個.connect    = evdev_connect, 在

connect里面會注冊handle，在前面注冊dev，匹配成功后調用。

//分配了一個 evdev結構 ,并對這個結構進行初始化 .在這里我們可以看到 ,這個結構封裝了一個 handle結構 ,這結構與

//我們之前所討論的 handler是不相同的 .注意有一個字母的差別哦 .我們可以把 handle看成是 handler和 input device

//的信息集合體 .在這個結構里集合了匹配成功的 handler和 input device

//在這段代碼里主要完成 evdev封裝的 device的初始化 .注意在這里 ,使它所屬的類指向 input_class.這樣在 /sysfs中創

//建的設備目錄就會在 /sys/class/input/下面顯示 .

====================================================================================

int input_register_handle(struct input_handle *handle){         struct input_handler *handler = handle->handler;         struct input_dev *dev = handle->dev;         int error;          /*          * We take dev->mutex here to prevent race with          * input_release_device().          */         error = mutex_lock_interruptible(&dev->mutex);         if (error)                   return error;         list_add_tail_rcu(&handle->d_node, &dev->h_list);         mutex_unlock(&dev->mutex);         synchronize_rcu();          /*          * Since we are supposed to be called from ->connect()          * which is mutually exclusive with ->disconnect()          * we can't be racing with input_unregister_handle()          * and so separate lock is not needed here.          */         list_add_tail(&handle->h_node, &handler->h_list);          if (handler->start)                   handler->start(handle);          return 0;}         將handle掛到所對應input device的h_list鏈表上.還將handle掛到對應的handler的hlist鏈表上.如果handler定

義了start函數,將調用之. 到這里,我們已經看到了input device, handler和handle是怎么關聯起來的了

====================================================================================

             接下來我們看看上報信息是調用的  .event        = evdev_event       。

       每當input device上報一個事件時,會將其交給和它匹配的handler的event函數處理.在evdev中.這個event函數

對應的代碼為: 

===================================================================================

static void evdev_pass_event(struct evdev_client *client,                                  struct input_event *event) {          /*           * Interrupts are disabled, just acquire the lock           */          spin_lock(&client->buffer_lock);          client->buffer[client->head++] = *event;          client->head &= EVDEV_BUFFER_SIZE - 1;          spin_unlock(&client->buffer_lock);            kill_fasync(&client->fasync, SIGIO, POLL_IN); } 

    這里的操作很簡單.就是將event(上傳數據)保存到client->buffer中.而client->head就是當前的數據位置.注意這里

是一個環形緩存區.寫數據是從client->head寫.而讀數據則是從client->tail中讀.

====================================================================================

       最后我們看下handler的相關操作函數    .fops        = &evdev_fops,  

    我們知道.對主設備號為INPUT_MAJOR的設備節點進行操作,會將操作集轉換成handler的操作集.在evdev中,這個

操作集就是evdev_fops.對應的open函數如下示: 

static int evdev_open(struct inode *inode, struct file *file) {          struct evdev *evdev;          struct evdev_client *client;          int i = iminor(inode) - EVDEV_MINOR_BASE;          int error;            if (i >= EVDEV_MINORS)                    return -ENODEV;            error = mutex_lock_interruptible(&evdev_table_mutex);          if (error)                    return error;          evdev = evdev_table[i];          if (evdev)                    get_device(&evdev->dev);          mutex_unlock(&evdev_table_mutex);            if (!evdev)                    return -ENODEV;            client = kzalloc(sizeof(struct evdev_client), GFP_KERNEL);          if (!client) {                    error = -ENOMEM;                    goto err_put_evdev;          }          spin_lock_init(&client->buffer_lock);          client->evdev = evdev;          evdev_attach_client(evdev, client);            error = evdev_open_device(evdev);          if (error)                    goto err_free_client;            file->private_data = client;          return 0;    err_free_client:          evdev_detach_client(evdev, client);          kfree(client);  err_put_evdev:          put_device(&evdev->dev);          return error; } 

====================================================================================

        evdev_open_device()函數用來打開相應的輸入設備，使設備準備好接收或者發送數據。evdev_open_device()函

數先獲得互斥鎖，然后檢查設備是否存在，并判斷設備是否已經被打開。如果沒有打開，則調用 input_open_device()

函數打開設備.

static int evdev_open_device(struct evdev *evdev) {          int retval;            retval = mutex_lock_interruptible(&evdev->mutex);          if (retval)                    return retval;            if (!evdev->exist)                    retval = -ENODEV;          else if (!evdev->open++) {                    retval = input_open_device(&evdev->handle);                    if (retval)                             evdev->open--;          }            mutex_unlock(&evdev->mutex);          return retval; } 

====================================================================================

       對于evdev設備節點的read操作都會由evdev_read()完成.它的代碼如下: 

static ssize_t evdev_read(struct file *file, char __user *buffer,                               size_t count, loff_t *ppos) {          struct evdev_client *client = file->private_data;          struct evdev *evdev = client->evdev;          struct input_event event;          int retval;            if (count < evdev_event_size())                    return -EINVAL;            if (client->head == client->tail && evdev->exist &&              (file->f_flags & O_NONBLOCK))                    return -EAGAIN;            retval = wait_event_interruptible(evdev->wait,                    client->head != client->tail || !evdev->exist);          if (retval)                    return retval;            if (!evdev->exist)                    return -ENODEV;            while (retval + evdev_event_size() <= count &&                 evdev_fetch_next_event(client, &event)) {                      if (evdev_event_to_user(buffer + retval, &event))                             return -EFAULT;                      retval += evdev_event_size();          }            return retval; } 

      首先,它判斷緩存區大小是否足夠.在讀取數據的情況下,可能當前緩存區內沒有數據可讀.在這里先睡眠等待緩存

區中有數據.如果在睡眠的時候,.條件滿足.是不會進行睡眠狀態而直接返回的. 然后根據read()提夠的緩存區大小.將

client中的數據寫入到用戶空間的緩存區中.

五  用戶空間

                 到這就沒啥講的了， ok到此為止吧！！！

參考網頁：http://hi.baidu.com/%B7%E8%D7%D3%D6%AE%CD%BD/blog/item/f4ed8135a4258c2d0b55a940.html

                    http://blog.csdn.net/changjiang654/article/details/6154622

轉自：http://blog.csdn.net/lbmygf/article/details/7360084