4 * Copyright (C) 2002, Linus Torvalds.
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.
11 * 10Apr2002 Andrew Morton
12 * Split out of fs/inode.c
13 * Additions for address_space-based writeback
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>
23 #include <linux/pagemap.h>
24 #include <linux/kthread.h>
25 #include <linux/writeback.h>
26 #include <linux/blkdev.h>
27 #include <linux/backing-dev.h>
28 #include <linux/tracepoint.h>
29 #include <linux/device.h>
33 * 4MB minimal write chunk size
35 #define MIN_WRITEBACK_PAGES (4096UL >> (PAGE_CACHE_SHIFT - 10))
37 struct wb_completion {
42 * Passed into wb_writeback(), essentially a subset of writeback_control
44 struct wb_writeback_work {
46 struct super_block *sb;
47 unsigned long *older_than_this;
48 enum writeback_sync_modes sync_mode;
49 unsigned int tagged_writepages:1;
50 unsigned int for_kupdate:1;
51 unsigned int range_cyclic:1;
52 unsigned int for_background:1;
53 unsigned int for_sync:1; /* sync(2) WB_SYNC_ALL writeback */
54 unsigned int auto_free:1; /* free on completion */
55 unsigned int single_wait:1;
56 unsigned int single_done:1;
57 enum wb_reason reason; /* why was writeback initiated? */
59 struct list_head list; /* pending work list */
60 struct wb_completion *done; /* set if the caller waits */
64 * If one wants to wait for one or more wb_writeback_works, each work's
65 * ->done should be set to a wb_completion defined using the following
66 * macro. Once all work items are issued with wb_queue_work(), the caller
67 * can wait for the completion of all using wb_wait_for_completion(). Work
68 * items which are waited upon aren't freed automatically on completion.
70 #define DEFINE_WB_COMPLETION_ONSTACK(cmpl) \
71 struct wb_completion cmpl = { \
72 .cnt = ATOMIC_INIT(1), \
77 * If an inode is constantly having its pages dirtied, but then the
78 * updates stop dirtytime_expire_interval seconds in the past, it's
79 * possible for the worst case time between when an inode has its
80 * timestamps updated and when they finally get written out to be two
81 * dirtytime_expire_intervals. We set the default to 12 hours (in
82 * seconds), which means most of the time inodes will have their
83 * timestamps written to disk after 12 hours, but in the worst case a
84 * few inodes might not their timestamps updated for 24 hours.
86 unsigned int dirtytime_expire_interval = 12 * 60 * 60;
88 static inline struct inode *wb_inode(struct list_head *head)
90 return list_entry(head, struct inode, i_wb_list);
94 * Include the creation of the trace points after defining the
95 * wb_writeback_work structure and inline functions so that the definition
96 * remains local to this file.
98 #define CREATE_TRACE_POINTS
99 #include <trace/events/writeback.h>
101 EXPORT_TRACEPOINT_SYMBOL_GPL(wbc_writepage);
103 static bool wb_io_lists_populated(struct bdi_writeback *wb)
105 if (wb_has_dirty_io(wb)) {
108 set_bit(WB_has_dirty_io, &wb->state);
109 WARN_ON_ONCE(!wb->avg_write_bandwidth);
110 atomic_long_add(wb->avg_write_bandwidth,
111 &wb->bdi->tot_write_bandwidth);
116 static void wb_io_lists_depopulated(struct bdi_writeback *wb)
118 if (wb_has_dirty_io(wb) && list_empty(&wb->b_dirty) &&
119 list_empty(&wb->b_io) && list_empty(&wb->b_more_io)) {
120 clear_bit(WB_has_dirty_io, &wb->state);
121 WARN_ON_ONCE(atomic_long_sub_return(wb->avg_write_bandwidth,
122 &wb->bdi->tot_write_bandwidth) < 0);
127 * inode_wb_list_move_locked - move an inode onto a bdi_writeback IO list
128 * @inode: inode to be moved
129 * @wb: target bdi_writeback
130 * @head: one of @wb->b_{dirty|io|more_io}
132 * Move @inode->i_wb_list to @list of @wb and set %WB_has_dirty_io.
133 * Returns %true if @inode is the first occupant of the !dirty_time IO
134 * lists; otherwise, %false.
136 static bool inode_wb_list_move_locked(struct inode *inode,
137 struct bdi_writeback *wb,
138 struct list_head *head)
140 assert_spin_locked(&wb->list_lock);
142 list_move(&inode->i_wb_list, head);
144 /* dirty_time doesn't count as dirty_io until expiration */
145 if (head != &wb->b_dirty_time)
146 return wb_io_lists_populated(wb);
148 wb_io_lists_depopulated(wb);
153 * inode_wb_list_del_locked - remove an inode from its bdi_writeback IO list
154 * @inode: inode to be removed
155 * @wb: bdi_writeback @inode is being removed from
157 * Remove @inode which may be on one of @wb->b_{dirty|io|more_io} lists and
158 * clear %WB_has_dirty_io if all are empty afterwards.
160 static void inode_wb_list_del_locked(struct inode *inode,
161 struct bdi_writeback *wb)
163 assert_spin_locked(&wb->list_lock);
165 list_del_init(&inode->i_wb_list);
166 wb_io_lists_depopulated(wb);
169 static void wb_wakeup(struct bdi_writeback *wb)
171 spin_lock_bh(&wb->work_lock);
172 if (test_bit(WB_registered, &wb->state))
173 mod_delayed_work(bdi_wq, &wb->dwork, 0);
174 spin_unlock_bh(&wb->work_lock);
177 static void wb_queue_work(struct bdi_writeback *wb,
178 struct wb_writeback_work *work)
180 trace_writeback_queue(wb->bdi, work);
182 spin_lock_bh(&wb->work_lock);
183 if (!test_bit(WB_registered, &wb->state)) {
184 if (work->single_wait)
185 work->single_done = 1;
189 atomic_inc(&work->done->cnt);
190 list_add_tail(&work->list, &wb->work_list);
191 mod_delayed_work(bdi_wq, &wb->dwork, 0);
193 spin_unlock_bh(&wb->work_lock);
197 * wb_wait_for_completion - wait for completion of bdi_writeback_works
198 * @bdi: bdi work items were issued to
199 * @done: target wb_completion
201 * Wait for one or more work items issued to @bdi with their ->done field
202 * set to @done, which should have been defined with
203 * DEFINE_WB_COMPLETION_ONSTACK(). This function returns after all such
204 * work items are completed. Work items which are waited upon aren't freed
205 * automatically on completion.
207 static void wb_wait_for_completion(struct backing_dev_info *bdi,
208 struct wb_completion *done)
210 atomic_dec(&done->cnt); /* put down the initial count */
211 wait_event(bdi->wb_waitq, !atomic_read(&done->cnt));
214 #ifdef CONFIG_CGROUP_WRITEBACK
217 * inode_congested - test whether an inode is congested
218 * @inode: inode to test for congestion
219 * @cong_bits: mask of WB_[a]sync_congested bits to test
221 * Tests whether @inode is congested. @cong_bits is the mask of congestion
222 * bits to test and the return value is the mask of set bits.
224 * If cgroup writeback is enabled for @inode, the congestion state is
225 * determined by whether the cgwb (cgroup bdi_writeback) for the blkcg
226 * associated with @inode is congested; otherwise, the root wb's congestion
229 int inode_congested(struct inode *inode, int cong_bits)
232 struct bdi_writeback *wb = inode_to_wb(inode);
234 return wb_congested(wb, cong_bits);
237 return wb_congested(&inode_to_bdi(inode)->wb, cong_bits);
239 EXPORT_SYMBOL_GPL(inode_congested);
242 * wb_wait_for_single_work - wait for completion of a single bdi_writeback_work
243 * @bdi: bdi the work item was issued to
244 * @work: work item to wait for
246 * Wait for the completion of @work which was issued to one of @bdi's
247 * bdi_writeback's. The caller must have set @work->single_wait before
248 * issuing it. This wait operates independently fo
249 * wb_wait_for_completion() and also disables automatic freeing of @work.
251 static void wb_wait_for_single_work(struct backing_dev_info *bdi,
252 struct wb_writeback_work *work)
254 if (WARN_ON_ONCE(!work->single_wait))
257 wait_event(bdi->wb_waitq, work->single_done);
260 * Paired with smp_wmb() in wb_do_writeback() and ensures that all
261 * modifications to @work prior to assertion of ->single_done is
262 * visible to the caller once this function returns.
268 * wb_split_bdi_pages - split nr_pages to write according to bandwidth
269 * @wb: target bdi_writeback to split @nr_pages to
270 * @nr_pages: number of pages to write for the whole bdi
272 * Split @wb's portion of @nr_pages according to @wb's write bandwidth in
273 * relation to the total write bandwidth of all wb's w/ dirty inodes on
276 static long wb_split_bdi_pages(struct bdi_writeback *wb, long nr_pages)
278 unsigned long this_bw = wb->avg_write_bandwidth;
279 unsigned long tot_bw = atomic_long_read(&wb->bdi->tot_write_bandwidth);
281 if (nr_pages == LONG_MAX)
285 * This may be called on clean wb's and proportional distribution
286 * may not make sense, just use the original @nr_pages in those
287 * cases. In general, we wanna err on the side of writing more.
289 if (!tot_bw || this_bw >= tot_bw)
292 return DIV_ROUND_UP_ULL((u64)nr_pages * this_bw, tot_bw);
295 #else /* CONFIG_CGROUP_WRITEBACK */
297 static long wb_split_bdi_pages(struct bdi_writeback *wb, long nr_pages)
302 #endif /* CONFIG_CGROUP_WRITEBACK */
304 void wb_start_writeback(struct bdi_writeback *wb, long nr_pages,
305 bool range_cyclic, enum wb_reason reason)
307 struct wb_writeback_work *work;
309 if (!wb_has_dirty_io(wb))
313 * This is WB_SYNC_NONE writeback, so if allocation fails just
314 * wakeup the thread for old dirty data writeback
316 work = kzalloc(sizeof(*work), GFP_ATOMIC);
318 trace_writeback_nowork(wb->bdi);
323 work->sync_mode = WB_SYNC_NONE;
324 work->nr_pages = nr_pages;
325 work->range_cyclic = range_cyclic;
326 work->reason = reason;
329 wb_queue_work(wb, work);
333 * wb_start_background_writeback - start background writeback
334 * @wb: bdi_writback to write from
337 * This makes sure WB_SYNC_NONE background writeback happens. When
338 * this function returns, it is only guaranteed that for given wb
339 * some IO is happening if we are over background dirty threshold.
340 * Caller need not hold sb s_umount semaphore.
342 void wb_start_background_writeback(struct bdi_writeback *wb)
345 * We just wake up the flusher thread. It will perform background
346 * writeback as soon as there is no other work to do.
348 trace_writeback_wake_background(wb->bdi);
353 * Remove the inode from the writeback list it is on.
355 void inode_wb_list_del(struct inode *inode)
357 struct bdi_writeback *wb = inode_to_wb(inode);
359 spin_lock(&wb->list_lock);
360 inode_wb_list_del_locked(inode, wb);
361 spin_unlock(&wb->list_lock);
365 * Redirty an inode: set its when-it-was dirtied timestamp and move it to the
366 * furthest end of its superblock's dirty-inode list.
368 * Before stamping the inode's ->dirtied_when, we check to see whether it is
369 * already the most-recently-dirtied inode on the b_dirty list. If that is
370 * the case then the inode must have been redirtied while it was being written
371 * out and we don't reset its dirtied_when.
373 static void redirty_tail(struct inode *inode, struct bdi_writeback *wb)
375 if (!list_empty(&wb->b_dirty)) {
378 tail = wb_inode(wb->b_dirty.next);
379 if (time_before(inode->dirtied_when, tail->dirtied_when))
380 inode->dirtied_when = jiffies;
382 inode_wb_list_move_locked(inode, wb, &wb->b_dirty);
386 * requeue inode for re-scanning after bdi->b_io list is exhausted.
388 static void requeue_io(struct inode *inode, struct bdi_writeback *wb)
390 inode_wb_list_move_locked(inode, wb, &wb->b_more_io);
393 static void inode_sync_complete(struct inode *inode)
395 inode->i_state &= ~I_SYNC;
396 /* If inode is clean an unused, put it into LRU now... */
397 inode_add_lru(inode);
398 /* Waiters must see I_SYNC cleared before being woken up */
400 wake_up_bit(&inode->i_state, __I_SYNC);
403 static bool inode_dirtied_after(struct inode *inode, unsigned long t)
405 bool ret = time_after(inode->dirtied_when, t);
408 * For inodes being constantly redirtied, dirtied_when can get stuck.
409 * It _appears_ to be in the future, but is actually in distant past.
410 * This test is necessary to prevent such wrapped-around relative times
411 * from permanently stopping the whole bdi writeback.
413 ret = ret && time_before_eq(inode->dirtied_when, jiffies);
418 #define EXPIRE_DIRTY_ATIME 0x0001
421 * Move expired (dirtied before work->older_than_this) dirty inodes from
422 * @delaying_queue to @dispatch_queue.
424 static int move_expired_inodes(struct list_head *delaying_queue,
425 struct list_head *dispatch_queue,
427 struct wb_writeback_work *work)
429 unsigned long *older_than_this = NULL;
430 unsigned long expire_time;
432 struct list_head *pos, *node;
433 struct super_block *sb = NULL;
438 if ((flags & EXPIRE_DIRTY_ATIME) == 0)
439 older_than_this = work->older_than_this;
440 else if (!work->for_sync) {
441 expire_time = jiffies - (dirtytime_expire_interval * HZ);
442 older_than_this = &expire_time;
444 while (!list_empty(delaying_queue)) {
445 inode = wb_inode(delaying_queue->prev);
446 if (older_than_this &&
447 inode_dirtied_after(inode, *older_than_this))
449 list_move(&inode->i_wb_list, &tmp);
451 if (flags & EXPIRE_DIRTY_ATIME)
452 set_bit(__I_DIRTY_TIME_EXPIRED, &inode->i_state);
453 if (sb_is_blkdev_sb(inode->i_sb))
455 if (sb && sb != inode->i_sb)
460 /* just one sb in list, splice to dispatch_queue and we're done */
462 list_splice(&tmp, dispatch_queue);
466 /* Move inodes from one superblock together */
467 while (!list_empty(&tmp)) {
468 sb = wb_inode(tmp.prev)->i_sb;
469 list_for_each_prev_safe(pos, node, &tmp) {
470 inode = wb_inode(pos);
471 if (inode->i_sb == sb)
472 list_move(&inode->i_wb_list, dispatch_queue);
480 * Queue all expired dirty inodes for io, eldest first.
482 * newly dirtied b_dirty b_io b_more_io
483 * =============> gf edc BA
485 * newly dirtied b_dirty b_io b_more_io
486 * =============> g fBAedc
488 * +--> dequeue for IO
490 static void queue_io(struct bdi_writeback *wb, struct wb_writeback_work *work)
494 assert_spin_locked(&wb->list_lock);
495 list_splice_init(&wb->b_more_io, &wb->b_io);
496 moved = move_expired_inodes(&wb->b_dirty, &wb->b_io, 0, work);
497 moved += move_expired_inodes(&wb->b_dirty_time, &wb->b_io,
498 EXPIRE_DIRTY_ATIME, work);
500 wb_io_lists_populated(wb);
501 trace_writeback_queue_io(wb, work, moved);
504 static int write_inode(struct inode *inode, struct writeback_control *wbc)
508 if (inode->i_sb->s_op->write_inode && !is_bad_inode(inode)) {
509 trace_writeback_write_inode_start(inode, wbc);
510 ret = inode->i_sb->s_op->write_inode(inode, wbc);
511 trace_writeback_write_inode(inode, wbc);
518 * Wait for writeback on an inode to complete. Called with i_lock held.
519 * Caller must make sure inode cannot go away when we drop i_lock.
521 static void __inode_wait_for_writeback(struct inode *inode)
522 __releases(inode->i_lock)
523 __acquires(inode->i_lock)
525 DEFINE_WAIT_BIT(wq, &inode->i_state, __I_SYNC);
526 wait_queue_head_t *wqh;
528 wqh = bit_waitqueue(&inode->i_state, __I_SYNC);
529 while (inode->i_state & I_SYNC) {
530 spin_unlock(&inode->i_lock);
531 __wait_on_bit(wqh, &wq, bit_wait,
532 TASK_UNINTERRUPTIBLE);
533 spin_lock(&inode->i_lock);
538 * Wait for writeback on an inode to complete. Caller must have inode pinned.
540 void inode_wait_for_writeback(struct inode *inode)
542 spin_lock(&inode->i_lock);
543 __inode_wait_for_writeback(inode);
544 spin_unlock(&inode->i_lock);
548 * Sleep until I_SYNC is cleared. This function must be called with i_lock
549 * held and drops it. It is aimed for callers not holding any inode reference
550 * so once i_lock is dropped, inode can go away.
552 static void inode_sleep_on_writeback(struct inode *inode)
553 __releases(inode->i_lock)
556 wait_queue_head_t *wqh = bit_waitqueue(&inode->i_state, __I_SYNC);
559 prepare_to_wait(wqh, &wait, TASK_UNINTERRUPTIBLE);
560 sleep = inode->i_state & I_SYNC;
561 spin_unlock(&inode->i_lock);
564 finish_wait(wqh, &wait);
568 * Find proper writeback list for the inode depending on its current state and
569 * possibly also change of its state while we were doing writeback. Here we
570 * handle things such as livelock prevention or fairness of writeback among
571 * inodes. This function can be called only by flusher thread - noone else
572 * processes all inodes in writeback lists and requeueing inodes behind flusher
573 * thread's back can have unexpected consequences.
575 static void requeue_inode(struct inode *inode, struct bdi_writeback *wb,
576 struct writeback_control *wbc)
578 if (inode->i_state & I_FREEING)
582 * Sync livelock prevention. Each inode is tagged and synced in one
583 * shot. If still dirty, it will be redirty_tail()'ed below. Update
584 * the dirty time to prevent enqueue and sync it again.
586 if ((inode->i_state & I_DIRTY) &&
587 (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages))
588 inode->dirtied_when = jiffies;
590 if (wbc->pages_skipped) {
592 * writeback is not making progress due to locked
593 * buffers. Skip this inode for now.
595 redirty_tail(inode, wb);
599 if (mapping_tagged(inode->i_mapping, PAGECACHE_TAG_DIRTY)) {
601 * We didn't write back all the pages. nfs_writepages()
602 * sometimes bales out without doing anything.
604 if (wbc->nr_to_write <= 0) {
605 /* Slice used up. Queue for next turn. */
606 requeue_io(inode, wb);
609 * Writeback blocked by something other than
610 * congestion. Delay the inode for some time to
611 * avoid spinning on the CPU (100% iowait)
612 * retrying writeback of the dirty page/inode
613 * that cannot be performed immediately.
615 redirty_tail(inode, wb);
617 } else if (inode->i_state & I_DIRTY) {
619 * Filesystems can dirty the inode during writeback operations,
620 * such as delayed allocation during submission or metadata
621 * updates after data IO completion.
623 redirty_tail(inode, wb);
624 } else if (inode->i_state & I_DIRTY_TIME) {
625 inode->dirtied_when = jiffies;
626 inode_wb_list_move_locked(inode, wb, &wb->b_dirty_time);
628 /* The inode is clean. Remove from writeback lists. */
629 inode_wb_list_del_locked(inode, wb);
634 * Write out an inode and its dirty pages. Do not update the writeback list
635 * linkage. That is left to the caller. The caller is also responsible for
636 * setting I_SYNC flag and calling inode_sync_complete() to clear it.
639 __writeback_single_inode(struct inode *inode, struct writeback_control *wbc)
641 struct address_space *mapping = inode->i_mapping;
642 long nr_to_write = wbc->nr_to_write;
646 WARN_ON(!(inode->i_state & I_SYNC));
648 trace_writeback_single_inode_start(inode, wbc, nr_to_write);
650 ret = do_writepages(mapping, wbc);
653 * Make sure to wait on the data before writing out the metadata.
654 * This is important for filesystems that modify metadata on data
655 * I/O completion. We don't do it for sync(2) writeback because it has a
656 * separate, external IO completion path and ->sync_fs for guaranteeing
657 * inode metadata is written back correctly.
659 if (wbc->sync_mode == WB_SYNC_ALL && !wbc->for_sync) {
660 int err = filemap_fdatawait(mapping);
666 * Some filesystems may redirty the inode during the writeback
667 * due to delalloc, clear dirty metadata flags right before
670 spin_lock(&inode->i_lock);
672 dirty = inode->i_state & I_DIRTY;
673 if (inode->i_state & I_DIRTY_TIME) {
674 if ((dirty & (I_DIRTY_SYNC | I_DIRTY_DATASYNC)) ||
675 unlikely(inode->i_state & I_DIRTY_TIME_EXPIRED) ||
676 unlikely(time_after(jiffies,
677 (inode->dirtied_time_when +
678 dirtytime_expire_interval * HZ)))) {
679 dirty |= I_DIRTY_TIME | I_DIRTY_TIME_EXPIRED;
680 trace_writeback_lazytime(inode);
683 inode->i_state &= ~I_DIRTY_TIME_EXPIRED;
684 inode->i_state &= ~dirty;
687 * Paired with smp_mb() in __mark_inode_dirty(). This allows
688 * __mark_inode_dirty() to test i_state without grabbing i_lock -
689 * either they see the I_DIRTY bits cleared or we see the dirtied
692 * I_DIRTY_PAGES is always cleared together above even if @mapping
693 * still has dirty pages. The flag is reinstated after smp_mb() if
694 * necessary. This guarantees that either __mark_inode_dirty()
695 * sees clear I_DIRTY_PAGES or we see PAGECACHE_TAG_DIRTY.
699 if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY))
700 inode->i_state |= I_DIRTY_PAGES;
702 spin_unlock(&inode->i_lock);
704 if (dirty & I_DIRTY_TIME)
705 mark_inode_dirty_sync(inode);
706 /* Don't write the inode if only I_DIRTY_PAGES was set */
707 if (dirty & ~I_DIRTY_PAGES) {
708 int err = write_inode(inode, wbc);
712 trace_writeback_single_inode(inode, wbc, nr_to_write);
717 * Write out an inode's dirty pages. Either the caller has an active reference
718 * on the inode or the inode has I_WILL_FREE set.
720 * This function is designed to be called for writing back one inode which
721 * we go e.g. from filesystem. Flusher thread uses __writeback_single_inode()
722 * and does more profound writeback list handling in writeback_sb_inodes().
725 writeback_single_inode(struct inode *inode, struct bdi_writeback *wb,
726 struct writeback_control *wbc)
730 spin_lock(&inode->i_lock);
731 if (!atomic_read(&inode->i_count))
732 WARN_ON(!(inode->i_state & (I_WILL_FREE|I_FREEING)));
734 WARN_ON(inode->i_state & I_WILL_FREE);
736 if (inode->i_state & I_SYNC) {
737 if (wbc->sync_mode != WB_SYNC_ALL)
740 * It's a data-integrity sync. We must wait. Since callers hold
741 * inode reference or inode has I_WILL_FREE set, it cannot go
744 __inode_wait_for_writeback(inode);
746 WARN_ON(inode->i_state & I_SYNC);
748 * Skip inode if it is clean and we have no outstanding writeback in
749 * WB_SYNC_ALL mode. We don't want to mess with writeback lists in this
750 * function since flusher thread may be doing for example sync in
751 * parallel and if we move the inode, it could get skipped. So here we
752 * make sure inode is on some writeback list and leave it there unless
753 * we have completely cleaned the inode.
755 if (!(inode->i_state & I_DIRTY_ALL) &&
756 (wbc->sync_mode != WB_SYNC_ALL ||
757 !mapping_tagged(inode->i_mapping, PAGECACHE_TAG_WRITEBACK)))
759 inode->i_state |= I_SYNC;
760 spin_unlock(&inode->i_lock);
762 ret = __writeback_single_inode(inode, wbc);
764 spin_lock(&wb->list_lock);
765 spin_lock(&inode->i_lock);
767 * If inode is clean, remove it from writeback lists. Otherwise don't
768 * touch it. See comment above for explanation.
770 if (!(inode->i_state & I_DIRTY_ALL))
771 inode_wb_list_del_locked(inode, wb);
772 spin_unlock(&wb->list_lock);
773 inode_sync_complete(inode);
775 spin_unlock(&inode->i_lock);
779 static long writeback_chunk_size(struct bdi_writeback *wb,
780 struct wb_writeback_work *work)
785 * WB_SYNC_ALL mode does livelock avoidance by syncing dirty
786 * inodes/pages in one big loop. Setting wbc.nr_to_write=LONG_MAX
787 * here avoids calling into writeback_inodes_wb() more than once.
789 * The intended call sequence for WB_SYNC_ALL writeback is:
792 * writeback_sb_inodes() <== called only once
793 * write_cache_pages() <== called once for each inode
794 * (quickly) tag currently dirty pages
795 * (maybe slowly) sync all tagged pages
797 if (work->sync_mode == WB_SYNC_ALL || work->tagged_writepages)
800 pages = min(wb->avg_write_bandwidth / 2,
801 global_dirty_limit / DIRTY_SCOPE);
802 pages = min(pages, work->nr_pages);
803 pages = round_down(pages + MIN_WRITEBACK_PAGES,
804 MIN_WRITEBACK_PAGES);
811 * Write a portion of b_io inodes which belong to @sb.
813 * Return the number of pages and/or inodes written.
815 static long writeback_sb_inodes(struct super_block *sb,
816 struct bdi_writeback *wb,
817 struct wb_writeback_work *work)
819 struct writeback_control wbc = {
820 .sync_mode = work->sync_mode,
821 .tagged_writepages = work->tagged_writepages,
822 .for_kupdate = work->for_kupdate,
823 .for_background = work->for_background,
824 .for_sync = work->for_sync,
825 .range_cyclic = work->range_cyclic,
827 .range_end = LLONG_MAX,
829 unsigned long start_time = jiffies;
831 long wrote = 0; /* count both pages and inodes */
833 while (!list_empty(&wb->b_io)) {
834 struct inode *inode = wb_inode(wb->b_io.prev);
836 if (inode->i_sb != sb) {
839 * We only want to write back data for this
840 * superblock, move all inodes not belonging
841 * to it back onto the dirty list.
843 redirty_tail(inode, wb);
848 * The inode belongs to a different superblock.
849 * Bounce back to the caller to unpin this and
850 * pin the next superblock.
856 * Don't bother with new inodes or inodes being freed, first
857 * kind does not need periodic writeout yet, and for the latter
858 * kind writeout is handled by the freer.
860 spin_lock(&inode->i_lock);
861 if (inode->i_state & (I_NEW | I_FREEING | I_WILL_FREE)) {
862 spin_unlock(&inode->i_lock);
863 redirty_tail(inode, wb);
866 if ((inode->i_state & I_SYNC) && wbc.sync_mode != WB_SYNC_ALL) {
868 * If this inode is locked for writeback and we are not
869 * doing writeback-for-data-integrity, move it to
870 * b_more_io so that writeback can proceed with the
871 * other inodes on s_io.
873 * We'll have another go at writing back this inode
874 * when we completed a full scan of b_io.
876 spin_unlock(&inode->i_lock);
877 requeue_io(inode, wb);
878 trace_writeback_sb_inodes_requeue(inode);
881 spin_unlock(&wb->list_lock);
884 * We already requeued the inode if it had I_SYNC set and we
885 * are doing WB_SYNC_NONE writeback. So this catches only the
888 if (inode->i_state & I_SYNC) {
889 /* Wait for I_SYNC. This function drops i_lock... */
890 inode_sleep_on_writeback(inode);
891 /* Inode may be gone, start again */
892 spin_lock(&wb->list_lock);
895 inode->i_state |= I_SYNC;
896 spin_unlock(&inode->i_lock);
898 write_chunk = writeback_chunk_size(wb, work);
899 wbc.nr_to_write = write_chunk;
900 wbc.pages_skipped = 0;
903 * We use I_SYNC to pin the inode in memory. While it is set
904 * evict_inode() will wait so the inode cannot be freed.
906 __writeback_single_inode(inode, &wbc);
908 work->nr_pages -= write_chunk - wbc.nr_to_write;
909 wrote += write_chunk - wbc.nr_to_write;
910 spin_lock(&wb->list_lock);
911 spin_lock(&inode->i_lock);
912 if (!(inode->i_state & I_DIRTY_ALL))
914 requeue_inode(inode, wb, &wbc);
915 inode_sync_complete(inode);
916 spin_unlock(&inode->i_lock);
917 cond_resched_lock(&wb->list_lock);
919 * bail out to wb_writeback() often enough to check
920 * background threshold and other termination conditions.
923 if (time_is_before_jiffies(start_time + HZ / 10UL))
925 if (work->nr_pages <= 0)
932 static long __writeback_inodes_wb(struct bdi_writeback *wb,
933 struct wb_writeback_work *work)
935 unsigned long start_time = jiffies;
938 while (!list_empty(&wb->b_io)) {
939 struct inode *inode = wb_inode(wb->b_io.prev);
940 struct super_block *sb = inode->i_sb;
942 if (!trylock_super(sb)) {
944 * trylock_super() may fail consistently due to
945 * s_umount being grabbed by someone else. Don't use
946 * requeue_io() to avoid busy retrying the inode/sb.
948 redirty_tail(inode, wb);
951 wrote += writeback_sb_inodes(sb, wb, work);
952 up_read(&sb->s_umount);
954 /* refer to the same tests at the end of writeback_sb_inodes */
956 if (time_is_before_jiffies(start_time + HZ / 10UL))
958 if (work->nr_pages <= 0)
962 /* Leave any unwritten inodes on b_io */
966 static long writeback_inodes_wb(struct bdi_writeback *wb, long nr_pages,
967 enum wb_reason reason)
969 struct wb_writeback_work work = {
970 .nr_pages = nr_pages,
971 .sync_mode = WB_SYNC_NONE,
976 spin_lock(&wb->list_lock);
977 if (list_empty(&wb->b_io))
979 __writeback_inodes_wb(wb, &work);
980 spin_unlock(&wb->list_lock);
982 return nr_pages - work.nr_pages;
985 static bool over_bground_thresh(struct bdi_writeback *wb)
987 unsigned long background_thresh, dirty_thresh;
989 global_dirty_limits(&background_thresh, &dirty_thresh);
991 if (global_page_state(NR_FILE_DIRTY) +
992 global_page_state(NR_UNSTABLE_NFS) > background_thresh)
995 if (wb_stat(wb, WB_RECLAIMABLE) > wb_dirty_limit(wb, background_thresh))
1002 * Called under wb->list_lock. If there are multiple wb per bdi,
1003 * only the flusher working on the first wb should do it.
1005 static void wb_update_bandwidth(struct bdi_writeback *wb,
1006 unsigned long start_time)
1008 __wb_update_bandwidth(wb, 0, 0, 0, 0, 0, start_time);
1012 * Explicit flushing or periodic writeback of "old" data.
1014 * Define "old": the first time one of an inode's pages is dirtied, we mark the
1015 * dirtying-time in the inode's address_space. So this periodic writeback code
1016 * just walks the superblock inode list, writing back any inodes which are
1017 * older than a specific point in time.
1019 * Try to run once per dirty_writeback_interval. But if a writeback event
1020 * takes longer than a dirty_writeback_interval interval, then leave a
1023 * older_than_this takes precedence over nr_to_write. So we'll only write back
1024 * all dirty pages if they are all attached to "old" mappings.
1026 static long wb_writeback(struct bdi_writeback *wb,
1027 struct wb_writeback_work *work)
1029 unsigned long wb_start = jiffies;
1030 long nr_pages = work->nr_pages;
1031 unsigned long oldest_jif;
1032 struct inode *inode;
1035 oldest_jif = jiffies;
1036 work->older_than_this = &oldest_jif;
1038 spin_lock(&wb->list_lock);
1041 * Stop writeback when nr_pages has been consumed
1043 if (work->nr_pages <= 0)
1047 * Background writeout and kupdate-style writeback may
1048 * run forever. Stop them if there is other work to do
1049 * so that e.g. sync can proceed. They'll be restarted
1050 * after the other works are all done.
1052 if ((work->for_background || work->for_kupdate) &&
1053 !list_empty(&wb->work_list))
1057 * For background writeout, stop when we are below the
1058 * background dirty threshold
1060 if (work->for_background && !over_bground_thresh(wb))
1064 * Kupdate and background works are special and we want to
1065 * include all inodes that need writing. Livelock avoidance is
1066 * handled by these works yielding to any other work so we are
1069 if (work->for_kupdate) {
1070 oldest_jif = jiffies -
1071 msecs_to_jiffies(dirty_expire_interval * 10);
1072 } else if (work->for_background)
1073 oldest_jif = jiffies;
1075 trace_writeback_start(wb->bdi, work);
1076 if (list_empty(&wb->b_io))
1079 progress = writeback_sb_inodes(work->sb, wb, work);
1081 progress = __writeback_inodes_wb(wb, work);
1082 trace_writeback_written(wb->bdi, work);
1084 wb_update_bandwidth(wb, wb_start);
1087 * Did we write something? Try for more
1089 * Dirty inodes are moved to b_io for writeback in batches.
1090 * The completion of the current batch does not necessarily
1091 * mean the overall work is done. So we keep looping as long
1092 * as made some progress on cleaning pages or inodes.
1097 * No more inodes for IO, bail
1099 if (list_empty(&wb->b_more_io))
1102 * Nothing written. Wait for some inode to
1103 * become available for writeback. Otherwise
1104 * we'll just busyloop.
1106 if (!list_empty(&wb->b_more_io)) {
1107 trace_writeback_wait(wb->bdi, work);
1108 inode = wb_inode(wb->b_more_io.prev);
1109 spin_lock(&inode->i_lock);
1110 spin_unlock(&wb->list_lock);
1111 /* This function drops i_lock... */
1112 inode_sleep_on_writeback(inode);
1113 spin_lock(&wb->list_lock);
1116 spin_unlock(&wb->list_lock);
1118 return nr_pages - work->nr_pages;
1122 * Return the next wb_writeback_work struct that hasn't been processed yet.
1124 static struct wb_writeback_work *get_next_work_item(struct bdi_writeback *wb)
1126 struct wb_writeback_work *work = NULL;
1128 spin_lock_bh(&wb->work_lock);
1129 if (!list_empty(&wb->work_list)) {
1130 work = list_entry(wb->work_list.next,
1131 struct wb_writeback_work, list);
1132 list_del_init(&work->list);
1134 spin_unlock_bh(&wb->work_lock);
1139 * Add in the number of potentially dirty inodes, because each inode
1140 * write can dirty pagecache in the underlying blockdev.
1142 static unsigned long get_nr_dirty_pages(void)
1144 return global_page_state(NR_FILE_DIRTY) +
1145 global_page_state(NR_UNSTABLE_NFS) +
1146 get_nr_dirty_inodes();
1149 static long wb_check_background_flush(struct bdi_writeback *wb)
1151 if (over_bground_thresh(wb)) {
1153 struct wb_writeback_work work = {
1154 .nr_pages = LONG_MAX,
1155 .sync_mode = WB_SYNC_NONE,
1156 .for_background = 1,
1158 .reason = WB_REASON_BACKGROUND,
1161 return wb_writeback(wb, &work);
1167 static long wb_check_old_data_flush(struct bdi_writeback *wb)
1169 unsigned long expired;
1173 * When set to zero, disable periodic writeback
1175 if (!dirty_writeback_interval)
1178 expired = wb->last_old_flush +
1179 msecs_to_jiffies(dirty_writeback_interval * 10);
1180 if (time_before(jiffies, expired))
1183 wb->last_old_flush = jiffies;
1184 nr_pages = get_nr_dirty_pages();
1187 struct wb_writeback_work work = {
1188 .nr_pages = nr_pages,
1189 .sync_mode = WB_SYNC_NONE,
1192 .reason = WB_REASON_PERIODIC,
1195 return wb_writeback(wb, &work);
1202 * Retrieve work items and do the writeback they describe
1204 static long wb_do_writeback(struct bdi_writeback *wb)
1206 struct wb_writeback_work *work;
1209 set_bit(WB_writeback_running, &wb->state);
1210 while ((work = get_next_work_item(wb)) != NULL) {
1211 struct wb_completion *done = work->done;
1212 bool need_wake_up = false;
1214 trace_writeback_exec(wb->bdi, work);
1216 wrote += wb_writeback(wb, work);
1218 if (work->single_wait) {
1219 WARN_ON_ONCE(work->auto_free);
1220 /* paired w/ rmb in wb_wait_for_single_work() */
1222 work->single_done = 1;
1223 need_wake_up = true;
1224 } else if (work->auto_free) {
1228 if (done && atomic_dec_and_test(&done->cnt))
1229 need_wake_up = true;
1232 wake_up_all(&wb->bdi->wb_waitq);
1236 * Check for periodic writeback, kupdated() style
1238 wrote += wb_check_old_data_flush(wb);
1239 wrote += wb_check_background_flush(wb);
1240 clear_bit(WB_writeback_running, &wb->state);
1246 * Handle writeback of dirty data for the device backed by this bdi. Also
1247 * reschedules periodically and does kupdated style flushing.
1249 void wb_workfn(struct work_struct *work)
1251 struct bdi_writeback *wb = container_of(to_delayed_work(work),
1252 struct bdi_writeback, dwork);
1255 set_worker_desc("flush-%s", dev_name(wb->bdi->dev));
1256 current->flags |= PF_SWAPWRITE;
1258 if (likely(!current_is_workqueue_rescuer() ||
1259 !test_bit(WB_registered, &wb->state))) {
1261 * The normal path. Keep writing back @wb until its
1262 * work_list is empty. Note that this path is also taken
1263 * if @wb is shutting down even when we're running off the
1264 * rescuer as work_list needs to be drained.
1267 pages_written = wb_do_writeback(wb);
1268 trace_writeback_pages_written(pages_written);
1269 } while (!list_empty(&wb->work_list));
1272 * bdi_wq can't get enough workers and we're running off
1273 * the emergency worker. Don't hog it. Hopefully, 1024 is
1274 * enough for efficient IO.
1276 pages_written = writeback_inodes_wb(wb, 1024,
1277 WB_REASON_FORKER_THREAD);
1278 trace_writeback_pages_written(pages_written);
1281 if (!list_empty(&wb->work_list))
1282 mod_delayed_work(bdi_wq, &wb->dwork, 0);
1283 else if (wb_has_dirty_io(wb) && dirty_writeback_interval)
1284 wb_wakeup_delayed(wb);
1286 current->flags &= ~PF_SWAPWRITE;
1290 * Start writeback of `nr_pages' pages. If `nr_pages' is zero, write back
1293 void wakeup_flusher_threads(long nr_pages, enum wb_reason reason)
1295 struct backing_dev_info *bdi;
1298 nr_pages = get_nr_dirty_pages();
1301 list_for_each_entry_rcu(bdi, &bdi_list, bdi_list) {
1302 struct bdi_writeback *wb;
1303 struct wb_iter iter;
1305 if (!bdi_has_dirty_io(bdi))
1308 bdi_for_each_wb(wb, bdi, &iter, 0)
1309 wb_start_writeback(wb, wb_split_bdi_pages(wb, nr_pages),
1316 * Wake up bdi's periodically to make sure dirtytime inodes gets
1317 * written back periodically. We deliberately do *not* check the
1318 * b_dirtytime list in wb_has_dirty_io(), since this would cause the
1319 * kernel to be constantly waking up once there are any dirtytime
1320 * inodes on the system. So instead we define a separate delayed work
1321 * function which gets called much more rarely. (By default, only
1322 * once every 12 hours.)
1324 * If there is any other write activity going on in the file system,
1325 * this function won't be necessary. But if the only thing that has
1326 * happened on the file system is a dirtytime inode caused by an atime
1327 * update, we need this infrastructure below to make sure that inode
1328 * eventually gets pushed out to disk.
1330 static void wakeup_dirtytime_writeback(struct work_struct *w);
1331 static DECLARE_DELAYED_WORK(dirtytime_work, wakeup_dirtytime_writeback);
1333 static void wakeup_dirtytime_writeback(struct work_struct *w)
1335 struct backing_dev_info *bdi;
1338 list_for_each_entry_rcu(bdi, &bdi_list, bdi_list) {
1339 struct bdi_writeback *wb;
1340 struct wb_iter iter;
1342 bdi_for_each_wb(wb, bdi, &iter, 0)
1343 if (!list_empty(&bdi->wb.b_dirty_time))
1344 wb_wakeup(&bdi->wb);
1347 schedule_delayed_work(&dirtytime_work, dirtytime_expire_interval * HZ);
1350 static int __init start_dirtytime_writeback(void)
1352 schedule_delayed_work(&dirtytime_work, dirtytime_expire_interval * HZ);
1355 __initcall(start_dirtytime_writeback);
1357 int dirtytime_interval_handler(struct ctl_table *table, int write,
1358 void __user *buffer, size_t *lenp, loff_t *ppos)
1362 ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
1363 if (ret == 0 && write)
1364 mod_delayed_work(system_wq, &dirtytime_work, 0);
1368 static noinline void block_dump___mark_inode_dirty(struct inode *inode)
1370 if (inode->i_ino || strcmp(inode->i_sb->s_id, "bdev")) {
1371 struct dentry *dentry;
1372 const char *name = "?";
1374 dentry = d_find_alias(inode);
1376 spin_lock(&dentry->d_lock);
1377 name = (const char *) dentry->d_name.name;
1380 "%s(%d): dirtied inode %lu (%s) on %s\n",
1381 current->comm, task_pid_nr(current), inode->i_ino,
1382 name, inode->i_sb->s_id);
1384 spin_unlock(&dentry->d_lock);
1391 * __mark_inode_dirty - internal function
1392 * @inode: inode to mark
1393 * @flags: what kind of dirty (i.e. I_DIRTY_SYNC)
1394 * Mark an inode as dirty. Callers should use mark_inode_dirty or
1395 * mark_inode_dirty_sync.
1397 * Put the inode on the super block's dirty list.
1399 * CAREFUL! We mark it dirty unconditionally, but move it onto the
1400 * dirty list only if it is hashed or if it refers to a blockdev.
1401 * If it was not hashed, it will never be added to the dirty list
1402 * even if it is later hashed, as it will have been marked dirty already.
1404 * In short, make sure you hash any inodes _before_ you start marking
1407 * Note that for blockdevs, inode->dirtied_when represents the dirtying time of
1408 * the block-special inode (/dev/hda1) itself. And the ->dirtied_when field of
1409 * the kernel-internal blockdev inode represents the dirtying time of the
1410 * blockdev's pages. This is why for I_DIRTY_PAGES we always use
1411 * page->mapping->host, so the page-dirtying time is recorded in the internal
1414 #define I_DIRTY_INODE (I_DIRTY_SYNC | I_DIRTY_DATASYNC)
1415 void __mark_inode_dirty(struct inode *inode, int flags)
1417 struct super_block *sb = inode->i_sb;
1418 struct backing_dev_info *bdi = NULL;
1421 trace_writeback_mark_inode_dirty(inode, flags);
1424 * Don't do this for I_DIRTY_PAGES - that doesn't actually
1425 * dirty the inode itself
1427 if (flags & (I_DIRTY_SYNC | I_DIRTY_DATASYNC | I_DIRTY_TIME)) {
1428 trace_writeback_dirty_inode_start(inode, flags);
1430 if (sb->s_op->dirty_inode)
1431 sb->s_op->dirty_inode(inode, flags);
1433 trace_writeback_dirty_inode(inode, flags);
1435 if (flags & I_DIRTY_INODE)
1436 flags &= ~I_DIRTY_TIME;
1437 dirtytime = flags & I_DIRTY_TIME;
1440 * Paired with smp_mb() in __writeback_single_inode() for the
1441 * following lockless i_state test. See there for details.
1445 if (((inode->i_state & flags) == flags) ||
1446 (dirtytime && (inode->i_state & I_DIRTY_INODE)))
1449 if (unlikely(block_dump))
1450 block_dump___mark_inode_dirty(inode);
1452 spin_lock(&inode->i_lock);
1453 if (dirtytime && (inode->i_state & I_DIRTY_INODE))
1454 goto out_unlock_inode;
1455 if ((inode->i_state & flags) != flags) {
1456 const int was_dirty = inode->i_state & I_DIRTY;
1458 inode_attach_wb(inode, NULL);
1460 if (flags & I_DIRTY_INODE)
1461 inode->i_state &= ~I_DIRTY_TIME;
1462 inode->i_state |= flags;
1465 * If the inode is being synced, just update its dirty state.
1466 * The unlocker will place the inode on the appropriate
1467 * superblock list, based upon its state.
1469 if (inode->i_state & I_SYNC)
1470 goto out_unlock_inode;
1473 * Only add valid (hashed) inodes to the superblock's
1474 * dirty list. Add blockdev inodes as well.
1476 if (!S_ISBLK(inode->i_mode)) {
1477 if (inode_unhashed(inode))
1478 goto out_unlock_inode;
1480 if (inode->i_state & I_FREEING)
1481 goto out_unlock_inode;
1484 * If the inode was already on b_dirty/b_io/b_more_io, don't
1485 * reposition it (that would break b_dirty time-ordering).
1488 struct list_head *dirty_list;
1489 bool wakeup_bdi = false;
1490 bdi = inode_to_bdi(inode);
1492 spin_unlock(&inode->i_lock);
1493 spin_lock(&bdi->wb.list_lock);
1495 WARN(bdi_cap_writeback_dirty(bdi) &&
1496 !test_bit(WB_registered, &bdi->wb.state),
1497 "bdi-%s not registered\n", bdi->name);
1499 inode->dirtied_when = jiffies;
1501 inode->dirtied_time_when = jiffies;
1503 if (inode->i_state & (I_DIRTY_INODE | I_DIRTY_PAGES))
1504 dirty_list = &bdi->wb.b_dirty;
1506 dirty_list = &bdi->wb.b_dirty_time;
1508 wakeup_bdi = inode_wb_list_move_locked(inode, &bdi->wb,
1511 spin_unlock(&bdi->wb.list_lock);
1512 trace_writeback_dirty_inode_enqueue(inode);
1515 * If this is the first dirty inode for this bdi,
1516 * we have to wake-up the corresponding bdi thread
1517 * to make sure background write-back happens
1520 if (bdi_cap_writeback_dirty(bdi) && wakeup_bdi)
1521 wb_wakeup_delayed(&bdi->wb);
1526 spin_unlock(&inode->i_lock);
1529 EXPORT_SYMBOL(__mark_inode_dirty);
1531 static void wait_sb_inodes(struct super_block *sb)
1533 struct inode *inode, *old_inode = NULL;
1536 * We need to be protected against the filesystem going from
1537 * r/o to r/w or vice versa.
1539 WARN_ON(!rwsem_is_locked(&sb->s_umount));
1541 spin_lock(&inode_sb_list_lock);
1544 * Data integrity sync. Must wait for all pages under writeback,
1545 * because there may have been pages dirtied before our sync
1546 * call, but which had writeout started before we write it out.
1547 * In which case, the inode may not be on the dirty list, but
1548 * we still have to wait for that writeout.
1550 list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
1551 struct address_space *mapping = inode->i_mapping;
1553 spin_lock(&inode->i_lock);
1554 if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) ||
1555 (mapping->nrpages == 0)) {
1556 spin_unlock(&inode->i_lock);
1560 spin_unlock(&inode->i_lock);
1561 spin_unlock(&inode_sb_list_lock);
1564 * We hold a reference to 'inode' so it couldn't have been
1565 * removed from s_inodes list while we dropped the
1566 * inode_sb_list_lock. We cannot iput the inode now as we can
1567 * be holding the last reference and we cannot iput it under
1568 * inode_sb_list_lock. So we keep the reference and iput it
1574 filemap_fdatawait(mapping);
1578 spin_lock(&inode_sb_list_lock);
1580 spin_unlock(&inode_sb_list_lock);
1584 static void __writeback_inodes_sb_nr(struct super_block *sb, unsigned long nr,
1585 enum wb_reason reason, bool skip_if_busy)
1587 DEFINE_WB_COMPLETION_ONSTACK(done);
1588 struct wb_writeback_work work = {
1590 .sync_mode = WB_SYNC_NONE,
1591 .tagged_writepages = 1,
1596 struct backing_dev_info *bdi = sb->s_bdi;
1598 if (!bdi_has_dirty_io(bdi) || bdi == &noop_backing_dev_info)
1600 WARN_ON(!rwsem_is_locked(&sb->s_umount));
1602 if (skip_if_busy && writeback_in_progress(&bdi->wb))
1605 wb_queue_work(&bdi->wb, &work);
1606 wb_wait_for_completion(bdi, &done);
1610 * writeback_inodes_sb_nr - writeback dirty inodes from given super_block
1611 * @sb: the superblock
1612 * @nr: the number of pages to write
1613 * @reason: reason why some writeback work initiated
1615 * Start writeback on some inodes on this super_block. No guarantees are made
1616 * on how many (if any) will be written, and this function does not wait
1617 * for IO completion of submitted IO.
1619 void writeback_inodes_sb_nr(struct super_block *sb,
1621 enum wb_reason reason)
1623 __writeback_inodes_sb_nr(sb, nr, reason, false);
1625 EXPORT_SYMBOL(writeback_inodes_sb_nr);
1628 * writeback_inodes_sb - writeback dirty inodes from given super_block
1629 * @sb: the superblock
1630 * @reason: reason why some writeback work was initiated
1632 * Start writeback on some inodes on this super_block. No guarantees are made
1633 * on how many (if any) will be written, and this function does not wait
1634 * for IO completion of submitted IO.
1636 void writeback_inodes_sb(struct super_block *sb, enum wb_reason reason)
1638 return writeback_inodes_sb_nr(sb, get_nr_dirty_pages(), reason);
1640 EXPORT_SYMBOL(writeback_inodes_sb);
1643 * try_to_writeback_inodes_sb_nr - try to start writeback if none underway
1644 * @sb: the superblock
1645 * @nr: the number of pages to write
1646 * @reason: the reason of writeback
1648 * Invoke writeback_inodes_sb_nr if no writeback is currently underway.
1649 * Returns 1 if writeback was started, 0 if not.
1651 bool try_to_writeback_inodes_sb_nr(struct super_block *sb, unsigned long nr,
1652 enum wb_reason reason)
1654 if (!down_read_trylock(&sb->s_umount))
1657 __writeback_inodes_sb_nr(sb, nr, reason, true);
1658 up_read(&sb->s_umount);
1661 EXPORT_SYMBOL(try_to_writeback_inodes_sb_nr);
1664 * try_to_writeback_inodes_sb - try to start writeback if none underway
1665 * @sb: the superblock
1666 * @reason: reason why some writeback work was initiated
1668 * Implement by try_to_writeback_inodes_sb_nr()
1669 * Returns 1 if writeback was started, 0 if not.
1671 bool try_to_writeback_inodes_sb(struct super_block *sb, enum wb_reason reason)
1673 return try_to_writeback_inodes_sb_nr(sb, get_nr_dirty_pages(), reason);
1675 EXPORT_SYMBOL(try_to_writeback_inodes_sb);
1678 * sync_inodes_sb - sync sb inode pages
1679 * @sb: the superblock
1681 * This function writes and waits on any dirty inode belonging to this
1684 void sync_inodes_sb(struct super_block *sb)
1686 DEFINE_WB_COMPLETION_ONSTACK(done);
1687 struct wb_writeback_work work = {
1689 .sync_mode = WB_SYNC_ALL,
1690 .nr_pages = LONG_MAX,
1693 .reason = WB_REASON_SYNC,
1696 struct backing_dev_info *bdi = sb->s_bdi;
1698 /* Nothing to do? */
1699 if (!bdi_has_dirty_io(bdi) || bdi == &noop_backing_dev_info)
1701 WARN_ON(!rwsem_is_locked(&sb->s_umount));
1703 wb_queue_work(&bdi->wb, &work);
1704 wb_wait_for_completion(bdi, &done);
1708 EXPORT_SYMBOL(sync_inodes_sb);
1711 * write_inode_now - write an inode to disk
1712 * @inode: inode to write to disk
1713 * @sync: whether the write should be synchronous or not
1715 * This function commits an inode to disk immediately if it is dirty. This is
1716 * primarily needed by knfsd.
1718 * The caller must either have a ref on the inode or must have set I_WILL_FREE.
1720 int write_inode_now(struct inode *inode, int sync)
1722 struct bdi_writeback *wb = &inode_to_bdi(inode)->wb;
1723 struct writeback_control wbc = {
1724 .nr_to_write = LONG_MAX,
1725 .sync_mode = sync ? WB_SYNC_ALL : WB_SYNC_NONE,
1727 .range_end = LLONG_MAX,
1730 if (!mapping_cap_writeback_dirty(inode->i_mapping))
1731 wbc.nr_to_write = 0;
1734 return writeback_single_inode(inode, wb, &wbc);
1736 EXPORT_SYMBOL(write_inode_now);
1739 * sync_inode - write an inode and its pages to disk.
1740 * @inode: the inode to sync
1741 * @wbc: controls the writeback mode
1743 * sync_inode() will write an inode and its pages to disk. It will also
1744 * correctly update the inode on its superblock's dirty inode lists and will
1745 * update inode->i_state.
1747 * The caller must have a ref on the inode.
1749 int sync_inode(struct inode *inode, struct writeback_control *wbc)
1751 return writeback_single_inode(inode, &inode_to_bdi(inode)->wb, wbc);
1753 EXPORT_SYMBOL(sync_inode);
1756 * sync_inode_metadata - write an inode to disk
1757 * @inode: the inode to sync
1758 * @wait: wait for I/O to complete.
1760 * Write an inode to disk and adjust its dirty state after completion.
1762 * Note: only writes the actual inode, no associated data or other metadata.
1764 int sync_inode_metadata(struct inode *inode, int wait)
1766 struct writeback_control wbc = {
1767 .sync_mode = wait ? WB_SYNC_ALL : WB_SYNC_NONE,
1768 .nr_to_write = 0, /* metadata-only */
1771 return sync_inode(inode, &wbc);
1773 EXPORT_SYMBOL(sync_inode_metadata);