【转】Linux Writeback机制分析

时间：2023-12-16 11:44:14

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这样的关键代码。

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

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

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

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数据结构具体定义如下：

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

writeback work

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

Writeback_work的数据结构定义如下：

  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. struct list_head list; /* pending work list，链入bdi-> work_list队列 */
  12. struct completion *done; /* set if the caller waits，work完成时通知调用者 */
  13. };

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

相关文章