xref: /openbmc/linux/fs/fs-writeback.c (revision f0fad8a5)
11da177e4SLinus Torvalds /*
21da177e4SLinus Torvalds  * fs/fs-writeback.c
31da177e4SLinus Torvalds  *
41da177e4SLinus Torvalds  * Copyright (C) 2002, Linus Torvalds.
51da177e4SLinus Torvalds  *
61da177e4SLinus Torvalds  * Contains all the functions related to writing back and waiting
71da177e4SLinus Torvalds  * upon dirty inodes against superblocks, and writing back dirty
81da177e4SLinus Torvalds  * pages against inodes.  ie: data writeback.  Writeout of the
91da177e4SLinus Torvalds  * inode itself is not handled here.
101da177e4SLinus Torvalds  *
11e1f8e874SFrancois Cami  * 10Apr2002	Andrew Morton
121da177e4SLinus Torvalds  *		Split out of fs/inode.c
131da177e4SLinus Torvalds  *		Additions for address_space-based writeback
141da177e4SLinus Torvalds  */
151da177e4SLinus Torvalds 
161da177e4SLinus Torvalds #include <linux/kernel.h>
17f5ff8422SJens Axboe #include <linux/module.h>
181da177e4SLinus Torvalds #include <linux/spinlock.h>
191da177e4SLinus Torvalds #include <linux/sched.h>
201da177e4SLinus Torvalds #include <linux/fs.h>
211da177e4SLinus Torvalds #include <linux/mm.h>
2203ba3782SJens Axboe #include <linux/kthread.h>
2303ba3782SJens Axboe #include <linux/freezer.h>
241da177e4SLinus Torvalds #include <linux/writeback.h>
251da177e4SLinus Torvalds #include <linux/blkdev.h>
261da177e4SLinus Torvalds #include <linux/backing-dev.h>
271da177e4SLinus Torvalds #include <linux/buffer_head.h>
2807f3f05cSDavid Howells #include "internal.h"
291da177e4SLinus Torvalds 
3066f3b8e2SJens Axboe #define inode_to_bdi(inode)	((inode)->i_mapping->backing_dev_info)
31f11b00f3SAdrian Bunk 
3203ba3782SJens Axboe /*
33d0bceac7SJens Axboe  * We don't actually have pdflush, but this one is exported though /proc...
34d0bceac7SJens Axboe  */
35d0bceac7SJens Axboe int nr_pdflush_threads;
36d0bceac7SJens Axboe 
37d0bceac7SJens Axboe /*
3803ba3782SJens Axboe  * Work items for the bdi_writeback threads
39f11b00f3SAdrian Bunk  */
4003ba3782SJens Axboe struct bdi_work {
4103ba3782SJens Axboe 	struct list_head list;
4203ba3782SJens Axboe 	struct list_head wait_list;
4303ba3782SJens Axboe 	struct rcu_head rcu_head;
4403ba3782SJens Axboe 
4503ba3782SJens Axboe 	unsigned long seen;
4603ba3782SJens Axboe 	atomic_t pending;
4703ba3782SJens Axboe 
4803ba3782SJens Axboe 	struct super_block *sb;
4903ba3782SJens Axboe 	unsigned long nr_pages;
5003ba3782SJens Axboe 	enum writeback_sync_modes sync_mode;
5103ba3782SJens Axboe 
5203ba3782SJens Axboe 	unsigned long state;
5303ba3782SJens Axboe };
5403ba3782SJens Axboe 
5503ba3782SJens Axboe enum {
5603ba3782SJens Axboe 	WS_USED_B = 0,
5703ba3782SJens Axboe 	WS_ONSTACK_B,
5803ba3782SJens Axboe };
5903ba3782SJens Axboe 
6003ba3782SJens Axboe #define WS_USED (1 << WS_USED_B)
6103ba3782SJens Axboe #define WS_ONSTACK (1 << WS_ONSTACK_B)
6203ba3782SJens Axboe 
6303ba3782SJens Axboe static inline bool bdi_work_on_stack(struct bdi_work *work)
64f11b00f3SAdrian Bunk {
6503ba3782SJens Axboe 	return test_bit(WS_ONSTACK_B, &work->state);
6603ba3782SJens Axboe }
6703ba3782SJens Axboe 
6803ba3782SJens Axboe static inline void bdi_work_init(struct bdi_work *work,
6903ba3782SJens Axboe 				 struct writeback_control *wbc)
7003ba3782SJens Axboe {
7103ba3782SJens Axboe 	INIT_RCU_HEAD(&work->rcu_head);
7203ba3782SJens Axboe 	work->sb = wbc->sb;
7303ba3782SJens Axboe 	work->nr_pages = wbc->nr_to_write;
7403ba3782SJens Axboe 	work->sync_mode = wbc->sync_mode;
7503ba3782SJens Axboe 	work->state = WS_USED;
7603ba3782SJens Axboe }
7703ba3782SJens Axboe 
78f11b00f3SAdrian Bunk /**
79f11b00f3SAdrian Bunk  * writeback_in_progress - determine whether there is writeback in progress
80f11b00f3SAdrian Bunk  * @bdi: the device's backing_dev_info structure.
81f11b00f3SAdrian Bunk  *
8203ba3782SJens Axboe  * Determine whether there is writeback waiting to be handled against a
8303ba3782SJens Axboe  * backing device.
84f11b00f3SAdrian Bunk  */
85f11b00f3SAdrian Bunk int writeback_in_progress(struct backing_dev_info *bdi)
86f11b00f3SAdrian Bunk {
8703ba3782SJens Axboe 	return !list_empty(&bdi->work_list);
88f11b00f3SAdrian Bunk }
89f11b00f3SAdrian Bunk 
9003ba3782SJens Axboe static void bdi_work_clear(struct bdi_work *work)
91f11b00f3SAdrian Bunk {
9203ba3782SJens Axboe 	clear_bit(WS_USED_B, &work->state);
9303ba3782SJens Axboe 	smp_mb__after_clear_bit();
9403ba3782SJens Axboe 	wake_up_bit(&work->state, WS_USED_B);
95f11b00f3SAdrian Bunk }
96f11b00f3SAdrian Bunk 
9703ba3782SJens Axboe static void bdi_work_free(struct rcu_head *head)
984195f73dSNick Piggin {
9903ba3782SJens Axboe 	struct bdi_work *work = container_of(head, struct bdi_work, rcu_head);
1004195f73dSNick Piggin 
10103ba3782SJens Axboe 	if (!bdi_work_on_stack(work))
10203ba3782SJens Axboe 		kfree(work);
10303ba3782SJens Axboe 	else
10403ba3782SJens Axboe 		bdi_work_clear(work);
1054195f73dSNick Piggin }
1064195f73dSNick Piggin 
10703ba3782SJens Axboe static void wb_work_complete(struct bdi_work *work)
1081da177e4SLinus Torvalds {
10903ba3782SJens Axboe 	const enum writeback_sync_modes sync_mode = work->sync_mode;
1101da177e4SLinus Torvalds 
1111da177e4SLinus Torvalds 	/*
11203ba3782SJens Axboe 	 * For allocated work, we can clear the done/seen bit right here.
11303ba3782SJens Axboe 	 * For on-stack work, we need to postpone both the clear and free
11403ba3782SJens Axboe 	 * to after the RCU grace period, since the stack could be invalidated
11503ba3782SJens Axboe 	 * as soon as bdi_work_clear() has done the wakeup.
1161da177e4SLinus Torvalds 	 */
11703ba3782SJens Axboe 	if (!bdi_work_on_stack(work))
11803ba3782SJens Axboe 		bdi_work_clear(work);
11903ba3782SJens Axboe 	if (sync_mode == WB_SYNC_NONE || bdi_work_on_stack(work))
12003ba3782SJens Axboe 		call_rcu(&work->rcu_head, bdi_work_free);
1211da177e4SLinus Torvalds }
1221da177e4SLinus Torvalds 
12303ba3782SJens Axboe static void wb_clear_pending(struct bdi_writeback *wb, struct bdi_work *work)
12403ba3782SJens Axboe {
1251da177e4SLinus Torvalds 	/*
12603ba3782SJens Axboe 	 * The caller has retrieved the work arguments from this work,
12703ba3782SJens Axboe 	 * drop our reference. If this is the last ref, delete and free it
12803ba3782SJens Axboe 	 */
12903ba3782SJens Axboe 	if (atomic_dec_and_test(&work->pending)) {
13003ba3782SJens Axboe 		struct backing_dev_info *bdi = wb->bdi;
13103ba3782SJens Axboe 
13203ba3782SJens Axboe 		spin_lock(&bdi->wb_lock);
13303ba3782SJens Axboe 		list_del_rcu(&work->list);
13403ba3782SJens Axboe 		spin_unlock(&bdi->wb_lock);
13503ba3782SJens Axboe 
13603ba3782SJens Axboe 		wb_work_complete(work);
13703ba3782SJens Axboe 	}
13803ba3782SJens Axboe }
13903ba3782SJens Axboe 
14003ba3782SJens Axboe static void bdi_queue_work(struct backing_dev_info *bdi, struct bdi_work *work)
14103ba3782SJens Axboe {
14203ba3782SJens Axboe 	if (work) {
14303ba3782SJens Axboe 		work->seen = bdi->wb_mask;
14403ba3782SJens Axboe 		BUG_ON(!work->seen);
14503ba3782SJens Axboe 		atomic_set(&work->pending, bdi->wb_cnt);
14603ba3782SJens Axboe 		BUG_ON(!bdi->wb_cnt);
14703ba3782SJens Axboe 
14803ba3782SJens Axboe 		/*
14903ba3782SJens Axboe 		 * Make sure stores are seen before it appears on the list
1501da177e4SLinus Torvalds 		 */
1511da177e4SLinus Torvalds 		smp_mb();
1521da177e4SLinus Torvalds 
15303ba3782SJens Axboe 		spin_lock(&bdi->wb_lock);
15403ba3782SJens Axboe 		list_add_tail_rcu(&work->list, &bdi->work_list);
15503ba3782SJens Axboe 		spin_unlock(&bdi->wb_lock);
15603ba3782SJens Axboe 	}
1571da177e4SLinus Torvalds 
1581da177e4SLinus Torvalds 	/*
15903ba3782SJens Axboe 	 * If the default thread isn't there, make sure we add it. When
16003ba3782SJens Axboe 	 * it gets created and wakes up, we'll run this work.
1611da177e4SLinus Torvalds 	 */
16203ba3782SJens Axboe 	if (unlikely(list_empty_careful(&bdi->wb_list)))
16303ba3782SJens Axboe 		wake_up_process(default_backing_dev_info.wb.task);
16403ba3782SJens Axboe 	else {
16503ba3782SJens Axboe 		struct bdi_writeback *wb = &bdi->wb;
1661da177e4SLinus Torvalds 
1671da177e4SLinus Torvalds 		/*
16803ba3782SJens Axboe 		 * If we failed allocating the bdi work item, wake up the wb
16903ba3782SJens Axboe 		 * thread always. As a safety precaution, it'll flush out
17003ba3782SJens Axboe 		 * everything
1711da177e4SLinus Torvalds 		 */
17203ba3782SJens Axboe 		if (!wb_has_dirty_io(wb)) {
17303ba3782SJens Axboe 			if (work)
17403ba3782SJens Axboe 				wb_clear_pending(wb, work);
17503ba3782SJens Axboe 		} else if (wb->task)
17603ba3782SJens Axboe 			wake_up_process(wb->task);
1771da177e4SLinus Torvalds 	}
17803ba3782SJens Axboe }
1791da177e4SLinus Torvalds 
1801da177e4SLinus Torvalds /*
18103ba3782SJens Axboe  * Used for on-stack allocated work items. The caller needs to wait until
18203ba3782SJens Axboe  * the wb threads have acked the work before it's safe to continue.
1831da177e4SLinus Torvalds  */
18403ba3782SJens Axboe static void bdi_wait_on_work_clear(struct bdi_work *work)
1851da177e4SLinus Torvalds {
18603ba3782SJens Axboe 	wait_on_bit(&work->state, WS_USED_B, bdi_sched_wait,
18703ba3782SJens Axboe 		    TASK_UNINTERRUPTIBLE);
18803ba3782SJens Axboe }
18903ba3782SJens Axboe 
19003ba3782SJens Axboe static struct bdi_work *bdi_alloc_work(struct writeback_control *wbc)
19103ba3782SJens Axboe {
19203ba3782SJens Axboe 	struct bdi_work *work;
19303ba3782SJens Axboe 
19403ba3782SJens Axboe 	work = kmalloc(sizeof(*work), GFP_ATOMIC);
19503ba3782SJens Axboe 	if (work)
19603ba3782SJens Axboe 		bdi_work_init(work, wbc);
19703ba3782SJens Axboe 
19803ba3782SJens Axboe 	return work;
19903ba3782SJens Axboe }
20003ba3782SJens Axboe 
20103ba3782SJens Axboe void bdi_start_writeback(struct writeback_control *wbc)
20203ba3782SJens Axboe {
20303ba3782SJens Axboe 	/*
204f0fad8a5SChristoph Hellwig 	 * WB_SYNC_NONE is opportunistic writeback. If this allocation fails,
205f0fad8a5SChristoph Hellwig 	 * bdi_queue_work() will wake up the thread and flush old data. This
206f0fad8a5SChristoph Hellwig 	 * should ensure some amount of progress in freeing memory.
20703ba3782SJens Axboe 	 */
208f0fad8a5SChristoph Hellwig 	if (wbc->sync_mode != WB_SYNC_ALL) {
209f0fad8a5SChristoph Hellwig 		struct bdi_work *w = bdi_alloc_work(wbc);
210f0fad8a5SChristoph Hellwig 
211f0fad8a5SChristoph Hellwig 		bdi_queue_work(wbc->bdi, w);
212f0fad8a5SChristoph Hellwig 	} else {
213f0fad8a5SChristoph Hellwig 		struct bdi_work work;
214f0fad8a5SChristoph Hellwig 
215f0fad8a5SChristoph Hellwig 		bdi_work_init(&work, wbc);
216f0fad8a5SChristoph Hellwig 		work.state |= WS_ONSTACK;
217f0fad8a5SChristoph Hellwig 
218f0fad8a5SChristoph Hellwig 		bdi_queue_work(wbc->bdi, &work);
219f0fad8a5SChristoph Hellwig 		bdi_wait_on_work_clear(&work);
22003ba3782SJens Axboe 	}
2211da177e4SLinus Torvalds }
2221da177e4SLinus Torvalds 
2231da177e4SLinus Torvalds /*
2246610a0bcSAndrew Morton  * Redirty an inode: set its when-it-was dirtied timestamp and move it to the
2256610a0bcSAndrew Morton  * furthest end of its superblock's dirty-inode list.
2266610a0bcSAndrew Morton  *
2276610a0bcSAndrew Morton  * Before stamping the inode's ->dirtied_when, we check to see whether it is
22866f3b8e2SJens Axboe  * already the most-recently-dirtied inode on the b_dirty list.  If that is
2296610a0bcSAndrew Morton  * the case then the inode must have been redirtied while it was being written
2306610a0bcSAndrew Morton  * out and we don't reset its dirtied_when.
2316610a0bcSAndrew Morton  */
2326610a0bcSAndrew Morton static void redirty_tail(struct inode *inode)
2336610a0bcSAndrew Morton {
23403ba3782SJens Axboe 	struct bdi_writeback *wb = &inode_to_bdi(inode)->wb;
2356610a0bcSAndrew Morton 
23603ba3782SJens Axboe 	if (!list_empty(&wb->b_dirty)) {
23766f3b8e2SJens Axboe 		struct inode *tail;
2386610a0bcSAndrew Morton 
23903ba3782SJens Axboe 		tail = list_entry(wb->b_dirty.next, struct inode, i_list);
24066f3b8e2SJens Axboe 		if (time_before(inode->dirtied_when, tail->dirtied_when))
2416610a0bcSAndrew Morton 			inode->dirtied_when = jiffies;
2426610a0bcSAndrew Morton 	}
24303ba3782SJens Axboe 	list_move(&inode->i_list, &wb->b_dirty);
2446610a0bcSAndrew Morton }
2456610a0bcSAndrew Morton 
2466610a0bcSAndrew Morton /*
24766f3b8e2SJens Axboe  * requeue inode for re-scanning after bdi->b_io list is exhausted.
248c986d1e2SAndrew Morton  */
2490e0f4fc2SKen Chen static void requeue_io(struct inode *inode)
250c986d1e2SAndrew Morton {
25103ba3782SJens Axboe 	struct bdi_writeback *wb = &inode_to_bdi(inode)->wb;
25203ba3782SJens Axboe 
25303ba3782SJens Axboe 	list_move(&inode->i_list, &wb->b_more_io);
254c986d1e2SAndrew Morton }
255c986d1e2SAndrew Morton 
2561c0eeaf5SJoern Engel static void inode_sync_complete(struct inode *inode)
2571c0eeaf5SJoern Engel {
2581c0eeaf5SJoern Engel 	/*
2591c0eeaf5SJoern Engel 	 * Prevent speculative execution through spin_unlock(&inode_lock);
2601c0eeaf5SJoern Engel 	 */
2611c0eeaf5SJoern Engel 	smp_mb();
2621c0eeaf5SJoern Engel 	wake_up_bit(&inode->i_state, __I_SYNC);
2631c0eeaf5SJoern Engel }
2641c0eeaf5SJoern Engel 
265d2caa3c5SJeff Layton static bool inode_dirtied_after(struct inode *inode, unsigned long t)
266d2caa3c5SJeff Layton {
267d2caa3c5SJeff Layton 	bool ret = time_after(inode->dirtied_when, t);
268d2caa3c5SJeff Layton #ifndef CONFIG_64BIT
269d2caa3c5SJeff Layton 	/*
270d2caa3c5SJeff Layton 	 * For inodes being constantly redirtied, dirtied_when can get stuck.
271d2caa3c5SJeff Layton 	 * It _appears_ to be in the future, but is actually in distant past.
272d2caa3c5SJeff Layton 	 * This test is necessary to prevent such wrapped-around relative times
273d2caa3c5SJeff Layton 	 * from permanently stopping the whole pdflush writeback.
274d2caa3c5SJeff Layton 	 */
275d2caa3c5SJeff Layton 	ret = ret && time_before_eq(inode->dirtied_when, jiffies);
276d2caa3c5SJeff Layton #endif
277d2caa3c5SJeff Layton 	return ret;
278d2caa3c5SJeff Layton }
279d2caa3c5SJeff Layton 
280c986d1e2SAndrew Morton /*
2812c136579SFengguang Wu  * Move expired dirty inodes from @delaying_queue to @dispatch_queue.
2822c136579SFengguang Wu  */
2832c136579SFengguang Wu static void move_expired_inodes(struct list_head *delaying_queue,
2842c136579SFengguang Wu 			       struct list_head *dispatch_queue,
2852c136579SFengguang Wu 				unsigned long *older_than_this)
2862c136579SFengguang Wu {
2872c136579SFengguang Wu 	while (!list_empty(delaying_queue)) {
2882c136579SFengguang Wu 		struct inode *inode = list_entry(delaying_queue->prev,
2892c136579SFengguang Wu 						struct inode, i_list);
2902c136579SFengguang Wu 		if (older_than_this &&
291d2caa3c5SJeff Layton 		    inode_dirtied_after(inode, *older_than_this))
2922c136579SFengguang Wu 			break;
2932c136579SFengguang Wu 		list_move(&inode->i_list, dispatch_queue);
2942c136579SFengguang Wu 	}
2952c136579SFengguang Wu }
2962c136579SFengguang Wu 
2972c136579SFengguang Wu /*
2982c136579SFengguang Wu  * Queue all expired dirty inodes for io, eldest first.
2992c136579SFengguang Wu  */
30003ba3782SJens Axboe static void queue_io(struct bdi_writeback *wb, unsigned long *older_than_this)
3012c136579SFengguang Wu {
30203ba3782SJens Axboe 	list_splice_init(&wb->b_more_io, wb->b_io.prev);
30303ba3782SJens Axboe 	move_expired_inodes(&wb->b_dirty, &wb->b_io, older_than_this);
30466f3b8e2SJens Axboe }
30566f3b8e2SJens Axboe 
30603ba3782SJens Axboe static int write_inode(struct inode *inode, int sync)
30766f3b8e2SJens Axboe {
30803ba3782SJens Axboe 	if (inode->i_sb->s_op->write_inode && !is_bad_inode(inode))
30903ba3782SJens Axboe 		return inode->i_sb->s_op->write_inode(inode, sync);
31003ba3782SJens Axboe 	return 0;
31166f3b8e2SJens Axboe }
31208d8e974SFengguang Wu 
3132c136579SFengguang Wu /*
31401c03194SChristoph Hellwig  * Wait for writeback on an inode to complete.
31501c03194SChristoph Hellwig  */
31601c03194SChristoph Hellwig static void inode_wait_for_writeback(struct inode *inode)
31701c03194SChristoph Hellwig {
31801c03194SChristoph Hellwig 	DEFINE_WAIT_BIT(wq, &inode->i_state, __I_SYNC);
31901c03194SChristoph Hellwig 	wait_queue_head_t *wqh;
32001c03194SChristoph Hellwig 
32101c03194SChristoph Hellwig 	wqh = bit_waitqueue(&inode->i_state, __I_SYNC);
32201c03194SChristoph Hellwig 	do {
32301c03194SChristoph Hellwig 		spin_unlock(&inode_lock);
32401c03194SChristoph Hellwig 		__wait_on_bit(wqh, &wq, inode_wait, TASK_UNINTERRUPTIBLE);
32501c03194SChristoph Hellwig 		spin_lock(&inode_lock);
32601c03194SChristoph Hellwig 	} while (inode->i_state & I_SYNC);
32701c03194SChristoph Hellwig }
32801c03194SChristoph Hellwig 
32901c03194SChristoph Hellwig /*
33001c03194SChristoph Hellwig  * Write out an inode's dirty pages.  Called under inode_lock.  Either the
33101c03194SChristoph Hellwig  * caller has ref on the inode (either via __iget or via syscall against an fd)
33201c03194SChristoph Hellwig  * or the inode has I_WILL_FREE set (via generic_forget_inode)
33301c03194SChristoph Hellwig  *
3341da177e4SLinus Torvalds  * If `wait' is set, wait on the writeout.
3351da177e4SLinus Torvalds  *
3361da177e4SLinus Torvalds  * The whole writeout design is quite complex and fragile.  We want to avoid
3371da177e4SLinus Torvalds  * starvation of particular inodes when others are being redirtied, prevent
3381da177e4SLinus Torvalds  * livelocks, etc.
3391da177e4SLinus Torvalds  *
3401da177e4SLinus Torvalds  * Called under inode_lock.
3411da177e4SLinus Torvalds  */
3421da177e4SLinus Torvalds static int
34301c03194SChristoph Hellwig writeback_single_inode(struct inode *inode, struct writeback_control *wbc)
3441da177e4SLinus Torvalds {
3451da177e4SLinus Torvalds 	struct address_space *mapping = inode->i_mapping;
3461da177e4SLinus Torvalds 	int wait = wbc->sync_mode == WB_SYNC_ALL;
34701c03194SChristoph Hellwig 	unsigned dirty;
3481da177e4SLinus Torvalds 	int ret;
3491da177e4SLinus Torvalds 
35001c03194SChristoph Hellwig 	if (!atomic_read(&inode->i_count))
35101c03194SChristoph Hellwig 		WARN_ON(!(inode->i_state & (I_WILL_FREE|I_FREEING)));
35201c03194SChristoph Hellwig 	else
35301c03194SChristoph Hellwig 		WARN_ON(inode->i_state & I_WILL_FREE);
35401c03194SChristoph Hellwig 
35501c03194SChristoph Hellwig 	if (inode->i_state & I_SYNC) {
35601c03194SChristoph Hellwig 		/*
35701c03194SChristoph Hellwig 		 * If this inode is locked for writeback and we are not doing
35866f3b8e2SJens Axboe 		 * writeback-for-data-integrity, move it to b_more_io so that
35901c03194SChristoph Hellwig 		 * writeback can proceed with the other inodes on s_io.
36001c03194SChristoph Hellwig 		 *
36101c03194SChristoph Hellwig 		 * We'll have another go at writing back this inode when we
36266f3b8e2SJens Axboe 		 * completed a full scan of b_io.
36301c03194SChristoph Hellwig 		 */
36401c03194SChristoph Hellwig 		if (!wait) {
36501c03194SChristoph Hellwig 			requeue_io(inode);
36601c03194SChristoph Hellwig 			return 0;
36701c03194SChristoph Hellwig 		}
36801c03194SChristoph Hellwig 
36901c03194SChristoph Hellwig 		/*
37001c03194SChristoph Hellwig 		 * It's a data-integrity sync.  We must wait.
37101c03194SChristoph Hellwig 		 */
37201c03194SChristoph Hellwig 		inode_wait_for_writeback(inode);
37301c03194SChristoph Hellwig 	}
37401c03194SChristoph Hellwig 
3751c0eeaf5SJoern Engel 	BUG_ON(inode->i_state & I_SYNC);
3761da177e4SLinus Torvalds 
3771c0eeaf5SJoern Engel 	/* Set I_SYNC, reset I_DIRTY */
3781da177e4SLinus Torvalds 	dirty = inode->i_state & I_DIRTY;
3791c0eeaf5SJoern Engel 	inode->i_state |= I_SYNC;
3801da177e4SLinus Torvalds 	inode->i_state &= ~I_DIRTY;
3811da177e4SLinus Torvalds 
3821da177e4SLinus Torvalds 	spin_unlock(&inode_lock);
3831da177e4SLinus Torvalds 
3841da177e4SLinus Torvalds 	ret = do_writepages(mapping, wbc);
3851da177e4SLinus Torvalds 
3861da177e4SLinus Torvalds 	/* Don't write the inode if only I_DIRTY_PAGES was set */
3871da177e4SLinus Torvalds 	if (dirty & (I_DIRTY_SYNC | I_DIRTY_DATASYNC)) {
3881da177e4SLinus Torvalds 		int err = write_inode(inode, wait);
3891da177e4SLinus Torvalds 		if (ret == 0)
3901da177e4SLinus Torvalds 			ret = err;
3911da177e4SLinus Torvalds 	}
3921da177e4SLinus Torvalds 
3931da177e4SLinus Torvalds 	if (wait) {
3941da177e4SLinus Torvalds 		int err = filemap_fdatawait(mapping);
3951da177e4SLinus Torvalds 		if (ret == 0)
3961da177e4SLinus Torvalds 			ret = err;
3971da177e4SLinus Torvalds 	}
3981da177e4SLinus Torvalds 
3991da177e4SLinus Torvalds 	spin_lock(&inode_lock);
4001c0eeaf5SJoern Engel 	inode->i_state &= ~I_SYNC;
40184a89245SWu Fengguang 	if (!(inode->i_state & (I_FREEING | I_CLEAR))) {
4021da177e4SLinus Torvalds 		if (!(inode->i_state & I_DIRTY) &&
4031da177e4SLinus Torvalds 		    mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) {
4041da177e4SLinus Torvalds 			/*
4051da177e4SLinus Torvalds 			 * We didn't write back all the pages.  nfs_writepages()
4061da177e4SLinus Torvalds 			 * sometimes bales out without doing anything. Redirty
40766f3b8e2SJens Axboe 			 * the inode; Move it from b_io onto b_more_io/b_dirty.
4081b43ef91SAndrew Morton 			 */
4091b43ef91SAndrew Morton 			/*
4101b43ef91SAndrew Morton 			 * akpm: if the caller was the kupdate function we put
41166f3b8e2SJens Axboe 			 * this inode at the head of b_dirty so it gets first
4121b43ef91SAndrew Morton 			 * consideration.  Otherwise, move it to the tail, for
4131b43ef91SAndrew Morton 			 * the reasons described there.  I'm not really sure
4141b43ef91SAndrew Morton 			 * how much sense this makes.  Presumably I had a good
4151b43ef91SAndrew Morton 			 * reasons for doing it this way, and I'd rather not
4161b43ef91SAndrew Morton 			 * muck with it at present.
4171da177e4SLinus Torvalds 			 */
4181da177e4SLinus Torvalds 			if (wbc->for_kupdate) {
4191da177e4SLinus Torvalds 				/*
4202c136579SFengguang Wu 				 * For the kupdate function we move the inode
42166f3b8e2SJens Axboe 				 * to b_more_io so it will get more writeout as
4222c136579SFengguang Wu 				 * soon as the queue becomes uncongested.
4231da177e4SLinus Torvalds 				 */
4241da177e4SLinus Torvalds 				inode->i_state |= I_DIRTY_PAGES;
4258bc3be27SFengguang Wu 				if (wbc->nr_to_write <= 0) {
4268bc3be27SFengguang Wu 					/*
4278bc3be27SFengguang Wu 					 * slice used up: queue for next turn
4288bc3be27SFengguang Wu 					 */
4290e0f4fc2SKen Chen 					requeue_io(inode);
4301da177e4SLinus Torvalds 				} else {
4311da177e4SLinus Torvalds 					/*
4328bc3be27SFengguang Wu 					 * somehow blocked: retry later
4338bc3be27SFengguang Wu 					 */
4348bc3be27SFengguang Wu 					redirty_tail(inode);
4358bc3be27SFengguang Wu 				}
4368bc3be27SFengguang Wu 			} else {
4378bc3be27SFengguang Wu 				/*
4381da177e4SLinus Torvalds 				 * Otherwise fully redirty the inode so that
4391da177e4SLinus Torvalds 				 * other inodes on this superblock will get some
4401da177e4SLinus Torvalds 				 * writeout.  Otherwise heavy writing to one
4411da177e4SLinus Torvalds 				 * file would indefinitely suspend writeout of
4421da177e4SLinus Torvalds 				 * all the other files.
4431da177e4SLinus Torvalds 				 */
4441da177e4SLinus Torvalds 				inode->i_state |= I_DIRTY_PAGES;
4451b43ef91SAndrew Morton 				redirty_tail(inode);
4461da177e4SLinus Torvalds 			}
4471da177e4SLinus Torvalds 		} else if (inode->i_state & I_DIRTY) {
4481da177e4SLinus Torvalds 			/*
4491da177e4SLinus Torvalds 			 * Someone redirtied the inode while were writing back
4501da177e4SLinus Torvalds 			 * the pages.
4511da177e4SLinus Torvalds 			 */
4526610a0bcSAndrew Morton 			redirty_tail(inode);
4531da177e4SLinus Torvalds 		} else if (atomic_read(&inode->i_count)) {
4541da177e4SLinus Torvalds 			/*
4551da177e4SLinus Torvalds 			 * The inode is clean, inuse
4561da177e4SLinus Torvalds 			 */
4571da177e4SLinus Torvalds 			list_move(&inode->i_list, &inode_in_use);
4581da177e4SLinus Torvalds 		} else {
4591da177e4SLinus Torvalds 			/*
4601da177e4SLinus Torvalds 			 * The inode is clean, unused
4611da177e4SLinus Torvalds 			 */
4621da177e4SLinus Torvalds 			list_move(&inode->i_list, &inode_unused);
4631da177e4SLinus Torvalds 		}
4641da177e4SLinus Torvalds 	}
4651c0eeaf5SJoern Engel 	inode_sync_complete(inode);
4661da177e4SLinus Torvalds 	return ret;
4671da177e4SLinus Torvalds }
4681da177e4SLinus Torvalds 
46903ba3782SJens Axboe /*
47003ba3782SJens Axboe  * For WB_SYNC_NONE writeback, the caller does not have the sb pinned
47103ba3782SJens Axboe  * before calling writeback. So make sure that we do pin it, so it doesn't
47203ba3782SJens Axboe  * go away while we are writing inodes from it.
47303ba3782SJens Axboe  *
47403ba3782SJens Axboe  * Returns 0 if the super was successfully pinned (or pinning wasn't needed),
47503ba3782SJens Axboe  * 1 if we failed.
47603ba3782SJens Axboe  */
47703ba3782SJens Axboe static int pin_sb_for_writeback(struct writeback_control *wbc,
47803ba3782SJens Axboe 				   struct inode *inode)
4791da177e4SLinus Torvalds {
48003ba3782SJens Axboe 	struct super_block *sb = inode->i_sb;
48103ba3782SJens Axboe 
48203ba3782SJens Axboe 	/*
48303ba3782SJens Axboe 	 * Caller must already hold the ref for this
48403ba3782SJens Axboe 	 */
48503ba3782SJens Axboe 	if (wbc->sync_mode == WB_SYNC_ALL) {
48603ba3782SJens Axboe 		WARN_ON(!rwsem_is_locked(&sb->s_umount));
48703ba3782SJens Axboe 		return 0;
48803ba3782SJens Axboe 	}
48903ba3782SJens Axboe 
49003ba3782SJens Axboe 	spin_lock(&sb_lock);
49103ba3782SJens Axboe 	sb->s_count++;
49203ba3782SJens Axboe 	if (down_read_trylock(&sb->s_umount)) {
49303ba3782SJens Axboe 		if (sb->s_root) {
49403ba3782SJens Axboe 			spin_unlock(&sb_lock);
49503ba3782SJens Axboe 			return 0;
49603ba3782SJens Axboe 		}
49703ba3782SJens Axboe 		/*
49803ba3782SJens Axboe 		 * umounted, drop rwsem again and fall through to failure
49903ba3782SJens Axboe 		 */
50003ba3782SJens Axboe 		up_read(&sb->s_umount);
50103ba3782SJens Axboe 	}
50203ba3782SJens Axboe 
50303ba3782SJens Axboe 	sb->s_count--;
50403ba3782SJens Axboe 	spin_unlock(&sb_lock);
50503ba3782SJens Axboe 	return 1;
50603ba3782SJens Axboe }
50703ba3782SJens Axboe 
50803ba3782SJens Axboe static void unpin_sb_for_writeback(struct writeback_control *wbc,
50903ba3782SJens Axboe 				   struct inode *inode)
51003ba3782SJens Axboe {
51103ba3782SJens Axboe 	struct super_block *sb = inode->i_sb;
51203ba3782SJens Axboe 
51303ba3782SJens Axboe 	if (wbc->sync_mode == WB_SYNC_ALL)
51403ba3782SJens Axboe 		return;
51503ba3782SJens Axboe 
51603ba3782SJens Axboe 	up_read(&sb->s_umount);
51703ba3782SJens Axboe 	put_super(sb);
51803ba3782SJens Axboe }
51903ba3782SJens Axboe 
52003ba3782SJens Axboe static void writeback_inodes_wb(struct bdi_writeback *wb,
52103ba3782SJens Axboe 				struct writeback_control *wbc)
52203ba3782SJens Axboe {
52303ba3782SJens Axboe 	struct super_block *sb = wbc->sb;
52466f3b8e2SJens Axboe 	const int is_blkdev_sb = sb_is_blkdev_sb(sb);
5251da177e4SLinus Torvalds 	const unsigned long start = jiffies;	/* livelock avoidance */
5261da177e4SLinus Torvalds 
527ae8547b0SHans Reiser 	spin_lock(&inode_lock);
5281da177e4SLinus Torvalds 
52903ba3782SJens Axboe 	if (!wbc->for_kupdate || list_empty(&wb->b_io))
53003ba3782SJens Axboe 		queue_io(wb, wbc->older_than_this);
53166f3b8e2SJens Axboe 
53203ba3782SJens Axboe 	while (!list_empty(&wb->b_io)) {
53303ba3782SJens Axboe 		struct inode *inode = list_entry(wb->b_io.prev,
5341da177e4SLinus Torvalds 						struct inode, i_list);
5351da177e4SLinus Torvalds 		long pages_skipped;
5361da177e4SLinus Torvalds 
53766f3b8e2SJens Axboe 		/*
53866f3b8e2SJens Axboe 		 * super block given and doesn't match, skip this inode
53966f3b8e2SJens Axboe 		 */
54066f3b8e2SJens Axboe 		if (sb && sb != inode->i_sb) {
54166f3b8e2SJens Axboe 			redirty_tail(inode);
54266f3b8e2SJens Axboe 			continue;
54366f3b8e2SJens Axboe 		}
54466f3b8e2SJens Axboe 
54503ba3782SJens Axboe 		if (!bdi_cap_writeback_dirty(wb->bdi)) {
5469852a0e7SAndrew Morton 			redirty_tail(inode);
54766f3b8e2SJens Axboe 			if (is_blkdev_sb) {
5481da177e4SLinus Torvalds 				/*
5491da177e4SLinus Torvalds 				 * Dirty memory-backed blockdev: the ramdisk
5501da177e4SLinus Torvalds 				 * driver does this.  Skip just this inode
5511da177e4SLinus Torvalds 				 */
5521da177e4SLinus Torvalds 				continue;
5531da177e4SLinus Torvalds 			}
5541da177e4SLinus Torvalds 			/*
5551da177e4SLinus Torvalds 			 * Dirty memory-backed inode against a filesystem other
5561da177e4SLinus Torvalds 			 * than the kernel-internal bdev filesystem.  Skip the
5571da177e4SLinus Torvalds 			 * entire superblock.
5581da177e4SLinus Torvalds 			 */
5591da177e4SLinus Torvalds 			break;
5601da177e4SLinus Torvalds 		}
5611da177e4SLinus Torvalds 
56284a89245SWu Fengguang 		if (inode->i_state & (I_NEW | I_WILL_FREE)) {
5637ef0d737SNick Piggin 			requeue_io(inode);
5647ef0d737SNick Piggin 			continue;
5657ef0d737SNick Piggin 		}
5667ef0d737SNick Piggin 
56703ba3782SJens Axboe 		if (wbc->nonblocking && bdi_write_congested(wb->bdi)) {
5681da177e4SLinus Torvalds 			wbc->encountered_congestion = 1;
56966f3b8e2SJens Axboe 			if (!is_blkdev_sb)
5701da177e4SLinus Torvalds 				break;		/* Skip a congested fs */
5710e0f4fc2SKen Chen 			requeue_io(inode);
5721da177e4SLinus Torvalds 			continue;		/* Skip a congested blockdev */
5731da177e4SLinus Torvalds 		}
5741da177e4SLinus Torvalds 
575d2caa3c5SJeff Layton 		/*
576d2caa3c5SJeff Layton 		 * Was this inode dirtied after sync_sb_inodes was called?
577d2caa3c5SJeff Layton 		 * This keeps sync from extra jobs and livelock.
578d2caa3c5SJeff Layton 		 */
579d2caa3c5SJeff Layton 		if (inode_dirtied_after(inode, start))
5801da177e4SLinus Torvalds 			break;
5811da177e4SLinus Torvalds 
58203ba3782SJens Axboe 		if (pin_sb_for_writeback(wbc, inode)) {
58303ba3782SJens Axboe 			requeue_io(inode);
58403ba3782SJens Axboe 			continue;
58503ba3782SJens Axboe 		}
5861da177e4SLinus Torvalds 
58784a89245SWu Fengguang 		BUG_ON(inode->i_state & (I_FREEING | I_CLEAR));
5881da177e4SLinus Torvalds 		__iget(inode);
5891da177e4SLinus Torvalds 		pages_skipped = wbc->pages_skipped;
59001c03194SChristoph Hellwig 		writeback_single_inode(inode, wbc);
59103ba3782SJens Axboe 		unpin_sb_for_writeback(wbc, inode);
5921da177e4SLinus Torvalds 		if (wbc->pages_skipped != pages_skipped) {
5931da177e4SLinus Torvalds 			/*
5941da177e4SLinus Torvalds 			 * writeback is not making progress due to locked
5951da177e4SLinus Torvalds 			 * buffers.  Skip this inode for now.
5961da177e4SLinus Torvalds 			 */
597f57b9b7bSAndrew Morton 			redirty_tail(inode);
5981da177e4SLinus Torvalds 		}
5991da177e4SLinus Torvalds 		spin_unlock(&inode_lock);
6001da177e4SLinus Torvalds 		iput(inode);
6014ffc8444SOGAWA Hirofumi 		cond_resched();
6021da177e4SLinus Torvalds 		spin_lock(&inode_lock);
6038bc3be27SFengguang Wu 		if (wbc->nr_to_write <= 0) {
6048bc3be27SFengguang Wu 			wbc->more_io = 1;
6051da177e4SLinus Torvalds 			break;
6061da177e4SLinus Torvalds 		}
60703ba3782SJens Axboe 		if (!list_empty(&wb->b_more_io))
6088bc3be27SFengguang Wu 			wbc->more_io = 1;
6098bc3be27SFengguang Wu 	}
61038f21977SNick Piggin 
61166f3b8e2SJens Axboe 	spin_unlock(&inode_lock);
61266f3b8e2SJens Axboe 	/* Leave any unwritten inodes on b_io */
61366f3b8e2SJens Axboe }
61466f3b8e2SJens Axboe 
61503ba3782SJens Axboe void writeback_inodes_wbc(struct writeback_control *wbc)
61603ba3782SJens Axboe {
61703ba3782SJens Axboe 	struct backing_dev_info *bdi = wbc->bdi;
61803ba3782SJens Axboe 
61903ba3782SJens Axboe 	writeback_inodes_wb(&bdi->wb, wbc);
62003ba3782SJens Axboe }
62103ba3782SJens Axboe 
62203ba3782SJens Axboe /*
62303ba3782SJens Axboe  * The maximum number of pages to writeout in a single bdi flush/kupdate
62403ba3782SJens Axboe  * operation.  We do this so we don't hold I_SYNC against an inode for
62503ba3782SJens Axboe  * enormous amounts of time, which would block a userspace task which has
62603ba3782SJens Axboe  * been forced to throttle against that inode.  Also, the code reevaluates
62703ba3782SJens Axboe  * the dirty each time it has written this many pages.
62803ba3782SJens Axboe  */
62903ba3782SJens Axboe #define MAX_WRITEBACK_PAGES     1024
63003ba3782SJens Axboe 
63103ba3782SJens Axboe static inline bool over_bground_thresh(void)
63203ba3782SJens Axboe {
63303ba3782SJens Axboe 	unsigned long background_thresh, dirty_thresh;
63403ba3782SJens Axboe 
63503ba3782SJens Axboe 	get_dirty_limits(&background_thresh, &dirty_thresh, NULL, NULL);
63603ba3782SJens Axboe 
63703ba3782SJens Axboe 	return (global_page_state(NR_FILE_DIRTY) +
63803ba3782SJens Axboe 		global_page_state(NR_UNSTABLE_NFS) >= background_thresh);
63903ba3782SJens Axboe }
64003ba3782SJens Axboe 
64103ba3782SJens Axboe /*
64203ba3782SJens Axboe  * Explicit flushing or periodic writeback of "old" data.
64303ba3782SJens Axboe  *
64403ba3782SJens Axboe  * Define "old": the first time one of an inode's pages is dirtied, we mark the
64503ba3782SJens Axboe  * dirtying-time in the inode's address_space.  So this periodic writeback code
64603ba3782SJens Axboe  * just walks the superblock inode list, writing back any inodes which are
64703ba3782SJens Axboe  * older than a specific point in time.
64803ba3782SJens Axboe  *
64903ba3782SJens Axboe  * Try to run once per dirty_writeback_interval.  But if a writeback event
65003ba3782SJens Axboe  * takes longer than a dirty_writeback_interval interval, then leave a
65103ba3782SJens Axboe  * one-second gap.
65203ba3782SJens Axboe  *
65303ba3782SJens Axboe  * older_than_this takes precedence over nr_to_write.  So we'll only write back
65403ba3782SJens Axboe  * all dirty pages if they are all attached to "old" mappings.
65503ba3782SJens Axboe  */
65603ba3782SJens Axboe static long wb_writeback(struct bdi_writeback *wb, long nr_pages,
65703ba3782SJens Axboe 			 struct super_block *sb,
65803ba3782SJens Axboe 			 enum writeback_sync_modes sync_mode, int for_kupdate)
65903ba3782SJens Axboe {
66003ba3782SJens Axboe 	struct writeback_control wbc = {
66103ba3782SJens Axboe 		.bdi			= wb->bdi,
66203ba3782SJens Axboe 		.sb			= sb,
66303ba3782SJens Axboe 		.sync_mode		= sync_mode,
66403ba3782SJens Axboe 		.older_than_this	= NULL,
66503ba3782SJens Axboe 		.for_kupdate		= for_kupdate,
66603ba3782SJens Axboe 		.range_cyclic		= 1,
66703ba3782SJens Axboe 	};
66803ba3782SJens Axboe 	unsigned long oldest_jif;
66903ba3782SJens Axboe 	long wrote = 0;
67003ba3782SJens Axboe 
67103ba3782SJens Axboe 	if (wbc.for_kupdate) {
67203ba3782SJens Axboe 		wbc.older_than_this = &oldest_jif;
67303ba3782SJens Axboe 		oldest_jif = jiffies -
67403ba3782SJens Axboe 				msecs_to_jiffies(dirty_expire_interval * 10);
67503ba3782SJens Axboe 	}
67603ba3782SJens Axboe 
67703ba3782SJens Axboe 	for (;;) {
67803ba3782SJens Axboe 		/*
67903ba3782SJens Axboe 		 * Don't flush anything for non-integrity writeback where
68003ba3782SJens Axboe 		 * no nr_pages was given
68103ba3782SJens Axboe 		 */
68203ba3782SJens Axboe 		if (!for_kupdate && nr_pages <= 0 && sync_mode == WB_SYNC_NONE)
68303ba3782SJens Axboe 			break;
68403ba3782SJens Axboe 
68503ba3782SJens Axboe 		/*
68603ba3782SJens Axboe 		 * If no specific pages were given and this is just a
68703ba3782SJens Axboe 		 * periodic background writeout and we are below the
68803ba3782SJens Axboe 		 * background dirty threshold, don't do anything
68903ba3782SJens Axboe 		 */
69003ba3782SJens Axboe 		if (for_kupdate && nr_pages <= 0 && !over_bground_thresh())
69103ba3782SJens Axboe 			break;
69203ba3782SJens Axboe 
69303ba3782SJens Axboe 		wbc.more_io = 0;
69403ba3782SJens Axboe 		wbc.encountered_congestion = 0;
69503ba3782SJens Axboe 		wbc.nr_to_write = MAX_WRITEBACK_PAGES;
69603ba3782SJens Axboe 		wbc.pages_skipped = 0;
69703ba3782SJens Axboe 		writeback_inodes_wb(wb, &wbc);
69803ba3782SJens Axboe 		nr_pages -= MAX_WRITEBACK_PAGES - wbc.nr_to_write;
69903ba3782SJens Axboe 		wrote += MAX_WRITEBACK_PAGES - wbc.nr_to_write;
70003ba3782SJens Axboe 
70103ba3782SJens Axboe 		/*
70203ba3782SJens Axboe 		 * If we ran out of stuff to write, bail unless more_io got set
70303ba3782SJens Axboe 		 */
70403ba3782SJens Axboe 		if (wbc.nr_to_write > 0 || wbc.pages_skipped > 0) {
70503ba3782SJens Axboe 			if (wbc.more_io && !wbc.for_kupdate)
70603ba3782SJens Axboe 				continue;
70703ba3782SJens Axboe 			break;
70803ba3782SJens Axboe 		}
70903ba3782SJens Axboe 	}
71003ba3782SJens Axboe 
71103ba3782SJens Axboe 	return wrote;
71203ba3782SJens Axboe }
71303ba3782SJens Axboe 
71403ba3782SJens Axboe /*
71503ba3782SJens Axboe  * Return the next bdi_work struct that hasn't been processed by this
71603ba3782SJens Axboe  * wb thread yet
71703ba3782SJens Axboe  */
71803ba3782SJens Axboe static struct bdi_work *get_next_work_item(struct backing_dev_info *bdi,
71903ba3782SJens Axboe 					   struct bdi_writeback *wb)
72003ba3782SJens Axboe {
72103ba3782SJens Axboe 	struct bdi_work *work, *ret = NULL;
72203ba3782SJens Axboe 
72303ba3782SJens Axboe 	rcu_read_lock();
72403ba3782SJens Axboe 
72503ba3782SJens Axboe 	list_for_each_entry_rcu(work, &bdi->work_list, list) {
72603ba3782SJens Axboe 		if (!test_and_clear_bit(wb->nr, &work->seen))
72703ba3782SJens Axboe 			continue;
72803ba3782SJens Axboe 
72903ba3782SJens Axboe 		ret = work;
73003ba3782SJens Axboe 		break;
73103ba3782SJens Axboe 	}
73203ba3782SJens Axboe 
73303ba3782SJens Axboe 	rcu_read_unlock();
73403ba3782SJens Axboe 	return ret;
73503ba3782SJens Axboe }
73603ba3782SJens Axboe 
73703ba3782SJens Axboe static long wb_check_old_data_flush(struct bdi_writeback *wb)
73803ba3782SJens Axboe {
73903ba3782SJens Axboe 	unsigned long expired;
74003ba3782SJens Axboe 	long nr_pages;
74103ba3782SJens Axboe 
74203ba3782SJens Axboe 	expired = wb->last_old_flush +
74303ba3782SJens Axboe 			msecs_to_jiffies(dirty_writeback_interval * 10);
74403ba3782SJens Axboe 	if (time_before(jiffies, expired))
74503ba3782SJens Axboe 		return 0;
74603ba3782SJens Axboe 
74703ba3782SJens Axboe 	wb->last_old_flush = jiffies;
74803ba3782SJens Axboe 	nr_pages = global_page_state(NR_FILE_DIRTY) +
74903ba3782SJens Axboe 			global_page_state(NR_UNSTABLE_NFS) +
75003ba3782SJens Axboe 			(inodes_stat.nr_inodes - inodes_stat.nr_unused);
75103ba3782SJens Axboe 
75203ba3782SJens Axboe 	if (nr_pages)
75303ba3782SJens Axboe 		return wb_writeback(wb, nr_pages, NULL, WB_SYNC_NONE, 1);
75403ba3782SJens Axboe 
75503ba3782SJens Axboe 	return 0;
75603ba3782SJens Axboe }
75703ba3782SJens Axboe 
75803ba3782SJens Axboe /*
75903ba3782SJens Axboe  * Retrieve work items and do the writeback they describe
76003ba3782SJens Axboe  */
76103ba3782SJens Axboe long wb_do_writeback(struct bdi_writeback *wb, int force_wait)
76203ba3782SJens Axboe {
76303ba3782SJens Axboe 	struct backing_dev_info *bdi = wb->bdi;
76403ba3782SJens Axboe 	struct bdi_work *work;
76503ba3782SJens Axboe 	long nr_pages, wrote = 0;
76603ba3782SJens Axboe 
76703ba3782SJens Axboe 	while ((work = get_next_work_item(bdi, wb)) != NULL) {
76803ba3782SJens Axboe 		enum writeback_sync_modes sync_mode;
76903ba3782SJens Axboe 
77003ba3782SJens Axboe 		nr_pages = work->nr_pages;
77103ba3782SJens Axboe 
77203ba3782SJens Axboe 		/*
77303ba3782SJens Axboe 		 * Override sync mode, in case we must wait for completion
77403ba3782SJens Axboe 		 */
77503ba3782SJens Axboe 		if (force_wait)
77603ba3782SJens Axboe 			work->sync_mode = sync_mode = WB_SYNC_ALL;
77703ba3782SJens Axboe 		else
77803ba3782SJens Axboe 			sync_mode = work->sync_mode;
77903ba3782SJens Axboe 
78003ba3782SJens Axboe 		/*
78103ba3782SJens Axboe 		 * If this isn't a data integrity operation, just notify
78203ba3782SJens Axboe 		 * that we have seen this work and we are now starting it.
78303ba3782SJens Axboe 		 */
78403ba3782SJens Axboe 		if (sync_mode == WB_SYNC_NONE)
78503ba3782SJens Axboe 			wb_clear_pending(wb, work);
78603ba3782SJens Axboe 
78703ba3782SJens Axboe 		wrote += wb_writeback(wb, nr_pages, work->sb, sync_mode, 0);
78803ba3782SJens Axboe 
78903ba3782SJens Axboe 		/*
79003ba3782SJens Axboe 		 * This is a data integrity writeback, so only do the
79103ba3782SJens Axboe 		 * notification when we have completed the work.
79203ba3782SJens Axboe 		 */
79303ba3782SJens Axboe 		if (sync_mode == WB_SYNC_ALL)
79403ba3782SJens Axboe 			wb_clear_pending(wb, work);
79503ba3782SJens Axboe 	}
79603ba3782SJens Axboe 
79703ba3782SJens Axboe 	/*
79803ba3782SJens Axboe 	 * Check for periodic writeback, kupdated() style
79903ba3782SJens Axboe 	 */
80003ba3782SJens Axboe 	wrote += wb_check_old_data_flush(wb);
80103ba3782SJens Axboe 
80203ba3782SJens Axboe 	return wrote;
80303ba3782SJens Axboe }
80403ba3782SJens Axboe 
80503ba3782SJens Axboe /*
80603ba3782SJens Axboe  * Handle writeback of dirty data for the device backed by this bdi. Also
80703ba3782SJens Axboe  * wakes up periodically and does kupdated style flushing.
80803ba3782SJens Axboe  */
80903ba3782SJens Axboe int bdi_writeback_task(struct bdi_writeback *wb)
81003ba3782SJens Axboe {
81103ba3782SJens Axboe 	unsigned long last_active = jiffies;
81203ba3782SJens Axboe 	unsigned long wait_jiffies = -1UL;
81303ba3782SJens Axboe 	long pages_written;
81403ba3782SJens Axboe 
81503ba3782SJens Axboe 	while (!kthread_should_stop()) {
81603ba3782SJens Axboe 		pages_written = wb_do_writeback(wb, 0);
81703ba3782SJens Axboe 
81803ba3782SJens Axboe 		if (pages_written)
81903ba3782SJens Axboe 			last_active = jiffies;
82003ba3782SJens Axboe 		else if (wait_jiffies != -1UL) {
82103ba3782SJens Axboe 			unsigned long max_idle;
82203ba3782SJens Axboe 
82303ba3782SJens Axboe 			/*
82403ba3782SJens Axboe 			 * Longest period of inactivity that we tolerate. If we
82503ba3782SJens Axboe 			 * see dirty data again later, the task will get
82603ba3782SJens Axboe 			 * recreated automatically.
82703ba3782SJens Axboe 			 */
82803ba3782SJens Axboe 			max_idle = max(5UL * 60 * HZ, wait_jiffies);
82903ba3782SJens Axboe 			if (time_after(jiffies, max_idle + last_active))
83003ba3782SJens Axboe 				break;
83103ba3782SJens Axboe 		}
83203ba3782SJens Axboe 
83303ba3782SJens Axboe 		wait_jiffies = msecs_to_jiffies(dirty_writeback_interval * 10);
83403ba3782SJens Axboe 		set_current_state(TASK_INTERRUPTIBLE);
83503ba3782SJens Axboe 		schedule_timeout(wait_jiffies);
83603ba3782SJens Axboe 		try_to_freeze();
83703ba3782SJens Axboe 	}
83803ba3782SJens Axboe 
83903ba3782SJens Axboe 	return 0;
84003ba3782SJens Axboe }
84103ba3782SJens Axboe 
84203ba3782SJens Axboe /*
84303ba3782SJens Axboe  * Schedule writeback for all backing devices. Expensive! If this is a data
84403ba3782SJens Axboe  * integrity operation, writeback will be complete when this returns. If
84503ba3782SJens Axboe  * we are simply called for WB_SYNC_NONE, then writeback will merely be
84603ba3782SJens Axboe  * scheduled to run.
84703ba3782SJens Axboe  */
84803ba3782SJens Axboe static void bdi_writeback_all(struct writeback_control *wbc)
84903ba3782SJens Axboe {
85003ba3782SJens Axboe 	const bool must_wait = wbc->sync_mode == WB_SYNC_ALL;
85103ba3782SJens Axboe 	struct backing_dev_info *bdi;
85203ba3782SJens Axboe 	struct bdi_work *work;
85303ba3782SJens Axboe 	LIST_HEAD(list);
85403ba3782SJens Axboe 
85503ba3782SJens Axboe restart:
85603ba3782SJens Axboe 	spin_lock(&bdi_lock);
85703ba3782SJens Axboe 
85803ba3782SJens Axboe 	list_for_each_entry(bdi, &bdi_list, bdi_list) {
85903ba3782SJens Axboe 		struct bdi_work *work;
86003ba3782SJens Axboe 
86103ba3782SJens Axboe 		if (!bdi_has_dirty_io(bdi))
86203ba3782SJens Axboe 			continue;
86303ba3782SJens Axboe 
86403ba3782SJens Axboe 		/*
86503ba3782SJens Axboe 		 * If work allocation fails, do the writes inline. We drop
86603ba3782SJens Axboe 		 * the lock and restart the list writeout. This should be OK,
86703ba3782SJens Axboe 		 * since this happens rarely and because the writeout should
86803ba3782SJens Axboe 		 * eventually make more free memory available.
86903ba3782SJens Axboe 		 */
87003ba3782SJens Axboe 		work = bdi_alloc_work(wbc);
87103ba3782SJens Axboe 		if (!work) {
87203ba3782SJens Axboe 			struct writeback_control __wbc;
87303ba3782SJens Axboe 
87403ba3782SJens Axboe 			/*
87503ba3782SJens Axboe 			 * Not a data integrity writeout, just continue
87603ba3782SJens Axboe 			 */
87703ba3782SJens Axboe 			if (!must_wait)
87803ba3782SJens Axboe 				continue;
87903ba3782SJens Axboe 
88003ba3782SJens Axboe 			spin_unlock(&bdi_lock);
88103ba3782SJens Axboe 			__wbc = *wbc;
88203ba3782SJens Axboe 			__wbc.bdi = bdi;
88303ba3782SJens Axboe 			writeback_inodes_wbc(&__wbc);
88403ba3782SJens Axboe 			goto restart;
88503ba3782SJens Axboe 		}
88603ba3782SJens Axboe 		if (must_wait)
88703ba3782SJens Axboe 			list_add_tail(&work->wait_list, &list);
88803ba3782SJens Axboe 
88903ba3782SJens Axboe 		bdi_queue_work(bdi, work);
89003ba3782SJens Axboe 	}
89103ba3782SJens Axboe 
89203ba3782SJens Axboe 	spin_unlock(&bdi_lock);
89303ba3782SJens Axboe 
89403ba3782SJens Axboe 	/*
89503ba3782SJens Axboe 	 * If this is for WB_SYNC_ALL, wait for pending work to complete
89603ba3782SJens Axboe 	 * before returning.
89703ba3782SJens Axboe 	 */
89803ba3782SJens Axboe 	while (!list_empty(&list)) {
89903ba3782SJens Axboe 		work = list_entry(list.next, struct bdi_work, wait_list);
90003ba3782SJens Axboe 		list_del(&work->wait_list);
90103ba3782SJens Axboe 		bdi_wait_on_work_clear(work);
90203ba3782SJens Axboe 		call_rcu(&work->rcu_head, bdi_work_free);
90303ba3782SJens Axboe 	}
90403ba3782SJens Axboe }
90503ba3782SJens Axboe 
90603ba3782SJens Axboe /*
90703ba3782SJens Axboe  * Start writeback of `nr_pages' pages.  If `nr_pages' is zero, write back
90803ba3782SJens Axboe  * the whole world.
90903ba3782SJens Axboe  */
91003ba3782SJens Axboe void wakeup_flusher_threads(long nr_pages)
91103ba3782SJens Axboe {
91203ba3782SJens Axboe 	struct writeback_control wbc = {
91303ba3782SJens Axboe 		.sync_mode	= WB_SYNC_NONE,
91403ba3782SJens Axboe 		.older_than_this = NULL,
91503ba3782SJens Axboe 		.range_cyclic	= 1,
91603ba3782SJens Axboe 	};
91703ba3782SJens Axboe 
91803ba3782SJens Axboe 	if (nr_pages == 0)
91903ba3782SJens Axboe 		nr_pages = global_page_state(NR_FILE_DIRTY) +
92003ba3782SJens Axboe 				global_page_state(NR_UNSTABLE_NFS);
92103ba3782SJens Axboe 	wbc.nr_to_write = nr_pages;
92203ba3782SJens Axboe 	bdi_writeback_all(&wbc);
92303ba3782SJens Axboe }
92403ba3782SJens Axboe 
92503ba3782SJens Axboe static noinline void block_dump___mark_inode_dirty(struct inode *inode)
92603ba3782SJens Axboe {
92703ba3782SJens Axboe 	if (inode->i_ino || strcmp(inode->i_sb->s_id, "bdev")) {
92803ba3782SJens Axboe 		struct dentry *dentry;
92903ba3782SJens Axboe 		const char *name = "?";
93003ba3782SJens Axboe 
93103ba3782SJens Axboe 		dentry = d_find_alias(inode);
93203ba3782SJens Axboe 		if (dentry) {
93303ba3782SJens Axboe 			spin_lock(&dentry->d_lock);
93403ba3782SJens Axboe 			name = (const char *) dentry->d_name.name;
93503ba3782SJens Axboe 		}
93603ba3782SJens Axboe 		printk(KERN_DEBUG
93703ba3782SJens Axboe 		       "%s(%d): dirtied inode %lu (%s) on %s\n",
93803ba3782SJens Axboe 		       current->comm, task_pid_nr(current), inode->i_ino,
93903ba3782SJens Axboe 		       name, inode->i_sb->s_id);
94003ba3782SJens Axboe 		if (dentry) {
94103ba3782SJens Axboe 			spin_unlock(&dentry->d_lock);
94203ba3782SJens Axboe 			dput(dentry);
94303ba3782SJens Axboe 		}
94403ba3782SJens Axboe 	}
94503ba3782SJens Axboe }
94603ba3782SJens Axboe 
94703ba3782SJens Axboe /**
94803ba3782SJens Axboe  *	__mark_inode_dirty -	internal function
94903ba3782SJens Axboe  *	@inode: inode to mark
95003ba3782SJens Axboe  *	@flags: what kind of dirty (i.e. I_DIRTY_SYNC)
95103ba3782SJens Axboe  *	Mark an inode as dirty. Callers should use mark_inode_dirty or
95203ba3782SJens Axboe  *  	mark_inode_dirty_sync.
95303ba3782SJens Axboe  *
95403ba3782SJens Axboe  * Put the inode on the super block's dirty list.
95503ba3782SJens Axboe  *
95603ba3782SJens Axboe  * CAREFUL! We mark it dirty unconditionally, but move it onto the
95703ba3782SJens Axboe  * dirty list only if it is hashed or if it refers to a blockdev.
95803ba3782SJens Axboe  * If it was not hashed, it will never be added to the dirty list
95903ba3782SJens Axboe  * even if it is later hashed, as it will have been marked dirty already.
96003ba3782SJens Axboe  *
96103ba3782SJens Axboe  * In short, make sure you hash any inodes _before_ you start marking
96203ba3782SJens Axboe  * them dirty.
96303ba3782SJens Axboe  *
96403ba3782SJens Axboe  * This function *must* be atomic for the I_DIRTY_PAGES case -
96503ba3782SJens Axboe  * set_page_dirty() is called under spinlock in several places.
96603ba3782SJens Axboe  *
96703ba3782SJens Axboe  * Note that for blockdevs, inode->dirtied_when represents the dirtying time of
96803ba3782SJens Axboe  * the block-special inode (/dev/hda1) itself.  And the ->dirtied_when field of
96903ba3782SJens Axboe  * the kernel-internal blockdev inode represents the dirtying time of the
97003ba3782SJens Axboe  * blockdev's pages.  This is why for I_DIRTY_PAGES we always use
97103ba3782SJens Axboe  * page->mapping->host, so the page-dirtying time is recorded in the internal
97203ba3782SJens Axboe  * blockdev inode.
97303ba3782SJens Axboe  */
97403ba3782SJens Axboe void __mark_inode_dirty(struct inode *inode, int flags)
97503ba3782SJens Axboe {
97603ba3782SJens Axboe 	struct super_block *sb = inode->i_sb;
97703ba3782SJens Axboe 
97803ba3782SJens Axboe 	/*
97903ba3782SJens Axboe 	 * Don't do this for I_DIRTY_PAGES - that doesn't actually
98003ba3782SJens Axboe 	 * dirty the inode itself
98103ba3782SJens Axboe 	 */
98203ba3782SJens Axboe 	if (flags & (I_DIRTY_SYNC | I_DIRTY_DATASYNC)) {
98303ba3782SJens Axboe 		if (sb->s_op->dirty_inode)
98403ba3782SJens Axboe 			sb->s_op->dirty_inode(inode);
98503ba3782SJens Axboe 	}
98603ba3782SJens Axboe 
98703ba3782SJens Axboe 	/*
98803ba3782SJens Axboe 	 * make sure that changes are seen by all cpus before we test i_state
98903ba3782SJens Axboe 	 * -- mikulas
99003ba3782SJens Axboe 	 */
99103ba3782SJens Axboe 	smp_mb();
99203ba3782SJens Axboe 
99303ba3782SJens Axboe 	/* avoid the locking if we can */
99403ba3782SJens Axboe 	if ((inode->i_state & flags) == flags)
99503ba3782SJens Axboe 		return;
99603ba3782SJens Axboe 
99703ba3782SJens Axboe 	if (unlikely(block_dump))
99803ba3782SJens Axboe 		block_dump___mark_inode_dirty(inode);
99903ba3782SJens Axboe 
100003ba3782SJens Axboe 	spin_lock(&inode_lock);
100103ba3782SJens Axboe 	if ((inode->i_state & flags) != flags) {
100203ba3782SJens Axboe 		const int was_dirty = inode->i_state & I_DIRTY;
100303ba3782SJens Axboe 
100403ba3782SJens Axboe 		inode->i_state |= flags;
100503ba3782SJens Axboe 
100603ba3782SJens Axboe 		/*
100703ba3782SJens Axboe 		 * If the inode is being synced, just update its dirty state.
100803ba3782SJens Axboe 		 * The unlocker will place the inode on the appropriate
100903ba3782SJens Axboe 		 * superblock list, based upon its state.
101003ba3782SJens Axboe 		 */
101103ba3782SJens Axboe 		if (inode->i_state & I_SYNC)
101203ba3782SJens Axboe 			goto out;
101303ba3782SJens Axboe 
101403ba3782SJens Axboe 		/*
101503ba3782SJens Axboe 		 * Only add valid (hashed) inodes to the superblock's
101603ba3782SJens Axboe 		 * dirty list.  Add blockdev inodes as well.
101703ba3782SJens Axboe 		 */
101803ba3782SJens Axboe 		if (!S_ISBLK(inode->i_mode)) {
101903ba3782SJens Axboe 			if (hlist_unhashed(&inode->i_hash))
102003ba3782SJens Axboe 				goto out;
102103ba3782SJens Axboe 		}
102203ba3782SJens Axboe 		if (inode->i_state & (I_FREEING|I_CLEAR))
102303ba3782SJens Axboe 			goto out;
102403ba3782SJens Axboe 
102503ba3782SJens Axboe 		/*
102603ba3782SJens Axboe 		 * If the inode was already on b_dirty/b_io/b_more_io, don't
102703ba3782SJens Axboe 		 * reposition it (that would break b_dirty time-ordering).
102803ba3782SJens Axboe 		 */
102903ba3782SJens Axboe 		if (!was_dirty) {
103003ba3782SJens Axboe 			struct bdi_writeback *wb = &inode_to_bdi(inode)->wb;
1031500b067cSJens Axboe 			struct backing_dev_info *bdi = wb->bdi;
1032500b067cSJens Axboe 
1033500b067cSJens Axboe 			if (bdi_cap_writeback_dirty(bdi) &&
1034500b067cSJens Axboe 			    !test_bit(BDI_registered, &bdi->state)) {
1035500b067cSJens Axboe 				WARN_ON(1);
1036500b067cSJens Axboe 				printk(KERN_ERR "bdi-%s not registered\n",
1037500b067cSJens Axboe 								bdi->name);
1038500b067cSJens Axboe 			}
103903ba3782SJens Axboe 
104003ba3782SJens Axboe 			inode->dirtied_when = jiffies;
104103ba3782SJens Axboe 			list_move(&inode->i_list, &wb->b_dirty);
104203ba3782SJens Axboe 		}
104303ba3782SJens Axboe 	}
104403ba3782SJens Axboe out:
104503ba3782SJens Axboe 	spin_unlock(&inode_lock);
104603ba3782SJens Axboe }
104703ba3782SJens Axboe EXPORT_SYMBOL(__mark_inode_dirty);
104803ba3782SJens Axboe 
104966f3b8e2SJens Axboe /*
105066f3b8e2SJens Axboe  * Write out a superblock's list of dirty inodes.  A wait will be performed
105166f3b8e2SJens Axboe  * upon no inodes, all inodes or the final one, depending upon sync_mode.
105266f3b8e2SJens Axboe  *
105366f3b8e2SJens Axboe  * If older_than_this is non-NULL, then only write out inodes which
105466f3b8e2SJens Axboe  * had their first dirtying at a time earlier than *older_than_this.
105566f3b8e2SJens Axboe  *
105666f3b8e2SJens Axboe  * If we're a pdlfush thread, then implement pdflush collision avoidance
105766f3b8e2SJens Axboe  * against the entire list.
105866f3b8e2SJens Axboe  *
105966f3b8e2SJens Axboe  * If `bdi' is non-zero then we're being asked to writeback a specific queue.
106066f3b8e2SJens Axboe  * This function assumes that the blockdev superblock's inodes are backed by
106166f3b8e2SJens Axboe  * a variety of queues, so all inodes are searched.  For other superblocks,
106266f3b8e2SJens Axboe  * assume that all inodes are backed by the same queue.
106366f3b8e2SJens Axboe  *
106466f3b8e2SJens Axboe  * The inodes to be written are parked on bdi->b_io.  They are moved back onto
106566f3b8e2SJens Axboe  * bdi->b_dirty as they are selected for writing.  This way, none can be missed
106666f3b8e2SJens Axboe  * on the writer throttling path, and we get decent balancing between many
106766f3b8e2SJens Axboe  * throttled threads: we don't want them all piling up on inode_sync_wait.
106866f3b8e2SJens Axboe  */
106903ba3782SJens Axboe static void wait_sb_inodes(struct writeback_control *wbc)
107066f3b8e2SJens Axboe {
107138f21977SNick Piggin 	struct inode *inode, *old_inode = NULL;
107238f21977SNick Piggin 
107303ba3782SJens Axboe 	/*
107403ba3782SJens Axboe 	 * We need to be protected against the filesystem going from
107503ba3782SJens Axboe 	 * r/o to r/w or vice versa.
107603ba3782SJens Axboe 	 */
107703ba3782SJens Axboe 	WARN_ON(!rwsem_is_locked(&wbc->sb->s_umount));
107803ba3782SJens Axboe 
107966f3b8e2SJens Axboe 	spin_lock(&inode_lock);
108066f3b8e2SJens Axboe 
108138f21977SNick Piggin 	/*
108238f21977SNick Piggin 	 * Data integrity sync. Must wait for all pages under writeback,
108338f21977SNick Piggin 	 * because there may have been pages dirtied before our sync
108438f21977SNick Piggin 	 * call, but which had writeout started before we write it out.
108538f21977SNick Piggin 	 * In which case, the inode may not be on the dirty list, but
108638f21977SNick Piggin 	 * we still have to wait for that writeout.
108738f21977SNick Piggin 	 */
108803ba3782SJens Axboe 	list_for_each_entry(inode, &wbc->sb->s_inodes, i_sb_list) {
108938f21977SNick Piggin 		struct address_space *mapping;
109038f21977SNick Piggin 
109103ba3782SJens Axboe 		if (inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE|I_NEW))
109238f21977SNick Piggin 			continue;
109338f21977SNick Piggin 		mapping = inode->i_mapping;
109438f21977SNick Piggin 		if (mapping->nrpages == 0)
109538f21977SNick Piggin 			continue;
109638f21977SNick Piggin 		__iget(inode);
1097ae8547b0SHans Reiser 		spin_unlock(&inode_lock);
109838f21977SNick Piggin 		/*
109938f21977SNick Piggin 		 * We hold a reference to 'inode' so it couldn't have
110038f21977SNick Piggin 		 * been removed from s_inodes list while we dropped the
110138f21977SNick Piggin 		 * inode_lock.  We cannot iput the inode now as we can
110238f21977SNick Piggin 		 * be holding the last reference and we cannot iput it
110338f21977SNick Piggin 		 * under inode_lock. So we keep the reference and iput
110438f21977SNick Piggin 		 * it later.
110538f21977SNick Piggin 		 */
110638f21977SNick Piggin 		iput(old_inode);
110738f21977SNick Piggin 		old_inode = inode;
110838f21977SNick Piggin 
110938f21977SNick Piggin 		filemap_fdatawait(mapping);
111038f21977SNick Piggin 
111138f21977SNick Piggin 		cond_resched();
111238f21977SNick Piggin 
111338f21977SNick Piggin 		spin_lock(&inode_lock);
111438f21977SNick Piggin 	}
111538f21977SNick Piggin 	spin_unlock(&inode_lock);
111638f21977SNick Piggin 	iput(old_inode);
111766f3b8e2SJens Axboe }
11181da177e4SLinus Torvalds 
1119d8a8559cSJens Axboe /**
1120d8a8559cSJens Axboe  * writeback_inodes_sb	-	writeback dirty inodes from given super_block
1121d8a8559cSJens Axboe  * @sb: the superblock
11221da177e4SLinus Torvalds  *
1123d8a8559cSJens Axboe  * Start writeback on some inodes on this super_block. No guarantees are made
1124d8a8559cSJens Axboe  * on how many (if any) will be written, and this function does not wait
1125d8a8559cSJens Axboe  * for IO completion of submitted IO. The number of pages submitted is
1126d8a8559cSJens Axboe  * returned.
11271da177e4SLinus Torvalds  */
1128d8a8559cSJens Axboe long writeback_inodes_sb(struct super_block *sb)
11291da177e4SLinus Torvalds {
11301da177e4SLinus Torvalds 	struct writeback_control wbc = {
113103ba3782SJens Axboe 		.sb		= sb,
1132d8a8559cSJens Axboe 		.sync_mode	= WB_SYNC_NONE,
1133111ebb6eSOGAWA Hirofumi 		.range_start	= 0,
1134111ebb6eSOGAWA Hirofumi 		.range_end	= LLONG_MAX,
11351da177e4SLinus Torvalds 	};
1136b1e7a8fdSChristoph Lameter 	unsigned long nr_dirty = global_page_state(NR_FILE_DIRTY);
1137fd39fc85SChristoph Lameter 	unsigned long nr_unstable = global_page_state(NR_UNSTABLE_NFS);
1138d8a8559cSJens Axboe 	long nr_to_write;
11391da177e4SLinus Torvalds 
1140d8a8559cSJens Axboe 	nr_to_write = nr_dirty + nr_unstable +
114138f21977SNick Piggin 			(inodes_stat.nr_inodes - inodes_stat.nr_unused);
114238f21977SNick Piggin 
1143d8a8559cSJens Axboe 	wbc.nr_to_write = nr_to_write;
114403ba3782SJens Axboe 	bdi_writeback_all(&wbc);
1145d8a8559cSJens Axboe 	return nr_to_write - wbc.nr_to_write;
11461da177e4SLinus Torvalds }
1147d8a8559cSJens Axboe EXPORT_SYMBOL(writeback_inodes_sb);
1148d8a8559cSJens Axboe 
1149d8a8559cSJens Axboe /**
1150d8a8559cSJens Axboe  * sync_inodes_sb	-	sync sb inode pages
1151d8a8559cSJens Axboe  * @sb: the superblock
1152d8a8559cSJens Axboe  *
1153d8a8559cSJens Axboe  * This function writes and waits on any dirty inode belonging to this
1154d8a8559cSJens Axboe  * super_block. The number of pages synced is returned.
1155d8a8559cSJens Axboe  */
1156d8a8559cSJens Axboe long sync_inodes_sb(struct super_block *sb)
1157d8a8559cSJens Axboe {
1158d8a8559cSJens Axboe 	struct writeback_control wbc = {
115903ba3782SJens Axboe 		.sb		= sb,
1160d8a8559cSJens Axboe 		.sync_mode	= WB_SYNC_ALL,
1161d8a8559cSJens Axboe 		.range_start	= 0,
1162d8a8559cSJens Axboe 		.range_end	= LLONG_MAX,
1163d8a8559cSJens Axboe 	};
1164d8a8559cSJens Axboe 	long nr_to_write = LONG_MAX; /* doesn't actually matter */
1165d8a8559cSJens Axboe 
1166d8a8559cSJens Axboe 	wbc.nr_to_write = nr_to_write;
116703ba3782SJens Axboe 	bdi_writeback_all(&wbc);
116803ba3782SJens Axboe 	wait_sb_inodes(&wbc);
1169d8a8559cSJens Axboe 	return nr_to_write - wbc.nr_to_write;
1170d8a8559cSJens Axboe }
1171d8a8559cSJens Axboe EXPORT_SYMBOL(sync_inodes_sb);
11721da177e4SLinus Torvalds 
11731da177e4SLinus Torvalds /**
11741da177e4SLinus Torvalds  * write_inode_now	-	write an inode to disk
11751da177e4SLinus Torvalds  * @inode: inode to write to disk
11761da177e4SLinus Torvalds  * @sync: whether the write should be synchronous or not
11771da177e4SLinus Torvalds  *
11787f04c26dSAndrea Arcangeli  * This function commits an inode to disk immediately if it is dirty. This is
11797f04c26dSAndrea Arcangeli  * primarily needed by knfsd.
11807f04c26dSAndrea Arcangeli  *
11817f04c26dSAndrea Arcangeli  * The caller must either have a ref on the inode or must have set I_WILL_FREE.
11821da177e4SLinus Torvalds  */
11831da177e4SLinus Torvalds int write_inode_now(struct inode *inode, int sync)
11841da177e4SLinus Torvalds {
11851da177e4SLinus Torvalds 	int ret;
11861da177e4SLinus Torvalds 	struct writeback_control wbc = {
11871da177e4SLinus Torvalds 		.nr_to_write = LONG_MAX,
118818914b18SMike Galbraith 		.sync_mode = sync ? WB_SYNC_ALL : WB_SYNC_NONE,
1189111ebb6eSOGAWA Hirofumi 		.range_start = 0,
1190111ebb6eSOGAWA Hirofumi 		.range_end = LLONG_MAX,
11911da177e4SLinus Torvalds 	};
11921da177e4SLinus Torvalds 
11931da177e4SLinus Torvalds 	if (!mapping_cap_writeback_dirty(inode->i_mapping))
119449364ce2SAndrew Morton 		wbc.nr_to_write = 0;
11951da177e4SLinus Torvalds 
11961da177e4SLinus Torvalds 	might_sleep();
11971da177e4SLinus Torvalds 	spin_lock(&inode_lock);
119801c03194SChristoph Hellwig 	ret = writeback_single_inode(inode, &wbc);
11991da177e4SLinus Torvalds 	spin_unlock(&inode_lock);
12001da177e4SLinus Torvalds 	if (sync)
12011c0eeaf5SJoern Engel 		inode_sync_wait(inode);
12021da177e4SLinus Torvalds 	return ret;
12031da177e4SLinus Torvalds }
12041da177e4SLinus Torvalds EXPORT_SYMBOL(write_inode_now);
12051da177e4SLinus Torvalds 
12061da177e4SLinus Torvalds /**
12071da177e4SLinus Torvalds  * sync_inode - write an inode and its pages to disk.
12081da177e4SLinus Torvalds  * @inode: the inode to sync
12091da177e4SLinus Torvalds  * @wbc: controls the writeback mode
12101da177e4SLinus Torvalds  *
12111da177e4SLinus Torvalds  * sync_inode() will write an inode and its pages to disk.  It will also
12121da177e4SLinus Torvalds  * correctly update the inode on its superblock's dirty inode lists and will
12131da177e4SLinus Torvalds  * update inode->i_state.
12141da177e4SLinus Torvalds  *
12151da177e4SLinus Torvalds  * The caller must have a ref on the inode.
12161da177e4SLinus Torvalds  */
12171da177e4SLinus Torvalds int sync_inode(struct inode *inode, struct writeback_control *wbc)
12181da177e4SLinus Torvalds {
12191da177e4SLinus Torvalds 	int ret;
12201da177e4SLinus Torvalds 
12211da177e4SLinus Torvalds 	spin_lock(&inode_lock);
122201c03194SChristoph Hellwig 	ret = writeback_single_inode(inode, wbc);
12231da177e4SLinus Torvalds 	spin_unlock(&inode_lock);
12241da177e4SLinus Torvalds 	return ret;
12251da177e4SLinus Torvalds }
12261da177e4SLinus Torvalds EXPORT_SYMBOL(sync_inode);
1227