From: Linus Torvalds Date: Wed, 23 Mar 2022 01:26:56 +0000 (-0700) Subject: Merge tag 'folio-5.18b' of git://git.infradead.org/users/willy/pagecache X-Git-Url: http://git.maquefel.me/?a=commitdiff_plain;h=6b1f86f8e9c7f9de7ca1cb987b2cf25e99b1ae3a;p=linux.git Merge tag 'folio-5.18b' of git://git.infradead.org/users/willy/pagecache Pull filesystem folio updates from Matthew Wilcox: "Primarily this series converts some of the address_space operations to take a folio instead of a page. Notably: - a_ops->is_partially_uptodate() takes a folio instead of a page and changes the type of the 'from' and 'count' arguments to make it obvious they're bytes. - a_ops->invalidatepage() becomes ->invalidate_folio() and has a similar type change. - a_ops->launder_page() becomes ->launder_folio() - a_ops->set_page_dirty() becomes ->dirty_folio() and adds the address_space as an argument. There are a couple of other misc changes up front that weren't worth separating into their own pull request" * tag 'folio-5.18b' of git://git.infradead.org/users/willy/pagecache: (53 commits) fs: Remove aops ->set_page_dirty fb_defio: Use noop_dirty_folio() fs: Convert __set_page_dirty_no_writeback to noop_dirty_folio fs: Convert __set_page_dirty_buffers to block_dirty_folio nilfs: Convert nilfs_set_page_dirty() to nilfs_dirty_folio() mm: Convert swap_set_page_dirty() to swap_dirty_folio() ubifs: Convert ubifs_set_page_dirty to ubifs_dirty_folio f2fs: Convert f2fs_set_node_page_dirty to f2fs_dirty_node_folio f2fs: Convert f2fs_set_data_page_dirty to f2fs_dirty_data_folio f2fs: Convert f2fs_set_meta_page_dirty to f2fs_dirty_meta_folio afs: Convert afs_dir_set_page_dirty() to afs_dir_dirty_folio() btrfs: Convert extent_range_redirty_for_io() to use folios fs: Convert trivial uses of __set_page_dirty_nobuffers to filemap_dirty_folio btrfs: Convert from set_page_dirty to dirty_folio fscache: Convert fscache_set_page_dirty() to fscache_dirty_folio() fs: Add aops->dirty_folio fs: Remove aops->launder_page orangefs: Convert launder_page to launder_folio nfs: Convert from launder_page to launder_folio fuse: Convert from launder_page to launder_folio ... --- 6b1f86f8e9c7f9de7ca1cb987b2cf25e99b1ae3a diff --cc fs/erofs/super.c index cafeb288fd6a3,a64c422f6763f..0c4b41130c2fd --- a/fs/erofs/super.c +++ b/fs/erofs/super.c @@@ -532,24 -535,18 +532,23 @@@ static int erofs_managed_cache_releasep return ret; } +/* + * It will be called only on inode eviction. In case that there are still some + * decompression requests in progress, wait with rescheduling for a bit here. + * We could introduce an extra locking instead but it seems unnecessary. + */ - static void erofs_managed_cache_invalidatepage(struct page *page, - unsigned int offset, - unsigned int length) + static void erofs_managed_cache_invalidate_folio(struct folio *folio, + size_t offset, size_t length) { - const unsigned int stop = length + offset; + const size_t stop = length + offset; - DBG_BUGON(!PageLocked(page)); + DBG_BUGON(!folio_test_locked(folio)); /* Check for potential overflow in debug mode */ - DBG_BUGON(stop > PAGE_SIZE || stop < length); + DBG_BUGON(stop > folio_size(folio) || stop < length); - if (offset == 0 && stop == PAGE_SIZE) - while (!erofs_managed_cache_releasepage(page, GFP_NOFS)) + if (offset == 0 && stop == folio_size(folio)) + while (!erofs_managed_cache_releasepage(&folio->page, GFP_NOFS)) cond_resched(); } diff --cc fs/ext4/inode.c index 3d0ca48d20c89,436efd31cc274..1ce13f69fbecb --- a/fs/ext4/inode.c +++ b/fs/ext4/inode.c @@@ -3573,31 -3541,30 +3573,32 @@@ const struct iomap_ops ext4_iomap_repor }; /* - * Whenever the page is being dirtied, corresponding buffers should already be - * attached to the transaction (we take care of this in ext4_page_mkwrite() and - * ext4_write_begin()). However we cannot move buffers to dirty transaction - * lists here because ->set_page_dirty is called under VFS locks and the page - * Folios can be marked dirty completely asynchronously from ext4's - * journalling activity. By filemap_sync_pte(), try_to_unmap_one(), etc. - * We cannot do much here because ->dirty_folio may be called with the - * page table lock held. The folio is not necessarily locked. ++ * Whenever the folio is being dirtied, corresponding buffers should already ++ * be attached to the transaction (we take care of this in ext4_page_mkwrite() ++ * and ext4_write_begin()). However we cannot move buffers to dirty transaction ++ * lists here because ->dirty_folio is called under VFS locks and the folio + * is not necessarily locked. * - * We cannot just dirty the page and leave attached buffers clean, because the + * We cannot just dirty the folio and leave attached buffers clean, because the * buffers' dirty state is "definitive". We cannot just set the buffers dirty * or jbddirty because all the journalling code will explode. * - * So what we do is to mark the page "pending dirty" and next time writepage + * So what we do is to mark the folio "pending dirty" and next time writepage * is called, propagate that into the buffers appropriately. */ - static int ext4_journalled_set_page_dirty(struct page *page) + static bool ext4_journalled_dirty_folio(struct address_space *mapping, + struct folio *folio) { - WARN_ON_ONCE(!page_has_buffers(page)); - SetPageChecked(page); - return __set_page_dirty_nobuffers(page); ++ WARN_ON_ONCE(!page_has_buffers(&folio->page)); + folio_set_checked(folio); + return filemap_dirty_folio(mapping, folio); } - static int ext4_set_page_dirty(struct page *page) + static bool ext4_dirty_folio(struct address_space *mapping, struct folio *folio) { - WARN_ON_ONCE(!PageLocked(page) && !PageDirty(page)); - WARN_ON_ONCE(!page_has_buffers(page)); - return __set_page_dirty_buffers(page); + WARN_ON_ONCE(!folio_test_locked(folio) && !folio_test_dirty(folio)); + WARN_ON_ONCE(!folio_buffers(folio)); + return block_dirty_folio(mapping, folio); } static int ext4_iomap_swap_activate(struct swap_info_struct *sis,