xref: /openbmc/linux/fs/fs-writeback.c (revision 0eeb28d7)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * fs/fs-writeback.c
4  *
5  * Copyright (C) 2002, Linus Torvalds.
6  *
7  * Contains all the functions related to writing back and waiting
8  * upon dirty inodes against superblocks, and writing back dirty
9  * pages against inodes.  ie: data writeback.  Writeout of the
10  * inode itself is not handled here.
11  *
12  * 10Apr2002	Andrew Morton
13  *		Split out of fs/inode.c
14  *		Additions for address_space-based writeback
15  */
16 
17 #include <linux/kernel.h>
18 #include <linux/export.h>
19 #include <linux/spinlock.h>
20 #include <linux/slab.h>
21 #include <linux/sched.h>
22 #include <linux/fs.h>
23 #include <linux/mm.h>
24 #include <linux/pagemap.h>
25 #include <linux/kthread.h>
26 #include <linux/writeback.h>
27 #include <linux/blkdev.h>
28 #include <linux/backing-dev.h>
29 #include <linux/tracepoint.h>
30 #include <linux/device.h>
31 #include <linux/memcontrol.h>
32 #include "internal.h"
33 
34 /*
35  * 4MB minimal write chunk size
36  */
37 #define MIN_WRITEBACK_PAGES	(4096UL >> (PAGE_SHIFT - 10))
38 
39 /*
40  * Passed into wb_writeback(), essentially a subset of writeback_control
41  */
42 struct wb_writeback_work {
43 	long nr_pages;
44 	struct super_block *sb;
45 	enum writeback_sync_modes sync_mode;
46 	unsigned int tagged_writepages:1;
47 	unsigned int for_kupdate:1;
48 	unsigned int range_cyclic:1;
49 	unsigned int for_background:1;
50 	unsigned int for_sync:1;	/* sync(2) WB_SYNC_ALL writeback */
51 	unsigned int auto_free:1;	/* free on completion */
52 	enum wb_reason reason;		/* why was writeback initiated? */
53 
54 	struct list_head list;		/* pending work list */
55 	struct wb_completion *done;	/* set if the caller waits */
56 };
57 
58 /*
59  * If an inode is constantly having its pages dirtied, but then the
60  * updates stop dirtytime_expire_interval seconds in the past, it's
61  * possible for the worst case time between when an inode has its
62  * timestamps updated and when they finally get written out to be two
63  * dirtytime_expire_intervals.  We set the default to 12 hours (in
64  * seconds), which means most of the time inodes will have their
65  * timestamps written to disk after 12 hours, but in the worst case a
66  * few inodes might not their timestamps updated for 24 hours.
67  */
68 unsigned int dirtytime_expire_interval = 12 * 60 * 60;
69 
wb_inode(struct list_head * head)70 static inline struct inode *wb_inode(struct list_head *head)
71 {
72 	return list_entry(head, struct inode, i_io_list);
73 }
74 
75 /*
76  * Include the creation of the trace points after defining the
77  * wb_writeback_work structure and inline functions so that the definition
78  * remains local to this file.
79  */
80 #define CREATE_TRACE_POINTS
81 #include <trace/events/writeback.h>
82 
83 EXPORT_TRACEPOINT_SYMBOL_GPL(wbc_writepage);
84 
wb_io_lists_populated(struct bdi_writeback * wb)85 static bool wb_io_lists_populated(struct bdi_writeback *wb)
86 {
87 	if (wb_has_dirty_io(wb)) {
88 		return false;
89 	} else {
90 		set_bit(WB_has_dirty_io, &wb->state);
91 		WARN_ON_ONCE(!wb->avg_write_bandwidth);
92 		atomic_long_add(wb->avg_write_bandwidth,
93 				&wb->bdi->tot_write_bandwidth);
94 		return true;
95 	}
96 }
97 
wb_io_lists_depopulated(struct bdi_writeback * wb)98 static void wb_io_lists_depopulated(struct bdi_writeback *wb)
99 {
100 	if (wb_has_dirty_io(wb) && list_empty(&wb->b_dirty) &&
101 	    list_empty(&wb->b_io) && list_empty(&wb->b_more_io)) {
102 		clear_bit(WB_has_dirty_io, &wb->state);
103 		WARN_ON_ONCE(atomic_long_sub_return(wb->avg_write_bandwidth,
104 					&wb->bdi->tot_write_bandwidth) < 0);
105 	}
106 }
107 
108 /**
109  * inode_io_list_move_locked - move an inode onto a bdi_writeback IO list
110  * @inode: inode to be moved
111  * @wb: target bdi_writeback
112  * @head: one of @wb->b_{dirty|io|more_io|dirty_time}
113  *
114  * Move @inode->i_io_list to @list of @wb and set %WB_has_dirty_io.
115  * Returns %true if @inode is the first occupant of the !dirty_time IO
116  * lists; otherwise, %false.
117  */
inode_io_list_move_locked(struct inode * inode,struct bdi_writeback * wb,struct list_head * head)118 static bool inode_io_list_move_locked(struct inode *inode,
119 				      struct bdi_writeback *wb,
120 				      struct list_head *head)
121 {
122 	assert_spin_locked(&wb->list_lock);
123 	assert_spin_locked(&inode->i_lock);
124 	WARN_ON_ONCE(inode->i_state & I_FREEING);
125 
126 	list_move(&inode->i_io_list, head);
127 
128 	/* dirty_time doesn't count as dirty_io until expiration */
129 	if (head != &wb->b_dirty_time)
130 		return wb_io_lists_populated(wb);
131 
132 	wb_io_lists_depopulated(wb);
133 	return false;
134 }
135 
wb_wakeup(struct bdi_writeback * wb)136 static void wb_wakeup(struct bdi_writeback *wb)
137 {
138 	spin_lock_irq(&wb->work_lock);
139 	if (test_bit(WB_registered, &wb->state))
140 		mod_delayed_work(bdi_wq, &wb->dwork, 0);
141 	spin_unlock_irq(&wb->work_lock);
142 }
143 
finish_writeback_work(struct bdi_writeback * wb,struct wb_writeback_work * work)144 static void finish_writeback_work(struct bdi_writeback *wb,
145 				  struct wb_writeback_work *work)
146 {
147 	struct wb_completion *done = work->done;
148 
149 	if (work->auto_free)
150 		kfree(work);
151 	if (done) {
152 		wait_queue_head_t *waitq = done->waitq;
153 
154 		/* @done can't be accessed after the following dec */
155 		if (atomic_dec_and_test(&done->cnt))
156 			wake_up_all(waitq);
157 	}
158 }
159 
wb_queue_work(struct bdi_writeback * wb,struct wb_writeback_work * work)160 static void wb_queue_work(struct bdi_writeback *wb,
161 			  struct wb_writeback_work *work)
162 {
163 	trace_writeback_queue(wb, work);
164 
165 	if (work->done)
166 		atomic_inc(&work->done->cnt);
167 
168 	spin_lock_irq(&wb->work_lock);
169 
170 	if (test_bit(WB_registered, &wb->state)) {
171 		list_add_tail(&work->list, &wb->work_list);
172 		mod_delayed_work(bdi_wq, &wb->dwork, 0);
173 	} else
174 		finish_writeback_work(wb, work);
175 
176 	spin_unlock_irq(&wb->work_lock);
177 }
178 
179 /**
180  * wb_wait_for_completion - wait for completion of bdi_writeback_works
181  * @done: target wb_completion
182  *
183  * Wait for one or more work items issued to @bdi with their ->done field
184  * set to @done, which should have been initialized with
185  * DEFINE_WB_COMPLETION().  This function returns after all such work items
186  * are completed.  Work items which are waited upon aren't freed
187  * automatically on completion.
188  */
wb_wait_for_completion(struct wb_completion * done)189 void wb_wait_for_completion(struct wb_completion *done)
190 {
191 	atomic_dec(&done->cnt);		/* put down the initial count */
192 	wait_event(*done->waitq, !atomic_read(&done->cnt));
193 }
194 
195 #ifdef CONFIG_CGROUP_WRITEBACK
196 
197 /*
198  * Parameters for foreign inode detection, see wbc_detach_inode() to see
199  * how they're used.
200  *
201  * These paramters are inherently heuristical as the detection target
202  * itself is fuzzy.  All we want to do is detaching an inode from the
203  * current owner if it's being written to by some other cgroups too much.
204  *
205  * The current cgroup writeback is built on the assumption that multiple
206  * cgroups writing to the same inode concurrently is very rare and a mode
207  * of operation which isn't well supported.  As such, the goal is not
208  * taking too long when a different cgroup takes over an inode while
209  * avoiding too aggressive flip-flops from occasional foreign writes.
210  *
211  * We record, very roughly, 2s worth of IO time history and if more than
212  * half of that is foreign, trigger the switch.  The recording is quantized
213  * to 16 slots.  To avoid tiny writes from swinging the decision too much,
214  * writes smaller than 1/8 of avg size are ignored.
215  */
216 #define WB_FRN_TIME_SHIFT	13	/* 1s = 2^13, upto 8 secs w/ 16bit */
217 #define WB_FRN_TIME_AVG_SHIFT	3	/* avg = avg * 7/8 + new * 1/8 */
218 #define WB_FRN_TIME_CUT_DIV	8	/* ignore rounds < avg / 8 */
219 #define WB_FRN_TIME_PERIOD	(2 * (1 << WB_FRN_TIME_SHIFT))	/* 2s */
220 
221 #define WB_FRN_HIST_SLOTS	16	/* inode->i_wb_frn_history is 16bit */
222 #define WB_FRN_HIST_UNIT	(WB_FRN_TIME_PERIOD / WB_FRN_HIST_SLOTS)
223 					/* each slot's duration is 2s / 16 */
224 #define WB_FRN_HIST_THR_SLOTS	(WB_FRN_HIST_SLOTS / 2)
225 					/* if foreign slots >= 8, switch */
226 #define WB_FRN_HIST_MAX_SLOTS	(WB_FRN_HIST_THR_SLOTS / 2 + 1)
227 					/* one round can affect upto 5 slots */
228 #define WB_FRN_MAX_IN_FLIGHT	1024	/* don't queue too many concurrently */
229 
230 /*
231  * Maximum inodes per isw.  A specific value has been chosen to make
232  * struct inode_switch_wbs_context fit into 1024 bytes kmalloc.
233  */
234 #define WB_MAX_INODES_PER_ISW  ((1024UL - sizeof(struct inode_switch_wbs_context)) \
235                                 / sizeof(struct inode *))
236 
237 static atomic_t isw_nr_in_flight = ATOMIC_INIT(0);
238 static struct workqueue_struct *isw_wq;
239 
__inode_attach_wb(struct inode * inode,struct folio * folio)240 void __inode_attach_wb(struct inode *inode, struct folio *folio)
241 {
242 	struct backing_dev_info *bdi = inode_to_bdi(inode);
243 	struct bdi_writeback *wb = NULL;
244 
245 	if (inode_cgwb_enabled(inode)) {
246 		struct cgroup_subsys_state *memcg_css;
247 
248 		if (folio) {
249 			memcg_css = mem_cgroup_css_from_folio(folio);
250 			wb = wb_get_create(bdi, memcg_css, GFP_ATOMIC);
251 		} else {
252 			/* must pin memcg_css, see wb_get_create() */
253 			memcg_css = task_get_css(current, memory_cgrp_id);
254 			wb = wb_get_create(bdi, memcg_css, GFP_ATOMIC);
255 			css_put(memcg_css);
256 		}
257 	}
258 
259 	if (!wb)
260 		wb = &bdi->wb;
261 
262 	/*
263 	 * There may be multiple instances of this function racing to
264 	 * update the same inode.  Use cmpxchg() to tell the winner.
265 	 */
266 	if (unlikely(cmpxchg(&inode->i_wb, NULL, wb)))
267 		wb_put(wb);
268 }
269 EXPORT_SYMBOL_GPL(__inode_attach_wb);
270 
271 /**
272  * inode_cgwb_move_to_attached - put the inode onto wb->b_attached list
273  * @inode: inode of interest with i_lock held
274  * @wb: target bdi_writeback
275  *
276  * Remove the inode from wb's io lists and if necessarily put onto b_attached
277  * list.  Only inodes attached to cgwb's are kept on this list.
278  */
inode_cgwb_move_to_attached(struct inode * inode,struct bdi_writeback * wb)279 static void inode_cgwb_move_to_attached(struct inode *inode,
280 					struct bdi_writeback *wb)
281 {
282 	assert_spin_locked(&wb->list_lock);
283 	assert_spin_locked(&inode->i_lock);
284 	WARN_ON_ONCE(inode->i_state & I_FREEING);
285 
286 	inode->i_state &= ~I_SYNC_QUEUED;
287 	if (wb != &wb->bdi->wb)
288 		list_move(&inode->i_io_list, &wb->b_attached);
289 	else
290 		list_del_init(&inode->i_io_list);
291 	wb_io_lists_depopulated(wb);
292 }
293 
294 /**
295  * locked_inode_to_wb_and_lock_list - determine a locked inode's wb and lock it
296  * @inode: inode of interest with i_lock held
297  *
298  * Returns @inode's wb with its list_lock held.  @inode->i_lock must be
299  * held on entry and is released on return.  The returned wb is guaranteed
300  * to stay @inode's associated wb until its list_lock is released.
301  */
302 static struct bdi_writeback *
locked_inode_to_wb_and_lock_list(struct inode * inode)303 locked_inode_to_wb_and_lock_list(struct inode *inode)
304 	__releases(&inode->i_lock)
305 	__acquires(&wb->list_lock)
306 {
307 	while (true) {
308 		struct bdi_writeback *wb = inode_to_wb(inode);
309 
310 		/*
311 		 * inode_to_wb() association is protected by both
312 		 * @inode->i_lock and @wb->list_lock but list_lock nests
313 		 * outside i_lock.  Drop i_lock and verify that the
314 		 * association hasn't changed after acquiring list_lock.
315 		 */
316 		wb_get(wb);
317 		spin_unlock(&inode->i_lock);
318 		spin_lock(&wb->list_lock);
319 
320 		/* i_wb may have changed inbetween, can't use inode_to_wb() */
321 		if (likely(wb == inode->i_wb)) {
322 			wb_put(wb);	/* @inode already has ref */
323 			return wb;
324 		}
325 
326 		spin_unlock(&wb->list_lock);
327 		wb_put(wb);
328 		cpu_relax();
329 		spin_lock(&inode->i_lock);
330 	}
331 }
332 
333 /**
334  * inode_to_wb_and_lock_list - determine an inode's wb and lock it
335  * @inode: inode of interest
336  *
337  * Same as locked_inode_to_wb_and_lock_list() but @inode->i_lock isn't held
338  * on entry.
339  */
inode_to_wb_and_lock_list(struct inode * inode)340 static struct bdi_writeback *inode_to_wb_and_lock_list(struct inode *inode)
341 	__acquires(&wb->list_lock)
342 {
343 	spin_lock(&inode->i_lock);
344 	return locked_inode_to_wb_and_lock_list(inode);
345 }
346 
347 struct inode_switch_wbs_context {
348 	struct rcu_work		work;
349 
350 	/*
351 	 * Multiple inodes can be switched at once.  The switching procedure
352 	 * consists of two parts, separated by a RCU grace period.  To make
353 	 * sure that the second part is executed for each inode gone through
354 	 * the first part, all inode pointers are placed into a NULL-terminated
355 	 * array embedded into struct inode_switch_wbs_context.  Otherwise
356 	 * an inode could be left in a non-consistent state.
357 	 */
358 	struct bdi_writeback	*new_wb;
359 	struct inode		*inodes[];
360 };
361 
bdi_down_write_wb_switch_rwsem(struct backing_dev_info * bdi)362 static void bdi_down_write_wb_switch_rwsem(struct backing_dev_info *bdi)
363 {
364 	down_write(&bdi->wb_switch_rwsem);
365 }
366 
bdi_up_write_wb_switch_rwsem(struct backing_dev_info * bdi)367 static void bdi_up_write_wb_switch_rwsem(struct backing_dev_info *bdi)
368 {
369 	up_write(&bdi->wb_switch_rwsem);
370 }
371 
inode_do_switch_wbs(struct inode * inode,struct bdi_writeback * old_wb,struct bdi_writeback * new_wb)372 static bool inode_do_switch_wbs(struct inode *inode,
373 				struct bdi_writeback *old_wb,
374 				struct bdi_writeback *new_wb)
375 {
376 	struct address_space *mapping = inode->i_mapping;
377 	XA_STATE(xas, &mapping->i_pages, 0);
378 	struct folio *folio;
379 	bool switched = false;
380 
381 	spin_lock(&inode->i_lock);
382 	xa_lock_irq(&mapping->i_pages);
383 
384 	/*
385 	 * Once I_FREEING or I_WILL_FREE are visible under i_lock, the eviction
386 	 * path owns the inode and we shouldn't modify ->i_io_list.
387 	 */
388 	if (unlikely(inode->i_state & (I_FREEING | I_WILL_FREE)))
389 		goto skip_switch;
390 
391 	trace_inode_switch_wbs(inode, old_wb, new_wb);
392 
393 	/*
394 	 * Count and transfer stats.  Note that PAGECACHE_TAG_DIRTY points
395 	 * to possibly dirty folios while PAGECACHE_TAG_WRITEBACK points to
396 	 * folios actually under writeback.
397 	 */
398 	xas_for_each_marked(&xas, folio, ULONG_MAX, PAGECACHE_TAG_DIRTY) {
399 		if (folio_test_dirty(folio)) {
400 			long nr = folio_nr_pages(folio);
401 			wb_stat_mod(old_wb, WB_RECLAIMABLE, -nr);
402 			wb_stat_mod(new_wb, WB_RECLAIMABLE, nr);
403 		}
404 	}
405 
406 	xas_set(&xas, 0);
407 	xas_for_each_marked(&xas, folio, ULONG_MAX, PAGECACHE_TAG_WRITEBACK) {
408 		long nr = folio_nr_pages(folio);
409 		WARN_ON_ONCE(!folio_test_writeback(folio));
410 		wb_stat_mod(old_wb, WB_WRITEBACK, -nr);
411 		wb_stat_mod(new_wb, WB_WRITEBACK, nr);
412 	}
413 
414 	if (mapping_tagged(mapping, PAGECACHE_TAG_WRITEBACK)) {
415 		atomic_dec(&old_wb->writeback_inodes);
416 		atomic_inc(&new_wb->writeback_inodes);
417 	}
418 
419 	wb_get(new_wb);
420 
421 	/*
422 	 * Transfer to @new_wb's IO list if necessary.  If the @inode is dirty,
423 	 * the specific list @inode was on is ignored and the @inode is put on
424 	 * ->b_dirty which is always correct including from ->b_dirty_time.
425 	 * The transfer preserves @inode->dirtied_when ordering.  If the @inode
426 	 * was clean, it means it was on the b_attached list, so move it onto
427 	 * the b_attached list of @new_wb.
428 	 */
429 	if (!list_empty(&inode->i_io_list)) {
430 		inode->i_wb = new_wb;
431 
432 		if (inode->i_state & I_DIRTY_ALL) {
433 			struct inode *pos;
434 
435 			list_for_each_entry(pos, &new_wb->b_dirty, i_io_list)
436 				if (time_after_eq(inode->dirtied_when,
437 						  pos->dirtied_when))
438 					break;
439 			inode_io_list_move_locked(inode, new_wb,
440 						  pos->i_io_list.prev);
441 		} else {
442 			inode_cgwb_move_to_attached(inode, new_wb);
443 		}
444 	} else {
445 		inode->i_wb = new_wb;
446 	}
447 
448 	/* ->i_wb_frn updates may race wbc_detach_inode() but doesn't matter */
449 	inode->i_wb_frn_winner = 0;
450 	inode->i_wb_frn_avg_time = 0;
451 	inode->i_wb_frn_history = 0;
452 	switched = true;
453 skip_switch:
454 	/*
455 	 * Paired with load_acquire in unlocked_inode_to_wb_begin() and
456 	 * ensures that the new wb is visible if they see !I_WB_SWITCH.
457 	 */
458 	smp_store_release(&inode->i_state, inode->i_state & ~I_WB_SWITCH);
459 
460 	xa_unlock_irq(&mapping->i_pages);
461 	spin_unlock(&inode->i_lock);
462 
463 	return switched;
464 }
465 
inode_switch_wbs_work_fn(struct work_struct * work)466 static void inode_switch_wbs_work_fn(struct work_struct *work)
467 {
468 	struct inode_switch_wbs_context *isw =
469 		container_of(to_rcu_work(work), struct inode_switch_wbs_context, work);
470 	struct backing_dev_info *bdi = inode_to_bdi(isw->inodes[0]);
471 	struct bdi_writeback *old_wb = isw->inodes[0]->i_wb;
472 	struct bdi_writeback *new_wb = isw->new_wb;
473 	unsigned long nr_switched = 0;
474 	struct inode **inodep;
475 
476 	/*
477 	 * If @inode switches cgwb membership while sync_inodes_sb() is
478 	 * being issued, sync_inodes_sb() might miss it.  Synchronize.
479 	 */
480 	down_read(&bdi->wb_switch_rwsem);
481 
482 	/*
483 	 * By the time control reaches here, RCU grace period has passed
484 	 * since I_WB_SWITCH assertion and all wb stat update transactions
485 	 * between unlocked_inode_to_wb_begin/end() are guaranteed to be
486 	 * synchronizing against the i_pages lock.
487 	 *
488 	 * Grabbing old_wb->list_lock, inode->i_lock and the i_pages lock
489 	 * gives us exclusion against all wb related operations on @inode
490 	 * including IO list manipulations and stat updates.
491 	 */
492 	if (old_wb < new_wb) {
493 		spin_lock(&old_wb->list_lock);
494 		spin_lock_nested(&new_wb->list_lock, SINGLE_DEPTH_NESTING);
495 	} else {
496 		spin_lock(&new_wb->list_lock);
497 		spin_lock_nested(&old_wb->list_lock, SINGLE_DEPTH_NESTING);
498 	}
499 
500 	for (inodep = isw->inodes; *inodep; inodep++) {
501 		WARN_ON_ONCE((*inodep)->i_wb != old_wb);
502 		if (inode_do_switch_wbs(*inodep, old_wb, new_wb))
503 			nr_switched++;
504 	}
505 
506 	spin_unlock(&new_wb->list_lock);
507 	spin_unlock(&old_wb->list_lock);
508 
509 	up_read(&bdi->wb_switch_rwsem);
510 
511 	if (nr_switched) {
512 		wb_wakeup(new_wb);
513 		wb_put_many(old_wb, nr_switched);
514 	}
515 
516 	for (inodep = isw->inodes; *inodep; inodep++)
517 		iput(*inodep);
518 	wb_put(new_wb);
519 	kfree(isw);
520 	atomic_dec(&isw_nr_in_flight);
521 }
522 
inode_prepare_wbs_switch(struct inode * inode,struct bdi_writeback * new_wb)523 static bool inode_prepare_wbs_switch(struct inode *inode,
524 				     struct bdi_writeback *new_wb)
525 {
526 	/*
527 	 * Paired with smp_mb() in cgroup_writeback_umount().
528 	 * isw_nr_in_flight must be increased before checking SB_ACTIVE and
529 	 * grabbing an inode, otherwise isw_nr_in_flight can be observed as 0
530 	 * in cgroup_writeback_umount() and the isw_wq will be not flushed.
531 	 */
532 	smp_mb();
533 
534 	if (IS_DAX(inode))
535 		return false;
536 
537 	/* while holding I_WB_SWITCH, no one else can update the association */
538 	spin_lock(&inode->i_lock);
539 	if (!(inode->i_sb->s_flags & SB_ACTIVE) ||
540 	    inode->i_state & (I_WB_SWITCH | I_FREEING | I_WILL_FREE) ||
541 	    inode_to_wb(inode) == new_wb) {
542 		spin_unlock(&inode->i_lock);
543 		return false;
544 	}
545 	inode->i_state |= I_WB_SWITCH;
546 	__iget(inode);
547 	spin_unlock(&inode->i_lock);
548 
549 	return true;
550 }
551 
552 /**
553  * inode_switch_wbs - change the wb association of an inode
554  * @inode: target inode
555  * @new_wb_id: ID of the new wb
556  *
557  * Switch @inode's wb association to the wb identified by @new_wb_id.  The
558  * switching is performed asynchronously and may fail silently.
559  */
inode_switch_wbs(struct inode * inode,int new_wb_id)560 static void inode_switch_wbs(struct inode *inode, int new_wb_id)
561 {
562 	struct backing_dev_info *bdi = inode_to_bdi(inode);
563 	struct cgroup_subsys_state *memcg_css;
564 	struct inode_switch_wbs_context *isw;
565 
566 	/* noop if seems to be already in progress */
567 	if (inode->i_state & I_WB_SWITCH)
568 		return;
569 
570 	/* avoid queueing a new switch if too many are already in flight */
571 	if (atomic_read(&isw_nr_in_flight) > WB_FRN_MAX_IN_FLIGHT)
572 		return;
573 
574 	isw = kzalloc(struct_size(isw, inodes, 2), GFP_ATOMIC);
575 	if (!isw)
576 		return;
577 
578 	atomic_inc(&isw_nr_in_flight);
579 
580 	/* find and pin the new wb */
581 	rcu_read_lock();
582 	memcg_css = css_from_id(new_wb_id, &memory_cgrp_subsys);
583 	if (memcg_css && !css_tryget(memcg_css))
584 		memcg_css = NULL;
585 	rcu_read_unlock();
586 	if (!memcg_css)
587 		goto out_free;
588 
589 	isw->new_wb = wb_get_create(bdi, memcg_css, GFP_ATOMIC);
590 	css_put(memcg_css);
591 	if (!isw->new_wb)
592 		goto out_free;
593 
594 	if (!inode_prepare_wbs_switch(inode, isw->new_wb))
595 		goto out_free;
596 
597 	isw->inodes[0] = inode;
598 
599 	/*
600 	 * In addition to synchronizing among switchers, I_WB_SWITCH tells
601 	 * the RCU protected stat update paths to grab the i_page
602 	 * lock so that stat transfer can synchronize against them.
603 	 * Let's continue after I_WB_SWITCH is guaranteed to be visible.
604 	 */
605 	INIT_RCU_WORK(&isw->work, inode_switch_wbs_work_fn);
606 	queue_rcu_work(isw_wq, &isw->work);
607 	return;
608 
609 out_free:
610 	atomic_dec(&isw_nr_in_flight);
611 	if (isw->new_wb)
612 		wb_put(isw->new_wb);
613 	kfree(isw);
614 }
615 
isw_prepare_wbs_switch(struct inode_switch_wbs_context * isw,struct list_head * list,int * nr)616 static bool isw_prepare_wbs_switch(struct inode_switch_wbs_context *isw,
617 				   struct list_head *list, int *nr)
618 {
619 	struct inode *inode;
620 
621 	list_for_each_entry(inode, list, i_io_list) {
622 		if (!inode_prepare_wbs_switch(inode, isw->new_wb))
623 			continue;
624 
625 		isw->inodes[*nr] = inode;
626 		(*nr)++;
627 
628 		if (*nr >= WB_MAX_INODES_PER_ISW - 1)
629 			return true;
630 	}
631 	return false;
632 }
633 
634 /**
635  * cleanup_offline_cgwb - detach associated inodes
636  * @wb: target wb
637  *
638  * Switch all inodes attached to @wb to a nearest living ancestor's wb in order
639  * to eventually release the dying @wb.  Returns %true if not all inodes were
640  * switched and the function has to be restarted.
641  */
cleanup_offline_cgwb(struct bdi_writeback * wb)642 bool cleanup_offline_cgwb(struct bdi_writeback *wb)
643 {
644 	struct cgroup_subsys_state *memcg_css;
645 	struct inode_switch_wbs_context *isw;
646 	int nr;
647 	bool restart = false;
648 
649 	isw = kzalloc(struct_size(isw, inodes, WB_MAX_INODES_PER_ISW),
650 		      GFP_KERNEL);
651 	if (!isw)
652 		return restart;
653 
654 	atomic_inc(&isw_nr_in_flight);
655 
656 	for (memcg_css = wb->memcg_css->parent; memcg_css;
657 	     memcg_css = memcg_css->parent) {
658 		isw->new_wb = wb_get_create(wb->bdi, memcg_css, GFP_KERNEL);
659 		if (isw->new_wb)
660 			break;
661 	}
662 	if (unlikely(!isw->new_wb))
663 		isw->new_wb = &wb->bdi->wb; /* wb_get() is noop for bdi's wb */
664 
665 	nr = 0;
666 	spin_lock(&wb->list_lock);
667 	/*
668 	 * In addition to the inodes that have completed writeback, also switch
669 	 * cgwbs for those inodes only with dirty timestamps. Otherwise, those
670 	 * inodes won't be written back for a long time when lazytime is
671 	 * enabled, and thus pinning the dying cgwbs. It won't break the
672 	 * bandwidth restrictions, as writeback of inode metadata is not
673 	 * accounted for.
674 	 */
675 	restart = isw_prepare_wbs_switch(isw, &wb->b_attached, &nr);
676 	if (!restart)
677 		restart = isw_prepare_wbs_switch(isw, &wb->b_dirty_time, &nr);
678 	spin_unlock(&wb->list_lock);
679 
680 	/* no attached inodes? bail out */
681 	if (nr == 0) {
682 		atomic_dec(&isw_nr_in_flight);
683 		wb_put(isw->new_wb);
684 		kfree(isw);
685 		return restart;
686 	}
687 
688 	/*
689 	 * In addition to synchronizing among switchers, I_WB_SWITCH tells
690 	 * the RCU protected stat update paths to grab the i_page
691 	 * lock so that stat transfer can synchronize against them.
692 	 * Let's continue after I_WB_SWITCH is guaranteed to be visible.
693 	 */
694 	INIT_RCU_WORK(&isw->work, inode_switch_wbs_work_fn);
695 	queue_rcu_work(isw_wq, &isw->work);
696 
697 	return restart;
698 }
699 
700 /**
701  * wbc_attach_and_unlock_inode - associate wbc with target inode and unlock it
702  * @wbc: writeback_control of interest
703  * @inode: target inode
704  *
705  * @inode is locked and about to be written back under the control of @wbc.
706  * Record @inode's writeback context into @wbc and unlock the i_lock.  On
707  * writeback completion, wbc_detach_inode() should be called.  This is used
708  * to track the cgroup writeback context.
709  */
wbc_attach_and_unlock_inode(struct writeback_control * wbc,struct inode * inode)710 void wbc_attach_and_unlock_inode(struct writeback_control *wbc,
711 				 struct inode *inode)
712 {
713 	if (!inode_cgwb_enabled(inode)) {
714 		spin_unlock(&inode->i_lock);
715 		return;
716 	}
717 
718 	wbc->wb = inode_to_wb(inode);
719 	wbc->inode = inode;
720 
721 	wbc->wb_id = wbc->wb->memcg_css->id;
722 	wbc->wb_lcand_id = inode->i_wb_frn_winner;
723 	wbc->wb_tcand_id = 0;
724 	wbc->wb_bytes = 0;
725 	wbc->wb_lcand_bytes = 0;
726 	wbc->wb_tcand_bytes = 0;
727 
728 	wb_get(wbc->wb);
729 	spin_unlock(&inode->i_lock);
730 
731 	/*
732 	 * A dying wb indicates that either the blkcg associated with the
733 	 * memcg changed or the associated memcg is dying.  In the first
734 	 * case, a replacement wb should already be available and we should
735 	 * refresh the wb immediately.  In the second case, trying to
736 	 * refresh will keep failing.
737 	 */
738 	if (unlikely(wb_dying(wbc->wb) && !css_is_dying(wbc->wb->memcg_css)))
739 		inode_switch_wbs(inode, wbc->wb_id);
740 }
741 EXPORT_SYMBOL_GPL(wbc_attach_and_unlock_inode);
742 
743 /**
744  * wbc_detach_inode - disassociate wbc from inode and perform foreign detection
745  * @wbc: writeback_control of the just finished writeback
746  *
747  * To be called after a writeback attempt of an inode finishes and undoes
748  * wbc_attach_and_unlock_inode().  Can be called under any context.
749  *
750  * As concurrent write sharing of an inode is expected to be very rare and
751  * memcg only tracks page ownership on first-use basis severely confining
752  * the usefulness of such sharing, cgroup writeback tracks ownership
753  * per-inode.  While the support for concurrent write sharing of an inode
754  * is deemed unnecessary, an inode being written to by different cgroups at
755  * different points in time is a lot more common, and, more importantly,
756  * charging only by first-use can too readily lead to grossly incorrect
757  * behaviors (single foreign page can lead to gigabytes of writeback to be
758  * incorrectly attributed).
759  *
760  * To resolve this issue, cgroup writeback detects the majority dirtier of
761  * an inode and transfers the ownership to it.  To avoid unnecessary
762  * oscillation, the detection mechanism keeps track of history and gives
763  * out the switch verdict only if the foreign usage pattern is stable over
764  * a certain amount of time and/or writeback attempts.
765  *
766  * On each writeback attempt, @wbc tries to detect the majority writer
767  * using Boyer-Moore majority vote algorithm.  In addition to the byte
768  * count from the majority voting, it also counts the bytes written for the
769  * current wb and the last round's winner wb (max of last round's current
770  * wb, the winner from two rounds ago, and the last round's majority
771  * candidate).  Keeping track of the historical winner helps the algorithm
772  * to semi-reliably detect the most active writer even when it's not the
773  * absolute majority.
774  *
775  * Once the winner of the round is determined, whether the winner is
776  * foreign or not and how much IO time the round consumed is recorded in
777  * inode->i_wb_frn_history.  If the amount of recorded foreign IO time is
778  * over a certain threshold, the switch verdict is given.
779  */
wbc_detach_inode(struct writeback_control * wbc)780 void wbc_detach_inode(struct writeback_control *wbc)
781 {
782 	struct bdi_writeback *wb = wbc->wb;
783 	struct inode *inode = wbc->inode;
784 	unsigned long avg_time, max_bytes, max_time;
785 	u16 history;
786 	int max_id;
787 
788 	if (!wb)
789 		return;
790 
791 	history = inode->i_wb_frn_history;
792 	avg_time = inode->i_wb_frn_avg_time;
793 
794 	/* pick the winner of this round */
795 	if (wbc->wb_bytes >= wbc->wb_lcand_bytes &&
796 	    wbc->wb_bytes >= wbc->wb_tcand_bytes) {
797 		max_id = wbc->wb_id;
798 		max_bytes = wbc->wb_bytes;
799 	} else if (wbc->wb_lcand_bytes >= wbc->wb_tcand_bytes) {
800 		max_id = wbc->wb_lcand_id;
801 		max_bytes = wbc->wb_lcand_bytes;
802 	} else {
803 		max_id = wbc->wb_tcand_id;
804 		max_bytes = wbc->wb_tcand_bytes;
805 	}
806 
807 	/*
808 	 * Calculate the amount of IO time the winner consumed and fold it
809 	 * into the running average kept per inode.  If the consumed IO
810 	 * time is lower than avag / WB_FRN_TIME_CUT_DIV, ignore it for
811 	 * deciding whether to switch or not.  This is to prevent one-off
812 	 * small dirtiers from skewing the verdict.
813 	 */
814 	max_time = DIV_ROUND_UP((max_bytes >> PAGE_SHIFT) << WB_FRN_TIME_SHIFT,
815 				wb->avg_write_bandwidth);
816 	if (avg_time)
817 		avg_time += (max_time >> WB_FRN_TIME_AVG_SHIFT) -
818 			    (avg_time >> WB_FRN_TIME_AVG_SHIFT);
819 	else
820 		avg_time = max_time;	/* immediate catch up on first run */
821 
822 	if (max_time >= avg_time / WB_FRN_TIME_CUT_DIV) {
823 		int slots;
824 
825 		/*
826 		 * The switch verdict is reached if foreign wb's consume
827 		 * more than a certain proportion of IO time in a
828 		 * WB_FRN_TIME_PERIOD.  This is loosely tracked by 16 slot
829 		 * history mask where each bit represents one sixteenth of
830 		 * the period.  Determine the number of slots to shift into
831 		 * history from @max_time.
832 		 */
833 		slots = min(DIV_ROUND_UP(max_time, WB_FRN_HIST_UNIT),
834 			    (unsigned long)WB_FRN_HIST_MAX_SLOTS);
835 		history <<= slots;
836 		if (wbc->wb_id != max_id)
837 			history |= (1U << slots) - 1;
838 
839 		if (history)
840 			trace_inode_foreign_history(inode, wbc, history);
841 
842 		/*
843 		 * Switch if the current wb isn't the consistent winner.
844 		 * If there are multiple closely competing dirtiers, the
845 		 * inode may switch across them repeatedly over time, which
846 		 * is okay.  The main goal is avoiding keeping an inode on
847 		 * the wrong wb for an extended period of time.
848 		 */
849 		if (hweight16(history) > WB_FRN_HIST_THR_SLOTS)
850 			inode_switch_wbs(inode, max_id);
851 	}
852 
853 	/*
854 	 * Multiple instances of this function may race to update the
855 	 * following fields but we don't mind occassional inaccuracies.
856 	 */
857 	inode->i_wb_frn_winner = max_id;
858 	inode->i_wb_frn_avg_time = min(avg_time, (unsigned long)U16_MAX);
859 	inode->i_wb_frn_history = history;
860 
861 	wb_put(wbc->wb);
862 	wbc->wb = NULL;
863 }
864 EXPORT_SYMBOL_GPL(wbc_detach_inode);
865 
866 /**
867  * wbc_account_cgroup_owner - account writeback to update inode cgroup ownership
868  * @wbc: writeback_control of the writeback in progress
869  * @page: page being written out
870  * @bytes: number of bytes being written out
871  *
872  * @bytes from @page are about to written out during the writeback
873  * controlled by @wbc.  Keep the book for foreign inode detection.  See
874  * wbc_detach_inode().
875  */
wbc_account_cgroup_owner(struct writeback_control * wbc,struct page * page,size_t bytes)876 void wbc_account_cgroup_owner(struct writeback_control *wbc, struct page *page,
877 			      size_t bytes)
878 {
879 	struct folio *folio;
880 	struct cgroup_subsys_state *css;
881 	int id;
882 
883 	/*
884 	 * pageout() path doesn't attach @wbc to the inode being written
885 	 * out.  This is intentional as we don't want the function to block
886 	 * behind a slow cgroup.  Ultimately, we want pageout() to kick off
887 	 * regular writeback instead of writing things out itself.
888 	 */
889 	if (!wbc->wb || wbc->no_cgroup_owner)
890 		return;
891 
892 	folio = page_folio(page);
893 	css = mem_cgroup_css_from_folio(folio);
894 	/* dead cgroups shouldn't contribute to inode ownership arbitration */
895 	if (!(css->flags & CSS_ONLINE))
896 		return;
897 
898 	id = css->id;
899 
900 	if (id == wbc->wb_id) {
901 		wbc->wb_bytes += bytes;
902 		return;
903 	}
904 
905 	if (id == wbc->wb_lcand_id)
906 		wbc->wb_lcand_bytes += bytes;
907 
908 	/* Boyer-Moore majority vote algorithm */
909 	if (!wbc->wb_tcand_bytes)
910 		wbc->wb_tcand_id = id;
911 	if (id == wbc->wb_tcand_id)
912 		wbc->wb_tcand_bytes += bytes;
913 	else
914 		wbc->wb_tcand_bytes -= min(bytes, wbc->wb_tcand_bytes);
915 }
916 EXPORT_SYMBOL_GPL(wbc_account_cgroup_owner);
917 
918 /**
919  * wb_split_bdi_pages - split nr_pages to write according to bandwidth
920  * @wb: target bdi_writeback to split @nr_pages to
921  * @nr_pages: number of pages to write for the whole bdi
922  *
923  * Split @wb's portion of @nr_pages according to @wb's write bandwidth in
924  * relation to the total write bandwidth of all wb's w/ dirty inodes on
925  * @wb->bdi.
926  */
wb_split_bdi_pages(struct bdi_writeback * wb,long nr_pages)927 static long wb_split_bdi_pages(struct bdi_writeback *wb, long nr_pages)
928 {
929 	unsigned long this_bw = wb->avg_write_bandwidth;
930 	unsigned long tot_bw = atomic_long_read(&wb->bdi->tot_write_bandwidth);
931 
932 	if (nr_pages == LONG_MAX)
933 		return LONG_MAX;
934 
935 	/*
936 	 * This may be called on clean wb's and proportional distribution
937 	 * may not make sense, just use the original @nr_pages in those
938 	 * cases.  In general, we wanna err on the side of writing more.
939 	 */
940 	if (!tot_bw || this_bw >= tot_bw)
941 		return nr_pages;
942 	else
943 		return DIV_ROUND_UP_ULL((u64)nr_pages * this_bw, tot_bw);
944 }
945 
946 /**
947  * bdi_split_work_to_wbs - split a wb_writeback_work to all wb's of a bdi
948  * @bdi: target backing_dev_info
949  * @base_work: wb_writeback_work to issue
950  * @skip_if_busy: skip wb's which already have writeback in progress
951  *
952  * Split and issue @base_work to all wb's (bdi_writeback's) of @bdi which
953  * have dirty inodes.  If @base_work->nr_page isn't %LONG_MAX, it's
954  * distributed to the busy wbs according to each wb's proportion in the
955  * total active write bandwidth of @bdi.
956  */
bdi_split_work_to_wbs(struct backing_dev_info * bdi,struct wb_writeback_work * base_work,bool skip_if_busy)957 static void bdi_split_work_to_wbs(struct backing_dev_info *bdi,
958 				  struct wb_writeback_work *base_work,
959 				  bool skip_if_busy)
960 {
961 	struct bdi_writeback *last_wb = NULL;
962 	struct bdi_writeback *wb = list_entry(&bdi->wb_list,
963 					      struct bdi_writeback, bdi_node);
964 
965 	might_sleep();
966 restart:
967 	rcu_read_lock();
968 	list_for_each_entry_continue_rcu(wb, &bdi->wb_list, bdi_node) {
969 		DEFINE_WB_COMPLETION(fallback_work_done, bdi);
970 		struct wb_writeback_work fallback_work;
971 		struct wb_writeback_work *work;
972 		long nr_pages;
973 
974 		if (last_wb) {
975 			wb_put(last_wb);
976 			last_wb = NULL;
977 		}
978 
979 		/* SYNC_ALL writes out I_DIRTY_TIME too */
980 		if (!wb_has_dirty_io(wb) &&
981 		    (base_work->sync_mode == WB_SYNC_NONE ||
982 		     list_empty(&wb->b_dirty_time)))
983 			continue;
984 		if (skip_if_busy && writeback_in_progress(wb))
985 			continue;
986 
987 		nr_pages = wb_split_bdi_pages(wb, base_work->nr_pages);
988 
989 		work = kmalloc(sizeof(*work), GFP_ATOMIC);
990 		if (work) {
991 			*work = *base_work;
992 			work->nr_pages = nr_pages;
993 			work->auto_free = 1;
994 			wb_queue_work(wb, work);
995 			continue;
996 		}
997 
998 		/*
999 		 * If wb_tryget fails, the wb has been shutdown, skip it.
1000 		 *
1001 		 * Pin @wb so that it stays on @bdi->wb_list.  This allows
1002 		 * continuing iteration from @wb after dropping and
1003 		 * regrabbing rcu read lock.
1004 		 */
1005 		if (!wb_tryget(wb))
1006 			continue;
1007 
1008 		/* alloc failed, execute synchronously using on-stack fallback */
1009 		work = &fallback_work;
1010 		*work = *base_work;
1011 		work->nr_pages = nr_pages;
1012 		work->auto_free = 0;
1013 		work->done = &fallback_work_done;
1014 
1015 		wb_queue_work(wb, work);
1016 		last_wb = wb;
1017 
1018 		rcu_read_unlock();
1019 		wb_wait_for_completion(&fallback_work_done);
1020 		goto restart;
1021 	}
1022 	rcu_read_unlock();
1023 
1024 	if (last_wb)
1025 		wb_put(last_wb);
1026 }
1027 
1028 /**
1029  * cgroup_writeback_by_id - initiate cgroup writeback from bdi and memcg IDs
1030  * @bdi_id: target bdi id
1031  * @memcg_id: target memcg css id
1032  * @reason: reason why some writeback work initiated
1033  * @done: target wb_completion
1034  *
1035  * Initiate flush of the bdi_writeback identified by @bdi_id and @memcg_id
1036  * with the specified parameters.
1037  */
cgroup_writeback_by_id(u64 bdi_id,int memcg_id,enum wb_reason reason,struct wb_completion * done)1038 int cgroup_writeback_by_id(u64 bdi_id, int memcg_id,
1039 			   enum wb_reason reason, struct wb_completion *done)
1040 {
1041 	struct backing_dev_info *bdi;
1042 	struct cgroup_subsys_state *memcg_css;
1043 	struct bdi_writeback *wb;
1044 	struct wb_writeback_work *work;
1045 	unsigned long dirty;
1046 	int ret;
1047 
1048 	/* lookup bdi and memcg */
1049 	bdi = bdi_get_by_id(bdi_id);
1050 	if (!bdi)
1051 		return -ENOENT;
1052 
1053 	rcu_read_lock();
1054 	memcg_css = css_from_id(memcg_id, &memory_cgrp_subsys);
1055 	if (memcg_css && !css_tryget(memcg_css))
1056 		memcg_css = NULL;
1057 	rcu_read_unlock();
1058 	if (!memcg_css) {
1059 		ret = -ENOENT;
1060 		goto out_bdi_put;
1061 	}
1062 
1063 	/*
1064 	 * And find the associated wb.  If the wb isn't there already
1065 	 * there's nothing to flush, don't create one.
1066 	 */
1067 	wb = wb_get_lookup(bdi, memcg_css);
1068 	if (!wb) {
1069 		ret = -ENOENT;
1070 		goto out_css_put;
1071 	}
1072 
1073 	/*
1074 	 * The caller is attempting to write out most of
1075 	 * the currently dirty pages.  Let's take the current dirty page
1076 	 * count and inflate it by 25% which should be large enough to
1077 	 * flush out most dirty pages while avoiding getting livelocked by
1078 	 * concurrent dirtiers.
1079 	 *
1080 	 * BTW the memcg stats are flushed periodically and this is best-effort
1081 	 * estimation, so some potential error is ok.
1082 	 */
1083 	dirty = memcg_page_state(mem_cgroup_from_css(memcg_css), NR_FILE_DIRTY);
1084 	dirty = dirty * 10 / 8;
1085 
1086 	/* issue the writeback work */
1087 	work = kzalloc(sizeof(*work), GFP_NOWAIT | __GFP_NOWARN);
1088 	if (work) {
1089 		work->nr_pages = dirty;
1090 		work->sync_mode = WB_SYNC_NONE;
1091 		work->range_cyclic = 1;
1092 		work->reason = reason;
1093 		work->done = done;
1094 		work->auto_free = 1;
1095 		wb_queue_work(wb, work);
1096 		ret = 0;
1097 	} else {
1098 		ret = -ENOMEM;
1099 	}
1100 
1101 	wb_put(wb);
1102 out_css_put:
1103 	css_put(memcg_css);
1104 out_bdi_put:
1105 	bdi_put(bdi);
1106 	return ret;
1107 }
1108 
1109 /**
1110  * cgroup_writeback_umount - flush inode wb switches for umount
1111  *
1112  * This function is called when a super_block is about to be destroyed and
1113  * flushes in-flight inode wb switches.  An inode wb switch goes through
1114  * RCU and then workqueue, so the two need to be flushed in order to ensure
1115  * that all previously scheduled switches are finished.  As wb switches are
1116  * rare occurrences and synchronize_rcu() can take a while, perform
1117  * flushing iff wb switches are in flight.
1118  */
cgroup_writeback_umount(void)1119 void cgroup_writeback_umount(void)
1120 {
1121 	/*
1122 	 * SB_ACTIVE should be reliably cleared before checking
1123 	 * isw_nr_in_flight, see generic_shutdown_super().
1124 	 */
1125 	smp_mb();
1126 
1127 	if (atomic_read(&isw_nr_in_flight)) {
1128 		/*
1129 		 * Use rcu_barrier() to wait for all pending callbacks to
1130 		 * ensure that all in-flight wb switches are in the workqueue.
1131 		 */
1132 		rcu_barrier();
1133 		flush_workqueue(isw_wq);
1134 	}
1135 }
1136 
cgroup_writeback_init(void)1137 static int __init cgroup_writeback_init(void)
1138 {
1139 	isw_wq = alloc_workqueue("inode_switch_wbs", 0, 0);
1140 	if (!isw_wq)
1141 		return -ENOMEM;
1142 	return 0;
1143 }
1144 fs_initcall(cgroup_writeback_init);
1145 
1146 #else	/* CONFIG_CGROUP_WRITEBACK */
1147 
bdi_down_write_wb_switch_rwsem(struct backing_dev_info * bdi)1148 static void bdi_down_write_wb_switch_rwsem(struct backing_dev_info *bdi) { }
bdi_up_write_wb_switch_rwsem(struct backing_dev_info * bdi)1149 static void bdi_up_write_wb_switch_rwsem(struct backing_dev_info *bdi) { }
1150 
inode_cgwb_move_to_attached(struct inode * inode,struct bdi_writeback * wb)1151 static void inode_cgwb_move_to_attached(struct inode *inode,
1152 					struct bdi_writeback *wb)
1153 {
1154 	assert_spin_locked(&wb->list_lock);
1155 	assert_spin_locked(&inode->i_lock);
1156 	WARN_ON_ONCE(inode->i_state & I_FREEING);
1157 
1158 	inode->i_state &= ~I_SYNC_QUEUED;
1159 	list_del_init(&inode->i_io_list);
1160 	wb_io_lists_depopulated(wb);
1161 }
1162 
1163 static struct bdi_writeback *
locked_inode_to_wb_and_lock_list(struct inode * inode)1164 locked_inode_to_wb_and_lock_list(struct inode *inode)
1165 	__releases(&inode->i_lock)
1166 	__acquires(&wb->list_lock)
1167 {
1168 	struct bdi_writeback *wb = inode_to_wb(inode);
1169 
1170 	spin_unlock(&inode->i_lock);
1171 	spin_lock(&wb->list_lock);
1172 	return wb;
1173 }
1174 
inode_to_wb_and_lock_list(struct inode * inode)1175 static struct bdi_writeback *inode_to_wb_and_lock_list(struct inode *inode)
1176 	__acquires(&wb->list_lock)
1177 {
1178 	struct bdi_writeback *wb = inode_to_wb(inode);
1179 
1180 	spin_lock(&wb->list_lock);
1181 	return wb;
1182 }
1183 
wb_split_bdi_pages(struct bdi_writeback * wb,long nr_pages)1184 static long wb_split_bdi_pages(struct bdi_writeback *wb, long nr_pages)
1185 {
1186 	return nr_pages;
1187 }
1188 
bdi_split_work_to_wbs(struct backing_dev_info * bdi,struct wb_writeback_work * base_work,bool skip_if_busy)1189 static void bdi_split_work_to_wbs(struct backing_dev_info *bdi,
1190 				  struct wb_writeback_work *base_work,
1191 				  bool skip_if_busy)
1192 {
1193 	might_sleep();
1194 
1195 	if (!skip_if_busy || !writeback_in_progress(&bdi->wb)) {
1196 		base_work->auto_free = 0;
1197 		wb_queue_work(&bdi->wb, base_work);
1198 	}
1199 }
1200 
1201 #endif	/* CONFIG_CGROUP_WRITEBACK */
1202 
1203 /*
1204  * Add in the number of potentially dirty inodes, because each inode
1205  * write can dirty pagecache in the underlying blockdev.
1206  */
get_nr_dirty_pages(void)1207 static unsigned long get_nr_dirty_pages(void)
1208 {
1209 	return global_node_page_state(NR_FILE_DIRTY) +
1210 		get_nr_dirty_inodes();
1211 }
1212 
wb_start_writeback(struct bdi_writeback * wb,enum wb_reason reason)1213 static void wb_start_writeback(struct bdi_writeback *wb, enum wb_reason reason)
1214 {
1215 	if (!wb_has_dirty_io(wb))
1216 		return;
1217 
1218 	/*
1219 	 * All callers of this function want to start writeback of all
1220 	 * dirty pages. Places like vmscan can call this at a very
1221 	 * high frequency, causing pointless allocations of tons of
1222 	 * work items and keeping the flusher threads busy retrieving
1223 	 * that work. Ensure that we only allow one of them pending and
1224 	 * inflight at the time.
1225 	 */
1226 	if (test_bit(WB_start_all, &wb->state) ||
1227 	    test_and_set_bit(WB_start_all, &wb->state))
1228 		return;
1229 
1230 	wb->start_all_reason = reason;
1231 	wb_wakeup(wb);
1232 }
1233 
1234 /**
1235  * wb_start_background_writeback - start background writeback
1236  * @wb: bdi_writback to write from
1237  *
1238  * Description:
1239  *   This makes sure WB_SYNC_NONE background writeback happens. When
1240  *   this function returns, it is only guaranteed that for given wb
1241  *   some IO is happening if we are over background dirty threshold.
1242  *   Caller need not hold sb s_umount semaphore.
1243  */
wb_start_background_writeback(struct bdi_writeback * wb)1244 void wb_start_background_writeback(struct bdi_writeback *wb)
1245 {
1246 	/*
1247 	 * We just wake up the flusher thread. It will perform background
1248 	 * writeback as soon as there is no other work to do.
1249 	 */
1250 	trace_writeback_wake_background(wb);
1251 	wb_wakeup(wb);
1252 }
1253 
1254 /*
1255  * Remove the inode from the writeback list it is on.
1256  */
inode_io_list_del(struct inode * inode)1257 void inode_io_list_del(struct inode *inode)
1258 {
1259 	struct bdi_writeback *wb;
1260 
1261 	wb = inode_to_wb_and_lock_list(inode);
1262 	spin_lock(&inode->i_lock);
1263 
1264 	inode->i_state &= ~I_SYNC_QUEUED;
1265 	list_del_init(&inode->i_io_list);
1266 	wb_io_lists_depopulated(wb);
1267 
1268 	spin_unlock(&inode->i_lock);
1269 	spin_unlock(&wb->list_lock);
1270 }
1271 EXPORT_SYMBOL(inode_io_list_del);
1272 
1273 /*
1274  * mark an inode as under writeback on the sb
1275  */
sb_mark_inode_writeback(struct inode * inode)1276 void sb_mark_inode_writeback(struct inode *inode)
1277 {
1278 	struct super_block *sb = inode->i_sb;
1279 	unsigned long flags;
1280 
1281 	if (list_empty(&inode->i_wb_list)) {
1282 		spin_lock_irqsave(&sb->s_inode_wblist_lock, flags);
1283 		if (list_empty(&inode->i_wb_list)) {
1284 			list_add_tail(&inode->i_wb_list, &sb->s_inodes_wb);
1285 			trace_sb_mark_inode_writeback(inode);
1286 		}
1287 		spin_unlock_irqrestore(&sb->s_inode_wblist_lock, flags);
1288 	}
1289 }
1290 
1291 /*
1292  * clear an inode as under writeback on the sb
1293  */
sb_clear_inode_writeback(struct inode * inode)1294 void sb_clear_inode_writeback(struct inode *inode)
1295 {
1296 	struct super_block *sb = inode->i_sb;
1297 	unsigned long flags;
1298 
1299 	if (!list_empty(&inode->i_wb_list)) {
1300 		spin_lock_irqsave(&sb->s_inode_wblist_lock, flags);
1301 		if (!list_empty(&inode->i_wb_list)) {
1302 			list_del_init(&inode->i_wb_list);
1303 			trace_sb_clear_inode_writeback(inode);
1304 		}
1305 		spin_unlock_irqrestore(&sb->s_inode_wblist_lock, flags);
1306 	}
1307 }
1308 
1309 /*
1310  * Redirty an inode: set its when-it-was dirtied timestamp and move it to the
1311  * furthest end of its superblock's dirty-inode list.
1312  *
1313  * Before stamping the inode's ->dirtied_when, we check to see whether it is
1314  * already the most-recently-dirtied inode on the b_dirty list.  If that is
1315  * the case then the inode must have been redirtied while it was being written
1316  * out and we don't reset its dirtied_when.
1317  */
redirty_tail_locked(struct inode * inode,struct bdi_writeback * wb)1318 static void redirty_tail_locked(struct inode *inode, struct bdi_writeback *wb)
1319 {
1320 	assert_spin_locked(&inode->i_lock);
1321 
1322 	inode->i_state &= ~I_SYNC_QUEUED;
1323 	/*
1324 	 * When the inode is being freed just don't bother with dirty list
1325 	 * tracking. Flush worker will ignore this inode anyway and it will
1326 	 * trigger assertions in inode_io_list_move_locked().
1327 	 */
1328 	if (inode->i_state & I_FREEING) {
1329 		list_del_init(&inode->i_io_list);
1330 		wb_io_lists_depopulated(wb);
1331 		return;
1332 	}
1333 	if (!list_empty(&wb->b_dirty)) {
1334 		struct inode *tail;
1335 
1336 		tail = wb_inode(wb->b_dirty.next);
1337 		if (time_before(inode->dirtied_when, tail->dirtied_when))
1338 			inode->dirtied_when = jiffies;
1339 	}
1340 	inode_io_list_move_locked(inode, wb, &wb->b_dirty);
1341 }
1342 
redirty_tail(struct inode * inode,struct bdi_writeback * wb)1343 static void redirty_tail(struct inode *inode, struct bdi_writeback *wb)
1344 {
1345 	spin_lock(&inode->i_lock);
1346 	redirty_tail_locked(inode, wb);
1347 	spin_unlock(&inode->i_lock);
1348 }
1349 
1350 /*
1351  * requeue inode for re-scanning after bdi->b_io list is exhausted.
1352  */
requeue_io(struct inode * inode,struct bdi_writeback * wb)1353 static void requeue_io(struct inode *inode, struct bdi_writeback *wb)
1354 {
1355 	inode_io_list_move_locked(inode, wb, &wb->b_more_io);
1356 }
1357 
inode_sync_complete(struct inode * inode)1358 static void inode_sync_complete(struct inode *inode)
1359 {
1360 	inode->i_state &= ~I_SYNC;
1361 	/* If inode is clean an unused, put it into LRU now... */
1362 	inode_add_lru(inode);
1363 	/* Waiters must see I_SYNC cleared before being woken up */
1364 	smp_mb();
1365 	wake_up_bit(&inode->i_state, __I_SYNC);
1366 }
1367 
inode_dirtied_after(struct inode * inode,unsigned long t)1368 static bool inode_dirtied_after(struct inode *inode, unsigned long t)
1369 {
1370 	bool ret = time_after(inode->dirtied_when, t);
1371 #ifndef CONFIG_64BIT
1372 	/*
1373 	 * For inodes being constantly redirtied, dirtied_when can get stuck.
1374 	 * It _appears_ to be in the future, but is actually in distant past.
1375 	 * This test is necessary to prevent such wrapped-around relative times
1376 	 * from permanently stopping the whole bdi writeback.
1377 	 */
1378 	ret = ret && time_before_eq(inode->dirtied_when, jiffies);
1379 #endif
1380 	return ret;
1381 }
1382 
1383 /*
1384  * Move expired (dirtied before dirtied_before) dirty inodes from
1385  * @delaying_queue to @dispatch_queue.
1386  */
move_expired_inodes(struct list_head * delaying_queue,struct list_head * dispatch_queue,unsigned long dirtied_before)1387 static int move_expired_inodes(struct list_head *delaying_queue,
1388 			       struct list_head *dispatch_queue,
1389 			       unsigned long dirtied_before)
1390 {
1391 	LIST_HEAD(tmp);
1392 	struct list_head *pos, *node;
1393 	struct super_block *sb = NULL;
1394 	struct inode *inode;
1395 	int do_sb_sort = 0;
1396 	int moved = 0;
1397 
1398 	while (!list_empty(delaying_queue)) {
1399 		inode = wb_inode(delaying_queue->prev);
1400 		if (inode_dirtied_after(inode, dirtied_before))
1401 			break;
1402 		spin_lock(&inode->i_lock);
1403 		list_move(&inode->i_io_list, &tmp);
1404 		moved++;
1405 		inode->i_state |= I_SYNC_QUEUED;
1406 		spin_unlock(&inode->i_lock);
1407 		if (sb_is_blkdev_sb(inode->i_sb))
1408 			continue;
1409 		if (sb && sb != inode->i_sb)
1410 			do_sb_sort = 1;
1411 		sb = inode->i_sb;
1412 	}
1413 
1414 	/* just one sb in list, splice to dispatch_queue and we're done */
1415 	if (!do_sb_sort) {
1416 		list_splice(&tmp, dispatch_queue);
1417 		goto out;
1418 	}
1419 
1420 	/*
1421 	 * Although inode's i_io_list is moved from 'tmp' to 'dispatch_queue',
1422 	 * we don't take inode->i_lock here because it is just a pointless overhead.
1423 	 * Inode is already marked as I_SYNC_QUEUED so writeback list handling is
1424 	 * fully under our control.
1425 	 */
1426 	while (!list_empty(&tmp)) {
1427 		sb = wb_inode(tmp.prev)->i_sb;
1428 		list_for_each_prev_safe(pos, node, &tmp) {
1429 			inode = wb_inode(pos);
1430 			if (inode->i_sb == sb)
1431 				list_move(&inode->i_io_list, dispatch_queue);
1432 		}
1433 	}
1434 out:
1435 	return moved;
1436 }
1437 
1438 /*
1439  * Queue all expired dirty inodes for io, eldest first.
1440  * Before
1441  *         newly dirtied     b_dirty    b_io    b_more_io
1442  *         =============>    gf         edc     BA
1443  * After
1444  *         newly dirtied     b_dirty    b_io    b_more_io
1445  *         =============>    g          fBAedc
1446  *                                           |
1447  *                                           +--> dequeue for IO
1448  */
queue_io(struct bdi_writeback * wb,struct wb_writeback_work * work,unsigned long dirtied_before)1449 static void queue_io(struct bdi_writeback *wb, struct wb_writeback_work *work,
1450 		     unsigned long dirtied_before)
1451 {
1452 	int moved;
1453 	unsigned long time_expire_jif = dirtied_before;
1454 
1455 	assert_spin_locked(&wb->list_lock);
1456 	list_splice_init(&wb->b_more_io, &wb->b_io);
1457 	moved = move_expired_inodes(&wb->b_dirty, &wb->b_io, dirtied_before);
1458 	if (!work->for_sync)
1459 		time_expire_jif = jiffies - dirtytime_expire_interval * HZ;
1460 	moved += move_expired_inodes(&wb->b_dirty_time, &wb->b_io,
1461 				     time_expire_jif);
1462 	if (moved)
1463 		wb_io_lists_populated(wb);
1464 	trace_writeback_queue_io(wb, work, dirtied_before, moved);
1465 }
1466 
write_inode(struct inode * inode,struct writeback_control * wbc)1467 static int write_inode(struct inode *inode, struct writeback_control *wbc)
1468 {
1469 	int ret;
1470 
1471 	if (inode->i_sb->s_op->write_inode && !is_bad_inode(inode)) {
1472 		trace_writeback_write_inode_start(inode, wbc);
1473 		ret = inode->i_sb->s_op->write_inode(inode, wbc);
1474 		trace_writeback_write_inode(inode, wbc);
1475 		return ret;
1476 	}
1477 	return 0;
1478 }
1479 
1480 /*
1481  * Wait for writeback on an inode to complete. Called with i_lock held.
1482  * Caller must make sure inode cannot go away when we drop i_lock.
1483  */
__inode_wait_for_writeback(struct inode * inode)1484 static void __inode_wait_for_writeback(struct inode *inode)
1485 	__releases(inode->i_lock)
1486 	__acquires(inode->i_lock)
1487 {
1488 	DEFINE_WAIT_BIT(wq, &inode->i_state, __I_SYNC);
1489 	wait_queue_head_t *wqh;
1490 
1491 	wqh = bit_waitqueue(&inode->i_state, __I_SYNC);
1492 	while (inode->i_state & I_SYNC) {
1493 		spin_unlock(&inode->i_lock);
1494 		__wait_on_bit(wqh, &wq, bit_wait,
1495 			      TASK_UNINTERRUPTIBLE);
1496 		spin_lock(&inode->i_lock);
1497 	}
1498 }
1499 
1500 /*
1501  * Wait for writeback on an inode to complete. Caller must have inode pinned.
1502  */
inode_wait_for_writeback(struct inode * inode)1503 void inode_wait_for_writeback(struct inode *inode)
1504 {
1505 	spin_lock(&inode->i_lock);
1506 	__inode_wait_for_writeback(inode);
1507 	spin_unlock(&inode->i_lock);
1508 }
1509 
1510 /*
1511  * Sleep until I_SYNC is cleared. This function must be called with i_lock
1512  * held and drops it. It is aimed for callers not holding any inode reference
1513  * so once i_lock is dropped, inode can go away.
1514  */
inode_sleep_on_writeback(struct inode * inode)1515 static void inode_sleep_on_writeback(struct inode *inode)
1516 	__releases(inode->i_lock)
1517 {
1518 	DEFINE_WAIT(wait);
1519 	wait_queue_head_t *wqh = bit_waitqueue(&inode->i_state, __I_SYNC);
1520 	int sleep;
1521 
1522 	prepare_to_wait(wqh, &wait, TASK_UNINTERRUPTIBLE);
1523 	sleep = inode->i_state & I_SYNC;
1524 	spin_unlock(&inode->i_lock);
1525 	if (sleep)
1526 		schedule();
1527 	finish_wait(wqh, &wait);
1528 }
1529 
1530 /*
1531  * Find proper writeback list for the inode depending on its current state and
1532  * possibly also change of its state while we were doing writeback.  Here we
1533  * handle things such as livelock prevention or fairness of writeback among
1534  * inodes. This function can be called only by flusher thread - noone else
1535  * processes all inodes in writeback lists and requeueing inodes behind flusher
1536  * thread's back can have unexpected consequences.
1537  */
requeue_inode(struct inode * inode,struct bdi_writeback * wb,struct writeback_control * wbc)1538 static void requeue_inode(struct inode *inode, struct bdi_writeback *wb,
1539 			  struct writeback_control *wbc)
1540 {
1541 	if (inode->i_state & I_FREEING)
1542 		return;
1543 
1544 	/*
1545 	 * Sync livelock prevention. Each inode is tagged and synced in one
1546 	 * shot. If still dirty, it will be redirty_tail()'ed below.  Update
1547 	 * the dirty time to prevent enqueue and sync it again.
1548 	 */
1549 	if ((inode->i_state & I_DIRTY) &&
1550 	    (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages))
1551 		inode->dirtied_when = jiffies;
1552 
1553 	if (wbc->pages_skipped) {
1554 		/*
1555 		 * Writeback is not making progress due to locked buffers.
1556 		 * Skip this inode for now. Although having skipped pages
1557 		 * is odd for clean inodes, it can happen for some
1558 		 * filesystems so handle that gracefully.
1559 		 */
1560 		if (inode->i_state & I_DIRTY_ALL)
1561 			redirty_tail_locked(inode, wb);
1562 		else
1563 			inode_cgwb_move_to_attached(inode, wb);
1564 		return;
1565 	}
1566 
1567 	if (mapping_tagged(inode->i_mapping, PAGECACHE_TAG_DIRTY)) {
1568 		/*
1569 		 * We didn't write back all the pages.  nfs_writepages()
1570 		 * sometimes bales out without doing anything.
1571 		 */
1572 		if (wbc->nr_to_write <= 0) {
1573 			/* Slice used up. Queue for next turn. */
1574 			requeue_io(inode, wb);
1575 		} else {
1576 			/*
1577 			 * Writeback blocked by something other than
1578 			 * congestion. Delay the inode for some time to
1579 			 * avoid spinning on the CPU (100% iowait)
1580 			 * retrying writeback of the dirty page/inode
1581 			 * that cannot be performed immediately.
1582 			 */
1583 			redirty_tail_locked(inode, wb);
1584 		}
1585 	} else if (inode->i_state & I_DIRTY) {
1586 		/*
1587 		 * Filesystems can dirty the inode during writeback operations,
1588 		 * such as delayed allocation during submission or metadata
1589 		 * updates after data IO completion.
1590 		 */
1591 		redirty_tail_locked(inode, wb);
1592 	} else if (inode->i_state & I_DIRTY_TIME) {
1593 		inode->dirtied_when = jiffies;
1594 		inode_io_list_move_locked(inode, wb, &wb->b_dirty_time);
1595 		inode->i_state &= ~I_SYNC_QUEUED;
1596 	} else {
1597 		/* The inode is clean. Remove from writeback lists. */
1598 		inode_cgwb_move_to_attached(inode, wb);
1599 	}
1600 }
1601 
1602 /*
1603  * Write out an inode and its dirty pages (or some of its dirty pages, depending
1604  * on @wbc->nr_to_write), and clear the relevant dirty flags from i_state.
1605  *
1606  * This doesn't remove the inode from the writeback list it is on, except
1607  * potentially to move it from b_dirty_time to b_dirty due to timestamp
1608  * expiration.  The caller is otherwise responsible for writeback list handling.
1609  *
1610  * The caller is also responsible for setting the I_SYNC flag beforehand and
1611  * calling inode_sync_complete() to clear it afterwards.
1612  */
1613 static int
__writeback_single_inode(struct inode * inode,struct writeback_control * wbc)1614 __writeback_single_inode(struct inode *inode, struct writeback_control *wbc)
1615 {
1616 	struct address_space *mapping = inode->i_mapping;
1617 	long nr_to_write = wbc->nr_to_write;
1618 	unsigned dirty;
1619 	int ret;
1620 
1621 	WARN_ON(!(inode->i_state & I_SYNC));
1622 
1623 	trace_writeback_single_inode_start(inode, wbc, nr_to_write);
1624 
1625 	ret = do_writepages(mapping, wbc);
1626 
1627 	/*
1628 	 * Make sure to wait on the data before writing out the metadata.
1629 	 * This is important for filesystems that modify metadata on data
1630 	 * I/O completion. We don't do it for sync(2) writeback because it has a
1631 	 * separate, external IO completion path and ->sync_fs for guaranteeing
1632 	 * inode metadata is written back correctly.
1633 	 */
1634 	if (wbc->sync_mode == WB_SYNC_ALL && !wbc->for_sync) {
1635 		int err = filemap_fdatawait(mapping);
1636 		if (ret == 0)
1637 			ret = err;
1638 	}
1639 
1640 	/*
1641 	 * If the inode has dirty timestamps and we need to write them, call
1642 	 * mark_inode_dirty_sync() to notify the filesystem about it and to
1643 	 * change I_DIRTY_TIME into I_DIRTY_SYNC.
1644 	 */
1645 	if ((inode->i_state & I_DIRTY_TIME) &&
1646 	    (wbc->sync_mode == WB_SYNC_ALL ||
1647 	     time_after(jiffies, inode->dirtied_time_when +
1648 			dirtytime_expire_interval * HZ))) {
1649 		trace_writeback_lazytime(inode);
1650 		mark_inode_dirty_sync(inode);
1651 	}
1652 
1653 	/*
1654 	 * Get and clear the dirty flags from i_state.  This needs to be done
1655 	 * after calling writepages because some filesystems may redirty the
1656 	 * inode during writepages due to delalloc.  It also needs to be done
1657 	 * after handling timestamp expiration, as that may dirty the inode too.
1658 	 */
1659 	spin_lock(&inode->i_lock);
1660 	dirty = inode->i_state & I_DIRTY;
1661 	inode->i_state &= ~dirty;
1662 
1663 	/*
1664 	 * Paired with smp_mb() in __mark_inode_dirty().  This allows
1665 	 * __mark_inode_dirty() to test i_state without grabbing i_lock -
1666 	 * either they see the I_DIRTY bits cleared or we see the dirtied
1667 	 * inode.
1668 	 *
1669 	 * I_DIRTY_PAGES is always cleared together above even if @mapping
1670 	 * still has dirty pages.  The flag is reinstated after smp_mb() if
1671 	 * necessary.  This guarantees that either __mark_inode_dirty()
1672 	 * sees clear I_DIRTY_PAGES or we see PAGECACHE_TAG_DIRTY.
1673 	 */
1674 	smp_mb();
1675 
1676 	if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY))
1677 		inode->i_state |= I_DIRTY_PAGES;
1678 	else if (unlikely(inode->i_state & I_PINNING_FSCACHE_WB)) {
1679 		if (!(inode->i_state & I_DIRTY_PAGES)) {
1680 			inode->i_state &= ~I_PINNING_FSCACHE_WB;
1681 			wbc->unpinned_fscache_wb = true;
1682 			dirty |= I_PINNING_FSCACHE_WB; /* Cause write_inode */
1683 		}
1684 	}
1685 
1686 	spin_unlock(&inode->i_lock);
1687 
1688 	/* Don't write the inode if only I_DIRTY_PAGES was set */
1689 	if (dirty & ~I_DIRTY_PAGES) {
1690 		int err = write_inode(inode, wbc);
1691 		if (ret == 0)
1692 			ret = err;
1693 	}
1694 	wbc->unpinned_fscache_wb = false;
1695 	trace_writeback_single_inode(inode, wbc, nr_to_write);
1696 	return ret;
1697 }
1698 
1699 /*
1700  * Write out an inode's dirty data and metadata on-demand, i.e. separately from
1701  * the regular batched writeback done by the flusher threads in
1702  * writeback_sb_inodes().  @wbc controls various aspects of the write, such as
1703  * whether it is a data-integrity sync (%WB_SYNC_ALL) or not (%WB_SYNC_NONE).
1704  *
1705  * To prevent the inode from going away, either the caller must have a reference
1706  * to the inode, or the inode must have I_WILL_FREE or I_FREEING set.
1707  */
writeback_single_inode(struct inode * inode,struct writeback_control * wbc)1708 static int writeback_single_inode(struct inode *inode,
1709 				  struct writeback_control *wbc)
1710 {
1711 	struct bdi_writeback *wb;
1712 	int ret = 0;
1713 
1714 	spin_lock(&inode->i_lock);
1715 	if (!atomic_read(&inode->i_count))
1716 		WARN_ON(!(inode->i_state & (I_WILL_FREE|I_FREEING)));
1717 	else
1718 		WARN_ON(inode->i_state & I_WILL_FREE);
1719 
1720 	if (inode->i_state & I_SYNC) {
1721 		/*
1722 		 * Writeback is already running on the inode.  For WB_SYNC_NONE,
1723 		 * that's enough and we can just return.  For WB_SYNC_ALL, we
1724 		 * must wait for the existing writeback to complete, then do
1725 		 * writeback again if there's anything left.
1726 		 */
1727 		if (wbc->sync_mode != WB_SYNC_ALL)
1728 			goto out;
1729 		__inode_wait_for_writeback(inode);
1730 	}
1731 	WARN_ON(inode->i_state & I_SYNC);
1732 	/*
1733 	 * If the inode is already fully clean, then there's nothing to do.
1734 	 *
1735 	 * For data-integrity syncs we also need to check whether any pages are
1736 	 * still under writeback, e.g. due to prior WB_SYNC_NONE writeback.  If
1737 	 * there are any such pages, we'll need to wait for them.
1738 	 */
1739 	if (!(inode->i_state & I_DIRTY_ALL) &&
1740 	    (wbc->sync_mode != WB_SYNC_ALL ||
1741 	     !mapping_tagged(inode->i_mapping, PAGECACHE_TAG_WRITEBACK)))
1742 		goto out;
1743 	inode->i_state |= I_SYNC;
1744 	wbc_attach_and_unlock_inode(wbc, inode);
1745 
1746 	ret = __writeback_single_inode(inode, wbc);
1747 
1748 	wbc_detach_inode(wbc);
1749 
1750 	wb = inode_to_wb_and_lock_list(inode);
1751 	spin_lock(&inode->i_lock);
1752 	/*
1753 	 * If the inode is freeing, its i_io_list shoudn't be updated
1754 	 * as it can be finally deleted at this moment.
1755 	 */
1756 	if (!(inode->i_state & I_FREEING)) {
1757 		/*
1758 		 * If the inode is now fully clean, then it can be safely
1759 		 * removed from its writeback list (if any). Otherwise the
1760 		 * flusher threads are responsible for the writeback lists.
1761 		 */
1762 		if (!(inode->i_state & I_DIRTY_ALL))
1763 			inode_cgwb_move_to_attached(inode, wb);
1764 		else if (!(inode->i_state & I_SYNC_QUEUED)) {
1765 			if ((inode->i_state & I_DIRTY))
1766 				redirty_tail_locked(inode, wb);
1767 			else if (inode->i_state & I_DIRTY_TIME) {
1768 				inode->dirtied_when = jiffies;
1769 				inode_io_list_move_locked(inode,
1770 							  wb,
1771 							  &wb->b_dirty_time);
1772 			}
1773 		}
1774 	}
1775 
1776 	spin_unlock(&wb->list_lock);
1777 	inode_sync_complete(inode);
1778 out:
1779 	spin_unlock(&inode->i_lock);
1780 	return ret;
1781 }
1782 
writeback_chunk_size(struct bdi_writeback * wb,struct wb_writeback_work * work)1783 static long writeback_chunk_size(struct bdi_writeback *wb,
1784 				 struct wb_writeback_work *work)
1785 {
1786 	long pages;
1787 
1788 	/*
1789 	 * WB_SYNC_ALL mode does livelock avoidance by syncing dirty
1790 	 * inodes/pages in one big loop. Setting wbc.nr_to_write=LONG_MAX
1791 	 * here avoids calling into writeback_inodes_wb() more than once.
1792 	 *
1793 	 * The intended call sequence for WB_SYNC_ALL writeback is:
1794 	 *
1795 	 *      wb_writeback()
1796 	 *          writeback_sb_inodes()       <== called only once
1797 	 *              write_cache_pages()     <== called once for each inode
1798 	 *                   (quickly) tag currently dirty pages
1799 	 *                   (maybe slowly) sync all tagged pages
1800 	 */
1801 	if (work->sync_mode == WB_SYNC_ALL || work->tagged_writepages)
1802 		pages = LONG_MAX;
1803 	else {
1804 		pages = min(wb->avg_write_bandwidth / 2,
1805 			    global_wb_domain.dirty_limit / DIRTY_SCOPE);
1806 		pages = min(pages, work->nr_pages);
1807 		pages = round_down(pages + MIN_WRITEBACK_PAGES,
1808 				   MIN_WRITEBACK_PAGES);
1809 	}
1810 
1811 	return pages;
1812 }
1813 
1814 /*
1815  * Write a portion of b_io inodes which belong to @sb.
1816  *
1817  * Return the number of pages and/or inodes written.
1818  *
1819  * NOTE! This is called with wb->list_lock held, and will
1820  * unlock and relock that for each inode it ends up doing
1821  * IO for.
1822  */
writeback_sb_inodes(struct super_block * sb,struct bdi_writeback * wb,struct wb_writeback_work * work)1823 static long writeback_sb_inodes(struct super_block *sb,
1824 				struct bdi_writeback *wb,
1825 				struct wb_writeback_work *work)
1826 {
1827 	struct writeback_control wbc = {
1828 		.sync_mode		= work->sync_mode,
1829 		.tagged_writepages	= work->tagged_writepages,
1830 		.for_kupdate		= work->for_kupdate,
1831 		.for_background		= work->for_background,
1832 		.for_sync		= work->for_sync,
1833 		.range_cyclic		= work->range_cyclic,
1834 		.range_start		= 0,
1835 		.range_end		= LLONG_MAX,
1836 	};
1837 	unsigned long start_time = jiffies;
1838 	long write_chunk;
1839 	long total_wrote = 0;  /* count both pages and inodes */
1840 
1841 	while (!list_empty(&wb->b_io)) {
1842 		struct inode *inode = wb_inode(wb->b_io.prev);
1843 		struct bdi_writeback *tmp_wb;
1844 		long wrote;
1845 
1846 		if (inode->i_sb != sb) {
1847 			if (work->sb) {
1848 				/*
1849 				 * We only want to write back data for this
1850 				 * superblock, move all inodes not belonging
1851 				 * to it back onto the dirty list.
1852 				 */
1853 				redirty_tail(inode, wb);
1854 				continue;
1855 			}
1856 
1857 			/*
1858 			 * The inode belongs to a different superblock.
1859 			 * Bounce back to the caller to unpin this and
1860 			 * pin the next superblock.
1861 			 */
1862 			break;
1863 		}
1864 
1865 		/*
1866 		 * Don't bother with new inodes or inodes being freed, first
1867 		 * kind does not need periodic writeout yet, and for the latter
1868 		 * kind writeout is handled by the freer.
1869 		 */
1870 		spin_lock(&inode->i_lock);
1871 		if (inode->i_state & (I_NEW | I_FREEING | I_WILL_FREE)) {
1872 			redirty_tail_locked(inode, wb);
1873 			spin_unlock(&inode->i_lock);
1874 			continue;
1875 		}
1876 		if ((inode->i_state & I_SYNC) && wbc.sync_mode != WB_SYNC_ALL) {
1877 			/*
1878 			 * If this inode is locked for writeback and we are not
1879 			 * doing writeback-for-data-integrity, move it to
1880 			 * b_more_io so that writeback can proceed with the
1881 			 * other inodes on s_io.
1882 			 *
1883 			 * We'll have another go at writing back this inode
1884 			 * when we completed a full scan of b_io.
1885 			 */
1886 			requeue_io(inode, wb);
1887 			spin_unlock(&inode->i_lock);
1888 			trace_writeback_sb_inodes_requeue(inode);
1889 			continue;
1890 		}
1891 		spin_unlock(&wb->list_lock);
1892 
1893 		/*
1894 		 * We already requeued the inode if it had I_SYNC set and we
1895 		 * are doing WB_SYNC_NONE writeback. So this catches only the
1896 		 * WB_SYNC_ALL case.
1897 		 */
1898 		if (inode->i_state & I_SYNC) {
1899 			/* Wait for I_SYNC. This function drops i_lock... */
1900 			inode_sleep_on_writeback(inode);
1901 			/* Inode may be gone, start again */
1902 			spin_lock(&wb->list_lock);
1903 			continue;
1904 		}
1905 		inode->i_state |= I_SYNC;
1906 		wbc_attach_and_unlock_inode(&wbc, inode);
1907 
1908 		write_chunk = writeback_chunk_size(wb, work);
1909 		wbc.nr_to_write = write_chunk;
1910 		wbc.pages_skipped = 0;
1911 
1912 		/*
1913 		 * We use I_SYNC to pin the inode in memory. While it is set
1914 		 * evict_inode() will wait so the inode cannot be freed.
1915 		 */
1916 		__writeback_single_inode(inode, &wbc);
1917 
1918 		wbc_detach_inode(&wbc);
1919 		work->nr_pages -= write_chunk - wbc.nr_to_write;
1920 		wrote = write_chunk - wbc.nr_to_write - wbc.pages_skipped;
1921 		wrote = wrote < 0 ? 0 : wrote;
1922 		total_wrote += wrote;
1923 
1924 		if (need_resched()) {
1925 			/*
1926 			 * We're trying to balance between building up a nice
1927 			 * long list of IOs to improve our merge rate, and
1928 			 * getting those IOs out quickly for anyone throttling
1929 			 * in balance_dirty_pages().  cond_resched() doesn't
1930 			 * unplug, so get our IOs out the door before we
1931 			 * give up the CPU.
1932 			 */
1933 			blk_flush_plug(current->plug, false);
1934 			cond_resched();
1935 		}
1936 
1937 		/*
1938 		 * Requeue @inode if still dirty.  Be careful as @inode may
1939 		 * have been switched to another wb in the meantime.
1940 		 */
1941 		tmp_wb = inode_to_wb_and_lock_list(inode);
1942 		spin_lock(&inode->i_lock);
1943 		if (!(inode->i_state & I_DIRTY_ALL))
1944 			total_wrote++;
1945 		requeue_inode(inode, tmp_wb, &wbc);
1946 		inode_sync_complete(inode);
1947 		spin_unlock(&inode->i_lock);
1948 
1949 		if (unlikely(tmp_wb != wb)) {
1950 			spin_unlock(&tmp_wb->list_lock);
1951 			spin_lock(&wb->list_lock);
1952 		}
1953 
1954 		/*
1955 		 * bail out to wb_writeback() often enough to check
1956 		 * background threshold and other termination conditions.
1957 		 */
1958 		if (total_wrote) {
1959 			if (time_is_before_jiffies(start_time + HZ / 10UL))
1960 				break;
1961 			if (work->nr_pages <= 0)
1962 				break;
1963 		}
1964 	}
1965 	return total_wrote;
1966 }
1967 
__writeback_inodes_wb(struct bdi_writeback * wb,struct wb_writeback_work * work)1968 static long __writeback_inodes_wb(struct bdi_writeback *wb,
1969 				  struct wb_writeback_work *work)
1970 {
1971 	unsigned long start_time = jiffies;
1972 	long wrote = 0;
1973 
1974 	while (!list_empty(&wb->b_io)) {
1975 		struct inode *inode = wb_inode(wb->b_io.prev);
1976 		struct super_block *sb = inode->i_sb;
1977 
1978 		if (!super_trylock_shared(sb)) {
1979 			/*
1980 			 * super_trylock_shared() may fail consistently due to
1981 			 * s_umount being grabbed by someone else. Don't use
1982 			 * requeue_io() to avoid busy retrying the inode/sb.
1983 			 */
1984 			redirty_tail(inode, wb);
1985 			continue;
1986 		}
1987 		wrote += writeback_sb_inodes(sb, wb, work);
1988 		up_read(&sb->s_umount);
1989 
1990 		/* refer to the same tests at the end of writeback_sb_inodes */
1991 		if (wrote) {
1992 			if (time_is_before_jiffies(start_time + HZ / 10UL))
1993 				break;
1994 			if (work->nr_pages <= 0)
1995 				break;
1996 		}
1997 	}
1998 	/* Leave any unwritten inodes on b_io */
1999 	return wrote;
2000 }
2001 
writeback_inodes_wb(struct bdi_writeback * wb,long nr_pages,enum wb_reason reason)2002 static long writeback_inodes_wb(struct bdi_writeback *wb, long nr_pages,
2003 				enum wb_reason reason)
2004 {
2005 	struct wb_writeback_work work = {
2006 		.nr_pages	= nr_pages,
2007 		.sync_mode	= WB_SYNC_NONE,
2008 		.range_cyclic	= 1,
2009 		.reason		= reason,
2010 	};
2011 	struct blk_plug plug;
2012 
2013 	blk_start_plug(&plug);
2014 	spin_lock(&wb->list_lock);
2015 	if (list_empty(&wb->b_io))
2016 		queue_io(wb, &work, jiffies);
2017 	__writeback_inodes_wb(wb, &work);
2018 	spin_unlock(&wb->list_lock);
2019 	blk_finish_plug(&plug);
2020 
2021 	return nr_pages - work.nr_pages;
2022 }
2023 
2024 /*
2025  * Explicit flushing or periodic writeback of "old" data.
2026  *
2027  * Define "old": the first time one of an inode's pages is dirtied, we mark the
2028  * dirtying-time in the inode's address_space.  So this periodic writeback code
2029  * just walks the superblock inode list, writing back any inodes which are
2030  * older than a specific point in time.
2031  *
2032  * Try to run once per dirty_writeback_interval.  But if a writeback event
2033  * takes longer than a dirty_writeback_interval interval, then leave a
2034  * one-second gap.
2035  *
2036  * dirtied_before takes precedence over nr_to_write.  So we'll only write back
2037  * all dirty pages if they are all attached to "old" mappings.
2038  */
wb_writeback(struct bdi_writeback * wb,struct wb_writeback_work * work)2039 static long wb_writeback(struct bdi_writeback *wb,
2040 			 struct wb_writeback_work *work)
2041 {
2042 	long nr_pages = work->nr_pages;
2043 	unsigned long dirtied_before = jiffies;
2044 	struct inode *inode;
2045 	long progress;
2046 	struct blk_plug plug;
2047 	bool queued = false;
2048 
2049 	blk_start_plug(&plug);
2050 	for (;;) {
2051 		/*
2052 		 * Stop writeback when nr_pages has been consumed
2053 		 */
2054 		if (work->nr_pages <= 0)
2055 			break;
2056 
2057 		/*
2058 		 * Background writeout and kupdate-style writeback may
2059 		 * run forever. Stop them if there is other work to do
2060 		 * so that e.g. sync can proceed. They'll be restarted
2061 		 * after the other works are all done.
2062 		 */
2063 		if ((work->for_background || work->for_kupdate) &&
2064 		    !list_empty(&wb->work_list))
2065 			break;
2066 
2067 		/*
2068 		 * For background writeout, stop when we are below the
2069 		 * background dirty threshold
2070 		 */
2071 		if (work->for_background && !wb_over_bg_thresh(wb))
2072 			break;
2073 
2074 
2075 		spin_lock(&wb->list_lock);
2076 
2077 		/*
2078 		 * Kupdate and background works are special and we want to
2079 		 * include all inodes that need writing. Livelock avoidance is
2080 		 * handled by these works yielding to any other work so we are
2081 		 * safe.
2082 		 */
2083 		if (work->for_kupdate) {
2084 			dirtied_before = jiffies -
2085 				msecs_to_jiffies(dirty_expire_interval * 10);
2086 		} else if (work->for_background)
2087 			dirtied_before = jiffies;
2088 
2089 		trace_writeback_start(wb, work);
2090 		if (list_empty(&wb->b_io)) {
2091 			queue_io(wb, work, dirtied_before);
2092 			queued = true;
2093 		}
2094 		if (work->sb)
2095 			progress = writeback_sb_inodes(work->sb, wb, work);
2096 		else
2097 			progress = __writeback_inodes_wb(wb, work);
2098 		trace_writeback_written(wb, work);
2099 
2100 		/*
2101 		 * Did we write something? Try for more
2102 		 *
2103 		 * Dirty inodes are moved to b_io for writeback in batches.
2104 		 * The completion of the current batch does not necessarily
2105 		 * mean the overall work is done. So we keep looping as long
2106 		 * as made some progress on cleaning pages or inodes.
2107 		 */
2108 		if (progress || !queued) {
2109 			spin_unlock(&wb->list_lock);
2110 			continue;
2111 		}
2112 
2113 		/*
2114 		 * No more inodes for IO, bail
2115 		 */
2116 		if (list_empty(&wb->b_more_io)) {
2117 			spin_unlock(&wb->list_lock);
2118 			break;
2119 		}
2120 
2121 		/*
2122 		 * Nothing written. Wait for some inode to
2123 		 * become available for writeback. Otherwise
2124 		 * we'll just busyloop.
2125 		 */
2126 		trace_writeback_wait(wb, work);
2127 		inode = wb_inode(wb->b_more_io.prev);
2128 		spin_lock(&inode->i_lock);
2129 		spin_unlock(&wb->list_lock);
2130 		/* This function drops i_lock... */
2131 		inode_sleep_on_writeback(inode);
2132 	}
2133 	blk_finish_plug(&plug);
2134 
2135 	return nr_pages - work->nr_pages;
2136 }
2137 
2138 /*
2139  * Return the next wb_writeback_work struct that hasn't been processed yet.
2140  */
get_next_work_item(struct bdi_writeback * wb)2141 static struct wb_writeback_work *get_next_work_item(struct bdi_writeback *wb)
2142 {
2143 	struct wb_writeback_work *work = NULL;
2144 
2145 	spin_lock_irq(&wb->work_lock);
2146 	if (!list_empty(&wb->work_list)) {
2147 		work = list_entry(wb->work_list.next,
2148 				  struct wb_writeback_work, list);
2149 		list_del_init(&work->list);
2150 	}
2151 	spin_unlock_irq(&wb->work_lock);
2152 	return work;
2153 }
2154 
wb_check_background_flush(struct bdi_writeback * wb)2155 static long wb_check_background_flush(struct bdi_writeback *wb)
2156 {
2157 	if (wb_over_bg_thresh(wb)) {
2158 
2159 		struct wb_writeback_work work = {
2160 			.nr_pages	= LONG_MAX,
2161 			.sync_mode	= WB_SYNC_NONE,
2162 			.for_background	= 1,
2163 			.range_cyclic	= 1,
2164 			.reason		= WB_REASON_BACKGROUND,
2165 		};
2166 
2167 		return wb_writeback(wb, &work);
2168 	}
2169 
2170 	return 0;
2171 }
2172 
wb_check_old_data_flush(struct bdi_writeback * wb)2173 static long wb_check_old_data_flush(struct bdi_writeback *wb)
2174 {
2175 	unsigned long expired;
2176 	long nr_pages;
2177 
2178 	/*
2179 	 * When set to zero, disable periodic writeback
2180 	 */
2181 	if (!dirty_writeback_interval)
2182 		return 0;
2183 
2184 	expired = wb->last_old_flush +
2185 			msecs_to_jiffies(dirty_writeback_interval * 10);
2186 	if (time_before(jiffies, expired))
2187 		return 0;
2188 
2189 	wb->last_old_flush = jiffies;
2190 	nr_pages = get_nr_dirty_pages();
2191 
2192 	if (nr_pages) {
2193 		struct wb_writeback_work work = {
2194 			.nr_pages	= nr_pages,
2195 			.sync_mode	= WB_SYNC_NONE,
2196 			.for_kupdate	= 1,
2197 			.range_cyclic	= 1,
2198 			.reason		= WB_REASON_PERIODIC,
2199 		};
2200 
2201 		return wb_writeback(wb, &work);
2202 	}
2203 
2204 	return 0;
2205 }
2206 
wb_check_start_all(struct bdi_writeback * wb)2207 static long wb_check_start_all(struct bdi_writeback *wb)
2208 {
2209 	long nr_pages;
2210 
2211 	if (!test_bit(WB_start_all, &wb->state))
2212 		return 0;
2213 
2214 	nr_pages = get_nr_dirty_pages();
2215 	if (nr_pages) {
2216 		struct wb_writeback_work work = {
2217 			.nr_pages	= wb_split_bdi_pages(wb, nr_pages),
2218 			.sync_mode	= WB_SYNC_NONE,
2219 			.range_cyclic	= 1,
2220 			.reason		= wb->start_all_reason,
2221 		};
2222 
2223 		nr_pages = wb_writeback(wb, &work);
2224 	}
2225 
2226 	clear_bit(WB_start_all, &wb->state);
2227 	return nr_pages;
2228 }
2229 
2230 
2231 /*
2232  * Retrieve work items and do the writeback they describe
2233  */
wb_do_writeback(struct bdi_writeback * wb)2234 static long wb_do_writeback(struct bdi_writeback *wb)
2235 {
2236 	struct wb_writeback_work *work;
2237 	long wrote = 0;
2238 
2239 	set_bit(WB_writeback_running, &wb->state);
2240 	while ((work = get_next_work_item(wb)) != NULL) {
2241 		trace_writeback_exec(wb, work);
2242 		wrote += wb_writeback(wb, work);
2243 		finish_writeback_work(wb, work);
2244 	}
2245 
2246 	/*
2247 	 * Check for a flush-everything request
2248 	 */
2249 	wrote += wb_check_start_all(wb);
2250 
2251 	/*
2252 	 * Check for periodic writeback, kupdated() style
2253 	 */
2254 	wrote += wb_check_old_data_flush(wb);
2255 	wrote += wb_check_background_flush(wb);
2256 	clear_bit(WB_writeback_running, &wb->state);
2257 
2258 	return wrote;
2259 }
2260 
2261 /*
2262  * Handle writeback of dirty data for the device backed by this bdi. Also
2263  * reschedules periodically and does kupdated style flushing.
2264  */
wb_workfn(struct work_struct * work)2265 void wb_workfn(struct work_struct *work)
2266 {
2267 	struct bdi_writeback *wb = container_of(to_delayed_work(work),
2268 						struct bdi_writeback, dwork);
2269 	long pages_written;
2270 
2271 	set_worker_desc("flush-%s", bdi_dev_name(wb->bdi));
2272 
2273 	if (likely(!current_is_workqueue_rescuer() ||
2274 		   !test_bit(WB_registered, &wb->state))) {
2275 		/*
2276 		 * The normal path.  Keep writing back @wb until its
2277 		 * work_list is empty.  Note that this path is also taken
2278 		 * if @wb is shutting down even when we're running off the
2279 		 * rescuer as work_list needs to be drained.
2280 		 */
2281 		do {
2282 			pages_written = wb_do_writeback(wb);
2283 			trace_writeback_pages_written(pages_written);
2284 		} while (!list_empty(&wb->work_list));
2285 	} else {
2286 		/*
2287 		 * bdi_wq can't get enough workers and we're running off
2288 		 * the emergency worker.  Don't hog it.  Hopefully, 1024 is
2289 		 * enough for efficient IO.
2290 		 */
2291 		pages_written = writeback_inodes_wb(wb, 1024,
2292 						    WB_REASON_FORKER_THREAD);
2293 		trace_writeback_pages_written(pages_written);
2294 	}
2295 
2296 	if (!list_empty(&wb->work_list))
2297 		wb_wakeup(wb);
2298 	else if (wb_has_dirty_io(wb) && dirty_writeback_interval)
2299 		wb_wakeup_delayed(wb);
2300 }
2301 
2302 /*
2303  * Start writeback of `nr_pages' pages on this bdi. If `nr_pages' is zero,
2304  * write back the whole world.
2305  */
__wakeup_flusher_threads_bdi(struct backing_dev_info * bdi,enum wb_reason reason)2306 static void __wakeup_flusher_threads_bdi(struct backing_dev_info *bdi,
2307 					 enum wb_reason reason)
2308 {
2309 	struct bdi_writeback *wb;
2310 
2311 	if (!bdi_has_dirty_io(bdi))
2312 		return;
2313 
2314 	list_for_each_entry_rcu(wb, &bdi->wb_list, bdi_node)
2315 		wb_start_writeback(wb, reason);
2316 }
2317 
wakeup_flusher_threads_bdi(struct backing_dev_info * bdi,enum wb_reason reason)2318 void wakeup_flusher_threads_bdi(struct backing_dev_info *bdi,
2319 				enum wb_reason reason)
2320 {
2321 	rcu_read_lock();
2322 	__wakeup_flusher_threads_bdi(bdi, reason);
2323 	rcu_read_unlock();
2324 }
2325 
2326 /*
2327  * Wakeup the flusher threads to start writeback of all currently dirty pages
2328  */
wakeup_flusher_threads(enum wb_reason reason)2329 void wakeup_flusher_threads(enum wb_reason reason)
2330 {
2331 	struct backing_dev_info *bdi;
2332 
2333 	/*
2334 	 * If we are expecting writeback progress we must submit plugged IO.
2335 	 */
2336 	blk_flush_plug(current->plug, true);
2337 
2338 	rcu_read_lock();
2339 	list_for_each_entry_rcu(bdi, &bdi_list, bdi_list)
2340 		__wakeup_flusher_threads_bdi(bdi, reason);
2341 	rcu_read_unlock();
2342 }
2343 
2344 /*
2345  * Wake up bdi's periodically to make sure dirtytime inodes gets
2346  * written back periodically.  We deliberately do *not* check the
2347  * b_dirtytime list in wb_has_dirty_io(), since this would cause the
2348  * kernel to be constantly waking up once there are any dirtytime
2349  * inodes on the system.  So instead we define a separate delayed work
2350  * function which gets called much more rarely.  (By default, only
2351  * once every 12 hours.)
2352  *
2353  * If there is any other write activity going on in the file system,
2354  * this function won't be necessary.  But if the only thing that has
2355  * happened on the file system is a dirtytime inode caused by an atime
2356  * update, we need this infrastructure below to make sure that inode
2357  * eventually gets pushed out to disk.
2358  */
2359 static void wakeup_dirtytime_writeback(struct work_struct *w);
2360 static DECLARE_DELAYED_WORK(dirtytime_work, wakeup_dirtytime_writeback);
2361 
wakeup_dirtytime_writeback(struct work_struct * w)2362 static void wakeup_dirtytime_writeback(struct work_struct *w)
2363 {
2364 	struct backing_dev_info *bdi;
2365 
2366 	rcu_read_lock();
2367 	list_for_each_entry_rcu(bdi, &bdi_list, bdi_list) {
2368 		struct bdi_writeback *wb;
2369 
2370 		list_for_each_entry_rcu(wb, &bdi->wb_list, bdi_node)
2371 			if (!list_empty(&wb->b_dirty_time))
2372 				wb_wakeup(wb);
2373 	}
2374 	rcu_read_unlock();
2375 	schedule_delayed_work(&dirtytime_work, dirtytime_expire_interval * HZ);
2376 }
2377 
start_dirtytime_writeback(void)2378 static int __init start_dirtytime_writeback(void)
2379 {
2380 	schedule_delayed_work(&dirtytime_work, dirtytime_expire_interval * HZ);
2381 	return 0;
2382 }
2383 __initcall(start_dirtytime_writeback);
2384 
dirtytime_interval_handler(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)2385 int dirtytime_interval_handler(struct ctl_table *table, int write,
2386 			       void *buffer, size_t *lenp, loff_t *ppos)
2387 {
2388 	int ret;
2389 
2390 	ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
2391 	if (ret == 0 && write)
2392 		mod_delayed_work(system_wq, &dirtytime_work, 0);
2393 	return ret;
2394 }
2395 
2396 /**
2397  * __mark_inode_dirty -	internal function to mark an inode dirty
2398  *
2399  * @inode: inode to mark
2400  * @flags: what kind of dirty, e.g. I_DIRTY_SYNC.  This can be a combination of
2401  *	   multiple I_DIRTY_* flags, except that I_DIRTY_TIME can't be combined
2402  *	   with I_DIRTY_PAGES.
2403  *
2404  * Mark an inode as dirty.  We notify the filesystem, then update the inode's
2405  * dirty flags.  Then, if needed we add the inode to the appropriate dirty list.
2406  *
2407  * Most callers should use mark_inode_dirty() or mark_inode_dirty_sync()
2408  * instead of calling this directly.
2409  *
2410  * CAREFUL!  We only add the inode to the dirty list if it is hashed or if it
2411  * refers to a blockdev.  Unhashed inodes will never be added to the dirty list
2412  * even if they are later hashed, as they will have been marked dirty already.
2413  *
2414  * In short, ensure you hash any inodes _before_ you start marking them dirty.
2415  *
2416  * Note that for blockdevs, inode->dirtied_when represents the dirtying time of
2417  * the block-special inode (/dev/hda1) itself.  And the ->dirtied_when field of
2418  * the kernel-internal blockdev inode represents the dirtying time of the
2419  * blockdev's pages.  This is why for I_DIRTY_PAGES we always use
2420  * page->mapping->host, so the page-dirtying time is recorded in the internal
2421  * blockdev inode.
2422  */
__mark_inode_dirty(struct inode * inode,int flags)2423 void __mark_inode_dirty(struct inode *inode, int flags)
2424 {
2425 	struct super_block *sb = inode->i_sb;
2426 	int dirtytime = 0;
2427 	struct bdi_writeback *wb = NULL;
2428 
2429 	trace_writeback_mark_inode_dirty(inode, flags);
2430 
2431 	if (flags & I_DIRTY_INODE) {
2432 		/*
2433 		 * Inode timestamp update will piggback on this dirtying.
2434 		 * We tell ->dirty_inode callback that timestamps need to
2435 		 * be updated by setting I_DIRTY_TIME in flags.
2436 		 */
2437 		if (inode->i_state & I_DIRTY_TIME) {
2438 			spin_lock(&inode->i_lock);
2439 			if (inode->i_state & I_DIRTY_TIME) {
2440 				inode->i_state &= ~I_DIRTY_TIME;
2441 				flags |= I_DIRTY_TIME;
2442 			}
2443 			spin_unlock(&inode->i_lock);
2444 		}
2445 
2446 		/*
2447 		 * Notify the filesystem about the inode being dirtied, so that
2448 		 * (if needed) it can update on-disk fields and journal the
2449 		 * inode.  This is only needed when the inode itself is being
2450 		 * dirtied now.  I.e. it's only needed for I_DIRTY_INODE, not
2451 		 * for just I_DIRTY_PAGES or I_DIRTY_TIME.
2452 		 */
2453 		trace_writeback_dirty_inode_start(inode, flags);
2454 		if (sb->s_op->dirty_inode)
2455 			sb->s_op->dirty_inode(inode,
2456 				flags & (I_DIRTY_INODE | I_DIRTY_TIME));
2457 		trace_writeback_dirty_inode(inode, flags);
2458 
2459 		/* I_DIRTY_INODE supersedes I_DIRTY_TIME. */
2460 		flags &= ~I_DIRTY_TIME;
2461 	} else {
2462 		/*
2463 		 * Else it's either I_DIRTY_PAGES, I_DIRTY_TIME, or nothing.
2464 		 * (We don't support setting both I_DIRTY_PAGES and I_DIRTY_TIME
2465 		 * in one call to __mark_inode_dirty().)
2466 		 */
2467 		dirtytime = flags & I_DIRTY_TIME;
2468 		WARN_ON_ONCE(dirtytime && flags != I_DIRTY_TIME);
2469 	}
2470 
2471 	/*
2472 	 * Paired with smp_mb() in __writeback_single_inode() for the
2473 	 * following lockless i_state test.  See there for details.
2474 	 */
2475 	smp_mb();
2476 
2477 	if ((inode->i_state & flags) == flags)
2478 		return;
2479 
2480 	spin_lock(&inode->i_lock);
2481 	if ((inode->i_state & flags) != flags) {
2482 		const int was_dirty = inode->i_state & I_DIRTY;
2483 
2484 		inode_attach_wb(inode, NULL);
2485 
2486 		inode->i_state |= flags;
2487 
2488 		/*
2489 		 * Grab inode's wb early because it requires dropping i_lock and we
2490 		 * need to make sure following checks happen atomically with dirty
2491 		 * list handling so that we don't move inodes under flush worker's
2492 		 * hands.
2493 		 */
2494 		if (!was_dirty) {
2495 			wb = locked_inode_to_wb_and_lock_list(inode);
2496 			spin_lock(&inode->i_lock);
2497 		}
2498 
2499 		/*
2500 		 * If the inode is queued for writeback by flush worker, just
2501 		 * update its dirty state. Once the flush worker is done with
2502 		 * the inode it will place it on the appropriate superblock
2503 		 * list, based upon its state.
2504 		 */
2505 		if (inode->i_state & I_SYNC_QUEUED)
2506 			goto out_unlock;
2507 
2508 		/*
2509 		 * Only add valid (hashed) inodes to the superblock's
2510 		 * dirty list.  Add blockdev inodes as well.
2511 		 */
2512 		if (!S_ISBLK(inode->i_mode)) {
2513 			if (inode_unhashed(inode))
2514 				goto out_unlock;
2515 		}
2516 		if (inode->i_state & I_FREEING)
2517 			goto out_unlock;
2518 
2519 		/*
2520 		 * If the inode was already on b_dirty/b_io/b_more_io, don't
2521 		 * reposition it (that would break b_dirty time-ordering).
2522 		 */
2523 		if (!was_dirty) {
2524 			struct list_head *dirty_list;
2525 			bool wakeup_bdi = false;
2526 
2527 			inode->dirtied_when = jiffies;
2528 			if (dirtytime)
2529 				inode->dirtied_time_when = jiffies;
2530 
2531 			if (inode->i_state & I_DIRTY)
2532 				dirty_list = &wb->b_dirty;
2533 			else
2534 				dirty_list = &wb->b_dirty_time;
2535 
2536 			wakeup_bdi = inode_io_list_move_locked(inode, wb,
2537 							       dirty_list);
2538 
2539 			spin_unlock(&wb->list_lock);
2540 			spin_unlock(&inode->i_lock);
2541 			trace_writeback_dirty_inode_enqueue(inode);
2542 
2543 			/*
2544 			 * If this is the first dirty inode for this bdi,
2545 			 * we have to wake-up the corresponding bdi thread
2546 			 * to make sure background write-back happens
2547 			 * later.
2548 			 */
2549 			if (wakeup_bdi &&
2550 			    (wb->bdi->capabilities & BDI_CAP_WRITEBACK))
2551 				wb_wakeup_delayed(wb);
2552 			return;
2553 		}
2554 	}
2555 out_unlock:
2556 	if (wb)
2557 		spin_unlock(&wb->list_lock);
2558 	spin_unlock(&inode->i_lock);
2559 }
2560 EXPORT_SYMBOL(__mark_inode_dirty);
2561 
2562 /*
2563  * The @s_sync_lock is used to serialise concurrent sync operations
2564  * to avoid lock contention problems with concurrent wait_sb_inodes() calls.
2565  * Concurrent callers will block on the s_sync_lock rather than doing contending
2566  * walks. The queueing maintains sync(2) required behaviour as all the IO that
2567  * has been issued up to the time this function is enter is guaranteed to be
2568  * completed by the time we have gained the lock and waited for all IO that is
2569  * in progress regardless of the order callers are granted the lock.
2570  */
wait_sb_inodes(struct super_block * sb)2571 static void wait_sb_inodes(struct super_block *sb)
2572 {
2573 	LIST_HEAD(sync_list);
2574 
2575 	/*
2576 	 * We need to be protected against the filesystem going from
2577 	 * r/o to r/w or vice versa.
2578 	 */
2579 	WARN_ON(!rwsem_is_locked(&sb->s_umount));
2580 
2581 	mutex_lock(&sb->s_sync_lock);
2582 
2583 	/*
2584 	 * Splice the writeback list onto a temporary list to avoid waiting on
2585 	 * inodes that have started writeback after this point.
2586 	 *
2587 	 * Use rcu_read_lock() to keep the inodes around until we have a
2588 	 * reference. s_inode_wblist_lock protects sb->s_inodes_wb as well as
2589 	 * the local list because inodes can be dropped from either by writeback
2590 	 * completion.
2591 	 */
2592 	rcu_read_lock();
2593 	spin_lock_irq(&sb->s_inode_wblist_lock);
2594 	list_splice_init(&sb->s_inodes_wb, &sync_list);
2595 
2596 	/*
2597 	 * Data integrity sync. Must wait for all pages under writeback, because
2598 	 * there may have been pages dirtied before our sync call, but which had
2599 	 * writeout started before we write it out.  In which case, the inode
2600 	 * may not be on the dirty list, but we still have to wait for that
2601 	 * writeout.
2602 	 */
2603 	while (!list_empty(&sync_list)) {
2604 		struct inode *inode = list_first_entry(&sync_list, struct inode,
2605 						       i_wb_list);
2606 		struct address_space *mapping = inode->i_mapping;
2607 
2608 		/*
2609 		 * Move each inode back to the wb list before we drop the lock
2610 		 * to preserve consistency between i_wb_list and the mapping
2611 		 * writeback tag. Writeback completion is responsible to remove
2612 		 * the inode from either list once the writeback tag is cleared.
2613 		 */
2614 		list_move_tail(&inode->i_wb_list, &sb->s_inodes_wb);
2615 
2616 		/*
2617 		 * The mapping can appear untagged while still on-list since we
2618 		 * do not have the mapping lock. Skip it here, wb completion
2619 		 * will remove it.
2620 		 */
2621 		if (!mapping_tagged(mapping, PAGECACHE_TAG_WRITEBACK))
2622 			continue;
2623 
2624 		spin_unlock_irq(&sb->s_inode_wblist_lock);
2625 
2626 		spin_lock(&inode->i_lock);
2627 		if (inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) {
2628 			spin_unlock(&inode->i_lock);
2629 
2630 			spin_lock_irq(&sb->s_inode_wblist_lock);
2631 			continue;
2632 		}
2633 		__iget(inode);
2634 		spin_unlock(&inode->i_lock);
2635 		rcu_read_unlock();
2636 
2637 		/*
2638 		 * We keep the error status of individual mapping so that
2639 		 * applications can catch the writeback error using fsync(2).
2640 		 * See filemap_fdatawait_keep_errors() for details.
2641 		 */
2642 		filemap_fdatawait_keep_errors(mapping);
2643 
2644 		cond_resched();
2645 
2646 		iput(inode);
2647 
2648 		rcu_read_lock();
2649 		spin_lock_irq(&sb->s_inode_wblist_lock);
2650 	}
2651 	spin_unlock_irq(&sb->s_inode_wblist_lock);
2652 	rcu_read_unlock();
2653 	mutex_unlock(&sb->s_sync_lock);
2654 }
2655 
__writeback_inodes_sb_nr(struct super_block * sb,unsigned long nr,enum wb_reason reason,bool skip_if_busy)2656 static void __writeback_inodes_sb_nr(struct super_block *sb, unsigned long nr,
2657 				     enum wb_reason reason, bool skip_if_busy)
2658 {
2659 	struct backing_dev_info *bdi = sb->s_bdi;
2660 	DEFINE_WB_COMPLETION(done, bdi);
2661 	struct wb_writeback_work work = {
2662 		.sb			= sb,
2663 		.sync_mode		= WB_SYNC_NONE,
2664 		.tagged_writepages	= 1,
2665 		.done			= &done,
2666 		.nr_pages		= nr,
2667 		.reason			= reason,
2668 	};
2669 
2670 	if (!bdi_has_dirty_io(bdi) || bdi == &noop_backing_dev_info)
2671 		return;
2672 	WARN_ON(!rwsem_is_locked(&sb->s_umount));
2673 
2674 	bdi_split_work_to_wbs(sb->s_bdi, &work, skip_if_busy);
2675 	wb_wait_for_completion(&done);
2676 }
2677 
2678 /**
2679  * writeback_inodes_sb_nr -	writeback dirty inodes from given super_block
2680  * @sb: the superblock
2681  * @nr: the number of pages to write
2682  * @reason: reason why some writeback work initiated
2683  *
2684  * Start writeback on some inodes on this super_block. No guarantees are made
2685  * on how many (if any) will be written, and this function does not wait
2686  * for IO completion of submitted IO.
2687  */
writeback_inodes_sb_nr(struct super_block * sb,unsigned long nr,enum wb_reason reason)2688 void writeback_inodes_sb_nr(struct super_block *sb,
2689 			    unsigned long nr,
2690 			    enum wb_reason reason)
2691 {
2692 	__writeback_inodes_sb_nr(sb, nr, reason, false);
2693 }
2694 EXPORT_SYMBOL(writeback_inodes_sb_nr);
2695 
2696 /**
2697  * writeback_inodes_sb	-	writeback dirty inodes from given super_block
2698  * @sb: the superblock
2699  * @reason: reason why some writeback work was initiated
2700  *
2701  * Start writeback on some inodes on this super_block. No guarantees are made
2702  * on how many (if any) will be written, and this function does not wait
2703  * for IO completion of submitted IO.
2704  */
writeback_inodes_sb(struct super_block * sb,enum wb_reason reason)2705 void writeback_inodes_sb(struct super_block *sb, enum wb_reason reason)
2706 {
2707 	return writeback_inodes_sb_nr(sb, get_nr_dirty_pages(), reason);
2708 }
2709 EXPORT_SYMBOL(writeback_inodes_sb);
2710 
2711 /**
2712  * try_to_writeback_inodes_sb - try to start writeback if none underway
2713  * @sb: the superblock
2714  * @reason: reason why some writeback work was initiated
2715  *
2716  * Invoke __writeback_inodes_sb_nr if no writeback is currently underway.
2717  */
try_to_writeback_inodes_sb(struct super_block * sb,enum wb_reason reason)2718 void try_to_writeback_inodes_sb(struct super_block *sb, enum wb_reason reason)
2719 {
2720 	if (!down_read_trylock(&sb->s_umount))
2721 		return;
2722 
2723 	__writeback_inodes_sb_nr(sb, get_nr_dirty_pages(), reason, true);
2724 	up_read(&sb->s_umount);
2725 }
2726 EXPORT_SYMBOL(try_to_writeback_inodes_sb);
2727 
2728 /**
2729  * sync_inodes_sb	-	sync sb inode pages
2730  * @sb: the superblock
2731  *
2732  * This function writes and waits on any dirty inode belonging to this
2733  * super_block.
2734  */
sync_inodes_sb(struct super_block * sb)2735 void sync_inodes_sb(struct super_block *sb)
2736 {
2737 	struct backing_dev_info *bdi = sb->s_bdi;
2738 	DEFINE_WB_COMPLETION(done, bdi);
2739 	struct wb_writeback_work work = {
2740 		.sb		= sb,
2741 		.sync_mode	= WB_SYNC_ALL,
2742 		.nr_pages	= LONG_MAX,
2743 		.range_cyclic	= 0,
2744 		.done		= &done,
2745 		.reason		= WB_REASON_SYNC,
2746 		.for_sync	= 1,
2747 	};
2748 
2749 	/*
2750 	 * Can't skip on !bdi_has_dirty() because we should wait for !dirty
2751 	 * inodes under writeback and I_DIRTY_TIME inodes ignored by
2752 	 * bdi_has_dirty() need to be written out too.
2753 	 */
2754 	if (bdi == &noop_backing_dev_info)
2755 		return;
2756 	WARN_ON(!rwsem_is_locked(&sb->s_umount));
2757 
2758 	/* protect against inode wb switch, see inode_switch_wbs_work_fn() */
2759 	bdi_down_write_wb_switch_rwsem(bdi);
2760 	bdi_split_work_to_wbs(bdi, &work, false);
2761 	wb_wait_for_completion(&done);
2762 	bdi_up_write_wb_switch_rwsem(bdi);
2763 
2764 	wait_sb_inodes(sb);
2765 }
2766 EXPORT_SYMBOL(sync_inodes_sb);
2767 
2768 /**
2769  * write_inode_now	-	write an inode to disk
2770  * @inode: inode to write to disk
2771  * @sync: whether the write should be synchronous or not
2772  *
2773  * This function commits an inode to disk immediately if it is dirty. This is
2774  * primarily needed by knfsd.
2775  *
2776  * The caller must either have a ref on the inode or must have set I_WILL_FREE.
2777  */
write_inode_now(struct inode * inode,int sync)2778 int write_inode_now(struct inode *inode, int sync)
2779 {
2780 	struct writeback_control wbc = {
2781 		.nr_to_write = LONG_MAX,
2782 		.sync_mode = sync ? WB_SYNC_ALL : WB_SYNC_NONE,
2783 		.range_start = 0,
2784 		.range_end = LLONG_MAX,
2785 	};
2786 
2787 	if (!mapping_can_writeback(inode->i_mapping))
2788 		wbc.nr_to_write = 0;
2789 
2790 	might_sleep();
2791 	return writeback_single_inode(inode, &wbc);
2792 }
2793 EXPORT_SYMBOL(write_inode_now);
2794 
2795 /**
2796  * sync_inode_metadata - write an inode to disk
2797  * @inode: the inode to sync
2798  * @wait: wait for I/O to complete.
2799  *
2800  * Write an inode to disk and adjust its dirty state after completion.
2801  *
2802  * Note: only writes the actual inode, no associated data or other metadata.
2803  */
sync_inode_metadata(struct inode * inode,int wait)2804 int sync_inode_metadata(struct inode *inode, int wait)
2805 {
2806 	struct writeback_control wbc = {
2807 		.sync_mode = wait ? WB_SYNC_ALL : WB_SYNC_NONE,
2808 		.nr_to_write = 0, /* metadata-only */
2809 	};
2810 
2811 	return writeback_single_inode(inode, &wbc);
2812 }
2813 EXPORT_SYMBOL(sync_inode_metadata);
2814