block_prepare_write解析

/*
*from和to分别指定页面内将要操作的段的起点和终点
*get_block针对具体的文件系统把文件逻辑块号转换成相对于设备分区起始的逻辑块号
*/

int block_prepare_write(struct page *page, unsigned from, unsigned to,

get_block_t *get_block)

{

struct inode *inode = page->mapping->host;

int err = __block_prepare_write(inode, page, from, to, get_block);

if (err)

ClearPageUptodate(page);

return err;

}

 

static int __block_prepare_write(struct inode *inode, struct page *page,

unsigned from, unsigned to, get_block_t *get_block)

{

unsigned block_start, block_end;

sector_t block;

int err = 0;

unsigned blocksize, bbits;

struct buffer_head *bh, *head, *wait[2], **wait_bh=wait;



BUG_ON(!PageLocked(page));

BUG_ON(from > PAGE_CACHE_SIZE);

BUG_ON(to > PAGE_CACHE_SIZE);

BUG_ON(from > to);
blocksize = 1 << inode->i_blkbits; //块大小，也即页内缓冲区大小
/*
*调用create_empty_buffers为该页建立缓冲区队列，然后对队列进行初始化。
*没有涉及bh的state标志
*调用的create_buffers中设置bh->state = 0
*且把新分配的buffer放入BUF_CLEAN链表（BH_dirty标志为0）
* 缓冲队列头赋给page->buffer

*/

if (!page_has_buffers(page))

create_empty_buffers(page, blocksize, 0);

head = page_buffers(page)；

/*当前页所在的块号*/
/*
*假设块大小为1k,则bbits = inode->i_blkbits, bbits为10
*则一页占2^(PAGE_CACHE_SHIFT-bbits)=2^(12-10)=2^2=4个块
*因此该页的逻辑起始块号为: page->index*每页块数
*即page->index*2^(PAGE_CACHE_SHIFT-bbits)=
* page->index<<(PAGE_CACHE_SHIFT-bbits)
*/

bbits = inode->i_blkbits;

block = (sector_t)page->index << (PAGE_CACHE_SHIFT - bbits);

/*
*对页中每个buffer对应的bh和受写影响的每个bh
*block_start记录循环写入的总块大小
*/
for(bh = head, block_start = 0; bh != head || !block_start;

block++, block_start=block_end, bh = bh->b_this_page) {

block_end = block_start + blocksize; /*累计写入块大小*/

if (block_end <= from || block_start >= to) {   //对页内from到to的区域进行下列转换、检查或设置

if (PageUptodate(page)) {

if (!buffer_uptodate(bh))

set_buffer_uptodate(bh);

}

continue;

}

if (buffer_new(bh))

clear_buffer_new(bh); /*清BH_New标志(如果相应的文件块正好被分配但从未被访问)*/

/*
*检查如果BH_Mapped标志未设置
*调用get_block将文件逻辑块号-〉设备上记录块(相对磁盘分区的起始位置)
*块号存放与b_blocknr字段且设置BH_Mapped标志(完成映射)
*/

if (!buffer_mapped(bh)) {

WARN_ON(bh->b_size != blocksize);

err = get_block(inode, block, bh, 1);

if (err)

break;

/*
*检查BH_New标志，如果被设置
*调用unmap_underlying_metadata来检查页高速缓存内的某个块设备缓冲区页是否包含指向磁盘同一块的缓冲区
*如果找到一块，BH_Dirty清0并等待知道该缓冲区的I/O数据传输完毕
*/

if (buffer_new(bh)) {

unmap_underlying_metadata(bh->b_bdev,

bh->b_blocknr);

if (PageUptodate(page)) {

set_buffer_uptodate(bh);

continue;

}

if (block_end > to || block_start < from) {

void *kaddr;



kaddr = kmap_atomic(page, KM_USER0);

if (block_end > to)

memset(kaddr+to, 0,

block_end-to);

if (block_start < from)

memset(kaddr+block_start,

0, from-block_start);

flush_dcache_page(page);

kunmap_atomic(kaddr, KM_USER0);

}

continue;

}

}

if (PageUptodate(page)) { /*如果page的读操作完成的PG_uptodate标志设置了，则将其缓冲区的BH_Uptodate也设置*/

if (!buffer_uptodate(bh))

set_buffer_uptodate(bh);

continue;

}

/*如果不对整个缓冲区进行重写且它的BH_Delay和BH_Uptodate标志未置位（即缓冲区没有有效的数据影响），
*调用ll_rw_block来从磁盘读入块的内容
*ll_rw_block函数中自定义了I/O完后调用了end_buffer_io_sync
*/

if (!buffer_uptodate(bh) && !buffer_delay(bh) &&

(block_start < from || block_end > to)) {

ll_rw_block(READ, 1, &bh);

*wait_bh++=bh;

}

}

/*

* If we issued read requests - let them complete.

*/







/*



* 阻塞当前进程，直到for循环中的ll_rw_block读操作全部完成



*/

while(wait_bh > wait) {

wait_on_buffer(*--wait_bh);

if (!buffer_uptodate(*wait_bh))

err = -EIO;

}

if (!err) {

bh = head;

do {

if (buffer_new(bh))

clear_buffer_new(bh);

} while ((bh = bh->b_this_page) != head);

return 0;

}

/* Error case: */

/*

* Zero out any newly allocated blocks to avoid exposing stale

* data. If BH_New is set, we know that the block was newly

* allocated in the above loop.

*/

bh = head;

block_start = 0;

do {

block_end = block_start+blocksize;

if (block_end <= from)

goto next_bh;

if (block_start >= to)

break;

if (buffer_new(bh)) {

void *kaddr;



clear_buffer_new(bh);

kaddr = kmap_atomic(page, KM_USER0);

memset(kaddr+block_start, 0, bh->b_size);

kunmap_atomic(kaddr, KM_USER0);

set_buffer_uptodate(bh);

mark_buffer_dirty(bh);

}

next_bh:

block_start = block_end;

bh = bh->b_this_page;

} while (bh != head);

return err;

}