Merge patch series "filemap_* writeback interface cleanups v2"

+4 -13

fs/9p/vfs_file.c

··· 483 483 484 484 static void v9fs_mmap_vm_close(struct vm_area_struct *vma) 485 485 { 486 - struct inode *inode; 487 - 488 - struct writeback_control wbc = { 489 - .nr_to_write = LONG_MAX, 490 - .sync_mode = WB_SYNC_ALL, 491 - .range_start = (loff_t)vma->vm_pgoff * PAGE_SIZE, 492 - /* absolute end, byte at end included */ 493 - .range_end = (loff_t)vma->vm_pgoff * PAGE_SIZE + 494 - (vma->vm_end - vma->vm_start - 1), 495 - }; 496 - 497 486 if (!(vma->vm_flags & VM_SHARED)) 498 487 return; 499 488 500 489 p9_debug(P9_DEBUG_VFS, "9p VMA close, %p, flushing", vma); 501 490 502 - inode = file_inode(vma->vm_file); 503 - filemap_fdatawrite_wbc(inode->i_mapping, &wbc); 491 + filemap_fdatawrite_range(file_inode(vma->vm_file)->i_mapping, 492 + (loff_t)vma->vm_pgoff * PAGE_SIZE, 493 + (loff_t)vma->vm_pgoff * PAGE_SIZE + 494 + (vma->vm_end - vma->vm_start - 1)); 504 495 } 505 496 506 497 static const struct vm_operations_struct v9fs_mmap_file_vm_ops = {

+14 -32

fs/btrfs/inode.c

··· 8709 8709 * some fairly slow code that needs optimization. This walks the list 8710 8710 * of all the inodes with pending delalloc and forces them to disk. 8711 8711 */ 8712 - static int start_delalloc_inodes(struct btrfs_root *root, 8713 - struct writeback_control *wbc, bool snapshot, 8714 - bool in_reclaim_context) 8712 + static int start_delalloc_inodes(struct btrfs_root *root, long *nr_to_write, 8713 + bool snapshot, bool in_reclaim_context) 8715 8714 { 8716 8715 struct btrfs_delalloc_work *work, *next; 8717 8716 LIST_HEAD(works); 8718 8717 LIST_HEAD(splice); 8719 8718 int ret = 0; 8720 - bool full_flush = wbc->nr_to_write == LONG_MAX; 8721 8719 8722 8720 mutex_lock(&root->delalloc_mutex); 8723 8721 spin_lock(&root->delalloc_lock); ··· 8741 8743 8742 8744 if (snapshot) 8743 8745 set_bit(BTRFS_INODE_SNAPSHOT_FLUSH, &inode->runtime_flags); 8744 - if (full_flush) { 8745 - work = btrfs_alloc_delalloc_work(&inode->vfs_inode); 8746 + if (nr_to_write == NULL) { 8747 + work = btrfs_alloc_delalloc_work(tmp_inode); 8746 8748 if (!work) { 8747 - iput(&inode->vfs_inode); 8749 + iput(tmp_inode); 8748 8750 ret = -ENOMEM; 8749 8751 goto out; 8750 8752 } ··· 8752 8754 btrfs_queue_work(root->fs_info->flush_workers, 8753 8755 &work->work); 8754 8756 } else { 8755 - ret = filemap_fdatawrite_wbc(inode->vfs_inode.i_mapping, wbc); 8757 + ret = filemap_flush_nr(tmp_inode->i_mapping, 8758 + nr_to_write); 8756 8759 btrfs_add_delayed_iput(inode); 8757 - if (ret || wbc->nr_to_write <= 0) 8760 + 8761 + if (ret || *nr_to_write <= 0) 8758 8762 goto out; 8759 8763 } 8760 8764 cond_resched(); ··· 8782 8782 8783 8783 int btrfs_start_delalloc_snapshot(struct btrfs_root *root, bool in_reclaim_context) 8784 8784 { 8785 - struct writeback_control wbc = { 8786 - .nr_to_write = LONG_MAX, 8787 - .sync_mode = WB_SYNC_NONE, 8788 - .range_start = 0, 8789 - .range_end = LLONG_MAX, 8790 - }; 8791 8785 struct btrfs_fs_info *fs_info = root->fs_info; 8792 8786 8793 8787 if (BTRFS_FS_ERROR(fs_info)) 8794 8788 return -EROFS; 8795 - 8796 - return start_delalloc_inodes(root, &wbc, true, in_reclaim_context); 8789 + return start_delalloc_inodes(root, NULL, true, in_reclaim_context); 8797 8790 } 8798 8791 8799 8792 int btrfs_start_delalloc_roots(struct btrfs_fs_info *fs_info, long nr, 8800 8793 bool in_reclaim_context) 8801 8794 { 8802 - struct writeback_control wbc = { 8803 - .nr_to_write = nr, 8804 - .sync_mode = WB_SYNC_NONE, 8805 - .range_start = 0, 8806 - .range_end = LLONG_MAX, 8807 - }; 8795 + long *nr_to_write = nr == LONG_MAX ? NULL : &nr; 8808 8796 struct btrfs_root *root; 8809 8797 LIST_HEAD(splice); 8810 8798 int ret; ··· 8804 8816 spin_lock(&fs_info->delalloc_root_lock); 8805 8817 list_splice_init(&fs_info->delalloc_roots, &splice); 8806 8818 while (!list_empty(&splice)) { 8807 - /* 8808 - * Reset nr_to_write here so we know that we're doing a full 8809 - * flush. 8810 - */ 8811 - if (nr == LONG_MAX) 8812 - wbc.nr_to_write = LONG_MAX; 8813 - 8814 8819 root = list_first_entry(&splice, struct btrfs_root, 8815 8820 delalloc_root); 8816 8821 root = btrfs_grab_root(root); ··· 8812 8831 &fs_info->delalloc_roots); 8813 8832 spin_unlock(&fs_info->delalloc_root_lock); 8814 8833 8815 - ret = start_delalloc_inodes(root, &wbc, false, in_reclaim_context); 8834 + ret = start_delalloc_inodes(root, nr_to_write, false, 8835 + in_reclaim_context); 8816 8836 btrfs_put_root(root); 8817 - if (ret < 0 || wbc.nr_to_write <= 0) 8837 + if (ret < 0 || nr <= 0) 8818 8838 goto out; 8819 8839 spin_lock(&fs_info->delalloc_root_lock); 8820 8840 }

+3 -3

fs/fs-writeback.c

··· 822 822 * @wbc: writeback_control of interest 823 823 * @inode: target inode 824 824 * 825 - * This function is to be used by __filemap_fdatawrite_range(), which is an 826 - * alternative entry point into writeback code, and first ensures @inode is 827 - * associated with a bdi_writeback and attaches it to @wbc. 825 + * This function is to be used by filemap_writeback(), which is an alternative 826 + * entry point into writeback code, and first ensures @inode is associated with 827 + * a bdi_writeback and attaches it to @wbc. 828 828 */ 829 829 void wbc_attach_fdatawrite_inode(struct writeback_control *wbc, 830 830 struct inode *inode)

+2 -9

fs/ocfs2/journal.c

··· 902 902 903 903 static int ocfs2_journal_submit_inode_data_buffers(struct jbd2_inode *jinode) 904 904 { 905 - struct address_space *mapping = jinode->i_vfs_inode->i_mapping; 906 - struct writeback_control wbc = { 907 - .sync_mode = WB_SYNC_ALL, 908 - .nr_to_write = mapping->nrpages * 2, 909 - .range_start = jinode->i_dirty_start, 910 - .range_end = jinode->i_dirty_end, 911 - }; 912 - 913 - return filemap_fdatawrite_wbc(mapping, &wbc); 905 + return filemap_fdatawrite_range(jinode->i_vfs_inode->i_mapping, 906 + jinode->i_dirty_start, jinode->i_dirty_end); 914 907 } 915 908 916 909 int ocfs2_journal_init(struct ocfs2_super *osb, int *dirty)

+4 -6

fs/sync.c

··· 280 280 } 281 281 282 282 if (flags & SYNC_FILE_RANGE_WRITE) { 283 - int sync_mode = WB_SYNC_NONE; 284 - 285 283 if ((flags & SYNC_FILE_RANGE_WRITE_AND_WAIT) == 286 284 SYNC_FILE_RANGE_WRITE_AND_WAIT) 287 - sync_mode = WB_SYNC_ALL; 288 - 289 - ret = __filemap_fdatawrite_range(mapping, offset, endbyte, 290 - sync_mode); 285 + ret = filemap_fdatawrite_range(mapping, offset, 286 + endbyte); 287 + else 288 + ret = filemap_flush_range(mapping, offset, endbyte); 291 289 if (ret < 0) 292 290 goto out; 293 291 }

+3 -3

include/linux/fs.h

··· 3014 3014 extern int __must_check file_check_and_advance_wb_err(struct file *file); 3015 3015 extern int __must_check file_write_and_wait_range(struct file *file, 3016 3016 loff_t start, loff_t end); 3017 - int filemap_fdatawrite_range_kick(struct address_space *mapping, loff_t start, 3017 + int filemap_flush_range(struct address_space *mapping, loff_t start, 3018 3018 loff_t end); 3019 3019 3020 3020 static inline int file_write_and_wait(struct file *file) ··· 3051 3051 } else if (iocb->ki_flags & IOCB_DONTCACHE) { 3052 3052 struct address_space *mapping = iocb->ki_filp->f_mapping; 3053 3053 3054 - filemap_fdatawrite_range_kick(mapping, iocb->ki_pos - count, 3055 - iocb->ki_pos - 1); 3054 + filemap_flush_range(mapping, iocb->ki_pos - count, 3055 + iocb->ki_pos - 1); 3056 3056 } 3057 3057 3058 3058 return count;

+1 -4

include/linux/pagemap.h

··· 38 38 int write_inode_now(struct inode *, int sync); 39 39 int filemap_fdatawrite(struct address_space *); 40 40 int filemap_flush(struct address_space *); 41 + int filemap_flush_nr(struct address_space *mapping, long *nr_to_write); 41 42 int filemap_fdatawait_keep_errors(struct address_space *mapping); 42 43 int filemap_fdatawait_range(struct address_space *, loff_t lstart, loff_t lend); 43 44 int filemap_fdatawait_range_keep_errors(struct address_space *mapping, ··· 54 53 bool filemap_range_has_page(struct address_space *, loff_t lstart, loff_t lend); 55 54 int filemap_write_and_wait_range(struct address_space *mapping, 56 55 loff_t lstart, loff_t lend); 57 - int __filemap_fdatawrite_range(struct address_space *mapping, 58 - loff_t start, loff_t end, int sync_mode); 59 56 int filemap_fdatawrite_range(struct address_space *mapping, 60 57 loff_t start, loff_t end); 61 58 int filemap_check_errors(struct address_space *mapping); 62 59 void __filemap_set_wb_err(struct address_space *mapping, int err); 63 - int filemap_fdatawrite_wbc(struct address_space *mapping, 64 - struct writeback_control *wbc); 65 60 int kiocb_write_and_wait(struct kiocb *iocb, size_t count); 66 61 67 62 static inline int filemap_write_and_wait(struct address_space *mapping)

+1 -2

mm/fadvise.c

··· 111 111 spin_unlock(&file->f_lock); 112 112 break; 113 113 case POSIX_FADV_DONTNEED: 114 - __filemap_fdatawrite_range(mapping, offset, endbyte, 115 - WB_SYNC_NONE); 114 + filemap_flush_range(mapping, offset, endbyte); 116 115 117 116 /* 118 117 * First and last FULL page! Partial pages are deliberately

+47 -68

mm/filemap.c

··· 366 366 return 0; 367 367 } 368 368 369 - /** 370 - * filemap_fdatawrite_wbc - start writeback on mapping dirty pages in range 371 - * @mapping: address space structure to write 372 - * @wbc: the writeback_control controlling the writeout 373 - * 374 - * Call writepages on the mapping using the provided wbc to control the 375 - * writeout. 376 - * 377 - * Return: %0 on success, negative error code otherwise. 378 - */ 379 - int filemap_fdatawrite_wbc(struct address_space *mapping, 380 - struct writeback_control *wbc) 369 + static int filemap_writeback(struct address_space *mapping, loff_t start, 370 + loff_t end, enum writeback_sync_modes sync_mode, 371 + long *nr_to_write) 381 372 { 373 + struct writeback_control wbc = { 374 + .sync_mode = sync_mode, 375 + .nr_to_write = nr_to_write ? *nr_to_write : LONG_MAX, 376 + .range_start = start, 377 + .range_end = end, 378 + }; 382 379 int ret; 383 380 384 381 if (!mapping_can_writeback(mapping) || 385 382 !mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) 386 383 return 0; 387 384 388 - wbc_attach_fdatawrite_inode(wbc, mapping->host); 389 - ret = do_writepages(mapping, wbc); 390 - wbc_detach_inode(wbc); 385 + wbc_attach_fdatawrite_inode(&wbc, mapping->host); 386 + ret = do_writepages(mapping, &wbc); 387 + wbc_detach_inode(&wbc); 388 + 389 + if (!ret && nr_to_write) 390 + *nr_to_write = wbc.nr_to_write; 391 391 return ret; 392 392 } 393 - EXPORT_SYMBOL(filemap_fdatawrite_wbc); 394 393 395 394 /** 396 - * __filemap_fdatawrite_range - start writeback on mapping dirty pages in range 395 + * filemap_fdatawrite_range - start writeback on mapping dirty pages in range 397 396 * @mapping: address space structure to write 398 397 * @start: offset in bytes where the range starts 399 398 * @end: offset in bytes where the range ends (inclusive) 400 - * @sync_mode: enable synchronous operation 401 399 * 402 400 * Start writeback against all of a mapping's dirty pages that lie 403 401 * within the byte offsets <start, end> inclusive. 404 402 * 405 - * If sync_mode is WB_SYNC_ALL then this is a "data integrity" operation, as 406 - * opposed to a regular memory cleansing writeback. The difference between 407 - * these two operations is that if a dirty page/buffer is encountered, it must 408 - * be waited upon, and not just skipped over. 403 + * This is a data integrity operation that waits upon dirty or in writeback 404 + * pages. 409 405 * 410 406 * Return: %0 on success, negative error code otherwise. 411 407 */ 412 - int __filemap_fdatawrite_range(struct address_space *mapping, loff_t start, 413 - loff_t end, int sync_mode) 414 - { 415 - struct writeback_control wbc = { 416 - .sync_mode = sync_mode, 417 - .nr_to_write = LONG_MAX, 418 - .range_start = start, 419 - .range_end = end, 420 - }; 421 - 422 - return filemap_fdatawrite_wbc(mapping, &wbc); 423 - } 424 - 425 - static inline int __filemap_fdatawrite(struct address_space *mapping, 426 - int sync_mode) 427 - { 428 - return __filemap_fdatawrite_range(mapping, 0, LLONG_MAX, sync_mode); 429 - } 430 - 431 - int filemap_fdatawrite(struct address_space *mapping) 432 - { 433 - return __filemap_fdatawrite(mapping, WB_SYNC_ALL); 434 - } 435 - EXPORT_SYMBOL(filemap_fdatawrite); 436 - 437 408 int filemap_fdatawrite_range(struct address_space *mapping, loff_t start, 438 - loff_t end) 409 + loff_t end) 439 410 { 440 - return __filemap_fdatawrite_range(mapping, start, end, WB_SYNC_ALL); 411 + return filemap_writeback(mapping, start, end, WB_SYNC_ALL, NULL); 441 412 } 442 413 EXPORT_SYMBOL(filemap_fdatawrite_range); 443 414 415 + int filemap_fdatawrite(struct address_space *mapping) 416 + { 417 + return filemap_fdatawrite_range(mapping, 0, LLONG_MAX); 418 + } 419 + EXPORT_SYMBOL(filemap_fdatawrite); 420 + 444 421 /** 445 - * filemap_fdatawrite_range_kick - start writeback on a range 422 + * filemap_flush_range - start writeback on a range 446 423 * @mapping: target address_space 447 424 * @start: index to start writeback on 448 425 * @end: last (inclusive) index for writeback ··· 429 452 * 430 453 * Return: %0 on success, negative error code otherwise. 431 454 */ 432 - int filemap_fdatawrite_range_kick(struct address_space *mapping, loff_t start, 455 + int filemap_flush_range(struct address_space *mapping, loff_t start, 433 456 loff_t end) 434 457 { 435 - return __filemap_fdatawrite_range(mapping, start, end, WB_SYNC_NONE); 458 + return filemap_writeback(mapping, start, end, WB_SYNC_NONE, NULL); 436 459 } 437 - EXPORT_SYMBOL_GPL(filemap_fdatawrite_range_kick); 460 + EXPORT_SYMBOL_GPL(filemap_flush_range); 438 461 439 462 /** 440 463 * filemap_flush - mostly a non-blocking flush ··· 447 470 */ 448 471 int filemap_flush(struct address_space *mapping) 449 472 { 450 - return __filemap_fdatawrite(mapping, WB_SYNC_NONE); 473 + return filemap_flush_range(mapping, 0, LLONG_MAX); 451 474 } 452 475 EXPORT_SYMBOL(filemap_flush); 476 + 477 + /* 478 + * Start writeback on @nr_to_write pages from @mapping. No one but the existing 479 + * btrfs caller should be using this. Talk to linux-mm if you think adding a 480 + * new caller is a good idea. 481 + */ 482 + int filemap_flush_nr(struct address_space *mapping, long *nr_to_write) 483 + { 484 + return filemap_writeback(mapping, 0, LLONG_MAX, WB_SYNC_NONE, 485 + nr_to_write); 486 + } 487 + EXPORT_SYMBOL_FOR_MODULES(filemap_flush_nr, "btrfs"); 453 488 454 489 /** 455 490 * filemap_range_has_page - check if a page exists in range. ··· 680 691 return 0; 681 692 682 693 if (mapping_needs_writeback(mapping)) { 683 - err = __filemap_fdatawrite_range(mapping, lstart, lend, 684 - WB_SYNC_ALL); 694 + err = filemap_fdatawrite_range(mapping, lstart, lend); 685 695 /* 686 696 * Even if the above returned error, the pages may be 687 697 * written partially (e.g. -ENOSPC), so we wait for it. ··· 782 794 return 0; 783 795 784 796 if (mapping_needs_writeback(mapping)) { 785 - err = __filemap_fdatawrite_range(mapping, lstart, lend, 786 - WB_SYNC_ALL); 797 + err = filemap_fdatawrite_range(mapping, lstart, lend); 787 798 /* See comment of filemap_write_and_wait() */ 788 799 if (err != -EIO) 789 800 __filemap_fdatawait_range(mapping, lstart, lend); ··· 4444 4457 unmap_mapping_pages(mapping, first, nr, false); 4445 4458 4446 4459 /* Write back the data if we're asked to. */ 4447 - if (flush) { 4448 - struct writeback_control wbc = { 4449 - .sync_mode = WB_SYNC_ALL, 4450 - .nr_to_write = LONG_MAX, 4451 - .range_start = start, 4452 - .range_end = end, 4453 - }; 4454 - 4455 - filemap_fdatawrite_wbc(mapping, &wbc); 4456 - } 4460 + if (flush) 4461 + filemap_fdatawrite_range(mapping, start, end); 4457 4462 4458 4463 /* Wait for writeback to complete on all folios and discard. */ 4459 4464 invalidate_inode_pages2_range(mapping, start / PAGE_SIZE, end / PAGE_SIZE);

Configure Feed

Configure Feed