tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge tag 'vfs-6.17-rc1.mmap_prepare' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs

Pull mmap_prepare updates from Christian Brauner:
"Last cycle we introduce f_op->mmap_prepare() in c84bf6dd2b83 ("mm:
introduce new .mmap_prepare() file callback").

This is preferred to the existing f_op->mmap() hook as it does require
a VMA to be established yet, thus allowing the mmap logic to invoke
this hook far, far earlier, prior to inserting a VMA into the virtual
address space, or performing any other heavy handed operations.

This allows for much simpler unwinding on error, and for there to be a
single attempt at merging a VMA rather than having to possibly
reattempt a merge based on potentially altered VMA state.

Far more importantly, it prevents inappropriate manipulation of
incompletely initialised VMA state, which is something that has been
the cause of bugs and complexity in the past.

The intent is to gradually deprecate f_op->mmap, and in that vein this
series coverts the majority of file systems to using f_op->mmap_prepare.

Prerequisite steps are taken - firstly ensuring all checks for mmap
capabilities use the file_has_valid_mmap_hooks() helper rather than
directly checking for f_op->mmap (which is now not a valid check) and
secondly updating daxdev_mapping_supported() to not require a VMA
parameter to allow ext4 and xfs to be converted.

Commit bb666b7c2707 ("mm: add mmap_prepare() compatibility layer for
nested file systems") handles the nasty edge-case of nested file
systems like overlayfs, which introduces a compatibility shim to allow
f_op->mmap_prepare() to be invoked from an f_op->mmap() callback.

This allows for nested filesystems to continue to function correctly
with all file systems regardless of which callback is used. Once we
finally convert all file systems, this shim can be removed.

As a result, ecryptfs, fuse, and overlayfs remain unaltered so they
can nest all other file systems.

We additionally do not update resctl - as this requires an update to
remap_pfn_range() (or an alternative to it) which we defer to a later
series, equally we do not update cramfs which needs a mixed mapping
insertion with the same issue, nor do we update procfs, hugetlbfs,
syfs or kernfs all of which require VMAs for internal state and hooks.
We shall return to all of these later"

* tag 'vfs-6.17-rc1.mmap_prepare' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs:
doc: update porting, vfs documentation to describe mmap_prepare()
fs: replace mmap hook with .mmap_prepare for simple mappings
fs: convert most other generic_file_*mmap() users to .mmap_prepare()
fs: convert simple use of generic_file_*_mmap() to .mmap_prepare()
mm/filemap: introduce generic_file_*_mmap_prepare() helpers
fs/xfs: transition from deprecated .mmap hook to .mmap_prepare
fs/ext4: transition from deprecated .mmap hook to .mmap_prepare
fs/dax: make it possible to check dev dax support without a VMA
fs: consistently use can_mmap_file() helper
mm/nommu: use file_has_valid_mmap_hooks() helper
mm: rename call_mmap/mmap_prepare to vfs_mmap/mmap_prepare

Linus Torvalds 7031769e 278c7d9b

+281 -187
+12
Documentation/filesystems/porting.rst
··· 1273 1273 ->d_op for different dentries - if not, just use set_default_d_op() 1274 1274 at mount time and be done with that. Currently procfs is the only 1275 1275 thing that really needs ->d_op varying between dentries. 1276 + 1277 + --- 1278 + 1279 + **highly recommended** 1280 + 1281 + The file operations mmap() callback is deprecated in favour of 1282 + mmap_prepare(). This passes a pointer to a vm_area_desc to the callback 1283 + rather than a VMA, as the VMA at this stage is not yet valid. 1284 + 1285 + The vm_area_desc provides the minimum required information for a filesystem 1286 + to initialise state upon memory mapping of a file-backed region, and output 1287 + parameters for the file system to set this state.
+18 -4
Documentation/filesystems/vfs.rst
··· 1072 1072 1073 1073 struct file_operations { 1074 1074 struct module *owner; 1075 + fop_flags_t fop_flags; 1075 1076 loff_t (*llseek) (struct file *, loff_t, int); 1076 1077 ssize_t (*read) (struct file *, char __user *, size_t, loff_t *); 1077 1078 ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *); 1078 1079 ssize_t (*read_iter) (struct kiocb *, struct iov_iter *); 1079 1080 ssize_t (*write_iter) (struct kiocb *, struct iov_iter *); 1080 - int (*iopoll)(struct kiocb *kiocb, bool spin); 1081 + int (*iopoll)(struct kiocb *kiocb, struct io_comp_batch *, 1082 + unsigned int flags); 1081 1083 int (*iterate_shared) (struct file *, struct dir_context *); 1082 1084 __poll_t (*poll) (struct file *, struct poll_table_struct *); 1083 1085 long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long); ··· 1096 1094 int (*flock) (struct file *, int, struct file_lock *); 1097 1095 ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int); 1098 1096 ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int); 1099 - int (*setlease)(struct file *, long, struct file_lock **, void **); 1097 + void (*splice_eof)(struct file *file); 1098 + int (*setlease)(struct file *, int, struct file_lease **, void **); 1100 1099 long (*fallocate)(struct file *file, int mode, loff_t offset, 1101 1100 loff_t len); 1102 1101 void (*show_fdinfo)(struct seq_file *m, struct file *f); 1103 1102 #ifndef CONFIG_MMU 1104 1103 unsigned (*mmap_capabilities)(struct file *); 1105 1104 #endif 1106 - ssize_t (*copy_file_range)(struct file *, loff_t, struct file *, loff_t, size_t, unsigned int); 1105 + ssize_t (*copy_file_range)(struct file *, loff_t, struct file *, 1106 + loff_t, size_t, unsigned int); 1107 1107 loff_t (*remap_file_range)(struct file *file_in, loff_t pos_in, 1108 1108 struct file *file_out, loff_t pos_out, 1109 1109 loff_t len, unsigned int remap_flags); 1110 1110 int (*fadvise)(struct file *, loff_t, loff_t, int); 1111 + int (*uring_cmd)(struct io_uring_cmd *ioucmd, unsigned int issue_flags); 1112 + int (*uring_cmd_iopoll)(struct io_uring_cmd *, struct io_comp_batch *, 1113 + unsigned int poll_flags); 1114 + int (*mmap_prepare)(struct vm_area_desc *); 1111 1115 }; 1112 1116 1113 1117 Again, all methods are called without any locks being held, unless ··· 1153 1145 used on 64 bit kernels. 1154 1146 1155 1147 ``mmap`` 1156 - called by the mmap(2) system call 1148 + called by the mmap(2) system call. Deprecated in favour of 1149 + ``mmap_prepare``. 1157 1150 1158 1151 ``open`` 1159 1152 called by the VFS when an inode should be opened. When the VFS ··· 1230 1221 1231 1222 ``fadvise`` 1232 1223 possibly called by the fadvise64() system call. 1224 + 1225 + ``mmap_prepare`` 1226 + Called by the mmap(2) system call. Allows a VFS to set up a 1227 + file-backed memory mapping, most notably establishing relevant 1228 + private state and VMA callbacks. 1233 1229 1234 1230 Note that the file operations are implemented by the specific 1235 1231 filesystem in which the inode resides. When opening a device node
+6 -6
block/fops.c
··· 920 920 return error; 921 921 } 922 922 923 - static int blkdev_mmap(struct file *file, struct vm_area_struct *vma) 923 + static int blkdev_mmap_prepare(struct vm_area_desc *desc) 924 924 { 925 - struct inode *bd_inode = bdev_file_inode(file); 925 + struct file *file = desc->file; 926 926 927 - if (bdev_read_only(I_BDEV(bd_inode))) 928 - return generic_file_readonly_mmap(file, vma); 927 + if (bdev_read_only(I_BDEV(bdev_file_inode(file)))) 928 + return generic_file_readonly_mmap_prepare(desc); 929 929 930 - return generic_file_mmap(file, vma); 930 + return generic_file_mmap_prepare(desc); 931 931 } 932 932 933 933 const struct file_operations def_blk_fops = { ··· 937 937 .read_iter = blkdev_read_iter, 938 938 .write_iter = blkdev_write_iter, 939 939 .iopoll = iocb_bio_iopoll, 940 - .mmap = blkdev_mmap, 940 + .mmap_prepare = blkdev_mmap_prepare, 941 941 .fsync = blkdev_fsync, 942 942 .unlocked_ioctl = blkdev_ioctl, 943 943 #ifdef CONFIG_COMPAT
+1 -1
drivers/gpu/drm/i915/gem/i915_gem_dmabuf.c
··· 105 105 if (!obj->base.filp) 106 106 return -ENODEV; 107 107 108 - ret = call_mmap(obj->base.filp, vma); 108 + ret = vfs_mmap(obj->base.filp, vma); 109 109 if (ret) 110 110 return ret; 111 111
+7 -6
fs/9p/vfs_file.c
··· 454 454 } 455 455 456 456 static int 457 - v9fs_file_mmap(struct file *filp, struct vm_area_struct *vma) 457 + v9fs_file_mmap_prepare(struct vm_area_desc *desc) 458 458 { 459 459 int retval; 460 + struct file *filp = desc->file; 460 461 struct inode *inode = file_inode(filp); 461 462 struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode); 462 463 ··· 465 464 466 465 if (!(v9ses->cache & CACHE_WRITEBACK)) { 467 466 p9_debug(P9_DEBUG_CACHE, "(read-only mmap mode)"); 468 - return generic_file_readonly_mmap(filp, vma); 467 + return generic_file_readonly_mmap_prepare(desc); 469 468 } 470 469 471 - retval = generic_file_mmap(filp, vma); 470 + retval = generic_file_mmap_prepare(desc); 472 471 if (!retval) 473 - vma->vm_ops = &v9fs_mmap_file_vm_ops; 472 + desc->vm_ops = &v9fs_mmap_file_vm_ops; 474 473 475 474 return retval; 476 475 } ··· 517 516 .open = v9fs_file_open, 518 517 .release = v9fs_dir_release, 519 518 .lock = v9fs_file_lock, 520 - .mmap = generic_file_readonly_mmap, 519 + .mmap_prepare = generic_file_readonly_mmap_prepare, 521 520 .splice_read = v9fs_file_splice_read, 522 521 .splice_write = iter_file_splice_write, 523 522 .fsync = v9fs_file_fsync, ··· 532 531 .release = v9fs_dir_release, 533 532 .lock = v9fs_file_lock_dotl, 534 533 .flock = v9fs_file_flock_dotl, 535 - .mmap = v9fs_file_mmap, 534 + .mmap_prepare = v9fs_file_mmap_prepare, 536 535 .splice_read = v9fs_file_splice_read, 537 536 .splice_write = iter_file_splice_write, 538 537 .fsync = v9fs_file_fsync_dotl,
+1 -1
fs/adfs/file.c
··· 25 25 const struct file_operations adfs_file_operations = { 26 26 .llseek = generic_file_llseek, 27 27 .read_iter = generic_file_read_iter, 28 - .mmap = generic_file_mmap, 28 + .mmap_prepare = generic_file_mmap_prepare, 29 29 .fsync = generic_file_fsync, 30 30 .write_iter = generic_file_write_iter, 31 31 .splice_read = filemap_splice_read,
+1 -1
fs/affs/file.c
··· 1003 1003 .llseek = generic_file_llseek, 1004 1004 .read_iter = generic_file_read_iter, 1005 1005 .write_iter = generic_file_write_iter, 1006 - .mmap = generic_file_mmap, 1006 + .mmap_prepare = generic_file_mmap_prepare, 1007 1007 .open = affs_file_open, 1008 1008 .release = affs_file_release, 1009 1009 .fsync = affs_file_fsync,
+6 -6
fs/afs/file.c
··· 19 19 #include <trace/events/netfs.h> 20 20 #include "internal.h" 21 21 22 - static int afs_file_mmap(struct file *file, struct vm_area_struct *vma); 22 + static int afs_file_mmap_prepare(struct vm_area_desc *desc); 23 23 24 24 static ssize_t afs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter); 25 25 static ssize_t afs_file_splice_read(struct file *in, loff_t *ppos, ··· 35 35 .llseek = generic_file_llseek, 36 36 .read_iter = afs_file_read_iter, 37 37 .write_iter = netfs_file_write_iter, 38 - .mmap = afs_file_mmap, 38 + .mmap_prepare = afs_file_mmap_prepare, 39 39 .splice_read = afs_file_splice_read, 40 40 .splice_write = iter_file_splice_write, 41 41 .fsync = afs_fsync, ··· 492 492 /* 493 493 * Handle setting up a memory mapping on an AFS file. 494 494 */ 495 - static int afs_file_mmap(struct file *file, struct vm_area_struct *vma) 495 + static int afs_file_mmap_prepare(struct vm_area_desc *desc) 496 496 { 497 - struct afs_vnode *vnode = AFS_FS_I(file_inode(file)); 497 + struct afs_vnode *vnode = AFS_FS_I(file_inode(desc->file)); 498 498 int ret; 499 499 500 500 afs_add_open_mmap(vnode); 501 501 502 - ret = generic_file_mmap(file, vma); 502 + ret = generic_file_mmap_prepare(desc); 503 503 if (ret == 0) 504 - vma->vm_ops = &afs_vm_ops; 504 + desc->vm_ops = &afs_vm_ops; 505 505 else 506 506 afs_drop_open_mmap(vnode); 507 507 return ret;
+4 -4
fs/aio.c
··· 392 392 #endif 393 393 }; 394 394 395 - static int aio_ring_mmap(struct file *file, struct vm_area_struct *vma) 395 + static int aio_ring_mmap_prepare(struct vm_area_desc *desc) 396 396 { 397 - vm_flags_set(vma, VM_DONTEXPAND); 398 - vma->vm_ops = &aio_ring_vm_ops; 397 + desc->vm_flags |= VM_DONTEXPAND; 398 + desc->vm_ops = &aio_ring_vm_ops; 399 399 return 0; 400 400 } 401 401 402 402 static const struct file_operations aio_ring_fops = { 403 - .mmap = aio_ring_mmap, 403 + .mmap_prepare = aio_ring_mmap_prepare, 404 404 }; 405 405 406 406 #if IS_ENABLED(CONFIG_MIGRATION)
+2 -2
fs/backing-file.c
··· 333 333 if (WARN_ON_ONCE(!(file->f_mode & FMODE_BACKING))) 334 334 return -EIO; 335 335 336 - if (!file->f_op->mmap) 336 + if (!can_mmap_file(file)) 337 337 return -ENODEV; 338 338 339 339 vma_set_file(vma, file); 340 340 341 341 old_cred = override_creds(ctx->cred); 342 - ret = call_mmap(vma->vm_file, vma); 342 + ret = vfs_mmap(vma->vm_file, vma); 343 343 revert_creds(old_cred); 344 344 345 345 if (ctx->accessed)
+4 -4
fs/bcachefs/fs.c
··· 1551 1551 .page_mkwrite = bch2_page_mkwrite, 1552 1552 }; 1553 1553 1554 - static int bch2_mmap(struct file *file, struct vm_area_struct *vma) 1554 + static int bch2_mmap_prepare(struct vm_area_desc *desc) 1555 1555 { 1556 - file_accessed(file); 1556 + file_accessed(desc->file); 1557 1557 1558 - vma->vm_ops = &bch_vm_ops; 1558 + desc->vm_ops = &bch_vm_ops; 1559 1559 return 0; 1560 1560 } 1561 1561 ··· 1739 1739 .llseek = bch2_llseek, 1740 1740 .read_iter = bch2_read_iter, 1741 1741 .write_iter = bch2_write_iter, 1742 - .mmap = bch2_mmap, 1742 + .mmap_prepare = bch2_mmap_prepare, 1743 1743 .get_unmapped_area = thp_get_unmapped_area, 1744 1744 .fsync = bch2_fsync, 1745 1745 .splice_read = filemap_splice_read,
+1 -1
fs/bfs/file.c
··· 27 27 .llseek = generic_file_llseek, 28 28 .read_iter = generic_file_read_iter, 29 29 .write_iter = generic_file_write_iter, 30 - .mmap = generic_file_mmap, 30 + .mmap_prepare = generic_file_mmap_prepare, 31 31 .splice_read = filemap_splice_read, 32 32 }; 33 33
+2 -2
fs/binfmt_elf.c
··· 646 646 if (!elf_check_arch(interp_elf_ex) || 647 647 elf_check_fdpic(interp_elf_ex)) 648 648 goto out; 649 - if (!interpreter->f_op->mmap) 649 + if (!can_mmap_file(interpreter)) 650 650 goto out; 651 651 652 652 total_size = total_mapping_size(interp_elf_phdata, ··· 848 848 goto out; 849 849 if (elf_check_fdpic(elf_ex)) 850 850 goto out; 851 - if (!bprm->file->f_op->mmap) 851 + if (!can_mmap_file(bprm->file)) 852 852 goto out; 853 853 854 854 elf_phdata = load_elf_phdrs(elf_ex, bprm->file);
+1 -1
fs/binfmt_elf_fdpic.c
··· 109 109 return 0; 110 110 if (!elf_check_arch(hdr)) 111 111 return 0; 112 - if (!file->f_op->mmap) 112 + if (!can_mmap_file(file)) 113 113 return 0; 114 114 return 1; 115 115 }
+4 -3
fs/btrfs/file.c
··· 2039 2039 .page_mkwrite = btrfs_page_mkwrite, 2040 2040 }; 2041 2041 2042 - static int btrfs_file_mmap(struct file *filp, struct vm_area_struct *vma) 2042 + static int btrfs_file_mmap_prepare(struct vm_area_desc *desc) 2043 2043 { 2044 + struct file *filp = desc->file; 2044 2045 struct address_space *mapping = filp->f_mapping; 2045 2046 2046 2047 if (!mapping->a_ops->read_folio) 2047 2048 return -ENOEXEC; 2048 2049 2049 2050 file_accessed(filp); 2050 - vma->vm_ops = &btrfs_file_vm_ops; 2051 + desc->vm_ops = &btrfs_file_vm_ops; 2051 2052 2052 2053 return 0; 2053 2054 } ··· 3822 3821 .splice_read = filemap_splice_read, 3823 3822 .write_iter = btrfs_file_write_iter, 3824 3823 .splice_write = iter_file_splice_write, 3825 - .mmap = btrfs_file_mmap, 3824 + .mmap_prepare = btrfs_file_mmap_prepare, 3826 3825 .open = btrfs_file_open, 3827 3826 .release = btrfs_release_file, 3828 3827 .get_unmapped_area = thp_get_unmapped_area,
+3 -3
fs/ceph/addr.c
··· 2334 2334 .page_mkwrite = ceph_page_mkwrite, 2335 2335 }; 2336 2336 2337 - int ceph_mmap(struct file *file, struct vm_area_struct *vma) 2337 + int ceph_mmap_prepare(struct vm_area_desc *desc) 2338 2338 { 2339 - struct address_space *mapping = file->f_mapping; 2339 + struct address_space *mapping = desc->file->f_mapping; 2340 2340 2341 2341 if (!mapping->a_ops->read_folio) 2342 2342 return -ENOEXEC; 2343 - vma->vm_ops = &ceph_vmops; 2343 + desc->vm_ops = &ceph_vmops; 2344 2344 return 0; 2345 2345 } 2346 2346
+1 -1
fs/ceph/file.c
··· 3171 3171 .llseek = ceph_llseek, 3172 3172 .read_iter = ceph_read_iter, 3173 3173 .write_iter = ceph_write_iter, 3174 - .mmap = ceph_mmap, 3174 + .mmap_prepare = ceph_mmap_prepare, 3175 3175 .fsync = ceph_fsync, 3176 3176 .lock = ceph_lock, 3177 3177 .setlease = simple_nosetlease,
+1 -1
fs/ceph/super.h
··· 1286 1286 /* addr.c */ 1287 1287 extern const struct address_space_operations ceph_aops; 1288 1288 extern const struct netfs_request_ops ceph_netfs_ops; 1289 - extern int ceph_mmap(struct file *file, struct vm_area_struct *vma); 1289 + int ceph_mmap_prepare(struct vm_area_desc *desc); 1290 1290 extern int ceph_uninline_data(struct file *file); 1291 1291 extern int ceph_pool_perm_check(struct inode *inode, int need); 1292 1292 extern void ceph_pool_perm_destroy(struct ceph_mds_client* mdsc);
+3 -3
fs/coda/file.c
··· 160 160 size_t count; 161 161 int ret; 162 162 163 - if (!host_file->f_op->mmap) 163 + if (!can_mmap_file(host_file)) 164 164 return -ENODEV; 165 165 166 166 if (WARN_ON(coda_file != vma->vm_file)) ··· 199 199 spin_unlock(&cii->c_lock); 200 200 201 201 vma->vm_file = get_file(host_file); 202 - ret = call_mmap(vma->vm_file, vma); 202 + ret = vfs_mmap(vma->vm_file, vma); 203 203 204 204 if (ret) { 205 - /* if call_mmap fails, our caller will put host_file so we 205 + /* if vfs_mmap fails, our caller will put host_file so we 206 206 * should drop the reference to the coda_file that we got. 207 207 */ 208 208 fput(coda_file);
+1 -1
fs/ecryptfs/file.c
··· 193 193 * natively. If FILESYSTEM_MAX_STACK_DEPTH > 2 or ecryptfs 194 194 * allows recursive mounting, this will need to be extended. 195 195 */ 196 - if (!lower_file->f_op->mmap) 196 + if (!can_mmap_file(lower_file)) 197 197 return -ENODEV; 198 198 return generic_file_mmap(file, vma); 199 199 }
+8 -8
fs/erofs/data.c
··· 432 432 .huge_fault = erofs_dax_huge_fault, 433 433 }; 434 434 435 - static int erofs_file_mmap(struct file *file, struct vm_area_struct *vma) 435 + static int erofs_file_mmap_prepare(struct vm_area_desc *desc) 436 436 { 437 - if (!IS_DAX(file_inode(file))) 438 - return generic_file_readonly_mmap(file, vma); 437 + if (!IS_DAX(file_inode(desc->file))) 438 + return generic_file_readonly_mmap_prepare(desc); 439 439 440 - if ((vma->vm_flags & VM_SHARED) && (vma->vm_flags & VM_MAYWRITE)) 440 + if ((desc->vm_flags & VM_SHARED) && (desc->vm_flags & VM_MAYWRITE)) 441 441 return -EINVAL; 442 442 443 - vma->vm_ops = &erofs_dax_vm_ops; 444 - vm_flags_set(vma, VM_HUGEPAGE); 443 + desc->vm_ops = &erofs_dax_vm_ops; 444 + desc->vm_flags |= VM_HUGEPAGE; 445 445 return 0; 446 446 } 447 447 #else 448 - #define erofs_file_mmap generic_file_readonly_mmap 448 + #define erofs_file_mmap_prepare generic_file_readonly_mmap_prepare 449 449 #endif 450 450 451 451 static loff_t erofs_file_llseek(struct file *file, loff_t offset, int whence) ··· 475 475 const struct file_operations erofs_file_fops = { 476 476 .llseek = erofs_file_llseek, 477 477 .read_iter = erofs_file_read_iter, 478 - .mmap = erofs_file_mmap, 478 + .mmap_prepare = erofs_file_mmap_prepare, 479 479 .get_unmapped_area = thp_get_unmapped_area, 480 480 .splice_read = filemap_splice_read, 481 481 };
+6 -4
fs/exfat/file.c
··· 682 682 .page_mkwrite = exfat_page_mkwrite, 683 683 }; 684 684 685 - static int exfat_file_mmap(struct file *file, struct vm_area_struct *vma) 685 + static int exfat_file_mmap_prepare(struct vm_area_desc *desc) 686 686 { 687 - if (unlikely(exfat_forced_shutdown(file_inode(file)->i_sb))) 687 + struct file *file = desc->file; 688 + 689 + if (unlikely(exfat_forced_shutdown(file_inode(desc->file)->i_sb))) 688 690 return -EIO; 689 691 690 692 file_accessed(file); 691 - vma->vm_ops = &exfat_file_vm_ops; 693 + desc->vm_ops = &exfat_file_vm_ops; 692 694 return 0; 693 695 } 694 696 ··· 711 709 #ifdef CONFIG_COMPAT 712 710 .compat_ioctl = exfat_compat_ioctl, 713 711 #endif 714 - .mmap = exfat_file_mmap, 712 + .mmap_prepare = exfat_file_mmap_prepare, 715 713 .fsync = exfat_file_fsync, 716 714 .splice_read = exfat_splice_read, 717 715 .splice_write = iter_file_splice_write,
+7 -5
fs/ext2/file.c
··· 122 122 .pfn_mkwrite = ext2_dax_fault, 123 123 }; 124 124 125 - static int ext2_file_mmap(struct file *file, struct vm_area_struct *vma) 125 + static int ext2_file_mmap_prepare(struct vm_area_desc *desc) 126 126 { 127 + struct file *file = desc->file; 128 + 127 129 if (!IS_DAX(file_inode(file))) 128 - return generic_file_mmap(file, vma); 130 + return generic_file_mmap_prepare(desc); 129 131 130 132 file_accessed(file); 131 - vma->vm_ops = &ext2_dax_vm_ops; 133 + desc->vm_ops = &ext2_dax_vm_ops; 132 134 return 0; 133 135 } 134 136 #else 135 - #define ext2_file_mmap generic_file_mmap 137 + #define ext2_file_mmap_prepare generic_file_mmap_prepare 136 138 #endif 137 139 138 140 /* ··· 318 316 #ifdef CONFIG_COMPAT 319 317 .compat_ioctl = ext2_compat_ioctl, 320 318 #endif 321 - .mmap = ext2_file_mmap, 319 + .mmap_prepare = ext2_file_mmap_prepare, 322 320 .open = ext2_file_open, 323 321 .release = ext2_release_file, 324 322 .fsync = ext2_fsync,
+7 -6
fs/ext4/file.c
··· 804 804 .page_mkwrite = ext4_page_mkwrite, 805 805 }; 806 806 807 - static int ext4_file_mmap(struct file *file, struct vm_area_struct *vma) 807 + static int ext4_file_mmap_prepare(struct vm_area_desc *desc) 808 808 { 809 809 int ret; 810 + struct file *file = desc->file; 810 811 struct inode *inode = file->f_mapping->host; 811 812 struct dax_device *dax_dev = EXT4_SB(inode->i_sb)->s_daxdev; 812 813 ··· 822 821 * We don't support synchronous mappings for non-DAX files and 823 822 * for DAX files if underneath dax_device is not synchronous. 824 823 */ 825 - if (!daxdev_mapping_supported(vma, dax_dev)) 824 + if (!daxdev_mapping_supported(desc->vm_flags, file_inode(file), dax_dev)) 826 825 return -EOPNOTSUPP; 827 826 828 827 file_accessed(file); 829 828 if (IS_DAX(file_inode(file))) { 830 - vma->vm_ops = &ext4_dax_vm_ops; 831 - vm_flags_set(vma, VM_HUGEPAGE); 829 + desc->vm_ops = &ext4_dax_vm_ops; 830 + desc->vm_flags |= VM_HUGEPAGE; 832 831 } else { 833 - vma->vm_ops = &ext4_file_vm_ops; 832 + desc->vm_ops = &ext4_file_vm_ops; 834 833 } 835 834 return 0; 836 835 } ··· 969 968 #ifdef CONFIG_COMPAT 970 969 .compat_ioctl = ext4_compat_ioctl, 971 970 #endif 972 - .mmap = ext4_file_mmap, 971 + .mmap_prepare = ext4_file_mmap_prepare, 973 972 .open = ext4_file_open, 974 973 .release = ext4_release_file, 975 974 .fsync = ext4_sync_file,
+4 -3
fs/f2fs/file.c
··· 548 548 return -EINVAL; 549 549 } 550 550 551 - static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma) 551 + static int f2fs_file_mmap_prepare(struct vm_area_desc *desc) 552 552 { 553 + struct file *file = desc->file; 553 554 struct inode *inode = file_inode(file); 554 555 555 556 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) ··· 560 559 return -EOPNOTSUPP; 561 560 562 561 file_accessed(file); 563 - vma->vm_ops = &f2fs_file_vm_ops; 562 + desc->vm_ops = &f2fs_file_vm_ops; 564 563 565 564 f2fs_down_read(&F2FS_I(inode)->i_sem); 566 565 set_inode_flag(inode, FI_MMAP_FILE); ··· 5415 5414 .iopoll = iocb_bio_iopoll, 5416 5415 .open = f2fs_file_open, 5417 5416 .release = f2fs_release_file, 5418 - .mmap = f2fs_file_mmap, 5417 + .mmap_prepare = f2fs_file_mmap_prepare, 5419 5418 .flush = f2fs_file_flush, 5420 5419 .fsync = f2fs_sync_file, 5421 5420 .fallocate = f2fs_fallocate,
+1 -1
fs/fat/file.c
··· 204 204 .llseek = generic_file_llseek, 205 205 .read_iter = generic_file_read_iter, 206 206 .write_iter = generic_file_write_iter, 207 - .mmap = generic_file_mmap, 207 + .mmap_prepare = generic_file_mmap_prepare, 208 208 .release = fat_file_release, 209 209 .unlocked_ioctl = fat_generic_ioctl, 210 210 .compat_ioctl = compat_ptr_ioctl,
+1 -1
fs/hfs/inode.c
··· 690 690 .llseek = generic_file_llseek, 691 691 .read_iter = generic_file_read_iter, 692 692 .write_iter = generic_file_write_iter, 693 - .mmap = generic_file_mmap, 693 + .mmap_prepare = generic_file_mmap_prepare, 694 694 .splice_read = filemap_splice_read, 695 695 .fsync = hfs_file_fsync, 696 696 .open = hfs_file_open,
+1 -1
fs/hfsplus/inode.c
··· 368 368 .llseek = generic_file_llseek, 369 369 .read_iter = generic_file_read_iter, 370 370 .write_iter = generic_file_write_iter, 371 - .mmap = generic_file_mmap, 371 + .mmap_prepare = generic_file_mmap_prepare, 372 372 .splice_read = filemap_splice_read, 373 373 .fsync = hfsplus_file_fsync, 374 374 .open = hfsplus_file_open,
+1 -1
fs/hostfs/hostfs_kern.c
··· 382 382 .splice_write = iter_file_splice_write, 383 383 .read_iter = generic_file_read_iter, 384 384 .write_iter = generic_file_write_iter, 385 - .mmap = generic_file_mmap, 385 + .mmap_prepare = generic_file_mmap_prepare, 386 386 .open = hostfs_open, 387 387 .release = hostfs_file_release, 388 388 .fsync = hostfs_fsync,
+1 -1
fs/hpfs/file.c
··· 257 257 .llseek = generic_file_llseek, 258 258 .read_iter = generic_file_read_iter, 259 259 .write_iter = generic_file_write_iter, 260 - .mmap = generic_file_mmap, 260 + .mmap_prepare = generic_file_mmap_prepare, 261 261 .release = hpfs_file_release, 262 262 .fsync = hpfs_file_fsync, 263 263 .splice_read = filemap_splice_read,
+1 -1
fs/jffs2/file.c
··· 56 56 .read_iter = generic_file_read_iter, 57 57 .write_iter = generic_file_write_iter, 58 58 .unlocked_ioctl=jffs2_ioctl, 59 - .mmap = generic_file_readonly_mmap, 59 + .mmap_prepare = generic_file_readonly_mmap_prepare, 60 60 .fsync = jffs2_fsync, 61 61 .splice_read = filemap_splice_read, 62 62 .splice_write = iter_file_splice_write,
+1 -1
fs/jfs/file.c
··· 143 143 .llseek = generic_file_llseek, 144 144 .read_iter = generic_file_read_iter, 145 145 .write_iter = generic_file_write_iter, 146 - .mmap = generic_file_mmap, 146 + .mmap_prepare = generic_file_mmap_prepare, 147 147 .splice_read = filemap_splice_read, 148 148 .splice_write = iter_file_splice_write, 149 149 .fsync = jfs_fsync,
+1 -1
fs/minix/file.c
··· 17 17 .llseek = generic_file_llseek, 18 18 .read_iter = generic_file_read_iter, 19 19 .write_iter = generic_file_write_iter, 20 - .mmap = generic_file_mmap, 20 + .mmap_prepare = generic_file_mmap_prepare, 21 21 .fsync = generic_file_fsync, 22 22 .splice_read = filemap_splice_read, 23 23 };
+7 -6
fs/nfs/file.c
··· 207 207 EXPORT_SYMBOL_GPL(nfs_file_splice_read); 208 208 209 209 int 210 - nfs_file_mmap(struct file *file, struct vm_area_struct *vma) 210 + nfs_file_mmap_prepare(struct vm_area_desc *desc) 211 211 { 212 + struct file *file = desc->file; 212 213 struct inode *inode = file_inode(file); 213 214 int status; 214 215 215 216 dprintk("NFS: mmap(%pD2)\n", file); 216 217 217 - /* Note: generic_file_mmap() returns ENOSYS on nommu systems 218 + /* Note: generic_file_mmap_prepare() returns ENOSYS on nommu systems 218 219 * so we call that before revalidating the mapping 219 220 */ 220 - status = generic_file_mmap(file, vma); 221 + status = generic_file_mmap_prepare(desc); 221 222 if (!status) { 222 - vma->vm_ops = &nfs_file_vm_ops; 223 + desc->vm_ops = &nfs_file_vm_ops; 223 224 status = nfs_revalidate_mapping(inode, file->f_mapping); 224 225 } 225 226 return status; 226 227 } 227 - EXPORT_SYMBOL_GPL(nfs_file_mmap); 228 + EXPORT_SYMBOL_GPL(nfs_file_mmap_prepare); 228 229 229 230 /* 230 231 * Flush any dirty pages for this process, and check for write errors. ··· 904 903 .llseek = nfs_file_llseek, 905 904 .read_iter = nfs_file_read, 906 905 .write_iter = nfs_file_write, 907 - .mmap = nfs_file_mmap, 906 + .mmap_prepare = nfs_file_mmap_prepare, 908 907 .open = nfs_file_open, 909 908 .flush = nfs_file_flush, 910 909 .release = nfs_file_release,
+1 -1
fs/nfs/internal.h
··· 432 432 ssize_t nfs_file_read(struct kiocb *, struct iov_iter *); 433 433 ssize_t nfs_file_splice_read(struct file *in, loff_t *ppos, struct pipe_inode_info *pipe, 434 434 size_t len, unsigned int flags); 435 - int nfs_file_mmap(struct file *, struct vm_area_struct *); 435 + int nfs_file_mmap_prepare(struct vm_area_desc *); 436 436 ssize_t nfs_file_write(struct kiocb *, struct iov_iter *); 437 437 int nfs_file_release(struct inode *, struct file *); 438 438 int nfs_lock(struct file *, int, struct file_lock *);
+1 -1
fs/nfs/nfs4file.c
··· 456 456 const struct file_operations nfs4_file_operations = { 457 457 .read_iter = nfs_file_read, 458 458 .write_iter = nfs_file_write, 459 - .mmap = nfs_file_mmap, 459 + .mmap_prepare = nfs_file_mmap_prepare, 460 460 .open = nfs4_file_open, 461 461 .flush = nfs4_file_flush, 462 462 .release = nfs_file_release,
+4 -4
fs/nilfs2/file.c
··· 125 125 .page_mkwrite = nilfs_page_mkwrite, 126 126 }; 127 127 128 - static int nilfs_file_mmap(struct file *file, struct vm_area_struct *vma) 128 + static int nilfs_file_mmap_prepare(struct vm_area_desc *desc) 129 129 { 130 - file_accessed(file); 131 - vma->vm_ops = &nilfs_file_vm_ops; 130 + file_accessed(desc->file); 131 + desc->vm_ops = &nilfs_file_vm_ops; 132 132 return 0; 133 133 } 134 134 ··· 144 144 #ifdef CONFIG_COMPAT 145 145 .compat_ioctl = nilfs_compat_ioctl, 146 146 #endif /* CONFIG_COMPAT */ 147 - .mmap = nilfs_file_mmap, 147 + .mmap_prepare = nilfs_file_mmap_prepare, 148 148 .open = generic_file_open, 149 149 /* .release = nilfs_release_file, */ 150 150 .fsync = nilfs_sync_file,
+8 -7
fs/ntfs3/file.c
··· 269 269 } 270 270 271 271 /* 272 - * ntfs_file_mmap - file_operations::mmap 272 + * ntfs_file_mmap_prepare - file_operations::mmap_prepare 273 273 */ 274 - static int ntfs_file_mmap(struct file *file, struct vm_area_struct *vma) 274 + static int ntfs_file_mmap_prepare(struct vm_area_desc *desc) 275 275 { 276 + struct file *file = desc->file; 276 277 struct inode *inode = file_inode(file); 277 278 struct ntfs_inode *ni = ntfs_i(inode); 278 - u64 from = ((u64)vma->vm_pgoff << PAGE_SHIFT); 279 - bool rw = vma->vm_flags & VM_WRITE; 279 + u64 from = ((u64)desc->pgoff << PAGE_SHIFT); 280 + bool rw = desc->vm_flags & VM_WRITE; 280 281 int err; 281 282 282 283 /* Avoid any operation if inode is bad. */ ··· 304 303 305 304 if (rw) { 306 305 u64 to = min_t(loff_t, i_size_read(inode), 307 - from + vma->vm_end - vma->vm_start); 306 + from + desc->end - desc->start); 308 307 309 308 if (is_sparsed(ni)) { 310 309 /* Allocate clusters for rw map. */ ··· 335 334 } 336 335 } 337 336 338 - err = generic_file_mmap(file, vma); 337 + err = generic_file_mmap_prepare(desc); 339 338 out: 340 339 return err; 341 340 } ··· 1367 1366 #endif 1368 1367 .splice_read = ntfs_file_splice_read, 1369 1368 .splice_write = ntfs_file_splice_write, 1370 - .mmap = ntfs_file_mmap, 1369 + .mmap_prepare = ntfs_file_mmap_prepare, 1371 1370 .open = ntfs_file_open, 1372 1371 .fsync = generic_file_fsync, 1373 1372 .fallocate = ntfs_fallocate,
+2 -2
fs/ocfs2/file.c
··· 2800 2800 */ 2801 2801 const struct file_operations ocfs2_fops = { 2802 2802 .llseek = ocfs2_file_llseek, 2803 - .mmap = ocfs2_mmap, 2803 + .mmap_prepare = ocfs2_mmap_prepare, 2804 2804 .fsync = ocfs2_sync_file, 2805 2805 .release = ocfs2_file_release, 2806 2806 .open = ocfs2_file_open, ··· 2850 2850 */ 2851 2851 const struct file_operations ocfs2_fops_no_plocks = { 2852 2852 .llseek = ocfs2_file_llseek, 2853 - .mmap = ocfs2_mmap, 2853 + .mmap_prepare = ocfs2_mmap_prepare, 2854 2854 .fsync = ocfs2_sync_file, 2855 2855 .release = ocfs2_file_release, 2856 2856 .open = ocfs2_file_open,
+3 -2
fs/ocfs2/mmap.c
··· 159 159 .page_mkwrite = ocfs2_page_mkwrite, 160 160 }; 161 161 162 - int ocfs2_mmap(struct file *file, struct vm_area_struct *vma) 162 + int ocfs2_mmap_prepare(struct vm_area_desc *desc) 163 163 { 164 + struct file *file = desc->file; 164 165 int ret = 0, lock_level = 0; 165 166 166 167 ret = ocfs2_inode_lock_atime(file_inode(file), ··· 172 171 } 173 172 ocfs2_inode_unlock(file_inode(file), lock_level); 174 173 out: 175 - vma->vm_ops = &ocfs2_file_vm_ops; 174 + desc->vm_ops = &ocfs2_file_vm_ops; 176 175 return 0; 177 176 } 178 177
+1 -1
fs/ocfs2/mmap.h
··· 2 2 #ifndef OCFS2_MMAP_H 3 3 #define OCFS2_MMAP_H 4 4 5 - int ocfs2_mmap(struct file *file, struct vm_area_struct *vma); 5 + int ocfs2_mmap_prepare(struct vm_area_desc *desc); 6 6 7 7 #endif /* OCFS2_MMAP_H */
+1 -1
fs/omfs/file.c
··· 333 333 .llseek = generic_file_llseek, 334 334 .read_iter = generic_file_read_iter, 335 335 .write_iter = generic_file_write_iter, 336 - .mmap = generic_file_mmap, 336 + .mmap_prepare = generic_file_mmap_prepare, 337 337 .fsync = generic_file_fsync, 338 338 .splice_read = filemap_splice_read, 339 339 };
+6 -4
fs/orangefs/file.c
··· 398 398 /* 399 399 * Memory map a region of a file. 400 400 */ 401 - static int orangefs_file_mmap(struct file *file, struct vm_area_struct *vma) 401 + static int orangefs_file_mmap_prepare(struct vm_area_desc *desc) 402 402 { 403 + struct file *file = desc->file; 403 404 int ret; 404 405 405 406 ret = orangefs_revalidate_mapping(file_inode(file)); ··· 411 410 "orangefs_file_mmap: called on %pD\n", file); 412 411 413 412 /* set the sequential readahead hint */ 414 - vm_flags_mod(vma, VM_SEQ_READ, VM_RAND_READ); 413 + desc->vm_flags |= VM_SEQ_READ; 414 + desc->vm_flags &= ~VM_RAND_READ; 415 415 416 416 file_accessed(file); 417 - vma->vm_ops = &orangefs_file_vm_ops; 417 + desc->vm_ops = &orangefs_file_vm_ops; 418 418 return 0; 419 419 } 420 420 ··· 576 574 .read_iter = orangefs_file_read_iter, 577 575 .write_iter = orangefs_file_write_iter, 578 576 .lock = orangefs_lock, 579 - .mmap = orangefs_file_mmap, 577 + .mmap_prepare = orangefs_file_mmap_prepare, 580 578 .open = generic_file_open, 581 579 .splice_read = orangefs_file_splice_read, 582 580 .splice_write = iter_file_splice_write,
+1 -1
fs/ramfs/file-mmu.c
··· 41 41 const struct file_operations ramfs_file_operations = { 42 42 .read_iter = generic_file_read_iter, 43 43 .write_iter = generic_file_write_iter, 44 - .mmap = generic_file_mmap, 44 + .mmap_prepare = generic_file_mmap_prepare, 45 45 .fsync = noop_fsync, 46 46 .splice_read = filemap_splice_read, 47 47 .splice_write = iter_file_splice_write,
+6 -6
fs/ramfs/file-nommu.c
··· 28 28 unsigned long len, 29 29 unsigned long pgoff, 30 30 unsigned long flags); 31 - static int ramfs_nommu_mmap(struct file *file, struct vm_area_struct *vma); 31 + static int ramfs_nommu_mmap_prepare(struct vm_area_desc *desc); 32 32 33 33 static unsigned ramfs_mmap_capabilities(struct file *file) 34 34 { ··· 38 38 39 39 const struct file_operations ramfs_file_operations = { 40 40 .mmap_capabilities = ramfs_mmap_capabilities, 41 - .mmap = ramfs_nommu_mmap, 41 + .mmap_prepare = ramfs_nommu_mmap_prepare, 42 42 .get_unmapped_area = ramfs_nommu_get_unmapped_area, 43 43 .read_iter = generic_file_read_iter, 44 44 .write_iter = generic_file_write_iter, ··· 262 262 /* 263 263 * set up a mapping for shared memory segments 264 264 */ 265 - static int ramfs_nommu_mmap(struct file *file, struct vm_area_struct *vma) 265 + static int ramfs_nommu_mmap_prepare(struct vm_area_desc *desc) 266 266 { 267 - if (!is_nommu_shared_mapping(vma->vm_flags)) 267 + if (!is_nommu_shared_mapping(desc->vm_flags)) 268 268 return -ENOSYS; 269 269 270 - file_accessed(file); 271 - vma->vm_ops = &generic_file_vm_ops; 270 + file_accessed(desc->file); 271 + desc->vm_ops = &generic_file_vm_ops; 272 272 return 0; 273 273 }
+1 -1
fs/read_write.c
··· 28 28 const struct file_operations generic_ro_fops = { 29 29 .llseek = generic_file_llseek, 30 30 .read_iter = generic_file_read_iter, 31 - .mmap = generic_file_readonly_mmap, 31 + .mmap_prepare = generic_file_readonly_mmap_prepare, 32 32 .splice_read = filemap_splice_read, 33 33 }; 34 34
+3 -3
fs/romfs/mmap-nommu.c
··· 61 61 * permit a R/O mapping to be made directly through onto an MTD device if 62 62 * possible 63 63 */ 64 - static int romfs_mmap(struct file *file, struct vm_area_struct *vma) 64 + static int romfs_mmap_prepare(struct vm_area_desc *desc) 65 65 { 66 - return is_nommu_shared_mapping(vma->vm_flags) ? 0 : -ENOSYS; 66 + return is_nommu_shared_mapping(desc->vm_flags) ? 0 : -ENOSYS; 67 67 } 68 68 69 69 static unsigned romfs_mmap_capabilities(struct file *file) ··· 79 79 .llseek = generic_file_llseek, 80 80 .read_iter = generic_file_read_iter, 81 81 .splice_read = filemap_splice_read, 82 - .mmap = romfs_mmap, 82 + .mmap_prepare = romfs_mmap_prepare, 83 83 .get_unmapped_area = romfs_get_unmapped_area, 84 84 .mmap_capabilities = romfs_mmap_capabilities, 85 85 };
+6 -6
fs/smb/client/cifsfs.c
··· 1525 1525 .flock = cifs_flock, 1526 1526 .fsync = cifs_fsync, 1527 1527 .flush = cifs_flush, 1528 - .mmap = cifs_file_mmap, 1528 + .mmap_prepare = cifs_file_mmap_prepare, 1529 1529 .splice_read = filemap_splice_read, 1530 1530 .splice_write = iter_file_splice_write, 1531 1531 .llseek = cifs_llseek, ··· 1545 1545 .flock = cifs_flock, 1546 1546 .fsync = cifs_strict_fsync, 1547 1547 .flush = cifs_flush, 1548 - .mmap = cifs_file_strict_mmap, 1548 + .mmap_prepare = cifs_file_strict_mmap_prepare, 1549 1549 .splice_read = filemap_splice_read, 1550 1550 .splice_write = iter_file_splice_write, 1551 1551 .llseek = cifs_llseek, ··· 1565 1565 .flock = cifs_flock, 1566 1566 .fsync = cifs_fsync, 1567 1567 .flush = cifs_flush, 1568 - .mmap = cifs_file_mmap, 1568 + .mmap_prepare = cifs_file_mmap_prepare, 1569 1569 .splice_read = copy_splice_read, 1570 1570 .splice_write = iter_file_splice_write, 1571 1571 .unlocked_ioctl = cifs_ioctl, ··· 1583 1583 .release = cifs_close, 1584 1584 .fsync = cifs_fsync, 1585 1585 .flush = cifs_flush, 1586 - .mmap = cifs_file_mmap, 1586 + .mmap_prepare = cifs_file_mmap_prepare, 1587 1587 .splice_read = filemap_splice_read, 1588 1588 .splice_write = iter_file_splice_write, 1589 1589 .llseek = cifs_llseek, ··· 1601 1601 .release = cifs_close, 1602 1602 .fsync = cifs_strict_fsync, 1603 1603 .flush = cifs_flush, 1604 - .mmap = cifs_file_strict_mmap, 1604 + .mmap_prepare = cifs_file_strict_mmap_prepare, 1605 1605 .splice_read = filemap_splice_read, 1606 1606 .splice_write = iter_file_splice_write, 1607 1607 .llseek = cifs_llseek, ··· 1619 1619 .release = cifs_close, 1620 1620 .fsync = cifs_fsync, 1621 1621 .flush = cifs_flush, 1622 - .mmap = cifs_file_mmap, 1622 + .mmap_prepare = cifs_file_mmap_prepare, 1623 1623 .splice_read = copy_splice_read, 1624 1624 .splice_write = iter_file_splice_write, 1625 1625 .unlocked_ioctl = cifs_ioctl,
+2 -2
fs/smb/client/cifsfs.h
··· 103 103 extern int cifs_fsync(struct file *, loff_t, loff_t, int); 104 104 extern int cifs_strict_fsync(struct file *, loff_t, loff_t, int); 105 105 extern int cifs_flush(struct file *, fl_owner_t id); 106 - extern int cifs_file_mmap(struct file *file, struct vm_area_struct *vma); 107 - extern int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma); 106 + int cifs_file_mmap_prepare(struct vm_area_desc *desc); 107 + int cifs_file_strict_mmap_prepare(struct vm_area_desc *desc); 108 108 extern const struct file_operations cifs_dir_ops; 109 109 extern int cifs_readdir(struct file *file, struct dir_context *ctx); 110 110
+8 -8
fs/smb/client/file.c
··· 2999 2999 .page_mkwrite = cifs_page_mkwrite, 3000 3000 }; 3001 3001 3002 - int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma) 3002 + int cifs_file_strict_mmap_prepare(struct vm_area_desc *desc) 3003 3003 { 3004 3004 int xid, rc = 0; 3005 - struct inode *inode = file_inode(file); 3005 + struct inode *inode = file_inode(desc->file); 3006 3006 3007 3007 xid = get_xid(); 3008 3008 3009 3009 if (!CIFS_CACHE_READ(CIFS_I(inode))) 3010 3010 rc = cifs_zap_mapping(inode); 3011 3011 if (!rc) 3012 - rc = generic_file_mmap(file, vma); 3012 + rc = generic_file_mmap_prepare(desc); 3013 3013 if (!rc) 3014 - vma->vm_ops = &cifs_file_vm_ops; 3014 + desc->vm_ops = &cifs_file_vm_ops; 3015 3015 3016 3016 free_xid(xid); 3017 3017 return rc; 3018 3018 } 3019 3019 3020 - int cifs_file_mmap(struct file *file, struct vm_area_struct *vma) 3020 + int cifs_file_mmap_prepare(struct vm_area_desc *desc) 3021 3021 { 3022 3022 int rc, xid; 3023 3023 3024 3024 xid = get_xid(); 3025 3025 3026 - rc = cifs_revalidate_file(file); 3026 + rc = cifs_revalidate_file(desc->file); 3027 3027 if (rc) 3028 3028 cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n", 3029 3029 rc); 3030 3030 if (!rc) 3031 - rc = generic_file_mmap(file, vma); 3031 + rc = generic_file_mmap_prepare(desc); 3032 3032 if (!rc) 3033 - vma->vm_ops = &cifs_file_vm_ops; 3033 + desc->vm_ops = &cifs_file_vm_ops; 3034 3034 3035 3035 free_xid(xid); 3036 3036 return rc;
+5 -5
fs/ubifs/file.c
··· 1581 1581 .page_mkwrite = ubifs_vm_page_mkwrite, 1582 1582 }; 1583 1583 1584 - static int ubifs_file_mmap(struct file *file, struct vm_area_struct *vma) 1584 + static int ubifs_file_mmap_prepare(struct vm_area_desc *desc) 1585 1585 { 1586 1586 int err; 1587 1587 1588 - err = generic_file_mmap(file, vma); 1588 + err = generic_file_mmap_prepare(desc); 1589 1589 if (err) 1590 1590 return err; 1591 - vma->vm_ops = &ubifs_file_vm_ops; 1591 + desc->vm_ops = &ubifs_file_vm_ops; 1592 1592 1593 1593 if (IS_ENABLED(CONFIG_UBIFS_ATIME_SUPPORT)) 1594 - file_accessed(file); 1594 + file_accessed(desc->file); 1595 1595 1596 1596 return 0; 1597 1597 } ··· 1654 1654 .llseek = generic_file_llseek, 1655 1655 .read_iter = generic_file_read_iter, 1656 1656 .write_iter = ubifs_write_iter, 1657 - .mmap = ubifs_file_mmap, 1657 + .mmap_prepare = ubifs_file_mmap_prepare, 1658 1658 .fsync = ubifs_fsync, 1659 1659 .unlocked_ioctl = ubifs_ioctl, 1660 1660 .splice_read = filemap_splice_read,
+1 -1
fs/ufs/file.c
··· 38 38 .llseek = generic_file_llseek, 39 39 .read_iter = generic_file_read_iter, 40 40 .write_iter = generic_file_write_iter, 41 - .mmap = generic_file_mmap, 41 + .mmap_prepare = generic_file_mmap_prepare, 42 42 .open = generic_file_open, 43 43 .fsync = generic_file_fsync, 44 44 .splice_read = filemap_splice_read,
+4 -4
fs/vboxsf/file.c
··· 165 165 .map_pages = filemap_map_pages, 166 166 }; 167 167 168 - static int vboxsf_file_mmap(struct file *file, struct vm_area_struct *vma) 168 + static int vboxsf_file_mmap_prepare(struct vm_area_desc *desc) 169 169 { 170 170 int err; 171 171 172 - err = generic_file_mmap(file, vma); 172 + err = generic_file_mmap_prepare(desc); 173 173 if (!err) 174 - vma->vm_ops = &vboxsf_file_vm_ops; 174 + desc->vm_ops = &vboxsf_file_vm_ops; 175 175 176 176 return err; 177 177 } ··· 213 213 .llseek = generic_file_llseek, 214 214 .read_iter = generic_file_read_iter, 215 215 .write_iter = generic_file_write_iter, 216 - .mmap = vboxsf_file_mmap, 216 + .mmap_prepare = vboxsf_file_mmap_prepare, 217 217 .open = vboxsf_file_open, 218 218 .release = vboxsf_file_release, 219 219 .fsync = noop_fsync,
+8 -7
fs/xfs/xfs_file.c
··· 1914 1914 }; 1915 1915 1916 1916 STATIC int 1917 - xfs_file_mmap( 1918 - struct file *file, 1919 - struct vm_area_struct *vma) 1917 + xfs_file_mmap_prepare( 1918 + struct vm_area_desc *desc) 1920 1919 { 1920 + struct file *file = desc->file; 1921 1921 struct inode *inode = file_inode(file); 1922 1922 struct xfs_buftarg *target = xfs_inode_buftarg(XFS_I(inode)); 1923 1923 ··· 1925 1925 * We don't support synchronous mappings for non-DAX files and 1926 1926 * for DAX files if underneath dax_device is not synchronous. 1927 1927 */ 1928 - if (!daxdev_mapping_supported(vma, target->bt_daxdev)) 1928 + if (!daxdev_mapping_supported(desc->vm_flags, file_inode(file), 1929 + target->bt_daxdev)) 1929 1930 return -EOPNOTSUPP; 1930 1931 1931 1932 file_accessed(file); 1932 - vma->vm_ops = &xfs_file_vm_ops; 1933 + desc->vm_ops = &xfs_file_vm_ops; 1933 1934 if (IS_DAX(inode)) 1934 - vm_flags_set(vma, VM_HUGEPAGE); 1935 + desc->vm_flags |= VM_HUGEPAGE; 1935 1936 return 0; 1936 1937 } 1937 1938 ··· 1947 1946 #ifdef CONFIG_COMPAT 1948 1947 .compat_ioctl = xfs_file_compat_ioctl, 1949 1948 #endif 1950 - .mmap = xfs_file_mmap, 1949 + .mmap_prepare = xfs_file_mmap_prepare, 1951 1950 .open = xfs_file_open, 1952 1951 .release = xfs_file_release, 1953 1952 .fsync = xfs_file_fsync,
+6 -4
fs/zonefs/file.c
··· 312 312 .page_mkwrite = zonefs_filemap_page_mkwrite, 313 313 }; 314 314 315 - static int zonefs_file_mmap(struct file *file, struct vm_area_struct *vma) 315 + static int zonefs_file_mmap_prepare(struct vm_area_desc *desc) 316 316 { 317 + struct file *file = desc->file; 318 + 317 319 /* 318 320 * Conventional zones accept random writes, so their files can support 319 321 * shared writable mappings. For sequential zone files, only read ··· 323 321 * ordering between msync() and page cache writeback. 324 322 */ 325 323 if (zonefs_inode_is_seq(file_inode(file)) && 326 - (vma->vm_flags & VM_SHARED) && (vma->vm_flags & VM_MAYWRITE)) 324 + (desc->vm_flags & VM_SHARED) && (desc->vm_flags & VM_MAYWRITE)) 327 325 return -EINVAL; 328 326 329 327 file_accessed(file); 330 - vma->vm_ops = &zonefs_file_vm_ops; 328 + desc->vm_ops = &zonefs_file_vm_ops; 331 329 332 330 return 0; 333 331 } ··· 852 850 .open = zonefs_file_open, 853 851 .release = zonefs_file_release, 854 852 .fsync = zonefs_file_fsync, 855 - .mmap = zonefs_file_mmap, 853 + .mmap_prepare = zonefs_file_mmap_prepare, 856 854 .llseek = zonefs_file_llseek, 857 855 .read_iter = zonefs_file_read_iter, 858 856 .write_iter = zonefs_file_write_iter,
+9 -7
include/linux/dax.h
··· 65 65 /* 66 66 * Check if given mapping is supported by the file / underlying device. 67 67 */ 68 - static inline bool daxdev_mapping_supported(struct vm_area_struct *vma, 69 - struct dax_device *dax_dev) 68 + static inline bool daxdev_mapping_supported(vm_flags_t vm_flags, 69 + const struct inode *inode, 70 + struct dax_device *dax_dev) 70 71 { 71 - if (!(vma->vm_flags & VM_SYNC)) 72 + if (!(vm_flags & VM_SYNC)) 72 73 return true; 73 - if (!IS_DAX(file_inode(vma->vm_file))) 74 + if (!IS_DAX(inode)) 74 75 return false; 75 76 return dax_synchronous(dax_dev); 76 77 } ··· 111 110 static inline void set_dax_synchronous(struct dax_device *dax_dev) 112 111 { 113 112 } 114 - static inline bool daxdev_mapping_supported(struct vm_area_struct *vma, 115 - struct dax_device *dax_dev) 113 + static inline bool daxdev_mapping_supported(vm_flags_t vm_flags, 114 + const struct inode *inode, 115 + struct dax_device *dax_dev) 116 116 { 117 - return !(vma->vm_flags & VM_SYNC); 117 + return !(vm_flags & VM_SYNC); 118 118 } 119 119 static inline size_t dax_recovery_write(struct dax_device *dax_dev, 120 120 pgoff_t pgoff, void *addr, size_t bytes, struct iov_iter *i)
+7 -6
include/linux/fs.h
··· 2263 2263 } ____cacheline_aligned; 2264 2264 2265 2265 /* Did the driver provide valid mmap hook configuration? */ 2266 - static inline bool file_has_valid_mmap_hooks(struct file *file) 2266 + static inline bool can_mmap_file(struct file *file) 2267 2267 { 2268 2268 bool has_mmap = file->f_op->mmap; 2269 2269 bool has_mmap_prepare = file->f_op->mmap_prepare; ··· 2279 2279 2280 2280 int compat_vma_mmap_prepare(struct file *file, struct vm_area_struct *vma); 2281 2281 2282 - static inline int call_mmap(struct file *file, struct vm_area_struct *vma) 2282 + static inline int vfs_mmap(struct file *file, struct vm_area_struct *vma) 2283 2283 { 2284 2284 if (file->f_op->mmap_prepare) 2285 2285 return compat_vma_mmap_prepare(file, vma); ··· 2287 2287 return file->f_op->mmap(file, vma); 2288 2288 } 2289 2289 2290 - static inline int __call_mmap_prepare(struct file *file, 2291 - struct vm_area_desc *desc) 2290 + static inline int vfs_mmap_prepare(struct file *file, struct vm_area_desc *desc) 2292 2291 { 2293 2292 return file->f_op->mmap_prepare(desc); 2294 2293 } ··· 3412 3413 extern int sb_set_blocksize(struct super_block *, int); 3413 3414 extern int sb_min_blocksize(struct super_block *, int); 3414 3415 3415 - extern int generic_file_mmap(struct file *, struct vm_area_struct *); 3416 - extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *); 3416 + int generic_file_mmap(struct file *, struct vm_area_struct *); 3417 + int generic_file_mmap_prepare(struct vm_area_desc *desc); 3418 + int generic_file_readonly_mmap(struct file *, struct vm_area_struct *); 3419 + int generic_file_readonly_mmap_prepare(struct vm_area_desc *desc); 3417 3420 extern ssize_t generic_write_checks(struct kiocb *, struct iov_iter *); 3418 3421 int generic_write_checks_count(struct kiocb *iocb, loff_t *count); 3419 3422 extern int generic_write_check_limits(struct file *file, loff_t pos,
+1 -1
ipc/shm.c
··· 602 602 if (ret) 603 603 return ret; 604 604 605 - ret = call_mmap(sfd->file, vma); 605 + ret = vfs_mmap(sfd->file, vma); 606 606 if (ret) { 607 607 __shm_close(sfd); 608 608 return ret;
+29
mm/filemap.c
··· 3814 3814 return 0; 3815 3815 } 3816 3816 3817 + int generic_file_mmap_prepare(struct vm_area_desc *desc) 3818 + { 3819 + struct file *file = desc->file; 3820 + struct address_space *mapping = file->f_mapping; 3821 + 3822 + if (!mapping->a_ops->read_folio) 3823 + return -ENOEXEC; 3824 + file_accessed(file); 3825 + desc->vm_ops = &generic_file_vm_ops; 3826 + return 0; 3827 + } 3828 + 3817 3829 /* 3818 3830 * This is for filesystems which do not implement ->writepage. 3819 3831 */ ··· 3834 3822 if (vma_is_shared_maywrite(vma)) 3835 3823 return -EINVAL; 3836 3824 return generic_file_mmap(file, vma); 3825 + } 3826 + 3827 + int generic_file_readonly_mmap_prepare(struct vm_area_desc *desc) 3828 + { 3829 + if (is_shared_maywrite(desc->vm_flags)) 3830 + return -EINVAL; 3831 + return generic_file_mmap_prepare(desc); 3837 3832 } 3838 3833 #else 3839 3834 vm_fault_t filemap_page_mkwrite(struct vm_fault *vmf) ··· 3851 3832 { 3852 3833 return -ENOSYS; 3853 3834 } 3835 + int generic_file_mmap_prepare(struct vm_area_desc *desc) 3836 + { 3837 + return -ENOSYS; 3838 + } 3854 3839 int generic_file_readonly_mmap(struct file *file, struct vm_area_struct *vma) 3840 + { 3841 + return -ENOSYS; 3842 + } 3843 + int generic_file_readonly_mmap_prepare(struct vm_area_desc *desc) 3855 3844 { 3856 3845 return -ENOSYS; 3857 3846 } ··· 3867 3840 3868 3841 EXPORT_SYMBOL(filemap_page_mkwrite); 3869 3842 EXPORT_SYMBOL(generic_file_mmap); 3843 + EXPORT_SYMBOL(generic_file_mmap_prepare); 3870 3844 EXPORT_SYMBOL(generic_file_readonly_mmap); 3845 + EXPORT_SYMBOL(generic_file_readonly_mmap_prepare); 3871 3846 3872 3847 static struct folio *do_read_cache_folio(struct address_space *mapping, 3873 3848 pgoff_t index, filler_t filler, struct file *file, gfp_t gfp)
+1 -1
mm/internal.h
··· 164 164 */ 165 165 static inline int mmap_file(struct file *file, struct vm_area_struct *vma) 166 166 { 167 - int err = call_mmap(file, vma); 167 + int err = vfs_mmap(file, vma); 168 168 169 169 if (likely(!err)) 170 170 return 0;
+1 -1
mm/mmap.c
··· 475 475 vm_flags &= ~VM_MAYEXEC; 476 476 } 477 477 478 - if (!file_has_valid_mmap_hooks(file)) 478 + if (!can_mmap_file(file)) 479 479 return -ENODEV; 480 480 if (vm_flags & (VM_GROWSDOWN|VM_GROWSUP)) 481 481 return -EINVAL;
+1 -1
mm/nommu.c
··· 719 719 720 720 if (file) { 721 721 /* files must support mmap */ 722 - if (!file->f_op->mmap) 722 + if (!can_mmap_file(file)) 723 723 return -ENODEV; 724 724 725 725 /* work out if what we've got could possibly be shared
+1 -1
mm/vma.c
··· 2569 2569 }; 2570 2570 2571 2571 /* Invoke the hook. */ 2572 - err = __call_mmap_prepare(map->file, &desc); 2572 + err = vfs_mmap_prepare(map->file, &desc); 2573 2573 if (err) 2574 2574 return err; 2575 2575
+27 -7
tools/testing/vma/vma_internal.h
··· 1442 1442 (void)vma; 1443 1443 } 1444 1444 1445 + /* Declared in vma.h. */ 1446 + static inline void set_vma_from_desc(struct vm_area_struct *vma, 1447 + struct vm_area_desc *desc); 1448 + 1449 + static inline struct vm_area_desc *vma_to_desc(struct vm_area_struct *vma, 1450 + struct vm_area_desc *desc); 1451 + 1452 + static int compat_vma_mmap_prepare(struct file *file, 1453 + struct vm_area_struct *vma) 1454 + { 1455 + struct vm_area_desc desc; 1456 + int err; 1457 + 1458 + err = file->f_op->mmap_prepare(vma_to_desc(vma, &desc)); 1459 + if (err) 1460 + return err; 1461 + set_vma_from_desc(vma, &desc); 1462 + 1463 + return 0; 1464 + } 1465 + 1445 1466 /* Did the driver provide valid mmap hook configuration? */ 1446 - static inline bool file_has_valid_mmap_hooks(struct file *file) 1467 + static inline bool can_mmap_file(struct file *file) 1447 1468 { 1448 1469 bool has_mmap = file->f_op->mmap; 1449 1470 bool has_mmap_prepare = file->f_op->mmap_prepare; ··· 1472 1451 /* Hooks are mutually exclusive. */ 1473 1452 if (WARN_ON_ONCE(has_mmap && has_mmap_prepare)) 1474 1453 return false; 1475 - if (WARN_ON_ONCE(!has_mmap && !has_mmap_prepare)) 1454 + if (!has_mmap && !has_mmap_prepare) 1476 1455 return false; 1477 1456 1478 1457 return true; 1479 1458 } 1480 1459 1481 - static inline int call_mmap(struct file *file, struct vm_area_struct *vma) 1460 + static inline int vfs_mmap(struct file *file, struct vm_area_struct *vma) 1482 1461 { 1483 - if (WARN_ON_ONCE(file->f_op->mmap_prepare)) 1484 - return -EINVAL; 1462 + if (file->f_op->mmap_prepare) 1463 + return compat_vma_mmap_prepare(file, vma); 1485 1464 1486 1465 return file->f_op->mmap(file, vma); 1487 1466 } 1488 1467 1489 - static inline int __call_mmap_prepare(struct file *file, 1490 - struct vm_area_desc *desc) 1468 + static inline int vfs_mmap_prepare(struct file *file, struct vm_area_desc *desc) 1491 1469 { 1492 1470 return file->f_op->mmap_prepare(desc); 1493 1471 }