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.

mm: update shmem_[kernel]_file_*() functions to use vma_flags_t

In order to be able to use only vma_flags_t in vm_area_desc we must adjust
shmem file setup functions to operate in terms of vma_flags_t rather than
vm_flags_t.

This patch makes this change and updates all callers to use the new
functions.

No functional changes intended.

[akpm@linux-foundation.org: comment fixes, per Baolin]
Link: https://lkml.kernel.org/r/736febd280eb484d79cef5cf55b8a6f79ad832d2.1769097829.git.lorenzo.stoakes@oracle.com
Signed-off-by: Lorenzo Stoakes <lorenzo.stoakes@oracle.com>
Reviewed-by: Baolin Wang <baolin.wang@linux.alibaba.com>
Reviewed-by: Jarkko Sakkinen <jarkko@kernel.org>
Reviewed-by: Liam R. Howlett <Liam.Howlett@oracle.com>
Cc: Barry Song <baohua@kernel.org>
Cc: David Hildenbrand <david@kernel.org>
Cc: Dev Jain <dev.jain@arm.com>
Cc: Jason Gunthorpe <jgg@nvidia.com>
Cc: Suren Baghdasaryan <surenb@google.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Zi Yan <ziy@nvidia.com>
Cc: "Darrick J. Wong" <djwong@kernel.org>
Cc: Damien Le Moal <dlemoal@kernel.org>
Cc: Yury Norov <ynorov@nvidia.com>
Cc: Chris Mason <clm@fb.com>
Cc: Pedro Falcato <pfalcato@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

authored by

Lorenzo Stoakes and committed by
Andrew Morton 590d356a fd3196ee

+57 -49
+1 -1
arch/x86/kernel/cpu/sgx/ioctl.c
··· 83 83 encl_size = secs->size + PAGE_SIZE; 84 84 85 85 backing = shmem_file_setup("SGX backing", encl_size + (encl_size >> 5), 86 - VM_NORESERVE); 86 + mk_vma_flags(VMA_NORESERVE_BIT)); 87 87 if (IS_ERR(backing)) { 88 88 ret = PTR_ERR(backing); 89 89 goto err_out_shrink;
+3 -2
drivers/gpu/drm/drm_gem.c
··· 130 130 struct vfsmount *gemfs) 131 131 { 132 132 struct file *filp; 133 + const vma_flags_t flags = mk_vma_flags(VMA_NORESERVE_BIT); 133 134 134 135 drm_gem_private_object_init(dev, obj, size); 135 136 136 137 if (gemfs) 137 138 filp = shmem_file_setup_with_mnt(gemfs, "drm mm object", size, 138 - VM_NORESERVE); 139 + flags); 139 140 else 140 - filp = shmem_file_setup("drm mm object", size, VM_NORESERVE); 141 + filp = shmem_file_setup("drm mm object", size, flags); 141 142 142 143 if (IS_ERR(filp)) 143 144 return PTR_ERR(filp);
+1 -1
drivers/gpu/drm/i915/gem/i915_gem_shmem.c
··· 496 496 struct drm_gem_object *obj, 497 497 resource_size_t size) 498 498 { 499 - unsigned long flags = VM_NORESERVE; 499 + const vma_flags_t flags = mk_vma_flags(VMA_NORESERVE_BIT); 500 500 struct file *filp; 501 501 502 502 drm_gem_private_object_init(&i915->drm, obj, size);
+2 -1
drivers/gpu/drm/i915/gem/i915_gem_ttm.c
··· 200 200 struct address_space *mapping; 201 201 gfp_t mask; 202 202 203 - filp = shmem_file_setup("i915-shmem-tt", size, VM_NORESERVE); 203 + filp = shmem_file_setup("i915-shmem-tt", size, 204 + mk_vma_flags(VMA_NORESERVE_BIT)); 204 205 if (IS_ERR(filp)) 205 206 return PTR_ERR(filp); 206 207
+2 -1
drivers/gpu/drm/i915/gt/shmem_utils.c
··· 19 19 struct file *file; 20 20 int err; 21 21 22 - file = shmem_file_setup(name, PAGE_ALIGN(len), VM_NORESERVE); 22 + file = shmem_file_setup(name, PAGE_ALIGN(len), 23 + mk_vma_flags(VMA_NORESERVE_BIT)); 23 24 if (IS_ERR(file)) 24 25 return file; 25 26
+1 -1
drivers/gpu/drm/ttm/tests/ttm_tt_test.c
··· 143 143 err = ttm_tt_init(tt, bo, 0, caching, 0); 144 144 KUNIT_ASSERT_EQ(test, err, 0); 145 145 146 - shmem = shmem_file_setup("ttm swap", BO_SIZE, 0); 146 + shmem = shmem_file_setup("ttm swap", BO_SIZE, EMPTY_VMA_FLAGS); 147 147 tt->swap_storage = shmem; 148 148 149 149 ttm_tt_fini(tt);
+2 -1
drivers/gpu/drm/ttm/ttm_backup.c
··· 178 178 */ 179 179 struct file *ttm_backup_shmem_create(loff_t size) 180 180 { 181 - return shmem_file_setup("ttm shmem backup", size, 0); 181 + return shmem_file_setup("ttm shmem backup", size, 182 + EMPTY_VMA_FLAGS); 182 183 }
+1 -1
drivers/gpu/drm/ttm/ttm_tt.c
··· 330 330 struct page *to_page; 331 331 int i, ret; 332 332 333 - swap_storage = shmem_file_setup("ttm swap", size, 0); 333 + swap_storage = shmem_file_setup("ttm swap", size, EMPTY_VMA_FLAGS); 334 334 if (IS_ERR(swap_storage)) { 335 335 pr_err("Failed allocating swap storage\n"); 336 336 return PTR_ERR(swap_storage);
+2 -1
fs/xfs/scrub/xfile.c
··· 61 61 if (!xf) 62 62 return -ENOMEM; 63 63 64 - xf->file = shmem_kernel_file_setup(description, isize, VM_NORESERVE); 64 + xf->file = shmem_kernel_file_setup(description, isize, 65 + mk_vma_flags(VMA_NORESERVE_BIT)); 65 66 if (IS_ERR(xf->file)) { 66 67 error = PTR_ERR(xf->file); 67 68 goto out_xfile;
+1 -1
fs/xfs/xfs_buf_mem.c
··· 62 62 if (!btp) 63 63 return -ENOMEM; 64 64 65 - file = shmem_kernel_file_setup(descr, 0, 0); 65 + file = shmem_kernel_file_setup(descr, 0, EMPTY_VMA_FLAGS); 66 66 if (IS_ERR(file)) { 67 67 error = PTR_ERR(file); 68 68 goto out_free_btp;
+3 -5
include/linux/shmem_fs.h
··· 102 102 extern const struct fs_parameter_spec shmem_fs_parameters[]; 103 103 extern void shmem_init(void); 104 104 extern int shmem_init_fs_context(struct fs_context *fc); 105 - extern struct file *shmem_file_setup(const char *name, 106 - loff_t size, unsigned long flags); 107 - extern struct file *shmem_kernel_file_setup(const char *name, loff_t size, 108 - unsigned long flags); 105 + struct file *shmem_file_setup(const char *name, loff_t size, vma_flags_t flags); 106 + struct file *shmem_kernel_file_setup(const char *name, loff_t size, vma_flags_t vma_flags); 109 107 extern struct file *shmem_file_setup_with_mnt(struct vfsmount *mnt, 110 - const char *name, loff_t size, unsigned long flags); 108 + const char *name, loff_t size, vma_flags_t flags); 111 109 int shmem_zero_setup(struct vm_area_struct *vma); 112 110 int shmem_zero_setup_desc(struct vm_area_desc *desc); 113 111 extern unsigned long shmem_get_unmapped_area(struct file *, unsigned long addr,
+2 -4
ipc/shm.c
··· 708 708 struct shmid_kernel *shp; 709 709 size_t numpages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT; 710 710 const bool has_no_reserve = shmflg & SHM_NORESERVE; 711 + vma_flags_t acctflag = EMPTY_VMA_FLAGS; 711 712 struct file *file; 712 713 char name[13]; 713 714 ··· 739 738 740 739 sprintf(name, "SYSV%08x", key); 741 740 if (shmflg & SHM_HUGETLB) { 742 - vma_flags_t acctflag = EMPTY_VMA_FLAGS; 743 741 struct hstate *hs; 744 742 size_t hugesize; 745 743 ··· 755 755 file = hugetlb_file_setup(name, hugesize, acctflag, 756 756 HUGETLB_SHMFS_INODE, (shmflg >> SHM_HUGE_SHIFT) & SHM_HUGE_MASK); 757 757 } else { 758 - vm_flags_t acctflag = 0; 759 - 760 758 /* 761 759 * Do not allow no accounting for OVERCOMMIT_NEVER, even 762 760 * if it's asked for. 763 761 */ 764 762 if (has_no_reserve && sysctl_overcommit_memory != OVERCOMMIT_NEVER) 765 - acctflag = VM_NORESERVE; 763 + vma_flags_set(&acctflag, VMA_NORESERVE_BIT); 766 764 file = shmem_kernel_file_setup(name, size, acctflag); 767 765 } 768 766 error = PTR_ERR(file);
+1 -1
mm/memfd.c
··· 468 468 (flags >> MFD_HUGE_SHIFT) & 469 469 MFD_HUGE_MASK); 470 470 } else { 471 - file = shmem_file_setup(name, 0, VM_NORESERVE); 471 + file = shmem_file_setup(name, 0, mk_vma_flags(VMA_NORESERVE_BIT)); 472 472 } 473 473 if (IS_ERR(file)) 474 474 return file;
+34 -27
mm/shmem.c
··· 3056 3056 } 3057 3057 3058 3058 static struct inode *__shmem_get_inode(struct mnt_idmap *idmap, 3059 - struct super_block *sb, 3060 - struct inode *dir, umode_t mode, 3061 - dev_t dev, unsigned long flags) 3059 + struct super_block *sb, 3060 + struct inode *dir, umode_t mode, 3061 + dev_t dev, vma_flags_t flags) 3062 3062 { 3063 3063 struct inode *inode; 3064 3064 struct shmem_inode_info *info; ··· 3086 3086 spin_lock_init(&info->lock); 3087 3087 atomic_set(&info->stop_eviction, 0); 3088 3088 info->seals = F_SEAL_SEAL; 3089 - info->flags = (flags & VM_NORESERVE) ? SHMEM_F_NORESERVE : 0; 3089 + info->flags = vma_flags_test(&flags, VMA_NORESERVE_BIT) 3090 + ? SHMEM_F_NORESERVE : 0; 3090 3091 info->i_crtime = inode_get_mtime(inode); 3091 3092 info->fsflags = (dir == NULL) ? 0 : 3092 3093 SHMEM_I(dir)->fsflags & SHMEM_FL_INHERITED; ··· 3140 3139 #ifdef CONFIG_TMPFS_QUOTA 3141 3140 static struct inode *shmem_get_inode(struct mnt_idmap *idmap, 3142 3141 struct super_block *sb, struct inode *dir, 3143 - umode_t mode, dev_t dev, unsigned long flags) 3142 + umode_t mode, dev_t dev, vma_flags_t flags) 3144 3143 { 3145 3144 int err; 3146 3145 struct inode *inode; ··· 3166 3165 return ERR_PTR(err); 3167 3166 } 3168 3167 #else 3169 - static inline struct inode *shmem_get_inode(struct mnt_idmap *idmap, 3168 + static struct inode *shmem_get_inode(struct mnt_idmap *idmap, 3170 3169 struct super_block *sb, struct inode *dir, 3171 - umode_t mode, dev_t dev, unsigned long flags) 3170 + umode_t mode, dev_t dev, vma_flags_t flags) 3172 3171 { 3173 3172 return __shmem_get_inode(idmap, sb, dir, mode, dev, flags); 3174 3173 } ··· 3875 3874 if (!generic_ci_validate_strict_name(dir, &dentry->d_name)) 3876 3875 return -EINVAL; 3877 3876 3878 - inode = shmem_get_inode(idmap, dir->i_sb, dir, mode, dev, VM_NORESERVE); 3877 + inode = shmem_get_inode(idmap, dir->i_sb, dir, mode, dev, 3878 + mk_vma_flags(VMA_NORESERVE_BIT)); 3879 3879 if (IS_ERR(inode)) 3880 3880 return PTR_ERR(inode); 3881 3881 ··· 3911 3909 struct inode *inode; 3912 3910 int error; 3913 3911 3914 - inode = shmem_get_inode(idmap, dir->i_sb, dir, mode, 0, VM_NORESERVE); 3912 + inode = shmem_get_inode(idmap, dir->i_sb, dir, mode, 0, 3913 + mk_vma_flags(VMA_NORESERVE_BIT)); 3915 3914 if (IS_ERR(inode)) { 3916 3915 error = PTR_ERR(inode); 3917 3916 goto err_out; ··· 4109 4106 return -ENAMETOOLONG; 4110 4107 4111 4108 inode = shmem_get_inode(idmap, dir->i_sb, dir, S_IFLNK | 0777, 0, 4112 - VM_NORESERVE); 4109 + mk_vma_flags(VMA_NORESERVE_BIT)); 4113 4110 if (IS_ERR(inode)) 4114 4111 return PTR_ERR(inode); 4115 4112 ··· 5110 5107 #endif /* CONFIG_TMPFS_QUOTA */ 5111 5108 5112 5109 inode = shmem_get_inode(&nop_mnt_idmap, sb, NULL, 5113 - S_IFDIR | sbinfo->mode, 0, VM_NORESERVE); 5110 + S_IFDIR | sbinfo->mode, 0, 5111 + mk_vma_flags(VMA_NORESERVE_BIT)); 5114 5112 if (IS_ERR(inode)) { 5115 5113 error = PTR_ERR(inode); 5116 5114 goto failed; ··· 5811 5807 5812 5808 static inline struct inode *shmem_get_inode(struct mnt_idmap *idmap, 5813 5809 struct super_block *sb, struct inode *dir, 5814 - umode_t mode, dev_t dev, unsigned long flags) 5810 + umode_t mode, dev_t dev, vma_flags_t flags) 5815 5811 { 5816 5812 struct inode *inode = ramfs_get_inode(sb, dir, mode, dev); 5817 5813 return inode ? inode : ERR_PTR(-ENOSPC); ··· 5822 5818 /* common code */ 5823 5819 5824 5820 static struct file *__shmem_file_setup(struct vfsmount *mnt, const char *name, 5825 - loff_t size, unsigned long vm_flags, 5821 + loff_t size, vma_flags_t flags, 5826 5822 unsigned int i_flags) 5827 5823 { 5828 - unsigned long flags = (vm_flags & VM_NORESERVE) ? SHMEM_F_NORESERVE : 0; 5824 + const unsigned long shmem_flags = 5825 + vma_flags_test(&flags, VMA_NORESERVE_BIT) ? SHMEM_F_NORESERVE : 0; 5829 5826 struct inode *inode; 5830 5827 struct file *res; 5831 5828 ··· 5839 5834 if (is_idmapped_mnt(mnt)) 5840 5835 return ERR_PTR(-EINVAL); 5841 5836 5842 - if (shmem_acct_size(flags, size)) 5837 + if (shmem_acct_size(shmem_flags, size)) 5843 5838 return ERR_PTR(-ENOMEM); 5844 5839 5845 5840 inode = shmem_get_inode(&nop_mnt_idmap, mnt->mnt_sb, NULL, 5846 - S_IFREG | S_IRWXUGO, 0, vm_flags); 5841 + S_IFREG | S_IRWXUGO, 0, flags); 5847 5842 if (IS_ERR(inode)) { 5848 - shmem_unacct_size(flags, size); 5843 + shmem_unacct_size(shmem_flags, size); 5849 5844 return ERR_CAST(inode); 5850 5845 } 5851 5846 inode->i_flags |= i_flags; ··· 5868 5863 * checks are provided at the key or shm level rather than the inode. 5869 5864 * @name: name for dentry (to be seen in /proc/<pid>/maps) 5870 5865 * @size: size to be set for the file 5871 - * @flags: VM_NORESERVE suppresses pre-accounting of the entire object size 5866 + * @flags: VMA_NORESERVE_BIT suppresses pre-accounting of the entire object size 5872 5867 */ 5873 - struct file *shmem_kernel_file_setup(const char *name, loff_t size, unsigned long flags) 5868 + struct file *shmem_kernel_file_setup(const char *name, loff_t size, 5869 + vma_flags_t flags) 5874 5870 { 5875 5871 return __shmem_file_setup(shm_mnt, name, size, flags, S_PRIVATE); 5876 5872 } ··· 5881 5875 * shmem_file_setup - get an unlinked file living in tmpfs 5882 5876 * @name: name for dentry (to be seen in /proc/<pid>/maps) 5883 5877 * @size: size to be set for the file 5884 - * @flags: VM_NORESERVE suppresses pre-accounting of the entire object size 5878 + * @flags: VMA_NORESERVE_BIT suppresses pre-accounting of the entire object size 5885 5879 */ 5886 - struct file *shmem_file_setup(const char *name, loff_t size, unsigned long flags) 5880 + struct file *shmem_file_setup(const char *name, loff_t size, vma_flags_t flags) 5887 5881 { 5888 5882 return __shmem_file_setup(shm_mnt, name, size, flags, 0); 5889 5883 } ··· 5894 5888 * @mnt: the tmpfs mount where the file will be created 5895 5889 * @name: name for dentry (to be seen in /proc/<pid>/maps) 5896 5890 * @size: size to be set for the file 5897 - * @flags: VM_NORESERVE suppresses pre-accounting of the entire object size 5891 + * @flags: VMA_NORESERVE_BIT suppresses pre-accounting of the entire object size 5898 5892 */ 5899 5893 struct file *shmem_file_setup_with_mnt(struct vfsmount *mnt, const char *name, 5900 - loff_t size, unsigned long flags) 5894 + loff_t size, vma_flags_t flags) 5901 5895 { 5902 5896 return __shmem_file_setup(mnt, name, size, flags, 0); 5903 5897 } 5904 5898 EXPORT_SYMBOL_GPL(shmem_file_setup_with_mnt); 5905 5899 5906 - static struct file *__shmem_zero_setup(unsigned long start, unsigned long end, vm_flags_t vm_flags) 5900 + static struct file *__shmem_zero_setup(unsigned long start, unsigned long end, 5901 + vma_flags_t flags) 5907 5902 { 5908 5903 loff_t size = end - start; 5909 5904 ··· 5914 5907 * accessible to the user through its mapping, use S_PRIVATE flag to 5915 5908 * bypass file security, in the same way as shmem_kernel_file_setup(). 5916 5909 */ 5917 - return shmem_kernel_file_setup("dev/zero", size, vm_flags); 5910 + return shmem_kernel_file_setup("dev/zero", size, flags); 5918 5911 } 5919 5912 5920 5913 /** ··· 5924 5917 */ 5925 5918 int shmem_zero_setup(struct vm_area_struct *vma) 5926 5919 { 5927 - struct file *file = __shmem_zero_setup(vma->vm_start, vma->vm_end, vma->vm_flags); 5920 + struct file *file = __shmem_zero_setup(vma->vm_start, vma->vm_end, vma->flags); 5928 5921 5929 5922 if (IS_ERR(file)) 5930 5923 return PTR_ERR(file); ··· 5945 5938 */ 5946 5939 int shmem_zero_setup_desc(struct vm_area_desc *desc) 5947 5940 { 5948 - struct file *file = __shmem_zero_setup(desc->start, desc->end, desc->vm_flags); 5941 + struct file *file = __shmem_zero_setup(desc->start, desc->end, desc->vma_flags); 5949 5942 5950 5943 if (IS_ERR(file)) 5951 5944 return PTR_ERR(file);
+1 -1
security/keys/big_key.c
··· 103 103 0, enckey); 104 104 105 105 /* save aligned data to file */ 106 - file = shmem_kernel_file_setup("", enclen, 0); 106 + file = shmem_kernel_file_setup("", enclen, EMPTY_VMA_FLAGS); 107 107 if (IS_ERR(file)) { 108 108 ret = PTR_ERR(file); 109 109 goto err_enckey;