讀取硬盤數據到內存中，是操作系統的一個基礎功能。

讀取硬盤需要有塊設備驅動程序，而以文件的方式來讀取則還有要再上面包一層文件系統。

把讀出來的數據放到內存，就涉及到內存中緩沖區的管理。

上面說的每一件事，都是一個十分龐大的體系，我們今天的文章一個都不展開講，哈哈。

我們就講講，讀取塊設備與內存緩沖區之間的橋梁，塊設備請求項的初始化工作。

我們以 Linux 0.11 源碼為例，發現進入內核的 main 函數后不久，有這樣一行代碼。

1. void main(void) {
2. ...
3. blk_dev_init();
4. ...
5. }

看到這個方法的全部代碼后，你可能會會心一笑，也可能一臉懵逼。

1. void blk_dev_init(void) {
2. int i;
3. for (i=0; i<32; i++) {
4. request[i].dev = -1;
5. request[i].next = NULL;
6. }
7. }

這也太簡單了吧?

就是給 request 這個數組的前 32 個元素的兩個變量 dev 和 next 附上值，看這倆值 -1 和 NULL 也可以大概猜出，這是沒有任何作用時的初始化值。

我們看下 request 結構體。

1. /*
2. * Ok, this is an expanded form so that we can use the same
3. * request for paging requests when that is implemented. In
4. * paging, 'bh' is NULL, and 'waiting' is used to wait for
5. * read/write completion.
6. */
7. struct request {
8. int dev; /* -1 if no request */
9. int cmd; /* READ or WRITE */
10. int errors;
11. unsigned long sector;
12. unsigned long nr_sectors;
13. char * buffer;
14. struct task_struct * waiting;
15. struct buffer_head * bh;
16. struct request * next;
17. };

注釋也附上了。

哎喲，這就有點頭大了，剛剛的函數雖然很短，但看到這個結構體我們知道了，重點在這呢。

這也側面說明了，學習操作系統，其實把遇到的重要數據結構牢記心中，就已經成功一半了。比如主內存管理結構 mem_map，知道它的數據結構是什么樣子，其功能也基本就懂了。

收，繼續說這個 request 結構，這個結構就代表了一次讀盤請求，其中：

dev 表示設備號，-1 就表示空閑。

cmd 表示命令，其實就是 READ 還是 WRITE，也就表示本次操作是讀還是寫。

errors 表示操作時產生的錯誤次數。

sector 表示起始扇區。

nr_sectors 表示扇區數。

buffer 表示數據緩沖區，也就是讀盤之后的數據放在內存中的什么位置。

waiting 是個 task_struct 結構，這可以表示一個進程，也就表示是哪個進程發起了這個請求。

bh 是緩沖區頭指針，這個后面講完緩沖區就懂了，因為這個 request 是需要與緩沖區掛鉤的。

next 指向了下一個請求項。

這里有的變量看不懂沒關系。

不過我們倒是可以基于現有的重點參數猜測一下，比如讀請求時，cmd 就是 READ，sector 和 nr_sectors 這倆就定位了所要讀取的塊設備(可以簡單先理解為硬盤)的哪幾個扇區，buffer 就定位了這些數據讀完之后放在內存的什么位置。

這就夠啦，想想看，這四個參數是不是就能完整描述了一個讀取硬盤的需求了?而且完全沒有歧義，就像下面這樣。

而其他的參數，肯定是為了更好地配合操作系統進行讀寫塊設備操作嘛，為了把多個讀寫塊設備請求很好地組織起來。這個組織不但要有這個數據結構中 hb 和 next 等變量的配合，還要有后面的電梯調度算法的配合，僅此而已，先點到為止。

總之，我們這里就先明白，這個 request 結構可以完整描述一個讀盤操作。然后那個 request 數組就是把它們都放在一起，并且它們又通過 next 指針串成鏈表。

好，本文講述的兩行代碼，其實就完成了上圖所示的工作而已。

但講到這就結束的話，很多同學可能會不太甘心，那我就簡單展望一下，后面讀盤的全流程中，是怎么用到剛剛初始化的這個 request[32] 結構的。

讀操作的系統調用函數是 sys_read，源代碼很長，我給簡化一下，僅僅保留讀取普通文件的分支，就是如下的樣子。

1. int sys_read(unsigned int fd,char * buf,int count) {
2. struct file * file = current->filp[fd];
3. struct m_inode * inode = file->f_inode;
4. // 校驗 buf 區域的內存限制
5. verify_area(buf,count);
6. // 僅關注目錄文件或普通文件
7. return file_read(inode,file,buf,count);
8. }

看，入參 fd 是文件描述符，通過它可以找到一個文件的 inode，進而找到這個文件在硬盤中的位置。

另兩個入參 buf 就是要復制到的內存中的位置，count 就是要復制多少個字節，很好理解。

鉆到 file_read 函數里繼續看。

1. int file_read(struct m_inode * inode, struct file * filp, char * buf, int count) {
2. int left,chars,nr;
3. struct buffer_head * bh;
4. left = count;
5. while (left) {
6. if (nr = bmap(inode,(filp->f_pos)/BLOCK_SIZE)) {
7. if (!(bh=bread(inode->i_dev,nr)))
8. break;
9. } else
10. bh = NULL;
11. nr = filp->f_pos % BLOCK_SIZE;
12. chars = MIN( BLOCK_SIZE-nr , left );
13. filp->f_pos += chars;
14. left -= chars;
15. if (bh) {
16. char * p = nr + bh->b_data;
17. while (chars-->0)
18. put_fs_byte(*(p++),buf++);
19. brelse(bh);
20. } else {
21. while (chars-->0)
22. put_fs_byte(0,buf++);
23. }
24. }
25. inode->i_atime = CURRENT_TIME;
26. return (count-left)?(count-left):-ERROR;
27. }

整體看，就是一個 while 循環，每次讀入一個塊的數據，直到入參所要求的大小全部讀完為止。

直接看 bread 那一行。

1. int file_read(struct m_inode * inode, struct file * filp, char * buf, int count) {
2. ...
3. while (left) {
4. ...
5. if (!(bh=bread(inode->i_dev,nr)))
6. }
7. }

這個函數就是去讀某一個設備的某一個數據塊號的內容，展開進去看。

1. struct buffer_head * bread(int dev,int block) {
2. struct buffer_head * bh = getblk(dev,block);
3. if (bh->b_uptodate)
4. return bh;
5. ll_rw_block(READ,bh);
6. wait_on_buffer(bh);
7. if (bh->b_uptodate)
8. return bh;
9. brelse(bh);
10. return NULL;
11. }

其中 getblk 先申請了一個內存中的緩沖塊，然后 ll_rw_block 負責把數據讀入這個緩沖塊，進去繼續看。

1. void ll_rw_block(int rw, struct buffer_head * bh) {
2. ...
3. make_request(major,rw,bh);
4. }
6. static void make_request(int major,int rw, struct buffer_head * bh) {
7. ...
8. if (rw == READ)
9. req = request+NR_REQUEST;
10. else
11. req = request+((NR_REQUEST*2)/3);
12. /* find an empty request */
13. while (--req >= request)
14. if (req->dev<0)
15. break;
16. ...
17. /* fill up the request-info, and add it to the queue */
18. req->dev = bh->b_dev;
19. req->cmd = rw;
20. req->errors=0;
21. req->sector = bh->b_blocknr<<1;
22. req->nr_sectors = 2;
23. req->buffer = bh->b_data;
24. req->waiting = NULL;
25. req->bh = bh;
26. req->next = NULL;
27. add_request(major+blk_dev,req);
28. }

看，這里就用到了剛剛說的結構咯。

具體說來，就是該函數會往剛剛的設備的請求項鏈表 request[32] 中添加一個請求項，只要 request[32] 中有未處理的請求項存在，都會陸續地被處理，直到設備的請求項鏈表是空為止。

具體怎么讀盤，就是與硬盤 IO 端口進行交互的過程了，可以繼續往里跟，直到看到一個 hd_out 函數為止，本講不展開了。

具體讀盤操作，后面會有詳細的章節展開講解，本講你只需要知道，我們在 main 函數的 init 系列函數中，通過 blk_dev_init 為后面的塊設備訪問，提前建立了一個數據結構，作為訪問塊設備和內存緩沖區之間的橋梁，就可以了。

原文鏈接：https://mp.weixin.qq.com/s/pIbVY1XPCktxGogc4lI1Bw