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