Chinaunix首页 | 论坛 | 博客

FenG71

首页　| 　博文目录　| 　关于我

FenG71

  • 博客访问： 294180
  • 博文数量： 60
  • 博客积分： 2697
  • 博客等级： 少校
  • 技术积分： 653
  • 用 户 组： 普通用户
  • 注册时间： 2010-07-13 15:52
文章分类

全部博文（60）

文章存档

2012年（6）

2011年（31）

2010年（23）

我的朋友
最近访客
推荐博文
相关博文
缓存同步操作--sys_sync系统调用

分类： LINUX

2011-01-26 18:35:50

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
Linux kernel virtual filesystem 09.gif
函数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
Linux kernel virtual filesystem 03.gif
函数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
Linux kernel virtual filesystem 04.gif
函数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;
  25. }
阅读(5722) | 评论(0) | 转发(2) |
0

上一篇：block_prepare_write解析

下一篇：一致性hash算法 - consistent hashing

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6