linux脏页回写机制

发表于 | 更新于 | 分类于 | 热度：
本文字数： 2.4k | 阅读时长 ≈ 2 分钟

从Linux 2.6.32开始，Linux内核脏页回写通过bdi_writeback机制实现，bdi的全拼是backing device info（后端存储设备信息，如ssd、hdd）。用户态调用write系统调用写入数据后，文件系统只在页缓存中写入数据便返回了write系统调用，并没有分配实际的物理磁盘块，ext4称为延迟分配技术（delay allocation）。本文将介绍内核是在何时如何将写入的数据回写到磁盘。

核心数据结构初始化

回写机制借助了Linux中工作队列来完成，在内核启动的时候，系统会使用alloc_workqueue函数申请一个用于回写的工作队列。具体实现在函数default_bdi_init中。

1
2
3
4
5
6
7
8
9
10
11
// /mm/backing-dev.c
static int __init default_bdi_init(void)
{
	int err;
	bdi_wq = alloc_workqueue("writeback", WQ_MEM_RECLAIM | WQ_FREEZABLE |
					      WQ_UNBOUND | WQ_SYSFS, 0);
	if (!bdi_wq)
		return -ENOMEM;
	err = bdi_init(&noop_backing_dev_info);
	return err;
}

函数调用栈如下图。
在这里插入图片描述

bdi_init()函数初始化bdi (struct backing_dev_info)，该结构体包含了块设备信息，代表一个设备。

  • struct backing_dev_info：描述一个块设备。
  • struct bdi_writeback：管理一个块设备所有的回写任务。
  • struct wb_writeback_work ：描述需要回写的任务。

还有管理回写任务的结构体bdi_writeback，描述任务的结构体wb_writeback_work，其三者的关系如下图所示。

在这里插入图片描述

backing_dev_info中维护了wb_list链表，管理bdi_writeback，同时每个bdi_writeback中维护了dwork和work_list，前者代表处理任务的函数，后者则是任务列表。

在bdi_init中对bdi进行初始化后，会继续调用倒wb_init()，该函数对bdi中的wb（struct bdi_writeback）进行初始化。
在这里插入图片描述

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
// /fs/fs-writeback.c
struct bdi_writeback {
	struct backing_dev_info *bdi;	/* our parent bdi */

	unsigned long state;		/* Always use atomic bitops on this */
	unsigned long last_old_flush;	/* 上次刷写数据的时间，用于周期性回写数据 */

	struct list_head b_dirty;	/* 暂存dirty inode，mark_dirty_inode会加入到这个list */
	struct list_head b_io;		/* 用于暂存即将要被writeback处理的inode */
	struct list_head b_more_io;	/* parked for more writeback */
	struct list_head b_dirty_time;	/* 暂存在cache过期的inode */
	spinlock_t list_lock;		/* protects the b_* lists */

	struct percpu_counter stat[NR_WB_STAT_ITEMS];

	struct bdi_writeback_congested *congested;

	unsigned long bw_time_stamp;	/* last time write bw is updated */
	unsigned long dirtied_stamp;
	unsigned long written_stamp;	/* pages written at bw_time_stamp */
	unsigned long write_bandwidth;	/* 单次wb任务的带宽 */
	unsigned long avg_write_bandwidth; /* further smoothed write bw, > 0 */

	unsigned long dirty_ratelimit;
	unsigned long balanced_dirty_ratelimit;

	struct fprop_local_percpu completions;
	int dirty_exceeded;
	enum wb_reason start_all_reason; /* 回写任务的触发原因 ，常见的原因有周期回写、脏页超出阈值回写，和用户主动回写*/

	spinlock_t work_lock;		/* protects work_list & dwork scheduling */
	struct list_head work_list; /* 保存wb_writeback_work结构的list，用于处理这次回写任务下面所有的任务 */
	struct delayed_work dwork;	/* work item used for writeback */

	unsigned long dirty_sleep;	/* last wait */

	struct list_head bdi_node;	/* anchored at bdi->wb_list */
};
//描述一个回写任务
struct wb_writeback_work {
	long nr_pages;//待回写页面数量；
	struct super_block *sb;// writeback 任务所属的 super_block；
	enum writeback_sync_modes sync_mode;/*指定同步模式，WB_SYNC_ALL 表示当遇到锁住的 inode 时，它必须
 等待该 inode 解锁，而不能跳过。WB_SYNC_NONE 表示跳过被锁住的 inode；*/
	unsigned int tagged_writepages:1;
	unsigned int for_kupdate:1;//若值为 1，则表示回写原因是周期性的回写；否则值为 0；
	unsigned int range_cyclic:1;
	unsigned int for_background:1;//若值为 1，表示后台回写；否则值为 0；
	unsigned int for_sync:1;	/* sync(2) WB_SYNC_ALL writeback */
	unsigned int auto_free:1;	/* free on completion */
	enum wb_reason reason;		/* why was writeback initiated? */

	struct list_head list;		/* pending work list */
	struct wb_completion *done;	/* set if the caller waits */
};

wb_init在初始化过程中，给wb->dwork字段赋值了函数wb_workfn，后面触发回写任务时，就会通过该函数进行执行回写。

1
2
3
4
5
6
7
8
9
10
11
12
13
static int wb_init(struct bdi_writeback *wb, struct backing_dev_info *bdi,
		   int blkcg_id, gfp_t gfp)
{
	INIT_LIST_HEAD(&wb->b_dirty);
  ...
	wb->bw_time_stamp = jiffies;
  ...
	INIT_DELAYED_WORK(&wb->dwork, wb_workfn);
	wb->dirty_sleep = jiffies;
  ...
	return 0;

}

至此bdi_writeback机制初始化完成。

触发回写任务的时机

由于写入的数据都缓存在内存中，猜想当空闲内存紧张的时候，内核会执行回写任务。于是我们需要减少系统可用内存，使用如下命令在内存中创建文件系统然后往里面写入文件。

1
2
mkdir tmp
mount -t ramfs ramfs tmp/

使用 dd 命令在该目录下创建文件。我们创建了一个79M的文件。

1
dd if=/dev/zero of=tmp/file bs=1M count=79

完成上述操作以后系统还剩余2M内存，内核并没有立即触发回写，于是使用write系统调用继续向磁盘写入数据。

在这里插入图片描述

很快就触发了内核函数wakeup_flusher_threads（事先添加了断点），函数调用栈如下：

在这里插入图片描述

从内核函数调用栈来看是触发了kswapd内核线程的非活跃LRU链表回收。shrink_inactive_list函数扫描不活跃页面链表并且回收页面，调用了wakeup_flusher_threads函数进行回写操作。

在这里插入图片描述

函数代码如下，该函数遍历所有bdi设备下的writeback，并通过函数wb_start_writeback执行回写操作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/* fs/fs-writeback.c
 * Start writeback of `nr_pages' pages.  If `nr_pages' is zero, write back
 * the whole world.
 */
void wakeup_flusher_threads(long nr_pages, enum wb_reason reason)
{
	struct backing_dev_info *bdi;

	/*
	 * If we are expecting writeback progress we must submit plugged IO.
	 */
	if (blk_needs_flush_plug(current))
		blk_schedule_flush_plug(current);
	if (!nr_pages)
		nr_pages = get_nr_dirty_pages();
	rcu_read_lock();
  //遍历当前的bdi_list所有的bdi设备
	list_for_each_entry_rcu(bdi, &bdi_list, bdi_list) {
		struct bdi_writeback *wb;

		if (!bdi_has_dirty_io(bdi))
			continue;
      //遍历当前bdi设备中wb_list存储的所有wb
		list_for_each_entry_rcu(wb, &bdi->wb_list, bdi_node)
			wb_start_writeback(wb, wb_split_bdi_pages(wb, nr_pages),
					   false, reason);
	}
	rcu_read_unlock();
}

GDB查看传入wakeup_flusher_threads的参数值分别是nr_pages = 0和reason = WB_REASON_VMSCAN。

在这里插入图片描述

其中nr_pages等于0表示尽可能回写所有的脏页reason表示本次回写触发的原因。除了WB_REASON_VMSCAN，还定义了如下原因，如周期回写：WB_REASON_PERIODIC，后台回写：WB_REASON_BACKGROUND。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/*
 * why some writeback work was initiated
 */
enum wb_reason {
	WB_REASON_BACKGROUND,//脏页达到阈值，后台回写
	WB_REASON_VMSCAN,//内存压力
	WB_REASON_SYNC,//sync系统调用回写
	WB_REASON_PERIODIC,//周期回写
	WB_REASON_LAPTOP_TIMER,//Laptop模式回写
	WB_REASON_FREE_MORE_MEM,
	WB_REASON_FS_FREE_SPACE,
	/*
	 * There is no bdi forker thread any more and works are done
	 * by emergency worker, however, this is TPs userland visible
	 * and we'll be exposing exactly the same information,
	 * so it has a mismatch name.
	 */
	WB_REASON_FORKER_THREAD,

	WB_REASON_MAX,
};

我们继续分析wb_start_writeback回写函数。该函数创建并初始化了一个wb_writeback_work来描述本次回写任务，最后调用wb_queue_work。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void wb_start_writeback(struct bdi_writeback *wb, long nr_pages,
			bool range_cyclic, enum wb_reason reason)
{
	struct wb_writeback_work *work;
	if (!wb_has_dirty_io(wb))
		return;
	work = kzalloc(sizeof(*work),
	work->sync_mode	= WB_SYNC_NONE;
	work->nr_pages	= nr_pages;
	work->range_cyclic = range_cyclic;
	work->reason	= reason;
	work->auto_free	= 1;
	wb_queue_work(wb, work);
}

wb_queue_work调用mod_delayed_work将该任务挂入工作队列（workqueue），在等待delay时间后由工作队列的工作线程（worker）执行初始化时注册的任务管理函数wb->dwork。Linux workqueue如何处理work的过程可以参考文章，本文跳过该过程，直接到回写任务的处理函数wb_workfn继续分析：
http://www.wowotech.net/irq_subsystem/queue_and_handle_work.html

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
static void wb_queue_work(struct bdi_writeback *wb,
			  struct wb_writeback_work *work)
{
	trace_writeback_queue(wb, work);

	if (work->done)
		atomic_inc(&work->done->cnt);

	spin_lock_bh(&wb->work_lock);

	if (test_bit(WB_registered, &wb->state)) {
		list_add_tail(&work->list, &wb->work_list);
		mod_delayed_work(bdi_wq, &wb->dwork, 0);
	} else
		finish_writeback_work(wb, work);

	spin_unlock_bh(&wb->work_lock);
}
bool mod_delayed_work_on(int cpu, struct workqueue_struct *wq,
			 struct delayed_work *dwork, unsigned long delay)
{
	unsigned long flags;
	int ret;

	do {//判断当前work的状态,找到一个pending的work
		ret = try_to_grab_pending(&dwork->work, true, &flags);
	} while (unlikely(ret == -EAGAIN));

	if (likely(ret >= 0)) {
		//将work加入到工作队列中，在delay时间周期后去执行
		__queue_delayed_work(cpu, wq, dwork, delay);
		local_irq_restore(flags);
	}

	/* -ENOENT from try_to_grab_pending() becomes %true */
	return ret;
}

关于触发内核回写的函数调用总结如下图：
在这里插入图片描述

回写任务的执行

回写的执行在文件系统层的函数调用如下所示。
在这里插入图片描述

函数wb_workfn正常路径为遍历work_list，执行wb_do_writeback函数。如果没有足够的worker则执行writeback_inodes_wb函数回写1024个脏页。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
void wb_workfn(struct work_struct *work)
{
	struct bdi_writeback *wb = container_of(to_delayed_work(work),
						struct bdi_writeback, dwork);
	long pages_written;

	set_worker_desc("flush-%s", dev_name(wb->bdi->dev));
	current->flags |= PF_SWAPWRITE;

	if (likely(!current_is_workqueue_rescuer() ||
		   !test_bit(WB_registered, &wb->state))) {
		do {
			pages_written = wb_do_writeback(wb);
			trace_writeback_pages_written(pages_written);
		} while (!list_empty(&wb->work_list)); // 正常情况下遍历work_list，执行wb_do_writeback
	} else {
		pages_written = writeback_inodes_wb(wb, 1024,
						    WB_REASON_FORKER_THREAD); // 没有足够的worker去处理writeback，紧急情况下回写。
		trace_writeback_pages_written(pages_written);
	}

	if (!list_empty(&wb->work_list))
		wb_wakeup(wb); // 如果没有处理完，再唤醒处理一次
	else if (wb_has_dirty_io(wb) && dirty_writeback_interval)
		wb_wakeup_delayed(wb); // 如果还有dirty inode在其他list，延迟500再执行一次

	current->flags &= ~PF_SWAPWRITE;
}

wb_do_writeback函数在遍历wb并调用wb_writeback回写结束后会进行定时回写和脏页是否超过阈值的回写检查。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/*
 * Retrieve work items and do the writeback they describe
 */
static long wb_do_writeback(struct bdi_writeback *wb)
{
	struct wb_writeback_work *work;
	long wrote = 0;
	//检查running标识，可以直接执行
	set_bit(WB_writeback_running, &wb->state);
	while ((work = get_next_work_item(wb)) != NULL) {
		trace_writeback_exec(wb, work);
		wrote += wb_writeback(wb, work);
		finish_writeback_work(wb, work);
	}

	/*
	 * Check for periodic writeback, kupdated() style
	 */
	//定期回写检查
	wrote += wb_check_old_data_flush(wb);
	wrote += wb_check_background_flush(wb);//脏页超过阈值回写检查
	clear_bit(WB_writeback_running, &wb->state);

	return wrote;
}

wb_writeback根据是否包含superblock，分别调用writeback_sb_inodes和__writeback_inodes_wb。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
static long wb_writeback(struct bdi_writeback *wb,
			 struct wb_writeback_work *work)
{
  ...
	blk_start_plug(&plug);
	for (;;) {
    ...
		if (work->sb)
			progress = writeback_sb_inodes(work->sb, wb, work);
		else
			progress = __writeback_inodes_wb(wb, work);
    ...
	}
	spin_unlock(&wb->list_lock);
	blk_finish_plug(&plug);
	return nr_pages - work->nr_pages;
}

writeback_sb_inodes调用__writeback_single_inode。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
static long writeback_sb_inodes(struct super_block *sb,
				struct bdi_writeback *wb,
				struct wb_writeback_work *work)
{
	...

	while (!list_empty(&wb->b_io)) { // 遍历wb->b_io里面的所有inode
		struct inode *inode = wb_inode(wb->b_io.prev); // 从list中取出一个inode
		...
    if ((inode->i_state & I_SYNC) && wbc.sync_mode != WB_SYNC_ALL) { 
			spin_unlock(&inode->i_lock);
			requeue_io(inode, wb); // 将这个inode迁移到wb->b_more_io
			trace_writeback_sb_inodes_requeue(inode);
			continue;
		}
		spin_unlock(&wb->list_lock);

		if (inode->i_state & I_SYNC) { /* 对于SYNC模式的inode和SYNC的wb类型 */
			/* Wait for I_SYNC. This function drops i_lock... */
			inode_sleep_on_writeback(inode);
			/* Inode may be gone, start again */
			spin_lock(&wb->list_lock);
			continue;
		}
		inode->i_state |= I_SYNC;
		wbc_attach_and_unlock_inode(&wbc, inode); // 对于inode进行解锁

		write_chunk = writeback_chunk_size(wb, work); // 计算需要写多少数据
		wbc.nr_to_write = write_chunk; // 一般是4096
		wbc.pages_skipped = 0;

		__writeback_single_inode(inode, &wbc); // 将inode的数据写入磁盘

		wbc_detach_inode(&wbc);
		work->nr_pages -= write_chunk - wbc.nr_to_write; // 记录写了多少页
		wrote += write_chunk - wbc.nr_to_write;

		if (need_resched()) {
			blk_flush_plug(current);
			cond_resched();
		}

		tmp_wb = inode_to_wb_and_lock_list(inode); // 给wb加锁
    ...
	return wrote;
}

__writeback_single_inode调用do_writepages。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
static int
__writeback_single_inode(struct inode *inode, struct writeback_control *wbc)
{
	struct address_space *mapping = inode->i_mapping;
	long nr_to_write = wbc->nr_to_write;
	unsigned dirty;
	int ret;

	WARN_ON(!(inode->i_state & I_SYNC));

	trace_writeback_single_inode_start(inode, wbc, nr_to_write);

	ret = do_writepages(mapping, wbc);
}

do_writepages就出现了我们熟悉的页缓存函数操作集struct address_space_operations *a_ops。其中writepages函数在ext4中的实现为ext4_writepages。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
int do_writepages(struct address_space *mapping, struct writeback_control *wbc)
{
	int ret;

	if (wbc->nr_to_write <= 0)
		return 0;
	while (1) {
		if (mapping->a_ops->writepages)
			ret = mapping->a_ops->writepages(mapping, wbc);
		else
			ret = generic_writepages(mapping, wbc);
		if ((ret != -ENOMEM) || (wbc->sync_mode != WB_SYNC_ALL))
			break;
		cond_resched();
		congestion_wait(BLK_RW_ASYNC, HZ/50);
	}
	return ret;
}
//ext4延时分配
static const struct address_space_operations ext4_da_aops = {
	.readpage		= ext4_readpage,
	.readahead		= ext4_readahead,
	.writepage		= ext4_writepage,
	.writepages		= ext4_writepages,
	.write_begin		= ext4_da_write_begin,
	.write_end		= ext4_da_write_end,
  ...
};

接下来会在ext4_writepages中打包bio结构体，发送到通用块层，继续更底层的IO操作。

最后，bdi_writeback机制整体流程如下。

在这里插入图片描述

PS：前往公众号“Linux工坊”，可以查看最新内容！关注即可免费领取面试&Linux技术书籍！

------ 本文结束------
  • 文章标题： linux脏页回写机制
  • 本文作者： 你是我的阳光
  • 发布时间： 2022年03月25日 - 21:01:42
    • 最后更新： 2022年11月09日 - 16:13:06
  • 本文链接： https://szp2016.github.io/Linux/linux脏页回写机制/
  • 版权声明： 本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
0%