【转】Linux Writeback机制分析

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