On Tue, May 12, 2026 at 07:35:19AM +0200, Christoph Hellwig wrote: > 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 <[email protected]>
This sounds like a good idea because the filesystem is effectively giving the kernel a lease on a file's layout, which has little to do with the pagecache. Reviewed-by: "Darrick J. Wong" <[email protected]> --D > --- > .../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 > > _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
