缓存同步操作--sys_sync系统调用

sys_sync系统调用被用户空间函数调用，用来将缓存中的数据写入块设备，sys_sync系统调用将buffer、inode和super在缓存中的数据写入设备。sys_sync函数在fs/buffer.c中，现分析如下：

1. asmlinkage long sys_sync(void)
3. {
5. do_sync(1);
7. return 0;
9. }

　　函数do_sync各种数据，开始唤醒pdflush，因为它并行地把所有队列写回设备。函数分析如下：

1. static void do_sync(unsigned long wait)
3. {
5. wakeup_bdflush(0);
7. sync_inodes(0); /* All mappings, inodes and their blockdevs */
9. DQUOT_SYNC(NULL);
11. 　　// 最终调用sb->s_op->write_super(sb)即具体文件系统的函数来实现写超级块
13. sync_supers(); /* Write the superblocks */
15. sync_filesystems(0); /* Start syncing the filesystems */
17. sync_filesystems(wait); /* Waitingly sync the filesystems */
19. sync_inodes(wait); /* Mappings, inodes and blockdevs, again. */
21. if (!wait)
23. printk("Emergency Sync complete\n");
25. if (unlikely(laptop_mode))
27. laptop_sync_completion();
30. }

多个节点同步回写操作函数sync_inodes

函数sync_inodes调用层次图

函数sync_inodes遍历每个超级块的脏节点链表，把节点写回到块设备，并等待回写操作的完成，写完成后把节点放回到正常的链表中。函数sync_inodes是给系统调用sys_sync用的，函数fsync_dev使用同样的算法。sync函数的精细地方是块设备"超级块"最后被处理。这是因为函数write_inode是典型的文件系统操作函数，它不执行I/O，而是在块设备映射的地址空间把buffer标识为脏。我们所想做的是先执行所有的标识脏的操作，接着，在一次扫描中通过块设备映射地址空间写回所有的节点块。这样附加的（在某种程度上说是冗余的）sync_blockdev函数在这儿调用来确认这个操作真正发生。因为如果我们对明显的脏节点调用函数sync_inodes_sb(wait=1)，回写操作将在文件系统的函数write_inode里有时进入堵塞，这种情况下将运行极慢。

函数sync_inodes的调用层次图如上图，函数sync_inodes分析如下（在fs/fs-writeback.c中）：

单个节点同步回写操作函数sync_inodes_sb

1. void sync_inodes(int wait)
3. {
5. struct super_block *sb;
9. set_sb_syncing(0);//设置每个超级块sb->s_syncing = 0
11. while ((sb = get_super_to_sync()) != NULL) {//得到脏的超级块结构
13. sync_inodes_sb(sb, 0);
15. 　　　　//写与块设备对应的所有脏数据，并等待写操作完成
17. sync_blockdev(sb->s_bdev);　
19. drop_super(sb);//使用计数减1，即sb->s_count-1
21. }
23. if (wait) {
25. set_sb_syncing(0);
27. while ((sb = get_super_to_sync()) != NULL) {
29. sync_inodes_sb(sb, 1);
31. sync_blockdev(sb->s_bdev);
33. drop_super(sb);
35. }
37. }
39. }

函数sync_inodes_sb执行回写操作并等待在文件系统的脏节点上。调用者将有两个方式调用这个函数，一个是写，一个是等待写。对于等待写方式来说，WB_SYNC_HOLD标识用来把写的节点停在sb->s_dirty上等待。为了防止函数sys_sync的死锁，将写的页数给了一个限制。限制被加到潜在的脏节点里，因为每个节点写操作能弄脏块设备的页缓存。

函数sync_inodes_sb分析如下（在fs/fs-writeback.c中）：

1. void sync_inodes_sb(struct super_block *sb, int wait)
3. {
5. struct writeback_control wbc = {
7. .sync_mode = wait ? WB_SYNC_ALL : WB_SYNC_HOLD,
9. };
11. unsigned long nr_dirty = read_page_state(nr_dirty);//得到脏页数
13. unsigned long nr_unstable = read_page_state(nr_unstable);//不稳定的页数
17. wbc.nr_to_write = nr_dirty + nr_unstable +
19. (inodes_stat.nr_inodes - inodes_stat.nr_unused) +
21. nr_dirty + nr_unstable;
23. wbc.nr_to_write += wbc.nr_to_write / 2; /* Bit more for luck */
25. spin_lock(&inode_lock);
27. sync_sb_inodes(sb, &wbc);
29. spin_unlock(&inode_lock);
31. }

函数sync_sb_inodes写回一个超级块的脏节点链表到块设备。根据sync_mode方式的不同，一个回写等待可在没有节点、所有节点或最后的节点上被执行。如果older_than_this非空，那么仅写回比older_than_this早些时候被弄脏的节点。

如果是一个pdlfush线程，就对整个链表使用pdflush的防冲突措施。对于函数sys_sync来说，WB_SYNC_HOLD标识是一个hack，它重绑定inode到sb->s_dirty，以便inode能被在__writeback_single_inode()上的线程定位。

函数sync_sb_inodes应在inode_lock情况下被调用。如果bdi结构非空，表示我们正被请求回写一个特定的队列，这个函数假定块设备超级块的节点被各种队列支持。因而所有的节点被搜索。对其它超级块来说，假定所有的节点被同一队列支持。

被写的节点被停在sb->s_io上，当他们被选择写时，它们被移回到sb->s_dirty上。这样，在写者控制的途中就不会有丢失。并且得到在多个调节线程之间的相当好的平衡：我们不想它们所有的堆积在__wait_on_inode上。

函数sync_sb_inodes分析如下（在fs/fs-writeback.c中）：

1. static void sync_sb_inodes(struct super_block *sb,
3. struct writeback_control *wbc)
5. {
7. const unsigned long start = jiffies; /* livelock avoidance */
11. if (!wbc->for_kupdate || list_empty(&sb->s_io))
13. 　　　　//将s_dirty链表加到s_io链表中，并初始化了s_dirty链表
15. list_splice_init(&sb->s_dirty, &sb->s_io);　
19. while (!list_empty(&sb->s_io)) {
21. struct inode *inode = list_entry(sb->s_io.prev,
23. struct inode, i_list);
25. struct address_space *mapping = inode->i_mapping;
27. struct backing_dev_info *bdi = mapping->backing_dev_info;
29. long pages_skipped;
31. 　　　　//内存支持的文件系统，不能用writepage刷新页
33. if (bdi->memory_backed) {　
35. 　　　　　　//将节点inode从i_list中移到s_dirty链表中
37. list_move(&inode->i_list, &sb->s_dirty);
39. if (sb == blockdev_superblock) {
41. //内存支持的块设备脏：ramdisk驱动程序做这，仅跳过这个节点
43. continue;
45. }
47. 　　　　　　//内存支持文件系统的节点脏，而不是块设备支持的文件系统的节点脏，
49. 　　　　　　//跳过整个超级块。
51. break;
53. }
55. 　　　　//没用阻塞在请求队列上，且块设备写操作过多，跳过壅塞的块设备
57. if (wbc->nonblocking && bdi_write_congested(bdi)) {
59. wbc->encountered_congestion = 1;
61. if (sb != blockdev_superblock)//不是块设备的超级块
63. break; //* Skip a congested fs */
65. //将inode从i_list队列移到s_dirty队列上
67. list_move(&inode->i_list, &sb->s_dirty);
69. continue;
71. }
75. if (wbc->bdi && bdi != wbc->bdi) {//块设备有错误的队列
77. if (sb != blockdev_superblock) //不是块设备的超级块
79. break; /* fs has the wrong queue */
81. list_move(&inode->i_list, &sb->s_dirty);
83. continue;
85. }
87. //在sync_sb_inodes函数被调用后，才变成脏节点？
89. if (time_after(inode->dirtied_when, start))
91. break;
95. //节点最近被弄脏的?
97. if (wbc->older_than_this && time_after(inode->dirtied_when,
99. *wbc->older_than_this))
101. break;
105. //另外的 pdflush线程已在刷新这个队列或不能获得设备回写操作
107. if (current_is_pdflush() && !writeback_acquire(bdi))
109. break;
113. BUG_ON(inode->i_state & I_FREEING);
115. __iget(inode);
117. pages_skipped = wbc->pages_skipped;//得到不被写的页数
119. __writeback_single_inode(inode, wbc);//写回一个节点到设备
121. // WB_SYNC_HOLD表示为sys_sys()正持有在sb_dirty上的节点 　
123. if (wbc->sync_mode == WB_SYNC_HOLD) {
125. inode->dirtied_when = jiffies;
127. list_move(&inode->i_list, &sb->s_dirty);
129. }
131. if (current_is_pdflush())　//当前正在pdflush线程
133. writeback_release(bdi);//释放了bdi上BDI_pdflush状态位
135. if (wbc->pages_skipped != pages_skipped) {
137. //因为buffer锁住，writeback不进行处理，现在跳过这个节点
139. list_move(&inode->i_list, &sb->s_dirty);
141. }
143. spin_unlock(&inode_lock);
145. iput(inode);
147. spin_lock(&inode_lock);
149. if (wbc->nr_to_write <= 0)
151. break;
153. }
155. return; //留下任何没写的节点在s_io链表上
157. }

函数__writeback_single_inode写回一个节点的脏页到块设备，它在inode_lock下被调用。函数__writeback_single_inode分析如下（在fs/fs-writeback.c中）：

1. static int　__writeback_single_inode(struct inode *inode,
3. 　　　　　　　　　　　struct writeback_control *wbc)
5. {
7. 　　//如果不是同步所有的且节点是锁住的，将节点移到s_dirty链表中
9. if ((wbc->sync_mode != WB_SYNC_ALL) && (inode->i_state & I_LOCK)) {
11. list_move(&inode->i_list, &inode->i_sb->s_dirty);
13. return 0;
15. }
21. //它是一个数据一致性同步，必须等待
25. while (inode->i_state & I_LOCK) {
27. __iget(inode);
29. spin_unlock(&inode_lock);
31. __wait_on_inode(inode);
33. iput(inode);
35. spin_lock(&inode_lock);
37. }
39. return __sync_single_inode(inode, wbc);
45. }

函数__sync_single_inode写单个节点的脏页和节点数据到硬盘上，如果wait被设备，则在这个节点上等待。整个回写的设计很复杂且脆弱，我们想避免当其它节点再次变脏时特殊节点存在饥饿的现象，防止死锁等。 函数__sync_single_inode分析如下（在fs/fs-writeback.c中）：

1. static int　__sync_single_inode(struct inode *inode,
3. struct writeback_control *wbc)
5. {
7. unsigned dirty;
9. struct address_space *mapping = inode->i_mapping;
11. struct super_block *sb = inode->i_sb;
13. int wait = wbc->sync_mode == WB_SYNC_ALL;
15. int ret;
19. BUG_ON(inode->i_state & I_LOCK);
23. //设置I_LOCK, 重设置I_DIRTY标识
25. dirty = inode->i_state & I_DIRTY;
27. inode->i_state |= I_LOCK;
29. inode->i_state &= ~I_DIRTY;
33. spin_unlock(&inode_lock);
37. ret = do_writepages(mapping, wbc);//将节点对应的地址空间的数据写回设备
41. //如果仅I_DIRTY_PAGES 被设置就不写节点到块设备　
43. if (dirty & (I_DIRTY_SYNC | I_DIRTY_DATASYNC)) {
45. int err = write_inode(inode, wait);//写回节点到设备
47. if (ret == 0)
49. ret = err;
51. }
53. 　　//遍历所给地址空间的回写页的链表，等待他们所有的脏页写完
55. if (wait) {
57. int err = filemap_fdatawait(mapping);
59. if (ret == 0)
61. ret = err;
63. }
67. spin_lock(&inode_lock);
69. inode->i_state &= ~I_LOCK;
71. if (!(inode->i_state & I_FREEING)) {
73. //节点非脏且mapping中的页有PAGECACHE_TAG_DIRTY标识
75. if (!(inode->i_state & I_DIRTY) &&
77. mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) {
79. //我们不写回所有的页，nfs_writepages()有时没做任何事却运行。
81. //重新把节点设置为脏，节点还在sb->s_io链表中
83. 　　　　　 if (wbc->for_kupdate) {
85. //对kupdate函数，我们留节点在sb_dirty的头部，
87. 　　　　　　　　//以便在队列变成不壅塞时它得到更多写机会，
89. inode->i_state |= I_DIRTY_PAGES;
91. list_move_tail(&inode->i_list, &sb->s_dirty);
93. } else {
95. //完全重把节点设置成脏，以便在这个超级块上其它节点得到回写机会。
97. 　　　　　//否则，一个文件的较重的写操作将会把其它所有的文件的回写操作挂起
99. inode->i_state |= I_DIRTY_PAGES;
101. inode->dirtied_when = jiffies;
103. list_move(&inode->i_list, &sb->s_dirty);//移到s_dirty链表上
105. }
107. } else if (inode->i_state & I_DIRTY) {
109. //当正回写这些页时，有人重把节点设置成脏　
111. list_move(&inode->i_list, &sb->s_dirty);
113. } else if (atomic_read(&inode->i_count)) {
115. //节点中干净的，在使用的　
117. list_move(&inode->i_list, &inode_in_use);
119. } else {
121. //节点中干净的，没使用的
123. list_move(&inode->i_list, &inode_unused);
125. inodes_stat.nr_unused++;
127. }
129. }
131. wake_up_inode(inode);//唤醒节点上的等待队列
133. return ret;
135. }

节点地址空间数据回写操作函数do_writepages

函数do_writepages调用层次图函数do_writepages写回地址空间mapping中的数据到设备，函数do_writepages调用层次图如上图，函数分析如下（在mm/page-writeback.c中）：

1. int do_writepages(struct address_space *mapping,
3. 　　　　　　　　　　　　　struct writeback_control *wbc)
5. {
7. if (wbc->nr_to_write <= 0)
9. return 0;
11. if (mapping->a_ops->writepages)//使用指定的函数
13. return mapping->a_ops->writepages(mapping, wbc);
15. return generic_writepages(mapping, wbc);//使用通用函数
17. }

函数mpage_writepages遍历所给地址空间的脏页链表并把它们所有的写回块设备。其参数为：

　　mapping: 要写的地址空间结构

　　wbc: 回写所有页的信息结构，从wbc->nr_to_write 减去已写的页数

　　get_block: 文件系统的块映射函数指针，如果这是NULL，那么使用 a_ops->writepage，否则使用direct-to-BIO。

函数mpage_writepages是一个库函数，它利用地址空间结构里操作函数writepages()。如果一页已在I/O，使用generic_writepages()跳过它，即使它是脏的。对于内存清理的回写操作来说这是理想的行为，但它对调用如fsync()来进行数据一致性同步来说是不正确的。fsync()和msync()需要保证脏数据得到针对它们已开始的新I/O，所有的这些脏数据在调用时必须已准备好。如果wbc->sync_mode是WB_SYNC_ALL，那么函数mpage_writepages被调用来进行数据一致性回写，并且它必须等待正存在的I/O完成。

函数mpage_writepages分析如下（在fs/mpage.c中）：

1. int　mpage_writepages(struct address_space *mapping,
3. struct writeback_control *wbc, get_block_t get_block)
5. {
7. struct backing_dev_info *bdi = mapping->backing_dev_info;
9. struct bio *bio = NULL;
11. sector_t last_block_in_bio = 0;
13. int ret = 0;
15. int done = 0;
17. int (*writepage)(struct page *page, struct writeback_control *wbc);
19. //在许多地方，把多个页放在一起成一束来进行操作是有效的，
21. //pagevec是这样的多页的容器结构。
23. struct pagevec pvec;　
25. int nr_pages;
27. pgoff_t index;
29. pgoff_t end = -1; /* Inclusive */
31. int scanned = 0;
33. int is_range = 0;
37. //块设备I/O是壅塞的
39. 　　if (wbc->nonblocking && bdi_write_congested(bdi)) {
41. wbc->encountered_congestion = 1;
43. return 0;
45. }
49. writepage = NULL;
51. if (get_block == NULL)
53. writepage = mapping->a_ops->writepage;
57. //初始化pagevec结构pvec
59. pagevec_init(&pvec, 0);
61. 　　//没有正在运行的回写同步，不需要等待
63. if (wbc->sync_mode == WB_SYNC_NONE) {
65. index = mapping->writeback_index; //从上次的偏移页序号开始　
67. } else {
69. index = 0; //需要整个文件的扫描，从0页序号开始
71. scanned = 1;
73. }
75. if (wbc->start || wbc->end) {//计算开始与结束的页序号
77. index = wbc->start >> PAGE_CACHE_SHIFT;
79. end = wbc->end >> PAGE_CACHE_SHIFT;
81. is_range = 1;
83. scanned = 1;
85. }
87. retry:
89. while (!done && (index <= end) &&
91. //计算脏页数nr_pages，把脏页放在pvec中
93. (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
95. PAGECACHE_TAG_DIRTY,
97. min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1))) {
99. unsigned i;
103. scanned = 1;
105. for (i = 0; i < nr_pages; i++) {
107. struct page *page = pvec.pages[i];//得到脏页
111. //在这个地方，我们不持有mapping->tree_lock锁和页本身的锁：这页可能被剪除或无效（改变page->mapping到NULL），或者甚至从交换空间欺骗地回到tmpfs文件映射中。
115. lock_page(page);
119. if (unlikely(page->mapping != mapping)) {//页的地址空间不对
121. unlock_page(page);
123. continue;
125. }
129. if (unlikely(is_range) && page->index > end) {//所有的页已完成
131. done = 1;
133. unlock_page(page);
135. continue;
137. }
141. if (wbc->sync_mode != WB_SYNC_NONE)//正在同步操作
143. wait_on_page_writeback(page);
145. 　　　　//页在回写或不是以前的脏页
147. if (PageWriteback(page) ||
149. !clear_page_dirty_for_io(page)) {
151. unlock_page(page);
153. continue;
155. }
159. if (writepage) {
161. ret = (*writepage)(page, wbc);
163. if (ret) {//返回有错误，设置到mapping->flags
165. if (ret == -ENOSPC)
167. set_bit(AS_ENOSPC,
169. &mapping->flags);
171. else
173. set_bit(AS_EIO,
175. &mapping->flags);
177. }
179. } else {
181. bio = mpage_writepage(bio, page, get_block,
183. &last_block_in_bio, &ret, wbc);
185. }
187. if (ret || (--(wbc->nr_to_write) <= 0))
189. done = 1;
191. if (wbc->nonblocking && bdi_write_congested(bdi)) {
193. wbc->encountered_congestion = 1;
195. done = 1;
197. }
199. }
201. pagevec_release(&pvec);
203. cond_resched();//进行调度
205. }
207. if (!scanned && !done) {
209. //命中最后一页，有更多的工作要做：折回到文件的开始　
211. scanned = 1;
213. index = 0;
215. goto retry;
217. }
219. if (!is_range)
221. mapping->writeback_index = index;
223. if (bio)
225. mpage_bio_submit(WRITE, bio);
227. return ret;
229. }

如果页上有buffer那么这些buffer将被用来获得硬盘映射。我们仅支持整个已被映射且脏的页，还有特殊的情况：在文件结尾没被映射的页。如果页没有buffers那么页在这儿被映射。如果所有的块被发现是连续的，那么页能直接进入BIO，否则，回到mapping的writepage()函数。 函数mpage_writepage设计的目标是能估计还有多少页需要被写，这样它能智能地分配合适大小的BIO。但现在仅支持分配全部尺寸（16页）的BIO。

1. static struct bio *mpage_writepage(struct bio *bio, struct page *page,
3. 　　　　　　　　　　　get_block_t get_block, sector_t *last_block_in_bio,
5. 　　　　　　　　　　　 int *ret, struct writeback_control *wbc)
7. {
9. struct address_space *mapping = page->mapping;
11. struct inode *inode = page->mapping->host;
13. const unsigned blkbits = inode->i_blkbits;
15. unsigned long end_index;
17. 　　//每页的块数
19. const unsigned blocks_per_page = PAGE_CACHE_SIZE >> blkbits;
21. sector_t last_block;
23. sector_t block_in_file;
25. sector_t blocks[MAX_BUF_PER_PAGE];
27. unsigned page_block;
29. unsigned first_unmapped = blocks_per_page;
31. struct block_device *bdev = NULL;
33. int boundary = 0;
35. sector_t boundary_block = 0;
37. struct block_device *boundary_bdev = NULL;
39. int length;
41. struct buffer_head map_bh;
43. loff_t i_size = i_size_read(inode);
47. if (page_has_buffers(page)) {//如果页上有buffer
49. struct buffer_head *head = page_buffers(page);
51. struct buffer_head *bh = head;
55. //如果所有的buffer是映射且是脏的　
57. page_block = 0;
59. do {
61. BUG_ON(buffer_locked(bh));
63. if (!buffer_mapped(bh)) {//buffer是非映射的
65. //非映射的脏buffer是由函数__set_page_dirty_buffers 映射数据创建　
67. if (buffer_dirty(bh))//脏buffer
69. goto confused;
71. if (first_unmapped == blocks_per_page)
73. first_unmapped = page_block;
75. continue;
77. }
81. if (first_unmapped != blocks_per_page)
83. goto confused; /* hole -> non-hole */
85. 　　　　　　//buffer非脏或非更新的
87. if (!buffer_dirty(bh) || !buffer_uptodate(bh))
89. goto confused;
91. if (page_block) {
93. if (bh->b_blocknr != blocks[page_block-1] + 1)
95. goto confused;
97. }
99. blocks[page_block++] = bh->b_blocknr;
101. boundary = buffer_boundary(bh);
103. if (boundary) {
105. boundary_block = bh->b_blocknr;
107. boundary_bdev = bh->b_bdev;
109. }
111. bdev = bh->b_bdev;
113. } while ((bh = bh->b_this_page) != head);
117. if (first_unmapped)
119. goto page_is_mapped;
123. /*页有buffer，但所有的buffer没被映射，这些页被在内存空洞上的pagein或读创建，这些空洞被函数block_read_full_page处理，如果address_space也用mpage_readpages，那么这种情况很少发生。*/
125. goto confused;
127. }
131. //页没有buffers，映射它到硬盘　
133. BUG_ON(!PageUptodate(page));
135. 　　//计算文件中页序号对应的块序号
137. block_in_file = page->index << (PAGE_CACHE_SHIFT - blkbits);
139. last_block = (i_size - 1) >> blkbits;
141. map_bh.b_page = page;
143. for (page_block = 0; page_block < blocks_per_page; ) {
147. map_bh.b_state = 0;
149. if (get_block(inode, block_in_file, &map_bh, 1))
151. goto confused;
153. if (buffer_new(&map_bh))//如果buffer是新的
155. 　　　　　 //找到块号对应的buffer，清除脏标识并等待
157. unmap_underlying_metadata(map_bh.b_bdev,
159. map_bh.b_blocknr);
161. if (buffer_boundary(&map_bh)) {
163. boundary_block = map_bh.b_blocknr;
165. boundary_bdev = map_bh.b_bdev;
167. }
169. if (page_block) {
171. if (map_bh.b_blocknr != blocks[page_block-1] + 1)
173. goto confused;
175. }
177. blocks[page_block++] = map_bh.b_blocknr;
179. boundary = buffer_boundary(&map_bh);
181. bdev = map_bh.b_bdev;
183. if (block_in_file == last_block)
185. break;
187. block_in_file++;
189. }
191. BUG_ON(page_block == 0);
195. first_unmapped = page_block;
199. page_is_mapped:
201. end_index = i_size >> PAGE_CACHE_SHIFT;
203. if (page->index >= end_index) {
205. /*如果页跨过i_size，它在每writepage函数上一定会被赋0值，因为这页可能被映射。 一个文件映射多页，如果文件没有多页的大小，则当映射时剩下的空间是0，并且写这块区域时，它不能被写入到文件中去。*/
207. unsigned offset = i_size & (PAGE_CACHE_SIZE - 1);
209. char *kaddr;
213. if (page->index > end_index || !offset)
215. goto confused;
217. kaddr = kmap_atomic(page, KM_USER0);
219. memset(kaddr + offset, 0, PAGE_CACHE_SIZE - offset);//设置为0
221. flush_dcache_page(page);
223. kunmap_atomic(kaddr, KM_USER0);
225. }
229. //这页将去BIO，我们先送这页到BIO　
231. if (bio && *last_block_in_bio != blocks[0] - 1)
233. bio = mpage_bio_submit(WRITE, bio);//提交BIO
237. alloc_new:
239. if (bio == NULL) {//分配新的BIO
241. bio = mpage_alloc(bdev, blocks[0] << (blkbits - 9),
243. bio_get_nr_vecs(bdev), GFP_NOFS|__GFP_HIGH);
245. if (bio == NULL)
247. goto confused;
249. }
253. /*在标识buffer为clean之前必须尝试加页到bio，当混乱坏路径（OOM）发现所有的bh标识干净时（它将不写任何东西），它将非常混乱。*/
255. length = first_unmapped << blkbits;
257. if (bio_add_page(bio, page, length, 0) < length) {//加页到bio
259. bio = mpage_bio_submit(WRITE, bio);//提交bio
261. goto alloc_new;
263. }
267. //我们有自己的BIO，因此我们现在能标识buffer为干净的，
269. 　　//确信仅设置我们将写的buffer。
271. if (page_has_buffers(page)) {//页上有buffer
273. struct buffer_head *head = page_buffers(page);
275. struct buffer_head *bh = head;
277. unsigned buffer_counter = 0;
281. do {
283. if (buffer_counter++ == first_unmapped)
285. break;
287. clear_buffer_dirty(bh);//清除脏标识
289. bh = bh->b_this_page;
291. } while (bh != head);
295. //如果页不是更新的或同时发生的readpage不能与bh一起串行化，并且在我们达到platter之前它将读取硬盘时，我们不能删除bh
297. if (buffer_heads_over_limit && PageUptodate(page))
299. try_to_free_buffers(page);//释放buffer
301. }
305. BUG_ON(PageWriteback(page));
307. set_page_writeback(page);//设置页状态标识PG_writeback
309. unlock_page(page);
311. if (boundary || (first_unmapped != blocks_per_page)) {
313. bio = mpage_bio_submit(WRITE, bio);
315. if (boundary_block) {//边界块
317. 　　　　　　//调用ll_rw_block函数写块对应的buffer到设备
319. write_boundary_block(boundary_bdev,
321. boundary_block, 1 << blkbits);
323. }
325. } else {
327. *last_block_in_bio = blocks[blocks_per_page - 1];
329. }
331. goto out;
335. confused:
337. if (bio)
339. bio = mpage_bio_submit(WRITE, bio);
341. *ret = page->mapping->a_ops->writepage(page, wbc);
343. //调用者有一个节点上的引用，这样mapping是稳定的　
345. if (*ret) {
347. if (*ret == -ENOSPC)
349. set_bit(AS_ENOSPC, &mapping->flags);
351. else
353. set_bit(AS_EIO, &mapping->flags);
355. }
357. out:
359. return bio;
361. }

函数mpage_bio_submit赋上回调函数，提交读写操作，函数分析如下（在fs/mpage.c中）：

1. struct bio *mpage_bio_submit(int rw, struct bio *bio)
3. {
5. bio->bi_end_io = mpage_end_io_read;//赋上读完后函数，用来进行页标识处理
7. if (rw == WRITE)
9. bio->bi_end_io = mpage_end_io_write;//赋上写完后处理函数
11. submit_bio(rw, bio);//提交操作
13. return NULL;
19. }

函数submit_bio 提交块I/O读写操作，函数分析如下（在drives/block/ll_rw_block.c中）：

1. void submit_bio(int rw, struct bio *bio)
3. {
5. int count = bio_sectors(bio);
9. BIO_BUG_ON(!bio->bi_size);
11. BIO_BUG_ON(!bio->bi_io_vec);
13. bio->bi_rw = rw;
15. if (rw & WRITE)
17. mod_page_state(pgpgout, count);
19. else
21. mod_page_state(pgpgin, count);
25. …
27. 　　/*这个函数是文件系统与块设备驱动程序的接口，它向块设备驱动程序提交块I/O操作，从这里开始进行驱动层，在块设备驱动程序中分析这一函数。*/
29. generic_make_request(bio);
35. }

块设备节点映射的数据同步回写函数sync_blockdev

函数sync_blockdev的调用层次图

函数sync_blockdev通过块设备的设备节点的地址空间，回写并等待所有的与一个块设备相关的脏数据写回到设备上。函数sync_blockdev的调用层次图如上图。

函数sync_blockdev分析如下（在fs/buffer.c中）：

1. int sync_blockdev(struct block_device *bdev)
3. {
5. int ret = 0;
9. if (bdev) {
11. int err;
13. 　　　 //写回块设备节点映射的脏页数据
15. ret = filemap_fdatawrite(bdev->bd_inode->i_mapping);
17. err = filemap_fdatawait(bdev->bd_inode->i_mapping);
19. if (!ret)
21. ret = err;
23. }
25. return ret;
27. }

函数filemap_fdatawait遍历所给地址空间回写页的链表并等待在他们上面，其中参数mapping表示等待的地址空间结构。函数filemap_fdatawait分析如下（在/mm/filemap.c中）：

1. int filemap_fdatawait(struct address_space *mapping)
3. {
5. loff_t i_size = i_size_read(mapping->host);
9. if (i_size == 0)
11. return 0;
15. return wait_on_page_writeback_range(mapping, 0,
17. (i_size - 1) >> PAGE_CACHE_SHIFT);
23. }

　　函数wait_on_page_writeback_range等待对从start到end的页完成回写操作。函数分析如下（在/mm/filemap.c中）：

1. static int wait_on_page_writeback_range(struct address_space *mapping,
3. pgoff_t start, pgoff_t end)
5. {
7. struct pagevec pvec;
9. int nr_pages;
11. int ret = 0;
13. pgoff_t index;
17. if (end < start)
19. return 0;
23. pagevec_init(&pvec, 0);
25. index = start;
27. while ((index <= end) &&
29. 　　　　　　//查找有回写标识PAGECACHE_TAG_WRITEBACK的页数
31. (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
33. PAGECACHE_TAG_WRITEBACK,
35. min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1)) != 0) {
37. unsigned i;
41. for (i = 0; i < nr_pages; i++) {
43. struct page *page = pvec.pages[i];
47. /* until radix tree lookup accepts end_index */
49. if (page->index > end)
51. continue;
53. 　　　　　　//等待一页回写完成
55. wait_on_page_writeback(page);
57. if (PageError(page))
59. ret = -EIO;
61. }
63. pagevec_release(&pvec);
65. cond_resched();//调度
67. }
71. //检查明显的写错误
73. if (test_and_clear_bit(AS_ENOSPC, &mapping->flags))
75. ret = -ENOSPC;
77. if (test_and_clear_bit(AS_EIO, &mapping->flags))
79. ret = -EIO;
83. return ret;
89. }

函数wait_on_page_writeback等待一页完成回写动作，函数分析如下（在include/linux/pagemap.h中）：

1. static inline void wait_on_page_writeback(struct page *page)
3. {
5. if (PageWriteback(page))//页上有回写标识
7. wait_on_page_bit(page, PG_writeback);
9. }

函数wait_on_page_bit分析如下（在mm/filemap.c中）：

1. void fastcall wait_on_page_bit(struct page *page, int bit_nr)
3. {
5. 　　//得到在页上等待队列
7. wait_queue_head_t *waitqueue = page_waitqueue(page);
9. DEFINE_PAGE_WAIT(wait, page, bit_nr);//得到页等待队列结构wait
13. do {
19. //设置当前进程状态，将wait.wait加到页等待队列waitqueue中
23. prepare_to_wait(waitqueue, &wait.wait, TASK_UNINTERRUPTIBLE);
25. if (test_bit(bit_nr, &page->flags)) {//测试标识
27. sync_page(page);
29. io_schedule(); //在需要调度时调度
31. }
33. } while (test_bit(bit_nr, &page->flags));
35. finish_wait(waitqueue, &wait.wait);
37. }

1. static inline int sync_page(struct page *page)
3. {
5. struct address_space *mapping;
9. smp_mb();//
11. mapping = page_mapping(page);//得到页对应的地址空间
13. 　　//调用地址空间结构对应的页同步函数
15. if (mapping && mapping->a_ops && mapping->a_ops->sync_page)
17. return mapping->a_ops->sync_page(page);
19. return 0;
21. 
    
23. }
24. 
    

http://blog.chinaunix.net/uid-24237502-id-106067.html