Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 08852b6d6c40f387f2b75e199e2ca1df68970f4c

Authored by Minchan Kim
Committed by Jens Axboe
1 parent 6965031d33
Exists in master and in 7 other branches imx_3.0.35_4.1.0, imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-l5.0.0_1.0.0-ga

writeback: remove wb in get_next_work_item 

83ba7b07 cleans up the writeback.
So we don't use wb any more in get_next_work_item.
Let's remove unnecessary argument.

CC: Christoph Hellwig <hch@lst.de>
Signed-off-by: Minchan Kim <minchan.kim@gmail.com>
Signed-off-by: Jens Axboe <jaxboe@fusionio.com>

Showing 1 changed file with 2 additions and 2 deletions Inline Diff

1 /* 1 /*
2 * fs/fs-writeback.c 2 * fs/fs-writeback.c
3 * 3 *
4 * Copyright (C) 2002, Linus Torvalds. 4 * Copyright (C) 2002, Linus Torvalds.
5 * 5 *
6 * Contains all the functions related to writing back and waiting 6 * Contains all the functions related to writing back and waiting
7 * upon dirty inodes against superblocks, and writing back dirty 7 * upon dirty inodes against superblocks, and writing back dirty
8 * pages against inodes. ie: data writeback. Writeout of the 8 * pages against inodes. ie: data writeback. Writeout of the
9 * inode itself is not handled here. 9 * inode itself is not handled here.
10 * 10 *
11 * 10Apr2002 Andrew Morton 11 * 10Apr2002 Andrew Morton
12 * Split out of fs/inode.c 12 * Split out of fs/inode.c
13 * Additions for address_space-based writeback 13 * Additions for address_space-based writeback
14 */ 14 */
15 15
16 #include <linux/kernel.h> 16 #include <linux/kernel.h>
17 #include <linux/module.h> 17 #include <linux/module.h>
18 #include <linux/spinlock.h> 18 #include <linux/spinlock.h>
19 #include <linux/slab.h> 19 #include <linux/slab.h>
20 #include <linux/sched.h> 20 #include <linux/sched.h>
21 #include <linux/fs.h> 21 #include <linux/fs.h>
22 #include <linux/mm.h> 22 #include <linux/mm.h>
23 #include <linux/kthread.h> 23 #include <linux/kthread.h>
24 #include <linux/freezer.h> 24 #include <linux/freezer.h>
25 #include <linux/writeback.h> 25 #include <linux/writeback.h>
26 #include <linux/blkdev.h> 26 #include <linux/blkdev.h>
27 #include <linux/backing-dev.h> 27 #include <linux/backing-dev.h>
28 #include <linux/buffer_head.h> 28 #include <linux/buffer_head.h>
29 #include <linux/tracepoint.h> 29 #include <linux/tracepoint.h>
30 #include "internal.h" 30 #include "internal.h"
31 31
32 /* 32 /*
33 * Passed into wb_writeback(), essentially a subset of writeback_control 33 * Passed into wb_writeback(), essentially a subset of writeback_control
34 */ 34 */
35 struct wb_writeback_work { 35 struct wb_writeback_work {
36 long nr_pages; 36 long nr_pages;
37 struct super_block *sb; 37 struct super_block *sb;
38 enum writeback_sync_modes sync_mode; 38 enum writeback_sync_modes sync_mode;
39 unsigned int for_kupdate:1; 39 unsigned int for_kupdate:1;
40 unsigned int range_cyclic:1; 40 unsigned int range_cyclic:1;
41 unsigned int for_background:1; 41 unsigned int for_background:1;
42 42
43 struct list_head list; /* pending work list */ 43 struct list_head list; /* pending work list */
44 struct completion *done; /* set if the caller waits */ 44 struct completion *done; /* set if the caller waits */
45 }; 45 };
46 46
47 /* 47 /*
48 * Include the creation of the trace points after defining the 48 * Include the creation of the trace points after defining the
49 * wb_writeback_work structure so that the definition remains local to this 49 * wb_writeback_work structure so that the definition remains local to this
50 * file. 50 * file.
51 */ 51 */
52 #define CREATE_TRACE_POINTS 52 #define CREATE_TRACE_POINTS
53 #include <trace/events/writeback.h> 53 #include <trace/events/writeback.h>
54 54
55 #define inode_to_bdi(inode) ((inode)->i_mapping->backing_dev_info) 55 #define inode_to_bdi(inode) ((inode)->i_mapping->backing_dev_info)
56 56
57 /* 57 /*
58 * We don't actually have pdflush, but this one is exported though /proc... 58 * We don't actually have pdflush, but this one is exported though /proc...
59 */ 59 */
60 int nr_pdflush_threads; 60 int nr_pdflush_threads;
61 61
62 /** 62 /**
63 * writeback_in_progress - determine whether there is writeback in progress 63 * writeback_in_progress - determine whether there is writeback in progress
64 * @bdi: the device's backing_dev_info structure. 64 * @bdi: the device's backing_dev_info structure.
65 * 65 *
66 * Determine whether there is writeback waiting to be handled against a 66 * Determine whether there is writeback waiting to be handled against a
67 * backing device. 67 * backing device.
68 */ 68 */
69 int writeback_in_progress(struct backing_dev_info *bdi) 69 int writeback_in_progress(struct backing_dev_info *bdi)
70 { 70 {
71 return !list_empty(&bdi->work_list); 71 return !list_empty(&bdi->work_list);
72 } 72 }
73 73
74 static void bdi_queue_work(struct backing_dev_info *bdi, 74 static void bdi_queue_work(struct backing_dev_info *bdi,
75 struct wb_writeback_work *work) 75 struct wb_writeback_work *work)
76 { 76 {
77 trace_writeback_queue(bdi, work); 77 trace_writeback_queue(bdi, work);
78 78
79 spin_lock(&bdi->wb_lock); 79 spin_lock(&bdi->wb_lock);
80 list_add_tail(&work->list, &bdi->work_list); 80 list_add_tail(&work->list, &bdi->work_list);
81 spin_unlock(&bdi->wb_lock); 81 spin_unlock(&bdi->wb_lock);
82 82
83 /* 83 /*
84 * If the default thread isn't there, make sure we add it. When 84 * If the default thread isn't there, make sure we add it. When
85 * it gets created and wakes up, we'll run this work. 85 * it gets created and wakes up, we'll run this work.
86 */ 86 */
87 if (unlikely(!bdi->wb.task)) { 87 if (unlikely(!bdi->wb.task)) {
88 trace_writeback_nothread(bdi, work); 88 trace_writeback_nothread(bdi, work);
89 wake_up_process(default_backing_dev_info.wb.task); 89 wake_up_process(default_backing_dev_info.wb.task);
90 } else { 90 } else {
91 struct bdi_writeback *wb = &bdi->wb; 91 struct bdi_writeback *wb = &bdi->wb;
92 92
93 if (wb->task) 93 if (wb->task)
94 wake_up_process(wb->task); 94 wake_up_process(wb->task);
95 } 95 }
96 } 96 }
97 97
98 static void 98 static void
99 __bdi_start_writeback(struct backing_dev_info *bdi, long nr_pages, 99 __bdi_start_writeback(struct backing_dev_info *bdi, long nr_pages,
100 bool range_cyclic, bool for_background) 100 bool range_cyclic, bool for_background)
101 { 101 {
102 struct wb_writeback_work *work; 102 struct wb_writeback_work *work;
103 103
104 /* 104 /*
105 * This is WB_SYNC_NONE writeback, so if allocation fails just 105 * This is WB_SYNC_NONE writeback, so if allocation fails just
106 * wakeup the thread for old dirty data writeback 106 * wakeup the thread for old dirty data writeback
107 */ 107 */
108 work = kzalloc(sizeof(*work), GFP_ATOMIC); 108 work = kzalloc(sizeof(*work), GFP_ATOMIC);
109 if (!work) { 109 if (!work) {
110 if (bdi->wb.task) { 110 if (bdi->wb.task) {
111 trace_writeback_nowork(bdi); 111 trace_writeback_nowork(bdi);
112 wake_up_process(bdi->wb.task); 112 wake_up_process(bdi->wb.task);
113 } 113 }
114 return; 114 return;
115 } 115 }
116 116
117 work->sync_mode = WB_SYNC_NONE; 117 work->sync_mode = WB_SYNC_NONE;
118 work->nr_pages = nr_pages; 118 work->nr_pages = nr_pages;
119 work->range_cyclic = range_cyclic; 119 work->range_cyclic = range_cyclic;
120 work->for_background = for_background; 120 work->for_background = for_background;
121 121
122 bdi_queue_work(bdi, work); 122 bdi_queue_work(bdi, work);
123 } 123 }
124 124
125 /** 125 /**
126 * bdi_start_writeback - start writeback 126 * bdi_start_writeback - start writeback
127 * @bdi: the backing device to write from 127 * @bdi: the backing device to write from
128 * @nr_pages: the number of pages to write 128 * @nr_pages: the number of pages to write
129 * 129 *
130 * Description: 130 * Description:
131 * This does WB_SYNC_NONE opportunistic writeback. The IO is only 131 * This does WB_SYNC_NONE opportunistic writeback. The IO is only
132 * started when this function returns, we make no guarentees on 132 * started when this function returns, we make no guarentees on
133 * completion. Caller need not hold sb s_umount semaphore. 133 * completion. Caller need not hold sb s_umount semaphore.
134 * 134 *
135 */ 135 */
136 void bdi_start_writeback(struct backing_dev_info *bdi, long nr_pages) 136 void bdi_start_writeback(struct backing_dev_info *bdi, long nr_pages)
137 { 137 {
138 __bdi_start_writeback(bdi, nr_pages, true, false); 138 __bdi_start_writeback(bdi, nr_pages, true, false);
139 } 139 }
140 140
141 /** 141 /**
142 * bdi_start_background_writeback - start background writeback 142 * bdi_start_background_writeback - start background writeback
143 * @bdi: the backing device to write from 143 * @bdi: the backing device to write from
144 * 144 *
145 * Description: 145 * Description:
146 * This does WB_SYNC_NONE background writeback. The IO is only 146 * This does WB_SYNC_NONE background writeback. The IO is only
147 * started when this function returns, we make no guarentees on 147 * started when this function returns, we make no guarentees on
148 * completion. Caller need not hold sb s_umount semaphore. 148 * completion. Caller need not hold sb s_umount semaphore.
149 */ 149 */
150 void bdi_start_background_writeback(struct backing_dev_info *bdi) 150 void bdi_start_background_writeback(struct backing_dev_info *bdi)
151 { 151 {
152 __bdi_start_writeback(bdi, LONG_MAX, true, true); 152 __bdi_start_writeback(bdi, LONG_MAX, true, true);
153 } 153 }
154 154
155 /* 155 /*
156 * Redirty an inode: set its when-it-was dirtied timestamp and move it to the 156 * Redirty an inode: set its when-it-was dirtied timestamp and move it to the
157 * furthest end of its superblock's dirty-inode list. 157 * furthest end of its superblock's dirty-inode list.
158 * 158 *
159 * Before stamping the inode's ->dirtied_when, we check to see whether it is 159 * Before stamping the inode's ->dirtied_when, we check to see whether it is
160 * already the most-recently-dirtied inode on the b_dirty list. If that is 160 * already the most-recently-dirtied inode on the b_dirty list. If that is
161 * the case then the inode must have been redirtied while it was being written 161 * the case then the inode must have been redirtied while it was being written
162 * out and we don't reset its dirtied_when. 162 * out and we don't reset its dirtied_when.
163 */ 163 */
164 static void redirty_tail(struct inode *inode) 164 static void redirty_tail(struct inode *inode)
165 { 165 {
166 struct bdi_writeback *wb = &inode_to_bdi(inode)->wb; 166 struct bdi_writeback *wb = &inode_to_bdi(inode)->wb;
167 167
168 if (!list_empty(&wb->b_dirty)) { 168 if (!list_empty(&wb->b_dirty)) {
169 struct inode *tail; 169 struct inode *tail;
170 170
171 tail = list_entry(wb->b_dirty.next, struct inode, i_list); 171 tail = list_entry(wb->b_dirty.next, struct inode, i_list);
172 if (time_before(inode->dirtied_when, tail->dirtied_when)) 172 if (time_before(inode->dirtied_when, tail->dirtied_when))
173 inode->dirtied_when = jiffies; 173 inode->dirtied_when = jiffies;
174 } 174 }
175 list_move(&inode->i_list, &wb->b_dirty); 175 list_move(&inode->i_list, &wb->b_dirty);
176 } 176 }
177 177
178 /* 178 /*
179 * requeue inode for re-scanning after bdi->b_io list is exhausted. 179 * requeue inode for re-scanning after bdi->b_io list is exhausted.
180 */ 180 */
181 static void requeue_io(struct inode *inode) 181 static void requeue_io(struct inode *inode)
182 { 182 {
183 struct bdi_writeback *wb = &inode_to_bdi(inode)->wb; 183 struct bdi_writeback *wb = &inode_to_bdi(inode)->wb;
184 184
185 list_move(&inode->i_list, &wb->b_more_io); 185 list_move(&inode->i_list, &wb->b_more_io);
186 } 186 }
187 187
188 static void inode_sync_complete(struct inode *inode) 188 static void inode_sync_complete(struct inode *inode)
189 { 189 {
190 /* 190 /*
191 * Prevent speculative execution through spin_unlock(&inode_lock); 191 * Prevent speculative execution through spin_unlock(&inode_lock);
192 */ 192 */
193 smp_mb(); 193 smp_mb();
194 wake_up_bit(&inode->i_state, __I_SYNC); 194 wake_up_bit(&inode->i_state, __I_SYNC);
195 } 195 }
196 196
197 static bool inode_dirtied_after(struct inode *inode, unsigned long t) 197 static bool inode_dirtied_after(struct inode *inode, unsigned long t)
198 { 198 {
199 bool ret = time_after(inode->dirtied_when, t); 199 bool ret = time_after(inode->dirtied_when, t);
200 #ifndef CONFIG_64BIT 200 #ifndef CONFIG_64BIT
201 /* 201 /*
202 * For inodes being constantly redirtied, dirtied_when can get stuck. 202 * For inodes being constantly redirtied, dirtied_when can get stuck.
203 * It _appears_ to be in the future, but is actually in distant past. 203 * It _appears_ to be in the future, but is actually in distant past.
204 * This test is necessary to prevent such wrapped-around relative times 204 * This test is necessary to prevent such wrapped-around relative times
205 * from permanently stopping the whole bdi writeback. 205 * from permanently stopping the whole bdi writeback.
206 */ 206 */
207 ret = ret && time_before_eq(inode->dirtied_when, jiffies); 207 ret = ret && time_before_eq(inode->dirtied_when, jiffies);
208 #endif 208 #endif
209 return ret; 209 return ret;
210 } 210 }
211 211
212 /* 212 /*
213 * Move expired dirty inodes from @delaying_queue to @dispatch_queue. 213 * Move expired dirty inodes from @delaying_queue to @dispatch_queue.
214 */ 214 */
215 static void move_expired_inodes(struct list_head *delaying_queue, 215 static void move_expired_inodes(struct list_head *delaying_queue,
216 struct list_head *dispatch_queue, 216 struct list_head *dispatch_queue,
217 unsigned long *older_than_this) 217 unsigned long *older_than_this)
218 { 218 {
219 LIST_HEAD(tmp); 219 LIST_HEAD(tmp);
220 struct list_head *pos, *node; 220 struct list_head *pos, *node;
221 struct super_block *sb = NULL; 221 struct super_block *sb = NULL;
222 struct inode *inode; 222 struct inode *inode;
223 int do_sb_sort = 0; 223 int do_sb_sort = 0;
224 224
225 while (!list_empty(delaying_queue)) { 225 while (!list_empty(delaying_queue)) {
226 inode = list_entry(delaying_queue->prev, struct inode, i_list); 226 inode = list_entry(delaying_queue->prev, struct inode, i_list);
227 if (older_than_this && 227 if (older_than_this &&
228 inode_dirtied_after(inode, *older_than_this)) 228 inode_dirtied_after(inode, *older_than_this))
229 break; 229 break;
230 if (sb && sb != inode->i_sb) 230 if (sb && sb != inode->i_sb)
231 do_sb_sort = 1; 231 do_sb_sort = 1;
232 sb = inode->i_sb; 232 sb = inode->i_sb;
233 list_move(&inode->i_list, &tmp); 233 list_move(&inode->i_list, &tmp);
234 } 234 }
235 235
236 /* just one sb in list, splice to dispatch_queue and we're done */ 236 /* just one sb in list, splice to dispatch_queue and we're done */
237 if (!do_sb_sort) { 237 if (!do_sb_sort) {
238 list_splice(&tmp, dispatch_queue); 238 list_splice(&tmp, dispatch_queue);
239 return; 239 return;
240 } 240 }
241 241
242 /* Move inodes from one superblock together */ 242 /* Move inodes from one superblock together */
243 while (!list_empty(&tmp)) { 243 while (!list_empty(&tmp)) {
244 inode = list_entry(tmp.prev, struct inode, i_list); 244 inode = list_entry(tmp.prev, struct inode, i_list);
245 sb = inode->i_sb; 245 sb = inode->i_sb;
246 list_for_each_prev_safe(pos, node, &tmp) { 246 list_for_each_prev_safe(pos, node, &tmp) {
247 inode = list_entry(pos, struct inode, i_list); 247 inode = list_entry(pos, struct inode, i_list);
248 if (inode->i_sb == sb) 248 if (inode->i_sb == sb)
249 list_move(&inode->i_list, dispatch_queue); 249 list_move(&inode->i_list, dispatch_queue);
250 } 250 }
251 } 251 }
252 } 252 }
253 253
254 /* 254 /*
255 * Queue all expired dirty inodes for io, eldest first. 255 * Queue all expired dirty inodes for io, eldest first.
256 */ 256 */
257 static void queue_io(struct bdi_writeback *wb, unsigned long *older_than_this) 257 static void queue_io(struct bdi_writeback *wb, unsigned long *older_than_this)
258 { 258 {
259 list_splice_init(&wb->b_more_io, wb->b_io.prev); 259 list_splice_init(&wb->b_more_io, wb->b_io.prev);
260 move_expired_inodes(&wb->b_dirty, &wb->b_io, older_than_this); 260 move_expired_inodes(&wb->b_dirty, &wb->b_io, older_than_this);
261 } 261 }
262 262
263 static int write_inode(struct inode *inode, struct writeback_control *wbc) 263 static int write_inode(struct inode *inode, struct writeback_control *wbc)
264 { 264 {
265 if (inode->i_sb->s_op->write_inode && !is_bad_inode(inode)) 265 if (inode->i_sb->s_op->write_inode && !is_bad_inode(inode))
266 return inode->i_sb->s_op->write_inode(inode, wbc); 266 return inode->i_sb->s_op->write_inode(inode, wbc);
267 return 0; 267 return 0;
268 } 268 }
269 269
270 /* 270 /*
271 * Wait for writeback on an inode to complete. 271 * Wait for writeback on an inode to complete.
272 */ 272 */
273 static void inode_wait_for_writeback(struct inode *inode) 273 static void inode_wait_for_writeback(struct inode *inode)
274 { 274 {
275 DEFINE_WAIT_BIT(wq, &inode->i_state, __I_SYNC); 275 DEFINE_WAIT_BIT(wq, &inode->i_state, __I_SYNC);
276 wait_queue_head_t *wqh; 276 wait_queue_head_t *wqh;
277 277
278 wqh = bit_waitqueue(&inode->i_state, __I_SYNC); 278 wqh = bit_waitqueue(&inode->i_state, __I_SYNC);
279 while (inode->i_state & I_SYNC) { 279 while (inode->i_state & I_SYNC) {
280 spin_unlock(&inode_lock); 280 spin_unlock(&inode_lock);
281 __wait_on_bit(wqh, &wq, inode_wait, TASK_UNINTERRUPTIBLE); 281 __wait_on_bit(wqh, &wq, inode_wait, TASK_UNINTERRUPTIBLE);
282 spin_lock(&inode_lock); 282 spin_lock(&inode_lock);
283 } 283 }
284 } 284 }
285 285
286 /* 286 /*
287 * Write out an inode's dirty pages. Called under inode_lock. Either the 287 * Write out an inode's dirty pages. Called under inode_lock. Either the
288 * caller has ref on the inode (either via __iget or via syscall against an fd) 288 * caller has ref on the inode (either via __iget or via syscall against an fd)
289 * or the inode has I_WILL_FREE set (via generic_forget_inode) 289 * or the inode has I_WILL_FREE set (via generic_forget_inode)
290 * 290 *
291 * If `wait' is set, wait on the writeout. 291 * If `wait' is set, wait on the writeout.
292 * 292 *
293 * The whole writeout design is quite complex and fragile. We want to avoid 293 * The whole writeout design is quite complex and fragile. We want to avoid
294 * starvation of particular inodes when others are being redirtied, prevent 294 * starvation of particular inodes when others are being redirtied, prevent
295 * livelocks, etc. 295 * livelocks, etc.
296 * 296 *
297 * Called under inode_lock. 297 * Called under inode_lock.
298 */ 298 */
299 static int 299 static int
300 writeback_single_inode(struct inode *inode, struct writeback_control *wbc) 300 writeback_single_inode(struct inode *inode, struct writeback_control *wbc)
301 { 301 {
302 struct address_space *mapping = inode->i_mapping; 302 struct address_space *mapping = inode->i_mapping;
303 unsigned dirty; 303 unsigned dirty;
304 int ret; 304 int ret;
305 305
306 if (!atomic_read(&inode->i_count)) 306 if (!atomic_read(&inode->i_count))
307 WARN_ON(!(inode->i_state & (I_WILL_FREE|I_FREEING))); 307 WARN_ON(!(inode->i_state & (I_WILL_FREE|I_FREEING)));
308 else 308 else
309 WARN_ON(inode->i_state & I_WILL_FREE); 309 WARN_ON(inode->i_state & I_WILL_FREE);
310 310
311 if (inode->i_state & I_SYNC) { 311 if (inode->i_state & I_SYNC) {
312 /* 312 /*
313 * If this inode is locked for writeback and we are not doing 313 * If this inode is locked for writeback and we are not doing
314 * writeback-for-data-integrity, move it to b_more_io so that 314 * writeback-for-data-integrity, move it to b_more_io so that
315 * writeback can proceed with the other inodes on s_io. 315 * writeback can proceed with the other inodes on s_io.
316 * 316 *
317 * We'll have another go at writing back this inode when we 317 * We'll have another go at writing back this inode when we
318 * completed a full scan of b_io. 318 * completed a full scan of b_io.
319 */ 319 */
320 if (wbc->sync_mode != WB_SYNC_ALL) { 320 if (wbc->sync_mode != WB_SYNC_ALL) {
321 requeue_io(inode); 321 requeue_io(inode);
322 return 0; 322 return 0;
323 } 323 }
324 324
325 /* 325 /*
326 * It's a data-integrity sync. We must wait. 326 * It's a data-integrity sync. We must wait.
327 */ 327 */
328 inode_wait_for_writeback(inode); 328 inode_wait_for_writeback(inode);
329 } 329 }
330 330
331 BUG_ON(inode->i_state & I_SYNC); 331 BUG_ON(inode->i_state & I_SYNC);
332 332
333 /* Set I_SYNC, reset I_DIRTY_PAGES */ 333 /* Set I_SYNC, reset I_DIRTY_PAGES */
334 inode->i_state |= I_SYNC; 334 inode->i_state |= I_SYNC;
335 inode->i_state &= ~I_DIRTY_PAGES; 335 inode->i_state &= ~I_DIRTY_PAGES;
336 spin_unlock(&inode_lock); 336 spin_unlock(&inode_lock);
337 337
338 ret = do_writepages(mapping, wbc); 338 ret = do_writepages(mapping, wbc);
339 339
340 /* 340 /*
341 * Make sure to wait on the data before writing out the metadata. 341 * Make sure to wait on the data before writing out the metadata.
342 * This is important for filesystems that modify metadata on data 342 * This is important for filesystems that modify metadata on data
343 * I/O completion. 343 * I/O completion.
344 */ 344 */
345 if (wbc->sync_mode == WB_SYNC_ALL) { 345 if (wbc->sync_mode == WB_SYNC_ALL) {
346 int err = filemap_fdatawait(mapping); 346 int err = filemap_fdatawait(mapping);
347 if (ret == 0) 347 if (ret == 0)
348 ret = err; 348 ret = err;
349 } 349 }
350 350
351 /* 351 /*
352 * Some filesystems may redirty the inode during the writeback 352 * Some filesystems may redirty the inode during the writeback
353 * due to delalloc, clear dirty metadata flags right before 353 * due to delalloc, clear dirty metadata flags right before
354 * write_inode() 354 * write_inode()
355 */ 355 */
356 spin_lock(&inode_lock); 356 spin_lock(&inode_lock);
357 dirty = inode->i_state & I_DIRTY; 357 dirty = inode->i_state & I_DIRTY;
358 inode->i_state &= ~(I_DIRTY_SYNC | I_DIRTY_DATASYNC); 358 inode->i_state &= ~(I_DIRTY_SYNC | I_DIRTY_DATASYNC);
359 spin_unlock(&inode_lock); 359 spin_unlock(&inode_lock);
360 /* Don't write the inode if only I_DIRTY_PAGES was set */ 360 /* Don't write the inode if only I_DIRTY_PAGES was set */
361 if (dirty & (I_DIRTY_SYNC | I_DIRTY_DATASYNC)) { 361 if (dirty & (I_DIRTY_SYNC | I_DIRTY_DATASYNC)) {
362 int err = write_inode(inode, wbc); 362 int err = write_inode(inode, wbc);
363 if (ret == 0) 363 if (ret == 0)
364 ret = err; 364 ret = err;
365 } 365 }
366 366
367 spin_lock(&inode_lock); 367 spin_lock(&inode_lock);
368 inode->i_state &= ~I_SYNC; 368 inode->i_state &= ~I_SYNC;
369 if (!(inode->i_state & (I_FREEING | I_CLEAR))) { 369 if (!(inode->i_state & (I_FREEING | I_CLEAR))) {
370 if ((inode->i_state & I_DIRTY_PAGES) && wbc->for_kupdate) { 370 if ((inode->i_state & I_DIRTY_PAGES) && wbc->for_kupdate) {
371 /* 371 /*
372 * More pages get dirtied by a fast dirtier. 372 * More pages get dirtied by a fast dirtier.
373 */ 373 */
374 goto select_queue; 374 goto select_queue;
375 } else if (inode->i_state & I_DIRTY) { 375 } else if (inode->i_state & I_DIRTY) {
376 /* 376 /*
377 * At least XFS will redirty the inode during the 377 * At least XFS will redirty the inode during the
378 * writeback (delalloc) and on io completion (isize). 378 * writeback (delalloc) and on io completion (isize).
379 */ 379 */
380 redirty_tail(inode); 380 redirty_tail(inode);
381 } else if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) { 381 } else if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) {
382 /* 382 /*
383 * We didn't write back all the pages. nfs_writepages() 383 * We didn't write back all the pages. nfs_writepages()
384 * sometimes bales out without doing anything. Redirty 384 * sometimes bales out without doing anything. Redirty
385 * the inode; Move it from b_io onto b_more_io/b_dirty. 385 * the inode; Move it from b_io onto b_more_io/b_dirty.
386 */ 386 */
387 /* 387 /*
388 * akpm: if the caller was the kupdate function we put 388 * akpm: if the caller was the kupdate function we put
389 * this inode at the head of b_dirty so it gets first 389 * this inode at the head of b_dirty so it gets first
390 * consideration. Otherwise, move it to the tail, for 390 * consideration. Otherwise, move it to the tail, for
391 * the reasons described there. I'm not really sure 391 * the reasons described there. I'm not really sure
392 * how much sense this makes. Presumably I had a good 392 * how much sense this makes. Presumably I had a good
393 * reasons for doing it this way, and I'd rather not 393 * reasons for doing it this way, and I'd rather not
394 * muck with it at present. 394 * muck with it at present.
395 */ 395 */
396 if (wbc->for_kupdate) { 396 if (wbc->for_kupdate) {
397 /* 397 /*
398 * For the kupdate function we move the inode 398 * For the kupdate function we move the inode
399 * to b_more_io so it will get more writeout as 399 * to b_more_io so it will get more writeout as
400 * soon as the queue becomes uncongested. 400 * soon as the queue becomes uncongested.
401 */ 401 */
402 inode->i_state |= I_DIRTY_PAGES; 402 inode->i_state |= I_DIRTY_PAGES;
403 select_queue: 403 select_queue:
404 if (wbc->nr_to_write <= 0) { 404 if (wbc->nr_to_write <= 0) {
405 /* 405 /*
406 * slice used up: queue for next turn 406 * slice used up: queue for next turn
407 */ 407 */
408 requeue_io(inode); 408 requeue_io(inode);
409 } else { 409 } else {
410 /* 410 /*
411 * somehow blocked: retry later 411 * somehow blocked: retry later
412 */ 412 */
413 redirty_tail(inode); 413 redirty_tail(inode);
414 } 414 }
415 } else { 415 } else {
416 /* 416 /*
417 * Otherwise fully redirty the inode so that 417 * Otherwise fully redirty the inode so that
418 * other inodes on this superblock will get some 418 * other inodes on this superblock will get some
419 * writeout. Otherwise heavy writing to one 419 * writeout. Otherwise heavy writing to one
420 * file would indefinitely suspend writeout of 420 * file would indefinitely suspend writeout of
421 * all the other files. 421 * all the other files.
422 */ 422 */
423 inode->i_state |= I_DIRTY_PAGES; 423 inode->i_state |= I_DIRTY_PAGES;
424 redirty_tail(inode); 424 redirty_tail(inode);
425 } 425 }
426 } else if (atomic_read(&inode->i_count)) { 426 } else if (atomic_read(&inode->i_count)) {
427 /* 427 /*
428 * The inode is clean, inuse 428 * The inode is clean, inuse
429 */ 429 */
430 list_move(&inode->i_list, &inode_in_use); 430 list_move(&inode->i_list, &inode_in_use);
431 } else { 431 } else {
432 /* 432 /*
433 * The inode is clean, unused 433 * The inode is clean, unused
434 */ 434 */
435 list_move(&inode->i_list, &inode_unused); 435 list_move(&inode->i_list, &inode_unused);
436 } 436 }
437 } 437 }
438 inode_sync_complete(inode); 438 inode_sync_complete(inode);
439 return ret; 439 return ret;
440 } 440 }
441 441
442 /* 442 /*
443 * For background writeback the caller does not have the sb pinned 443 * For background writeback the caller does not have the sb pinned
444 * before calling writeback. So make sure that we do pin it, so it doesn't 444 * before calling writeback. So make sure that we do pin it, so it doesn't
445 * go away while we are writing inodes from it. 445 * go away while we are writing inodes from it.
446 */ 446 */
447 static bool pin_sb_for_writeback(struct super_block *sb) 447 static bool pin_sb_for_writeback(struct super_block *sb)
448 { 448 {
449 spin_lock(&sb_lock); 449 spin_lock(&sb_lock);
450 if (list_empty(&sb->s_instances)) { 450 if (list_empty(&sb->s_instances)) {
451 spin_unlock(&sb_lock); 451 spin_unlock(&sb_lock);
452 return false; 452 return false;
453 } 453 }
454 454
455 sb->s_count++; 455 sb->s_count++;
456 spin_unlock(&sb_lock); 456 spin_unlock(&sb_lock);
457 457
458 if (down_read_trylock(&sb->s_umount)) { 458 if (down_read_trylock(&sb->s_umount)) {
459 if (sb->s_root) 459 if (sb->s_root)
460 return true; 460 return true;
461 up_read(&sb->s_umount); 461 up_read(&sb->s_umount);
462 } 462 }
463 463
464 put_super(sb); 464 put_super(sb);
465 return false; 465 return false;
466 } 466 }
467 467
468 /* 468 /*
469 * Write a portion of b_io inodes which belong to @sb. 469 * Write a portion of b_io inodes which belong to @sb.
470 * 470 *
471 * If @only_this_sb is true, then find and write all such 471 * If @only_this_sb is true, then find and write all such
472 * inodes. Otherwise write only ones which go sequentially 472 * inodes. Otherwise write only ones which go sequentially
473 * in reverse order. 473 * in reverse order.
474 * 474 *
475 * Return 1, if the caller writeback routine should be 475 * Return 1, if the caller writeback routine should be
476 * interrupted. Otherwise return 0. 476 * interrupted. Otherwise return 0.
477 */ 477 */
478 static int writeback_sb_inodes(struct super_block *sb, struct bdi_writeback *wb, 478 static int writeback_sb_inodes(struct super_block *sb, struct bdi_writeback *wb,
479 struct writeback_control *wbc, bool only_this_sb) 479 struct writeback_control *wbc, bool only_this_sb)
480 { 480 {
481 while (!list_empty(&wb->b_io)) { 481 while (!list_empty(&wb->b_io)) {
482 long pages_skipped; 482 long pages_skipped;
483 struct inode *inode = list_entry(wb->b_io.prev, 483 struct inode *inode = list_entry(wb->b_io.prev,
484 struct inode, i_list); 484 struct inode, i_list);
485 485
486 if (inode->i_sb != sb) { 486 if (inode->i_sb != sb) {
487 if (only_this_sb) { 487 if (only_this_sb) {
488 /* 488 /*
489 * We only want to write back data for this 489 * We only want to write back data for this
490 * superblock, move all inodes not belonging 490 * superblock, move all inodes not belonging
491 * to it back onto the dirty list. 491 * to it back onto the dirty list.
492 */ 492 */
493 redirty_tail(inode); 493 redirty_tail(inode);
494 continue; 494 continue;
495 } 495 }
496 496
497 /* 497 /*
498 * The inode belongs to a different superblock. 498 * The inode belongs to a different superblock.
499 * Bounce back to the caller to unpin this and 499 * Bounce back to the caller to unpin this and
500 * pin the next superblock. 500 * pin the next superblock.
501 */ 501 */
502 return 0; 502 return 0;
503 } 503 }
504 504
505 if (inode->i_state & (I_NEW | I_WILL_FREE)) { 505 if (inode->i_state & (I_NEW | I_WILL_FREE)) {
506 requeue_io(inode); 506 requeue_io(inode);
507 continue; 507 continue;
508 } 508 }
509 /* 509 /*
510 * Was this inode dirtied after sync_sb_inodes was called? 510 * Was this inode dirtied after sync_sb_inodes was called?
511 * This keeps sync from extra jobs and livelock. 511 * This keeps sync from extra jobs and livelock.
512 */ 512 */
513 if (inode_dirtied_after(inode, wbc->wb_start)) 513 if (inode_dirtied_after(inode, wbc->wb_start))
514 return 1; 514 return 1;
515 515
516 BUG_ON(inode->i_state & (I_FREEING | I_CLEAR)); 516 BUG_ON(inode->i_state & (I_FREEING | I_CLEAR));
517 __iget(inode); 517 __iget(inode);
518 pages_skipped = wbc->pages_skipped; 518 pages_skipped = wbc->pages_skipped;
519 writeback_single_inode(inode, wbc); 519 writeback_single_inode(inode, wbc);
520 if (wbc->pages_skipped != pages_skipped) { 520 if (wbc->pages_skipped != pages_skipped) {
521 /* 521 /*
522 * writeback is not making progress due to locked 522 * writeback is not making progress due to locked
523 * buffers. Skip this inode for now. 523 * buffers. Skip this inode for now.
524 */ 524 */
525 redirty_tail(inode); 525 redirty_tail(inode);
526 } 526 }
527 spin_unlock(&inode_lock); 527 spin_unlock(&inode_lock);
528 iput(inode); 528 iput(inode);
529 cond_resched(); 529 cond_resched();
530 spin_lock(&inode_lock); 530 spin_lock(&inode_lock);
531 if (wbc->nr_to_write <= 0) { 531 if (wbc->nr_to_write <= 0) {
532 wbc->more_io = 1; 532 wbc->more_io = 1;
533 return 1; 533 return 1;
534 } 534 }
535 if (!list_empty(&wb->b_more_io)) 535 if (!list_empty(&wb->b_more_io))
536 wbc->more_io = 1; 536 wbc->more_io = 1;
537 } 537 }
538 /* b_io is empty */ 538 /* b_io is empty */
539 return 1; 539 return 1;
540 } 540 }
541 541
542 void writeback_inodes_wb(struct bdi_writeback *wb, 542 void writeback_inodes_wb(struct bdi_writeback *wb,
543 struct writeback_control *wbc) 543 struct writeback_control *wbc)
544 { 544 {
545 int ret = 0; 545 int ret = 0;
546 546
547 wbc->wb_start = jiffies; /* livelock avoidance */ 547 wbc->wb_start = jiffies; /* livelock avoidance */
548 spin_lock(&inode_lock); 548 spin_lock(&inode_lock);
549 if (!wbc->for_kupdate || list_empty(&wb->b_io)) 549 if (!wbc->for_kupdate || list_empty(&wb->b_io))
550 queue_io(wb, wbc->older_than_this); 550 queue_io(wb, wbc->older_than_this);
551 551
552 while (!list_empty(&wb->b_io)) { 552 while (!list_empty(&wb->b_io)) {
553 struct inode *inode = list_entry(wb->b_io.prev, 553 struct inode *inode = list_entry(wb->b_io.prev,
554 struct inode, i_list); 554 struct inode, i_list);
555 struct super_block *sb = inode->i_sb; 555 struct super_block *sb = inode->i_sb;
556 556
557 if (!pin_sb_for_writeback(sb)) { 557 if (!pin_sb_for_writeback(sb)) {
558 requeue_io(inode); 558 requeue_io(inode);
559 continue; 559 continue;
560 } 560 }
561 ret = writeback_sb_inodes(sb, wb, wbc, false); 561 ret = writeback_sb_inodes(sb, wb, wbc, false);
562 drop_super(sb); 562 drop_super(sb);
563 563
564 if (ret) 564 if (ret)
565 break; 565 break;
566 } 566 }
567 spin_unlock(&inode_lock); 567 spin_unlock(&inode_lock);
568 /* Leave any unwritten inodes on b_io */ 568 /* Leave any unwritten inodes on b_io */
569 } 569 }
570 570
571 static void __writeback_inodes_sb(struct super_block *sb, 571 static void __writeback_inodes_sb(struct super_block *sb,
572 struct bdi_writeback *wb, struct writeback_control *wbc) 572 struct bdi_writeback *wb, struct writeback_control *wbc)
573 { 573 {
574 WARN_ON(!rwsem_is_locked(&sb->s_umount)); 574 WARN_ON(!rwsem_is_locked(&sb->s_umount));
575 575
576 wbc->wb_start = jiffies; /* livelock avoidance */ 576 wbc->wb_start = jiffies; /* livelock avoidance */
577 spin_lock(&inode_lock); 577 spin_lock(&inode_lock);
578 if (!wbc->for_kupdate || list_empty(&wb->b_io)) 578 if (!wbc->for_kupdate || list_empty(&wb->b_io))
579 queue_io(wb, wbc->older_than_this); 579 queue_io(wb, wbc->older_than_this);
580 writeback_sb_inodes(sb, wb, wbc, true); 580 writeback_sb_inodes(sb, wb, wbc, true);
581 spin_unlock(&inode_lock); 581 spin_unlock(&inode_lock);
582 } 582 }
583 583
584 /* 584 /*
585 * The maximum number of pages to writeout in a single bdi flush/kupdate 585 * The maximum number of pages to writeout in a single bdi flush/kupdate
586 * operation. We do this so we don't hold I_SYNC against an inode for 586 * operation. We do this so we don't hold I_SYNC against an inode for
587 * enormous amounts of time, which would block a userspace task which has 587 * enormous amounts of time, which would block a userspace task which has
588 * been forced to throttle against that inode. Also, the code reevaluates 588 * been forced to throttle against that inode. Also, the code reevaluates
589 * the dirty each time it has written this many pages. 589 * the dirty each time it has written this many pages.
590 */ 590 */
591 #define MAX_WRITEBACK_PAGES 1024 591 #define MAX_WRITEBACK_PAGES 1024
592 592
593 static inline bool over_bground_thresh(void) 593 static inline bool over_bground_thresh(void)
594 { 594 {
595 unsigned long background_thresh, dirty_thresh; 595 unsigned long background_thresh, dirty_thresh;
596 596
597 get_dirty_limits(&background_thresh, &dirty_thresh, NULL, NULL); 597 get_dirty_limits(&background_thresh, &dirty_thresh, NULL, NULL);
598 598
599 return (global_page_state(NR_FILE_DIRTY) + 599 return (global_page_state(NR_FILE_DIRTY) +
600 global_page_state(NR_UNSTABLE_NFS) >= background_thresh); 600 global_page_state(NR_UNSTABLE_NFS) >= background_thresh);
601 } 601 }
602 602
603 /* 603 /*
604 * Explicit flushing or periodic writeback of "old" data. 604 * Explicit flushing or periodic writeback of "old" data.
605 * 605 *
606 * Define "old": the first time one of an inode's pages is dirtied, we mark the 606 * Define "old": the first time one of an inode's pages is dirtied, we mark the
607 * dirtying-time in the inode's address_space. So this periodic writeback code 607 * dirtying-time in the inode's address_space. So this periodic writeback code
608 * just walks the superblock inode list, writing back any inodes which are 608 * just walks the superblock inode list, writing back any inodes which are
609 * older than a specific point in time. 609 * older than a specific point in time.
610 * 610 *
611 * Try to run once per dirty_writeback_interval. But if a writeback event 611 * Try to run once per dirty_writeback_interval. But if a writeback event
612 * takes longer than a dirty_writeback_interval interval, then leave a 612 * takes longer than a dirty_writeback_interval interval, then leave a
613 * one-second gap. 613 * one-second gap.
614 * 614 *
615 * older_than_this takes precedence over nr_to_write. So we'll only write back 615 * older_than_this takes precedence over nr_to_write. So we'll only write back
616 * all dirty pages if they are all attached to "old" mappings. 616 * all dirty pages if they are all attached to "old" mappings.
617 */ 617 */
618 static long wb_writeback(struct bdi_writeback *wb, 618 static long wb_writeback(struct bdi_writeback *wb,
619 struct wb_writeback_work *work) 619 struct wb_writeback_work *work)
620 { 620 {
621 struct writeback_control wbc = { 621 struct writeback_control wbc = {
622 .sync_mode = work->sync_mode, 622 .sync_mode = work->sync_mode,
623 .older_than_this = NULL, 623 .older_than_this = NULL,
624 .for_kupdate = work->for_kupdate, 624 .for_kupdate = work->for_kupdate,
625 .for_background = work->for_background, 625 .for_background = work->for_background,
626 .range_cyclic = work->range_cyclic, 626 .range_cyclic = work->range_cyclic,
627 }; 627 };
628 unsigned long oldest_jif; 628 unsigned long oldest_jif;
629 long wrote = 0; 629 long wrote = 0;
630 struct inode *inode; 630 struct inode *inode;
631 631
632 if (wbc.for_kupdate) { 632 if (wbc.for_kupdate) {
633 wbc.older_than_this = &oldest_jif; 633 wbc.older_than_this = &oldest_jif;
634 oldest_jif = jiffies - 634 oldest_jif = jiffies -
635 msecs_to_jiffies(dirty_expire_interval * 10); 635 msecs_to_jiffies(dirty_expire_interval * 10);
636 } 636 }
637 if (!wbc.range_cyclic) { 637 if (!wbc.range_cyclic) {
638 wbc.range_start = 0; 638 wbc.range_start = 0;
639 wbc.range_end = LLONG_MAX; 639 wbc.range_end = LLONG_MAX;
640 } 640 }
641 641
642 for (;;) { 642 for (;;) {
643 /* 643 /*
644 * Stop writeback when nr_pages has been consumed 644 * Stop writeback when nr_pages has been consumed
645 */ 645 */
646 if (work->nr_pages <= 0) 646 if (work->nr_pages <= 0)
647 break; 647 break;
648 648
649 /* 649 /*
650 * For background writeout, stop when we are below the 650 * For background writeout, stop when we are below the
651 * background dirty threshold 651 * background dirty threshold
652 */ 652 */
653 if (work->for_background && !over_bground_thresh()) 653 if (work->for_background && !over_bground_thresh())
654 break; 654 break;
655 655
656 wbc.more_io = 0; 656 wbc.more_io = 0;
657 wbc.nr_to_write = MAX_WRITEBACK_PAGES; 657 wbc.nr_to_write = MAX_WRITEBACK_PAGES;
658 wbc.pages_skipped = 0; 658 wbc.pages_skipped = 0;
659 659
660 trace_wbc_writeback_start(&wbc, wb->bdi); 660 trace_wbc_writeback_start(&wbc, wb->bdi);
661 if (work->sb) 661 if (work->sb)
662 __writeback_inodes_sb(work->sb, wb, &wbc); 662 __writeback_inodes_sb(work->sb, wb, &wbc);
663 else 663 else
664 writeback_inodes_wb(wb, &wbc); 664 writeback_inodes_wb(wb, &wbc);
665 trace_wbc_writeback_written(&wbc, wb->bdi); 665 trace_wbc_writeback_written(&wbc, wb->bdi);
666 666
667 work->nr_pages -= MAX_WRITEBACK_PAGES - wbc.nr_to_write; 667 work->nr_pages -= MAX_WRITEBACK_PAGES - wbc.nr_to_write;
668 wrote += MAX_WRITEBACK_PAGES - wbc.nr_to_write; 668 wrote += MAX_WRITEBACK_PAGES - wbc.nr_to_write;
669 669
670 /* 670 /*
671 * If we consumed everything, see if we have more 671 * If we consumed everything, see if we have more
672 */ 672 */
673 if (wbc.nr_to_write <= 0) 673 if (wbc.nr_to_write <= 0)
674 continue; 674 continue;
675 /* 675 /*
676 * Didn't write everything and we don't have more IO, bail 676 * Didn't write everything and we don't have more IO, bail
677 */ 677 */
678 if (!wbc.more_io) 678 if (!wbc.more_io)
679 break; 679 break;
680 /* 680 /*
681 * Did we write something? Try for more 681 * Did we write something? Try for more
682 */ 682 */
683 if (wbc.nr_to_write < MAX_WRITEBACK_PAGES) 683 if (wbc.nr_to_write < MAX_WRITEBACK_PAGES)
684 continue; 684 continue;
685 /* 685 /*
686 * Nothing written. Wait for some inode to 686 * Nothing written. Wait for some inode to
687 * become available for writeback. Otherwise 687 * become available for writeback. Otherwise
688 * we'll just busyloop. 688 * we'll just busyloop.
689 */ 689 */
690 spin_lock(&inode_lock); 690 spin_lock(&inode_lock);
691 if (!list_empty(&wb->b_more_io)) { 691 if (!list_empty(&wb->b_more_io)) {
692 inode = list_entry(wb->b_more_io.prev, 692 inode = list_entry(wb->b_more_io.prev,
693 struct inode, i_list); 693 struct inode, i_list);
694 trace_wbc_writeback_wait(&wbc, wb->bdi); 694 trace_wbc_writeback_wait(&wbc, wb->bdi);
695 inode_wait_for_writeback(inode); 695 inode_wait_for_writeback(inode);
696 } 696 }
697 spin_unlock(&inode_lock); 697 spin_unlock(&inode_lock);
698 } 698 }
699 699
700 return wrote; 700 return wrote;
701 } 701 }
702 702
703 /* 703 /*
704 * Return the next wb_writeback_work struct that hasn't been processed yet. 704 * Return the next wb_writeback_work struct that hasn't been processed yet.
705 */ 705 */
706 static struct wb_writeback_work * 706 static struct wb_writeback_work *
707 get_next_work_item(struct backing_dev_info *bdi, struct bdi_writeback *wb) 707 get_next_work_item(struct backing_dev_info *bdi)
708 { 708 {
709 struct wb_writeback_work *work = NULL; 709 struct wb_writeback_work *work = NULL;
710 710
711 spin_lock(&bdi->wb_lock); 711 spin_lock(&bdi->wb_lock);
712 if (!list_empty(&bdi->work_list)) { 712 if (!list_empty(&bdi->work_list)) {
713 work = list_entry(bdi->work_list.next, 713 work = list_entry(bdi->work_list.next,
714 struct wb_writeback_work, list); 714 struct wb_writeback_work, list);
715 list_del_init(&work->list); 715 list_del_init(&work->list);
716 } 716 }
717 spin_unlock(&bdi->wb_lock); 717 spin_unlock(&bdi->wb_lock);
718 return work; 718 return work;
719 } 719 }
720 720
721 static long wb_check_old_data_flush(struct bdi_writeback *wb) 721 static long wb_check_old_data_flush(struct bdi_writeback *wb)
722 { 722 {
723 unsigned long expired; 723 unsigned long expired;
724 long nr_pages; 724 long nr_pages;
725 725
726 /* 726 /*
727 * When set to zero, disable periodic writeback 727 * When set to zero, disable periodic writeback
728 */ 728 */
729 if (!dirty_writeback_interval) 729 if (!dirty_writeback_interval)
730 return 0; 730 return 0;
731 731
732 expired = wb->last_old_flush + 732 expired = wb->last_old_flush +
733 msecs_to_jiffies(dirty_writeback_interval * 10); 733 msecs_to_jiffies(dirty_writeback_interval * 10);
734 if (time_before(jiffies, expired)) 734 if (time_before(jiffies, expired))
735 return 0; 735 return 0;
736 736
737 wb->last_old_flush = jiffies; 737 wb->last_old_flush = jiffies;
738 nr_pages = global_page_state(NR_FILE_DIRTY) + 738 nr_pages = global_page_state(NR_FILE_DIRTY) +
739 global_page_state(NR_UNSTABLE_NFS) + 739 global_page_state(NR_UNSTABLE_NFS) +
740 (inodes_stat.nr_inodes - inodes_stat.nr_unused); 740 (inodes_stat.nr_inodes - inodes_stat.nr_unused);
741 741
742 if (nr_pages) { 742 if (nr_pages) {
743 struct wb_writeback_work work = { 743 struct wb_writeback_work work = {
744 .nr_pages = nr_pages, 744 .nr_pages = nr_pages,
745 .sync_mode = WB_SYNC_NONE, 745 .sync_mode = WB_SYNC_NONE,
746 .for_kupdate = 1, 746 .for_kupdate = 1,
747 .range_cyclic = 1, 747 .range_cyclic = 1,
748 }; 748 };
749 749
750 return wb_writeback(wb, &work); 750 return wb_writeback(wb, &work);
751 } 751 }
752 752
753 return 0; 753 return 0;
754 } 754 }
755 755
756 /* 756 /*
757 * Retrieve work items and do the writeback they describe 757 * Retrieve work items and do the writeback they describe
758 */ 758 */
759 long wb_do_writeback(struct bdi_writeback *wb, int force_wait) 759 long wb_do_writeback(struct bdi_writeback *wb, int force_wait)
760 { 760 {
761 struct backing_dev_info *bdi = wb->bdi; 761 struct backing_dev_info *bdi = wb->bdi;
762 struct wb_writeback_work *work; 762 struct wb_writeback_work *work;
763 long wrote = 0; 763 long wrote = 0;
764 764
765 while ((work = get_next_work_item(bdi, wb)) != NULL) { 765 while ((work = get_next_work_item(bdi)) != NULL) {
766 /* 766 /*
767 * Override sync mode, in case we must wait for completion 767 * Override sync mode, in case we must wait for completion
768 * because this thread is exiting now. 768 * because this thread is exiting now.
769 */ 769 */
770 if (force_wait) 770 if (force_wait)
771 work->sync_mode = WB_SYNC_ALL; 771 work->sync_mode = WB_SYNC_ALL;
772 772
773 trace_writeback_exec(bdi, work); 773 trace_writeback_exec(bdi, work);
774 774
775 wrote += wb_writeback(wb, work); 775 wrote += wb_writeback(wb, work);
776 776
777 /* 777 /*
778 * Notify the caller of completion if this is a synchronous 778 * Notify the caller of completion if this is a synchronous
779 * work item, otherwise just free it. 779 * work item, otherwise just free it.
780 */ 780 */
781 if (work->done) 781 if (work->done)
782 complete(work->done); 782 complete(work->done);
783 else 783 else
784 kfree(work); 784 kfree(work);
785 } 785 }
786 786
787 /* 787 /*
788 * Check for periodic writeback, kupdated() style 788 * Check for periodic writeback, kupdated() style
789 */ 789 */
790 wrote += wb_check_old_data_flush(wb); 790 wrote += wb_check_old_data_flush(wb);
791 791
792 return wrote; 792 return wrote;
793 } 793 }
794 794
795 /* 795 /*
796 * Handle writeback of dirty data for the device backed by this bdi. Also 796 * Handle writeback of dirty data for the device backed by this bdi. Also
797 * wakes up periodically and does kupdated style flushing. 797 * wakes up periodically and does kupdated style flushing.
798 */ 798 */
799 int bdi_writeback_thread(void *data) 799 int bdi_writeback_thread(void *data)
800 { 800 {
801 struct bdi_writeback *wb = data; 801 struct bdi_writeback *wb = data;
802 struct backing_dev_info *bdi = wb->bdi; 802 struct backing_dev_info *bdi = wb->bdi;
803 unsigned long last_active = jiffies; 803 unsigned long last_active = jiffies;
804 unsigned long wait_jiffies = -1UL; 804 unsigned long wait_jiffies = -1UL;
805 long pages_written; 805 long pages_written;
806 806
807 /* 807 /*
808 * Add us to the active bdi_list 808 * Add us to the active bdi_list
809 */ 809 */
810 spin_lock_bh(&bdi_lock); 810 spin_lock_bh(&bdi_lock);
811 list_add_rcu(&bdi->bdi_list, &bdi_list); 811 list_add_rcu(&bdi->bdi_list, &bdi_list);
812 spin_unlock_bh(&bdi_lock); 812 spin_unlock_bh(&bdi_lock);
813 813
814 current->flags |= PF_FLUSHER | PF_SWAPWRITE; 814 current->flags |= PF_FLUSHER | PF_SWAPWRITE;
815 set_freezable(); 815 set_freezable();
816 816
817 /* 817 /*
818 * Our parent may run at a different priority, just set us to normal 818 * Our parent may run at a different priority, just set us to normal
819 */ 819 */
820 set_user_nice(current, 0); 820 set_user_nice(current, 0);
821 821
822 /* 822 /*
823 * Clear pending bit and wakeup anybody waiting to tear us down 823 * Clear pending bit and wakeup anybody waiting to tear us down
824 */ 824 */
825 clear_bit(BDI_pending, &bdi->state); 825 clear_bit(BDI_pending, &bdi->state);
826 smp_mb__after_clear_bit(); 826 smp_mb__after_clear_bit();
827 wake_up_bit(&bdi->state, BDI_pending); 827 wake_up_bit(&bdi->state, BDI_pending);
828 828
829 trace_writeback_thread_start(bdi); 829 trace_writeback_thread_start(bdi);
830 830
831 while (!kthread_should_stop()) { 831 while (!kthread_should_stop()) {
832 pages_written = wb_do_writeback(wb, 0); 832 pages_written = wb_do_writeback(wb, 0);
833 833
834 trace_writeback_pages_written(pages_written); 834 trace_writeback_pages_written(pages_written);
835 835
836 if (pages_written) 836 if (pages_written)
837 last_active = jiffies; 837 last_active = jiffies;
838 else if (wait_jiffies != -1UL) { 838 else if (wait_jiffies != -1UL) {
839 unsigned long max_idle; 839 unsigned long max_idle;
840 840
841 /* 841 /*
842 * Longest period of inactivity that we tolerate. If we 842 * Longest period of inactivity that we tolerate. If we
843 * see dirty data again later, the task will get 843 * see dirty data again later, the task will get
844 * recreated automatically. 844 * recreated automatically.
845 */ 845 */
846 max_idle = max(5UL * 60 * HZ, wait_jiffies); 846 max_idle = max(5UL * 60 * HZ, wait_jiffies);
847 if (time_after(jiffies, max_idle + last_active)) 847 if (time_after(jiffies, max_idle + last_active))
848 break; 848 break;
849 } 849 }
850 850
851 if (dirty_writeback_interval) { 851 if (dirty_writeback_interval) {
852 wait_jiffies = msecs_to_jiffies(dirty_writeback_interval * 10); 852 wait_jiffies = msecs_to_jiffies(dirty_writeback_interval * 10);
853 schedule_timeout_interruptible(wait_jiffies); 853 schedule_timeout_interruptible(wait_jiffies);
854 } else { 854 } else {
855 set_current_state(TASK_INTERRUPTIBLE); 855 set_current_state(TASK_INTERRUPTIBLE);
856 if (list_empty_careful(&wb->bdi->work_list) && 856 if (list_empty_careful(&wb->bdi->work_list) &&
857 !kthread_should_stop()) 857 !kthread_should_stop())
858 schedule(); 858 schedule();
859 __set_current_state(TASK_RUNNING); 859 __set_current_state(TASK_RUNNING);
860 } 860 }
861 861
862 try_to_freeze(); 862 try_to_freeze();
863 } 863 }
864 864
865 wb->task = NULL; 865 wb->task = NULL;
866 866
867 /* 867 /*
868 * Flush any work that raced with us exiting. No new work 868 * Flush any work that raced with us exiting. No new work
869 * will be added, since this bdi isn't discoverable anymore. 869 * will be added, since this bdi isn't discoverable anymore.
870 */ 870 */
871 if (!list_empty(&bdi->work_list)) 871 if (!list_empty(&bdi->work_list))
872 wb_do_writeback(wb, 1); 872 wb_do_writeback(wb, 1);
873 873
874 trace_writeback_thread_stop(bdi); 874 trace_writeback_thread_stop(bdi);
875 return 0; 875 return 0;
876 } 876 }
877 877
878 878
879 /* 879 /*
880 * Start writeback of `nr_pages' pages. If `nr_pages' is zero, write back 880 * Start writeback of `nr_pages' pages. If `nr_pages' is zero, write back
881 * the whole world. 881 * the whole world.
882 */ 882 */
883 void wakeup_flusher_threads(long nr_pages) 883 void wakeup_flusher_threads(long nr_pages)
884 { 884 {
885 struct backing_dev_info *bdi; 885 struct backing_dev_info *bdi;
886 886
887 if (!nr_pages) { 887 if (!nr_pages) {
888 nr_pages = global_page_state(NR_FILE_DIRTY) + 888 nr_pages = global_page_state(NR_FILE_DIRTY) +
889 global_page_state(NR_UNSTABLE_NFS); 889 global_page_state(NR_UNSTABLE_NFS);
890 } 890 }
891 891
892 rcu_read_lock(); 892 rcu_read_lock();
893 list_for_each_entry_rcu(bdi, &bdi_list, bdi_list) { 893 list_for_each_entry_rcu(bdi, &bdi_list, bdi_list) {
894 if (!bdi_has_dirty_io(bdi)) 894 if (!bdi_has_dirty_io(bdi))
895 continue; 895 continue;
896 __bdi_start_writeback(bdi, nr_pages, false, false); 896 __bdi_start_writeback(bdi, nr_pages, false, false);
897 } 897 }
898 rcu_read_unlock(); 898 rcu_read_unlock();
899 } 899 }
900 900
901 static noinline void block_dump___mark_inode_dirty(struct inode *inode) 901 static noinline void block_dump___mark_inode_dirty(struct inode *inode)
902 { 902 {
903 if (inode->i_ino || strcmp(inode->i_sb->s_id, "bdev")) { 903 if (inode->i_ino || strcmp(inode->i_sb->s_id, "bdev")) {
904 struct dentry *dentry; 904 struct dentry *dentry;
905 const char *name = "?"; 905 const char *name = "?";
906 906
907 dentry = d_find_alias(inode); 907 dentry = d_find_alias(inode);
908 if (dentry) { 908 if (dentry) {
909 spin_lock(&dentry->d_lock); 909 spin_lock(&dentry->d_lock);
910 name = (const char *) dentry->d_name.name; 910 name = (const char *) dentry->d_name.name;
911 } 911 }
912 printk(KERN_DEBUG 912 printk(KERN_DEBUG
913 "%s(%d): dirtied inode %lu (%s) on %s\n", 913 "%s(%d): dirtied inode %lu (%s) on %s\n",
914 current->comm, task_pid_nr(current), inode->i_ino, 914 current->comm, task_pid_nr(current), inode->i_ino,
915 name, inode->i_sb->s_id); 915 name, inode->i_sb->s_id);
916 if (dentry) { 916 if (dentry) {
917 spin_unlock(&dentry->d_lock); 917 spin_unlock(&dentry->d_lock);
918 dput(dentry); 918 dput(dentry);
919 } 919 }
920 } 920 }
921 } 921 }
922 922
923 /** 923 /**
924 * __mark_inode_dirty - internal function 924 * __mark_inode_dirty - internal function
925 * @inode: inode to mark 925 * @inode: inode to mark
926 * @flags: what kind of dirty (i.e. I_DIRTY_SYNC) 926 * @flags: what kind of dirty (i.e. I_DIRTY_SYNC)
927 * Mark an inode as dirty. Callers should use mark_inode_dirty or 927 * Mark an inode as dirty. Callers should use mark_inode_dirty or
928 * mark_inode_dirty_sync. 928 * mark_inode_dirty_sync.
929 * 929 *
930 * Put the inode on the super block's dirty list. 930 * Put the inode on the super block's dirty list.
931 * 931 *
932 * CAREFUL! We mark it dirty unconditionally, but move it onto the 932 * CAREFUL! We mark it dirty unconditionally, but move it onto the
933 * dirty list only if it is hashed or if it refers to a blockdev. 933 * dirty list only if it is hashed or if it refers to a blockdev.
934 * If it was not hashed, it will never be added to the dirty list 934 * If it was not hashed, it will never be added to the dirty list
935 * even if it is later hashed, as it will have been marked dirty already. 935 * even if it is later hashed, as it will have been marked dirty already.
936 * 936 *
937 * In short, make sure you hash any inodes _before_ you start marking 937 * In short, make sure you hash any inodes _before_ you start marking
938 * them dirty. 938 * them dirty.
939 * 939 *
940 * This function *must* be atomic for the I_DIRTY_PAGES case - 940 * This function *must* be atomic for the I_DIRTY_PAGES case -
941 * set_page_dirty() is called under spinlock in several places. 941 * set_page_dirty() is called under spinlock in several places.
942 * 942 *
943 * Note that for blockdevs, inode->dirtied_when represents the dirtying time of 943 * Note that for blockdevs, inode->dirtied_when represents the dirtying time of
944 * the block-special inode (/dev/hda1) itself. And the ->dirtied_when field of 944 * the block-special inode (/dev/hda1) itself. And the ->dirtied_when field of
945 * the kernel-internal blockdev inode represents the dirtying time of the 945 * the kernel-internal blockdev inode represents the dirtying time of the
946 * blockdev's pages. This is why for I_DIRTY_PAGES we always use 946 * blockdev's pages. This is why for I_DIRTY_PAGES we always use
947 * page->mapping->host, so the page-dirtying time is recorded in the internal 947 * page->mapping->host, so the page-dirtying time is recorded in the internal
948 * blockdev inode. 948 * blockdev inode.
949 */ 949 */
950 void __mark_inode_dirty(struct inode *inode, int flags) 950 void __mark_inode_dirty(struct inode *inode, int flags)
951 { 951 {
952 struct super_block *sb = inode->i_sb; 952 struct super_block *sb = inode->i_sb;
953 953
954 /* 954 /*
955 * Don't do this for I_DIRTY_PAGES - that doesn't actually 955 * Don't do this for I_DIRTY_PAGES - that doesn't actually
956 * dirty the inode itself 956 * dirty the inode itself
957 */ 957 */
958 if (flags & (I_DIRTY_SYNC | I_DIRTY_DATASYNC)) { 958 if (flags & (I_DIRTY_SYNC | I_DIRTY_DATASYNC)) {
959 if (sb->s_op->dirty_inode) 959 if (sb->s_op->dirty_inode)
960 sb->s_op->dirty_inode(inode); 960 sb->s_op->dirty_inode(inode);
961 } 961 }
962 962
963 /* 963 /*
964 * make sure that changes are seen by all cpus before we test i_state 964 * make sure that changes are seen by all cpus before we test i_state
965 * -- mikulas 965 * -- mikulas
966 */ 966 */
967 smp_mb(); 967 smp_mb();
968 968
969 /* avoid the locking if we can */ 969 /* avoid the locking if we can */
970 if ((inode->i_state & flags) == flags) 970 if ((inode->i_state & flags) == flags)
971 return; 971 return;
972 972
973 if (unlikely(block_dump)) 973 if (unlikely(block_dump))
974 block_dump___mark_inode_dirty(inode); 974 block_dump___mark_inode_dirty(inode);
975 975
976 spin_lock(&inode_lock); 976 spin_lock(&inode_lock);
977 if ((inode->i_state & flags) != flags) { 977 if ((inode->i_state & flags) != flags) {
978 const int was_dirty = inode->i_state & I_DIRTY; 978 const int was_dirty = inode->i_state & I_DIRTY;
979 979
980 inode->i_state |= flags; 980 inode->i_state |= flags;
981 981
982 /* 982 /*
983 * If the inode is being synced, just update its dirty state. 983 * If the inode is being synced, just update its dirty state.
984 * The unlocker will place the inode on the appropriate 984 * The unlocker will place the inode on the appropriate
985 * superblock list, based upon its state. 985 * superblock list, based upon its state.
986 */ 986 */
987 if (inode->i_state & I_SYNC) 987 if (inode->i_state & I_SYNC)
988 goto out; 988 goto out;
989 989
990 /* 990 /*
991 * Only add valid (hashed) inodes to the superblock's 991 * Only add valid (hashed) inodes to the superblock's
992 * dirty list. Add blockdev inodes as well. 992 * dirty list. Add blockdev inodes as well.
993 */ 993 */
994 if (!S_ISBLK(inode->i_mode)) { 994 if (!S_ISBLK(inode->i_mode)) {
995 if (hlist_unhashed(&inode->i_hash)) 995 if (hlist_unhashed(&inode->i_hash))
996 goto out; 996 goto out;
997 } 997 }
998 if (inode->i_state & (I_FREEING|I_CLEAR)) 998 if (inode->i_state & (I_FREEING|I_CLEAR))
999 goto out; 999 goto out;
1000 1000
1001 /* 1001 /*
1002 * If the inode was already on b_dirty/b_io/b_more_io, don't 1002 * If the inode was already on b_dirty/b_io/b_more_io, don't
1003 * reposition it (that would break b_dirty time-ordering). 1003 * reposition it (that would break b_dirty time-ordering).
1004 */ 1004 */
1005 if (!was_dirty) { 1005 if (!was_dirty) {
1006 struct bdi_writeback *wb = &inode_to_bdi(inode)->wb; 1006 struct bdi_writeback *wb = &inode_to_bdi(inode)->wb;
1007 struct backing_dev_info *bdi = wb->bdi; 1007 struct backing_dev_info *bdi = wb->bdi;
1008 1008
1009 if (bdi_cap_writeback_dirty(bdi) && 1009 if (bdi_cap_writeback_dirty(bdi) &&
1010 !test_bit(BDI_registered, &bdi->state)) { 1010 !test_bit(BDI_registered, &bdi->state)) {
1011 WARN_ON(1); 1011 WARN_ON(1);
1012 printk(KERN_ERR "bdi-%s not registered\n", 1012 printk(KERN_ERR "bdi-%s not registered\n",
1013 bdi->name); 1013 bdi->name);
1014 } 1014 }
1015 1015
1016 inode->dirtied_when = jiffies; 1016 inode->dirtied_when = jiffies;
1017 list_move(&inode->i_list, &wb->b_dirty); 1017 list_move(&inode->i_list, &wb->b_dirty);
1018 } 1018 }
1019 } 1019 }
1020 out: 1020 out:
1021 spin_unlock(&inode_lock); 1021 spin_unlock(&inode_lock);
1022 } 1022 }
1023 EXPORT_SYMBOL(__mark_inode_dirty); 1023 EXPORT_SYMBOL(__mark_inode_dirty);
1024 1024
1025 /* 1025 /*
1026 * Write out a superblock's list of dirty inodes. A wait will be performed 1026 * Write out a superblock's list of dirty inodes. A wait will be performed
1027 * upon no inodes, all inodes or the final one, depending upon sync_mode. 1027 * upon no inodes, all inodes or the final one, depending upon sync_mode.
1028 * 1028 *
1029 * If older_than_this is non-NULL, then only write out inodes which 1029 * If older_than_this is non-NULL, then only write out inodes which
1030 * had their first dirtying at a time earlier than *older_than_this. 1030 * had their first dirtying at a time earlier than *older_than_this.
1031 * 1031 *
1032 * If `bdi' is non-zero then we're being asked to writeback a specific queue. 1032 * If `bdi' is non-zero then we're being asked to writeback a specific queue.
1033 * This function assumes that the blockdev superblock's inodes are backed by 1033 * This function assumes that the blockdev superblock's inodes are backed by
1034 * a variety of queues, so all inodes are searched. For other superblocks, 1034 * a variety of queues, so all inodes are searched. For other superblocks,
1035 * assume that all inodes are backed by the same queue. 1035 * assume that all inodes are backed by the same queue.
1036 * 1036 *
1037 * The inodes to be written are parked on bdi->b_io. They are moved back onto 1037 * The inodes to be written are parked on bdi->b_io. They are moved back onto
1038 * bdi->b_dirty as they are selected for writing. This way, none can be missed 1038 * bdi->b_dirty as they are selected for writing. This way, none can be missed
1039 * on the writer throttling path, and we get decent balancing between many 1039 * on the writer throttling path, and we get decent balancing between many
1040 * throttled threads: we don't want them all piling up on inode_sync_wait. 1040 * throttled threads: we don't want them all piling up on inode_sync_wait.
1041 */ 1041 */
1042 static void wait_sb_inodes(struct super_block *sb) 1042 static void wait_sb_inodes(struct super_block *sb)
1043 { 1043 {
1044 struct inode *inode, *old_inode = NULL; 1044 struct inode *inode, *old_inode = NULL;
1045 1045
1046 /* 1046 /*
1047 * We need to be protected against the filesystem going from 1047 * We need to be protected against the filesystem going from
1048 * r/o to r/w or vice versa. 1048 * r/o to r/w or vice versa.
1049 */ 1049 */
1050 WARN_ON(!rwsem_is_locked(&sb->s_umount)); 1050 WARN_ON(!rwsem_is_locked(&sb->s_umount));
1051 1051
1052 spin_lock(&inode_lock); 1052 spin_lock(&inode_lock);
1053 1053
1054 /* 1054 /*
1055 * Data integrity sync. Must wait for all pages under writeback, 1055 * Data integrity sync. Must wait for all pages under writeback,
1056 * because there may have been pages dirtied before our sync 1056 * because there may have been pages dirtied before our sync
1057 * call, but which had writeout started before we write it out. 1057 * call, but which had writeout started before we write it out.
1058 * In which case, the inode may not be on the dirty list, but 1058 * In which case, the inode may not be on the dirty list, but
1059 * we still have to wait for that writeout. 1059 * we still have to wait for that writeout.
1060 */ 1060 */
1061 list_for_each_entry(inode, &sb->s_inodes, i_sb_list) { 1061 list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
1062 struct address_space *mapping; 1062 struct address_space *mapping;
1063 1063
1064 if (inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE|I_NEW)) 1064 if (inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE|I_NEW))
1065 continue; 1065 continue;
1066 mapping = inode->i_mapping; 1066 mapping = inode->i_mapping;
1067 if (mapping->nrpages == 0) 1067 if (mapping->nrpages == 0)
1068 continue; 1068 continue;
1069 __iget(inode); 1069 __iget(inode);
1070 spin_unlock(&inode_lock); 1070 spin_unlock(&inode_lock);
1071 /* 1071 /*
1072 * We hold a reference to 'inode' so it couldn't have 1072 * We hold a reference to 'inode' so it couldn't have
1073 * been removed from s_inodes list while we dropped the 1073 * been removed from s_inodes list while we dropped the
1074 * inode_lock. We cannot iput the inode now as we can 1074 * inode_lock. We cannot iput the inode now as we can
1075 * be holding the last reference and we cannot iput it 1075 * be holding the last reference and we cannot iput it
1076 * under inode_lock. So we keep the reference and iput 1076 * under inode_lock. So we keep the reference and iput
1077 * it later. 1077 * it later.
1078 */ 1078 */
1079 iput(old_inode); 1079 iput(old_inode);
1080 old_inode = inode; 1080 old_inode = inode;
1081 1081
1082 filemap_fdatawait(mapping); 1082 filemap_fdatawait(mapping);
1083 1083
1084 cond_resched(); 1084 cond_resched();
1085 1085
1086 spin_lock(&inode_lock); 1086 spin_lock(&inode_lock);
1087 } 1087 }
1088 spin_unlock(&inode_lock); 1088 spin_unlock(&inode_lock);
1089 iput(old_inode); 1089 iput(old_inode);
1090 } 1090 }
1091 1091
1092 /** 1092 /**
1093 * writeback_inodes_sb - writeback dirty inodes from given super_block 1093 * writeback_inodes_sb - writeback dirty inodes from given super_block
1094 * @sb: the superblock 1094 * @sb: the superblock
1095 * 1095 *
1096 * Start writeback on some inodes on this super_block. No guarantees are made 1096 * Start writeback on some inodes on this super_block. No guarantees are made
1097 * on how many (if any) will be written, and this function does not wait 1097 * on how many (if any) will be written, and this function does not wait
1098 * for IO completion of submitted IO. The number of pages submitted is 1098 * for IO completion of submitted IO. The number of pages submitted is
1099 * returned. 1099 * returned.
1100 */ 1100 */
1101 void writeback_inodes_sb(struct super_block *sb) 1101 void writeback_inodes_sb(struct super_block *sb)
1102 { 1102 {
1103 unsigned long nr_dirty = global_page_state(NR_FILE_DIRTY); 1103 unsigned long nr_dirty = global_page_state(NR_FILE_DIRTY);
1104 unsigned long nr_unstable = global_page_state(NR_UNSTABLE_NFS); 1104 unsigned long nr_unstable = global_page_state(NR_UNSTABLE_NFS);
1105 DECLARE_COMPLETION_ONSTACK(done); 1105 DECLARE_COMPLETION_ONSTACK(done);
1106 struct wb_writeback_work work = { 1106 struct wb_writeback_work work = {
1107 .sb = sb, 1107 .sb = sb,
1108 .sync_mode = WB_SYNC_NONE, 1108 .sync_mode = WB_SYNC_NONE,
1109 .done = &done, 1109 .done = &done,
1110 }; 1110 };
1111 1111
1112 WARN_ON(!rwsem_is_locked(&sb->s_umount)); 1112 WARN_ON(!rwsem_is_locked(&sb->s_umount));
1113 1113
1114 work.nr_pages = nr_dirty + nr_unstable + 1114 work.nr_pages = nr_dirty + nr_unstable +
1115 (inodes_stat.nr_inodes - inodes_stat.nr_unused); 1115 (inodes_stat.nr_inodes - inodes_stat.nr_unused);
1116 1116
1117 bdi_queue_work(sb->s_bdi, &work); 1117 bdi_queue_work(sb->s_bdi, &work);
1118 wait_for_completion(&done); 1118 wait_for_completion(&done);
1119 } 1119 }
1120 EXPORT_SYMBOL(writeback_inodes_sb); 1120 EXPORT_SYMBOL(writeback_inodes_sb);
1121 1121
1122 /** 1122 /**
1123 * writeback_inodes_sb_if_idle - start writeback if none underway 1123 * writeback_inodes_sb_if_idle - start writeback if none underway
1124 * @sb: the superblock 1124 * @sb: the superblock
1125 * 1125 *
1126 * Invoke writeback_inodes_sb if no writeback is currently underway. 1126 * Invoke writeback_inodes_sb if no writeback is currently underway.
1127 * Returns 1 if writeback was started, 0 if not. 1127 * Returns 1 if writeback was started, 0 if not.
1128 */ 1128 */
1129 int writeback_inodes_sb_if_idle(struct super_block *sb) 1129 int writeback_inodes_sb_if_idle(struct super_block *sb)
1130 { 1130 {
1131 if (!writeback_in_progress(sb->s_bdi)) { 1131 if (!writeback_in_progress(sb->s_bdi)) {
1132 down_read(&sb->s_umount); 1132 down_read(&sb->s_umount);
1133 writeback_inodes_sb(sb); 1133 writeback_inodes_sb(sb);
1134 up_read(&sb->s_umount); 1134 up_read(&sb->s_umount);
1135 return 1; 1135 return 1;
1136 } else 1136 } else
1137 return 0; 1137 return 0;
1138 } 1138 }
1139 EXPORT_SYMBOL(writeback_inodes_sb_if_idle); 1139 EXPORT_SYMBOL(writeback_inodes_sb_if_idle);
1140 1140
1141 /** 1141 /**
1142 * sync_inodes_sb - sync sb inode pages 1142 * sync_inodes_sb - sync sb inode pages
1143 * @sb: the superblock 1143 * @sb: the superblock
1144 * 1144 *
1145 * This function writes and waits on any dirty inode belonging to this 1145 * This function writes and waits on any dirty inode belonging to this
1146 * super_block. The number of pages synced is returned. 1146 * super_block. The number of pages synced is returned.
1147 */ 1147 */
1148 void sync_inodes_sb(struct super_block *sb) 1148 void sync_inodes_sb(struct super_block *sb)
1149 { 1149 {
1150 DECLARE_COMPLETION_ONSTACK(done); 1150 DECLARE_COMPLETION_ONSTACK(done);
1151 struct wb_writeback_work work = { 1151 struct wb_writeback_work work = {
1152 .sb = sb, 1152 .sb = sb,
1153 .sync_mode = WB_SYNC_ALL, 1153 .sync_mode = WB_SYNC_ALL,
1154 .nr_pages = LONG_MAX, 1154 .nr_pages = LONG_MAX,
1155 .range_cyclic = 0, 1155 .range_cyclic = 0,
1156 .done = &done, 1156 .done = &done,
1157 }; 1157 };
1158 1158
1159 WARN_ON(!rwsem_is_locked(&sb->s_umount)); 1159 WARN_ON(!rwsem_is_locked(&sb->s_umount));
1160 1160
1161 bdi_queue_work(sb->s_bdi, &work); 1161 bdi_queue_work(sb->s_bdi, &work);
1162 wait_for_completion(&done); 1162 wait_for_completion(&done);
1163 1163
1164 wait_sb_inodes(sb); 1164 wait_sb_inodes(sb);
1165 } 1165 }
1166 EXPORT_SYMBOL(sync_inodes_sb); 1166 EXPORT_SYMBOL(sync_inodes_sb);
1167 1167
1168 /** 1168 /**
1169 * write_inode_now - write an inode to disk 1169 * write_inode_now - write an inode to disk
1170 * @inode: inode to write to disk 1170 * @inode: inode to write to disk
1171 * @sync: whether the write should be synchronous or not 1171 * @sync: whether the write should be synchronous or not
1172 * 1172 *
1173 * This function commits an inode to disk immediately if it is dirty. This is 1173 * This function commits an inode to disk immediately if it is dirty. This is
1174 * primarily needed by knfsd. 1174 * primarily needed by knfsd.
1175 * 1175 *
1176 * The caller must either have a ref on the inode or must have set I_WILL_FREE. 1176 * The caller must either have a ref on the inode or must have set I_WILL_FREE.
1177 */ 1177 */
1178 int write_inode_now(struct inode *inode, int sync) 1178 int write_inode_now(struct inode *inode, int sync)
1179 { 1179 {
1180 int ret; 1180 int ret;
1181 struct writeback_control wbc = { 1181 struct writeback_control wbc = {
1182 .nr_to_write = LONG_MAX, 1182 .nr_to_write = LONG_MAX,
1183 .sync_mode = sync ? WB_SYNC_ALL : WB_SYNC_NONE, 1183 .sync_mode = sync ? WB_SYNC_ALL : WB_SYNC_NONE,
1184 .range_start = 0, 1184 .range_start = 0,
1185 .range_end = LLONG_MAX, 1185 .range_end = LLONG_MAX,
1186 }; 1186 };
1187 1187
1188 if (!mapping_cap_writeback_dirty(inode->i_mapping)) 1188 if (!mapping_cap_writeback_dirty(inode->i_mapping))
1189 wbc.nr_to_write = 0; 1189 wbc.nr_to_write = 0;
1190 1190
1191 might_sleep(); 1191 might_sleep();
1192 spin_lock(&inode_lock); 1192 spin_lock(&inode_lock);
1193 ret = writeback_single_inode(inode, &wbc); 1193 ret = writeback_single_inode(inode, &wbc);
1194 spin_unlock(&inode_lock); 1194 spin_unlock(&inode_lock);
1195 if (sync) 1195 if (sync)
1196 inode_sync_wait(inode); 1196 inode_sync_wait(inode);
1197 return ret; 1197 return ret;
1198 } 1198 }
1199 EXPORT_SYMBOL(write_inode_now); 1199 EXPORT_SYMBOL(write_inode_now);
1200 1200
1201 /** 1201 /**
1202 * sync_inode - write an inode and its pages to disk. 1202 * sync_inode - write an inode and its pages to disk.
1203 * @inode: the inode to sync 1203 * @inode: the inode to sync
1204 * @wbc: controls the writeback mode 1204 * @wbc: controls the writeback mode
1205 * 1205 *
1206 * sync_inode() will write an inode and its pages to disk. It will also 1206 * sync_inode() will write an inode and its pages to disk. It will also
1207 * correctly update the inode on its superblock's dirty inode lists and will 1207 * correctly update the inode on its superblock's dirty inode lists and will
1208 * update inode->i_state. 1208 * update inode->i_state.
1209 * 1209 *
1210 * The caller must have a ref on the inode. 1210 * The caller must have a ref on the inode.
1211 */ 1211 */
1212 int sync_inode(struct inode *inode, struct writeback_control *wbc) 1212 int sync_inode(struct inode *inode, struct writeback_control *wbc)
1213 { 1213 {
1214 int ret; 1214 int ret;
1215 1215
1216 spin_lock(&inode_lock); 1216 spin_lock(&inode_lock);
1217 ret = writeback_single_inode(inode, wbc); 1217 ret = writeback_single_inode(inode, wbc);
1218 spin_unlock(&inode_lock); 1218 spin_unlock(&inode_lock);
1219 return ret; 1219 return ret;
1220 } 1220 }
1221 EXPORT_SYMBOL(sync_inode); 1221 EXPORT_SYMBOL(sync_inode);
1222 1222