[关闭]
@harpsword 2015-11-16T10:24:31.000000Z 字数 17517 阅读 3439

文件系统代码分析之 buffer.c

文件系统

功能描述

这个文件主要是缓冲系统。关于缓冲，在 linux0.11内核之文件系统中有简单的介绍。

高速缓冲区

结构

photo

机制

简述

内核程序在使用高速缓冲区中的缓冲块时，是指定设备号(dev)和所要访问设备数据的逻辑块号(block),通过调用缓冲块读取函数 bread()、bread_page()和breada()进行操作。这几个函数都是使用缓冲区搜索管理函数 getblk() ,用于在所有缓冲块中寻找最为空闲的缓冲块。在系统释放缓冲块时， 需要调用 brelse() 函数。所有这些缓冲块数据存取和管理函数之间的调用层次关系可用下图表示：
层次图

关于hash表

某一时刻hash表

上图中
- 双箭头横线表示 散列在同一hash表项中缓冲块头结构之间的双向链接指针。
- 虚线表示缓冲区中所有缓冲块所组成的一个双向循环链表（即所谓空闲列表），free_list即为其头指针。实际上这个双向链表是一个最近最少使用LRU(Least Recently Used)链表。

getblk()函数

流程图如下:
流程图

补充：
1. 图中的两次搜索hash表目的有些不同(1:搜索hash表;2:已在高速缓冲中，这个隐含搜索hash表的意思)

1. 第一次搜索hash表是判断指定设备号和逻辑块号对应的缓冲块是否存在，存在则不用继续；否则继续下一步。
2. 第二次搜索hash表是判断之前确定指定设备号和逻辑块号是否已经有缓冲块，有的话就不需要申请新的。

2. 函数在每次获取新的空闲缓冲块时，就会把它移动到free_list头指针所指链表的最后面，即越靠近链表末端的缓冲块被使用的时间就越近，越靠近链表头部的缓冲块使用时间越远。
3. 算法采用的策略:

1. 如果指定的缓冲块在hash表中，则说明已经得到可用缓冲块，于是直接返回。
2. 否则就需要在链表中从 free_list 头指针处开始搜索

4. 最理想的情况是找到一个 完全空闲的缓冲块(b_dirt=0,b_lock=0),但是当无法做到时，需要根据b_dirt和b_lock 计算出一个值。因为设备操作通常很费时间，所以加大 b_dirt 的权重。然后在计算结果值最少的缓冲块上等待（如果该块被锁）。最后得到一个空闲缓冲块。

bread()函数

bread()
一个调用了getblk()的读取数据块操作函数。

流程图

更新和同步

主要作用
让内存中的一些缓冲块内容和磁盘块等块设备上的信息一致.

同步操作的两个阶段:
1. 数据结构信息与高速缓冲区中的缓冲块同步问题，由驱动程序独立负责。
2. 高速缓冲区中数据块与磁盘块对应块的同步问题，由这里的缓冲管理程序负责。

sync_inodes()函数的主要作用
把 i节点表inode_table(内存)中的i节点信息和磁盘上的一致起来。

sync_inodes()函数不会直接与磁盘打交道，只负责与缓冲区中的信息同步。剩下的需要缓冲管理程序负责。为了让sync_inodes()知道哪些i节点与磁盘上的不同，步骤如下:
1. 首先让缓冲区中内容与磁盘上的内容一致
2. 然后 sync_inodes() 就知道哪些磁盘inode需要修改和更新
3. 进行第二次高速缓冲区与磁盘设备的同步操作。

综述

代码注释

  1. /*
  2.  *  linux/fs/buffer.c
  3.  *
  4.  *  (C) 1991  Linus Torvalds
  5.  */
  7. /*
  8.  *  'buffer.c' implements the buffer-cache functions. Race-conditions have
  9.  * been avoided by NEVER letting a interrupt change a buffer (except for the
  10.  * data, of course), but instead letting the caller do it. NOTE! As interrupts
  11.  * can wake up a caller, some cli-sti sequences are needed to check for
  12.  * sleep-on-calls. These should be extremely quick, though (I hope).
  13.  */
  15. /*
  16.  * NOTE! There is one discordant note here: checking floppies for
  17.  * disk change. This is where it fits best, I think, as it should
  18.  * invalidate changed floppy-disk-caches.
  19.  */
  21. #include <stdarg.h>
  23. #include <linux/config.h>
  24. #include <linux/sched.h>
  25. #include <linux/kernel.h>
  26. #include <asm/system.h>
  27. #include <asm/io.h>
  29. // 变量end是由编译时的连接程序ld生成，用于表明内核代码的末端，即指明内核模块某段位置。
  30. // 也可以从编译内核时生成的System.map文件中查出。这里用它来表明高速缓冲区开始于内核
  31. // 代码某段位置。
  32. // buffer_wait等变量是等待空闲缓冲块而睡眠的任务队列头指针。它与缓冲块头部结构中b_wait
  33. // 指针的租用不同。当任务申请一个缓冲块而正好遇到系统缺乏可用空闲缓冲块时，当前任务
  34. // 就会被添加到buffer_wait睡眠等待队列中。而b_wait则是专门供等待指定缓冲块(即b_wait
  35. // 对应的缓冲块)的任务使用的等待队列头指针。
  36. extern int end;
  37. extern void put_super(int);
  38. extern void invalidate_inodes(int);
  40. // end , the start address of cache 
  41. // so start_buffer is the first buffer_head
  42. struct buffer_head * start_buffer = (struct buffer_head *) &end;
  43. struct buffer_head * hash_table[NR_HASH];           // NR_HASH ＝ 307项
  44. static struct buffer_head * free_list;              // 空闲缓冲块链表头指针
  45. static struct task_struct * buffer_wait = NULL;     // 等待空闲缓冲块而睡眠的任务队列
  46. // 下面定义系统缓冲区中含有的缓冲块个数。这里，NR_BUFFERS是一个定义在linux/fs.h中的
  47. // 宏，其值即使变量名nr_buffers，并且在fs.h文件中声明为全局变量。大写名称通常都是一个
  48. // 宏名称，Linus这样编写代码是为了利用这个大写名称来隐含地表示nr_buffers是一个在内核
  49. // 初始化之后不再改变的“变量”。它将在后面的缓冲区初始化函数buffer_init中被设置。
  50. int NR_BUFFERS = 0;                                 // 系统含有缓冲区块的个数
  52. //// 等待指定缓冲块解锁
  53. // 如果指定的缓冲块bh已经上锁就让进程不可中断地睡眠在该缓冲块的等待队列b_wait中。
  54. // 在缓冲块解锁时，其等待队列上的所有进程将被唤醒。虽然是在关闭中断(cli)之后
  55. // 去睡眠的，但这样做并不会影响在其他进程上下文中影响中断。因为每个进程都在自己的
  56. // TSS段中保存了标志寄存器EFLAGS的值，所以在进程切换时CPU中当前EFLAGS的值也随之
  57. // 改变。使用sleep_on进入睡眠状态的进程需要用wake_up明确地唤醒。
  58. static inline void wait_on_buffer(struct buffer_head * bh)
  59. {
  60.     cli();                          // 关中断
  61.     while (bh->b_lock)              // 如果已被上锁则进程进入睡眠，等待其解锁
  62.         sleep_on(&bh->b_wait);      // sleep_on(struct task_struct * * p) 
  63.     sti();                          // 开中断
  64. }
  66. //// 设备数据同步。
  67. // 同步设备和内存高速缓冲中数据，其中sync_inode()定义在inode.c中。
  68. int sys_sync(void)
  69. {
  70.     int i;
  71.     struct buffer_head * bh;
  73.     // 首先调用i节点同步函数，把内存i节点表中所有修改过的i节点写入高速缓冲中。
  74.     // 然后扫描所有高速缓冲区，对已被修改的缓冲块产生写盘请求，将缓冲中数据写入
  75.     // 盘中，做到高速缓冲中的数据与设备中的同步。
  76.     sync_inodes();      /* write out inodes into buffers */
  77.     bh = start_buffer;
  78.     for (i=0 ; i<NR_BUFFERS ; i++,bh++) {
  79.         wait_on_buffer(bh);                 // 等待缓冲区解锁(如果已经上锁的话)
  80.         if (bh->b_dirt)
  81.             ll_rw_block(WRITE,bh);          // 产生写设备块请求
  82.     }
  83.     return 0;
  84. }
  86. //// 对指定设备进行高速缓冲数据与设备上数据的同步操作
  87. // 该函数首先搜索高速缓冲区所有缓冲块。对于指定设备dev的缓冲块，若其数据已经
  88. // 被修改过就写入盘中(同步操作)。然后把内存中i节点表数据写入 高速缓冲中。之后
  89. // 再对指定设备dev执行一次与上述相同的写盘操作。
  90. int sync_dev(int dev)
  91. {
  92.     int i;
  93.     struct buffer_head * bh;
  95.     // 首先对参数指定的设备执行数据同步操作，让设备上的数据与高速缓冲区中的数据
  96.     // 同步。方法是扫描高速缓冲区中所有缓冲块，对指定设备dev的缓冲块，先检测其
  97.     // 是否已被上锁，若已被上锁就睡眠等待其解锁。然后再判断一次该缓冲块是否还是
  98.     // 指定设备的缓冲块并且已修改过(b_dirt标志置位)，若是就对其执行写盘操作。
  99.     // 因为在我们睡眠期间该缓冲块有可能已被释放或者被挪作他用，所以在继续执行前
  100.     // 需要再次判断一下该缓冲块是否还是指定设备的缓冲块。
  101.     bh = start_buffer;
  102.     for (i=0 ; i<NR_BUFFERS ; i++,bh++) {
  103.         if (bh->b_dev != dev)               // 不是设备dev的缓冲块则继续
  104.             continue;
  105.         wait_on_buffer(bh);                     // 等待缓冲区解锁
  106.         if (bh->b_dev == dev && bh->b_dirt)
  107.             ll_rw_block(WRITE,bh);
  108.     }
  109.     // 再将i节点数据吸入高速缓冲。让i节点表inode_table中的inode与缓冲中的信息同步。
  110.     sync_inodes();
  111.     // 然后在高速缓冲中的数据更新之后，再把他们与设备中的数据同步。这里采用两遍同步
  112.     // 操作是为了提高内核执行效率。第一遍缓冲区同步操作可以让内核中许多"脏快"变干净，
  113.     // 使得i节点的同步操作能够高效执行。本次缓冲区同步操作则把那些由于i节点同步操作
  114.     // 而又变脏的缓冲块与设备中数据同步。
  115.     bh = start_buffer;
  116.     for (i=0 ; i<NR_BUFFERS ; i++,bh++) {
  117.         if (bh->b_dev != dev)
  118.             continue;
  119.         wait_on_buffer(bh);
  120.         if (bh->b_dev == dev && bh->b_dirt)
  121.             ll_rw_block(WRITE,bh);
  122.     }
  123.     return 0;
  124. }
  126. //// 使指定设备在高速缓冲区中的数据无效
  127. // 扫描高速缓冲区中所有缓冲块，对指定设备的缓冲块复位其有效(更新)标志和已修改标志
  128. void inline invalidate_buffers(int dev)
  129. {
  130.     int i;
  131.     struct buffer_head * bh;
  133.     bh = start_buffer;
  134.     for (i=0 ; i<NR_BUFFERS ; i++,bh++) {
  135.         // 如果不是指定设备的缓冲块，则继续扫描下一块
  136.         if (bh->b_dev != dev)
  137.             continue;
  138.         wait_on_buffer(bh);
  139.         // 由于进程执行过程睡眠等待，所以需要再判断一下缓冲区是否是指定设备的。
  140.         if (bh->b_dev == dev)
  141.             bh->b_uptodate = bh->b_dirt = 0;
  142.     }
  143. }
  145. /*
  146.  * This routine checks whether a floppy has been changed, and
  147.  * invalidates all buffer-cache-entries in that case. This
  148.  * is a relatively slow routine, so we have to try to minimize using
  149.  * it. Thus it is called only upon a 'mount' or 'open'. This
  150.  * is the best way of combining speed and utility, I think.
  151.  * People changing diskettes in the middle of an operation deserve
  152.  * to loose :-)
  153.  *
  154.  * NOTE! Although currently this is only for floppies, the idea is
  155.  * that any additional removable block-device will use this routine,
  156.  * and that mount/open needn't know that floppies/whatever are
  157.  * special.
  158.  */
  159. // 检查磁盘是否更换，如果已更换就使对应高速缓冲区无效
  160. void check_disk_change(int dev)
  161. {
  162.     int i;
  164.     // 首先检测一下是不是软盘设备。因为现在仅支持软盘可移动介质。如果不是则
  165.     // 退出。然后测试软盘是否已更换，如果没有则退出。
  166.     if (MAJOR(dev) != 2)
  167.         return;
  168.     if (!floppy_change(dev & 0x03))
  169.         return;
  170.     // 软盘已经更换，所以解释对应设备的i节点位图和逻辑块位图所占的高速缓冲区；
  171.     // 并使该设备的i节点和数据库信息所占据的高速缓冲块无效。
  172.     for (i=0 ; i<NR_SUPER ; i++)
  173.         if (super_block[i].s_dev == dev)
  174.             put_super(super_block[i].s_dev);
  175.     invalidate_inodes(dev);
  176.     invalidate_buffers(dev);
  177. }
  179. // 下面两行代码是hash（散列）函数定义和Hash表项的计算宏
  180. // hash表的主要作用是减少查找比较元素所花费的时间。通过在元素的存储位置与关
  181. // 键字之间建立一个对应关系(hash函数)，我们就可以直接通过函数计算立刻查询到指定
  182. // 的元素。建立hash函数的指导条件主要是尽量确保散列在任何数组项的概率基本相等。
  183. // 建立函数的方法有多种，这里Linux-0.11主要采用了关键字除留余数法。因为我们
  184. // 寻找的缓冲块有两个条件，即设备号dev和缓冲块号block，因此设计的hash函数肯定
  185. // 需要包含这两个关键值。这两个关键字的异或操作只是计算关键值的一种方法。再对
  186. // 关键值进行MOD运算就可以保证函数所计算得到的值都处于函数数组项范围内。
  187. #define _hashfn(dev,block) (((unsigned)(dev^block))%NR_HASH)
  188. #define hash(dev,block) hash_table[_hashfn(dev,block)]
  190. //// 从hash队列和空闲缓冲区队列中移走缓冲块。
  191. // hash队列是双向链表结构，空闲缓冲块队列是双向循环链表结构。
  192. static inline void remove_from_queues(struct buffer_head * bh)
  193. {
  194. /* remove from hash-queue */
  195.     if (bh->b_next)
  196.         bh->b_next->b_prev = bh->b_prev;
  197.     if (bh->b_prev)
  198.         bh->b_prev->b_next = bh->b_next;
  199.     // 如果该缓冲区是该队列的头一个块，则让hash表的对应项指向本队列中的下一个
  200.     // 缓冲区。
  201.     if (hash(bh->b_dev,bh->b_blocknr) == bh)
  202.         hash(bh->b_dev,bh->b_blocknr) = bh->b_next;
  203. /* remove from free list */
  204.     if (!(bh->b_prev_free) || !(bh->b_next_free))
  205.         panic("Free block list corrupted");
  206.     bh->b_prev_free->b_next_free = bh->b_next_free;
  207.     bh->b_next_free->b_prev_free = bh->b_prev_free;
  208.     // 如果空闲链表头指向本缓冲区，则让其指向下一缓冲区。
  209.     if (free_list == bh)
  210.         free_list = bh->b_next_free;
  211. }
  213. //// 将缓冲块插入空闲链表尾部，同时放入hash队列中。
  214. static inline void insert_into_queues(struct buffer_head * bh)
  215. {
  216. /* put at end of free list */
  217.     bh->b_next_free = free_list;
  218.     bh->b_prev_free = free_list->b_prev_free;
  219.     free_list->b_prev_free->b_next_free = bh;
  220.     free_list->b_prev_free = bh;
  221. /* put the buffer in new hash-queue if it has a device */
  222.     // 请注意当hash表某项第1次插入项时，hash()计算值肯定为Null，因此此时得到
  223.     // 的bh->b_next肯定是NULL，所以应该在bh->b_next不为NULL时才能给b_prev赋
  224.     // bh值。
  225.     bh->b_prev = NULL;
  226.     bh->b_next = NULL;
  227.     if (!bh->b_dev)
  228.         return;
  229.     bh->b_next = hash(bh->b_dev,bh->b_blocknr);
  230.     hash(bh->b_dev,bh->b_blocknr) = bh;
  231.     bh->b_next->b_prev = bh;                // 此句前应添加"if (bh->b_next)"判断
  232. }
  234. //// 利用hash表在高速缓冲区中寻找给定设备和指定块号的缓冲区块。
  235. // 如果找到则返回缓冲区块的指针，否则返回NULL。
  236. static struct buffer_head * find_buffer(int dev, int block)
  237. {       
  238.     struct buffer_head * tmp;
  240.     // 搜索hash表，寻找指定设备号和块号的缓冲块。
  241.     for (tmp = hash(dev,block) ; tmp != NULL ; tmp = tmp->b_next)
  242.         if (tmp->b_dev==dev && tmp->b_blocknr==block)
  243.             return tmp;
  244.     return NULL;
  245. }
  247. /*
  248.  * Why like this, I hear you say... The reason is race-conditions.
  249.  * As we don't lock buffers (unless we are readint them, that is),
  250.  * something might happen to it while we sleep (ie a read-error
  251.  * will force it bad). This shouldn't really happen currently, but
  252.  * the code is ready.
  253.  */
  254. //// 利用hash表在高速缓冲区中寻找指定的缓冲块。若找到则对该缓冲块上锁
  255. // 返回块头指针。
  256. struct buffer_head * get_hash_table(int dev, int block)
  257. {
  258.     struct buffer_head * bh;
  260.     for (;;) {
  261.         // 在高速缓冲中寻找给定设备和指定块的缓冲区块，如果没有找到则返回NULL。
  262.         if (!(bh=find_buffer(dev,block)))
  263.             return NULL;
  264.         // 对该缓冲块增加引用计数，并等待该缓冲块解锁。由于经过了睡眠状态，
  265.         // 因此有必要在验证该缓冲块的正确性，并返回缓冲块头指针。
  266.         bh->b_count++;
  267.         wait_on_buffer(bh);
  268.         if (bh->b_dev == dev && bh->b_blocknr == block)
  269.             return bh;
  270.         // 如果在睡眠时该缓冲块所属的设备号或块设备号发生了改变，则撤消对它的
  271.         // 引用计数，重新寻找。
  272.         bh->b_count--;
  273.     }
  274. }
  276. /*
  277.  * Ok, this is getblk, and it isn't very clear, again to hinder
  278.  * race-conditions. Most of the code is seldom used, (ie repeating),
  279.  * so it should be much more efficient than it looks.
  280.  *
  281.  * The algoritm is changed: hopefully better, and an elusive bug removed.
  282.  */
  283. // 下面宏用于同时判断缓冲区的修改标志和锁定标志，并且定义修改标志的权重要比锁定标志大。
  284. #define BADNESS(bh) (((bh)->b_dirt<<1)+(bh)->b_lock)
  285. //// 取高速缓冲中指定的缓冲块
  286. // 检查指定（设备号和块号）的缓冲区是否已经在高速缓冲中。如果指定块已经在
  287. // 高速缓冲中，则返回对应缓冲区头指针退出；如果不在，就需要在高速缓冲中设置一个
  288. // 对应设备号和块好的新项。返回相应的缓冲区头指针。
  289. struct buffer_head * getblk(int dev,int block)
  290. {
  291.     struct buffer_head * tmp, * bh;
  293. repeat:
  294.     // 搜索hash表，如果指定块已经在高速缓冲中，则返回对应缓冲区头指针，退出。
  295.     if ((bh = get_hash_table(dev,block)))
  296.         return bh;
  297.     // 扫描空闲数据块链表，寻找空闲缓冲区。
  298.     // 首先让tmp指向空闲链表的第一个空闲缓冲区头
  299.     tmp = free_list;
  300.     do {
  301.         // 如果该缓冲区正被使用（引用计数不等于0），则继续扫描下一项。对于
  302.         // b_count = 0的块，即高速缓冲中当前没有引用的块不一定就是干净的
  303.         // (b_dirt=0)或没有锁定的(b_lock=0)。因此，我们还是需要继续下面的判断
  304.         // 和选择。例如当一个任务该写过一块内容后就释放了，于是该块b_count()=0
  305.         // 但b_lock不等于0；当一个任务执行breada()预读几个块时，只要ll_rw_block()
  306.         // 命令发出后，它就会递减b_count; 但此时实际上硬盘访问操作可能还在进行，
  307.         // 因此此时b_lock=1, 但b_count=0.
  308.         if (tmp->b_count)
  309.             continue;
  310.         // 如果缓冲头指针bh为空，或者tmp所指缓冲头的标志(修改、锁定)权重小于bh
  311.         // 头标志的权重，则让bh指向tmp缓冲块头。如果该tmp缓冲块头表明缓冲块既
  312.         // 没有修改也没有锁定标志置位，则说明已为指定设备上的块取得对应的高速
  313.         // 缓冲块，则退出循环。否则我们就继续执行本循环，看看能否找到一个BANDNESS()
  314.         // 最小的缓冲块。
  315.         if (!bh || BADNESS(tmp)<BADNESS(bh)) {
  316.             bh = tmp;
  317.             if (!BADNESS(tmp))
  318.                 break;
  319.         }
  320. /* and repeat until we find something good */
  321.     } while ((tmp = tmp->b_next_free) != free_list);
  322.     // 如果循环检查发现所有缓冲块都正在被使用(所有缓冲块的头部引用计数都>0)中，
  323.     // 则睡眠等待有空闲缓冲块可用。当有空闲缓冲块可用时本进程会呗明确的唤醒。
  324.     // 然后我们跳转到函数开始处重新查找空闲缓冲块。
  325.     if (!bh) {
  326.         sleep_on(&buffer_wait);
  327.         goto repeat;
  328.     }
  329.     // 执行到这里，说明我们已经找到了一个比较合适的空闲缓冲块了。于是先等待该缓冲区
  330.     // 解锁。如果在我们睡眠阶段该缓冲区又被其他任务使用的话，只好重复上述寻找过程。
  331.     wait_on_buffer(bh);
  332.     if (bh->b_count)
  333.         goto repeat;
  334.     // 如果该缓冲区已被修改，则将数据写盘，并再次等待缓冲区解锁。同样地，若该缓冲区
  335.     // 又被其他任务使用的话，只好再重复上述寻找过程。
  336.     while (bh->b_dirt) {
  337.         sync_dev(bh->b_dev);
  338.         wait_on_buffer(bh);
  339.         if (bh->b_count)
  340.             goto repeat;
  341.     }
  342. /* NOTE!! While we slept waiting for this block, somebody else might */
  343. /* already have added "this" block to the cache. check it */
  344.     // 在高速缓冲hash表中检查指定设备和块的缓冲块是否乘我们睡眠之际已经被加入
  345.     // 进去。如果是的话，则返回，即没有必要申请新的缓冲块。
  346.     if (find_buffer(dev,block))
  347.         goto repeat;
  348. /* OK, FINALLY we know that this buffer is the only one of it's kind, */
  349. /* and that it's unused (b_count=0), unlocked (b_lock=0), and clean */
  350.     // 于是让我们占用此缓冲块。置引用计数为1，复位修改标志和有效(更新)标志。
  351.     bh->b_count=1;
  352.     bh->b_dirt=0;
  353.     bh->b_uptodate=0;
  354.     // 从hash队列和空闲队列块链表中移出该缓冲区头，让该缓冲区用于指定设备和
  355.     // 其上的指定块。然后根据此新的设备号和块号重新插入空闲链表和hash队列新
  356.     // 位置处。并最终返回缓冲头指针。
  357.     remove_from_queues(bh);
  358.     bh->b_dev=dev;
  359.     bh->b_blocknr=block;
  360.     insert_into_queues(bh);
  361.     return bh;
  362. }
  364. // 释放指定缓冲块。
  365. // 等待该缓冲块解锁。然后引用计数递减1，并明确地唤醒等待空闲缓冲块的进程。
  366. void brelse(struct buffer_head * buf)
  367. {
  368.     if (!buf)
  369.         return;
  370.     wait_on_buffer(buf);
  371.     if (!(buf->b_count--))
  372.         panic("Trying to free free buffer");
  373.     wake_up(&buffer_wait);
  374. }
  376. /*
  377.  * bread() reads a specified block and returns the buffer that contains
  378.  * it. It returns NULL if the block was unreadable.
  379.  */
  380. //// 从设备上读取数据块。
  381. // 该函数根据指定的设备号 dev 和数据块号 block，首先在高速缓冲区中申请一块
  382. // 缓冲块。如果该缓冲块中已经包含有有效的数据就直接返回该缓冲块指针，否则
  383. // 就从设备中读取指定的数据块到该缓冲块中并返回缓冲块指针。
  384. struct buffer_head * bread(int dev,int block)
  385. {
  386.     struct buffer_head * bh;
  388.     // 在高速缓冲区中申请一块缓冲块。如果返回值是NULL，则表示内核出错，停机。
  389.     // 然后我们判断其中说是否已有可用数据。
  390.     if (!(bh=getblk(dev,block)))
  391.         panic("bread: getblk returned NULL\n");
  392.     // 如果该缓冲块中数据是有效的（已更新）
  393.     // 可以直接使用，则返回。
  394.     if (bh->b_uptodate)
  395.         return bh;
  396.     // 否则我们就调用底层快设备读写ll_rw_block函数，产生读设备块请求。然后
  397.     // 等待指定数据块被读入，并等待缓冲区解锁。在睡眠醒来之后，如果该缓冲区已
  398.     // 更新，则返回缓冲区头指针，退出。否则表明读设备操作失败，于是释放该缓
  399.     // 冲区，返回NULL，退出。
  400.     ll_rw_block(READ,bh);
  401.     wait_on_buffer(bh);
  402.     if (bh->b_uptodate)
  403.         return bh;
  404.     brelse(bh);
  405.     return NULL;
  406. }
  408. //// 复制内存块
  409. // 从from地址复制一块(1024 bytes)数据到 to 位置。
  410. #define COPYBLK(from,to) \
  411. __asm__("cld\n\t" \
  412.     "rep\n\t" \
  413.     "movsl\n\t" \
  414.     ::"c" (BLOCK_SIZE/4),"S" (from),"D" (to) \
  415.     )
  417. /*
  418.  * bread_page reads four buffers into memory at the desired address. It's
  419.  * a function of its own, as there is some speed to be got by reading them
  420.  * all at the same time, not waiting for one to be read, and then another
  421.  * etc.
  422.  */
  423. //// 读设备上一个页面（4个缓冲块）的内容到指定内存地址。
  424. // 参数address是保存页面数据的地址：dev 是指定的设备号；b[4]是含有4个设备
  425. // 数据块号的数组。该函数仅用于mm/memory.c文件中的do_no_page()函数中。
  426. void bread_page(unsigned long address,int dev,int b[4])
  427. {
  428.     struct buffer_head * bh[4];
  429.     int i;
  431.     // 该函数循环执行4次，根据放在数组b[]中的4个块号从设备dev中读取一页内容
  432.     // 放到指定内存位置address处。对于参数b[i]给出的有效块号，函数首先从高速
  433.     // 缓冲中取指定设备和块号的缓冲块。如果缓冲块中数据无效(未更新)则产生读
  434.     // 设备请求从设备上读取相应数据块。对于b[i]无效的块号则不用去理他了。因此
  435.     // 本函数其实可以根据指定的b[]中的块号随意读取1-4个数据块。
  436.     for (i=0 ; i<4 ; i++)
  437.         if (b[i]) {
  438.             if ((bh[i] = getblk(dev,b[i])))
  439.                 if (!bh[i]->b_uptodate)
  440.                     ll_rw_block(READ,bh[i]);
  441.         } else
  442.             bh[i] = NULL;
  443.     // 随后将4个缓冲块上的内容顺序复制到指定地址处。在进行复制（使用）缓冲块之前
  444.     // 我们先要睡眠等待缓冲块解锁，另外，因为可能睡眠过了，所以我们还需要在复制
  445.     // 之前再检查一下缓冲块中的数据是否是有效的。复制完后我们还需要释放缓冲块。
  446.     for (i=0 ; i<4 ; i++,address += BLOCK_SIZE)
  447.         if (bh[i]) {
  448.             wait_on_buffer(bh[i]);          // 等待缓冲块解锁
  449.             if (bh[i]->b_uptodate)          // 若缓冲块中数据有效则复制
  450.                 COPYBLK((unsigned long) bh[i]->b_data,address);
  451.             brelse(bh[i]);
  452.         }
  453. }
  455. /*
  456.  * Ok, breada can be used as bread, but additionally to mark other
  457.  * blocks for reading as well. End the argument list with a negative
  458.  * number.
  459.  */
  460. //// 从指定设备读取指定的一些块
  461. // 函数参数个可变，是一些列指定的块号。成功时返回第一块的缓冲块头指针，
  462. // 否则返回NULL。
  463. struct buffer_head * breada(int dev,int first, ...)
  464. {
  465.     va_list args;
  466.     struct buffer_head * bh, *tmp;
  468.     // 首先可变参数表中第一个参数（块号）。接着从高速缓冲区中取指定设备和块号
  469.     // 的缓冲块。如果该缓冲块数据无效（更新标志未置位），则发出读设备数据块请求。
  470.     va_start(args,first);
  471.     if (!(bh=getblk(dev,first)))
  472.         panic("bread: getblk returned NULL\n");
  473.     if (!bh->b_uptodate)
  474.         ll_rw_block(READ,bh);
  475.     // 然后顺序取可变参数表中其他预读块号，并作与上面同样处理，但不引用。
  476.     while ((first=va_arg(args,int))>=0) {
  477.         tmp=getblk(dev,first);
  478.         if (tmp) {
  479.             if (!tmp->b_uptodate)
  480.                 // 这句中的bh应该是tmp。
  481.                 ll_rw_block(READA,bh);
  482.             // 因为这里是预读随后的数据块，只需读进高速缓冲区但并不是马上就使用，
  483.             // 所以这句需要将其引用计数递减释放该块(因为getblk()函数会增加引用计数值)
  484.             tmp->b_count--;
  485.         }
  486.     }
  487.     // 此时可变参数表中所有参数处理完毕。于是等待第一个缓冲区解锁，在等待退出之后，如果
  488.     // 缓冲区中数据仍然有效，则返回缓冲区头指针退出。否则释放该缓冲区返回NULL,退出。
  489.     va_end(args); 
  490.     wait_on_buffer(bh);
  491.     if (bh->b_uptodate)
  492.         return bh;
  493.     brelse(bh);
  494.     return (NULL);
  495. }
  497. // 缓冲区初始化函数
  498. // 参数buffer_end是缓冲区内存末端。对于具有16MB内存的系统，缓冲区末端被设置为4MB.
  499. // 对于有8MB内存的系统，缓冲区末端被设置为2MB。该函数从缓冲区开始位置start_buffer
  500. // 处和缓冲区末端buffer_end处分别同时设置(初始化)缓冲块头结构和对应的数据块。直到
  501. // 缓冲区中所有内存被分配完毕。
  502. void buffer_init(long buffer_end)
  503. {
  504.     // struct buffer_head * start_buffer = (struct buffer_head *) &end;
  505.     struct buffer_head * h = start_buffer;
  506.     void * b;
  507.     int i;
  509.     // 首先根据参数提供的缓冲区高端位置确定实际缓冲区高端位置b。如果缓冲区高端等于1Mb，
  510.     // 则因为从640KB - 1MB被显示内存和BIOS占用，所以实际可用缓冲区内存高端位置应该是
  511.     // 640KB。否则缓冲区内存高端一定大于1MB。
  512.     if (buffer_end == 1<<20)
  513.         b = (void *) (640*1024);
  514.     else
  515.         b = (void *) buffer_end;
  516.     // 这段代码用于初始化缓冲区，建立空闲缓冲区块循环链表，并获取系统中缓冲块数目。
  517.     // 操作的过程是从缓冲区高端开始划分1KB大小的缓冲块，与此同时在缓冲区低端建立
  518.     // 描述该缓冲区块的结构buffer_head,并将这些buffer_head组成双向链表。
  519.     // h是指向缓冲头结构的指针，而h+1是指向内存地址连续的下一个缓冲头地址，也可以说
  520.     // 是指向h缓冲头的末端外。为了保证有足够长度的内存来存储一个缓冲头结构，需要b所
  521.     // 指向的内存块地址 >= h 缓冲头的末端，即要求 >= h+1.
  522.     while ( (b -= BLOCK_SIZE) >= ((void *) (h+1)) ) {
  523.         h->b_dev = 0;                       // 使用该缓冲块的设备号
  524.         h->b_dirt = 0;                      // 脏标志，即缓冲块修改标志
  525.         h->b_count = 0;                     // 缓冲块引用计数
  526.         h->b_lock = 0;                      // 缓冲块锁定标志
  527.         h->b_uptodate = 0;                  // 缓冲块更新标志(或称数据有效标志)
  528.         h->b_wait = NULL;                   // 指向等待该缓冲块解锁的进程
  529.         h->b_next = NULL;                   // 指向具有相同hash值的下一个缓冲头
  530.         h->b_prev = NULL;                   // 指向具有相同hash值的前一个缓冲头
  531.         h->b_data = (char *) b;             // 指向对应缓冲块数据块（1024字节）
  532.         h->b_prev_free = h-1;               // 指向链表中前一项
  533.         h->b_next_free = h+1;               // 指向连表中后一项
  534.         h++;                                // h指向下一新缓冲头位置
  535.         NR_BUFFERS++;                       // 缓冲区块数累加
  536.         if (b == (void *) 0x100000)         // 若b递减到等于1MB，则跳过384KB
  537.             b = (void *) 0xA0000;           // 让b指向地址0xA0000(640KB)处
  538.     }
  539.     h--;                                    // 让h指向最后一个有效缓冲块头
  540.     free_list = start_buffer;               // 让空闲链表头指向头一个缓冲快
  541.     free_list->b_prev_free = h;             // 链表头的b_prev_free指向前一项(即最后一项)。
  542.     h->b_next_free = free_list;             // h的下一项指针指向第一项，形成一个环链
  543.     // 最后初始化hash表，置表中所有指针为NULL。
  544.     for (i=0;i<NR_HASH;i++)
  545.         hash_table[i]=NULL;
  546. }

疑问

  1. buffer.c中 wait_on_buffer()函数中 根本没有涉及到当前任务 current,而且也没有发现 任何修改 bh->b_wait 参数的语句，所以在 wait_on_buffer() 函数中到底是怎么回事?只能通过运行调试的方式来解决。

在我眼中 wait_on_buffer() 应该是

  1. static inline void wait_on_buffer (struct buffer_head *bh)  
  2. {  
  3.   cli ();           // 关中断。  
  4.   if !(bh->b_wait){
  5.     bh_>b_wait = current;   
  6.   }else{
  7.     // 往 bh的 b_wait 队列后面加上current  
  8.     // 但是这样的话， b_wait 应该是二级指针
  9.     // 而且 之后睡眠的 语句有有待商榷
  10.     // 或者 一个buffer后面只能等待一个 进程
  11.     // 即一个buffer只能同时被一个 进程使用， 被另外一个进程等待
  12.     // 这样的话，后面那段语句就可以不用修改，而且 b_wait 也只是一个指针
  13.     // 而不是二级指针
  15.     // 另外， 关于缓存管理的方面可以参考  unix design , 所以具体解答还要
  16.     // 等我阅读完 unix design 关于缓存管理的部分
  17.   }
  18.   while (bh->b_lock)     // 如果已被上锁，则进程进入睡眠，等待其解锁。  
  19.     sleep_on (&bh->b_wait);  
  20.   sti ();           // 开中断。  
  21. }

解答：

sleep_on(struct task_struct **p) 函数会让 这个指针指向当前进程，同时让当前进程进入不可中断的睡眠状态。这样就可以解释之前的问题，因为 wait_on_buffer()函数中没有判断 bh->b_wait 是否有效，再加上 bh->b-wait 只是一个 buffer_head的指针， 所以一个 buffer只能有一个等待的进程。

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注