[PATCH 03/12] swap,fs: move swapfile operations to struct file_operations

[Christoph Hellwig <hch@lst.de>]

The swap operations have nothing to do with the address_space, which is
used for pagecache operations.  Move them to struct file_operations
instead.  This will allow moving the block device special cases into
block/fops.c subsequently.

Pass struct file first to ->swap_activate as file operations typically
get the file or iocb as first argument and use swap_activate instead of
swapfile_activate in all names to be consistent.

Note that while the trivial iomap wrappers are moved to a new file when
applicable to keep them local to the file operation instances, complex
implementation are kept in their existing place.  It might be worth to
move them in follow-on patches if the maintainers desire so.

Signed-off-by: Christoph Hellwig <hch@lst.de>
---
 .../filesystems/iomap/operations.rst          |  3 +-
 Documentation/filesystems/locking.rst         | 35 +++++++-------
 Documentation/filesystems/vfs.rst             | 40 ++++++++--------
 fs/btrfs/btrfs_inode.h                        |  3 ++
 fs/btrfs/file.c                               |  4 ++
 fs/btrfs/inode.c                              | 15 +-----
 fs/ext4/file.c                                |  6 +++
 fs/ext4/inode.c                               | 10 ----
 fs/f2fs/data.c                                | 15 +-----
 fs/f2fs/f2fs.h                                |  2 +
 fs/f2fs/file.c                                |  4 ++
 fs/iomap/swapfile.c                           | 12 ++---
 fs/nfs/direct.c                               |  1 +
 fs/nfs/file.c                                 | 12 +++--
 fs/nfs/nfs4file.c                             |  3 ++
 fs/ntfs/aops.c                                |  7 ---
 fs/ntfs/file.c                                |  6 +++
 fs/smb/client/cifsfs.c                        | 18 ++++++++
 fs/smb/client/cifsfs.h                        |  3 ++
 fs/smb/client/file.c                          | 12 ++---
 fs/xfs/xfs_aops.c                             | 46 -------------------
 fs/xfs/xfs_file.c                             | 45 ++++++++++++++++++
 fs/zonefs/file.c                              | 29 ++++++------
 include/linux/fs.h                            | 10 ++--
 include/linux/iomap.h                         |  6 +--
 include/linux/nfs_fs.h                        |  3 ++
 include/linux/swap.h                          |  2 +-
 mm/page_io.c                                  |  9 ++--
 mm/swapfile.c                                 | 12 ++---
 29 files changed, 187 insertions(+), 186 deletions(-)

diff --git a/Documentation/filesystems/iomap/operations.rst b/Documentation/filesystems/iomap/operations.rst
index da982ca7e413..2a78037665b7 100644
--- a/Documentation/filesystems/iomap/operations.rst
+++ b/Documentation/filesystems/iomap/operations.rst
@@ -55,7 +55,6 @@ The following address space operations can be wrapped easily:
  * ``readahead``
  * ``writepages``
  * ``bmap``
- * ``swap_activate``
 
 ``struct iomap_write_ops``
 --------------------------
@@ -747,7 +746,7 @@ function.
 Swap File Activation
 ====================
 
-The ``iomap_swapfile_activate`` function finds all the base-page aligned
+The ``iomap_swap_activate`` function finds all the base-page aligned
 regions in a file and sets them up as swap space.
 The file will be ``fsync()``'d before activation.
 ``IOMAP_REPORT`` will be passed as the ``flags`` argument to
diff --git a/Documentation/filesystems/locking.rst b/Documentation/filesystems/locking.rst
index f3658204d070..e79d72a12273 100644
--- a/Documentation/filesystems/locking.rst
+++ b/Documentation/filesystems/locking.rst
@@ -264,9 +264,6 @@ prototypes::
 	int (*launder_folio)(struct folio *);
 	bool (*is_partially_uptodate)(struct folio *, size_t from, size_t count);
 	int (*error_remove_folio)(struct address_space *, struct folio *);
-	int (*swap_activate)(struct swap_info_struct *sis, struct file *f)
-	int (*swap_deactivate)(struct file *);
-	int (*swap_rw)(struct kiocb *iocb, struct iov_iter *iter);
 
 locking rules:
 	All except dirty_folio and free_folio may block
@@ -289,9 +286,6 @@ migrate_folio:		yes (both)
 launder_folio:		yes
 is_partially_uptodate:	yes
 error_remove_folio:	yes
-swap_activate:		no
-swap_deactivate:	no
-swap_rw:		yes, unlocks
 ======================	======================== =========	===============
 
 ->write_begin(), ->write_end() and ->read_folio() may be called from
@@ -350,19 +344,6 @@ cleaned, or an error value if not. Note that in order to prevent the folio
 getting mapped back in and redirtied, it needs to be kept locked
 across the entire operation.
 
-->swap_activate() will be called to prepare the given file for swap.  It
-should perform any validation and preparation necessary to ensure that
-writes can be performed with minimal memory allocation.  It should call
-add_swap_extent(), or the helper iomap_swapfile_activate(), and return
-the number of extents added.  If IO should be submitted through
-->swap_rw(), it should set SWP_FS_OPS, otherwise IO will be submitted
-directly to the block device ``sis->bdev``.
-
-->swap_deactivate() will be called in the sys_swapoff()
-path after ->swap_activate() returned success.
-
-->swap_rw will be called for swap IO if SWP_FS_OPS was set by ->swap_activate().
-
 file_lock_operations
 ====================
 
@@ -503,6 +484,9 @@ prototypes::
 			struct file *file_out, loff_t pos_out,
 			loff_t len, unsigned int remap_flags);
 	int (*fadvise)(struct file *, loff_t, loff_t, int);
+	int (*swap_activate)(struct file *file, struct swap_info_struct *sis);
+	int (*swap_deactivate)(struct file *);
+	int (*swap_rw)(struct kiocb *iocb, struct iov_iter *iter);
 
 locking rules:
 	All may block.
@@ -555,6 +539,19 @@ used. To block changes to file contents via a memory mapping during the
 operation, the filesystem must take mapping->invalidate_lock to coordinate
 with ->page_mkwrite.
 
+->swap_activate() is called to prepare the given file for swap.  It should
+perform any validation and preparation necessary to ensure that writes can be
+performed with minimal memory allocation.  It should call add_swap_extent(),
+or the helper iomap_swap_activate(), and return the number of extents added.
+If IO should be submitted through ->swap_rw(), the file system must set
+SWP_FS_OPS from ->swap_activate(), otherwise IO will be submitted directly to
+the block device ``sis->bdev``.
+
+->swap_deactivate() is called from the swapoff path to disable a swapfile
+successfully activated using ->swap_activate().
+
+->swap_rw will be called for swap IO if SWP_FS_OPS was set by ->swap_activate().
+
 dquot_operations
 ================
 
diff --git a/Documentation/filesystems/vfs.rst b/Documentation/filesystems/vfs.rst
index 4092b2149a5d..1624c1ee82d6 100644
--- a/Documentation/filesystems/vfs.rst
+++ b/Documentation/filesystems/vfs.rst
@@ -774,9 +774,6 @@ cache in your filesystem.  The following members are defined:
 					       size_t count);
 		void (*is_dirty_writeback)(struct folio *, bool *, bool *);
 		int (*error_remove_folio)(struct mapping *mapping, struct folio *);
-		int (*swap_activate)(struct swap_info_struct *sis, struct file *f);
-		int (*swap_deactivate)(struct file *);
-		int (*swap_rw)(struct kiocb *iocb, struct iov_iter *iter);
 	};
 
 ``read_folio``
@@ -970,23 +967,6 @@ cache in your filesystem.  The following members are defined:
 	Setting this implies you deal with pages going away under you,
 	unless you have them locked or reference counts increased.
 
-``swap_activate``
-
-	Called to prepare the given file for swap.  It should perform
-	any validation and preparation necessary to ensure that writes
-	can be performed with minimal memory allocation.  It should call
-	add_swap_extent(), or the helper iomap_swapfile_activate(), and
-	return the number of extents added.  If IO should be submitted
-	through ->swap_rw(), it should set SWP_FS_OPS, otherwise IO will
-	be submitted directly to the block device ``sis->bdev``.
-
-``swap_deactivate``
-	Called during swapoff on files where swap_activate was
-	successful.
-
-``swap_rw``
-	Called to read or write swap pages when SWP_FS_OPS is set.
-
 The File Object
 ===============
 
@@ -1046,6 +1026,9 @@ This describes how the VFS can manipulate an open file.  As of kernel
 		int (*uring_cmd_iopoll)(struct io_uring_cmd *, struct io_comp_batch *,
 					unsigned int poll_flags);
 		int (*mmap_prepare)(struct vm_area_desc *);
+		int (*swap_activate)(struct file *file, struct swap_info_struct *sis);
+		int (*swap_deactivate)(struct file *);
+		int (*swap_rw)(struct kiocb *iocb, struct iov_iter *iter);
 	};
 
 Again, all methods are called without any locks being held, unless
@@ -1175,6 +1158,23 @@ otherwise noted.
 	this can be specified by the vm_area_desc->action field and related
 	parameters.
 
+``swap_activate``
+
+	Called to prepare the given file for swap.  It should perform
+	any validation and preparation necessary to ensure that writes
+	can be performed with minimal memory allocation.  It should call
+	add_swap_extent(), or the helper iomap_swap_activate(), and
+	return the number of extents added.  If IO should be submitted
+	through ->swap_rw(), it should set SWP_FS_OPS, otherwise IO will
+	be submitted directly to the block device ``sis->bdev``.
+
+``swap_deactivate``
+	Called during swapoff on files where swap_activate was
+	successful.
+
+``swap_rw``
+	Called to read or write swap pages when SWP_FS_OPS is set.
+
 Note that the file operations are implemented by the specific
 filesystem in which the inode resides.  When opening a device node
 (character or block special) most filesystems will call special
diff --git a/fs/btrfs/btrfs_inode.h b/fs/btrfs/btrfs_inode.h
index 55c272fe5d92..f527126882d6 100644
--- a/fs/btrfs/btrfs_inode.h
+++ b/fs/btrfs/btrfs_inode.h
@@ -670,4 +670,7 @@ struct extent_map *btrfs_create_io_em(struct btrfs_inode *inode, u64 start,
 				      const struct btrfs_file_extent *file_extent,
 				      int type);
 
+int btrfs_swap_activate(struct file *file, struct swap_info_struct *sis);
+void btrfs_swap_deactivate(struct file *file);
+
 #endif
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index cf1cb5c4db75..165b8da1d7db 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -3867,6 +3867,10 @@ const struct file_operations btrfs_file_operations = {
 	.uring_cmd	= btrfs_uring_cmd,
 	.fop_flags	= FOP_BUFFER_RASYNC | FOP_BUFFER_WASYNC,
 	.setlease	= generic_setlease,
+#ifdef CONFIG_SWAP
+	.swap_activate	= btrfs_swap_activate,
+	.swap_deactivate = btrfs_swap_deactivate,
+#endif
 };
 
 int btrfs_fdatawrite_range(struct btrfs_inode *inode, loff_t start, loff_t end)
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 198d87e6f19a..ee0a7947706a 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -10217,7 +10217,7 @@ static int btrfs_add_swap_extent(struct swap_info_struct *sis,
 	return add_swap_extent(sis, next_ppage - first_ppage, first_ppage);
 }
 
-static void btrfs_swap_deactivate(struct file *file)
+void btrfs_swap_deactivate(struct file *file)
 {
 	struct inode *inode = file_inode(file);
 
@@ -10225,7 +10225,7 @@ static void btrfs_swap_deactivate(struct file *file)
 	atomic_dec(&BTRFS_I(inode)->root->nr_swapfiles);
 }
 
-static int btrfs_swap_activate(struct swap_info_struct *sis, struct file *file)
+int btrfs_swap_activate(struct file *file, struct swap_info_struct *sis)
 {
 	struct inode *inode = file_inode(file);
 	struct btrfs_root *root = BTRFS_I(inode)->root;
@@ -10537,15 +10537,6 @@ static int btrfs_swap_activate(struct swap_info_struct *sis, struct file *file)
 		sis->bdev = device->bdev;
 	return ret;
 }
-#else
-static void btrfs_swap_deactivate(struct file *file)
-{
-}
-
-static int btrfs_swap_activate(struct swap_info_struct *sis, struct file *file)
-{
-	return -EOPNOTSUPP;
-}
 #endif
 
 /*
@@ -10692,8 +10683,6 @@ static const struct address_space_operations btrfs_aops = {
 	.migrate_folio	= btrfs_migrate_folio,
 	.dirty_folio	= filemap_dirty_folio,
 	.error_remove_folio = generic_error_remove_folio,
-	.swap_activate	= btrfs_swap_activate,
-	.swap_deactivate = btrfs_swap_deactivate,
 };
 
 static const struct inode_operations btrfs_file_inode_operations = {
diff --git a/fs/ext4/file.c b/fs/ext4/file.c
index eb1a323962b1..fad3ed05c02a 100644
--- a/fs/ext4/file.c
+++ b/fs/ext4/file.c
@@ -971,6 +971,11 @@ loff_t ext4_llseek(struct file *file, loff_t offset, int whence)
 	return vfs_setpos(file, offset, maxbytes);
 }
 
+static int ext4_swap_activate(struct file *file, struct swap_info_struct *sis)
+{
+	return iomap_swap_activate(file, sis, &ext4_iomap_report_ops);
+}
+
 const struct file_operations ext4_file_operations = {
 	.llseek		= ext4_llseek,
 	.read_iter	= ext4_file_read_iter,
@@ -992,6 +997,7 @@ const struct file_operations ext4_file_operations = {
 			  FOP_DIO_PARALLEL_WRITE |
 			  FOP_DONTCACHE,
 	.setlease	= generic_setlease,
+	.swap_activate	= ext4_swap_activate,
 };
 
 const struct inode_operations ext4_file_inode_operations = {
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index ca7bac4a8b4a..efbb2ddad363 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -3939,12 +3939,6 @@ static bool ext4_dirty_folio(struct address_space *mapping, struct folio *folio)
 	return block_dirty_folio(mapping, folio);
 }
 
-static int ext4_iomap_swap_activate(struct swap_info_struct *sis,
-				    struct file *file)
-{
-	return iomap_swapfile_activate(sis, file, &ext4_iomap_report_ops);
-}
-
 static const struct address_space_operations ext4_aops = {
 	.read_folio		= ext4_read_folio,
 	.readahead		= ext4_readahead,
@@ -3958,7 +3952,6 @@ static const struct address_space_operations ext4_aops = {
 	.migrate_folio		= buffer_migrate_folio,
 	.is_partially_uptodate  = block_is_partially_uptodate,
 	.error_remove_folio	= generic_error_remove_folio,
-	.swap_activate		= ext4_iomap_swap_activate,
 };
 
 static const struct address_space_operations ext4_journalled_aops = {
@@ -3974,7 +3967,6 @@ static const struct address_space_operations ext4_journalled_aops = {
 	.migrate_folio		= buffer_migrate_folio_norefs,
 	.is_partially_uptodate  = block_is_partially_uptodate,
 	.error_remove_folio	= generic_error_remove_folio,
-	.swap_activate		= ext4_iomap_swap_activate,
 };
 
 static const struct address_space_operations ext4_da_aops = {
@@ -3990,14 +3982,12 @@ static const struct address_space_operations ext4_da_aops = {
 	.migrate_folio		= buffer_migrate_folio,
 	.is_partially_uptodate  = block_is_partially_uptodate,
 	.error_remove_folio	= generic_error_remove_folio,
-	.swap_activate		= ext4_iomap_swap_activate,
 };
 
 static const struct address_space_operations ext4_dax_aops = {
 	.writepages		= ext4_dax_writepages,
 	.dirty_folio		= noop_dirty_folio,
 	.bmap			= ext4_bmap,
-	.swap_activate		= ext4_iomap_swap_activate,
 };
 
 void ext4_set_aops(struct inode *inode)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 86fabacc67e6..8bcf630df557 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -4338,7 +4338,7 @@ static int check_swap_activate(struct swap_info_struct *sis,
 	return ret;
 }
 
-static int f2fs_swap_activate(struct swap_info_struct *sis, struct file *file)
+int f2fs_swap_activate(struct file *file, struct swap_info_struct *sis)
 {
 	struct inode *inode = file_inode(file);
 	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
@@ -4378,22 +4378,13 @@ static int f2fs_swap_activate(struct swap_info_struct *sis, struct file *file)
 	return 0;
 }
 
-static void f2fs_swap_deactivate(struct file *file)
+void f2fs_swap_deactivate(struct file *file)
 {
 	struct inode *inode = file_inode(file);
 
 	stat_dec_swapfile_inode(inode);
 	clear_inode_flag(inode, FI_PIN_FILE);
 }
-#else
-static int f2fs_swap_activate(struct swap_info_struct *sis, struct file *file)
-{
-	return -EOPNOTSUPP;
-}
-
-static void f2fs_swap_deactivate(struct file *file)
-{
-}
 #endif
 
 const struct address_space_operations f2fs_dblock_aops = {
@@ -4407,8 +4398,6 @@ const struct address_space_operations f2fs_dblock_aops = {
 	.invalidate_folio = f2fs_invalidate_folio,
 	.release_folio	= f2fs_release_folio,
 	.bmap		= f2fs_bmap,
-	.swap_activate  = f2fs_swap_activate,
-	.swap_deactivate = f2fs_swap_deactivate,
 };
 
 void f2fs_clear_page_cache_dirty_tag(struct folio *folio)
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 91f506e7c9cf..93e9709f26fa 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -4195,6 +4195,8 @@ int f2fs_init_post_read_processing(void);
 void f2fs_destroy_post_read_processing(void);
 int f2fs_init_post_read_wq(struct f2fs_sb_info *sbi);
 void f2fs_destroy_post_read_wq(struct f2fs_sb_info *sbi);
+int f2fs_swap_activate(struct file *file, struct swap_info_struct *sis);
+void f2fs_swap_deactivate(struct file *file);
 extern const struct iomap_ops f2fs_iomap_ops;
 
 /*
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index fb12c5c9affd..aa91d5fff1cf 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -5488,4 +5488,8 @@ const struct file_operations f2fs_file_operations = {
 	.fadvise	= f2fs_file_fadvise,
 	.fop_flags	= FOP_BUFFER_RASYNC,
 	.setlease	= generic_setlease,
+#ifdef CONFIG_SWAP
+	.swap_activate  = f2fs_swap_activate,
+	.swap_deactivate = f2fs_swap_deactivate,
+#endif
 };
diff --git a/fs/iomap/swapfile.c b/fs/iomap/swapfile.c
index f778b2c6c922..cf354fdfb7c3 100644
--- a/fs/iomap/swapfile.c
+++ b/fs/iomap/swapfile.c
@@ -100,10 +100,10 @@ static int iomap_swapfile_iter(struct iomap_iter *iter,
  * Iterate a swap file's iomaps to construct physical extents that can be
  * passed to the swapfile subsystem.
  */
-int iomap_swapfile_activate(struct swap_info_struct *sis,
-		struct file *swap_file, const struct iomap_ops *ops)
+int iomap_swap_activate(struct file *file, struct swap_info_struct *sis,
+		const struct iomap_ops *ops)
 {
-	struct inode *inode = swap_file->f_mapping->host;
+	struct inode *inode = file->f_mapping->host;
 	struct iomap_iter iter = {
 		.inode	= inode,
 		.pos	= 0,
@@ -112,7 +112,7 @@ int iomap_swapfile_activate(struct swap_info_struct *sis,
 	};
 	struct iomap_swapfile_info isi = {
 		.sis = sis,
-		.file = swap_file,
+		.file = file,
 	};
 	int ret;
 
@@ -120,7 +120,7 @@ int iomap_swapfile_activate(struct swap_info_struct *sis,
 	 * Persist all file mapping metadata so that we won't have any
 	 * IOMAP_F_DIRTY iomaps.
 	 */
-	ret = vfs_fsync(swap_file, 1);
+	ret = vfs_fsync(file, 1);
 	if (ret)
 		return ret;
 
@@ -137,4 +137,4 @@ int iomap_swapfile_activate(struct swap_info_struct *sis,
 
 	return 0;
 }
-EXPORT_SYMBOL_GPL(iomap_swapfile_activate);
+EXPORT_SYMBOL_GPL(iomap_swap_activate);
diff --git a/fs/nfs/direct.c b/fs/nfs/direct.c
index 48d89716193a..e92a4c8f8f77 100644
--- a/fs/nfs/direct.c
+++ b/fs/nfs/direct.c
@@ -164,6 +164,7 @@ int nfs_swap_rw(struct kiocb *iocb, struct iov_iter *iter)
 		return ret;
 	return 0;
 }
+EXPORT_SYMBOL_GPL(nfs_swap_rw);
 
 static void nfs_direct_release_pages(struct page **pages, unsigned int npages)
 {
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index 74b401aa2b3a..2bc55d9d71e1 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -567,7 +567,7 @@ static int nfs_launder_folio(struct folio *folio)
 	return ret;
 }
 
-static int nfs_swap_activate(struct swap_info_struct *sis, struct file *file)
+int nfs_swap_activate(struct file *file, struct swap_info_struct *sis)
 {
 	unsigned long blocks;
 	long long isize;
@@ -600,8 +600,9 @@ static int nfs_swap_activate(struct swap_info_struct *sis, struct file *file)
 	sis->flags |= SWP_FS_OPS;
 	return 0;
 }
+EXPORT_SYMBOL_GPL(nfs_swap_activate);
 
-static void nfs_swap_deactivate(struct file *file)
+void nfs_swap_deactivate(struct file *file)
 {
 	struct inode *inode = file_inode(file);
 	struct rpc_clnt *clnt = NFS_CLIENT(inode);
@@ -611,6 +612,7 @@ static void nfs_swap_deactivate(struct file *file)
 	if (cl->rpc_ops->disable_swap)
 		cl->rpc_ops->disable_swap(file_inode(file));
 }
+EXPORT_SYMBOL_GPL(nfs_swap_deactivate);
 
 const struct address_space_operations nfs_file_aops = {
 	.read_folio = nfs_read_folio,
@@ -625,9 +627,6 @@ const struct address_space_operations nfs_file_aops = {
 	.launder_folio = nfs_launder_folio,
 	.is_dirty_writeback = nfs_check_dirty_writeback,
 	.error_remove_folio = generic_error_remove_folio,
-	.swap_activate = nfs_swap_activate,
-	.swap_deactivate = nfs_swap_deactivate,
-	.swap_rw = nfs_swap_rw,
 };
 
 /*
@@ -960,6 +959,9 @@ const struct file_operations nfs_file_operations = {
 	.splice_read	= nfs_file_splice_read,
 	.splice_write	= iter_file_splice_write,
 	.check_flags	= nfs_check_flags,
+	.swap_activate	= nfs_swap_activate,
+	.swap_deactivate = nfs_swap_deactivate,
+	.swap_rw	= nfs_swap_rw,
 	.fop_flags	= FOP_DONTCACHE,
 };
 EXPORT_SYMBOL_GPL(nfs_file_operations);
diff --git a/fs/nfs/nfs4file.c b/fs/nfs/nfs4file.c
index be40e126c539..eb1a8dbab55a 100644
--- a/fs/nfs/nfs4file.c
+++ b/fs/nfs/nfs4file.c
@@ -455,5 +455,8 @@ const struct file_operations nfs4_file_operations = {
 #else
 	.llseek		= nfs_file_llseek,
 #endif
+	.swap_activate	= nfs_swap_activate,
+	.swap_deactivate = nfs_swap_deactivate,
+	.swap_rw	= nfs_swap_rw,
 	.fop_flags	= FOP_DONTCACHE,
 };
diff --git a/fs/ntfs/aops.c b/fs/ntfs/aops.c
index 4b7d019bc6ed..a94f5f675790 100644
--- a/fs/ntfs/aops.c
+++ b/fs/ntfs/aops.c
@@ -270,12 +270,6 @@ static int ntfs_writepages(struct address_space *mapping,
 	return iomap_writepages(&wpc);
 }
 
-static int ntfs_swap_activate(struct swap_info_struct *sis,
-		struct file *swap_file)
-{
-	return iomap_swapfile_activate(sis, swap_file, &ntfs_read_iomap_ops);
-}
-
 const struct address_space_operations ntfs_aops = {
 	.read_folio		= ntfs_read_folio,
 	.readahead		= ntfs_readahead,
@@ -287,7 +281,6 @@ const struct address_space_operations ntfs_aops = {
 	.error_remove_folio	= generic_error_remove_folio,
 	.release_folio		= iomap_release_folio,
 	.invalidate_folio	= iomap_invalidate_folio,
-	.swap_activate          = ntfs_swap_activate,
 };
 
 const struct address_space_operations ntfs_mft_aops = {
diff --git a/fs/ntfs/file.c b/fs/ntfs/file.c
index e8bea22b81a7..0dcf8479362a 100644
--- a/fs/ntfs/file.c
+++ b/fs/ntfs/file.c
@@ -1114,6 +1114,11 @@ static long ntfs_fallocate(struct file *file, int mode, loff_t offset, loff_t le
 	return err;
 }
 
+static int ntfs_swap_activate(struct file *file, struct swap_info_struct *sis)
+{
+	return iomap_swap_activate(file, sis, &ntfs_read_iomap_ops);
+}
+
 const struct file_operations ntfs_file_ops = {
 	.llseek		= ntfs_file_llseek,
 	.read_iter	= ntfs_file_read_iter,
@@ -1130,6 +1135,7 @@ const struct file_operations ntfs_file_ops = {
 #endif
 	.fallocate	= ntfs_fallocate,
 	.setlease	= generic_setlease,
+	.swap_activate	= ntfs_swap_activate,
 };
 
 const struct inode_operations ntfs_file_inode_ops = {
diff --git a/fs/smb/client/cifsfs.c b/fs/smb/client/cifsfs.c
index 9f76b0347fa9..f0d8a3a46074 100644
--- a/fs/smb/client/cifsfs.c
+++ b/fs/smb/client/cifsfs.c
@@ -1577,6 +1577,9 @@ const struct file_operations cifs_file_ops = {
 	.remap_file_range = cifs_remap_file_range,
 	.setlease = cifs_setlease,
 	.fallocate = cifs_fallocate,
+	.swap_activate	= cifs_swap_activate,
+	.swap_deactivate = cifs_swap_deactivate,
+	.swap_rw = cifs_swap_rw,
 };
 
 const struct file_operations cifs_file_strict_ops = {
@@ -1597,6 +1600,9 @@ const struct file_operations cifs_file_strict_ops = {
 	.remap_file_range = cifs_remap_file_range,
 	.setlease = cifs_setlease,
 	.fallocate = cifs_fallocate,
+	.swap_activate	= cifs_swap_activate,
+	.swap_deactivate = cifs_swap_deactivate,
+	.swap_rw = cifs_swap_rw,
 };
 
 const struct file_operations cifs_file_direct_ops = {
@@ -1617,6 +1623,9 @@ const struct file_operations cifs_file_direct_ops = {
 	.llseek = cifs_llseek,
 	.setlease = cifs_setlease,
 	.fallocate = cifs_fallocate,
+	.swap_activate	= cifs_swap_activate,
+	.swap_deactivate = cifs_swap_deactivate,
+	.swap_rw = cifs_swap_rw,
 };
 
 const struct file_operations cifs_file_nobrl_ops = {
@@ -1635,6 +1644,9 @@ const struct file_operations cifs_file_nobrl_ops = {
 	.remap_file_range = cifs_remap_file_range,
 	.setlease = cifs_setlease,
 	.fallocate = cifs_fallocate,
+	.swap_activate	= cifs_swap_activate,
+	.swap_deactivate = cifs_swap_deactivate,
+	.swap_rw = cifs_swap_rw,
 };
 
 const struct file_operations cifs_file_strict_nobrl_ops = {
@@ -1653,6 +1665,9 @@ const struct file_operations cifs_file_strict_nobrl_ops = {
 	.remap_file_range = cifs_remap_file_range,
 	.setlease = cifs_setlease,
 	.fallocate = cifs_fallocate,
+	.swap_activate	= cifs_swap_activate,
+	.swap_deactivate = cifs_swap_deactivate,
+	.swap_rw = cifs_swap_rw,
 };
 
 const struct file_operations cifs_file_direct_nobrl_ops = {
@@ -1671,6 +1686,9 @@ const struct file_operations cifs_file_direct_nobrl_ops = {
 	.llseek = cifs_llseek,
 	.setlease = cifs_setlease,
 	.fallocate = cifs_fallocate,
+	.swap_activate	= cifs_swap_activate,
+	.swap_deactivate = cifs_swap_deactivate,
+	.swap_rw = cifs_swap_rw,
 };
 
 const struct file_operations cifs_dir_ops = {
diff --git a/fs/smb/client/cifsfs.h b/fs/smb/client/cifsfs.h
index c455b15f2778..1e5b9fce84f9 100644
--- a/fs/smb/client/cifsfs.h
+++ b/fs/smb/client/cifsfs.h
@@ -115,6 +115,9 @@ int cifs_file_mmap_prepare(struct vm_area_desc *desc);
 int cifs_file_strict_mmap_prepare(struct vm_area_desc *desc);
 extern const struct file_operations cifs_dir_ops;
 int cifs_readdir(struct file *file, struct dir_context *ctx);
+int cifs_swap_activate(struct file *swap_file, struct swap_info_struct *sis);
+void cifs_swap_deactivate(struct file *file);
+int cifs_swap_rw(struct kiocb *iocb, struct iov_iter *iter);
 
 /* Functions related to dir entries */
 extern const struct dentry_operations cifs_dentry_ops;
diff --git a/fs/smb/client/file.c b/fs/smb/client/file.c
index 11d4655ef490..84459f87907e 100644
--- a/fs/smb/client/file.c
+++ b/fs/smb/client/file.c
@@ -3286,8 +3286,7 @@ void cifs_oplock_break(struct work_struct *work)
 	cifs_done_oplock_break(cinode);
 }
 
-static int cifs_swap_activate(struct swap_info_struct *sis,
-			      struct file *swap_file)
+int cifs_swap_activate(struct file *swap_file, struct swap_info_struct *sis)
 {
 	struct cifsFileInfo *cfile = swap_file->private_data;
 	struct inode *inode = swap_file->f_mapping->host;
@@ -3296,7 +3295,7 @@ static int cifs_swap_activate(struct swap_info_struct *sis,
 
 	cifs_dbg(FYI, "swap activate\n");
 
-	if (!swap_file->f_mapping->a_ops->swap_rw)
+	if (!swap_file->f_op->swap_rw)
 		/* Cannot support swap */
 		return -EINVAL;
 
@@ -3331,7 +3330,7 @@ static int cifs_swap_activate(struct swap_info_struct *sis,
 	return add_swap_extent(sis, sis->max, 0);
 }
 
-static void cifs_swap_deactivate(struct file *file)
+void cifs_swap_deactivate(struct file *file)
 {
 	struct cifsFileInfo *cfile = file->private_data;
 
@@ -3352,7 +3351,7 @@ static void cifs_swap_deactivate(struct file *file)
  *
  * Perform IO to the swap-file.  This is much like direct IO.
  */
-static int cifs_swap_rw(struct kiocb *iocb, struct iov_iter *iter)
+int cifs_swap_rw(struct kiocb *iocb, struct iov_iter *iter)
 {
 	ssize_t ret;
 
@@ -3378,9 +3377,6 @@ const struct address_space_operations cifs_addr_ops = {
 	 * TODO: investigate and if useful we could add an is_dirty_writeback
 	 * helper if needed
 	 */
-	.swap_activate	= cifs_swap_activate,
-	.swap_deactivate = cifs_swap_deactivate,
-	.swap_rw = cifs_swap_rw,
 };
 
 /*
diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index 1e8662e0e7cd..7488fc6a7b78 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -796,50 +796,6 @@ xfs_vm_readahead(
 	iomap_readahead(&xfs_read_iomap_ops, &ctx, NULL);
 }
 
-static int
-xfs_vm_swap_activate(
-	struct swap_info_struct		*sis,
-	struct file			*swap_file)
-{
-	struct xfs_inode		*ip = XFS_I(file_inode(swap_file));
-
-	if (xfs_is_zoned_inode(ip))
-		return -EINVAL;
-
-	/*
-	 * Swap file activation can race against concurrent shared extent
-	 * removal in files that have been cloned.  If this happens,
-	 * iomap_swapfile_iter() can fail because it encountered a shared
-	 * extent even though an operation is in progress to remove those
-	 * shared extents.
-	 *
-	 * This race becomes problematic when we defer extent removal
-	 * operations beyond the end of a syscall (i.e. use async background
-	 * processing algorithms).  Users think the extents are no longer
-	 * shared, but iomap_swapfile_iter() still sees them as shared
-	 * because the refcountbt entries for the extents being removed have
-	 * not yet been updated.  Hence the swapon call fails unexpectedly.
-	 *
-	 * The race condition is currently most obvious from the unlink()
-	 * operation as extent removal is deferred until after the last
-	 * reference to the inode goes away.  We then process the extent
-	 * removal asynchronously, hence triggers the "syscall completed but
-	 * work not done" condition mentioned above.  To close this race
-	 * window, we need to flush any pending inodegc operations to ensure
-	 * they have updated the refcountbt records before we try to map the
-	 * swapfile.
-	 */
-	xfs_inodegc_flush(ip->i_mount);
-
-	/*
-	 * Direct the swap code to the correct block device when this file
-	 * sits on the RT device.
-	 */
-	sis->bdev = xfs_inode_buftarg(ip)->bt_bdev;
-
-	return iomap_swapfile_activate(sis, swap_file, &xfs_read_iomap_ops);
-}
-
 const struct address_space_operations xfs_address_space_operations = {
 	.read_folio		= xfs_vm_read_folio,
 	.readahead		= xfs_vm_readahead,
@@ -851,11 +807,9 @@ const struct address_space_operations xfs_address_space_operations = {
 	.migrate_folio		= filemap_migrate_folio,
 	.is_partially_uptodate  = iomap_is_partially_uptodate,
 	.error_remove_folio	= generic_error_remove_folio,
-	.swap_activate		= xfs_vm_swap_activate,
 };
 
 const struct address_space_operations xfs_dax_aops = {
 	.writepages		= xfs_dax_writepages,
 	.dirty_folio		= noop_dirty_folio,
-	.swap_activate		= xfs_vm_swap_activate,
 };
diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
index 845a97c9b063..41f7e19bd31f 100644
--- a/fs/xfs/xfs_file.c
+++ b/fs/xfs/xfs_file.c
@@ -2081,6 +2081,50 @@ xfs_file_mmap_prepare(
 	return 0;
 }
 
+static int
+xfs_file_swap_activate(
+	struct file			*file,
+	struct swap_info_struct		*sis)
+{
+	struct xfs_inode		*ip = XFS_I(file_inode(file));
+
+	if (xfs_is_zoned_inode(ip))
+		return -EINVAL;
+
+	/*
+	 * Swap file activation can race against concurrent shared extent
+	 * removal in files that have been cloned.  If this happens,
+	 * iomap_swapfile_iter() can fail because it encountered a shared
+	 * extent even though an operation is in progress to remove those
+	 * shared extents.
+	 *
+	 * This race becomes problematic when we defer extent removal
+	 * operations beyond the end of a syscall (i.e. use async background
+	 * processing algorithms).  Users think the extents are no longer
+	 * shared, but iomap_swapfile_iter() still sees them as shared
+	 * because the refcountbt entries for the extents being removed have
+	 * not yet been updated.  Hence the swapon call fails unexpectedly.
+	 *
+	 * The race condition is currently most obvious from the unlink()
+	 * operation as extent removal is deferred until after the last
+	 * reference to the inode goes away.  We then process the extent
+	 * removal asynchronously, hence triggers the "syscall completed but
+	 * work not done" condition mentioned above.  To close this race
+	 * window, we need to flush any pending inodegc operations to ensure
+	 * they have updated the refcountbt records before we try to map the
+	 * swapfile.
+	 */
+	xfs_inodegc_flush(ip->i_mount);
+
+	/*
+	 * Direct the swap code to the correct block device when this file
+	 * sits on the RT device.
+	 */
+	sis->bdev = xfs_inode_buftarg(ip)->bt_bdev;
+
+	return iomap_swap_activate(file, sis, &xfs_read_iomap_ops);
+}
+
 const struct file_operations xfs_file_operations = {
 	.llseek		= xfs_file_llseek,
 	.read_iter	= xfs_file_read_iter,
@@ -2104,6 +2148,7 @@ const struct file_operations xfs_file_operations = {
 			  FOP_BUFFER_WASYNC | FOP_DIO_PARALLEL_WRITE |
 			  FOP_DONTCACHE,
 	.setlease	= generic_setlease,
+	.swap_activate	= xfs_file_swap_activate,
 };
 
 const struct file_operations xfs_dir_file_operations = {
diff --git a/fs/zonefs/file.c b/fs/zonefs/file.c
index 214e4bf8e30a..2c817917a13d 100644
--- a/fs/zonefs/file.c
+++ b/fs/zonefs/file.c
@@ -167,20 +167,6 @@ static int zonefs_writepages(struct address_space *mapping,
 	return iomap_writepages(&wpc);
 }
 
-static int zonefs_swap_activate(struct swap_info_struct *sis,
-				struct file *swap_file)
-{
-	struct inode *inode = file_inode(swap_file);
-
-	if (zonefs_inode_is_seq(inode)) {
-		zonefs_err(inode->i_sb,
-			   "swap file: not a conventional zone file\n");
-		return -EINVAL;
-	}
-
-	return iomap_swapfile_activate(sis, swap_file, &zonefs_read_iomap_ops);
-}
-
 const struct address_space_operations zonefs_file_aops = {
 	.read_folio		= zonefs_read_folio,
 	.readahead		= zonefs_readahead,
@@ -191,7 +177,6 @@ const struct address_space_operations zonefs_file_aops = {
 	.migrate_folio		= filemap_migrate_folio,
 	.is_partially_uptodate	= iomap_is_partially_uptodate,
 	.error_remove_folio	= generic_error_remove_folio,
-	.swap_activate		= zonefs_swap_activate,
 };
 
 int zonefs_file_truncate(struct inode *inode, loff_t isize)
@@ -858,6 +843,19 @@ static int zonefs_file_release(struct inode *inode, struct file *file)
 	return 0;
 }
 
+static int zonefs_swap_activate(struct file *file, struct swap_info_struct *sis)
+{
+	struct inode *inode = file_inode(file);
+
+	if (zonefs_inode_is_seq(inode)) {
+		zonefs_err(inode->i_sb,
+			   "swap file: not a conventional zone file\n");
+		return -EINVAL;
+	}
+
+	return iomap_swap_activate(file, sis, &zonefs_read_iomap_ops);
+}
+
 const struct file_operations zonefs_file_operations = {
 	.open		= zonefs_file_open,
 	.release	= zonefs_file_release,
@@ -869,4 +867,5 @@ const struct file_operations zonefs_file_operations = {
 	.splice_read	= zonefs_file_splice_read,
 	.splice_write	= iter_file_splice_write,
 	.iopoll		= iocb_bio_iopoll,
+	.swap_activate	= zonefs_swap_activate,
 };
diff --git a/include/linux/fs.h b/include/linux/fs.h
index b8b6f7a38f4d..7564cef5405d 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -433,11 +433,6 @@ struct address_space_operations {
 			size_t count);
 	void (*is_dirty_writeback) (struct folio *, bool *dirty, bool *wb);
 	int (*error_remove_folio)(struct address_space *, struct folio *);
-
-	/* swapfile support */
-	int (*swap_activate)(struct swap_info_struct *sis, struct file *file);
-	void (*swap_deactivate)(struct file *file);
-	int (*swap_rw)(struct kiocb *iocb, struct iov_iter *iter);
 };
 
 extern const struct address_space_operations empty_aops;
@@ -1966,6 +1961,11 @@ struct file_operations {
 	int (*uring_cmd_iopoll)(struct io_uring_cmd *, struct io_comp_batch *,
 				unsigned int poll_flags);
 	int (*mmap_prepare)(struct vm_area_desc *);
+
+	/* swapfile support */
+	int (*swap_activate)(struct file *file, struct swap_info_struct *sis);
+	void (*swap_deactivate)(struct file *file);
+	int (*swap_rw)(struct kiocb *iocb, struct iov_iter *iter);
 } __randomize_layout;
 
 /* Supports async buffered reads */
diff --git a/include/linux/iomap.h b/include/linux/iomap.h
index d82126e3d086..3fd582d375b6 100644
--- a/include/linux/iomap.h
+++ b/include/linux/iomap.h
@@ -603,10 +603,10 @@ void iomap_dio_bio_end_io(struct bio *bio);
 struct file;
 struct swap_info_struct;
 
-int iomap_swapfile_activate(struct swap_info_struct *sis,
-		struct file *swap_file, const struct iomap_ops *ops);
+int iomap_swap_activate(struct file *file, struct swap_info_struct *sis,
+		const struct iomap_ops *ops);
 #else
-# define iomap_swapfile_activate(sis, swapfile, ops)	(-EIO)
+# define iomap_swap_activate(file, sis, ops)	(-EIO)
 #endif /* CONFIG_SWAP */
 
 extern struct bio_set iomap_ioend_bioset;
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index 4623262da3c0..9746212a085e 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -538,6 +538,9 @@ extern __be32 root_nfs_parse_addr(char *name); /*__init*/
 /*
  * linux/fs/nfs/file.c
  */
+int nfs_swap_activate(struct file *file, struct swap_info_struct *sis);
+void nfs_swap_deactivate(struct file *file);
+
 extern const struct file_operations nfs_file_operations;
 #if IS_ENABLED(CONFIG_NFS_V4)
 extern const struct file_operations nfs4_file_operations;
diff --git a/include/linux/swap.h b/include/linux/swap.h
index b8dfe2c6bc98..657779485ae4 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -405,7 +405,7 @@ extern void __meminit kswapd_stop(int nid);
 
 int add_swap_extent(struct swap_info_struct *sis, unsigned long nr_pages,
 		sector_t start_block);
-int generic_swapfile_activate(struct swap_info_struct *, struct file *);
+int generic_swap_activate(struct file *swap_file, struct swap_info_struct *sis);
 
 static inline unsigned long total_swapcache_pages(void)
 {
diff --git a/mm/page_io.c b/mm/page_io.c
index f30f36ec1ed0..3e1c12649448 100644
--- a/mm/page_io.c
+++ b/mm/page_io.c
@@ -75,8 +75,7 @@ static void end_swap_bio_read(struct bio *bio)
 	bio_put(bio);
 }
 
-int generic_swapfile_activate(struct swap_info_struct *sis,
-				struct file *swap_file)
+int generic_swap_activate(struct file *swap_file, struct swap_info_struct *sis)
 {
 	struct address_space *mapping = swap_file->f_mapping;
 	struct inode *inode = mapping->host;
@@ -451,11 +450,10 @@ void __swap_writepage(struct folio *folio, struct swap_iocb **swap_plug)
 void swap_write_unplug(struct swap_iocb *sio)
 {
 	struct iov_iter from;
-	struct address_space *mapping = sio->iocb.ki_filp->f_mapping;
 	int ret;
 
 	iov_iter_bvec(&from, ITER_SOURCE, sio->bvec, sio->pages, sio->len);
-	ret = mapping->a_ops->swap_rw(&sio->iocb, &from);
+	ret = sio->iocb.ki_filp->f_op->swap_rw(&sio->iocb, &from);
 	if (ret != -EIOCBQUEUED)
 		sio_write_complete(&sio->iocb, ret);
 }
@@ -640,11 +638,10 @@ void swap_read_folio(struct folio *folio, struct swap_iocb **plug)
 void __swap_read_unplug(struct swap_iocb *sio)
 {
 	struct iov_iter from;
-	struct address_space *mapping = sio->iocb.ki_filp->f_mapping;
 	int ret;
 
 	iov_iter_bvec(&from, ITER_DEST, sio->bvec, sio->pages, sio->len);
-	ret = mapping->a_ops->swap_rw(&sio->iocb, &from);
+	ret = sio->iocb.ki_filp->f_op->swap_rw(&sio->iocb, &from);
 	if (ret != -EIOCBQUEUED)
 		sio_read_complete(&sio->iocb, ret);
 }
diff --git a/mm/swapfile.c b/mm/swapfile.c
index 158620fd2978..a183c9c95695 100644
--- a/mm/swapfile.c
+++ b/mm/swapfile.c
@@ -2692,11 +2692,9 @@ static void destroy_swap_extents(struct swap_info_struct *sis,
 	}
 
 	if (sis->flags & SWP_ACTIVATED) {
-		struct address_space *mapping = swap_file->f_mapping;
-
 		sis->flags &= ~SWP_ACTIVATED;
-		if (mapping->a_ops->swap_deactivate)
-			mapping->a_ops->swap_deactivate(swap_file);
+		if (swap_file->f_op->swap_deactivate)
+			swap_file->f_op->swap_deactivate(swap_file);
 	}
 }
 
@@ -2790,8 +2788,8 @@ static int setup_swap_extents(struct swap_info_struct *sis,
 	if (S_ISBLK(inode->i_mode))
 		return add_swap_extent(sis, sis->max, 0);
 
-	if (mapping->a_ops->swap_activate) {
-		ret = mapping->a_ops->swap_activate(sis, swap_file);
+	if (swap_file->f_op->swap_activate) {
+		ret = swap_file->f_op->swap_activate(swap_file, sis);
 		if (ret < 0)
 			return ret;
 		sis->flags |= SWP_ACTIVATED;
@@ -2803,7 +2801,7 @@ static int setup_swap_extents(struct swap_info_struct *sis,
 		return ret;
 	}
 
-	return generic_swapfile_activate(sis, swap_file);
+	return generic_swap_activate(swap_file, sis);
 }
 
 static void _enable_swap_info(struct swap_info_struct *si)
-- 
2.53.0