码迷，mamicode.com
首页 > 系统相关 > 详细

【转】Linux Writeback机制分析

时间：2014-10-30 11:33:10      阅读：433      评论：0      收藏：0      [点我收藏+]

标签：des   blog   http   io   os   ar   for   sp   strong   

1. bdi是什么?

    bdi，即是backing device info的缩写，顾名思义它描述备用存储设备相关描述信息，这在内核代码里用一个结构体backing_dev_info来表示。

    bdi，备用存储设备，简单点说就是能够用来存储数据的设备，而这些设备存储的数据能够保证在计算机电源关闭时也不丢失。这样说来，软盘存储设备、光驱存储设备、USB存储设备、硬盘存储设备都是所谓的备用存储设备（后面都用bdi来指示），而内存显然不是

2. bdi工作模型  

 相对于内存来说，bdi设备（比如最常见的硬盘存储设备）的读写速度是非常慢的，因此为了提高系统整体性能，Linux系统对bdi设备的读写内容进行了缓冲，那些读写的数据会临时保存在内存里，以避免每次都直接操作bdi设备，但这就需要在一定的时机（比如每隔5秒、脏数据达到的一定的比率等）把它们同步到bdi设备，否则长久的呆在内存里容易丢失（比如机器突然宕机、重启），而进行间隔性同步工作的进程之前名叫pdflush，但后来在Kernel 2.6.2x/3x对此进行了优化改进，产生有多个内核进程，bdi-default、flush-x:y等。

   关于以前的pdflush不再多说，我们这里只讨论bdi-default和flush-x:y，这两个进程（事实上，flush-x:y为多个）的关系为父与子的关系，即bdi-default根据当前的状态Create或Destroy flush-x:y，x为块设备类型，y为此类设备的序号。如有两个TF卡，则分别为：flush-179:0、flush-179:1。

    一般而言，一个Linux系统会挂载很多bdi设备，在bdi设备注册（函数：bdi_register(…)）时，这些bdi设备会以链表的形式组织在全局变量bdi_list下，除了一个比较特别的bdi设备以外，它就是default bdi设备（default_backing_dev_info），它除了被加进到bdi_list，还会新建一个bdi-default内核进程，即本文的主角。具体代码如下，我相信你一眼就能注意到kthread_run和list_add_tail_rcu这样的关键代码。

[cpp] view plaincopy
 
  1. struct backing_dev_info default_backing_dev_info = {  
  2.     .name       = "default",  
  3.     .ra_pages   = VM_MAX_READAHEAD * 1024 / PAGE_CACHE_SIZE,  
  4.     .state      = 0,  
  5.     .capabilities   = BDI_CAP_MAP_COPY,  
  6. };  
  7. EXPORT_SYMBOL_GPL(default_backing_dev_info);  
[cpp] view plaincopy
 
  1. static inline bool bdi_cap_flush_forker(struct backing_dev_info *bdi)  
  2. {  
  3.     return bdi == &default_backing_dev_info;  
  4. }  
  5.   
  6. int bdi_register(struct backing_dev_info *bdi, struct device *parent,  
  7.         const char *fmt, ...)  
  8. {  
  9.     va_list args;  
  10.     struct device *dev;  
  11.   
  12.     if (bdi->dev)    /* The driver needs to use separate queues per device */  
  13.         return 0;  
  14.   
  15.     va_start(args, fmt);  
  16.     dev = device_create_vargs(bdi_class, parent, MKDEV(0, 0), bdi, fmt, args);  
  17.     va_end(args);  
  18.     if (IS_ERR(dev))  
  19.         return PTR_ERR(dev);  
  20.   
  21.     bdi->dev = dev;  
  22.   
  23.     /* 
  24.      * Just start the forker thread for our default backing_dev_info, 
  25.      * and add other bdi‘s to the list. They will get a thread created 
  26.      * on-demand when they need it. 
  27.      */  
  28.     if (bdi_cap_flush_forker(bdi)) {  
  29.         struct bdi_writeback *wb = &bdi->wb;  
  30.   
  31.         wb->task = kthread_run(bdi_forker_thread, wb, "bdi-%s",  
  32.                         dev_name(dev));  
  33.         if (IS_ERR(wb->task))  
  34.             return PTR_ERR(wb->task);  
  35.     }  
  36.   
  37.     bdi_debug_register(bdi, dev_name(dev));  
  38.     set_bit(BDI_registered, &bdi->state);  
  39.   
  40.     spin_lock_bh(&bdi_lock);  
  41.     list_add_tail_rcu(&bdi->bdi_list, &bdi_list);  
  42.     spin_unlock_bh(&bdi_lock);  
  43.   
  44.     trace_writeback_bdi_register(bdi);  
  45.     return 0;  
  46. }  
  47. EXPORT_SYMBOL(bdi_register);  


接着跟进函数bdi_forker_thread，它是bdi-default内核进程的主体：

[cpp] view plaincopy
 
  1. static int bdi_forker_thread(void *ptr)   
  2. {   
  3. struct bdi_writeback *me = ptr;  
  4.   
  5. current->flags |= PF_SWAPWRITE;   
  6. set_freezable();  
  7.   
  8. /*  
  9. * Our parent may run at a different priority, just set us to normal  
  10. */   
  11. set_user_nice(current, 0);  
  12.   
  13. for (;;) {   
  14. struct task_struct *task = NULL;   
  15. struct backing_dev_info *bdi;   
  16. enum {   
  17. NO_ACTION, /* Nothing to do */   
  18. FORK_THREAD, /* Fork bdi thread */   
  19. KILL_THREAD, /* Kill inactive bdi thread */   
  20. } action = NO_ACTION;  
  21.   
  22. /*  
  23. * Temporary measure, we want to make sure we don‘t see  
  24. * dirty data on the default backing_dev_info  
  25. */   
  26. if (wb_has_dirty_io(me) || !list_empty(&me->bdi->work_list)) {   
  27. del_timer(&me->wakeup_timer);   
  28. wb_do_writeback(me, 0);   
  29. }  
  30.   
  31. spin_lock_bh(&bdi_lock);   
  32. /*  
  33. * In the following loop we are going to check whether we have  
  34. * some work to do without any synchronization with tasks  
  35. * waking us up to do work for them. Set the task state here  
  36. * so that we don‘t miss wakeups after verifying conditions.  
  37. */   
  38. set_current_state(TASK_INTERRUPTIBLE);   
  39. /* 遍历所有的bdi对象，检查这些bdi是否存在脏数据，如果有脏数据，那么需要为其fork线程，然后做writeback操作 */   
  40. list_for_each_entry(bdi, &bdi_list, bdi_list) {   
  41. bool have_dirty_io;  
  42.   
  43. if (!bdi_cap_writeback_dirty(bdi) ||   
  44. bdi_cap_flush_forker(bdi))   
  45. continue;  
  46.   
  47. WARN(!test_bit(BDI_registered, &bdi->state),   
  48. "bdi %p/%s is not registered!\n", bdi, bdi->name);   
  49. /* 检查是否存在脏数据 */   
  50. have_dirty_io = !list_empty(&bdi->work_list) ||   
  51. wb_has_dirty_io(&bdi->wb);  
  52.   
  53. /*  
  54. * If the bdi has work to do, but the thread does not  
  55. * exist - create it.  
  56. */   
  57. if (!bdi->wb.task && have_dirty_io) {   
  58. /*  
  59. * Set the pending bit - if someone will try to  
  60. * unregister this bdi - it‘ll wait on this bit.  
  61. */   
  62. /* 如果有脏数据，并且不存在线程，那么接下来做线程的FORK操作 */   
  63. set_bit(BDI_pending, &bdi->state);   
  64. action = FORK_THREAD;   
  65. break;   
  66. }  
  67.   
  68. spin_lock(&bdi->wb_lock);  
  69.   
  70. /*  
  71. * If there is no work to do and the bdi thread was  
  72. * inactive long enough - kill it. The wb_lock is taken  
  73. * to make sure no-one adds more work to this bdi and  
  74. * wakes the bdi thread up.  
  75. */   
  76. /* 如果一个bdi长时间没有脏数据，那么执行线程的KILL操作，结束掉该bdi对应的writeback线程 */   
  77. if (bdi->wb.task && !have_dirty_io &&   
  78. time_after(jiffies, bdi->wb.last_active +   
  79. bdi_longest_inactive())) {   
  80. task = bdi->wb.task;   
  81. bdi->wb.task = NULL;   
  82. spin_unlock(&bdi->wb_lock);   
  83. set_bit(BDI_pending, &bdi->state);   
  84. action = KILL_THREAD;   
  85. break;   
  86. }   
  87. spin_unlock(&bdi->wb_lock);   
  88. }   
  89. spin_unlock_bh(&bdi_lock);  
  90.   
  91. /* Keep working if default bdi still has things to do */   
  92. if (!list_empty(&me->bdi->work_list))   
  93. __set_current_state(TASK_RUNNING);   
  94. /* 执行线程的FORK和KILL操作 */   
  95. switch (action) {   
  96. case FORK_THREAD:   
  97. /* FORK一个bdi_writeback_thread线程，该线程的名字为flush-major:minor */   
  98. __set_current_state(TASK_RUNNING);   
  99. task = kthread_create(bdi_writeback_thread, &bdi->wb,   
  100. "flush-%s", dev_name(bdi->dev));   
  101. if (IS_ERR(task)) {   
  102. /*  
  103. * If thread creation fails, force writeout of  
  104. * the bdi from the thread. Hopefully 1024 is  
  105. * large enough for efficient IO.  
  106. */   
  107. writeback_inodes_wb(&bdi->wb, 1024,   
  108. WB_REASON_FORKER_THREAD);   
  109. } else {   
  110. /*  
  111. * The spinlock makes sure we do not lose  
  112. * wake-ups when racing with ‘bdi_queue_work()‘.  
  113. * And as soon as the bdi thread is visible, we  
  114. * can start it.  
  115. */   
  116. spin_lock_bh(&bdi->wb_lock);   
  117. bdi->wb.task = task;   
  118. spin_unlock_bh(&bdi->wb_lock);   
  119. wake_up_process(task);   
  120. }   
  121. bdi_clear_pending(bdi);   
  122. break;  
  123.   
  124. case KILL_THREAD:   
  125. /* KILL一个线程 */   
  126. __set_current_state(TASK_RUNNING);   
  127. kthread_stop(task);   
  128. bdi_clear_pending(bdi);   
  129. break;  
  130.   
  131. case NO_ACTION:   
  132. /* 如果没有可执行的动作，那么调度本线程睡眠一段时间 */   
  133. if (!wb_has_dirty_io(me) || !dirty_writeback_interval)   
  134. /*  
  135. * There are no dirty data. The only thing we  
  136. * should now care about is checking for  
  137. * inactive bdi threads and killing them. Thus,  
  138. * let‘s sleep for longer time, save energy and  
  139. * be friendly for battery-driven devices.  
  140. */   
  141. schedule_timeout(bdi_longest_inactive());   
  142. else   
  143. schedule_timeout(msecs_to_jiffies(dirty_writeback_interval * 10));   
  144. try_to_freeze();   
  145. break;   
  146. }   
  147. }  
  148.   
  149. return 0;   
  150. }  

 

3. bdi相关数据结构

    在bdi数据结构中定义了一个writeback对象，该对象是对writeback内核线程的描述，并且封装了需要处理的inode队列。在bdi数据结构中有一条work_list，该work队列维护了writeback内核线程需要处理的任务。如果该队列上没有work可以处理，那么writeback内核线程将会睡眠等待。

    writeback

    writeback对象封装了内核线程task以及需要处理的inode队列。当page cache/buffer cache需要刷新radix tree上的inode时，可以将该inode挂载到writeback对象的b_dirty队列上，然后唤醒writeback线程。在处理过程中，inode会被移到b_io队列上进行处理。多条链表的方式可以降低多线程之间的资源共享。writeback数据结构具体定义如下：

[cpp] view plaincopy
 
  1. struct bdi_writeback {   
  2. struct backing_dev_info *bdi; /* our parent bdi */   
  3. unsigned int nr;  
  4.   
  5. unsigned long last_old_flush; /* last old data flush */   
  6. unsigned long last_active; /* last time bdi thread was active */  
  7.   
  8. struct task_struct *task; /* writeback thread */   
  9. struct timer_list wakeup_timer; /* used for delayed bdi thread wakeup */   
  10. struct list_head b_dirty; /* dirty inodes */   
  11. struct list_head b_io; /* parked for writeback */   
  12. struct list_head b_more_io; /* parked for more writeback */   
  13. spinlock_t list_lock; /* protects the b_* lists */   
  14. };  


 

    writeback work

    wb_writeback_work数据结构是对writeback任务的封装，不同的任务可以采用不同的刷新策略。writeback线程的处理对象就是writeback_work。如果writeback_work队列为空，那么内核线程就可以睡眠了。

Writeback_work的数据结构定义如下：


 

[cpp] view plaincopy
 
  1. struct wb_writeback_work {   
  2.  long nr_pages;   
  3.  struct super_block *sb; /* superblock对象 */   
  4. unsigned long *older_than_this;   
  5.  enum writeback_sync_modes sync_mode;   
  6.  unsigned int tagged_writepages:1;   
  7.  unsigned int for_kupdate:1;   
  8.  unsigned int range_cyclic:1;   
  9.  unsigned int for_background:1;   
  10.  enum wb_reason reason; /* why was writeback initiated? */  
  11.   
  12.  struct list_head list; /* pending work list，链入bdi-> work_list队列 */   
  13. struct completion *done; /* set if the caller waits，work完成时通知调用者 */   
  14. };  

 

4. writeback主要函数分析

   writeback机制的主要函数包括如下两个方面：

   1. 管理bdi对象并且fork相应的writeback内核线程处理cache数据的刷新工作。

   2. writeback内核线程处理函数，实现dirty page的刷新操作

writeback线程管理

    Linux中有一个内核守护线程，该线程用来管理系统bdi队列，并且负责为block device创建writeback thread。当bdi中有dirty page并且还没有为bdi分配内核线程的时候，bdi_forker_thread程序会为其分配线程资源；当一个writeback线程长时间处于空闲状态时，bdi_forker_thread程序会释放该线程资源。

 

转自：http://blog.csdn.net/myarrow/article/details/8918944

【转】Linux Writeback机制分析

标签：des   blog   http   io   os   ar   for   sp   strong   

原文地址：http://www.cnblogs.com/MerlinJ/p/4058694.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！