// linux/fs/buffer.c
205 #define BADNESS(bh) (((bh)->b_dirt<<1)+(bh)->b_lock)
206 struct buffer_head * getblk(int dev,int block)
207 {
208 struct buffer_head * tmp, * bh;
209
210 repeat:
211 if (bh = get_hash_table(dev,block))
212 return bh;
213 tmp = free_list;
214 do {
215 if (tmp->b_count)
216 continue;
217 if (!bh || BADNESS(tmp)<BADNESS(bh)) {
218 bh = tmp;
219 if (!BADNESS(tmp))
220 break;
221 }
222 /* and repeat until we find something good */
223 } while ((tmp = tmp->b_next_free) != free_list);
struct buffer_head *tmp,*bh就是缓冲块头结构的两个变量，然后，进入repeat循环。
在repeat循环中，首先，先搜索hash表，检查是不是所需要的缓冲块已经被读入缓冲区了，即if(bh=get_hash_table(dev,block)) return bh;。那么，我们来看get_hash_table是如何实现的
// linux/fs/buffer.c
183 struct buffer_head * get_hash_table(int dev, int block)
184 {
185 struct buffer_head * bh;
186
187 for (;;) {
188 if (!(bh=find_buffer(dev,block)))
189 return NULL;
190 bh->b_count++;
191 wait_on_buffer(bh);
192 if (bh->b_dev == dev && bh->b_blocknr == block)
193 return bh;
194 bh->b_count--;
195 }
196 }
可以看到，这个函数又会调用find_buffer,我们再往下走
// linux/fs/buffer.c
166 static struct buffer_head * find_buffer(int dev, int block)
167 {
168 struct buffer_head * tmp;
169
170 for (tmp = hash(dev,block) ; tmp != NULL ; tmp = tmp->b_next)
171 if (tmp->b_dev==dev && tmp->b_blocknr==block)
172 return tmp;
173 return NULL;
174 }
这个函数的主体是一个for循环，tmp=hash(dev,block)，我们再看hash函数的实现
//linux/fs/buffer.c
128 #define _hashfn(dev,block) (((unsigned)(dev^block))%NR_HASH)
129 #define hash(dev,block) hash_table[_hashfn(dev,block)]
可以看到，hash函数其实就是一个宏，hash函数为(dev^block)%NR_HASH，其中NR_HASH为307。这样，也就是说，先从标号为hash(dev,block)的缓冲头开始找，如果往下走，能够找到一个该设备的，且为该数据块的缓冲块已经存在于内存中（即if(tmp->b_dev==dev&&tmp->b_blocknr==block)。
如果找不到，则返回NULL
如果找到了,
187 for (;;) {
188 if (!(bh=find_buffer(dev,block)))
189 return NULL;
190 bh->b_count++;
191 wait_on_buffer(bh);
192 if (bh->b_dev == dev && bh->b_blocknr == block)
193 return bh;
194 bh->b_count--;
195 }
便会将这个缓冲块的引用计数加1,然后如果被锁，则等待其解锁，待锁解开后，if(bh->b_dev==dev&&bh->b_blocknr==block)，即再进行一次确认，如果确认成功，将bh返回，否则，将bh的引用计数减1（因为在等待解锁前已经将其加1）。
这里的再次确认是有必要的，因为在等待其解锁的过程中，有可能这个块已经被别的进程使用了。
现在再回过头去看getblk函数
//linux/fs/buffer.c
210 repeat:
211 if (bh = get_hash_table(dev,block))
212 return bh;
213 tmp = free_list;
214 do {
215 if (tmp->b_count)
216 continue;
217 if (!bh || BADNESS(tmp)<BADNESS(bh)) {
218 bh = tmp;
219 if (!BADNESS(tmp))
220 break;
221 }
222 /* and repeat until we find something good */
223 } while ((tmp = tmp->b_next_free) != free_list);
这里，如果没找到，将会进入do while循环。
if(tmp->count) countinue;如果缓冲块正在被使用，则跳过
直到找到一个合适的缓冲块。
如果循环了链表的一圈，还是没有找到合适的缓冲块，那么将这个进程挂起，也就是
224 if (!bh) {
225 sleep_on(&buffer_wait);
226 goto repeat;
227 }
待其被唤醒后，重新进入repeat循环，进行合适缓冲块的查找。
228 wait_on_buffer(bh);
229 if (bh->b_count)
230 goto repeat;
231 while (bh->b_dirt) {
232 sync_dev(bh->b_dev);
233 wait_on_buffer(bh);
234 if (bh->b_count)
235 goto repeat;
如果经过了一次repeat循环，找到了合适的缓冲块，那么，等待这个缓冲块的解锁，即wait_on_buffer(bh)，注意这个函数并不是真正的等待，我们可以去看它的内部实现，只是在该缓冲块被锁定时，调用schedule函数进入任务切换，否则，函数直接返回。
同样，在等待的过程中，可能别的进程又将其占用了(这里面的原因个人认为应该和进程调试中，进程被唤醒的方式有关，也就是说，有两个进程同时等待同一个缓冲区，那么，在缓冲区可用时，系统肯定会发送一个信号，至于在schedule函数中，是怎么对task_struct数组进行遍历的，就决定了这里需不需要再进行检查）。
如果没被占用，但是该缓冲区已经被修改，那么进入while循环
sync_dev(bh->dev)是将所对应的设备进入写入操作。
在操作时，会对该块加锁，所以需要等待其解锁。
如果解锁完毕后，该块又被占用了（道理同上），那么，前功尽弃，只好重新进入repeat循环，再去寻找新的可用的缓冲块。
237 /* NOTE!! While we slept waiting for this block, somebody else might */
238 /* already have added "this" block to the cache. check it */
239 if (find_buffer(dev,block))
240 goto repeat;
这几句没看明白，虽然有注释。。。 等下问下同学和老师再回来做解释。
241 /* OK, FINALLY we know that this buffer is the only one of it's kind, */
242 /* and that it's unused (b_count=0), unlocked (b_lock=0), and clean */
243 bh->b_count=1;
244 bh->b_dirt=0;
245 bh->b_uptodate=0;
246 remove_from_queues(bh);
247 bh->b_dev=dev;
248 bh->b_blocknr=block;
249 insert_into_queues(bh);
250 return bh;
看注释可以看出来，到这里，”OK，FINALLY we know that this buffer is the only one of it's kind,"
linus还故意用大写字母，可见他也是松了一口气~~
于是，将此缓冲区占用(bh->b_count=1)，清除其脏标志（bh->dirt=0)，以及有效标志(bh->b_uptodate=0)
既然它已经被占用了，那么便把它移出空闲链表
remove_from_queues(bh)
bh->b_dev=dev;
bh->b_blocknr=blockl;
移出后，把它放放到一个新的合适的位置。（因为这时候，有可能另一个进程需要使用同样的缓冲块，在hash时，最好能够尽快找到这个块。)
insert_into_queues(bh);
现在，一切大功告成，
return bh;