fs: Turn block_invalidatepage into block_invalidate_folio

Remove special-casing of a NULL invalidatepage, since there is no
more block_invalidatepage.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Tested-by: Damien Le Moal <damien.lemoal@opensource.wdc.com>
Acked-by: Damien Le Moal <damien.lemoal@opensource.wdc.com>
Tested-by: Mike Marshall <hubcap@omnibond.com> # orangefs
Tested-by: David Howells <dhowells@redhat.com> # afs

diff --git a/block/fops.c b/block/fops.c
index 4f59e0f5bf30966214064260c9a4119773b2bff7..8ce1dccd15b931f469817d78818ca1ebd67c26a9 100644 (file)
--- a/block/fops.c
+++ b/block/fops.c
@@ -430,6 +430,7 @@ static int blkdev_writepages(struct address_space *mapping,
 
 const struct address_space_operations def_blk_aops = {
        .set_page_dirty = __set_page_dirty_buffers,
+       .invalidate_folio = block_invalidate_folio,
        .readpage       = blkdev_readpage,
        .readahead      = blkdev_readahead,
        .writepage      = blkdev_writepage,

diff --git a/fs/adfs/inode.c b/fs/adfs/inode.c
index 5156821bfe6a56d590409e388332fd7f928883e0..5c423254895ae51fbcc25fb9cda4c226e60eafbd 100644 (file)
--- a/fs/adfs/inode.c
+++ b/fs/adfs/inode.c
@@ -74,6 +74,7 @@ static sector_t _adfs_bmap(struct address_space *mapping, sector_t block)
 
 static const struct address_space_operations adfs_aops = {
        .set_page_dirty = __set_page_dirty_buffers,
+       .invalidate_folio = block_invalidate_folio,
        .readpage       = adfs_readpage,
        .writepage      = adfs_writepage,
        .write_begin    = adfs_write_begin,

diff --git a/fs/affs/file.c b/fs/affs/file.c
index 75ebd2b576ca4b9cf33e4d978c8cac3bba066bb5..6d4921f97162f1b797ba5765b50c2de970878aa5 100644 (file)
--- a/fs/affs/file.c
+++ b/fs/affs/file.c
@@ -454,6 +454,7 @@ static sector_t _affs_bmap(struct address_space *mapping, sector_t block)
 
 const struct address_space_operations affs_aops = {
        .set_page_dirty = __set_page_dirty_buffers,
+       .invalidate_folio = block_invalidate_folio,
        .readpage = affs_readpage,
        .writepage = affs_writepage,
        .write_begin = affs_write_begin,
@@ -835,6 +836,7 @@ err_bh:
 
 const struct address_space_operations affs_aops_ofs = {
        .set_page_dirty = __set_page_dirty_buffers,
+       .invalidate_folio = block_invalidate_folio,
        .readpage = affs_readpage_ofs,
        //.writepage = affs_writepage_ofs,
        .write_begin = affs_write_begin_ofs,

diff --git a/fs/bfs/file.c b/fs/bfs/file.c
index 7f8544abf636f4ba58fc4cab24d1bd2c221fd262..2e42b82edb58953322ab2f804c87debcd5b3bd69 100644 (file)
--- a/fs/bfs/file.c
+++ b/fs/bfs/file.c
@@ -189,6 +189,7 @@ static sector_t bfs_bmap(struct address_space *mapping, sector_t block)
 
 const struct address_space_operations bfs_aops = {
        .set_page_dirty = __set_page_dirty_buffers,
+       .invalidate_folio = block_invalidate_folio,
        .readpage       = bfs_readpage,
        .writepage      = bfs_writepage,
        .write_begin    = bfs_write_begin,

diff --git a/fs/buffer.c b/fs/buffer.c
index 929061995cf81039ed5a0775572a19f0662ff3ee..5fe02e5a9807944121e05ccedd053d6d3e03a1af 100644 (file)
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -1482,41 +1482,40 @@ static void discard_buffer(struct buffer_head * bh)
 }
 
 /**
- * block_invalidatepage - invalidate part or all of a buffer-backed page
- *
- * @page: the page which is affected
+ * block_invalidate_folio - Invalidate part or all of a buffer-backed folio.
+ * @folio: The folio which is affected.
  * @offset: start of the range to invalidate
  * @length: length of the range to invalidate
  *
- * block_invalidatepage() is called when all or part of the page has become
+ * block_invalidate_folio() is called when all or part of the folio has been
  * invalidated by a truncate operation.
  *
- * block_invalidatepage() does not have to release all buffers, but it must
+ * block_invalidate_folio() does not have to release all buffers, but it must
  * ensure that no dirty buffer is left outside @offset and that no I/O
  * is underway against any of the blocks which are outside the truncation
  * point.  Because the caller is about to free (and possibly reuse) those
  * blocks on-disk.
  */
-void block_invalidatepage(struct page *page, unsigned int offset,
-                         unsigned int length)
+void block_invalidate_folio(struct folio *folio, size_t offset, size_t length)
 {
        struct buffer_head *head, *bh, *next;
-       unsigned int curr_off = 0;
-       unsigned int stop = length + offset;
+       size_t curr_off = 0;
+       size_t stop = length + offset;
 
-       BUG_ON(!PageLocked(page));
-       if (!page_has_buffers(page))
-               goto out;
+       BUG_ON(!folio_test_locked(folio));
 
        /*
         * Check for overflow
         */
-       BUG_ON(stop > PAGE_SIZE || stop < length);
+       BUG_ON(stop > folio_size(folio) || stop < length);
+
+       head = folio_buffers(folio);
+       if (!head)
+               return;
 
-       head = page_buffers(page);
        bh = head;
        do {
-               unsigned int next_off = curr_off + bh->b_size;
+               size_t next_off = curr_off + bh->b_size;
                next = bh->b_this_page;
 
                /*
@@ -1535,16 +1534,16 @@ void block_invalidatepage(struct page *page, unsigned int offset,
        } while (bh != head);
 
        /*
-        * We release buffers only if the entire page is being invalidated.
+        * We release buffers only if the entire folio is being invalidated.
         * The get_block cached value has been unconditionally invalidated,
         * so real IO is not possible anymore.
         */
-       if (length == PAGE_SIZE)
-               try_to_release_page(page, 0);
+       if (length == folio_size(folio))
+               filemap_release_folio(folio, 0);
 out:
        return;
 }
-EXPORT_SYMBOL(block_invalidatepage);
+EXPORT_SYMBOL(block_invalidate_folio);
 
 
 /*

diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index 7d85e64ea62f3880311cd32b81ca96b596b89f5a..bf7f35b375b7969b5463676e43a814d6e7be5953 100644 (file)
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -546,6 +546,7 @@ const struct address_space_operations ecryptfs_aops = {
         */
 #ifdef CONFIG_BLOCK
        .set_page_dirty = __set_page_dirty_buffers,
+       .invalidate_folio = block_invalidate_folio,
 #endif
        .writepage = ecryptfs_writepage,
        .readpage = ecryptfs_readpage,

diff --git a/fs/exfat/inode.c b/fs/exfat/inode.c
index df805bd05508b841a94a3451a703ebd08ad7409e..5ed471eb973b48b609b48c2be47c7c10305a77de 100644 (file)
--- a/fs/exfat/inode.c
+++ b/fs/exfat/inode.c
@@ -491,6 +491,7 @@ int exfat_block_truncate_page(struct inode *inode, loff_t from)
 
 static const struct address_space_operations exfat_aops = {
        .set_page_dirty = __set_page_dirty_buffers,
+       .invalidate_folio = block_invalidate_folio,
        .readpage       = exfat_readpage,
        .readahead      = exfat_readahead,
        .writepage      = exfat_writepage,

diff --git a/fs/ext2/inode.c b/fs/ext2/inode.c
index 602578b72d8c5873d820375a3c3f7a08375efe6f..1e14777c3ca68c84d717cd98eddcb6c681c319b3 100644 (file)
--- a/fs/ext2/inode.c
+++ b/fs/ext2/inode.c
@@ -968,6 +968,7 @@ ext2_dax_writepages(struct address_space *mapping, struct writeback_control *wbc
 
 const struct address_space_operations ext2_aops = {
        .set_page_dirty         = __set_page_dirty_buffers,
+       .invalidate_folio = block_invalidate_folio,
        .readpage               = ext2_readpage,
        .readahead              = ext2_readahead,
        .writepage              = ext2_writepage,
@@ -983,6 +984,7 @@ const struct address_space_operations ext2_aops = {
 
 const struct address_space_operations ext2_nobh_aops = {
        .set_page_dirty         = __set_page_dirty_buffers,
+       .invalidate_folio = block_invalidate_folio,
        .readpage               = ext2_readpage,
        .readahead              = ext2_readahead,
        .writepage              = ext2_nobh_writepage,

diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 57800ecbe466bcdaac2547a3a49a5b65c991aec7..07ef3f84db9ea2b2f2d62ae431d563f806eabb88 100644 (file)
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -137,8 +137,6 @@ static inline int ext4_begin_ordered_truncate(struct inode *inode,
                                                   new_size);
 }
 
-static void ext4_invalidatepage(struct page *page, unsigned int offset,
-                               unsigned int length);
 static int __ext4_journalled_writepage(struct page *page, unsigned int len);
 static int ext4_meta_trans_blocks(struct inode *inode, int lblocks,
                                  int pextents);
@@ -1571,16 +1569,18 @@ static void mpage_release_unused_pages(struct mpage_da_data *mpd,
                        break;
                for (i = 0; i < nr_pages; i++) {
                        struct page *page = pvec.pages[i];
+                       struct folio *folio = page_folio(page);
 
-                       BUG_ON(!PageLocked(page));
-                       BUG_ON(PageWriteback(page));
+                       BUG_ON(!folio_test_locked(folio));
+                       BUG_ON(folio_test_writeback(folio));
                        if (invalidate) {
-                               if (page_mapped(page))
-                                       clear_page_dirty_for_io(page);
-                               block_invalidatepage(page, 0, PAGE_SIZE);
-                               ClearPageUptodate(page);
+                               if (folio_mapped(folio))
+                                       folio_clear_dirty_for_io(folio);
+                               block_invalidate_folio(folio, 0,
+                                               folio_size(folio));
+                               folio_clear_uptodate(folio);
                        }
-                       unlock_page(page);
+                       folio_unlock(folio);
                }
                pagevec_release(&pvec);
        }
@@ -3183,15 +3183,15 @@ static void ext4_readahead(struct readahead_control *rac)
        ext4_mpage_readpages(inode, rac, NULL);
 }
 
-static void ext4_invalidatepage(struct page *page, unsigned int offset,
-                               unsigned int length)
+static void ext4_invalidate_folio(struct folio *folio, size_t offset,
+                               size_t length)
 {
-       trace_ext4_invalidatepage(page, offset, length);
+       trace_ext4_invalidatepage(&folio->page, offset, length);
 
        /* No journalling happens on data buffers when this function is used */
-       WARN_ON(page_has_buffers(page) && buffer_jbd(page_buffers(page)));
+       WARN_ON(folio_buffers(folio) && buffer_jbd(folio_buffers(folio)));
 
-       block_invalidatepage(page, offset, length);
+       block_invalidate_folio(folio, offset, length);
 }
 
 static int __ext4_journalled_invalidatepage(struct page *page,
@@ -3583,7 +3583,7 @@ static const struct address_space_operations ext4_aops = {
        .write_end              = ext4_write_end,
        .set_page_dirty         = ext4_set_page_dirty,
        .bmap                   = ext4_bmap,
-       .invalidatepage         = ext4_invalidatepage,
+       .invalidate_folio       = ext4_invalidate_folio,
        .releasepage            = ext4_releasepage,
        .direct_IO              = noop_direct_IO,
        .migratepage            = buffer_migrate_page,
@@ -3618,7 +3618,7 @@ static const struct address_space_operations ext4_da_aops = {
        .write_end              = ext4_da_write_end,
        .set_page_dirty         = ext4_set_page_dirty,
        .bmap                   = ext4_bmap,
-       .invalidatepage         = ext4_invalidatepage,
+       .invalidate_folio       = ext4_invalidate_folio,
        .releasepage            = ext4_releasepage,
        .direct_IO              = noop_direct_IO,
        .migratepage            = buffer_migrate_page,

diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index a6f1c6d426d1ca89e8094978a3d9fc0e1aefa270..1e2f1e24a073cfd9c285e511ba2ce3524fa8ddf5 100644 (file)
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -343,6 +343,7 @@ int fat_block_truncate_page(struct inode *inode, loff_t from)
 
 static const struct address_space_operations fat_aops = {
        .set_page_dirty = __set_page_dirty_buffers,
+       .invalidate_folio = block_invalidate_folio,
        .readpage       = fat_readpage,
        .readahead      = fat_readahead,
        .writepage      = fat_writepage,

diff --git a/fs/gfs2/meta_io.c b/fs/gfs2/meta_io.c
index 72d30a682ececbb4a5fa19eaea0dd5430852c31d..d23c8b0354473b99515c41c9f8b879107c1b9af4 100644 (file)
--- a/fs/gfs2/meta_io.c
+++ b/fs/gfs2/meta_io.c
@@ -90,12 +90,14 @@ static int gfs2_aspace_writepage(struct page *page, struct writeback_control *wb
 
 const struct address_space_operations gfs2_meta_aops = {
        .set_page_dirty = __set_page_dirty_buffers,
+       .invalidate_folio = block_invalidate_folio,
        .writepage = gfs2_aspace_writepage,
        .releasepage = gfs2_releasepage,
 };
 
 const struct address_space_operations gfs2_rgrp_aops = {
        .set_page_dirty = __set_page_dirty_buffers,
+       .invalidate_folio = block_invalidate_folio,
        .writepage = gfs2_aspace_writepage,
        .releasepage = gfs2_releasepage,
 };

diff --git a/fs/hfs/inode.c b/fs/hfs/inode.c
index 2a51432462820dd879ebff7e5c23879575ed6a25..029d1869a22481bba9efde709a199995e1e0a9d6 100644 (file)
--- a/fs/hfs/inode.c
+++ b/fs/hfs/inode.c
@@ -160,6 +160,7 @@ static int hfs_writepages(struct address_space *mapping,
 
 const struct address_space_operations hfs_btree_aops = {
        .set_page_dirty = __set_page_dirty_buffers,
+       .invalidate_folio = block_invalidate_folio,
        .readpage       = hfs_readpage,
        .writepage      = hfs_writepage,
        .write_begin    = hfs_write_begin,
@@ -170,6 +171,7 @@ const struct address_space_operations hfs_btree_aops = {
 
 const struct address_space_operations hfs_aops = {
        .set_page_dirty = __set_page_dirty_buffers,
+       .invalidate_folio = block_invalidate_folio,
        .readpage       = hfs_readpage,
        .writepage      = hfs_writepage,
        .write_begin    = hfs_write_begin,

diff --git a/fs/hfsplus/inode.c b/fs/hfsplus/inode.c
index d08a8d1d40a4cb2701cdc9e3115fdebf854de06e..a91b9b5e92a85d8ba59684528e86c0e2335903ec 100644 (file)
--- a/fs/hfsplus/inode.c
+++ b/fs/hfsplus/inode.c
@@ -157,6 +157,7 @@ static int hfsplus_writepages(struct address_space *mapping,
 
 const struct address_space_operations hfsplus_btree_aops = {
        .set_page_dirty = __set_page_dirty_buffers,
+       .invalidate_folio = block_invalidate_folio,
        .readpage       = hfsplus_readpage,
        .writepage      = hfsplus_writepage,
        .write_begin    = hfsplus_write_begin,
@@ -167,6 +168,7 @@ const struct address_space_operations hfsplus_btree_aops = {
 
 const struct address_space_operations hfsplus_aops = {
        .set_page_dirty = __set_page_dirty_buffers,
+       .invalidate_folio = block_invalidate_folio,
        .readpage       = hfsplus_readpage,
        .writepage      = hfsplus_writepage,
        .write_begin    = hfsplus_write_begin,

diff --git a/fs/hpfs/file.c b/fs/hpfs/file.c
index fb37f57130aa6b099eb17c3fa03b4c61a49d99c2..cf68f5e76dddac26a34f167d4f0bd1d5d0b599a4 100644 (file)
--- a/fs/hpfs/file.c
+++ b/fs/hpfs/file.c
@@ -246,6 +246,7 @@ static int hpfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
 
 const struct address_space_operations hpfs_aops = {
        .set_page_dirty = __set_page_dirty_buffers,
+       .invalidate_folio = block_invalidate_folio,
        .readpage = hpfs_readpage,
        .writepage = hpfs_writepage,
        .readahead = hpfs_readahead,

diff --git a/fs/jfs/inode.c b/fs/jfs/inode.c
index 57ab424c05ff02a198328ecdd62da906b03fc02e..3950b3d610a0376f42415af3dc73c229a684f892 100644 (file)
--- a/fs/jfs/inode.c
+++ b/fs/jfs/inode.c
@@ -358,6 +358,7 @@ static ssize_t jfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
 
 const struct address_space_operations jfs_aops = {
        .set_page_dirty = __set_page_dirty_buffers,
+       .invalidate_folio = block_invalidate_folio,
        .readpage       = jfs_readpage,
        .readahead      = jfs_readahead,
        .writepage      = jfs_writepage,

diff --git a/fs/minix/inode.c b/fs/minix/inode.c
index a71f1cf894b9f1218f8c739dda034f100ed20c99..2295804d1893b3157589d930890a9107648afd87 100644 (file)
--- a/fs/minix/inode.c
+++ b/fs/minix/inode.c
@@ -443,6 +443,7 @@ static sector_t minix_bmap(struct address_space *mapping, sector_t block)
 
 static const struct address_space_operations minix_aops = {
        .set_page_dirty = __set_page_dirty_buffers,
+       .invalidate_folio = block_invalidate_folio,
        .readpage = minix_readpage,
        .writepage = minix_writepage,
        .write_begin = minix_write_begin,

diff --git a/fs/nilfs2/inode.c b/fs/nilfs2/inode.c
index e3d807d5b83ad08d308b81a99c7efa04723ca819..153f0569dcf2953ea0601dce03ac3aef7be11f03 100644 (file)
--- a/fs/nilfs2/inode.c
+++ b/fs/nilfs2/inode.c
@@ -304,7 +304,7 @@ const struct address_space_operations nilfs_aops = {
        .write_begin            = nilfs_write_begin,
        .write_end              = nilfs_write_end,
        /* .releasepage         = nilfs_releasepage, */
-       .invalidatepage         = block_invalidatepage,
+       .invalidate_folio       = block_invalidate_folio,
        .direct_IO              = nilfs_direct_IO,
        .is_partially_uptodate  = block_is_partially_uptodate,
 };

diff --git a/fs/nilfs2/mdt.c b/fs/nilfs2/mdt.c
index 4b3d33cf0041fb4b7ec5f8aeac3d93c7987a6d22..72adca629bc9ca3f821f15985eb10cc2915c16f2 100644 (file)
--- a/fs/nilfs2/mdt.c
+++ b/fs/nilfs2/mdt.c
@@ -435,6 +435,7 @@ nilfs_mdt_write_page(struct page *page, struct writeback_control *wbc)
 
 static const struct address_space_operations def_mdt_aops = {
        .set_page_dirty         = __set_page_dirty_buffers,
+       .invalidate_folio = block_invalidate_folio,
        .writepage              = nilfs_mdt_write_page,
 };
 

diff --git a/fs/ntfs/aops.c b/fs/ntfs/aops.c
index bb0a43860ad26dd351901c80f81fbc31f4f23634..6858bf6df49a6abe468f03bf73f3107dc14327c2 100644 (file)
--- a/fs/ntfs/aops.c
+++ b/fs/ntfs/aops.c
@@ -1350,12 +1350,13 @@ retry_writepage:
        /* Is the page fully outside i_size? (truncate in progress) */
        if (unlikely(page->index >= (i_size + PAGE_SIZE - 1) >>
                        PAGE_SHIFT)) {
+               struct folio *folio = page_folio(page);
                /*
                 * The page may have dirty, unmapped buffers.  Make them
                 * freeable here, so the page does not leak.
                 */
-               block_invalidatepage(page, 0, PAGE_SIZE);
-               unlock_page(page);
+               block_invalidate_folio(folio, 0, folio_size(folio));
+               folio_unlock(folio);
                ntfs_debug("Write outside i_size - truncated?");
                return 0;
        }

diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index 498da317580a75e2e6bbb03e2f66f1a930d44216..b274061e22a7b83e974429e01aa198d0a1d75797 100644 (file)
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -2461,7 +2461,7 @@ const struct address_space_operations ocfs2_aops = {
        .write_end              = ocfs2_write_end,
        .bmap                   = ocfs2_bmap,
        .direct_IO              = ocfs2_direct_IO,
-       .invalidatepage         = block_invalidatepage,
+       .invalidate_folio       = block_invalidate_folio,
        .releasepage            = ocfs2_releasepage,
        .migratepage            = buffer_migrate_page,
        .is_partially_uptodate  = block_is_partially_uptodate,

diff --git a/fs/omfs/file.c b/fs/omfs/file.c
index 89725b15a64b4c709238d8078430ccaf944ae6d4..139d6a21dca155bf97ee974b80dbb22d98c77e91 100644 (file)
--- a/fs/omfs/file.c
+++ b/fs/omfs/file.c
@@ -373,6 +373,7 @@ const struct inode_operations omfs_file_inops = {
 
 const struct address_space_operations omfs_aops = {
        .set_page_dirty = __set_page_dirty_buffers,
+       .invalidate_folio = block_invalidate_folio,
        .readpage = omfs_readpage,
        .readahead = omfs_readahead,
        .writepage = omfs_writepage,

diff --git a/fs/sysv/itree.c b/fs/sysv/itree.c
index 749385015a8d3f1e8d1d8b47010330f7e7b009c0..d39984a1d4d3ce3ca5db1775fdfd4cd70d5e3773 100644 (file)
--- a/fs/sysv/itree.c
+++ b/fs/sysv/itree.c
@@ -496,6 +496,7 @@ static sector_t sysv_bmap(struct address_space *mapping, sector_t block)
 
 const struct address_space_operations sysv_aops = {
        .set_page_dirty = __set_page_dirty_buffers,
+       .invalidate_folio = block_invalidate_folio,
        .readpage = sysv_readpage,
        .writepage = sysv_writepage,
        .write_begin = sysv_write_begin,

diff --git a/fs/udf/file.c b/fs/udf/file.c
index 1baff8ddb754497ef41757d2fa75d9385137e34a..a91011a7bb88cd1be7d829085ffce81365d45fdb 100644 (file)
--- a/fs/udf/file.c
+++ b/fs/udf/file.c
@@ -126,6 +126,7 @@ static int udf_adinicb_write_end(struct file *file, struct address_space *mappin
 
 const struct address_space_operations udf_adinicb_aops = {
        .set_page_dirty = __set_page_dirty_buffers,
+       .invalidate_folio = block_invalidate_folio,
        .readpage       = udf_adinicb_readpage,
        .writepage      = udf_adinicb_writepage,
        .write_begin    = udf_adinicb_write_begin,

diff --git a/fs/udf/inode.c b/fs/udf/inode.c
index ea8f6cd01f501696cd276e58b8229af677283796..ab98c7aaf9f9415a97c56d6ed080f7d18f8c86ea 100644 (file)
--- a/fs/udf/inode.c
+++ b/fs/udf/inode.c
@@ -236,6 +236,7 @@ static sector_t udf_bmap(struct address_space *mapping, sector_t block)
 
 const struct address_space_operations udf_aops = {
        .set_page_dirty = __set_page_dirty_buffers,
+       .invalidate_folio = block_invalidate_folio,
        .readpage       = udf_readpage,
        .readahead      = udf_readahead,
        .writepage      = udf_writepage,

diff --git a/fs/ufs/inode.c b/fs/ufs/inode.c
index ac628de69601d932b0e4211646cad01fdc47cd9a..2d005788c24d553a3de0e07283f466805c192328 100644 (file)
--- a/fs/ufs/inode.c
+++ b/fs/ufs/inode.c
@@ -527,6 +527,7 @@ static sector_t ufs_bmap(struct address_space *mapping, sector_t block)
 
 const struct address_space_operations ufs_aops = {
        .set_page_dirty = __set_page_dirty_buffers,
+       .invalidate_folio = block_invalidate_folio,
        .readpage = ufs_readpage,
        .writepage = ufs_writepage,
        .write_begin = ufs_write_begin,

diff --git a/include/linux/buffer_head.h b/include/linux/buffer_head.h
index 79d4650578898b3f288133e87a815785bfaede68..9ee9d003d73625d4e7ebb08c13060a4c5752aef9 100644 (file)
--- a/include/linux/buffer_head.h
+++ b/include/linux/buffer_head.h
@@ -217,8 +217,7 @@ extern int buffer_heads_over_limit;
  * Generic address_space_operations implementations for buffer_head-backed
  * address_spaces.
  */
-void block_invalidatepage(struct page *page, unsigned int offset,
-                         unsigned int length);
+void block_invalidate_folio(struct folio *folio, size_t offset, size_t length);
 int block_write_full_page(struct page *page, get_block_t *get_block,
                                struct writeback_control *wbc);
 int __block_write_full_page(struct inode *inode, struct page *page,

diff --git a/mm/truncate.c b/mm/truncate.c
index b9ad298e6ce7bd6c5a7e55f850a281c3da9d49d7..28650151091a87b063752242c10bd8ce7290aa89 100644 (file)
--- a/mm/truncate.c
+++ b/mm/truncate.c
@@ -163,10 +163,6 @@ void folio_invalidate(struct folio *folio, size_t offset, size_t length)
        }
 
        invalidatepage = aops->invalidatepage;
-#ifdef CONFIG_BLOCK
-       if (!invalidatepage)
-               invalidatepage = block_invalidatepage;
-#endif
        if (invalidatepage)
                (*invalidatepage)(&folio->page, offset, length);
 }