作業系統是如何將資料讀到緩衝區的，發生了什麼？我們帶著這樣的問題，粗略走一下read呼叫系統過程，希望這個初探，可以喚起大家研究作業系統核心的好奇心和興趣，並以此為例，讓我們先初步對請求在過濾塊裝置驅動中的處理過程有個大概印象和了解。

塊裝置在整個Linux中應用的總體結構圖如下：

從上圖可以看出，塊裝置的應用在Linux中是一個完整的子系統。 最上面是虛擬檔案系統層，其作用是遮蔽下層具體檔案系統操作的差異，為上層的操作提供一個統一的介面。有了這個層次，可以把裝置抽象成檔案，使得操作裝置就像操作檔案一樣簡單。在具體的檔案系統層中，不同的檔案系統（例如 ext2 和 NTFS）具體的操作過程也是不同的，每種檔案系統定義了自己的操作集合。引入 cache 層的目的是為了提高 linux 作業系統對磁碟訪問的效能，cache 層在記憶體中快取了磁碟上的部分資料，當資料的請求到達時，如果在 cache 中存在該資料且是最新的，則直接將資料傳遞給使用者程式，免除了對底層磁碟的操作，提高了效能。

接下來是通用塊層，其主要工作是：接收上層發出的磁碟請求，並最終發出 IO 請求。該層隱藏了底層硬體塊裝置的特性，為塊裝置提供了一個通用的抽象檢視。然後下面是IO 排程層，其功能是接收通用塊層發出的 IO 請求，快取請求並試圖合併相鄰的請求（如果這兩個請求的資料在磁碟上是相鄰的）。根據設定好的排程演算法，回撥驅動層提供的請求處理函式，來處理具體的 IO 請求。驅動層中的驅動程式對應具體的物理塊裝置，它從上層中取出 IO 請求，並根據該 IO 請求中指定的資訊，通過向具體塊裝置的裝置控制器傳送命令的方式，來操縱裝置傳輸資料。

大家都寫過read讀檔案的資料，你想知道或者探祕read到底是如何把資料讀上來的嗎，作業系統是如何處理的，linux是如何處理的，從現在開始讓我們逐漸養成尋根究底的學習方法，能夠主動思考或者探祕作業系統行為，這樣才能逐漸理解作業系統的工作原理，逐漸理解linux核心的設計藝術和實現原理，也才能夠逐漸往高手的水平上邁進。讓我們分析一下一個讀請求從應用層到核心層的全過程，來分析read系統呼叫的真正工作原理，也充分理解一下請求是如何走到塊裝置驅動層，然後塊裝置做了哪些處理把請求最終提交到磁碟完成資料請求的，這樣就為塊裝置學習開啟了入門之路。

關鍵路徑點初探：

   從應用層開始呼叫glibc庫的read函式，經過glibc庫的處理，最終通過作業系統核心提供的sys_read函式系統呼叫進入核心。［再回頭看看第一章中的核心系統架構圖，核心klib庫中系統呼叫是核心一個機制，系統呼叫中發生了什麼事，cpu相關關鍵暫存器做了什麼切換，我們現在先提出來，先不具體講解，繼續我們的主線初探過程］

   進入核心sys_read函式處理，我們進入了核心IO路徑上的第一個模組層VFS虛擬檔案系統層，首先根據sys_read函式中指定的檔案描述符和要訪問的檔案資料起始地址，去記憶體上找一找，是否記憶體中已經快取了我們要讀取的檔案資料，如果有，直接從記憶體拷貝一份到我們申請的buffer中即可，在這裡我們知道了一個很關鍵的作業系統知識點，應用read函式提供的buffer 與  核心記憶體快取是不一樣的，核心中管理的記憶體資料需要拷貝給使用者空間的buffer才可以，使用者空間的程式是不能直接訪問和使用核心中的快取資料的；如果沒有快取資料，則sys_read會繼續往下走，首先VFS會為我們要讀取的檔案資料單獨申請一下核心記憶體空間，這個記憶體空間是後續從磁碟真正把資料讀上來時要存放的地方，我們不能直接往使用者空間read函式提供的buffer中存放資料，這是linux核心架構機制決定的，我們先記住這是一個約定，是否感覺核心好麻煩，已經有記憶體buffer了還要申請記憶體，這樣的事情後續還有很多，我們通過課程的逐漸加深會一一為大家解答，但是現在先不要過於心急，繼續我們的初探之路；

   VFS為其分配了快取後，sys_read便從VFS 層進入到了具體檔案系統層的IO程式碼處理中，為啥要進入具體檔案系統，因為只有檔案系統才知道檔案資料在磁碟的真正位置，所以既然接下來要從磁碟上獲取資料了，那一定要通過具體檔案系統知道檔案資料的真實磁碟位置，我們從read函式的介面輸入引數上也可以看出，我們並沒有指定我們從磁碟那個位置進行讀取；

   具體檔案系統轉換請求地址後，會構造塊裝置請求（bio），我們由此接觸到了過濾塊裝置驅動第一個最核心的資料結構 －塊裝置請求描述資料結構bio，就是block device input/output的縮寫。檔案系統會把bio提交給過濾塊裝置驅動。

   過濾塊裝置驅動收到請求後，會繼續轉發給底層真實的硬體磁碟驅動，進而由其進行資料讀取操作。

整個過程的初探之路結束了，這裡面沒有涉及程式碼的細節，只是通過初探讓大家先整體上粗略的走一下真實的作業系統核心處理請求的過程，接下來讓我們趕緊開始實戰吧，真正的挑戰要開始了。

經過第一節一個簡單的I/O路徑的資料流動介紹，現在讓我們開始真正的進入邏輯塊裝置驅動的學習，因為linux核心中的關鍵模組和術語太多了，較為抽象，但是理解和掌握後，相信大家一定會感覺事情就是這麼簡單，也就會覺得為什麼要把它描述的那麼複雜和抽象，不就是那麼回事嗎，所以我們首先先給I/O 路徑上的各個模組簡單打個比方，用一個較為形象的例子帶領大家腳踏實地，完成一個簡單過濾塊裝置驅動模組，進而以此為基礎，把作業系統／國內外講解核心的書中經常提到的自旋鎖，訊號量，程序，記憶體分配，工作佇列，實踐在我們的過濾塊裝置驅動模組中，由此我們不僅可以在核心裡面開發了，同時我們開發的模組在核心中是多麼的重要，同時通過我們開發的模組還能快速把一些核心機制／API使用上，一切是那麼的自然，這就是我們的目標，我們不希望千篇一律再把龐大的核心翻來覆去的抽象講解，我們就是要腳踏實地，踏踏實實的真正進入核心做開發，通過過濾塊裝置驅動的編寫，會為我們成功開啟核心學習和實戰的視窗，從而為後續核心分析及修煉之路打下堅實的實戰技能基礎。

［小知識：塊裝置與字元裝置］

系統中能夠隨機讀取（不需要按順序）訪問固定大小資料片（chunk）的裝置被稱作塊裝置，這些資料片就稱作塊。最常見的塊裝置是硬碟，除此之外，還有軟盤驅動器、CD-ROM驅動器和快閃記憶體等許多其他裝置。它們都是以安裝檔案系統的方式使用的——這也是塊裝置通常的訪問方式。塊裝置分為物理塊裝置（實際的磁碟）和邏輯塊裝置（磁碟分割槽，LVM等）。塊裝置可以用來建立檔案系統、載入解除安裝、儲存資料，也可以用來建立分割槽。

Linux裝置的每個裝置都由唯一的一個裝置號標識，裝置號由主裝置號和次裝置號組成；主裝置號標識裝置的型別及對應的驅動程式；次裝置號對應具體的裝置。Linux系統負責管理全域性裝置號，裝置驅動負責申請裝置號（可以通過ll /dev/xxx命令檢視裝置號；cat/proc/devices可以檢視系統中已使用的裝置號）。

與字元裝置的區別：

字元裝置按照字元流的方式被有序訪問，如串列埠和鍵盤就都屬於字元裝置，如果一個硬體裝置是以字元流的方式訪問的話，那就應該將它歸於字元裝置，反過來，如果一個裝置是隨機（無序的）訪問的，那麼它就屬於塊裝置。根本區別是它們能否可以被隨機訪問，也就是說，能否在訪問裝置時隨意的從一個位置跳轉到另一個位置。塊裝置只能以塊為單位接受輸入和返回輸出，而字元裝置以位元組為單位，只能被順序讀寫。

我們仍然以一個讀請求的處理過程為例進行，首先大家先看一個例子，最近X公司耗費精力籌寫了一本鉅著，書內容非常龐大，該公司以512頁為單位，將這本書分開存放在一個祕密的儲存室裡，由於這本書內容太龐大，並且就只有一本，許多讀者想借閱，為了滿足大家的需要，X公司規定大家把每次需要借閱的書的頁碼起始數和頁數準備好，公司會根據讀者的需要找到書後進行復印，把影印件提供給讀者。

寫到這，大家應該能夠明白X公司相當於檔案系統，它知道讀者需要的頁碼對應的內容在儲存室的哪個位置存放，儲存室就相當於我們的磁碟。Ok，我們繼續把這個事情打比喻，請大家繼續耐心。

X公司為了竭力保護好儲存室，他們把儲存室的位置放置在城市的郊區，同時為了更好的服務讀者，他們在市區租用了一個小型的臨時儲存室，預先存放書籍的部分影印件，主要是考慮到大部分讀者都在市區工作，郊區太遠，不方便，如果臨時儲存室有讀者需要的書籍，則直接影印給讀者，如果沒有則去郊區的儲存室找到檔案進行復印。同時為了更加安全的考慮，X公司在市區和郊區之間構建了三個虛擬的儲存室站點A,B,C，樣子看上去象是一個很大的實體儲存室，其實裡面空空的，什麼都沒有，只是個樣子而已，空間都是虛擬的，之所以這麼做，是X公司想更好的保護圖書，以免出現安全問題。這樣市區到郊區的路程就變為，市區－>A站點－>B站點－>C站點－>郊區。同時規定市區的人員只知道書存放在A站點，A站點的人員會知道書其實存放在B站點，B站點的人員其實只知道書存放在C站點，而C站點才真正知道書存放在郊區的地點。

寫到這，大家又會進一步明白，市區的臨時儲存室相當於VFS快取層，而A/B/C就是我們要給大家介紹的過濾塊裝置驅動模組，大家可以看到過濾塊裝置驅動可以層疊很多，我們現在是三個過濾塊裝置疊加。

       我們繼續再定義幾個概念，讀者在市區借閱，如果市區的臨時儲存室沒有影印件，則X公司會準備一個快遞包，這個快遞包就是個空盒子，裡面什麼也沒有，但是要注意空盒子雖然是空的，但是不是誰都可以申請到的，空盒子有數量限制，如果申請太多了，讀者就會被告知現在資源比較緊張，請稍等。好了，如果空盒子申請到了，那麼是否就可以開始傳送了，稍等，我們還要在盒子上做點標記，起碼我們要寫上讀者要讀的書的頁碼和頁數，當然還有最重要的一個標記就是這個空盒子的目的地，即這個盒子要發到A這個站點，A站點收到盒子後，會繼續發給B，此時它要把盒子的目的地標記修改為B, B收到後修改目的地，會繼續發給C, C會繼續發到X公司的郊區站點。

       好了，以上提到的空盒子就是大名鼎鼎的BIO, 它就是描述一個請求的。當這個請求也就是空盒子被髮到郊區站點時，注意此時還有一道關卡，這到關卡準備了一些大箱子，內容頁碼連續的空盒子被放在同樣的大箱子中，關卡會暫時快取一下這些大箱子，等空盒子差不多積攢的夠多了，然後統一送到最終的儲存室，最後書籍會按照需求影印出來。上面的大箱子就是request, 而關卡就是request_queue請求佇列。

此時我們再介紹三個概念：gendisk，hd_struct和block_device, 不管是臨時站點A/B/C, 還是郊區的儲存點，都會對應一個gendisk描述結構，該結構描述了臨時站點或者儲存點的門牌號（major,minor號碼），儲存容量大小等資訊，雖然A/B/C都是虛擬的站點，但是也被寫上了一個虛擬容量，讓大家看上去象那麼回事，感覺就是一個真實的物理磁碟塊裝置。然後是hd_struct，大家都知道對磁碟進行分割槽，一個分割槽就會用一個hd_struct結構進行描述，記錄分割槽的大小，起始位置等資訊。最後至於block_device結構，這個結構其實也是描述裝置資訊的，同時它也要描述檔案系統相關的部分資訊，具體的我們現在先不介紹，我們仍然以資料流動的過程為主，暫時先不跟進具體的細節資訊，我們只要明確一件事情，一個gendisk會對應的一個block_device,  如果gendisk有分割槽，則每個分割槽hd_struct也會對應一個block_device。

至此我們介紹了六個主要的資料結構，下面讓我們繼續描述如何構建塊裝置過濾驅動。還是接著借書的例子，A/B/C要建立虛擬倉庫，首先我們要向作業系統申請註冊並申請門牌號，這個申請的介面就是（register_blk_device）, 申請了門牌號，接著需要申請倉庫了，也就是我們的gendisk, 通過alloc_disk完成，接著我們要申請倉庫的關卡－請求佇列，通過alloc_queue完成，當然我們要申明一下，並不是所有的虛擬倉庫都會用到這個關卡即請求佇列，我們舉的例子中是沒有使用的，後面我們會舉例使用關卡的情況，在我們這個例子中，只有郊區的儲存室使用了請求佇列，如下圖，我們再描述一下看看，A/B/C三個虛擬倉庫都有自己的請求佇列，但是都沒有實際使用，這當然可以，作業系統並沒有強制規定，必須使用請求佇列，這是沒問題的。這此我們介紹了三個很重要的虛擬倉庫申請函式，接下來我們讓重點描述一個函式－ make_request, 我們繼續舉例，A/B/C每個臨時倉庫，接收到請求後要進行加工處理，這就是make_request函式，這也是過濾塊裝置驅動最核心的地方，那麼我們如何把這個函式註冊到倉庫裡呢，通過blk_queue_make_request這個函式註冊的，是不是非常簡單。到現在為止，我們已經把過濾塊裝置驅動要構建的操作全部描述完了，是的，事情就是那麼回事，從此請求會經過每層過濾驅動的make_request函式依次傳遞下去，如何傳遞，我們會繼續介紹，但現在，讓我們先離開一下這個例子，開始分析一下程式碼，從程式碼上充分體會一下我們如何構建一個最簡單的過濾塊裝置驅動。

首先我們繼續假設一種情況，假設讀者去市區借書，沒有影印件，我們繼續去A那拿，不幸的是，A 壓根兒不理睬我們，直接拒絕了我們，好悲哀啊。接下來，我們就是用170行程式碼，把這個過程的程式程式碼呈現給大家。

讓我們再記住這幾個步驟：

1.                                                                                                註冊並申請門牌號： register_blkdev

2.                                                                                                申請倉庫：alloc_disk

3.                                                                                                申請倉庫的關卡：alloc_queue

4.                                                                                                註冊倉庫的加工處理函式：blk_queue_make_request

讓我們看一下核心程式碼是如何寫的。首先我們先給出全部的170行程式碼，然後我們會從module_init函式開始閱讀理解，把我們上面提到的步驟一步一步驗證一下，下面是全部的程式碼。

fbd_driver.h

  1#ifndef  _FBD_DRIVER_H

  2#define  _FBD_DRIVER_H

  3#include <linux/init.h>

  4#include <linux/module.h>

  5#include <linux/blkdev.h>

  6#include <linux/bio.h>

  7#include <linux/genhd.h>

  8

  9#define SECTOR_BITS             (9)

 10#define DEV_NAME_LEN            32

 11#define DEV_SIZE                (512UL<< 20)   /* 512M Bytes */

 12

 13#define DRIVER_NAME            "filter driver"

 14

 15#define DEVICE1_NAME           "fbd1_dev"

 16#define DEVICE1_MINOR           0

 17#define DEVICE2_NAME           "fbd2_dev"

 18#define DEVICE2_MINOR           1

 19

 20struct fbd_dev {

 21        struct request_queue *queue;

 22        struct gendisk *disk;

 23        sector_t size;          /* devicesize in Bytes */

 24};

 25#endif

fbd_driver.c

  1/**

 2  *  fbd-driver - filter block device driver

 3  *  Author: [email protected]

  4**/

  5#include "fbd_driver.h"

  6

  7static int fbd_driver_major = 0;

  8

  9static struct fbd_dev fbd_dev1 = {NULL};

 10static struct fbd_dev fbd_dev2 = {NULL};

 11

 12static int fbddev_open(struct inode *inode, struct file *file);

 13 staticint fbddev_close(struct inode *inode, struct file *file);

 14

 15static struct block_device_operations disk_fops = {

 16        .open = fbddev_open,

 17        .release = fbddev_close,

 18        .owner = THIS_MODULE,

 19};

 20

 21static int fbddev_open(struct inode *inode, struct file *file)

 22 {

 23        printk("device is opened by:[%s]\n", current->comm);

 24        return 0;

 25 }

 26

 27static int fbddev_close(struct inode *inode, struct file *file)

 28 {

 29        printk("device is closed by:[%s]\n", current->comm);

 30        return 0;

 31 }

 32

 33static int make_request(struct request_queue *q, struct bio *bio)

 34 {

 35        struct fbd_dev *dev = (struct fbd_dev *)q->queuedata;

 36        printk("device [%s] recevied [%s] io request, "

 37                 "access on dev sector[%llu], length is [%u] sectors.\n",

 38                 dev->disk->disk_name,

 39                 bio_data_dir(bio) == READ ?"read" : "write",

 40                 bio->bi_sector,

 41                bio_sectors(bio));

 42

 43        bio_endio(bio, bio->bi_size, 0);

 44        return 0;

 45 }

 46

 47static int dev_create(struct fbd_dev *dev, char *dev_name, int major, intmi    nor)

 48 {

 49        int ret = 0;

 50

 51        /* init fbd_dev */

 52        dev->size = DEV_SIZE;

 53         dev->disk = alloc_disk(1);

 54        if (!dev->disk) {

 55                 printk("alloc diskerror");

 56                 ret = -ENOMEM;

 57                 goto err_out1;

 58        }

 59

 60         dev->queue = blk_alloc_queue(GFP_KERNEL);

 61        if (!dev->queue) {

 62                 printk("alloc queueerror");

 63                 ret = -ENOMEM;

 64                 goto err_out2;

 65        }

 66

 67        /* init queue */

 68        blk_queue_make_request(dev->queue, make_request);

 69        dev->queue->queuedata = dev;

 70

 71        /* init gendisk */

 72        strncpy(dev->disk->disk_name, dev_name, DEV_NAME_LEN);

 73        dev->disk->major = major;

 74        dev->disk->first_minor = minor;

 75        dev->disk->fops = &disk_fops;

 76        set_capacity(dev->disk, (dev->size >> SECTOR_BITS));

 77

 78         /* bind queue to disk */

 79         dev->disk->queue =dev->queue;

 80

 81        /* add disk to kernel */

 82         add_disk(dev->disk);

 83        return 0;

 84err_out2:

 85        put_disk(dev->disk);

 86err_out1:

 87        return ret;

 88 }

 89

 90static void dev_delete(struct fbd_dev *dev, char *name)

 91 {

 92        printk("delete the device [%s]!\n", name);

 93        blk_cleanup_queue(dev->queue);

 94        del_gendisk(dev->disk);

 95        put_disk(dev->disk);

 96 }

 97

 98static int __init fbd_driver_init(void)

 99 {

100        int ret;

101

102        /* register fbd driver, get the driver major number*/

103     fbd_driver_major =register_blkdev(fbd_driver_major, DRIVER_NAME);

104        if (fbd_driver_major < 0) {

105                 printk("get majorfail");

106                 ret = -EIO;

107                 goto err_out1;

108         }

109

110        /* create the first device */

111        ret = dev_create(&fbd_dev1, DEVICE1_NAME, fbd_driver_major,DEVICE1_MINOR);

112        if (ret) {

113                 printk("create device[%s] failed!\n", DEVICE1_NAME);

114                 goto err_out2;

115        }

116

117        /* create the second device */

118        ret = dev_create(&fbd_dev2, DEVICE2_NAME, fbd_driver_major,DEVICE2_MINOR);

119        if (ret) {

120                 printk("create device[%s] failed!\n", DEVICE2_NAME);

121                 goto err_out3;

122        }

123        return ret;

124 err_out3:

125        dev_delete(&fbd_dev1, DEVICE1_NAME);

126 err_out2:

127        unregister_blkdev(fbd_driver_major, DRIVER_NAME);

128 err_out1:

129        return ret;

130 }

131

132 static void __exitfbd_driver_exit(void)

133 {

134        /* delete the two devices */

135        dev_delete(&fbd_dev2, DEVICE2_NAME);

136        dev_delete(&fbd_dev1, DEVICE1_NAME);

137

138        /* unregister fbd driver */

139         unregister_blkdev(fbd_driver_major,DRIVER_NAME);

140        printk("block device driver exit successfuly!\n");

141 }

142

143 module_init(fbd_driver_init);

144 module_exit(fbd_driver_exit);

145 MODULE_LICENSE("GPL");

Makefile

  1 obj-m := fbd_driver.o

  2 KDIR := /lib/modules/$(shell uname-r)/build

  3 PWD := $(shell pwd)

  4 default:

  5        $(MAKE) -C $(KDIR) M=$(PWD) modules

  6 clean:

  7        $(MAKE) -C $(KDIR) M=$(PWD) clean

  8        rm -rf Module.markers modules.order Module.symvers

一共三個檔案，fbd_driver.c和fbd_driver.h兩個檔案是原始碼檔案，Makefile檔案是我們的編譯規則檔案，大家可以回憶下這個Makefile檔案是否與我們上冊一開始寫的簡單核心模組中的Makefile檔案非常類似，是的，核心模組的編譯規則和方法就是這麼簡單，我們不需要在這上面的花太多的精力，會讀懂和修改編譯規則即可。有興趣深入研究的同學，我們附了一個專門講解Makefile規則語法的書，大家有選擇性查閱，更多的是掌握好基本的規則和當成工具書方便查閱即可。

先看一下fbd_driver.h標頭檔案的內容，首先看1－2行，這個非常有意思，是一個C語言語法中的條件編譯關鍵字，#ifndef _FBD_DRIVER_H 意思就是說如果“_FBD_DRIVER_H”該巨集沒有定義，則第2行用#define定義一下這個巨集，然後再看第25行“#endif”，#ifndef 與 #endif是一對條件編譯關鍵字語法，作為標頭檔案中這麼用的作用非常強大，它能夠防止我們在.c檔案中對標頭檔案重複包含，避免程式碼冗餘，大家體會一下這個用法。接下來3－7行共包含了5個頭檔案，這5個頭檔案是我們這個過濾塊裝置驅動實現需要引用的標頭檔案，它們中有我們需要的一些函式API介面宣告和資料結構的定義，其中一個我們一定不陌生就是module.h，任何一個核心模組不管它是塊裝置驅動，還是其它核心驅動模組，這個標頭檔案是一定要包含的。然後bio.h/blkdev.h/genhd.h是核心塊裝置驅動必須要包含的三個標頭檔案，核心的標頭檔案命名上很有意義，基本上相關的核心API呼叫會放在相應的標頭檔案中，這裡我們先不具體介紹這三個標頭檔案，在下一章節我們具體分析塊裝置驅動核心資料結構及API介面宣告時再詳細分析，我們繼續往下走。第9行是定義了扇區位元數是9，對於塊裝置，扇區是其最小的傳輸和儲存單位，是按扇區來劃分的，預設扇區大小是512位元組，這裡的9代表512如果換算為二進位制需要多少位描述，我們一定很快算出來就是2＾9 = 512，後面我們會經常遇到這樣的二進位制轉換描述，在核心中是經常遇到的。第10行，我們定義的巨集叫DISK_NAME_LEN，表示我們要寫的過濾塊裝置的名字最大是32個位元組，第11行定義了我們要建立的過濾塊裝置大小是512M，1左移20位是1M，再乘以扇區大小即是512M。

第13－18行定義我們定義了驅動程式註冊的名字“fbd_driver”，及通過過濾塊裝置驅動程式建立的過濾塊裝置名字叫“fbd1_dev”和”fbd2_dev”。

接下來20－24行，我們定義了一個數據結構結構體叫fbd_dev，這個結構體裡面有三個成員，首先是一個queue指標成員，然後是disk指標，最後是裝置大小，這個結構體用於描述我們建立的過濾塊裝置，從我們前面列舉的圖書館的例子，大家應該可以對上號了，

好了準備工作一切就緒，我們開始分析原始碼檔案fbd_driver.c，由於核心驅動模組的特殊性，我們向系統載入一個模組時linux核心一定會首先呼叫module_init所約定的函式，注意看143行程式碼，module_init是核心的一個API, 我們所寫的驅動模組一定要寫143／144這樣兩行程式碼，告訴核心我們的模組載入時會執行module_init的約定函式，模組解除安裝時會執行module_exit的約定函式，好的，先記住這個。然後對於我們的過濾塊裝置驅動來說，我們要如何設計module­­_init約定的初始化函式呢，接下來我們介紹104行程式碼中的這個 fbd_driver­­_init函式。至於module_init的具體實現原理我們希望大家現在暫時先沉住氣，不要去分析，有時候先放一放，把精力用在最主要的事情上是非常好的一個方法。現在先來看這個載入模組時就會被執行的函式fbd_driver_init函式。我們再把程式碼貼一下：

 95static int __init fbd_driver_init(void)

 96 {

 97        int ret;

 98

 99        /* register fbd driver, get the driver major number*/

100           fbd_driver_major =register_blkdev(fbd_driver_major, DRIVER_NAME);

101        if (fbd_driver_major < 0) {

102                 printk("get majorfail");

103                 ret = -EIO;

104                 goto err_out1;

105        }

106

107        /* create the first device */

108        ret = dev_create(&fbd_dev1, DEVICE1_NAME, fbd_driver_major,DEVICE1_    MINOR);

109        if (ret) {

110                 printk("create device[%s] failed!\n", DEVICE1_NAME);

111                 goto err_out2;

112        }

113

114        /* create the second device */

115        ret = dev_create(&fbd_dev2, DEVICE2_NAME, fbd_driver_major,DEVICE2_    MINOR);

116        if (ret) {

117                 printk("create device[%s] failed!\n", DEVICE2_NAME);

118                goto err_out3;

119        }

120

121        return ret;

122

123 err_out3:

124        dev_delete(&fbd_dev1, DEVICE1_NAME);

125 err_out2:

126        unregister_blkdev(fbd_driver_major, DRIVER_NAME);

127 err_out1:

128        return ret;

129 }

首先函式是一個static函式，這個是C語言的一個基本語法，表示該函式只能在當前的檔案中被呼叫，static後面是int 表示該函式返回值是整型，然後是__init， 這個需要大家注意一下，這是gcc的一個語法，gcc是編譯器，這個__init就是告訴gcc在編譯後，在程式碼執行時把這個函式的程式碼放在特殊的記憶體區域，函式執行完畢，這部分記憶體就會被linux核心回收，因為這個函式是模組載入時就只會呼叫一次的函式，後面不會再有人用這個函數了，所以執行完，就可以釋放出佔用的記憶體。

說到這希望大家還沒有忘記我們開頭提的4個步驟，我們再囉嗦一下塊裝置驅動程式需要做4件非常重要的準備工作：

1.                                                                                                註冊並申請門牌號： register_blk_device

2.                                                                                                申請倉庫：alloc_disk

3.                                                                                                申請倉庫的關卡：alloc_queue

4.                                                                                                註冊倉庫的加工處理函式：blk_queue_make_request

我們稍等一下，再介紹一下一個我們自己定義資料結構，也就是我們的倉庫的一個描述性結構，這個結構只有我們自己寫這個過濾塊裝置驅動的作者知道，這個結構對於linux核心是不可見的，我們內部使用而已，如下：

fbd_driver.h

 20struct fbd_dev {

 21        struct request_queue *queue;

 22        struct gendisk *disk;

 23        sector_t size;          /* devicesize in Bytes */

 24};

好了，準備工作一切就緒，然後揭開塊裝置過濾驅動的面紗，開始分析fbd_driver_init函式吧，大家從此刻開始要打起二十分的精力，這是構建塊裝置驅動最核心的部分。

fbd_driver_init這個函式首先呼叫register_blk_device函式，獲取到了塊裝置驅動程式的主裝置號，register_blkdev終於浮出水面了，還記得那4個步驟不？第一步註冊並申請門牌號，對就是它，我們要向系統申請和註冊，第一個引數就是一個初始化的major號，第二引數是我們塊裝置驅動的名字，這裡我們第一引數是0, 此時系統會去它自己管理的登記情況表上看看是否有不用的號碼可以我們，如果有就會我們一個，這就是regiser_blkdev的返回值，那這個第一個引數一定要是0嗎？不需要的，如果你選好自己的幸運數字了比如8,你可以把8傳入這個函式，但是要小心了，系統裡面如果有那位仁兄已經申請過這個8了，很不幸，就會申請失敗。然後呼叫兩次dev_create函式建立了兩個塊裝置，fbd_driver­_init函式比較簡單，通過register_blk_device申請到門牌號（主裝置號）後，我們直接跟進到dev_create函式中分析，程式碼如下：

 47static int dev_create(struct fbd_dev *dev, char *dev_name, int major, intmi    nor)

 48 {

 49        int ret = 0;

 50

 51        /* init fbd_dev */

 52        dev->size = DEV_SIZE;

 53         dev->disk = alloc_disk(1);

 54        if (!dev->disk) {

 55                 printk("alloc diskerror");

 56                 ret = -ENOMEM;

 57                 goto err_out1;

 58        }

 59

 60        dev->queue = blk_alloc_queue(GFP_KERNEL);

 61        if (!dev->queue) {

 62                 printk("alloc queueerror");

 63                 ret = -ENOMEM;

 64                 goto err_out2;

 65        }

 66

 67        /* init queue */

 68        blk_queue_make_request(dev->queue, make_request);

 69        dev->queue->queuedata = dev;

 70

 71        /* init gendisk */

 72        strncpy(dev->disk->disk_name, dev_name, DEV_NAME_LEN);

 73        dev->disk->major = major;

 74        dev->disk->first_minor = minor;

 75        dev->disk->fops = &disk_fops;

 76        set_capacity(dev->disk, (dev->size >> SECTOR_BITS));

 77

 78         /* bind queue to disk */

 79         dev->disk->queue = dev->queue;

 80

 81        /* add disk to kernel */

 82        add_disk(dev->disk);

 83        return 0;

 84err_out2:

 85        put_disk(dev->disk);

 86err_out1:

 87        return ret;

 88 }

首先第49行，我們定義了一個整型變數，用於記錄塊裝置驅動初始化過程中的返回值，再看53行到57行，接下來申請我們的倉庫gendisk，我們看到是通過呼叫alloc_disk這個函式，我們得到了gendisk結構，我們依然不去細說gendisk中的具體欄位，在第二節詳細分析。

申請完倉庫，我們要建立關卡了，只有經過關卡，才能進入倉庫，是的，這就是入庫前的規則，當前關卡申請了，可以用也可以不用。我們的過濾塊裝置驅動就是這樣，申請了，但是沒用，但是注意一定要申請的。

接著我們看60行－65行，我們看到了申請關卡的函式blk_alloc_queue函式，這樣我們就有申請到了一個數據結構。三個步驟我們已經走完了三個，我們都沒有介紹資料結構裡面的具體成員，接下來我們繼續做第四個步驟，註冊我們的倉庫加工函式－ 請求處理函式make_request。

我們看68行程式碼，我們再次貼一下：

 67         /* init queue */

 68        blk_queue_make_request(dev->queue, make_request);

 69        dev->queue->queuedata = dev;

呼叫的函式是blk_queue_make_request, 第一引數是我們剛剛申請到的請求佇列，第二個引數就是我們自己寫好的make_request函式名，這個函式我們待會分析它。然後注意69行，我們做了一個賦值操作，把我們的裝置描述結構繫結給了request_queue的一個成員變數queuedata。

接下來，我們要對我們申請的倉庫裝飾一下，程式碼同樣再貼一下：

 71         /* init gendisk */

 72        strncpy(dev->disk->disk_name, dev_name, DEV_NAME_LEN);

 73        dev->disk->major = major;

 74        dev->disk->first_minor = minor;

 75        dev->disk->fops = &disk_fops;

 76        set_capacity(dev->disk, (dev->size >> SECTOR_BITS));

 77

 78          /* bind queue to disk */

 79         dev->disk->queue = dev->queue;

 80

72行程式碼是給gendisk的disk_name成員賦值，就是給我們的倉庫取名字。73行程式碼就是把我們申請到的門牌號賦值給disk的成員major，74行我們賦值了一個次裝置號，75行我們為gendisk的檔案操作函式賦值了一個函式指標集結構體，這個我們在稍後分析，最後76行我們設定了裝置的容量大小為512M。

79行程式碼就是把我們申請的queue地址儲存在disk中，這樣倉庫和關卡就繫結在一起了，同時我們也知道了disk中有個成員叫queue, 是個指標，對吧，我們沒有放棄詳細說明資料結構中的成員，只不過在我們遇到的時候我們一定會予以介紹，然後在第二節詳細總結分析。

好了我們已經申請註冊了門牌號，申請了倉庫，申請了關卡，給倉庫安裝了加工函式，對我們的倉庫進行了裝飾，就可以了嗎？還差最後一個關鍵步驟，非常的重要，就是告訴核心我們的倉庫需要稽核一下，如果通過，那恭喜你，你的倉庫建好了，那這個步驟就是82行程式碼：

 81        /* add disk to kernel */

 82        add_disk(dev->disk);

好了我們終於建好自己的倉庫了，稍等，我們還有一個沒有分析，就是我們倉庫的加工函式make_request，讓我們趕緊看看前面圖書館例子中的請求處理函式的功能是什麼，我們說過我們的過濾塊裝置驅動在接受到請求後不做任何處理，直接結束請求，我們看看到底是如何實現的。

 33static int make_request(struct request_queue *q, struct bio *bio)

 34 {

 35        struct fbd_dev *dev = (struct fbd_dev *)q->queuedata;

 36        printk("device [%s] recevied [%s] io request, "

 37                 "access on dev sector[%llu], length is [%u] sectors.\n",

 38                 dev->disk->disk_name,

 39                 bio_data_dir(bio) == READ ?"read" : "write",

 40                 bio->bi_sector,

 41                 bio_sectors(bio));

 42

 43        bio_endio(bio, bio->bi_size, 0);

 44        return 0;

 45 }

這個函式輸入引數就是我們的關卡請求佇列，第二個引數就是上層準備好的盒子bio請求描述結構指標，我們的函式就調了個bio_endio就完事了，是的，這個函式就是用於結束一個請求bio的，這樣我們就知道了為什麼請求到我們的倉庫，就會結束，是因為我們的加工函式就是通過呼叫bio_endio做到的。

至此我們終於完成了一個最簡單的過濾塊裝置驅動的開發，趕緊試試吧，在自己的虛擬上，執行make，得到fbd_driver.ko後，載入你的驅動insmod fbd_driver.ko，在/dev/下面是否可以看到我們的過濾裝置/dev/fbd1_dev和/dev/fbd2_dev，對其進行dd操作然後看dmesg資訊，從dmesg命令顯示的資訊中我們會看到如下資訊，比如執行：

[[email protected] fbd_driver_stage1]# ddif=/dev/zero of=/dev/fbd1_dev bs=1M oflag=direct count=1

1+0 records in

1+0 records out

1048576 bytes(1.0 MB) copied, 0.038983 seconds, 26.9 MB/s

[[email protected] fbd_driver_stage1]# dmesg

device is openedby:[dd]

device[fbd1_dev] recevied [write] io request, access on dev sector [0], length is[248] sectors.

device[fbd1_dev] recevied [write] io request, access on dev sector [248], length is[248] sectors.

device[fbd1_dev] recevied [write] io request, access on dev sector [496], length is[248] sectors.

device[fbd1_dev] recevied [write] io request, access on dev sector [744], length is[248] sectors.

device[fbd1_dev] recevied [write] io request, access on dev sector [992], length is[248] sectors.

device [fbd1_dev]recevied [write] io request, access on dev sector [1240], length is [248]sectors.

device[fbd1_dev] recevied [write] io request, access on dev sector [1488], length is[248] sectors.

device[fbd1_dev] recevied [write] io request, access on dev sector [1736], length is[248] sectors.

device[fbd1_dev] recevied [write] io request, access on dev sector [1984], length is[64] sectors.

device is closedby:[dd]

[[email protected]_driver_stage1]#

75行我們為gendisk的檔案操作函式賦值了一個函式指標集結構體，我們繼續通過分析dmesg的資訊完成這個解讀，我們做dd寫了一個1M的資料，看到了

“device is openedby:[dd]” 和 “device is closed by:[dd]” 這兩行資訊，這就是下面fbddev_open和fbddev_close函式打出的，這樣我們應該能夠理解了，這兩個函式指標就是我們建立的塊裝置被開啟時和關閉時會呼叫到，我們都寫過這樣的簡單程式open/read/close，對吧，只不過我們跑的dd命令包含了這三個函式呼叫。

 15static struct block_device_operations disk_fops = {

 16        .open = fbddev_open,

 17        .release = fbddev_close,

 18        .owner = THIS_MODULE,

 19};

 20

 21static int fbddev_open(struct inode *inode, struct file *file)

 22 {

 23        printk("device is opened by:[%s]\n", current->comm);

 24        return 0;

 25 }

 26

 27static int fbddev_close(struct inode *inode, struct file *file)

 28 {

 29        printk("device is closed by:[%s]\n", current->comm);

 30        return 0;

 31 }

這就是我們這個最簡單的過濾塊裝置驅動，由於在make_request函式中我們直接呼叫bio_endio，這個函式的作用是直接返回收到的請求，不做任何處理，這樣我們寫入的1M資料實際並沒有處理，而是直接返回了。在第三節我們會繼續完善這個170行程式碼的驅動，讓我們的驅動能夠真正的過濾請求，而不是直接退出請求處理。

P.S.： 本篇程式碼同仁們可以去程式碼分享中獲取。