fs/fs-writeback.c: remove unneccesary parameter of __writeback_single_inode()
[linux-3.10.git] / fs / fs-writeback.c
1 /*
2  * fs/fs-writeback.c
3  *
4  * Copyright (C) 2002, Linus Torvalds.
5  *
6  * Contains all the functions related to writing back and waiting
7  * upon dirty inodes against superblocks, and writing back dirty
8  * pages against inodes.  ie: data writeback.  Writeout of the
9  * inode itself is not handled here.
10  *
11  * 10Apr2002    Andrew Morton
12  *              Split out of fs/inode.c
13  *              Additions for address_space-based writeback
14  */
15
16 #include <linux/kernel.h>
17 #include <linux/export.h>
18 #include <linux/spinlock.h>
19 #include <linux/slab.h>
20 #include <linux/sched.h>
21 #include <linux/fs.h>
22 #include <linux/mm.h>
23 #include <linux/pagemap.h>
24 #include <linux/kthread.h>
25 #include <linux/freezer.h>
26 #include <linux/writeback.h>
27 #include <linux/blkdev.h>
28 #include <linux/backing-dev.h>
29 #include <linux/tracepoint.h>
30 #include "internal.h"
31
32 /*
33  * 4MB minimal write chunk size
34  */
35 #define MIN_WRITEBACK_PAGES     (4096UL >> (PAGE_CACHE_SHIFT - 10))
36
37 /*
38  * Passed into wb_writeback(), essentially a subset of writeback_control
39  */
40 struct wb_writeback_work {
41         long nr_pages;
42         struct super_block *sb;
43         unsigned long *older_than_this;
44         enum writeback_sync_modes sync_mode;
45         unsigned int tagged_writepages:1;
46         unsigned int for_kupdate:1;
47         unsigned int range_cyclic:1;
48         unsigned int for_background:1;
49         enum wb_reason reason;          /* why was writeback initiated? */
50
51         struct list_head list;          /* pending work list */
52         struct completion *done;        /* set if the caller waits */
53 };
54
55 /**
56  * writeback_in_progress - determine whether there is writeback in progress
57  * @bdi: the device's backing_dev_info structure.
58  *
59  * Determine whether there is writeback waiting to be handled against a
60  * backing device.
61  */
62 int writeback_in_progress(struct backing_dev_info *bdi)
63 {
64         return test_bit(BDI_writeback_running, &bdi->state);
65 }
66 EXPORT_SYMBOL(writeback_in_progress);
67
68 static inline struct backing_dev_info *inode_to_bdi(struct inode *inode)
69 {
70         struct super_block *sb = inode->i_sb;
71
72         if (strcmp(sb->s_type->name, "bdev") == 0)
73                 return inode->i_mapping->backing_dev_info;
74
75         return sb->s_bdi;
76 }
77
78 static inline struct inode *wb_inode(struct list_head *head)
79 {
80         return list_entry(head, struct inode, i_wb_list);
81 }
82
83 /*
84  * Include the creation of the trace points after defining the
85  * wb_writeback_work structure and inline functions so that the definition
86  * remains local to this file.
87  */
88 #define CREATE_TRACE_POINTS
89 #include <trace/events/writeback.h>
90
91 /* Wakeup flusher thread or forker thread to fork it. Requires bdi->wb_lock. */
92 static void bdi_wakeup_flusher(struct backing_dev_info *bdi)
93 {
94         if (bdi->wb.task) {
95                 wake_up_process(bdi->wb.task);
96         } else {
97                 /*
98                  * The bdi thread isn't there, wake up the forker thread which
99                  * will create and run it.
100                  */
101                 wake_up_process(default_backing_dev_info.wb.task);
102         }
103 }
104
105 static void bdi_queue_work(struct backing_dev_info *bdi,
106                            struct wb_writeback_work *work)
107 {
108         trace_writeback_queue(bdi, work);
109
110         spin_lock_bh(&bdi->wb_lock);
111         list_add_tail(&work->list, &bdi->work_list);
112         if (!bdi->wb.task)
113                 trace_writeback_nothread(bdi, work);
114         bdi_wakeup_flusher(bdi);
115         spin_unlock_bh(&bdi->wb_lock);
116 }
117
118 static void
119 __bdi_start_writeback(struct backing_dev_info *bdi, long nr_pages,
120                       bool range_cyclic, enum wb_reason reason)
121 {
122         struct wb_writeback_work *work;
123
124         /*
125          * This is WB_SYNC_NONE writeback, so if allocation fails just
126          * wakeup the thread for old dirty data writeback
127          */
128         work = kzalloc(sizeof(*work), GFP_ATOMIC);
129         if (!work) {
130                 if (bdi->wb.task) {
131                         trace_writeback_nowork(bdi);
132                         wake_up_process(bdi->wb.task);
133                 }
134                 return;
135         }
136
137         work->sync_mode = WB_SYNC_NONE;
138         work->nr_pages  = nr_pages;
139         work->range_cyclic = range_cyclic;
140         work->reason    = reason;
141
142         bdi_queue_work(bdi, work);
143 }
144
145 /**
146  * bdi_start_writeback - start writeback
147  * @bdi: the backing device to write from
148  * @nr_pages: the number of pages to write
149  * @reason: reason why some writeback work was initiated
150  *
151  * Description:
152  *   This does WB_SYNC_NONE opportunistic writeback. The IO is only
153  *   started when this function returns, we make no guarantees on
154  *   completion. Caller need not hold sb s_umount semaphore.
155  *
156  */
157 void bdi_start_writeback(struct backing_dev_info *bdi, long nr_pages,
158                         enum wb_reason reason)
159 {
160         __bdi_start_writeback(bdi, nr_pages, true, reason);
161 }
162
163 /**
164  * bdi_start_background_writeback - start background writeback
165  * @bdi: the backing device to write from
166  *
167  * Description:
168  *   This makes sure WB_SYNC_NONE background writeback happens. When
169  *   this function returns, it is only guaranteed that for given BDI
170  *   some IO is happening if we are over background dirty threshold.
171  *   Caller need not hold sb s_umount semaphore.
172  */
173 void bdi_start_background_writeback(struct backing_dev_info *bdi)
174 {
175         /*
176          * We just wake up the flusher thread. It will perform background
177          * writeback as soon as there is no other work to do.
178          */
179         trace_writeback_wake_background(bdi);
180         spin_lock_bh(&bdi->wb_lock);
181         bdi_wakeup_flusher(bdi);
182         spin_unlock_bh(&bdi->wb_lock);
183 }
184
185 /*
186  * Remove the inode from the writeback list it is on.
187  */
188 void inode_wb_list_del(struct inode *inode)
189 {
190         struct backing_dev_info *bdi = inode_to_bdi(inode);
191
192         spin_lock(&bdi->wb.list_lock);
193         list_del_init(&inode->i_wb_list);
194         spin_unlock(&bdi->wb.list_lock);
195 }
196
197 /*
198  * Redirty an inode: set its when-it-was dirtied timestamp and move it to the
199  * furthest end of its superblock's dirty-inode list.
200  *
201  * Before stamping the inode's ->dirtied_when, we check to see whether it is
202  * already the most-recently-dirtied inode on the b_dirty list.  If that is
203  * the case then the inode must have been redirtied while it was being written
204  * out and we don't reset its dirtied_when.
205  */
206 static void redirty_tail(struct inode *inode, struct bdi_writeback *wb)
207 {
208         assert_spin_locked(&wb->list_lock);
209         if (!list_empty(&wb->b_dirty)) {
210                 struct inode *tail;
211
212                 tail = wb_inode(wb->b_dirty.next);
213                 if (time_before(inode->dirtied_when, tail->dirtied_when))
214                         inode->dirtied_when = jiffies;
215         }
216         list_move(&inode->i_wb_list, &wb->b_dirty);
217 }
218
219 /*
220  * requeue inode for re-scanning after bdi->b_io list is exhausted.
221  */
222 static void requeue_io(struct inode *inode, struct bdi_writeback *wb)
223 {
224         assert_spin_locked(&wb->list_lock);
225         list_move(&inode->i_wb_list, &wb->b_more_io);
226 }
227
228 static void inode_sync_complete(struct inode *inode)
229 {
230         inode->i_state &= ~I_SYNC;
231         /* Waiters must see I_SYNC cleared before being woken up */
232         smp_mb();
233         wake_up_bit(&inode->i_state, __I_SYNC);
234 }
235
236 static bool inode_dirtied_after(struct inode *inode, unsigned long t)
237 {
238         bool ret = time_after(inode->dirtied_when, t);
239 #ifndef CONFIG_64BIT
240         /*
241          * For inodes being constantly redirtied, dirtied_when can get stuck.
242          * It _appears_ to be in the future, but is actually in distant past.
243          * This test is necessary to prevent such wrapped-around relative times
244          * from permanently stopping the whole bdi writeback.
245          */
246         ret = ret && time_before_eq(inode->dirtied_when, jiffies);
247 #endif
248         return ret;
249 }
250
251 /*
252  * Move expired (dirtied after work->older_than_this) dirty inodes from
253  * @delaying_queue to @dispatch_queue.
254  */
255 static int move_expired_inodes(struct list_head *delaying_queue,
256                                struct list_head *dispatch_queue,
257                                struct wb_writeback_work *work)
258 {
259         LIST_HEAD(tmp);
260         struct list_head *pos, *node;
261         struct super_block *sb = NULL;
262         struct inode *inode;
263         int do_sb_sort = 0;
264         int moved = 0;
265
266         while (!list_empty(delaying_queue)) {
267                 inode = wb_inode(delaying_queue->prev);
268                 if (work->older_than_this &&
269                     inode_dirtied_after(inode, *work->older_than_this))
270                         break;
271                 if (sb && sb != inode->i_sb)
272                         do_sb_sort = 1;
273                 sb = inode->i_sb;
274                 list_move(&inode->i_wb_list, &tmp);
275                 moved++;
276         }
277
278         /* just one sb in list, splice to dispatch_queue and we're done */
279         if (!do_sb_sort) {
280                 list_splice(&tmp, dispatch_queue);
281                 goto out;
282         }
283
284         /* Move inodes from one superblock together */
285         while (!list_empty(&tmp)) {
286                 sb = wb_inode(tmp.prev)->i_sb;
287                 list_for_each_prev_safe(pos, node, &tmp) {
288                         inode = wb_inode(pos);
289                         if (inode->i_sb == sb)
290                                 list_move(&inode->i_wb_list, dispatch_queue);
291                 }
292         }
293 out:
294         return moved;
295 }
296
297 /*
298  * Queue all expired dirty inodes for io, eldest first.
299  * Before
300  *         newly dirtied     b_dirty    b_io    b_more_io
301  *         =============>    gf         edc     BA
302  * After
303  *         newly dirtied     b_dirty    b_io    b_more_io
304  *         =============>    g          fBAedc
305  *                                           |
306  *                                           +--> dequeue for IO
307  */
308 static void queue_io(struct bdi_writeback *wb, struct wb_writeback_work *work)
309 {
310         int moved;
311         assert_spin_locked(&wb->list_lock);
312         list_splice_init(&wb->b_more_io, &wb->b_io);
313         moved = move_expired_inodes(&wb->b_dirty, &wb->b_io, work);
314         trace_writeback_queue_io(wb, work, moved);
315 }
316
317 static int write_inode(struct inode *inode, struct writeback_control *wbc)
318 {
319         if (inode->i_sb->s_op->write_inode && !is_bad_inode(inode))
320                 return inode->i_sb->s_op->write_inode(inode, wbc);
321         return 0;
322 }
323
324 /*
325  * Wait for writeback on an inode to complete. Called with i_lock held.
326  * Caller must make sure inode cannot go away when we drop i_lock.
327  */
328 static void __inode_wait_for_writeback(struct inode *inode)
329         __releases(inode->i_lock)
330         __acquires(inode->i_lock)
331 {
332         DEFINE_WAIT_BIT(wq, &inode->i_state, __I_SYNC);
333         wait_queue_head_t *wqh;
334
335         wqh = bit_waitqueue(&inode->i_state, __I_SYNC);
336         while (inode->i_state & I_SYNC) {
337                 spin_unlock(&inode->i_lock);
338                 __wait_on_bit(wqh, &wq, inode_wait, TASK_UNINTERRUPTIBLE);
339                 spin_lock(&inode->i_lock);
340         }
341 }
342
343 /*
344  * Wait for writeback on an inode to complete. Caller must have inode pinned.
345  */
346 void inode_wait_for_writeback(struct inode *inode)
347 {
348         spin_lock(&inode->i_lock);
349         __inode_wait_for_writeback(inode);
350         spin_unlock(&inode->i_lock);
351 }
352
353 /*
354  * Sleep until I_SYNC is cleared. This function must be called with i_lock
355  * held and drops it. It is aimed for callers not holding any inode reference
356  * so once i_lock is dropped, inode can go away.
357  */
358 static void inode_sleep_on_writeback(struct inode *inode)
359         __releases(inode->i_lock)
360 {
361         DEFINE_WAIT(wait);
362         wait_queue_head_t *wqh = bit_waitqueue(&inode->i_state, __I_SYNC);
363         int sleep;
364
365         prepare_to_wait(wqh, &wait, TASK_UNINTERRUPTIBLE);
366         sleep = inode->i_state & I_SYNC;
367         spin_unlock(&inode->i_lock);
368         if (sleep)
369                 schedule();
370         finish_wait(wqh, &wait);
371 }
372
373 /*
374  * Find proper writeback list for the inode depending on its current state and
375  * possibly also change of its state while we were doing writeback.  Here we
376  * handle things such as livelock prevention or fairness of writeback among
377  * inodes. This function can be called only by flusher thread - noone else
378  * processes all inodes in writeback lists and requeueing inodes behind flusher
379  * thread's back can have unexpected consequences.
380  */
381 static void requeue_inode(struct inode *inode, struct bdi_writeback *wb,
382                           struct writeback_control *wbc)
383 {
384         if (inode->i_state & I_FREEING)
385                 return;
386
387         /*
388          * Sync livelock prevention. Each inode is tagged and synced in one
389          * shot. If still dirty, it will be redirty_tail()'ed below.  Update
390          * the dirty time to prevent enqueue and sync it again.
391          */
392         if ((inode->i_state & I_DIRTY) &&
393             (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages))
394                 inode->dirtied_when = jiffies;
395
396         if (wbc->pages_skipped) {
397                 /*
398                  * writeback is not making progress due to locked
399                  * buffers. Skip this inode for now.
400                  */
401                 redirty_tail(inode, wb);
402                 return;
403         }
404
405         if (mapping_tagged(inode->i_mapping, PAGECACHE_TAG_DIRTY)) {
406                 /*
407                  * We didn't write back all the pages.  nfs_writepages()
408                  * sometimes bales out without doing anything.
409                  */
410                 if (wbc->nr_to_write <= 0) {
411                         /* Slice used up. Queue for next turn. */
412                         requeue_io(inode, wb);
413                 } else {
414                         /*
415                          * Writeback blocked by something other than
416                          * congestion. Delay the inode for some time to
417                          * avoid spinning on the CPU (100% iowait)
418                          * retrying writeback of the dirty page/inode
419                          * that cannot be performed immediately.
420                          */
421                         redirty_tail(inode, wb);
422                 }
423         } else if (inode->i_state & I_DIRTY) {
424                 /*
425                  * Filesystems can dirty the inode during writeback operations,
426                  * such as delayed allocation during submission or metadata
427                  * updates after data IO completion.
428                  */
429                 redirty_tail(inode, wb);
430         } else {
431                 /* The inode is clean. Remove from writeback lists. */
432                 list_del_init(&inode->i_wb_list);
433         }
434 }
435
436 /*
437  * Write out an inode and its dirty pages. Do not update the writeback list
438  * linkage. That is left to the caller. The caller is also responsible for
439  * setting I_SYNC flag and calling inode_sync_complete() to clear it.
440  */
441 static int
442 __writeback_single_inode(struct inode *inode, struct writeback_control *wbc)
443 {
444         struct address_space *mapping = inode->i_mapping;
445         long nr_to_write = wbc->nr_to_write;
446         unsigned dirty;
447         int ret;
448
449         WARN_ON(!(inode->i_state & I_SYNC));
450
451         ret = do_writepages(mapping, wbc);
452
453         /*
454          * Make sure to wait on the data before writing out the metadata.
455          * This is important for filesystems that modify metadata on data
456          * I/O completion.
457          */
458         if (wbc->sync_mode == WB_SYNC_ALL) {
459                 int err = filemap_fdatawait(mapping);
460                 if (ret == 0)
461                         ret = err;
462         }
463
464         /*
465          * Some filesystems may redirty the inode during the writeback
466          * due to delalloc, clear dirty metadata flags right before
467          * write_inode()
468          */
469         spin_lock(&inode->i_lock);
470         /* Clear I_DIRTY_PAGES if we've written out all dirty pages */
471         if (!mapping_tagged(mapping, PAGECACHE_TAG_DIRTY))
472                 inode->i_state &= ~I_DIRTY_PAGES;
473         dirty = inode->i_state & I_DIRTY;
474         inode->i_state &= ~(I_DIRTY_SYNC | I_DIRTY_DATASYNC);
475         spin_unlock(&inode->i_lock);
476         /* Don't write the inode if only I_DIRTY_PAGES was set */
477         if (dirty & (I_DIRTY_SYNC | I_DIRTY_DATASYNC)) {
478                 int err = write_inode(inode, wbc);
479                 if (ret == 0)
480                         ret = err;
481         }
482         trace_writeback_single_inode(inode, wbc, nr_to_write);
483         return ret;
484 }
485
486 /*
487  * Write out an inode's dirty pages. Either the caller has an active reference
488  * on the inode or the inode has I_WILL_FREE set.
489  *
490  * This function is designed to be called for writing back one inode which
491  * we go e.g. from filesystem. Flusher thread uses __writeback_single_inode()
492  * and does more profound writeback list handling in writeback_sb_inodes().
493  */
494 static int
495 writeback_single_inode(struct inode *inode, struct bdi_writeback *wb,
496                        struct writeback_control *wbc)
497 {
498         int ret = 0;
499
500         spin_lock(&inode->i_lock);
501         if (!atomic_read(&inode->i_count))
502                 WARN_ON(!(inode->i_state & (I_WILL_FREE|I_FREEING)));
503         else
504                 WARN_ON(inode->i_state & I_WILL_FREE);
505
506         if (inode->i_state & I_SYNC) {
507                 if (wbc->sync_mode != WB_SYNC_ALL)
508                         goto out;
509                 /*
510                  * It's a data-integrity sync. We must wait. Since callers hold
511                  * inode reference or inode has I_WILL_FREE set, it cannot go
512                  * away under us.
513                  */
514                 __inode_wait_for_writeback(inode);
515         }
516         WARN_ON(inode->i_state & I_SYNC);
517         /*
518          * Skip inode if it is clean. We don't want to mess with writeback
519          * lists in this function since flusher thread may be doing for example
520          * sync in parallel and if we move the inode, it could get skipped. So
521          * here we make sure inode is on some writeback list and leave it there
522          * unless we have completely cleaned the inode.
523          */
524         if (!(inode->i_state & I_DIRTY))
525                 goto out;
526         inode->i_state |= I_SYNC;
527         spin_unlock(&inode->i_lock);
528
529         ret = __writeback_single_inode(inode, wbc);
530
531         spin_lock(&wb->list_lock);
532         spin_lock(&inode->i_lock);
533         /*
534          * If inode is clean, remove it from writeback lists. Otherwise don't
535          * touch it. See comment above for explanation.
536          */
537         if (!(inode->i_state & I_DIRTY))
538                 list_del_init(&inode->i_wb_list);
539         spin_unlock(&wb->list_lock);
540         inode_sync_complete(inode);
541 out:
542         spin_unlock(&inode->i_lock);
543         return ret;
544 }
545
546 static long writeback_chunk_size(struct backing_dev_info *bdi,
547                                  struct wb_writeback_work *work)
548 {
549         long pages;
550
551         /*
552          * WB_SYNC_ALL mode does livelock avoidance by syncing dirty
553          * inodes/pages in one big loop. Setting wbc.nr_to_write=LONG_MAX
554          * here avoids calling into writeback_inodes_wb() more than once.
555          *
556          * The intended call sequence for WB_SYNC_ALL writeback is:
557          *
558          *      wb_writeback()
559          *          writeback_sb_inodes()       <== called only once
560          *              write_cache_pages()     <== called once for each inode
561          *                   (quickly) tag currently dirty pages
562          *                   (maybe slowly) sync all tagged pages
563          */
564         if (work->sync_mode == WB_SYNC_ALL || work->tagged_writepages)
565                 pages = LONG_MAX;
566         else {
567                 pages = min(bdi->avg_write_bandwidth / 2,
568                             global_dirty_limit / DIRTY_SCOPE);
569                 pages = min(pages, work->nr_pages);
570                 pages = round_down(pages + MIN_WRITEBACK_PAGES,
571                                    MIN_WRITEBACK_PAGES);
572         }
573
574         return pages;
575 }
576
577 /*
578  * Write a portion of b_io inodes which belong to @sb.
579  *
580  * Return the number of pages and/or inodes written.
581  */
582 static long writeback_sb_inodes(struct super_block *sb,
583                                 struct bdi_writeback *wb,
584                                 struct wb_writeback_work *work)
585 {
586         struct writeback_control wbc = {
587                 .sync_mode              = work->sync_mode,
588                 .tagged_writepages      = work->tagged_writepages,
589                 .for_kupdate            = work->for_kupdate,
590                 .for_background         = work->for_background,
591                 .range_cyclic           = work->range_cyclic,
592                 .range_start            = 0,
593                 .range_end              = LLONG_MAX,
594         };
595         unsigned long start_time = jiffies;
596         long write_chunk;
597         long wrote = 0;  /* count both pages and inodes */
598
599         while (!list_empty(&wb->b_io)) {
600                 struct inode *inode = wb_inode(wb->b_io.prev);
601
602                 if (inode->i_sb != sb) {
603                         if (work->sb) {
604                                 /*
605                                  * We only want to write back data for this
606                                  * superblock, move all inodes not belonging
607                                  * to it back onto the dirty list.
608                                  */
609                                 redirty_tail(inode, wb);
610                                 continue;
611                         }
612
613                         /*
614                          * The inode belongs to a different superblock.
615                          * Bounce back to the caller to unpin this and
616                          * pin the next superblock.
617                          */
618                         break;
619                 }
620
621                 /*
622                  * Don't bother with new inodes or inodes being freed, first
623                  * kind does not need periodic writeout yet, and for the latter
624                  * kind writeout is handled by the freer.
625                  */
626                 spin_lock(&inode->i_lock);
627                 if (inode->i_state & (I_NEW | I_FREEING | I_WILL_FREE)) {
628                         spin_unlock(&inode->i_lock);
629                         redirty_tail(inode, wb);
630                         continue;
631                 }
632                 if ((inode->i_state & I_SYNC) && wbc.sync_mode != WB_SYNC_ALL) {
633                         /*
634                          * If this inode is locked for writeback and we are not
635                          * doing writeback-for-data-integrity, move it to
636                          * b_more_io so that writeback can proceed with the
637                          * other inodes on s_io.
638                          *
639                          * We'll have another go at writing back this inode
640                          * when we completed a full scan of b_io.
641                          */
642                         spin_unlock(&inode->i_lock);
643                         requeue_io(inode, wb);
644                         trace_writeback_sb_inodes_requeue(inode);
645                         continue;
646                 }
647                 spin_unlock(&wb->list_lock);
648
649                 /*
650                  * We already requeued the inode if it had I_SYNC set and we
651                  * are doing WB_SYNC_NONE writeback. So this catches only the
652                  * WB_SYNC_ALL case.
653                  */
654                 if (inode->i_state & I_SYNC) {
655                         /* Wait for I_SYNC. This function drops i_lock... */
656                         inode_sleep_on_writeback(inode);
657                         /* Inode may be gone, start again */
658                         spin_lock(&wb->list_lock);
659                         continue;
660                 }
661                 inode->i_state |= I_SYNC;
662                 spin_unlock(&inode->i_lock);
663
664                 write_chunk = writeback_chunk_size(wb->bdi, work);
665                 wbc.nr_to_write = write_chunk;
666                 wbc.pages_skipped = 0;
667
668                 /*
669                  * We use I_SYNC to pin the inode in memory. While it is set
670                  * evict_inode() will wait so the inode cannot be freed.
671                  */
672                 __writeback_single_inode(inode, &wbc);
673
674                 work->nr_pages -= write_chunk - wbc.nr_to_write;
675                 wrote += write_chunk - wbc.nr_to_write;
676                 spin_lock(&wb->list_lock);
677                 spin_lock(&inode->i_lock);
678                 if (!(inode->i_state & I_DIRTY))
679                         wrote++;
680                 requeue_inode(inode, wb, &wbc);
681                 inode_sync_complete(inode);
682                 spin_unlock(&inode->i_lock);
683                 cond_resched_lock(&wb->list_lock);
684                 /*
685                  * bail out to wb_writeback() often enough to check
686                  * background threshold and other termination conditions.
687                  */
688                 if (wrote) {
689                         if (time_is_before_jiffies(start_time + HZ / 10UL))
690                                 break;
691                         if (work->nr_pages <= 0)
692                                 break;
693                 }
694         }
695         return wrote;
696 }
697
698 static long __writeback_inodes_wb(struct bdi_writeback *wb,
699                                   struct wb_writeback_work *work)
700 {
701         unsigned long start_time = jiffies;
702         long wrote = 0;
703
704         while (!list_empty(&wb->b_io)) {
705                 struct inode *inode = wb_inode(wb->b_io.prev);
706                 struct super_block *sb = inode->i_sb;
707
708                 if (!grab_super_passive(sb)) {
709                         /*
710                          * grab_super_passive() may fail consistently due to
711                          * s_umount being grabbed by someone else. Don't use
712                          * requeue_io() to avoid busy retrying the inode/sb.
713                          */
714                         redirty_tail(inode, wb);
715                         continue;
716                 }
717                 wrote += writeback_sb_inodes(sb, wb, work);
718                 drop_super(sb);
719
720                 /* refer to the same tests at the end of writeback_sb_inodes */
721                 if (wrote) {
722                         if (time_is_before_jiffies(start_time + HZ / 10UL))
723                                 break;
724                         if (work->nr_pages <= 0)
725                                 break;
726                 }
727         }
728         /* Leave any unwritten inodes on b_io */
729         return wrote;
730 }
731
732 long writeback_inodes_wb(struct bdi_writeback *wb, long nr_pages,
733                                 enum wb_reason reason)
734 {
735         struct wb_writeback_work work = {
736                 .nr_pages       = nr_pages,
737                 .sync_mode      = WB_SYNC_NONE,
738                 .range_cyclic   = 1,
739                 .reason         = reason,
740         };
741
742         spin_lock(&wb->list_lock);
743         if (list_empty(&wb->b_io))
744                 queue_io(wb, &work);
745         __writeback_inodes_wb(wb, &work);
746         spin_unlock(&wb->list_lock);
747
748         return nr_pages - work.nr_pages;
749 }
750
751 static bool over_bground_thresh(struct backing_dev_info *bdi)
752 {
753         unsigned long background_thresh, dirty_thresh;
754
755         global_dirty_limits(&background_thresh, &dirty_thresh);
756
757         if (global_page_state(NR_FILE_DIRTY) +
758             global_page_state(NR_UNSTABLE_NFS) > background_thresh)
759                 return true;
760
761         if (bdi_stat(bdi, BDI_RECLAIMABLE) >
762                                 bdi_dirty_limit(bdi, background_thresh))
763                 return true;
764
765         return false;
766 }
767
768 /*
769  * Called under wb->list_lock. If there are multiple wb per bdi,
770  * only the flusher working on the first wb should do it.
771  */
772 static void wb_update_bandwidth(struct bdi_writeback *wb,
773                                 unsigned long start_time)
774 {
775         __bdi_update_bandwidth(wb->bdi, 0, 0, 0, 0, 0, start_time);
776 }
777
778 /*
779  * Explicit flushing or periodic writeback of "old" data.
780  *
781  * Define "old": the first time one of an inode's pages is dirtied, we mark the
782  * dirtying-time in the inode's address_space.  So this periodic writeback code
783  * just walks the superblock inode list, writing back any inodes which are
784  * older than a specific point in time.
785  *
786  * Try to run once per dirty_writeback_interval.  But if a writeback event
787  * takes longer than a dirty_writeback_interval interval, then leave a
788  * one-second gap.
789  *
790  * older_than_this takes precedence over nr_to_write.  So we'll only write back
791  * all dirty pages if they are all attached to "old" mappings.
792  */
793 static long wb_writeback(struct bdi_writeback *wb,
794                          struct wb_writeback_work *work)
795 {
796         unsigned long wb_start = jiffies;
797         long nr_pages = work->nr_pages;
798         unsigned long oldest_jif;
799         struct inode *inode;
800         long progress;
801
802         oldest_jif = jiffies;
803         work->older_than_this = &oldest_jif;
804
805         spin_lock(&wb->list_lock);
806         for (;;) {
807                 /*
808                  * Stop writeback when nr_pages has been consumed
809                  */
810                 if (work->nr_pages <= 0)
811                         break;
812
813                 /*
814                  * Background writeout and kupdate-style writeback may
815                  * run forever. Stop them if there is other work to do
816                  * so that e.g. sync can proceed. They'll be restarted
817                  * after the other works are all done.
818                  */
819                 if ((work->for_background || work->for_kupdate) &&
820                     !list_empty(&wb->bdi->work_list))
821                         break;
822
823                 /*
824                  * For background writeout, stop when we are below the
825                  * background dirty threshold
826                  */
827                 if (work->for_background && !over_bground_thresh(wb->bdi))
828                         break;
829
830                 /*
831                  * Kupdate and background works are special and we want to
832                  * include all inodes that need writing. Livelock avoidance is
833                  * handled by these works yielding to any other work so we are
834                  * safe.
835                  */
836                 if (work->for_kupdate) {
837                         oldest_jif = jiffies -
838                                 msecs_to_jiffies(dirty_expire_interval * 10);
839                 } else if (work->for_background)
840                         oldest_jif = jiffies;
841
842                 trace_writeback_start(wb->bdi, work);
843                 if (list_empty(&wb->b_io))
844                         queue_io(wb, work);
845                 if (work->sb)
846                         progress = writeback_sb_inodes(work->sb, wb, work);
847                 else
848                         progress = __writeback_inodes_wb(wb, work);
849                 trace_writeback_written(wb->bdi, work);
850
851                 wb_update_bandwidth(wb, wb_start);
852
853                 /*
854                  * Did we write something? Try for more
855                  *
856                  * Dirty inodes are moved to b_io for writeback in batches.
857                  * The completion of the current batch does not necessarily
858                  * mean the overall work is done. So we keep looping as long
859                  * as made some progress on cleaning pages or inodes.
860                  */
861                 if (progress)
862                         continue;
863                 /*
864                  * No more inodes for IO, bail
865                  */
866                 if (list_empty(&wb->b_more_io))
867                         break;
868                 /*
869                  * Nothing written. Wait for some inode to
870                  * become available for writeback. Otherwise
871                  * we'll just busyloop.
872                  */
873                 if (!list_empty(&wb->b_more_io))  {
874                         trace_writeback_wait(wb->bdi, work);
875                         inode = wb_inode(wb->b_more_io.prev);
876                         spin_lock(&inode->i_lock);
877                         spin_unlock(&wb->list_lock);
878                         /* This function drops i_lock... */
879                         inode_sleep_on_writeback(inode);
880                         spin_lock(&wb->list_lock);
881                 }
882         }
883         spin_unlock(&wb->list_lock);
884
885         return nr_pages - work->nr_pages;
886 }
887
888 /*
889  * Return the next wb_writeback_work struct that hasn't been processed yet.
890  */
891 static struct wb_writeback_work *
892 get_next_work_item(struct backing_dev_info *bdi)
893 {
894         struct wb_writeback_work *work = NULL;
895
896         spin_lock_bh(&bdi->wb_lock);
897         if (!list_empty(&bdi->work_list)) {
898                 work = list_entry(bdi->work_list.next,
899                                   struct wb_writeback_work, list);
900                 list_del_init(&work->list);
901         }
902         spin_unlock_bh(&bdi->wb_lock);
903         return work;
904 }
905
906 /*
907  * Add in the number of potentially dirty inodes, because each inode
908  * write can dirty pagecache in the underlying blockdev.
909  */
910 static unsigned long get_nr_dirty_pages(void)
911 {
912         return global_page_state(NR_FILE_DIRTY) +
913                 global_page_state(NR_UNSTABLE_NFS) +
914                 get_nr_dirty_inodes();
915 }
916
917 static long wb_check_background_flush(struct bdi_writeback *wb)
918 {
919         if (over_bground_thresh(wb->bdi)) {
920
921                 struct wb_writeback_work work = {
922                         .nr_pages       = LONG_MAX,
923                         .sync_mode      = WB_SYNC_NONE,
924                         .for_background = 1,
925                         .range_cyclic   = 1,
926                         .reason         = WB_REASON_BACKGROUND,
927                 };
928
929                 return wb_writeback(wb, &work);
930         }
931
932         return 0;
933 }
934
935 static long wb_check_old_data_flush(struct bdi_writeback *wb)
936 {
937         unsigned long expired;
938         long nr_pages;
939
940         /*
941          * When set to zero, disable periodic writeback
942          */
943         if (!dirty_writeback_interval)
944                 return 0;
945
946         expired = wb->last_old_flush +
947                         msecs_to_jiffies(dirty_writeback_interval * 10);
948         if (time_before(jiffies, expired))
949                 return 0;
950
951         wb->last_old_flush = jiffies;
952         nr_pages = get_nr_dirty_pages();
953
954         if (nr_pages) {
955                 struct wb_writeback_work work = {
956                         .nr_pages       = nr_pages,
957                         .sync_mode      = WB_SYNC_NONE,
958                         .for_kupdate    = 1,
959                         .range_cyclic   = 1,
960                         .reason         = WB_REASON_PERIODIC,
961                 };
962
963                 return wb_writeback(wb, &work);
964         }
965
966         return 0;
967 }
968
969 /*
970  * Retrieve work items and do the writeback they describe
971  */
972 long wb_do_writeback(struct bdi_writeback *wb, int force_wait)
973 {
974         struct backing_dev_info *bdi = wb->bdi;
975         struct wb_writeback_work *work;
976         long wrote = 0;
977
978         set_bit(BDI_writeback_running, &wb->bdi->state);
979         while ((work = get_next_work_item(bdi)) != NULL) {
980                 /*
981                  * Override sync mode, in case we must wait for completion
982                  * because this thread is exiting now.
983                  */
984                 if (force_wait)
985                         work->sync_mode = WB_SYNC_ALL;
986
987                 trace_writeback_exec(bdi, work);
988
989                 wrote += wb_writeback(wb, work);
990
991                 /*
992                  * Notify the caller of completion if this is a synchronous
993                  * work item, otherwise just free it.
994                  */
995                 if (work->done)
996                         complete(work->done);
997                 else
998                         kfree(work);
999         }
1000
1001         /*
1002          * Check for periodic writeback, kupdated() style
1003          */
1004         wrote += wb_check_old_data_flush(wb);
1005         wrote += wb_check_background_flush(wb);
1006         clear_bit(BDI_writeback_running, &wb->bdi->state);
1007
1008         return wrote;
1009 }
1010
1011 /*
1012  * Handle writeback of dirty data for the device backed by this bdi. Also
1013  * wakes up periodically and does kupdated style flushing.
1014  */
1015 int bdi_writeback_thread(void *data)
1016 {
1017         struct bdi_writeback *wb = data;
1018         struct backing_dev_info *bdi = wb->bdi;
1019         long pages_written;
1020
1021         current->flags |= PF_SWAPWRITE;
1022         set_freezable();
1023         wb->last_active = jiffies;
1024
1025         /*
1026          * Our parent may run at a different priority, just set us to normal
1027          */
1028         set_user_nice(current, 0);
1029
1030         trace_writeback_thread_start(bdi);
1031
1032         while (!kthread_freezable_should_stop(NULL)) {
1033                 /*
1034                  * Remove own delayed wake-up timer, since we are already awake
1035                  * and we'll take care of the preriodic write-back.
1036                  */
1037                 del_timer(&wb->wakeup_timer);
1038
1039                 pages_written = wb_do_writeback(wb, 0);
1040
1041                 trace_writeback_pages_written(pages_written);
1042
1043                 if (pages_written)
1044                         wb->last_active = jiffies;
1045
1046                 set_current_state(TASK_INTERRUPTIBLE);
1047                 if (!list_empty(&bdi->work_list) || kthread_should_stop()) {
1048                         __set_current_state(TASK_RUNNING);
1049                         continue;
1050                 }
1051
1052                 if (wb_has_dirty_io(wb) && dirty_writeback_interval)
1053                         schedule_timeout(msecs_to_jiffies(dirty_writeback_interval * 10));
1054                 else {
1055                         /*
1056                          * We have nothing to do, so can go sleep without any
1057                          * timeout and save power. When a work is queued or
1058                          * something is made dirty - we will be woken up.
1059                          */
1060                         schedule();
1061                 }
1062         }
1063
1064         /* Flush any work that raced with us exiting */
1065         if (!list_empty(&bdi->work_list))
1066                 wb_do_writeback(wb, 1);
1067
1068         trace_writeback_thread_stop(bdi);
1069         return 0;
1070 }
1071
1072
1073 /*
1074  * Start writeback of `nr_pages' pages.  If `nr_pages' is zero, write back
1075  * the whole world.
1076  */
1077 void wakeup_flusher_threads(long nr_pages, enum wb_reason reason)
1078 {
1079         struct backing_dev_info *bdi;
1080
1081         if (!nr_pages) {
1082                 nr_pages = global_page_state(NR_FILE_DIRTY) +
1083                                 global_page_state(NR_UNSTABLE_NFS);
1084         }
1085
1086         rcu_read_lock();
1087         list_for_each_entry_rcu(bdi, &bdi_list, bdi_list) {
1088                 if (!bdi_has_dirty_io(bdi))
1089                         continue;
1090                 __bdi_start_writeback(bdi, nr_pages, false, reason);
1091         }
1092         rcu_read_unlock();
1093 }
1094
1095 static noinline void block_dump___mark_inode_dirty(struct inode *inode)
1096 {
1097         if (inode->i_ino || strcmp(inode->i_sb->s_id, "bdev")) {
1098                 struct dentry *dentry;
1099                 const char *name = "?";
1100
1101                 dentry = d_find_alias(inode);
1102                 if (dentry) {
1103                         spin_lock(&dentry->d_lock);
1104                         name = (const char *) dentry->d_name.name;
1105                 }
1106                 printk(KERN_DEBUG
1107                        "%s(%d): dirtied inode %lu (%s) on %s\n",
1108                        current->comm, task_pid_nr(current), inode->i_ino,
1109                        name, inode->i_sb->s_id);
1110                 if (dentry) {
1111                         spin_unlock(&dentry->d_lock);
1112                         dput(dentry);
1113                 }
1114         }
1115 }
1116
1117 /**
1118  *      __mark_inode_dirty -    internal function
1119  *      @inode: inode to mark
1120  *      @flags: what kind of dirty (i.e. I_DIRTY_SYNC)
1121  *      Mark an inode as dirty. Callers should use mark_inode_dirty or
1122  *      mark_inode_dirty_sync.
1123  *
1124  * Put the inode on the super block's dirty list.
1125  *
1126  * CAREFUL! We mark it dirty unconditionally, but move it onto the
1127  * dirty list only if it is hashed or if it refers to a blockdev.
1128  * If it was not hashed, it will never be added to the dirty list
1129  * even if it is later hashed, as it will have been marked dirty already.
1130  *
1131  * In short, make sure you hash any inodes _before_ you start marking
1132  * them dirty.
1133  *
1134  * Note that for blockdevs, inode->dirtied_when represents the dirtying time of
1135  * the block-special inode (/dev/hda1) itself.  And the ->dirtied_when field of
1136  * the kernel-internal blockdev inode represents the dirtying time of the
1137  * blockdev's pages.  This is why for I_DIRTY_PAGES we always use
1138  * page->mapping->host, so the page-dirtying time is recorded in the internal
1139  * blockdev inode.
1140  */
1141 void __mark_inode_dirty(struct inode *inode, int flags)
1142 {
1143         struct super_block *sb = inode->i_sb;
1144         struct backing_dev_info *bdi = NULL;
1145
1146         /*
1147          * Don't do this for I_DIRTY_PAGES - that doesn't actually
1148          * dirty the inode itself
1149          */
1150         if (flags & (I_DIRTY_SYNC | I_DIRTY_DATASYNC)) {
1151                 if (sb->s_op->dirty_inode)
1152                         sb->s_op->dirty_inode(inode, flags);
1153         }
1154
1155         /*
1156          * make sure that changes are seen by all cpus before we test i_state
1157          * -- mikulas
1158          */
1159         smp_mb();
1160
1161         /* avoid the locking if we can */
1162         if ((inode->i_state & flags) == flags)
1163                 return;
1164
1165         if (unlikely(block_dump))
1166                 block_dump___mark_inode_dirty(inode);
1167
1168         spin_lock(&inode->i_lock);
1169         if ((inode->i_state & flags) != flags) {
1170                 const int was_dirty = inode->i_state & I_DIRTY;
1171
1172                 inode->i_state |= flags;
1173
1174                 /*
1175                  * If the inode is being synced, just update its dirty state.
1176                  * The unlocker will place the inode on the appropriate
1177                  * superblock list, based upon its state.
1178                  */
1179                 if (inode->i_state & I_SYNC)
1180                         goto out_unlock_inode;
1181
1182                 /*
1183                  * Only add valid (hashed) inodes to the superblock's
1184                  * dirty list.  Add blockdev inodes as well.
1185                  */
1186                 if (!S_ISBLK(inode->i_mode)) {
1187                         if (inode_unhashed(inode))
1188                                 goto out_unlock_inode;
1189                 }
1190                 if (inode->i_state & I_FREEING)
1191                         goto out_unlock_inode;
1192
1193                 /*
1194                  * If the inode was already on b_dirty/b_io/b_more_io, don't
1195                  * reposition it (that would break b_dirty time-ordering).
1196                  */
1197                 if (!was_dirty) {
1198                         bool wakeup_bdi = false;
1199                         bdi = inode_to_bdi(inode);
1200
1201                         if (bdi_cap_writeback_dirty(bdi)) {
1202                                 WARN(!test_bit(BDI_registered, &bdi->state),
1203                                      "bdi-%s not registered\n", bdi->name);
1204
1205                                 /*
1206                                  * If this is the first dirty inode for this
1207                                  * bdi, we have to wake-up the corresponding
1208                                  * bdi thread to make sure background
1209                                  * write-back happens later.
1210                                  */
1211                                 if (!wb_has_dirty_io(&bdi->wb))
1212                                         wakeup_bdi = true;
1213                         }
1214
1215                         spin_unlock(&inode->i_lock);
1216                         spin_lock(&bdi->wb.list_lock);
1217                         inode->dirtied_when = jiffies;
1218                         list_move(&inode->i_wb_list, &bdi->wb.b_dirty);
1219                         spin_unlock(&bdi->wb.list_lock);
1220
1221                         if (wakeup_bdi)
1222                                 bdi_wakeup_thread_delayed(bdi);
1223                         return;
1224                 }
1225         }
1226 out_unlock_inode:
1227         spin_unlock(&inode->i_lock);
1228
1229 }
1230 EXPORT_SYMBOL(__mark_inode_dirty);
1231
1232 static void wait_sb_inodes(struct super_block *sb)
1233 {
1234         struct inode *inode, *old_inode = NULL;
1235
1236         /*
1237          * We need to be protected against the filesystem going from
1238          * r/o to r/w or vice versa.
1239          */
1240         WARN_ON(!rwsem_is_locked(&sb->s_umount));
1241
1242         spin_lock(&inode_sb_list_lock);
1243
1244         /*
1245          * Data integrity sync. Must wait for all pages under writeback,
1246          * because there may have been pages dirtied before our sync
1247          * call, but which had writeout started before we write it out.
1248          * In which case, the inode may not be on the dirty list, but
1249          * we still have to wait for that writeout.
1250          */
1251         list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
1252                 struct address_space *mapping = inode->i_mapping;
1253
1254                 spin_lock(&inode->i_lock);
1255                 if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) ||
1256                     (mapping->nrpages == 0)) {
1257                         spin_unlock(&inode->i_lock);
1258                         continue;
1259                 }
1260                 __iget(inode);
1261                 spin_unlock(&inode->i_lock);
1262                 spin_unlock(&inode_sb_list_lock);
1263
1264                 /*
1265                  * We hold a reference to 'inode' so it couldn't have been
1266                  * removed from s_inodes list while we dropped the
1267                  * inode_sb_list_lock.  We cannot iput the inode now as we can
1268                  * be holding the last reference and we cannot iput it under
1269                  * inode_sb_list_lock. So we keep the reference and iput it
1270                  * later.
1271                  */
1272                 iput(old_inode);
1273                 old_inode = inode;
1274
1275                 filemap_fdatawait(mapping);
1276
1277                 cond_resched();
1278
1279                 spin_lock(&inode_sb_list_lock);
1280         }
1281         spin_unlock(&inode_sb_list_lock);
1282         iput(old_inode);
1283 }
1284
1285 /**
1286  * writeback_inodes_sb_nr -     writeback dirty inodes from given super_block
1287  * @sb: the superblock
1288  * @nr: the number of pages to write
1289  * @reason: reason why some writeback work initiated
1290  *
1291  * Start writeback on some inodes on this super_block. No guarantees are made
1292  * on how many (if any) will be written, and this function does not wait
1293  * for IO completion of submitted IO.
1294  */
1295 void writeback_inodes_sb_nr(struct super_block *sb,
1296                             unsigned long nr,
1297                             enum wb_reason reason)
1298 {
1299         DECLARE_COMPLETION_ONSTACK(done);
1300         struct wb_writeback_work work = {
1301                 .sb                     = sb,
1302                 .sync_mode              = WB_SYNC_NONE,
1303                 .tagged_writepages      = 1,
1304                 .done                   = &done,
1305                 .nr_pages               = nr,
1306                 .reason                 = reason,
1307         };
1308
1309         if (sb->s_bdi == &noop_backing_dev_info)
1310                 return;
1311         WARN_ON(!rwsem_is_locked(&sb->s_umount));
1312         bdi_queue_work(sb->s_bdi, &work);
1313         wait_for_completion(&done);
1314 }
1315 EXPORT_SYMBOL(writeback_inodes_sb_nr);
1316
1317 /**
1318  * writeback_inodes_sb  -       writeback dirty inodes from given super_block
1319  * @sb: the superblock
1320  * @reason: reason why some writeback work was initiated
1321  *
1322  * Start writeback on some inodes on this super_block. No guarantees are made
1323  * on how many (if any) will be written, and this function does not wait
1324  * for IO completion of submitted IO.
1325  */
1326 void writeback_inodes_sb(struct super_block *sb, enum wb_reason reason)
1327 {
1328         return writeback_inodes_sb_nr(sb, get_nr_dirty_pages(), reason);
1329 }
1330 EXPORT_SYMBOL(writeback_inodes_sb);
1331
1332 /**
1333  * writeback_inodes_sb_if_idle  -       start writeback if none underway
1334  * @sb: the superblock
1335  * @reason: reason why some writeback work was initiated
1336  *
1337  * Invoke writeback_inodes_sb if no writeback is currently underway.
1338  * Returns 1 if writeback was started, 0 if not.
1339  */
1340 int writeback_inodes_sb_if_idle(struct super_block *sb, enum wb_reason reason)
1341 {
1342         if (!writeback_in_progress(sb->s_bdi)) {
1343                 down_read(&sb->s_umount);
1344                 writeback_inodes_sb(sb, reason);
1345                 up_read(&sb->s_umount);
1346                 return 1;
1347         } else
1348                 return 0;
1349 }
1350 EXPORT_SYMBOL(writeback_inodes_sb_if_idle);
1351
1352 /**
1353  * writeback_inodes_sb_nr_if_idle       -       start writeback if none underway
1354  * @sb: the superblock
1355  * @nr: the number of pages to write
1356  * @reason: reason why some writeback work was initiated
1357  *
1358  * Invoke writeback_inodes_sb if no writeback is currently underway.
1359  * Returns 1 if writeback was started, 0 if not.
1360  */
1361 int writeback_inodes_sb_nr_if_idle(struct super_block *sb,
1362                                    unsigned long nr,
1363                                    enum wb_reason reason)
1364 {
1365         if (!writeback_in_progress(sb->s_bdi)) {
1366                 down_read(&sb->s_umount);
1367                 writeback_inodes_sb_nr(sb, nr, reason);
1368                 up_read(&sb->s_umount);
1369                 return 1;
1370         } else
1371                 return 0;
1372 }
1373 EXPORT_SYMBOL(writeback_inodes_sb_nr_if_idle);
1374
1375 /**
1376  * sync_inodes_sb       -       sync sb inode pages
1377  * @sb: the superblock
1378  *
1379  * This function writes and waits on any dirty inode belonging to this
1380  * super_block.
1381  */
1382 void sync_inodes_sb(struct super_block *sb)
1383 {
1384         DECLARE_COMPLETION_ONSTACK(done);
1385         struct wb_writeback_work work = {
1386                 .sb             = sb,
1387                 .sync_mode      = WB_SYNC_ALL,
1388                 .nr_pages       = LONG_MAX,
1389                 .range_cyclic   = 0,
1390                 .done           = &done,
1391                 .reason         = WB_REASON_SYNC,
1392         };
1393
1394         /* Nothing to do? */
1395         if (sb->s_bdi == &noop_backing_dev_info)
1396                 return;
1397         WARN_ON(!rwsem_is_locked(&sb->s_umount));
1398
1399         bdi_queue_work(sb->s_bdi, &work);
1400         wait_for_completion(&done);
1401
1402         wait_sb_inodes(sb);
1403 }
1404 EXPORT_SYMBOL(sync_inodes_sb);
1405
1406 /**
1407  * write_inode_now      -       write an inode to disk
1408  * @inode: inode to write to disk
1409  * @sync: whether the write should be synchronous or not
1410  *
1411  * This function commits an inode to disk immediately if it is dirty. This is
1412  * primarily needed by knfsd.
1413  *
1414  * The caller must either have a ref on the inode or must have set I_WILL_FREE.
1415  */
1416 int write_inode_now(struct inode *inode, int sync)
1417 {
1418         struct bdi_writeback *wb = &inode_to_bdi(inode)->wb;
1419         struct writeback_control wbc = {
1420                 .nr_to_write = LONG_MAX,
1421                 .sync_mode = sync ? WB_SYNC_ALL : WB_SYNC_NONE,
1422                 .range_start = 0,
1423                 .range_end = LLONG_MAX,
1424         };
1425
1426         if (!mapping_cap_writeback_dirty(inode->i_mapping))
1427                 wbc.nr_to_write = 0;
1428
1429         might_sleep();
1430         return writeback_single_inode(inode, wb, &wbc);
1431 }
1432 EXPORT_SYMBOL(write_inode_now);
1433
1434 /**
1435  * sync_inode - write an inode and its pages to disk.
1436  * @inode: the inode to sync
1437  * @wbc: controls the writeback mode
1438  *
1439  * sync_inode() will write an inode and its pages to disk.  It will also
1440  * correctly update the inode on its superblock's dirty inode lists and will
1441  * update inode->i_state.
1442  *
1443  * The caller must have a ref on the inode.
1444  */
1445 int sync_inode(struct inode *inode, struct writeback_control *wbc)
1446 {
1447         return writeback_single_inode(inode, &inode_to_bdi(inode)->wb, wbc);
1448 }
1449 EXPORT_SYMBOL(sync_inode);
1450
1451 /**
1452  * sync_inode_metadata - write an inode to disk
1453  * @inode: the inode to sync
1454  * @wait: wait for I/O to complete.
1455  *
1456  * Write an inode to disk and adjust its dirty state after completion.
1457  *
1458  * Note: only writes the actual inode, no associated data or other metadata.
1459  */
1460 int sync_inode_metadata(struct inode *inode, int wait)
1461 {
1462         struct writeback_control wbc = {
1463                 .sync_mode = wait ? WB_SYNC_ALL : WB_SYNC_NONE,
1464                 .nr_to_write = 0, /* metadata-only */
1465         };
1466
1467         return sync_inode(inode, &wbc);
1468 }
1469 EXPORT_SYMBOL(sync_inode_metadata);