+11

Documentation/filesystems/porting.rst

reviewed

··· 1340 1340 support for leases. When set to NULL, the kernel will now return -EINVAL to 1341 1341 attempts to set a lease. Filesystems that wish to use the kernel-internal lease 1342 1342 implementation should set it to generic_setlease(). 1343 1343 + 1344 1344 + --- 1345 1345 + 1346 1346 + **mandatory** 1347 1347 + 1348 1348 + fs/namei.c primitives that consume filesystem references (do_renameat2(), 1349 1349 + do_linkat(), do_symlinkat(), do_mkdirat(), do_mknodat(), do_unlinkat() 1350 1350 + and do_rmdir()) are gone; they are replaced with non-consuming analogues 1351 1351 + (filename_renameat2(), etc.) 1352 1352 + Callers are adjusted - responsibility for dropping the filenames belongs 1353 1353 + to them now.

+11 -23

arch/alpha/kernel/osf_sys.c

reviewed

··· 454 454 osf_ufs_mount(const char __user *dirname, 455 455 struct ufs_args __user *args, int flags) 456 456 { 457 457 - int retval; 458 458 - struct cdfs_args tmp; 459 459 - struct filename *devname; 457 457 + struct ufs_args tmp; 458 458 + char *devname __free(kfree) = NULL; 460 459 461 461 - retval = -EFAULT; 462 460 if (copy_from_user(&tmp, args, sizeof(tmp))) 463 463 - goto out; 464 464 - devname = getname(tmp.devname); 465 465 - retval = PTR_ERR(devname); 461 461 + return -EFAULT; 462 462 + devname = strndup_user(tmp.devname, PATH_MAX); 466 463 if (IS_ERR(devname)) 467 467 - goto out; 468 468 - retval = do_mount(devname->name, dirname, "ext2", flags, NULL); 469 469 - putname(devname); 470 470 - out: 471 471 - return retval; 464 464 + return PTR_ERR(devname); 465 465 + return do_mount(devname, dirname, "ext2", flags, NULL); 472 466 } 473 467 474 468 static int 475 469 osf_cdfs_mount(const char __user *dirname, 476 470 struct cdfs_args __user *args, int flags) 477 471 { 478 478 - int retval; 479 472 struct cdfs_args tmp; 480 480 - struct filename *devname; 473 473 + char *devname __free(kfree) = NULL; 481 474 482 482 - retval = -EFAULT; 483 475 if (copy_from_user(&tmp, args, sizeof(tmp))) 484 484 - goto out; 485 485 - devname = getname(tmp.devname); 486 486 - retval = PTR_ERR(devname); 476 476 + return -EFAULT; 477 477 + devname = strndup_user(tmp.devname, PATH_MAX); 487 478 if (IS_ERR(devname)) 488 488 - goto out; 489 489 - retval = do_mount(devname->name, dirname, "iso9660", flags, NULL); 490 490 - putname(devname); 491 491 - out: 492 492 - return retval; 479 479 + return PTR_ERR(devname); 480 480 + return do_mount(devname, dirname, "iso9660", flags, NULL); 493 481 } 494 482 495 483 static int

+2 -1

fs/coredump.c

reviewed

··· 895 895 * privs and don't want to unlink another user's coredump. 896 896 */ 897 897 if (!coredump_force_suid_safe(cprm)) { 898 898 + CLASS(filename_kernel, name)(cn->corename); 898 899 /* 899 900 * If it doesn't exist, that's fine. If there's some 900 901 * other problem, we'll catch it at the filp_open(). 901 902 */ 902 902 - do_unlinkat(AT_FDCWD, getname_kernel(cn->corename)); 903 903 + filename_unlinkat(AT_FDCWD, name); 903 904 } 904 905 905 906 /*

+1 -7

fs/dcache.c

reviewed

··· 3297 3297 runtime_const_init(ptr, dentry_hashtable); 3298 3298 } 3299 3299 3300 3300 - /* SLAB cache for __getname() consumers */ 3301 3301 - struct kmem_cache *names_cachep __ro_after_init; 3302 3302 - EXPORT_SYMBOL(names_cachep); 3303 3303 - 3304 3300 void __init vfs_caches_init_early(void) 3305 3301 { 3306 3302 int i; ··· 3310 3314 3311 3315 void __init vfs_caches_init(void) 3312 3316 { 3313 3313 - names_cachep = kmem_cache_create_usercopy("names_cache", PATH_MAX, 0, 3314 3314 - SLAB_HWCACHE_ALIGN|SLAB_PANIC, 0, PATH_MAX, NULL); 3315 3315 - 3317 3317 + filename_init(); 3316 3318 dcache_init(); 3317 3319 inode_init(); 3318 3320 files_init();

+54 -124

fs/exec.c

reviewed

··· 777 777 return ERR_PTR(-EINVAL); 778 778 if (flags & AT_SYMLINK_NOFOLLOW) 779 779 open_exec_flags.lookup_flags &= ~LOOKUP_FOLLOW; 780 780 - if (flags & AT_EMPTY_PATH) 781 781 - open_exec_flags.lookup_flags |= LOOKUP_EMPTY; 782 780 783 783 - file = do_filp_open(fd, name, &open_exec_flags); 781 781 + file = do_file_open(fd, name, &open_exec_flags); 784 782 if (IS_ERR(file)) 785 783 return file; 786 784 ··· 813 815 */ 814 816 struct file *open_exec(const char *name) 815 817 { 816 816 - struct filename *filename = getname_kernel(name); 817 817 - struct file *f = ERR_CAST(filename); 818 818 - 819 819 - if (!IS_ERR(filename)) { 820 820 - f = do_open_execat(AT_FDCWD, filename, 0); 821 821 - putname(filename); 822 822 - } 823 823 - return f; 818 818 + CLASS(filename_kernel, filename)(name); 819 819 + return do_open_execat(AT_FDCWD, filename, 0); 824 820 } 825 821 EXPORT_SYMBOL(open_exec); 826 822 ··· 1463 1471 return ERR_PTR(retval); 1464 1472 } 1465 1473 1474 1474 + DEFINE_CLASS(bprm, struct linux_binprm *, if (!IS_ERR(_T)) free_bprm(_T), 1475 1475 + alloc_bprm(fd, name, flags), int fd, struct filename *name, int flags) 1476 1476 + 1466 1477 int bprm_change_interp(const char *interp, struct linux_binprm *bprm) 1467 1478 { 1468 1479 /* If a binfmt changed the interp, free it first. */ ··· 1780 1785 struct user_arg_ptr envp, 1781 1786 int flags) 1782 1787 { 1783 1783 - struct linux_binprm *bprm; 1784 1788 int retval; 1785 1785 - 1786 1786 - if (IS_ERR(filename)) 1787 1787 - return PTR_ERR(filename); 1788 1789 1789 1790 /* 1790 1791 * We move the actual failure in case of RLIMIT_NPROC excess from ··· 1789 1798 * whether NPROC limit is still exceeded. 1790 1799 */ 1791 1800 if ((current->flags & PF_NPROC_EXCEEDED) && 1792 1792 - is_rlimit_overlimit(current_ucounts(), UCOUNT_RLIMIT_NPROC, rlimit(RLIMIT_NPROC))) { 1793 1793 - retval = -EAGAIN; 1794 1794 - goto out_ret; 1795 1795 - } 1801 1801 + is_rlimit_overlimit(current_ucounts(), UCOUNT_RLIMIT_NPROC, rlimit(RLIMIT_NPROC))) 1802 1802 + return -EAGAIN; 1796 1803 1797 1804 /* We're below the limit (still or again), so we don't want to make 1798 1805 * further execve() calls fail. */ 1799 1806 current->flags &= ~PF_NPROC_EXCEEDED; 1800 1807 1801 1801 - bprm = alloc_bprm(fd, filename, flags); 1802 1802 - if (IS_ERR(bprm)) { 1803 1803 - retval = PTR_ERR(bprm); 1804 1804 - goto out_ret; 1805 1805 - } 1808 1808 + CLASS(bprm, bprm)(fd, filename, flags); 1809 1809 + if (IS_ERR(bprm)) 1810 1810 + return PTR_ERR(bprm); 1806 1811 1807 1812 retval = count(argv, MAX_ARG_STRINGS); 1808 1813 if (retval < 0) 1809 1809 - goto out_free; 1814 1814 + return retval; 1810 1815 bprm->argc = retval; 1811 1816 1812 1817 retval = count(envp, MAX_ARG_STRINGS); 1813 1818 if (retval < 0) 1814 1814 - goto out_free; 1819 1819 + return retval; 1815 1820 bprm->envc = retval; 1816 1821 1817 1822 retval = bprm_stack_limits(bprm); 1818 1823 if (retval < 0) 1819 1819 - goto out_free; 1824 1824 + return retval; 1820 1825 1821 1826 retval = copy_string_kernel(bprm->filename, bprm); 1822 1827 if (retval < 0) 1823 1823 - goto out_free; 1828 1828 + return retval; 1824 1829 bprm->exec = bprm->p; 1825 1830 1826 1831 retval = copy_strings(bprm->envc, envp, bprm); 1827 1832 if (retval < 0) 1828 1828 - goto out_free; 1833 1833 + return retval; 1829 1834 1830 1835 retval = copy_strings(bprm->argc, argv, bprm); 1831 1836 if (retval < 0) 1832 1832 - goto out_free; 1837 1837 + return retval; 1833 1838 1834 1839 /* 1835 1840 * When argv is empty, add an empty string ("") as argv[0] to ··· 1836 1849 if (bprm->argc == 0) { 1837 1850 retval = copy_string_kernel("", bprm); 1838 1851 if (retval < 0) 1839 1839 - goto out_free; 1852 1852 + return retval; 1840 1853 bprm->argc = 1; 1841 1854 1842 1855 pr_warn_once("process '%s' launched '%s' with NULL argv: empty string added\n", 1843 1856 current->comm, bprm->filename); 1844 1857 } 1845 1858 1846 1846 - retval = bprm_execve(bprm); 1847 1847 - out_free: 1848 1848 - free_bprm(bprm); 1849 1849 - 1850 1850 - out_ret: 1851 1851 - putname(filename); 1852 1852 - return retval; 1859 1859 + return bprm_execve(bprm); 1853 1860 } 1854 1861 1855 1862 int kernel_execve(const char *kernel_filename, 1856 1863 const char *const *argv, const char *const *envp) 1857 1864 { 1858 1858 - struct filename *filename; 1859 1859 - struct linux_binprm *bprm; 1860 1860 - int fd = AT_FDCWD; 1861 1865 int retval; 1862 1866 1863 1867 /* It is non-sense for kernel threads to call execve */ 1864 1868 if (WARN_ON_ONCE(current->flags & PF_KTHREAD)) 1865 1869 return -EINVAL; 1866 1870 1867 1867 - filename = getname_kernel(kernel_filename); 1868 1868 - if (IS_ERR(filename)) 1869 1869 - return PTR_ERR(filename); 1870 1870 - 1871 1871 - bprm = alloc_bprm(fd, filename, 0); 1872 1872 - if (IS_ERR(bprm)) { 1873 1873 - retval = PTR_ERR(bprm); 1874 1874 - goto out_ret; 1875 1875 - } 1871 1871 + CLASS(filename_kernel, filename)(kernel_filename); 1872 1872 + CLASS(bprm, bprm)(AT_FDCWD, filename, 0); 1873 1873 + if (IS_ERR(bprm)) 1874 1874 + return PTR_ERR(bprm); 1876 1875 1877 1876 retval = count_strings_kernel(argv); 1878 1877 if (WARN_ON_ONCE(retval == 0)) 1879 1879 - retval = -EINVAL; 1878 1878 + return -EINVAL; 1880 1879 if (retval < 0) 1881 1881 - goto out_free; 1880 1880 + return retval; 1882 1881 bprm->argc = retval; 1883 1882 1884 1883 retval = count_strings_kernel(envp); 1885 1884 if (retval < 0) 1886 1886 - goto out_free; 1885 1885 + return retval; 1887 1886 bprm->envc = retval; 1888 1887 1889 1888 retval = bprm_stack_limits(bprm); 1890 1889 if (retval < 0) 1891 1891 - goto out_free; 1890 1890 + return retval; 1892 1891 1893 1892 retval = copy_string_kernel(bprm->filename, bprm); 1894 1893 if (retval < 0) 1895 1895 - goto out_free; 1894 1894 + return retval; 1896 1895 bprm->exec = bprm->p; 1897 1896 1898 1897 retval = copy_strings_kernel(bprm->envc, envp, bprm); 1899 1898 if (retval < 0) 1900 1900 - goto out_free; 1899 1899 + return retval; 1901 1900 1902 1901 retval = copy_strings_kernel(bprm->argc, argv, bprm); 1903 1902 if (retval < 0) 1904 1904 - goto out_free; 1903 1903 + return retval; 1905 1904 1906 1906 - retval = bprm_execve(bprm); 1907 1907 - out_free: 1908 1908 - free_bprm(bprm); 1909 1909 - out_ret: 1910 1910 - putname(filename); 1911 1911 - return retval; 1905 1905 + return bprm_execve(bprm); 1912 1906 } 1913 1913 - 1914 1914 - static int do_execve(struct filename *filename, 1915 1915 - const char __user *const __user *__argv, 1916 1916 - const char __user *const __user *__envp) 1917 1917 - { 1918 1918 - struct user_arg_ptr argv = { .ptr.native = __argv }; 1919 1919 - struct user_arg_ptr envp = { .ptr.native = __envp }; 1920 1920 - return do_execveat_common(AT_FDCWD, filename, argv, envp, 0); 1921 1921 - } 1922 1922 - 1923 1923 - static int do_execveat(int fd, struct filename *filename, 1924 1924 - const char __user *const __user *__argv, 1925 1925 - const char __user *const __user *__envp, 1926 1926 - int flags) 1927 1927 - { 1928 1928 - struct user_arg_ptr argv = { .ptr.native = __argv }; 1929 1929 - struct user_arg_ptr envp = { .ptr.native = __envp }; 1930 1930 - 1931 1931 - return do_execveat_common(fd, filename, argv, envp, flags); 1932 1932 - } 1933 1933 - 1934 1934 - #ifdef CONFIG_COMPAT 1935 1935 - static int compat_do_execve(struct filename *filename, 1936 1936 - const compat_uptr_t __user *__argv, 1937 1937 - const compat_uptr_t __user *__envp) 1938 1938 - { 1939 1939 - struct user_arg_ptr argv = { 1940 1940 - .is_compat = true, 1941 1941 - .ptr.compat = __argv, 1942 1942 - }; 1943 1943 - struct user_arg_ptr envp = { 1944 1944 - .is_compat = true, 1945 1945 - .ptr.compat = __envp, 1946 1946 - }; 1947 1947 - return do_execveat_common(AT_FDCWD, filename, argv, envp, 0); 1948 1948 - } 1949 1949 - 1950 1950 - static int compat_do_execveat(int fd, struct filename *filename, 1951 1951 - const compat_uptr_t __user *__argv, 1952 1952 - const compat_uptr_t __user *__envp, 1953 1953 - int flags) 1954 1954 - { 1955 1955 - struct user_arg_ptr argv = { 1956 1956 - .is_compat = true, 1957 1957 - .ptr.compat = __argv, 1958 1958 - }; 1959 1959 - struct user_arg_ptr envp = { 1960 1960 - .is_compat = true, 1961 1961 - .ptr.compat = __envp, 1962 1962 - }; 1963 1963 - return do_execveat_common(fd, filename, argv, envp, flags); 1964 1964 - } 1965 1965 - #endif 1966 1907 1967 1908 void set_binfmt(struct linux_binfmt *new) 1968 1909 { ··· 1916 2001 __mm_flags_set_mask_dumpable(mm, value); 1917 2002 } 1918 2003 2004 2004 + static inline struct user_arg_ptr native_arg(const char __user *const __user *p) 2005 2005 + { 2006 2006 + return (struct user_arg_ptr){.ptr.native = p}; 2007 2007 + } 2008 2008 + 1919 2009 SYSCALL_DEFINE3(execve, 1920 2010 const char __user *, filename, 1921 2011 const char __user *const __user *, argv, 1922 2012 const char __user *const __user *, envp) 1923 2013 { 1924 1924 - return do_execve(getname(filename), argv, envp); 2014 2014 + CLASS(filename, name)(filename); 2015 2015 + return do_execveat_common(AT_FDCWD, name, 2016 2016 + native_arg(argv), native_arg(envp), 0); 1925 2017 } 1926 2018 1927 2019 SYSCALL_DEFINE5(execveat, ··· 1937 2015 const char __user *const __user *, envp, 1938 2016 int, flags) 1939 2017 { 1940 1940 - return do_execveat(fd, 1941 1941 - getname_uflags(filename, flags), 1942 1942 - argv, envp, flags); 2018 2018 + CLASS(filename_uflags, name)(filename, flags); 2019 2019 + return do_execveat_common(fd, name, 2020 2020 + native_arg(argv), native_arg(envp), flags); 1943 2021 } 1944 2022 1945 2023 #ifdef CONFIG_COMPAT 2024 2024 + 2025 2025 + static inline struct user_arg_ptr compat_arg(const compat_uptr_t __user *p) 2026 2026 + { 2027 2027 + return (struct user_arg_ptr){.is_compat = true, .ptr.compat = p}; 2028 2028 + } 2029 2029 + 1946 2030 COMPAT_SYSCALL_DEFINE3(execve, const char __user *, filename, 1947 2031 const compat_uptr_t __user *, argv, 1948 2032 const compat_uptr_t __user *, envp) 1949 2033 { 1950 1950 - return compat_do_execve(getname(filename), argv, envp); 2034 2034 + CLASS(filename, name)(filename); 2035 2035 + return do_execveat_common(AT_FDCWD, name, 2036 2036 + compat_arg(argv), compat_arg(envp), 0); 1951 2037 } 1952 2038 1953 2039 COMPAT_SYSCALL_DEFINE5(execveat, int, fd, ··· 1964 2034 const compat_uptr_t __user *, envp, 1965 2035 int, flags) 1966 2036 { 1967 1967 - return compat_do_execveat(fd, 1968 1968 - getname_uflags(filename, flags), 1969 1969 - argv, envp, flags); 2037 2037 + CLASS(filename_uflags, name)(filename, flags); 2038 2038 + return do_execveat_common(fd, name, 2039 2039 + compat_arg(argv), compat_arg(envp), flags); 1970 2040 } 1971 2041 #endif 1972 2042

+2 -3

fs/fhandle.c

reviewed

··· 157 157 fh_flags |= EXPORT_FH_CONNECTABLE; 158 158 159 159 lookup_flags = (flag & AT_SYMLINK_FOLLOW) ? LOOKUP_FOLLOW : 0; 160 160 - if (flag & AT_EMPTY_PATH) 161 161 - lookup_flags |= LOOKUP_EMPTY; 162 162 - err = user_path_at(dfd, name, lookup_flags, &path); 160 160 + CLASS(filename_uflags, filename)(name, flag); 161 161 + err = filename_lookup(dfd, filename, lookup_flags, &path, NULL); 163 162 if (!err) { 164 163 err = do_sys_name_to_handle(&path, handle, mnt_id, 165 164 flag & AT_HANDLE_MNT_ID_UNIQUE,

+2 -10

fs/file_attr.c

reviewed

··· 374 374 unsigned int, at_flags) 375 375 { 376 376 struct path filepath __free(path_put) = {}; 377 377 - struct filename *name __free(putname) = NULL; 378 377 unsigned int lookup_flags = 0; 379 378 struct file_attr fattr; 380 379 struct file_kattr fa; ··· 394 395 if (usize < FILE_ATTR_SIZE_VER0) 395 396 return -EINVAL; 396 397 397 397 - name = getname_maybe_null(filename, at_flags); 398 398 - if (IS_ERR(name)) 399 399 - return PTR_ERR(name); 400 400 - 398 398 + CLASS(filename_maybe_null, name)(filename, at_flags); 401 399 if (!name && dfd >= 0) { 402 400 CLASS(fd, f)(dfd); 403 401 if (fd_empty(f)) ··· 427 431 unsigned int, at_flags) 428 432 { 429 433 struct path filepath __free(path_put) = {}; 430 430 - struct filename *name __free(putname) = NULL; 431 434 unsigned int lookup_flags = 0; 432 435 struct file_attr fattr; 433 436 struct file_kattr fa; ··· 456 461 if (error) 457 462 return error; 458 463 459 459 - name = getname_maybe_null(filename, at_flags); 460 460 - if (IS_ERR(name)) 461 461 - return PTR_ERR(name); 462 462 - 464 464 + CLASS(filename_maybe_null, name)(filename, at_flags); 463 465 if (!name && dfd >= 0) { 464 466 CLASS(fd, f)(dfd); 465 467 if (fd_empty(f))

+3 -6

fs/filesystems.c

reviewed

··· 132 132 static int fs_index(const char __user * __name) 133 133 { 134 134 struct file_system_type * tmp; 135 135 - struct filename *name; 135 135 + char *name __free(kfree) = strndup_user(__name, PATH_MAX); 136 136 int err, index; 137 137 138 138 - name = getname(__name); 139 139 - err = PTR_ERR(name); 140 138 if (IS_ERR(name)) 141 141 - return err; 139 139 + return PTR_ERR(name); 142 140 143 141 err = -EINVAL; 144 142 read_lock(&file_systems_lock); 145 143 for (tmp=file_systems, index=0 ; tmp ; tmp=tmp->next, index++) { 146 146 - if (strcmp(tmp->name, name->name) == 0) { 144 144 + if (strcmp(tmp->name, name) == 0) { 147 145 err = index; 148 146 break; 149 147 } 150 148 } 151 149 read_unlock(&file_systems_lock); 152 152 - putname(name); 153 150 return err; 154 151 } 155 152

+3 -3

fs/fsopen.c

reviewed

··· 181 181 lookup_flags &= ~LOOKUP_FOLLOW; 182 182 if (flags & FSPICK_NO_AUTOMOUNT) 183 183 lookup_flags &= ~LOOKUP_AUTOMOUNT; 184 184 - if (flags & FSPICK_EMPTY_PATH) 185 185 - lookup_flags |= LOOKUP_EMPTY; 186 186 - ret = user_path_at(dfd, path, lookup_flags, &target); 184 184 + CLASS(filename_flags, filename)(path, 185 185 + (flags & FSPICK_EMPTY_PATH) ? LOOKUP_EMPTY : 0); 186 186 + ret = filename_lookup(dfd, filename, lookup_flags, &target, NULL); 187 187 if (ret < 0) 188 188 goto err; 189 189

+14 -84

fs/init.c

reviewed

··· 157 157 158 158 int __init init_mknod(const char *filename, umode_t mode, unsigned int dev) 159 159 { 160 160 - struct dentry *dentry; 161 161 - struct path path; 162 162 - int error; 163 163 - 164 164 - if (S_ISFIFO(mode) || S_ISSOCK(mode)) 165 165 - dev = 0; 166 166 - else if (!(S_ISBLK(mode) || S_ISCHR(mode))) 167 167 - return -EINVAL; 168 168 - 169 169 - dentry = start_creating_path(AT_FDCWD, filename, &path, 0); 170 170 - if (IS_ERR(dentry)) 171 171 - return PTR_ERR(dentry); 172 172 - 173 173 - mode = mode_strip_umask(d_inode(path.dentry), mode); 174 174 - error = security_path_mknod(&path, dentry, mode, dev); 175 175 - if (!error) 176 176 - error = vfs_mknod(mnt_idmap(path.mnt), path.dentry->d_inode, 177 177 - dentry, mode, new_decode_dev(dev), NULL); 178 178 - end_creating_path(&path, dentry); 179 179 - return error; 160 160 + CLASS(filename_kernel, name)(filename); 161 161 + return filename_mknodat(AT_FDCWD, name, mode, dev); 180 162 } 181 163 182 164 int __init init_link(const char *oldname, const char *newname) 183 165 { 184 184 - struct dentry *new_dentry; 185 185 - struct path old_path, new_path; 186 186 - struct mnt_idmap *idmap; 187 187 - int error; 188 188 - 189 189 - error = kern_path(oldname, 0, &old_path); 190 190 - if (error) 191 191 - return error; 192 192 - 193 193 - new_dentry = start_creating_path(AT_FDCWD, newname, &new_path, 0); 194 194 - error = PTR_ERR(new_dentry); 195 195 - if (IS_ERR(new_dentry)) 196 196 - goto out; 197 197 - 198 198 - error = -EXDEV; 199 199 - if (old_path.mnt != new_path.mnt) 200 200 - goto out_dput; 201 201 - idmap = mnt_idmap(new_path.mnt); 202 202 - error = may_linkat(idmap, &old_path); 203 203 - if (unlikely(error)) 204 204 - goto out_dput; 205 205 - error = security_path_link(old_path.dentry, &new_path, new_dentry); 206 206 - if (error) 207 207 - goto out_dput; 208 208 - error = vfs_link(old_path.dentry, idmap, new_path.dentry->d_inode, 209 209 - new_dentry, NULL); 210 210 - out_dput: 211 211 - end_creating_path(&new_path, new_dentry); 212 212 - out: 213 213 - path_put(&old_path); 214 214 - return error; 166 166 + CLASS(filename_kernel, old)(oldname); 167 167 + CLASS(filename_kernel, new)(newname); 168 168 + return filename_linkat(AT_FDCWD, old, AT_FDCWD, new, 0); 215 169 } 216 170 217 171 int __init init_symlink(const char *oldname, const char *newname) 218 172 { 219 219 - struct dentry *dentry; 220 220 - struct path path; 221 221 - int error; 222 222 - 223 223 - dentry = start_creating_path(AT_FDCWD, newname, &path, 0); 224 224 - if (IS_ERR(dentry)) 225 225 - return PTR_ERR(dentry); 226 226 - error = security_path_symlink(&path, dentry, oldname); 227 227 - if (!error) 228 228 - error = vfs_symlink(mnt_idmap(path.mnt), path.dentry->d_inode, 229 229 - dentry, oldname, NULL); 230 230 - end_creating_path(&path, dentry); 231 231 - return error; 173 173 + CLASS(filename_kernel, old)(oldname); 174 174 + CLASS(filename_kernel, new)(newname); 175 175 + return filename_symlinkat(old, AT_FDCWD, new); 232 176 } 233 177 234 178 int __init init_unlink(const char *pathname) 235 179 { 236 236 - return do_unlinkat(AT_FDCWD, getname_kernel(pathname)); 180 180 + CLASS(filename_kernel, name)(pathname); 181 181 + return filename_unlinkat(AT_FDCWD, name); 237 182 } 238 183 239 184 int __init init_mkdir(const char *pathname, umode_t mode) 240 185 { 241 241 - struct dentry *dentry; 242 242 - struct path path; 243 243 - int error; 244 244 - 245 245 - dentry = start_creating_path(AT_FDCWD, pathname, &path, 246 246 - LOOKUP_DIRECTORY); 247 247 - if (IS_ERR(dentry)) 248 248 - return PTR_ERR(dentry); 249 249 - mode = mode_strip_umask(d_inode(path.dentry), mode); 250 250 - error = security_path_mkdir(&path, dentry, mode); 251 251 - if (!error) { 252 252 - dentry = vfs_mkdir(mnt_idmap(path.mnt), path.dentry->d_inode, 253 253 - dentry, mode, NULL); 254 254 - if (IS_ERR(dentry)) 255 255 - error = PTR_ERR(dentry); 256 256 - } 257 257 - end_creating_path(&path, dentry); 258 258 - return error; 186 186 + CLASS(filename_kernel, name)(pathname); 187 187 + return filename_mkdirat(AT_FDCWD, name, mode); 259 188 } 260 189 261 190 int __init init_rmdir(const char *pathname) 262 191 { 263 263 - return do_rmdir(AT_FDCWD, getname_kernel(pathname)); 192 192 + CLASS(filename_kernel, name)(pathname); 193 193 + return filename_rmdir(AT_FDCWD, name); 264 194 } 265 195 266 196 int __init init_utimes(char *filename, struct timespec64 *ts)

+10 -7

fs/internal.h

reviewed

··· 53 53 */ 54 54 extern int filename_lookup(int dfd, struct filename *name, unsigned flags, 55 55 struct path *path, const struct path *root); 56 56 - int do_rmdir(int dfd, struct filename *name); 57 57 - int do_unlinkat(int dfd, struct filename *name); 56 56 + int filename_rmdir(int dfd, struct filename *name); 57 57 + int filename_unlinkat(int dfd, struct filename *name); 58 58 int may_linkat(struct mnt_idmap *idmap, const struct path *link); 59 59 - int do_renameat2(int olddfd, struct filename *oldname, int newdfd, 59 59 + int filename_renameat2(int olddfd, struct filename *oldname, int newdfd, 60 60 struct filename *newname, unsigned int flags); 61 61 - int do_mkdirat(int dfd, struct filename *name, umode_t mode); 62 62 - int do_symlinkat(struct filename *from, int newdfd, struct filename *to); 63 63 - int do_linkat(int olddfd, struct filename *old, int newdfd, 61 61 + int filename_mkdirat(int dfd, struct filename *name, umode_t mode); 62 62 + int filename_mknodat(int dfd, struct filename *name, umode_t mode, unsigned int dev); 63 63 + int filename_symlinkat(struct filename *from, int newdfd, struct filename *to); 64 64 + int filename_linkat(int olddfd, struct filename *old, int newdfd, 64 65 struct filename *new, int flags); 65 66 int vfs_tmpfile(struct mnt_idmap *idmap, 66 67 const struct path *parentpath, ··· 70 69 struct dentry *start_dirop(struct dentry *parent, struct qstr *name, 71 70 unsigned int lookup_flags); 72 71 int lookup_noperm_common(struct qstr *qname, struct dentry *base); 72 72 + 73 73 + void __init filename_init(void); 73 74 74 75 /* 75 76 * namespace.c ··· 190 187 int intent; 191 188 int lookup_flags; 192 189 }; 193 193 - extern struct file *do_filp_open(int dfd, struct filename *pathname, 190 190 + extern struct file *do_file_open(int dfd, struct filename *pathname, 194 191 const struct open_flags *op); 195 192 extern struct file *do_file_open_root(const struct path *, 196 193 const char *, const struct open_flags *);

+222 -200

fs/namei.c

reviewed

··· 41 41 #include <linux/init_task.h> 42 42 #include <linux/uaccess.h> 43 43 44 44 + #include <asm/runtime-const.h> 45 45 + 44 46 #include "internal.h" 45 47 #include "mount.h" 46 48 ··· 125 123 * PATH_MAX includes the nul terminator --RR. 126 124 */ 127 125 128 128 - #define EMBEDDED_NAME_MAX (PATH_MAX - offsetof(struct filename, iname)) 126 126 + /* SLAB cache for struct filename instances */ 127 127 + static struct kmem_cache *__names_cache __ro_after_init; 128 128 + #define names_cache runtime_const_ptr(__names_cache) 129 129 130 130 - static inline void initname(struct filename *name, const char __user *uptr) 130 130 + void __init filename_init(void) 131 131 { 132 132 - name->uptr = uptr; 133 133 - name->aname = NULL; 134 134 - atomic_set(&name->refcnt, 1); 132 132 + __names_cache = kmem_cache_create_usercopy("names_cache", sizeof(struct filename), 0, 133 133 + SLAB_HWCACHE_ALIGN|SLAB_PANIC, offsetof(struct filename, iname), 134 134 + EMBEDDED_NAME_MAX, NULL); 135 135 + runtime_const_init(ptr, __names_cache); 135 136 } 136 137 137 137 - struct filename * 138 138 - getname_flags(const char __user *filename, int flags) 138 138 + static inline struct filename *alloc_filename(void) 139 139 + { 140 140 + return kmem_cache_alloc(names_cache, GFP_KERNEL); 141 141 + } 142 142 + 143 143 + static inline void free_filename(struct filename *p) 144 144 + { 145 145 + kmem_cache_free(names_cache, p); 146 146 + } 147 147 + 148 148 + static inline void initname(struct filename *name) 149 149 + { 150 150 + name->aname = NULL; 151 151 + name->refcnt = 1; 152 152 + } 153 153 + 154 154 + static int getname_long(struct filename *name, const char __user *filename) 155 155 + { 156 156 + int len; 157 157 + char *p __free(kfree) = kmalloc(PATH_MAX, GFP_KERNEL); 158 158 + if (unlikely(!p)) 159 159 + return -ENOMEM; 160 160 + 161 161 + memcpy(p, &name->iname, EMBEDDED_NAME_MAX); 162 162 + len = strncpy_from_user(p + EMBEDDED_NAME_MAX, 163 163 + filename + EMBEDDED_NAME_MAX, 164 164 + PATH_MAX - EMBEDDED_NAME_MAX); 165 165 + if (unlikely(len < 0)) 166 166 + return len; 167 167 + if (unlikely(len == PATH_MAX - EMBEDDED_NAME_MAX)) 168 168 + return -ENAMETOOLONG; 169 169 + name->name = no_free_ptr(p); 170 170 + return 0; 171 171 + } 172 172 + 173 173 + static struct filename * 174 174 + do_getname(const char __user *filename, int flags, bool incomplete) 139 175 { 140 176 struct filename *result; 141 177 char *kname; 142 178 int len; 143 179 144 144 - result = audit_reusename(filename); 145 145 - if (result) 146 146 - return result; 147 147 - 148 148 - result = __getname(); 180 180 + result = alloc_filename(); 149 181 if (unlikely(!result)) 150 182 return ERR_PTR(-ENOMEM); 151 183 ··· 195 159 * Handle both empty path and copy failure in one go. 196 160 */ 197 161 if (unlikely(len <= 0)) { 198 198 - if (unlikely(len < 0)) { 199 199 - __putname(result); 200 200 - return ERR_PTR(len); 201 201 - } 202 202 - 203 162 /* The empty path is special. */ 204 204 - if (!(flags & LOOKUP_EMPTY)) { 205 205 - __putname(result); 206 206 - return ERR_PTR(-ENOENT); 207 207 - } 163 163 + if (!len && !(flags & LOOKUP_EMPTY)) 164 164 + len = -ENOENT; 208 165 } 209 166 210 167 /* ··· 206 177 * names_cache allocation for the pathname, and re-do the copy from 207 178 * userland. 208 179 */ 209 209 - if (unlikely(len == EMBEDDED_NAME_MAX)) { 210 210 - const size_t size = offsetof(struct filename, iname[1]); 211 211 - kname = (char *)result; 212 212 - 213 213 - /* 214 214 - * size is chosen that way we to guarantee that 215 215 - * result->iname[0] is within the same object and that 216 216 - * kname can't be equal to result->iname, no matter what. 217 217 - */ 218 218 - result = kzalloc(size, GFP_KERNEL); 219 219 - if (unlikely(!result)) { 220 220 - __putname(kname); 221 221 - return ERR_PTR(-ENOMEM); 222 222 - } 223 223 - result->name = kname; 224 224 - len = strncpy_from_user(kname, filename, PATH_MAX); 225 225 - if (unlikely(len < 0)) { 226 226 - __putname(kname); 227 227 - kfree(result); 228 228 - return ERR_PTR(len); 229 229 - } 230 230 - /* The empty path is special. */ 231 231 - if (unlikely(!len) && !(flags & LOOKUP_EMPTY)) { 232 232 - __putname(kname); 233 233 - kfree(result); 234 234 - return ERR_PTR(-ENOENT); 235 235 - } 236 236 - if (unlikely(len == PATH_MAX)) { 237 237 - __putname(kname); 238 238 - kfree(result); 239 239 - return ERR_PTR(-ENAMETOOLONG); 240 240 - } 180 180 + if (unlikely(len == EMBEDDED_NAME_MAX)) 181 181 + len = getname_long(result, filename); 182 182 + if (unlikely(len < 0)) { 183 183 + free_filename(result); 184 184 + return ERR_PTR(len); 241 185 } 242 242 - initname(result, filename); 243 243 - audit_getname(result); 186 186 + 187 187 + initname(result); 188 188 + if (likely(!incomplete)) 189 189 + audit_getname(result); 244 190 return result; 191 191 + } 192 192 + 193 193 + struct filename * 194 194 + getname_flags(const char __user *filename, int flags) 195 195 + { 196 196 + return do_getname(filename, flags, false); 245 197 } 246 198 247 199 struct filename *getname_uflags(const char __user *filename, int uflags) ··· 234 224 235 225 struct filename *__getname_maybe_null(const char __user *pathname) 236 226 { 237 237 - struct filename *name; 238 227 char c; 239 228 240 229 /* try to save on allocations; loss on um, though */ ··· 242 233 if (!c) 243 234 return NULL; 244 235 245 245 - name = getname_flags(pathname, LOOKUP_EMPTY); 246 246 - if (!IS_ERR(name) && !(name->name[0])) { 247 247 - putname(name); 248 248 - name = NULL; 249 249 - } 250 250 - return name; 236 236 + CLASS(filename_flags, name)(pathname, LOOKUP_EMPTY); 237 237 + /* empty pathname translates to NULL */ 238 238 + if (!IS_ERR(name) && !(name->name[0])) 239 239 + return NULL; 240 240 + return no_free_ptr(name); 251 241 } 252 242 253 253 - struct filename *getname_kernel(const char * filename) 243 243 + static struct filename *do_getname_kernel(const char *filename, bool incomplete) 254 244 { 255 245 struct filename *result; 256 246 int len = strlen(filename) + 1; 247 247 + char *p; 257 248 258 258 - result = __getname(); 249 249 + if (unlikely(len > PATH_MAX)) 250 250 + return ERR_PTR(-ENAMETOOLONG); 251 251 + 252 252 + result = alloc_filename(); 259 253 if (unlikely(!result)) 260 254 return ERR_PTR(-ENOMEM); 261 255 262 256 if (len <= EMBEDDED_NAME_MAX) { 263 263 - result->name = (char *)result->iname; 264 264 - } else if (len <= PATH_MAX) { 265 265 - const size_t size = offsetof(struct filename, iname[1]); 266 266 - struct filename *tmp; 267 267 - 268 268 - tmp = kmalloc(size, GFP_KERNEL); 269 269 - if (unlikely(!tmp)) { 270 270 - __putname(result); 257 257 + p = (char *)result->iname; 258 258 + memcpy(p, filename, len); 259 259 + } else { 260 260 + p = kmemdup(filename, len, GFP_KERNEL); 261 261 + if (unlikely(!p)) { 262 262 + free_filename(result); 271 263 return ERR_PTR(-ENOMEM); 272 264 } 273 273 - tmp->name = (char *)result; 274 274 - result = tmp; 275 275 - } else { 276 276 - __putname(result); 277 277 - return ERR_PTR(-ENAMETOOLONG); 278 265 } 279 279 - memcpy((char *)result->name, filename, len); 280 280 - initname(result, NULL); 281 281 - audit_getname(result); 266 266 + result->name = p; 267 267 + initname(result); 268 268 + if (likely(!incomplete)) 269 269 + audit_getname(result); 282 270 return result; 271 271 + } 272 272 + 273 273 + struct filename *getname_kernel(const char *filename) 274 274 + { 275 275 + return do_getname_kernel(filename, false); 283 276 } 284 277 EXPORT_SYMBOL(getname_kernel); 285 278 ··· 292 281 if (IS_ERR_OR_NULL(name)) 293 282 return; 294 283 295 295 - refcnt = atomic_read(&name->refcnt); 284 284 + refcnt = name->refcnt; 296 285 if (unlikely(refcnt != 1)) { 297 286 if (WARN_ON_ONCE(!refcnt)) 298 287 return; 299 288 300 300 - if (!atomic_dec_and_test(&name->refcnt)) 301 301 - return; 289 289 + name->refcnt--; 290 290 + return; 302 291 } 303 292 304 304 - if (unlikely(name->name != name->iname)) { 305 305 - __putname(name->name); 306 306 - kfree(name); 307 307 - } else 308 308 - __putname(name); 293 293 + if (unlikely(name->name != name->iname)) 294 294 + kfree(name->name); 295 295 + free_filename(name); 309 296 } 310 297 EXPORT_SYMBOL(putname); 298 298 + 299 299 + static inline int __delayed_getname(struct delayed_filename *v, 300 300 + const char __user *string, int flags) 301 301 + { 302 302 + v->__incomplete_filename = do_getname(string, flags, true); 303 303 + return PTR_ERR_OR_ZERO(v->__incomplete_filename); 304 304 + } 305 305 + 306 306 + int delayed_getname(struct delayed_filename *v, const char __user *string) 307 307 + { 308 308 + return __delayed_getname(v, string, 0); 309 309 + } 310 310 + 311 311 + int delayed_getname_uflags(struct delayed_filename *v, const char __user *string, 312 312 + int uflags) 313 313 + { 314 314 + int flags = (uflags & AT_EMPTY_PATH) ? LOOKUP_EMPTY : 0; 315 315 + return __delayed_getname(v, string, flags); 316 316 + } 317 317 + 318 318 + int putname_to_delayed(struct delayed_filename *v, struct filename *name) 319 319 + { 320 320 + if (likely(name->refcnt == 1)) { 321 321 + v->__incomplete_filename = name; 322 322 + return 0; 323 323 + } 324 324 + name->refcnt--; 325 325 + v->__incomplete_filename = do_getname_kernel(name->name, true); 326 326 + return PTR_ERR_OR_ZERO(v->__incomplete_filename); 327 327 + } 328 328 + 329 329 + void dismiss_delayed_filename(struct delayed_filename *v) 330 330 + { 331 331 + putname(no_free_ptr(v->__incomplete_filename)); 332 332 + } 333 333 + 334 334 + struct filename *complete_getname(struct delayed_filename *v) 335 335 + { 336 336 + struct filename *res = no_free_ptr(v->__incomplete_filename); 337 337 + if (!IS_ERR(res)) 338 338 + audit_getname(res); 339 339 + return res; 340 340 + } 311 341 312 342 /** 313 343 * check_acl - perform ACL permission checking ··· 3000 2948 struct dentry *kern_path_parent(const char *name, struct path *path) 3001 2949 { 3002 2950 struct path parent_path __free(path_put) = {}; 3003 3003 - struct filename *filename __free(putname) = getname_kernel(name); 2951 2951 + CLASS(filename_kernel, filename)(name); 3004 2952 struct dentry *d; 3005 2953 struct qstr last; 3006 2954 int type, error; ··· 3021 2969 3022 2970 struct dentry *start_removing_path(const char *name, struct path *path) 3023 2971 { 3024 3024 - struct filename *filename = getname_kernel(name); 3025 3025 - struct dentry *res = __start_removing_path(AT_FDCWD, filename, path); 3026 3026 - 3027 3027 - putname(filename); 3028 3028 - return res; 2972 2972 + CLASS(filename_kernel, filename)(name); 2973 2973 + return __start_removing_path(AT_FDCWD, filename, path); 3029 2974 } 3030 2975 3031 2976 struct dentry *start_removing_user_path_at(int dfd, 3032 2977 const char __user *name, 3033 2978 struct path *path) 3034 2979 { 3035 3035 - struct filename *filename = getname(name); 3036 3036 - struct dentry *res = __start_removing_path(dfd, filename, path); 3037 3037 - 3038 3038 - putname(filename); 3039 3039 - return res; 2980 2980 + CLASS(filename, filename)(name); 2981 2981 + return __start_removing_path(dfd, filename, path); 3040 2982 } 3041 2983 EXPORT_SYMBOL(start_removing_user_path_at); 3042 2984 3043 2985 int kern_path(const char *name, unsigned int flags, struct path *path) 3044 2986 { 3045 3045 - struct filename *filename = getname_kernel(name); 3046 3046 - int ret = filename_lookup(AT_FDCWD, filename, flags, path, NULL); 3047 3047 - 3048 3048 - putname(filename); 3049 3049 - return ret; 3050 3050 - 2987 2987 + CLASS(filename_kernel, filename)(name); 2988 2988 + return filename_lookup(AT_FDCWD, filename, flags, path, NULL); 3051 2989 } 3052 2990 EXPORT_SYMBOL(kern_path); 3053 2991 ··· 3071 3029 const char *name, unsigned int flags, 3072 3030 struct path *path) 3073 3031 { 3074 3074 - struct filename *filename; 3032 3032 + CLASS(filename_kernel, filename)(name); 3075 3033 struct path root = {.mnt = mnt, .dentry = dentry}; 3076 3076 - int ret; 3077 3034 3078 3078 - filename = getname_kernel(name); 3079 3035 /* the first argument of filename_lookup() is ignored with root */ 3080 3080 - ret = filename_lookup(AT_FDCWD, filename, flags, path, &root); 3081 3081 - putname(filename); 3082 3082 - return ret; 3036 3036 + return filename_lookup(AT_FDCWD, filename, flags, path, &root); 3083 3037 } 3084 3038 EXPORT_SYMBOL(vfs_path_lookup); 3085 3039 ··· 3608 3570 int user_path_at(int dfd, const char __user *name, unsigned flags, 3609 3571 struct path *path) 3610 3572 { 3611 3611 - struct filename *filename = getname_flags(name, flags); 3612 3612 - int ret = filename_lookup(dfd, filename, flags, path, NULL); 3613 3613 - 3614 3614 - putname(filename); 3615 3615 - return ret; 3573 3573 + CLASS(filename_flags, filename)(name, flags); 3574 3574 + return filename_lookup(dfd, filename, flags, path, NULL); 3616 3575 } 3617 3576 EXPORT_SYMBOL(user_path_at); 3618 3577 ··· 4846 4811 return ERR_PTR(error); 4847 4812 } 4848 4813 4849 4849 - struct file *do_filp_open(int dfd, struct filename *pathname, 4814 4814 + struct file *do_file_open(int dfd, struct filename *pathname, 4850 4815 const struct open_flags *op) 4851 4816 { 4852 4817 struct nameidata nd; 4853 4818 int flags = op->lookup_flags; 4854 4819 struct file *filp; 4855 4820 4821 4821 + if (IS_ERR(pathname)) 4822 4822 + return ERR_CAST(pathname); 4856 4823 set_nameidata(&nd, dfd, pathname, NULL); 4857 4824 filp = path_openat(&nd, op, flags | LOOKUP_RCU); 4858 4825 if (unlikely(filp == ERR_PTR(-ECHILD))) ··· 4870 4833 { 4871 4834 struct nameidata nd; 4872 4835 struct file *file; 4873 4873 - struct filename *filename; 4874 4836 int flags = op->lookup_flags; 4875 4837 4876 4838 if (d_is_symlink(root->dentry) && op->intent & LOOKUP_OPEN) 4877 4839 return ERR_PTR(-ELOOP); 4878 4840 4879 4879 - filename = getname_kernel(name); 4841 4841 + CLASS(filename_kernel, filename)(name); 4880 4842 if (IS_ERR(filename)) 4881 4843 return ERR_CAST(filename); 4882 4844 ··· 4886 4850 if (unlikely(file == ERR_PTR(-ESTALE))) 4887 4851 file = path_openat(&nd, op, flags | LOOKUP_REVAL); 4888 4852 restore_nameidata(); 4889 4889 - putname(filename); 4890 4853 return file; 4891 4854 } 4892 4855 ··· 4941 4906 struct dentry *start_creating_path(int dfd, const char *pathname, 4942 4907 struct path *path, unsigned int lookup_flags) 4943 4908 { 4944 4944 - struct filename *filename = getname_kernel(pathname); 4945 4945 - struct dentry *res = filename_create(dfd, filename, path, lookup_flags); 4946 4946 - 4947 4947 - putname(filename); 4948 4948 - return res; 4909 4909 + CLASS(filename_kernel, filename)(pathname); 4910 4910 + return filename_create(dfd, filename, path, lookup_flags); 4949 4911 } 4950 4912 EXPORT_SYMBOL(start_creating_path); 4951 4913 ··· 4969 4937 int dfd, const char __user *pathname, 4970 4938 struct path *path, unsigned int lookup_flags) 4971 4939 { 4972 4972 - struct filename *filename = getname(pathname); 4973 4973 - struct dentry *res = filename_create(dfd, filename, path, lookup_flags); 4974 4974 - 4975 4975 - putname(filename); 4976 4976 - return res; 4940 4940 + CLASS(filename, filename)(pathname); 4941 4941 + return filename_create(dfd, filename, path, lookup_flags); 4977 4942 } 4978 4943 EXPORT_SYMBOL(start_creating_user_path); 4979 4944 ··· 5113 5084 } 5114 5085 } 5115 5086 5116 5116 - static int do_mknodat(int dfd, struct filename *name, umode_t mode, 5117 5117 - unsigned int dev) 5087 5087 + int filename_mknodat(int dfd, struct filename *name, umode_t mode, 5088 5088 + unsigned int dev) 5118 5089 { 5119 5090 struct delegated_inode di = { }; 5120 5091 struct mnt_idmap *idmap; ··· 5125 5096 5126 5097 error = may_mknod(mode); 5127 5098 if (error) 5128 5128 - goto out1; 5099 5099 + return error; 5129 5100 retry: 5130 5101 dentry = filename_create(dfd, name, &path, lookup_flags); 5131 5131 - error = PTR_ERR(dentry); 5132 5102 if (IS_ERR(dentry)) 5133 5133 - goto out1; 5103 5103 + return PTR_ERR(dentry); 5134 5104 5135 5105 error = security_path_mknod(&path, dentry, 5136 5106 mode_strip_umask(path.dentry->d_inode, mode), dev); ··· 5163 5135 lookup_flags |= LOOKUP_REVAL; 5164 5136 goto retry; 5165 5137 } 5166 5166 - out1: 5167 5167 - putname(name); 5168 5138 return error; 5169 5139 } 5170 5140 5171 5141 SYSCALL_DEFINE4(mknodat, int, dfd, const char __user *, filename, umode_t, mode, 5172 5142 unsigned int, dev) 5173 5143 { 5174 5174 - return do_mknodat(dfd, getname(filename), mode, dev); 5144 5144 + CLASS(filename, name)(filename); 5145 5145 + return filename_mknodat(dfd, name, mode, dev); 5175 5146 } 5176 5147 5177 5148 SYSCALL_DEFINE3(mknod, const char __user *, filename, umode_t, mode, unsigned, dev) 5178 5149 { 5179 5179 - return do_mknodat(AT_FDCWD, getname(filename), mode, dev); 5150 5150 + CLASS(filename, name)(filename); 5151 5151 + return filename_mknodat(AT_FDCWD, name, mode, dev); 5180 5152 } 5181 5153 5182 5154 /** ··· 5247 5219 } 5248 5220 EXPORT_SYMBOL(vfs_mkdir); 5249 5221 5250 5250 - int do_mkdirat(int dfd, struct filename *name, umode_t mode) 5222 5222 + int filename_mkdirat(int dfd, struct filename *name, umode_t mode) 5251 5223 { 5252 5224 struct dentry *dentry; 5253 5225 struct path path; ··· 5257 5229 5258 5230 retry: 5259 5231 dentry = filename_create(dfd, name, &path, lookup_flags); 5260 5260 - error = PTR_ERR(dentry); 5261 5232 if (IS_ERR(dentry)) 5262 5262 - goto out_putname; 5233 5233 + return PTR_ERR(dentry); 5263 5234 5264 5235 error = security_path_mkdir(&path, dentry, 5265 5236 mode_strip_umask(path.dentry->d_inode, mode)); ··· 5278 5251 lookup_flags |= LOOKUP_REVAL; 5279 5252 goto retry; 5280 5253 } 5281 5281 - out_putname: 5282 5282 - putname(name); 5283 5254 return error; 5284 5255 } 5285 5256 5286 5257 SYSCALL_DEFINE3(mkdirat, int, dfd, const char __user *, pathname, umode_t, mode) 5287 5258 { 5288 5288 - return do_mkdirat(dfd, getname(pathname), mode); 5259 5259 + CLASS(filename, name)(pathname); 5260 5260 + return filename_mkdirat(dfd, name, mode); 5289 5261 } 5290 5262 5291 5263 SYSCALL_DEFINE2(mkdir, const char __user *, pathname, umode_t, mode) 5292 5264 { 5293 5293 - return do_mkdirat(AT_FDCWD, getname(pathname), mode); 5265 5265 + CLASS(filename, name)(pathname); 5266 5266 + return filename_mkdirat(AT_FDCWD, name, mode); 5294 5267 } 5295 5268 5296 5269 /** ··· 5353 5326 } 5354 5327 EXPORT_SYMBOL(vfs_rmdir); 5355 5328 5356 5356 - int do_rmdir(int dfd, struct filename *name) 5329 5329 + int filename_rmdir(int dfd, struct filename *name) 5357 5330 { 5358 5331 int error; 5359 5332 struct dentry *dentry; ··· 5365 5338 retry: 5366 5339 error = filename_parentat(dfd, name, lookup_flags, &path, &last, &type); 5367 5340 if (error) 5368 5368 - goto exit1; 5341 5341 + return error; 5369 5342 5370 5343 switch (type) { 5371 5344 case LAST_DOTDOT: ··· 5407 5380 lookup_flags |= LOOKUP_REVAL; 5408 5381 goto retry; 5409 5382 } 5410 5410 - exit1: 5411 5411 - putname(name); 5412 5383 return error; 5413 5384 } 5414 5385 5415 5386 SYSCALL_DEFINE1(rmdir, const char __user *, pathname) 5416 5387 { 5417 5417 - return do_rmdir(AT_FDCWD, getname(pathname)); 5388 5388 + CLASS(filename, name)(pathname); 5389 5389 + return filename_rmdir(AT_FDCWD, name); 5418 5390 } 5419 5391 5420 5392 /** ··· 5495 5469 * writeout happening, and we don't want to prevent access to the directory 5496 5470 * while waiting on the I/O. 5497 5471 */ 5498 5498 - int do_unlinkat(int dfd, struct filename *name) 5472 5472 + int filename_unlinkat(int dfd, struct filename *name) 5499 5473 { 5500 5474 int error; 5501 5475 struct dentry *dentry; ··· 5508 5482 retry: 5509 5483 error = filename_parentat(dfd, name, lookup_flags, &path, &last, &type); 5510 5484 if (error) 5511 5511 - goto exit_putname; 5485 5485 + return error; 5512 5486 5513 5487 error = -EISDIR; 5514 5488 if (type != LAST_NORM) ··· 5555 5529 lookup_flags |= LOOKUP_REVAL; 5556 5530 goto retry; 5557 5531 } 5558 5558 - exit_putname: 5559 5559 - putname(name); 5560 5532 return error; 5561 5533 } 5562 5534 ··· 5563 5539 if ((flag & ~AT_REMOVEDIR) != 0) 5564 5540 return -EINVAL; 5565 5541 5542 5542 + CLASS(filename, name)(pathname); 5566 5543 if (flag & AT_REMOVEDIR) 5567 5567 - return do_rmdir(dfd, getname(pathname)); 5568 5568 - return do_unlinkat(dfd, getname(pathname)); 5544 5544 + return filename_rmdir(dfd, name); 5545 5545 + return filename_unlinkat(dfd, name); 5569 5546 } 5570 5547 5571 5548 SYSCALL_DEFINE1(unlink, const char __user *, pathname) 5572 5549 { 5573 5573 - return do_unlinkat(AT_FDCWD, getname(pathname)); 5550 5550 + CLASS(filename, name)(pathname); 5551 5551 + return filename_unlinkat(AT_FDCWD, name); 5574 5552 } 5575 5553 5576 5554 /** ··· 5619 5593 } 5620 5594 EXPORT_SYMBOL(vfs_symlink); 5621 5595 5622 5622 - int do_symlinkat(struct filename *from, int newdfd, struct filename *to) 5596 5596 + int filename_symlinkat(struct filename *from, int newdfd, struct filename *to) 5623 5597 { 5624 5598 int error; 5625 5599 struct dentry *dentry; ··· 5627 5601 unsigned int lookup_flags = 0; 5628 5602 struct delegated_inode delegated_inode = { }; 5629 5603 5630 5630 - if (IS_ERR(from)) { 5631 5631 - error = PTR_ERR(from); 5632 5632 - goto out_putnames; 5633 5633 - } 5604 5604 + if (IS_ERR(from)) 5605 5605 + return PTR_ERR(from); 5606 5606 + 5634 5607 retry: 5635 5608 dentry = filename_create(newdfd, to, &path, lookup_flags); 5636 5636 - error = PTR_ERR(dentry); 5637 5609 if (IS_ERR(dentry)) 5638 5638 - goto out_putnames; 5610 5610 + return PTR_ERR(dentry); 5639 5611 5640 5612 error = security_path_symlink(&path, dentry, from->name); 5641 5613 if (!error) ··· 5649 5625 lookup_flags |= LOOKUP_REVAL; 5650 5626 goto retry; 5651 5627 } 5652 5652 - out_putnames: 5653 5653 - putname(to); 5654 5654 - putname(from); 5655 5628 return error; 5656 5629 } 5657 5630 5658 5631 SYSCALL_DEFINE3(symlinkat, const char __user *, oldname, 5659 5632 int, newdfd, const char __user *, newname) 5660 5633 { 5661 5661 - return do_symlinkat(getname(oldname), newdfd, getname(newname)); 5634 5634 + CLASS(filename, old)(oldname); 5635 5635 + CLASS(filename, new)(newname); 5636 5636 + return filename_symlinkat(old, newdfd, new); 5662 5637 } 5663 5638 5664 5639 SYSCALL_DEFINE2(symlink, const char __user *, oldname, const char __user *, newname) 5665 5640 { 5666 5666 - return do_symlinkat(getname(oldname), AT_FDCWD, getname(newname)); 5641 5641 + CLASS(filename, old)(oldname); 5642 5642 + CLASS(filename, new)(newname); 5643 5643 + return filename_symlinkat(old, AT_FDCWD, new); 5667 5644 } 5668 5645 5669 5646 /** ··· 5766 5741 * We don't follow them on the oldname either to be compatible 5767 5742 * with linux 2.0, and to avoid hard-linking to directories 5768 5743 * and other special files. --ADM 5769 5769 - */ 5770 5770 - int do_linkat(int olddfd, struct filename *old, int newdfd, 5771 5771 - struct filename *new, int flags) 5744 5744 + */ 5745 5745 + int filename_linkat(int olddfd, struct filename *old, 5746 5746 + int newdfd, struct filename *new, int flags) 5772 5747 { 5773 5748 struct mnt_idmap *idmap; 5774 5749 struct dentry *new_dentry; ··· 5777 5752 int how = 0; 5778 5753 int error; 5779 5754 5780 5780 - if ((flags & ~(AT_SYMLINK_FOLLOW | AT_EMPTY_PATH)) != 0) { 5781 5781 - error = -EINVAL; 5782 5782 - goto out_putnames; 5783 5783 - } 5755 5755 + if ((flags & ~(AT_SYMLINK_FOLLOW | AT_EMPTY_PATH)) != 0) 5756 5756 + return -EINVAL; 5784 5757 /* 5785 5758 * To use null names we require CAP_DAC_READ_SEARCH or 5786 5759 * that the open-time creds of the dfd matches current. ··· 5793 5770 retry: 5794 5771 error = filename_lookup(olddfd, old, how, &old_path, NULL); 5795 5772 if (error) 5796 5796 - goto out_putnames; 5773 5773 + return error; 5797 5774 5798 5775 new_dentry = filename_create(newdfd, new, &new_path, 5799 5776 (how & LOOKUP_REVAL)); ··· 5829 5806 } 5830 5807 out_putpath: 5831 5808 path_put(&old_path); 5832 5832 - out_putnames: 5833 5833 - putname(old); 5834 5834 - putname(new); 5835 5835 - 5836 5809 return error; 5837 5810 } 5838 5811 5839 5812 SYSCALL_DEFINE5(linkat, int, olddfd, const char __user *, oldname, 5840 5813 int, newdfd, const char __user *, newname, int, flags) 5841 5814 { 5842 5842 - return do_linkat(olddfd, getname_uflags(oldname, flags), 5843 5843 - newdfd, getname(newname), flags); 5815 5815 + CLASS(filename_uflags, old)(oldname, flags); 5816 5816 + CLASS(filename, new)(newname); 5817 5817 + return filename_linkat(olddfd, old, newdfd, new, flags); 5844 5818 } 5845 5819 5846 5820 SYSCALL_DEFINE2(link, const char __user *, oldname, const char __user *, newname) 5847 5821 { 5848 5848 - return do_linkat(AT_FDCWD, getname(oldname), AT_FDCWD, getname(newname), 0); 5822 5822 + CLASS(filename, old)(oldname); 5823 5823 + CLASS(filename, new)(newname); 5824 5824 + return filename_linkat(AT_FDCWD, old, AT_FDCWD, new, 0); 5849 5825 } 5850 5826 5851 5827 /** ··· 6062 6040 } 6063 6041 EXPORT_SYMBOL(vfs_rename); 6064 6042 6065 6065 - int do_renameat2(int olddfd, struct filename *from, int newdfd, 6066 6066 - struct filename *to, unsigned int flags) 6043 6043 + int filename_renameat2(int olddfd, struct filename *from, 6044 6044 + int newdfd, struct filename *to, unsigned int flags) 6067 6045 { 6068 6046 struct renamedata rd; 6069 6047 struct path old_path, new_path; ··· 6072 6050 struct delegated_inode delegated_inode = { }; 6073 6051 unsigned int lookup_flags = 0; 6074 6052 bool should_retry = false; 6075 6075 - int error = -EINVAL; 6053 6053 + int error; 6076 6054 6077 6055 if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT)) 6078 6078 - goto put_names; 6056 6056 + return -EINVAL; 6079 6057 6080 6058 if ((flags & (RENAME_NOREPLACE | RENAME_WHITEOUT)) && 6081 6059 (flags & RENAME_EXCHANGE)) 6082 6082 - goto put_names; 6060 6060 + return -EINVAL; 6083 6061 6084 6062 retry: 6085 6063 error = filename_parentat(olddfd, from, lookup_flags, &old_path, 6086 6064 &old_last, &old_type); 6087 6065 if (error) 6088 6088 - goto put_names; 6066 6066 + return error; 6089 6067 6090 6068 error = filename_parentat(newdfd, to, lookup_flags, &new_path, &new_last, 6091 6069 &new_type); ··· 6162 6140 lookup_flags |= LOOKUP_REVAL; 6163 6141 goto retry; 6164 6142 } 6165 6165 - put_names: 6166 6166 - putname(from); 6167 6167 - putname(to); 6168 6143 return error; 6169 6144 } 6170 6145 6171 6146 SYSCALL_DEFINE5(renameat2, int, olddfd, const char __user *, oldname, 6172 6147 int, newdfd, const char __user *, newname, unsigned int, flags) 6173 6148 { 6174 6174 - return do_renameat2(olddfd, getname(oldname), newdfd, getname(newname), 6175 6175 - flags); 6149 6149 + CLASS(filename, old)(oldname); 6150 6150 + CLASS(filename, new)(newname); 6151 6151 + return filename_renameat2(olddfd, old, newdfd, new, flags); 6176 6152 } 6177 6153 6178 6154 SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname, 6179 6155 int, newdfd, const char __user *, newname) 6180 6156 { 6181 6181 - return do_renameat2(olddfd, getname(oldname), newdfd, getname(newname), 6182 6182 - 0); 6157 6157 + CLASS(filename, old)(oldname); 6158 6158 + CLASS(filename, new)(newname); 6159 6159 + return filename_renameat2(olddfd, old, newdfd, new, 0); 6183 6160 } 6184 6161 6185 6162 SYSCALL_DEFINE2(rename, const char __user *, oldname, const char __user *, newname) 6186 6163 { 6187 6187 - return do_renameat2(AT_FDCWD, getname(oldname), AT_FDCWD, 6188 6188 - getname(newname), 0); 6164 6164 + CLASS(filename, old)(oldname); 6165 6165 + CLASS(filename, new)(newname); 6166 6166 + return filename_renameat2(AT_FDCWD, old, AT_FDCWD, new, 0); 6189 6167 } 6190 6168 6191 6169 int readlink_copy(char __user *buffer, int buflen, const char *link, int linklen)

+6 -16

fs/namespace.c

reviewed

··· 3195 3195 lookup_flags &= ~LOOKUP_AUTOMOUNT; 3196 3196 if (flags & AT_SYMLINK_NOFOLLOW) 3197 3197 lookup_flags &= ~LOOKUP_FOLLOW; 3198 3198 - if (flags & AT_EMPTY_PATH) 3199 3199 - lookup_flags |= LOOKUP_EMPTY; 3200 3198 3201 3199 /* 3202 3200 * If we create a new mount namespace with the cloned mount tree we ··· 3208 3210 if ((flags & OPEN_TREE_CLONE) && !may_mount()) 3209 3211 return ERR_PTR(-EPERM); 3210 3212 3211 3211 - ret = user_path_at(dfd, filename, lookup_flags, &path); 3213 3213 + CLASS(filename_uflags, name)(filename, flags); 3214 3214 + ret = filename_lookup(dfd, name, lookup_flags, &path, NULL); 3212 3215 if (unlikely(ret)) 3213 3216 return ERR_PTR(ret); 3214 3217 ··· 4527 4528 { 4528 4529 struct path to_path __free(path_put) = {}; 4529 4530 struct path from_path __free(path_put) = {}; 4530 4530 - struct filename *to_name __free(putname) = NULL; 4531 4531 - struct filename *from_name __free(putname) = NULL; 4532 4531 unsigned int lflags, uflags; 4533 4532 enum mnt_tree_flags_t mflags = 0; 4534 4533 int ret = 0; ··· 4548 4551 if (flags & MOVE_MOUNT_T_EMPTY_PATH) 4549 4552 uflags = AT_EMPTY_PATH; 4550 4553 4551 4551 - to_name = getname_maybe_null(to_pathname, uflags); 4552 4552 - if (IS_ERR(to_name)) 4553 4553 - return PTR_ERR(to_name); 4554 4554 - 4554 4554 + CLASS(filename_maybe_null,to_name)(to_pathname, uflags); 4555 4555 if (!to_name && to_dfd >= 0) { 4556 4556 CLASS(fd_raw, f_to)(to_dfd); 4557 4557 if (fd_empty(f_to)) ··· 4571 4577 if (flags & MOVE_MOUNT_F_EMPTY_PATH) 4572 4578 uflags = AT_EMPTY_PATH; 4573 4579 4574 4574 - from_name = getname_maybe_null(from_pathname, uflags); 4575 4575 - if (IS_ERR(from_name)) 4576 4576 - return PTR_ERR(from_name); 4577 4577 - 4580 4580 + CLASS(filename_maybe_null,from_name)(from_pathname, uflags); 4578 4581 if (!from_name && from_dfd >= 0) { 4579 4582 CLASS(fd_raw, f_from)(from_dfd); 4580 4583 if (fd_empty(f_from)) ··· 5107 5116 lookup_flags &= ~LOOKUP_AUTOMOUNT; 5108 5117 if (flags & AT_SYMLINK_NOFOLLOW) 5109 5118 lookup_flags &= ~LOOKUP_FOLLOW; 5110 5110 - if (flags & AT_EMPTY_PATH) 5111 5111 - lookup_flags |= LOOKUP_EMPTY; 5112 5119 5113 5120 kattr = (struct mount_kattr) { 5114 5121 .lookup_flags = lookup_flags, ··· 5119 5130 if (err <= 0) 5120 5131 return err; 5121 5132 5122 5122 - err = user_path_at(dfd, path, kattr.lookup_flags, &target); 5133 5133 + CLASS(filename_uflags, name)(path, flags); 5134 5134 + err = filename_lookup(dfd, name, kattr.lookup_flags, &target, NULL); 5123 5135 if (!err) { 5124 5136 err = do_mount_setattr(&target, &kattr); 5125 5137 path_put(&target);

+2 -3

fs/ntfs3/dir.c

reviewed

··· 424 424 if (!dir_emit_dots(file, ctx)) 425 425 return 0; 426 426 427 427 - /* Allocate PATH_MAX bytes. */ 428 428 - name = __getname(); 427 427 + name = kmalloc(PATH_MAX, GFP_KERNEL); 429 428 if (!name) 430 429 return -ENOMEM; 431 430 ··· 502 503 503 504 out: 504 505 505 505 - __putname(name); 506 506 + kfree(name); 506 507 put_indx_node(node); 507 508 508 509 if (err == 1) {

+2 -2

fs/ntfs3/fsntfs.c

reviewed

··· 2627 2627 u32 uni_bytes; 2628 2628 struct ntfs_inode *ni = sbi->volume.ni; 2629 2629 /* Allocate PATH_MAX bytes. */ 2630 2630 - struct cpu_str *uni = __getname(); 2630 2630 + struct cpu_str *uni = kmalloc(PATH_MAX, GFP_KERNEL); 2631 2631 2632 2632 if (!uni) 2633 2633 return -ENOMEM; ··· 2671 2671 err = _ni_write_inode(&ni->vfs_inode, 0); 2672 2672 2673 2673 out: 2674 2674 - __putname(uni); 2674 2674 + kfree(uni); 2675 2675 return err; 2676 2676 }

+6 -7

fs/ntfs3/inode.c

reviewed

··· 1281 1281 fa |= FILE_ATTRIBUTE_READONLY; 1282 1282 1283 1283 /* Allocate PATH_MAX bytes. */ 1284 1284 - new_de = kmem_cache_zalloc(names_cachep, GFP_KERNEL); 1284 1284 + new_de = kzalloc(PATH_MAX, GFP_KERNEL); 1285 1285 if (!new_de) { 1286 1286 err = -ENOMEM; 1287 1287 goto out1; ··· 1702 1702 ntfs_mark_rec_free(sbi, ino, false); 1703 1703 1704 1704 out2: 1705 1705 - __putname(new_de); 1705 1705 + kfree(new_de); 1706 1706 kfree(rp); 1707 1707 1708 1708 out1: ··· 1723 1723 struct NTFS_DE *de; 1724 1724 1725 1725 /* Allocate PATH_MAX bytes. */ 1726 1726 - de = kmem_cache_zalloc(names_cachep, GFP_KERNEL); 1726 1726 + de = kzalloc(PATH_MAX, GFP_KERNEL); 1727 1727 if (!de) 1728 1728 return -ENOMEM; 1729 1729 ··· 1737 1737 1738 1738 err = ni_add_name(ntfs_i(d_inode(dentry->d_parent)), ni, de); 1739 1739 out: 1740 1740 - __putname(de); 1740 1740 + kfree(de); 1741 1741 return err; 1742 1742 } 1743 1743 ··· 1760 1760 if (ntfs_is_meta_file(sbi, ni->mi.rno)) 1761 1761 return -EINVAL; 1762 1762 1763 1763 - /* Allocate PATH_MAX bytes. */ 1764 1764 - de = kmem_cache_zalloc(names_cachep, GFP_KERNEL); 1763 1763 + de = kzalloc(PATH_MAX, GFP_KERNEL); 1765 1764 if (!de) 1766 1765 return -ENOMEM; 1767 1766 ··· 1796 1797 1797 1798 out: 1798 1799 ni_unlock(ni); 1799 1799 - __putname(de); 1800 1800 + kfree(de); 1800 1801 return err; 1801 1802 } 1802 1803

+8 -9

fs/ntfs3/namei.c

reviewed

··· 68 68 u32 flags) 69 69 { 70 70 struct ntfs_inode *ni = ntfs_i(dir); 71 71 - struct cpu_str *uni = __getname(); 71 71 + struct cpu_str *uni = kmalloc(PATH_MAX, GFP_KERNEL); 72 72 struct inode *inode; 73 73 int err; 74 74 ··· 85 85 inode = dir_search_u(dir, uni, NULL); 86 86 ni_unlock(ni); 87 87 } 88 88 - __putname(uni); 88 88 + kfree(uni); 89 89 } 90 90 91 91 /* ··· 303 303 return err; 304 304 } 305 305 306 306 - /* Allocate PATH_MAX bytes. */ 307 307 - de = __getname(); 306 306 + de = kmalloc(PATH_MAX, GFP_KERNEL); 308 307 if (!de) 309 308 return -ENOMEM; 310 309 ··· 348 349 ni_unlock(ni); 349 350 ni_unlock(dir_ni); 350 351 out: 351 351 - __putname(de); 352 352 + kfree(de); 352 353 return err; 353 354 } 354 355 ··· 406 407 /* 407 408 * Try slow way with current upcase table 408 409 */ 409 409 - uni = kmem_cache_alloc(names_cachep, GFP_NOWAIT); 410 410 + uni = kmalloc(PATH_MAX, GFP_NOWAIT); 410 411 if (!uni) 411 412 return -ENOMEM; 412 413 ··· 428 429 err = 0; 429 430 430 431 out: 431 431 - kmem_cache_free(names_cachep, uni); 432 432 + kfree(uni); 432 433 return err; 433 434 } 434 435 ··· 467 468 * Try slow way with current upcase table 468 469 */ 469 470 sbi = dentry->d_sb->s_fs_info; 470 470 - uni1 = __getname(); 471 471 + uni1 = kmalloc(PATH_MAX, GFP_NOWAIT); 471 472 if (!uni1) 472 473 return -ENOMEM; 473 474 ··· 497 498 ret = !ntfs_cmp_names_cpu(uni1, uni2, sbi->upcase, false) ? 0 : 1; 498 499 499 500 out: 500 500 - __putname(uni1); 501 501 + kfree(uni1); 501 502 return ret; 502 503 } 503 504

+2 -3

fs/ntfs3/xattr.c

reviewed

··· 556 556 if (unlikely(is_bad_ni(ni))) 557 557 return ERR_PTR(-EINVAL); 558 558 559 559 - /* Allocate PATH_MAX bytes. */ 560 560 - buf = __getname(); 559 559 + buf = kmalloc(PATH_MAX, GFP_KERNEL); 561 560 if (!buf) 562 561 return ERR_PTR(-ENOMEM); 563 562 ··· 587 588 if (!IS_ERR(acl)) 588 589 set_cached_acl(inode, type, acl); 589 590 590 590 - __putname(buf); 591 591 + kfree(buf); 591 592 592 593 return acl; 593 594 }

+47 -72

fs/open.c

reviewed

··· 135 135 if (length < 0) /* sorry, but loff_t says... */ 136 136 return -EINVAL; 137 137 138 138 + CLASS(filename, name)(pathname); 138 139 retry: 139 139 - error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path); 140 140 + error = filename_lookup(AT_FDCWD, name, lookup_flags, &path, NULL); 140 141 if (!error) { 141 142 error = vfs_truncate(&path, length); 142 143 path_put(&path); 143 143 - } 144 144 - if (retry_estale(error, lookup_flags)) { 145 145 - lookup_flags |= LOOKUP_REVAL; 146 146 - goto retry; 144 144 + if (retry_estale(error, lookup_flags)) { 145 145 + lookup_flags |= LOOKUP_REVAL; 146 146 + goto retry; 147 147 + } 147 148 } 148 149 return error; 149 150 } ··· 478 477 479 478 if (flags & AT_SYMLINK_NOFOLLOW) 480 479 lookup_flags &= ~LOOKUP_FOLLOW; 481 481 - if (flags & AT_EMPTY_PATH) 482 482 - lookup_flags |= LOOKUP_EMPTY; 483 480 484 481 if (access_need_override_creds(flags)) { 485 482 old_cred = access_override_creds(); ··· 485 486 return -ENOMEM; 486 487 } 487 488 489 489 + CLASS(filename_uflags, name)(filename, flags); 488 490 retry: 489 489 - res = user_path_at(dfd, filename, lookup_flags, &path); 491 491 + res = filename_lookup(dfd, name, lookup_flags, &path, NULL); 490 492 if (res) 491 493 goto out; 492 494 ··· 554 554 struct path path; 555 555 int error; 556 556 unsigned int lookup_flags = LOOKUP_FOLLOW | LOOKUP_DIRECTORY; 557 557 + CLASS(filename, name)(filename); 557 558 retry: 558 558 - error = user_path_at(AT_FDCWD, filename, lookup_flags, &path); 559 559 - if (error) 560 560 - goto out; 561 561 - 562 562 - error = path_permission(&path, MAY_EXEC | MAY_CHDIR); 563 563 - if (error) 564 564 - goto dput_and_out; 565 565 - 566 566 - set_fs_pwd(current->fs, &path); 567 567 - 568 568 - dput_and_out: 569 569 - path_put(&path); 570 570 - if (retry_estale(error, lookup_flags)) { 571 571 - lookup_flags |= LOOKUP_REVAL; 572 572 - goto retry; 559 559 + error = filename_lookup(AT_FDCWD, name, lookup_flags, &path, NULL); 560 560 + if (!error) { 561 561 + error = path_permission(&path, MAY_EXEC | MAY_CHDIR); 562 562 + if (!error) 563 563 + set_fs_pwd(current->fs, &path); 564 564 + path_put(&path); 565 565 + if (retry_estale(error, lookup_flags)) { 566 566 + lookup_flags |= LOOKUP_REVAL; 567 567 + goto retry; 568 568 + } 573 569 } 574 574 - out: 575 570 return error; 576 571 } 577 572 ··· 592 597 struct path path; 593 598 int error; 594 599 unsigned int lookup_flags = LOOKUP_FOLLOW | LOOKUP_DIRECTORY; 600 600 + CLASS(filename, name)(filename); 595 601 retry: 596 596 - error = user_path_at(AT_FDCWD, filename, lookup_flags, &path); 602 602 + error = filename_lookup(AT_FDCWD, name, lookup_flags, &path, NULL); 597 603 if (error) 598 598 - goto out; 604 604 + return error; 599 605 600 606 error = path_permission(&path, MAY_EXEC | MAY_CHDIR); 601 607 if (error) ··· 606 610 if (!ns_capable(current_user_ns(), CAP_SYS_CHROOT)) 607 611 goto dput_and_out; 608 612 error = security_path_chroot(&path); 609 609 - if (error) 610 610 - goto dput_and_out; 611 611 - 612 612 - set_fs_root(current->fs, &path); 613 613 - error = 0; 613 613 + if (!error) 614 614 + set_fs_root(current->fs, &path); 614 615 dput_and_out: 615 616 path_put(&path); 616 617 if (retry_estale(error, lookup_flags)) { 617 618 lookup_flags |= LOOKUP_REVAL; 618 619 goto retry; 619 620 } 620 620 - out: 621 621 return error; 622 622 } 623 623 ··· 677 685 return -EINVAL; 678 686 679 687 lookup_flags = (flags & AT_SYMLINK_NOFOLLOW) ? 0 : LOOKUP_FOLLOW; 680 680 - if (flags & AT_EMPTY_PATH) 681 681 - lookup_flags |= LOOKUP_EMPTY; 682 682 - 688 688 + CLASS(filename_uflags, name)(filename, flags); 683 689 retry: 684 684 - error = user_path_at(dfd, filename, lookup_flags, &path); 690 690 + error = filename_lookup(dfd, name, lookup_flags, &path, NULL); 685 691 if (!error) { 686 692 error = chmod_common(&path, mode); 687 693 path_put(&path); ··· 790 800 int flag) 791 801 { 792 802 struct path path; 793 793 - int error = -EINVAL; 803 803 + int error; 794 804 int lookup_flags; 795 805 796 806 if ((flag & ~(AT_SYMLINK_NOFOLLOW | AT_EMPTY_PATH)) != 0) 797 797 - goto out; 807 807 + return -EINVAL; 798 808 799 809 lookup_flags = (flag & AT_SYMLINK_NOFOLLOW) ? 0 : LOOKUP_FOLLOW; 800 800 - if (flag & AT_EMPTY_PATH) 801 801 - lookup_flags |= LOOKUP_EMPTY; 810 810 + CLASS(filename_uflags, name)(filename, flag); 802 811 retry: 803 803 - error = user_path_at(dfd, filename, lookup_flags, &path); 804 804 - if (error) 805 805 - goto out; 806 806 - error = mnt_want_write(path.mnt); 807 807 - if (error) 808 808 - goto out_release; 809 809 - error = chown_common(&path, user, group); 810 810 - mnt_drop_write(path.mnt); 811 811 - out_release: 812 812 - path_put(&path); 813 813 - if (retry_estale(error, lookup_flags)) { 814 814 - lookup_flags |= LOOKUP_REVAL; 815 815 - goto retry; 812 812 + error = filename_lookup(dfd, name, lookup_flags, &path, NULL); 813 813 + if (!error) { 814 814 + error = mnt_want_write(path.mnt); 815 815 + if (!error) { 816 816 + error = chown_common(&path, user, group); 817 817 + mnt_drop_write(path.mnt); 818 818 + } 819 819 + path_put(&path); 820 820 + if (retry_estale(error, lookup_flags)) { 821 821 + lookup_flags |= LOOKUP_REVAL; 822 822 + goto retry; 823 823 + } 816 824 } 817 817 - out: 818 825 return error; 819 826 } 820 827 ··· 1321 1334 int err = build_open_flags(&how, &op); 1322 1335 if (err) 1323 1336 return ERR_PTR(err); 1324 1324 - return do_filp_open(AT_FDCWD, name, &op); 1337 1337 + return do_file_open(AT_FDCWD, name, &op); 1325 1338 } 1326 1339 1327 1340 /** ··· 1337 1350 */ 1338 1351 struct file *filp_open(const char *filename, int flags, umode_t mode) 1339 1352 { 1340 1340 - struct filename *name = getname_kernel(filename); 1341 1341 - struct file *file = ERR_CAST(name); 1342 1342 - 1343 1343 - if (!IS_ERR(name)) { 1344 1344 - file = file_open_name(name, flags, mode); 1345 1345 - putname(name); 1346 1346 - } 1347 1347 - return file; 1353 1353 + CLASS(filename_kernel, name)(filename); 1354 1354 + return file_open_name(name, flags, mode); 1348 1355 } 1349 1356 EXPORT_SYMBOL(filp_open); 1350 1357 ··· 1358 1377 struct open_how *how) 1359 1378 { 1360 1379 struct open_flags op; 1361 1361 - struct filename *tmp __free(putname) = NULL; 1362 1362 - int err; 1363 1363 - 1364 1364 - err = build_open_flags(how, &op); 1380 1380 + int err = build_open_flags(how, &op); 1365 1381 if (unlikely(err)) 1366 1382 return err; 1367 1383 1368 1368 - tmp = getname(filename); 1369 1369 - if (IS_ERR(tmp)) 1370 1370 - return PTR_ERR(tmp); 1371 1371 - 1372 1372 - return FD_ADD(how->flags, do_filp_open(dfd, tmp, &op)); 1384 1384 + CLASS(filename, name)(filename); 1385 1385 + return FD_ADD(how->flags, do_file_open(dfd, name, &op)); 1373 1386 } 1374 1387 1375 1388 int do_sys_open(int dfd, const char __user *filename, int flags, umode_t mode)

+1 -2

fs/quota/quota.c

reviewed

··· 867 867 { 868 868 #ifdef CONFIG_BLOCK 869 869 struct super_block *sb; 870 870 - struct filename *tmp = getname(special); 870 870 + CLASS(filename, tmp)(special); 871 871 bool excl = false, thawed = false; 872 872 int error; 873 873 dev_t dev; ··· 875 875 if (IS_ERR(tmp)) 876 876 return ERR_CAST(tmp); 877 877 error = lookup_bdev(tmp->name, &dev); 878 878 - putname(tmp); 879 878 if (error) 880 879 return ERR_PTR(error); 881 880

+2 -13

fs/smb/server/vfs.c

reviewed

··· 54 54 struct path *path, bool for_remove) 55 55 { 56 56 struct qstr last; 57 57 - struct filename *filename __free(putname) = NULL; 58 57 const struct path *root_share_path = &share_conf->vfs_path; 59 58 int err, type; 60 59 struct dentry *d; ··· 65 66 flags |= LOOKUP_BENEATH; 66 67 } 67 68 68 68 - filename = getname_kernel(pathname); 69 69 - if (IS_ERR(filename)) 70 70 - return PTR_ERR(filename); 71 71 - 69 69 + CLASS(filename_kernel, filename)(pathname); 72 70 err = vfs_path_parent_lookup(filename, flags, 73 71 path, &last, &type, 74 72 root_share_path); ··· 663 667 struct path new_path; 664 668 struct qstr new_last; 665 669 struct renamedata rd; 666 666 - struct filename *to; 667 670 struct ksmbd_share_config *share_conf = work->tcon->share_conf; 668 671 struct ksmbd_file *parent_fp; 669 672 int new_type; ··· 671 676 if (ksmbd_override_fsids(work)) 672 677 return -ENOMEM; 673 678 674 674 - to = getname_kernel(newname); 675 675 - if (IS_ERR(to)) { 676 676 - err = PTR_ERR(to); 677 677 - goto revert_fsids; 678 678 - } 679 679 + CLASS(filename_kernel, to)(newname); 679 680 680 681 retry: 681 682 err = vfs_path_parent_lookup(to, lookup_flags | LOOKUP_BENEATH, ··· 730 739 goto retry; 731 740 } 732 741 out1: 733 733 - putname(to); 734 734 - revert_fsids: 735 742 ksmbd_revert_fsids(work); 736 743 return err; 737 744 }

+8 -20

fs/stat.c

reviewed

··· 365 365 int vfs_fstatat(int dfd, const char __user *filename, 366 366 struct kstat *stat, int flags) 367 367 { 368 368 - int ret; 369 369 - int statx_flags = flags | AT_NO_AUTOMOUNT; 370 370 - struct filename *name = getname_maybe_null(filename, flags); 368 368 + CLASS(filename_maybe_null, name)(filename, flags); 371 369 372 370 if (!name && dfd >= 0) 373 371 return vfs_fstat(dfd, stat); 374 372 375 375 - ret = vfs_statx(dfd, name, statx_flags, stat, STATX_BASIC_STATS); 376 376 - putname(name); 377 377 - 378 378 - return ret; 373 373 + return vfs_statx(dfd, name, flags | AT_NO_AUTOMOUNT, 374 374 + stat, STATX_BASIC_STATS); 379 375 } 380 376 381 377 #ifdef __ARCH_WANT_OLD_STAT ··· 560 564 char __user *buf, int bufsiz) 561 565 { 562 566 struct path path; 563 563 - struct filename *name; 564 567 int error; 565 565 - unsigned int lookup_flags = LOOKUP_EMPTY; 568 568 + unsigned int lookup_flags = 0; 566 569 567 570 if (bufsiz <= 0) 568 571 return -EINVAL; 569 572 573 573 + CLASS(filename_flags, name)(pathname, LOOKUP_EMPTY); 570 574 retry: 571 571 - name = getname_flags(pathname, lookup_flags); 572 575 error = filename_lookup(dfd, name, lookup_flags, &path, NULL); 573 573 - if (unlikely(error)) { 574 574 - putname(name); 576 576 + if (unlikely(error)) 575 577 return error; 576 576 - } 577 578 578 579 /* 579 580 * AFS mountpoints allow readlink(2) but are not symlinks ··· 586 593 error = (name->name[0] == '\0') ? -ENOENT : -EINVAL; 587 594 } 588 595 path_put(&path); 589 589 - putname(name); 590 596 if (retry_estale(error, lookup_flags)) { 591 597 lookup_flags |= LOOKUP_REVAL; 592 598 goto retry; ··· 806 814 unsigned int, mask, 807 815 struct statx __user *, buffer) 808 816 { 809 809 - int ret; 810 810 - struct filename *name = getname_maybe_null(filename, flags); 817 817 + CLASS(filename_maybe_null, name)(filename, flags); 811 818 812 819 if (!name && dfd >= 0) 813 820 return do_statx_fd(dfd, flags & ~AT_NO_AUTOMOUNT, mask, buffer); 814 821 815 815 - ret = do_statx(dfd, name, flags, mask, buffer); 816 816 - putname(name); 817 817 - 818 818 - return ret; 822 822 + return do_statx(dfd, name, flags, mask, buffer); 819 823 } 820 824 821 825 #if defined(CONFIG_COMPAT) && defined(__ARCH_WANT_COMPAT_STAT)

+2 -1

fs/statfs.c

reviewed

··· 99 99 struct path path; 100 100 int error; 101 101 unsigned int lookup_flags = LOOKUP_FOLLOW|LOOKUP_AUTOMOUNT; 102 102 + CLASS(filename, name)(pathname); 102 103 retry: 103 103 - error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path); 104 104 + error = filename_lookup(AT_FDCWD, name, lookup_flags, &path, NULL); 104 105 if (!error) { 105 106 error = vfs_statfs(&path, st); 106 107 path_put(&path);

+3 -5

fs/utimes.c

reviewed

··· 8 8 #include <linux/compat.h> 9 9 #include <asm/unistd.h> 10 10 #include <linux/filelock.h> 11 11 + #include "internal.h" 11 12 12 13 static bool nsec_valid(long nsec) 13 14 { ··· 90 89 91 90 if (!(flags & AT_SYMLINK_NOFOLLOW)) 92 91 lookup_flags |= LOOKUP_FOLLOW; 93 93 - if (flags & AT_EMPTY_PATH) 94 94 - lookup_flags |= LOOKUP_EMPTY; 95 92 93 93 + CLASS(filename_uflags, name)(filename, flags); 96 94 retry: 97 97 - error = user_path_at(dfd, filename, lookup_flags, &path); 95 95 + error = filename_lookup(dfd, name, lookup_flags, &path, NULL); 98 96 if (error) 99 97 return error; 100 100 - 101 98 error = vfs_utimes(&path, times); 102 99 path_put(&path); 103 100 if (retry_estale(error, lookup_flags)) { 104 101 lookup_flags |= LOOKUP_REVAL; 105 102 goto retry; 106 103 } 107 107 - 108 104 return error; 109 105 } 110 106

+8 -25

fs/xattr.c

reviewed

··· 649 649 return error; 650 650 } 651 651 652 652 - /* unconditionally consumes filename */ 653 652 int filename_setxattr(int dfd, struct filename *filename, 654 653 unsigned int lookup_flags, struct kernel_xattr_ctx *ctx) 655 654 { ··· 658 659 retry: 659 660 error = filename_lookup(dfd, filename, lookup_flags, &path, NULL); 660 661 if (error) 661 661 - goto out; 662 662 + return error; 662 663 error = mnt_want_write(path.mnt); 663 664 if (!error) { 664 665 error = do_setxattr(mnt_idmap(path.mnt), path.dentry, ctx); ··· 669 670 lookup_flags |= LOOKUP_REVAL; 670 671 goto retry; 671 672 } 672 672 - 673 673 - out: 674 674 - putname(filename); 675 673 return error; 676 674 } 677 675 ··· 684 688 .kname = &kname, 685 689 .flags = flags, 686 690 }; 687 687 - struct filename *filename; 688 691 unsigned int lookup_flags = 0; 689 692 int error; 690 693 ··· 697 702 if (error) 698 703 return error; 699 704 700 700 - filename = getname_maybe_null(pathname, at_flags); 705 705 + CLASS(filename_maybe_null, filename)(pathname, at_flags); 701 706 if (!filename && dfd >= 0) { 702 707 CLASS(fd, f)(dfd); 703 708 if (fd_empty(f)) ··· 799 804 return do_getxattr(file_mnt_idmap(f), f->f_path.dentry, ctx); 800 805 } 801 806 802 802 - /* unconditionally consumes filename */ 803 807 ssize_t filename_getxattr(int dfd, struct filename *filename, 804 808 unsigned int lookup_flags, struct kernel_xattr_ctx *ctx) 805 809 { ··· 807 813 retry: 808 814 error = filename_lookup(dfd, filename, lookup_flags, &path, NULL); 809 815 if (error) 810 810 - goto out; 816 816 + return error; 811 817 error = do_getxattr(mnt_idmap(path.mnt), path.dentry, ctx); 812 818 path_put(&path); 813 819 if (retry_estale(error, lookup_flags)) { 814 820 lookup_flags |= LOOKUP_REVAL; 815 821 goto retry; 816 822 } 817 817 - out: 818 818 - putname(filename); 819 823 return error; 820 824 } 821 825 ··· 828 836 .kname = &kname, 829 837 .flags = 0, 830 838 }; 831 831 - struct filename *filename; 832 839 ssize_t error; 833 840 834 841 if ((at_flags & ~(AT_SYMLINK_NOFOLLOW | AT_EMPTY_PATH)) != 0) ··· 837 846 if (error) 838 847 return error; 839 848 840 840 - filename = getname_maybe_null(pathname, at_flags); 849 849 + CLASS(filename_maybe_null, filename)(pathname, at_flags); 841 850 if (!filename && dfd >= 0) { 842 851 CLASS(fd, f)(dfd); 843 852 if (fd_empty(f)) ··· 934 943 return listxattr(f->f_path.dentry, list, size); 935 944 } 936 945 937 937 - /* unconditionally consumes filename */ 938 946 static 939 947 ssize_t filename_listxattr(int dfd, struct filename *filename, 940 948 unsigned int lookup_flags, ··· 944 954 retry: 945 955 error = filename_lookup(dfd, filename, lookup_flags, &path, NULL); 946 956 if (error) 947 947 - goto out; 957 957 + return error; 948 958 error = listxattr(path.dentry, list, size); 949 959 path_put(&path); 950 960 if (retry_estale(error, lookup_flags)) { 951 961 lookup_flags |= LOOKUP_REVAL; 952 962 goto retry; 953 963 } 954 954 - out: 955 955 - putname(filename); 956 964 return error; 957 965 } 958 966 ··· 958 970 unsigned int at_flags, char __user *list, 959 971 size_t size) 960 972 { 961 961 - struct filename *filename; 962 973 int lookup_flags; 963 974 964 975 if ((at_flags & ~(AT_SYMLINK_NOFOLLOW | AT_EMPTY_PATH)) != 0) 965 976 return -EINVAL; 966 977 967 967 - filename = getname_maybe_null(pathname, at_flags); 978 978 + CLASS(filename_maybe_null, filename)(pathname, at_flags); 968 979 if (!filename) { 969 980 CLASS(fd, f)(dfd); 970 981 if (fd_empty(f)) ··· 1023 1036 return error; 1024 1037 } 1025 1038 1026 1026 - /* unconditionally consumes filename */ 1027 1039 static int filename_removexattr(int dfd, struct filename *filename, 1028 1040 unsigned int lookup_flags, struct xattr_name *kname) 1029 1041 { ··· 1032 1046 retry: 1033 1047 error = filename_lookup(dfd, filename, lookup_flags, &path, NULL); 1034 1048 if (error) 1035 1035 - goto out; 1049 1049 + return error; 1036 1050 error = mnt_want_write(path.mnt); 1037 1051 if (!error) { 1038 1052 error = removexattr(mnt_idmap(path.mnt), path.dentry, kname->name); ··· 1043 1057 lookup_flags |= LOOKUP_REVAL; 1044 1058 goto retry; 1045 1059 } 1046 1046 - out: 1047 1047 - putname(filename); 1048 1060 return error; 1049 1061 } 1050 1062 ··· 1050 1066 unsigned int at_flags, const char __user *name) 1051 1067 { 1052 1068 struct xattr_name kname; 1053 1053 - struct filename *filename; 1054 1069 unsigned int lookup_flags; 1055 1070 int error; 1056 1071 ··· 1060 1077 if (error) 1061 1078 return error; 1062 1079 1063 1063 - filename = getname_maybe_null(pathname, at_flags); 1080 1080 + CLASS(filename_maybe_null, filename)(pathname, at_flags); 1064 1081 if (!filename) { 1065 1082 CLASS(fd, f)(dfd); 1066 1083 if (fd_empty(f))

+2 -1

include/asm-generic/vmlinux.lds.h

reviewed

··· 972 972 #define RUNTIME_CONST_VARIABLES \ 973 973 RUNTIME_CONST(shift, d_hash_shift) \ 974 974 RUNTIME_CONST(ptr, dentry_hashtable) \ 975 975 - RUNTIME_CONST(ptr, __dentry_cache) 975 975 + RUNTIME_CONST(ptr, __dentry_cache) \ 976 976 + RUNTIME_CONST(ptr, __names_cache) 976 977 977 978 /* Alignment must be consistent with (kunit_suite *) in include/kunit/test.h */ 978 979 #define KUNIT_TABLE() \

-11

include/linux/audit.h

reviewed

··· 318 318 extern void __audit_syscall_entry(int major, unsigned long a0, unsigned long a1, 319 319 unsigned long a2, unsigned long a3); 320 320 extern void __audit_syscall_exit(int ret_success, long ret_value); 321 321 - extern struct filename *__audit_reusename(const __user char *uptr); 322 321 extern void __audit_getname(struct filename *name); 323 322 extern void __audit_inode(struct filename *name, const struct dentry *dentry, 324 323 unsigned int flags); ··· 380 381 381 382 __audit_syscall_exit(success, return_code); 382 383 } 383 383 - } 384 384 - static inline struct filename *audit_reusename(const __user char *name) 385 385 - { 386 386 - if (unlikely(!audit_dummy_context())) 387 387 - return __audit_reusename(name); 388 388 - return NULL; 389 384 } 390 385 static inline void audit_getname(struct filename *name) 391 386 { ··· 616 623 static inline void audit_set_context(struct task_struct *task, struct audit_context *ctx) 617 624 { } 618 625 static inline struct audit_context *audit_context(void) 619 619 - { 620 620 - return NULL; 621 621 - } 622 622 - static inline struct filename *audit_reusename(const __user char *name) 623 626 { 624 627 return NULL; 625 628 }

+28 -13

include/linux/fs.h

reviewed

··· 2418 2418 2419 2419 /* fs/open.c */ 2420 2420 struct audit_names; 2421 2421 - struct filename { 2421 2421 + 2422 2422 + struct __filename_head { 2422 2423 const char *name; /* pointer to actual string */ 2423 2423 - const __user char *uptr; /* original userland pointer */ 2424 2424 - atomic_t refcnt; 2424 2424 + int refcnt; 2425 2425 struct audit_names *aname; 2426 2426 - const char iname[]; 2426 2426 + }; 2427 2427 + #define EMBEDDED_NAME_MAX (192 - sizeof(struct __filename_head)) 2428 2428 + struct filename { 2429 2429 + struct __filename_head; 2430 2430 + const char iname[EMBEDDED_NAME_MAX]; 2427 2431 }; 2428 2432 static_assert(offsetof(struct filename, iname) % sizeof(long) == 0); 2433 2433 + static_assert(sizeof(struct filename) % 64 == 0); 2429 2434 2430 2435 static inline struct mnt_idmap *file_mnt_idmap(const struct file *file) 2431 2436 { ··· 2525 2520 extern void putname(struct filename *name); 2526 2521 DEFINE_FREE(putname, struct filename *, if (!IS_ERR_OR_NULL(_T)) putname(_T)) 2527 2522 2528 2528 - static inline struct filename *refname(struct filename *name) 2529 2529 - { 2530 2530 - atomic_inc(&name->refcnt); 2531 2531 - return name; 2532 2532 - } 2523 2523 + struct delayed_filename { 2524 2524 + struct filename *__incomplete_filename; // don't touch 2525 2525 + }; 2526 2526 + #define INIT_DELAYED_FILENAME(ptr) \ 2527 2527 + ((void)(*(ptr) = (struct delayed_filename){})) 2528 2528 + int delayed_getname(struct delayed_filename *, const char __user *); 2529 2529 + int delayed_getname_uflags(struct delayed_filename *v, const char __user *, int); 2530 2530 + void dismiss_delayed_filename(struct delayed_filename *); 2531 2531 + int putname_to_delayed(struct delayed_filename *, struct filename *); 2532 2532 + struct filename *complete_getname(struct delayed_filename *); 2533 2533 + 2534 2534 + DEFINE_CLASS(filename, struct filename *, putname(_T), getname(p), const char __user *p) 2535 2535 + EXTEND_CLASS(filename, _kernel, getname_kernel(p), const char *p) 2536 2536 + EXTEND_CLASS(filename, _flags, getname_flags(p, f), const char __user *p, unsigned int f) 2537 2537 + EXTEND_CLASS(filename, _uflags, getname_uflags(p, f), const char __user *p, unsigned int f) 2538 2538 + EXTEND_CLASS(filename, _maybe_null, getname_maybe_null(p, f), const char __user *p, unsigned int f) 2539 2539 + EXTEND_CLASS(filename, _complete_delayed, complete_getname(p), struct delayed_filename *p) 2533 2540 2534 2541 extern int finish_open(struct file *file, struct dentry *dentry, 2535 2542 int (*open)(struct inode *, struct file *)); ··· 2560 2543 extern void __init vfs_caches_init_early(void); 2561 2544 extern void __init vfs_caches_init(void); 2562 2545 2563 2563 - extern struct kmem_cache *names_cachep; 2564 2564 - 2565 2565 - #define __getname() kmem_cache_alloc(names_cachep, GFP_KERNEL) 2566 2566 - #define __putname(name) kmem_cache_free(names_cachep, (void *)(name)) 2546 2546 + #define __getname() kmalloc(PATH_MAX, GFP_KERNEL) 2547 2547 + #define __putname(name) kfree(name) 2567 2548 2568 2549 void emergency_thaw_all(void); 2569 2550 extern int sync_filesystem(struct super_block *);

+59 -47

io_uring/fs.c

reviewed

··· 19 19 struct file *file; 20 20 int old_dfd; 21 21 int new_dfd; 22 22 - struct filename *oldpath; 23 23 - struct filename *newpath; 22 22 + struct delayed_filename oldpath; 23 23 + struct delayed_filename newpath; 24 24 int flags; 25 25 }; 26 26 ··· 28 28 struct file *file; 29 29 int dfd; 30 30 int flags; 31 31 - struct filename *filename; 31 31 + struct delayed_filename filename; 32 32 }; 33 33 34 34 struct io_mkdir { 35 35 struct file *file; 36 36 int dfd; 37 37 umode_t mode; 38 38 - struct filename *filename; 38 38 + struct delayed_filename filename; 39 39 }; 40 40 41 41 struct io_link { 42 42 struct file *file; 43 43 int old_dfd; 44 44 int new_dfd; 45 45 - struct filename *oldpath; 46 46 - struct filename *newpath; 45 45 + struct delayed_filename oldpath; 46 46 + struct delayed_filename newpath; 47 47 int flags; 48 48 }; 49 49 ··· 51 51 { 52 52 struct io_rename *ren = io_kiocb_to_cmd(req, struct io_rename); 53 53 const char __user *oldf, *newf; 54 54 + int err; 54 55 55 56 if (sqe->buf_index || sqe->splice_fd_in) 56 57 return -EINVAL; ··· 64 63 ren->new_dfd = READ_ONCE(sqe->len); 65 64 ren->flags = READ_ONCE(sqe->rename_flags); 66 65 67 67 - ren->oldpath = getname(oldf); 68 68 - if (IS_ERR(ren->oldpath)) 69 69 - return PTR_ERR(ren->oldpath); 66 66 + err = delayed_getname(&ren->oldpath, oldf); 67 67 + if (unlikely(err)) 68 68 + return err; 70 69 71 71 - ren->newpath = getname(newf); 72 72 - if (IS_ERR(ren->newpath)) { 73 73 - putname(ren->oldpath); 74 74 - return PTR_ERR(ren->newpath); 70 70 + err = delayed_getname(&ren->newpath, newf); 71 71 + if (unlikely(err)) { 72 72 + dismiss_delayed_filename(&ren->oldpath); 73 73 + return err; 75 74 } 76 75 77 76 req->flags |= REQ_F_NEED_CLEANUP; ··· 82 81 int io_renameat(struct io_kiocb *req, unsigned int issue_flags) 83 82 { 84 83 struct io_rename *ren = io_kiocb_to_cmd(req, struct io_rename); 84 84 + CLASS(filename_complete_delayed, old)(&ren->oldpath); 85 85 + CLASS(filename_complete_delayed, new)(&ren->newpath); 85 86 int ret; 86 87 87 88 WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK); 88 89 89 89 - ret = do_renameat2(ren->old_dfd, ren->oldpath, ren->new_dfd, 90 90 - ren->newpath, ren->flags); 90 90 + ret = filename_renameat2(ren->old_dfd, old, 91 91 + ren->new_dfd, new, ren->flags); 91 92 92 93 req->flags &= ~REQ_F_NEED_CLEANUP; 93 94 io_req_set_res(req, ret, 0); ··· 100 97 { 101 98 struct io_rename *ren = io_kiocb_to_cmd(req, struct io_rename); 102 99 103 103 - putname(ren->oldpath); 104 104 - putname(ren->newpath); 100 100 + dismiss_delayed_filename(&ren->oldpath); 101 101 + dismiss_delayed_filename(&ren->newpath); 105 102 } 106 103 107 104 int io_unlinkat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe) 108 105 { 109 106 struct io_unlink *un = io_kiocb_to_cmd(req, struct io_unlink); 110 107 const char __user *fname; 108 108 + int err; 111 109 112 110 if (sqe->off || sqe->len || sqe->buf_index || sqe->splice_fd_in) 113 111 return -EINVAL; ··· 122 118 return -EINVAL; 123 119 124 120 fname = u64_to_user_ptr(READ_ONCE(sqe->addr)); 125 125 - un->filename = getname(fname); 126 126 - if (IS_ERR(un->filename)) 127 127 - return PTR_ERR(un->filename); 121 121 + err = delayed_getname(&un->filename, fname); 122 122 + if (unlikely(err)) 123 123 + return err; 128 124 129 125 req->flags |= REQ_F_NEED_CLEANUP; 130 126 req->flags |= REQ_F_FORCE_ASYNC; ··· 134 130 int io_unlinkat(struct io_kiocb *req, unsigned int issue_flags) 135 131 { 136 132 struct io_unlink *un = io_kiocb_to_cmd(req, struct io_unlink); 133 133 + CLASS(filename_complete_delayed, name)(&un->filename); 137 134 int ret; 138 135 139 136 WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK); 140 137 141 138 if (un->flags & AT_REMOVEDIR) 142 142 - ret = do_rmdir(un->dfd, un->filename); 139 139 + ret = filename_rmdir(un->dfd, name); 143 140 else 144 144 - ret = do_unlinkat(un->dfd, un->filename); 141 141 + ret = filename_unlinkat(un->dfd, name); 145 142 146 143 req->flags &= ~REQ_F_NEED_CLEANUP; 147 144 io_req_set_res(req, ret, 0); ··· 153 148 { 154 149 struct io_unlink *ul = io_kiocb_to_cmd(req, struct io_unlink); 155 150 156 156 - putname(ul->filename); 151 151 + dismiss_delayed_filename(&ul->filename); 157 152 } 158 153 159 154 int io_mkdirat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe) 160 155 { 161 156 struct io_mkdir *mkd = io_kiocb_to_cmd(req, struct io_mkdir); 162 157 const char __user *fname; 158 158 + int err; 163 159 164 160 if (sqe->off || sqe->rw_flags || sqe->buf_index || sqe->splice_fd_in) 165 161 return -EINVAL; ··· 171 165 mkd->mode = READ_ONCE(sqe->len); 172 166 173 167 fname = u64_to_user_ptr(READ_ONCE(sqe->addr)); 174 174 - mkd->filename = getname(fname); 175 175 - if (IS_ERR(mkd->filename)) 176 176 - return PTR_ERR(mkd->filename); 168 168 + err = delayed_getname(&mkd->filename, fname); 169 169 + if (unlikely(err)) 170 170 + return err; 177 171 178 172 req->flags |= REQ_F_NEED_CLEANUP; 179 173 req->flags |= REQ_F_FORCE_ASYNC; ··· 183 177 int io_mkdirat(struct io_kiocb *req, unsigned int issue_flags) 184 178 { 185 179 struct io_mkdir *mkd = io_kiocb_to_cmd(req, struct io_mkdir); 180 180 + CLASS(filename_complete_delayed, name)(&mkd->filename); 186 181 int ret; 187 182 188 183 WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK); 189 184 190 190 - ret = do_mkdirat(mkd->dfd, mkd->filename, mkd->mode); 185 185 + ret = filename_mkdirat(mkd->dfd, name, mkd->mode); 191 186 192 187 req->flags &= ~REQ_F_NEED_CLEANUP; 193 188 io_req_set_res(req, ret, 0); ··· 199 192 { 200 193 struct io_mkdir *md = io_kiocb_to_cmd(req, struct io_mkdir); 201 194 202 202 - putname(md->filename); 195 195 + dismiss_delayed_filename(&md->filename); 203 196 } 204 197 205 198 int io_symlinkat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe) 206 199 { 207 200 struct io_link *sl = io_kiocb_to_cmd(req, struct io_link); 208 201 const char __user *oldpath, *newpath; 202 202 + int err; 209 203 210 204 if (sqe->len || sqe->rw_flags || sqe->buf_index || sqe->splice_fd_in) 211 205 return -EINVAL; ··· 217 209 oldpath = u64_to_user_ptr(READ_ONCE(sqe->addr)); 218 210 newpath = u64_to_user_ptr(READ_ONCE(sqe->addr2)); 219 211 220 220 - sl->oldpath = getname(oldpath); 221 221 - if (IS_ERR(sl->oldpath)) 222 222 - return PTR_ERR(sl->oldpath); 212 212 + err = delayed_getname(&sl->oldpath, oldpath); 213 213 + if (unlikely(err)) 214 214 + return err; 223 215 224 224 - sl->newpath = getname(newpath); 225 225 - if (IS_ERR(sl->newpath)) { 226 226 - putname(sl->oldpath); 227 227 - return PTR_ERR(sl->newpath); 216 216 + err = delayed_getname(&sl->newpath, newpath); 217 217 + if (unlikely(err)) { 218 218 + dismiss_delayed_filename(&sl->oldpath); 219 219 + return err; 228 220 } 229 221 230 222 req->flags |= REQ_F_NEED_CLEANUP; ··· 235 227 int io_symlinkat(struct io_kiocb *req, unsigned int issue_flags) 236 228 { 237 229 struct io_link *sl = io_kiocb_to_cmd(req, struct io_link); 230 230 + CLASS(filename_complete_delayed, old)(&sl->oldpath); 231 231 + CLASS(filename_complete_delayed, new)(&sl->newpath); 238 232 int ret; 239 233 240 234 WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK); 241 235 242 242 - ret = do_symlinkat(sl->oldpath, sl->new_dfd, sl->newpath); 236 236 + ret = filename_symlinkat(old, sl->new_dfd, new); 243 237 244 238 req->flags &= ~REQ_F_NEED_CLEANUP; 245 239 io_req_set_res(req, ret, 0); ··· 252 242 { 253 243 struct io_link *lnk = io_kiocb_to_cmd(req, struct io_link); 254 244 const char __user *oldf, *newf; 245 245 + int err; 255 246 256 247 if (sqe->buf_index || sqe->splice_fd_in) 257 248 return -EINVAL; ··· 265 254 newf = u64_to_user_ptr(READ_ONCE(sqe->addr2)); 266 255 lnk->flags = READ_ONCE(sqe->hardlink_flags); 267 256 268 268 - lnk->oldpath = getname_uflags(oldf, lnk->flags); 269 269 - if (IS_ERR(lnk->oldpath)) 270 270 - return PTR_ERR(lnk->oldpath); 257 257 + err = delayed_getname_uflags(&lnk->oldpath, oldf, lnk->flags); 258 258 + if (unlikely(err)) 259 259 + return err; 271 260 272 272 - lnk->newpath = getname(newf); 273 273 - if (IS_ERR(lnk->newpath)) { 274 274 - putname(lnk->oldpath); 275 275 - return PTR_ERR(lnk->newpath); 261 261 + err = delayed_getname(&lnk->newpath, newf); 262 262 + if (unlikely(err)) { 263 263 + dismiss_delayed_filename(&lnk->oldpath); 264 264 + return err; 276 265 } 277 266 278 267 req->flags |= REQ_F_NEED_CLEANUP; ··· 283 272 int io_linkat(struct io_kiocb *req, unsigned int issue_flags) 284 273 { 285 274 struct io_link *lnk = io_kiocb_to_cmd(req, struct io_link); 275 275 + CLASS(filename_complete_delayed, old)(&lnk->oldpath); 276 276 + CLASS(filename_complete_delayed, new)(&lnk->newpath); 286 277 int ret; 287 278 288 279 WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK); 289 280 290 290 - ret = do_linkat(lnk->old_dfd, lnk->oldpath, lnk->new_dfd, 291 291 - lnk->newpath, lnk->flags); 281 281 + ret = filename_linkat(lnk->old_dfd, old, lnk->new_dfd, new, lnk->flags); 292 282 293 283 req->flags &= ~REQ_F_NEED_CLEANUP; 294 284 io_req_set_res(req, ret, 0); ··· 300 288 { 301 289 struct io_link *sl = io_kiocb_to_cmd(req, struct io_link); 302 290 303 303 - putname(sl->oldpath); 304 304 - putname(sl->newpath); 291 291 + dismiss_delayed_filename(&sl->oldpath); 292 292 + dismiss_delayed_filename(&sl->newpath); 305 293 }

+13 -13

io_uring/openclose.c

reviewed

··· 23 23 struct file *file; 24 24 int dfd; 25 25 u32 file_slot; 26 26 - struct filename *filename; 26 26 + struct delayed_filename filename; 27 27 struct open_how how; 28 28 unsigned long nofile; 29 29 }; ··· 67 67 68 68 open->dfd = READ_ONCE(sqe->fd); 69 69 fname = u64_to_user_ptr(READ_ONCE(sqe->addr)); 70 70 - open->filename = getname(fname); 71 71 - if (IS_ERR(open->filename)) { 72 72 - ret = PTR_ERR(open->filename); 73 73 - open->filename = NULL; 70 70 + ret = delayed_getname(&open->filename, fname); 71 71 + if (unlikely(ret)) 74 72 return ret; 75 75 - } 76 73 req->flags |= REQ_F_NEED_CLEANUP; 77 74 78 75 open->file_slot = READ_ONCE(sqe->file_index); ··· 118 121 struct file *file; 119 122 bool resolve_nonblock, nonblock_set; 120 123 bool fixed = !!open->file_slot; 124 124 + CLASS(filename_complete_delayed, name)(&open->filename); 121 125 int ret; 122 126 123 127 ret = build_open_flags(&open->how, &op); ··· 138 140 goto err; 139 141 } 140 142 141 141 - file = do_filp_open(open->dfd, open->filename, &op); 143 143 + file = do_file_open(open->dfd, name, &op); 142 144 if (IS_ERR(file)) { 143 145 /* 144 146 * We could hang on to this 'fd' on retrying, but seems like ··· 150 152 151 153 ret = PTR_ERR(file); 152 154 /* only retry if RESOLVE_CACHED wasn't already set by application */ 153 153 - if (ret == -EAGAIN && 154 154 - (!resolve_nonblock && (issue_flags & IO_URING_F_NONBLOCK))) 155 155 - return -EAGAIN; 155 155 + if (ret == -EAGAIN && !resolve_nonblock && 156 156 + (issue_flags & IO_URING_F_NONBLOCK)) { 157 157 + ret = putname_to_delayed(&open->filename, 158 158 + no_free_ptr(name)); 159 159 + if (likely(!ret)) 160 160 + return -EAGAIN; 161 161 + } 156 162 goto err; 157 163 } 158 164 ··· 169 167 ret = io_fixed_fd_install(req, issue_flags, file, 170 168 open->file_slot); 171 169 err: 172 172 - putname(open->filename); 173 170 req->flags &= ~REQ_F_NEED_CLEANUP; 174 171 if (ret < 0) 175 172 req_set_fail(req); ··· 185 184 { 186 185 struct io_open *open = io_kiocb_to_cmd(req, struct io_open); 187 186 188 188 - if (open->filename) 189 189 - putname(open->filename); 187 187 + dismiss_delayed_filename(&open->filename); 190 188 } 191 189 192 190 int __io_close_fixed(struct io_ring_ctx *ctx, unsigned int issue_flags,

+7 -10

io_uring/statx.c

reviewed

··· 16 16 int dfd; 17 17 unsigned int mask; 18 18 unsigned int flags; 19 19 - struct filename *filename; 19 19 + struct delayed_filename filename; 20 20 struct statx __user *buffer; 21 21 }; 22 22 ··· 24 24 { 25 25 struct io_statx *sx = io_kiocb_to_cmd(req, struct io_statx); 26 26 const char __user *path; 27 27 + int ret; 27 28 28 29 if (sqe->buf_index || sqe->splice_fd_in) 29 30 return -EINVAL; ··· 37 36 sx->buffer = u64_to_user_ptr(READ_ONCE(sqe->addr2)); 38 37 sx->flags = READ_ONCE(sqe->statx_flags); 39 38 40 40 - sx->filename = getname_uflags(path, sx->flags); 39 39 + ret = delayed_getname_uflags(&sx->filename, path, sx->flags); 41 40 42 42 - if (IS_ERR(sx->filename)) { 43 43 - int ret = PTR_ERR(sx->filename); 44 44 - 45 45 - sx->filename = NULL; 41 41 + if (unlikely(ret)) 46 42 return ret; 47 47 - } 48 43 49 44 req->flags |= REQ_F_NEED_CLEANUP; 50 45 req->flags |= REQ_F_FORCE_ASYNC; ··· 50 53 int io_statx(struct io_kiocb *req, unsigned int issue_flags) 51 54 { 52 55 struct io_statx *sx = io_kiocb_to_cmd(req, struct io_statx); 56 56 + CLASS(filename_complete_delayed, name)(&sx->filename); 53 57 int ret; 54 58 55 59 WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK); 56 60 57 57 - ret = do_statx(sx->dfd, sx->filename, sx->flags, sx->mask, sx->buffer); 61 61 + ret = do_statx(sx->dfd, name, sx->flags, sx->mask, sx->buffer); 58 62 io_req_set_res(req, ret, 0); 59 63 return IOU_COMPLETE; 60 64 } ··· 64 66 { 65 67 struct io_statx *sx = io_kiocb_to_cmd(req, struct io_statx); 66 68 67 67 - if (sx->filename) 68 68 - putname(sx->filename); 69 69 + dismiss_delayed_filename(&sx->filename); 69 70 }

+10 -20

io_uring/xattr.c

reviewed

··· 19 19 struct io_xattr { 20 20 struct file *file; 21 21 struct kernel_xattr_ctx ctx; 22 22 - struct filename *filename; 22 22 + struct delayed_filename filename; 23 23 }; 24 24 25 25 void io_xattr_cleanup(struct io_kiocb *req) 26 26 { 27 27 struct io_xattr *ix = io_kiocb_to_cmd(req, struct io_xattr); 28 28 29 29 - if (ix->filename) 30 30 - putname(ix->filename); 31 31 - 29 29 + dismiss_delayed_filename(&ix->filename); 32 30 kfree(ix->ctx.kname); 33 31 kvfree(ix->ctx.kvalue); 34 32 } ··· 46 48 const char __user *name; 47 49 int ret; 48 50 49 49 - ix->filename = NULL; 51 51 + INIT_DELAYED_FILENAME(&ix->filename); 50 52 ix->ctx.kvalue = NULL; 51 53 name = u64_to_user_ptr(READ_ONCE(sqe->addr)); 52 54 ix->ctx.value = u64_to_user_ptr(READ_ONCE(sqe->addr2)); ··· 91 93 92 94 path = u64_to_user_ptr(READ_ONCE(sqe->addr3)); 93 95 94 94 - ix->filename = getname(path); 95 95 - if (IS_ERR(ix->filename)) 96 96 - return PTR_ERR(ix->filename); 97 97 - 98 98 - return 0; 96 96 + return delayed_getname(&ix->filename, path); 99 97 } 100 98 101 99 int io_fgetxattr(struct io_kiocb *req, unsigned int issue_flags) ··· 109 115 int io_getxattr(struct io_kiocb *req, unsigned int issue_flags) 110 116 { 111 117 struct io_xattr *ix = io_kiocb_to_cmd(req, struct io_xattr); 118 118 + CLASS(filename_complete_delayed, name)(&ix->filename); 112 119 int ret; 113 120 114 121 WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK); 115 122 116 116 - ret = filename_getxattr(AT_FDCWD, ix->filename, LOOKUP_FOLLOW, &ix->ctx); 117 117 - ix->filename = NULL; 123 123 + ret = filename_getxattr(AT_FDCWD, name, LOOKUP_FOLLOW, &ix->ctx); 118 124 io_xattr_finish(req, ret); 119 125 return IOU_COMPLETE; 120 126 } ··· 126 132 const char __user *name; 127 133 int ret; 128 134 129 129 - ix->filename = NULL; 135 135 + INIT_DELAYED_FILENAME(&ix->filename); 130 136 name = u64_to_user_ptr(READ_ONCE(sqe->addr)); 131 137 ix->ctx.cvalue = u64_to_user_ptr(READ_ONCE(sqe->addr2)); 132 138 ix->ctx.kvalue = NULL; ··· 163 169 164 170 path = u64_to_user_ptr(READ_ONCE(sqe->addr3)); 165 171 166 166 - ix->filename = getname(path); 167 167 - if (IS_ERR(ix->filename)) 168 168 - return PTR_ERR(ix->filename); 169 169 - 170 170 - return 0; 172 172 + return delayed_getname(&ix->filename, path); 171 173 } 172 174 173 175 int io_fsetxattr_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe) ··· 186 196 int io_setxattr(struct io_kiocb *req, unsigned int issue_flags) 187 197 { 188 198 struct io_xattr *ix = io_kiocb_to_cmd(req, struct io_xattr); 199 199 + CLASS(filename_complete_delayed, name)(&ix->filename); 189 200 int ret; 190 201 191 202 WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK); 192 203 193 193 - ret = filename_setxattr(AT_FDCWD, ix->filename, LOOKUP_FOLLOW, &ix->ctx); 194 194 - ix->filename = NULL; 204 204 + ret = filename_setxattr(AT_FDCWD, name, LOOKUP_FOLLOW, &ix->ctx); 195 205 io_xattr_finish(req, ret); 196 206 return IOU_COMPLETE; 197 207 }

+3 -8

ipc/mqueue.c

reviewed

··· 912 912 static int do_mq_open(const char __user *u_name, int oflag, umode_t mode, 913 913 struct mq_attr *attr) 914 914 { 915 915 - struct filename *name __free(putname) = NULL;; 916 915 struct vfsmount *mnt = current->nsproxy->ipc_ns->mq_mnt; 917 916 int fd, ro; 918 917 919 918 audit_mq_open(oflag, mode, attr); 920 919 921 921 - name = getname(u_name); 920 920 + CLASS(filename, name)(u_name); 922 921 if (IS_ERR(name)) 923 922 return PTR_ERR(name); 924 923 ··· 941 942 SYSCALL_DEFINE1(mq_unlink, const char __user *, u_name) 942 943 { 943 944 int err; 944 944 - struct filename *name; 945 945 struct dentry *dentry; 946 946 struct inode *inode; 947 947 struct ipc_namespace *ipc_ns = current->nsproxy->ipc_ns; 948 948 struct vfsmount *mnt = ipc_ns->mq_mnt; 949 949 + CLASS(filename, name)(u_name); 949 950 950 950 - name = getname(u_name); 951 951 if (IS_ERR(name)) 952 952 return PTR_ERR(name); 953 953 954 954 audit_inode_parent_hidden(name, mnt->mnt_root); 955 955 err = mnt_want_write(mnt); 956 956 if (err) 957 957 - goto out_name; 957 957 + return err; 958 958 dentry = start_removing_noperm(mnt->mnt_root, &QSTR(name->name)); 959 959 if (IS_ERR(dentry)) { 960 960 err = PTR_ERR(dentry); ··· 969 971 970 972 out_drop_write: 971 973 mnt_drop_write(mnt); 972 972 - out_name: 973 973 - putname(name); 974 974 - 975 974 return err; 976 975 } 977 976

+1 -3

kernel/acct.c

reviewed

··· 218 218 /* Difference from BSD - they don't do O_APPEND */ 219 219 const int open_flags = O_WRONLY|O_APPEND|O_LARGEFILE; 220 220 struct pid_namespace *ns = task_active_pid_ns(current); 221 221 - struct filename *pathname __free(putname) = getname(name); 222 221 struct file *original_file __free(fput) = NULL; // in that order 223 222 struct path internal __free(path_put) = {}; // in that order 224 223 struct file *file __free(fput_sync) = NULL; // in that order ··· 225 226 struct vfsmount *mnt; 226 227 struct fs_pin *old; 227 228 228 228 - if (IS_ERR(pathname)) 229 229 - return PTR_ERR(pathname); 229 229 + CLASS(filename, pathname)(name); 230 230 original_file = file_open_name(pathname, open_flags, 0); 231 231 if (IS_ERR(original_file)) 232 232 return PTR_ERR(original_file);

+3 -26

kernel/auditsc.c

reviewed

··· 2170 2170 } 2171 2171 2172 2172 /** 2173 2173 - * __audit_reusename - fill out filename with info from existing entry 2174 2174 - * @uptr: userland ptr to pathname 2175 2175 - * 2176 2176 - * Search the audit_names list for the current audit context. If there is an 2177 2177 - * existing entry with a matching "uptr" then return the filename 2178 2178 - * associated with that audit_name. If not, return NULL. 2179 2179 - */ 2180 2180 - struct filename * 2181 2181 - __audit_reusename(const __user char *uptr) 2182 2182 - { 2183 2183 - struct audit_context *context = audit_context(); 2184 2184 - struct audit_names *n; 2185 2185 - 2186 2186 - list_for_each_entry(n, &context->names_list, list) { 2187 2187 - if (!n->name) 2188 2188 - continue; 2189 2189 - if (n->name->uptr == uptr) 2190 2190 - return refname(n->name); 2191 2191 - } 2192 2192 - return NULL; 2193 2193 - } 2194 2194 - 2195 2195 - /** 2196 2173 * __audit_getname - add a name to the list 2197 2174 * @name: name to add 2198 2175 * ··· 2191 2214 n->name = name; 2192 2215 n->name_len = AUDIT_NAME_FULL; 2193 2216 name->aname = n; 2194 2194 - refname(name); 2217 2217 + name->refcnt++; 2195 2218 } 2196 2219 2197 2220 static inline int audit_copy_fcaps(struct audit_names *name, ··· 2323 2346 return; 2324 2347 if (name) { 2325 2348 n->name = name; 2326 2326 - refname(name); 2349 2349 + name->refcnt++; 2327 2350 } 2328 2351 2329 2352 out: ··· 2445 2468 if (found_parent) { 2446 2469 found_child->name = found_parent->name; 2447 2470 found_child->name_len = AUDIT_NAME_FULL; 2448 2448 - refname(found_child->name); 2471 2471 + found_child->name->refcnt++; 2449 2472 } 2450 2473 } 2451 2474

+3 -12

mm/huge_memory.c

reviewed

··· 4692 4692 pgoff_t off_end, unsigned int new_order, 4693 4693 long in_folio_offset) 4694 4694 { 4695 4695 - struct filename *file; 4696 4695 struct file *candidate; 4697 4696 struct address_space *mapping; 4698 4698 - int ret = -EINVAL; 4699 4697 pgoff_t index; 4700 4698 int nr_pages = 1; 4701 4699 unsigned long total = 0, split = 0; 4702 4700 unsigned int min_order; 4703 4701 unsigned int target_order; 4704 4702 4705 4705 - file = getname_kernel(file_path); 4706 4706 - if (IS_ERR(file)) 4707 4707 - return ret; 4708 4708 - 4703 4703 + CLASS(filename_kernel, file)(file_path); 4709 4704 candidate = file_open_name(file, O_RDONLY, 0); 4710 4705 if (IS_ERR(candidate)) 4711 4711 - goto out; 4706 4706 + return -EINVAL; 4712 4707 4713 4708 pr_debug("split file-backed THPs in file: %s, page offset: [0x%lx - 0x%lx], new_order: %u, in_folio_offset: %ld\n", 4714 4709 file_path, off_start, off_end, new_order, in_folio_offset); ··· 4752 4757 } 4753 4758 4754 4759 filp_close(candidate, NULL); 4755 4755 - ret = 0; 4756 4756 - 4757 4760 pr_debug("%lu of %lu file-backed THP split\n", split, total); 4758 4758 - out: 4759 4759 - putname(file); 4760 4760 - return ret; 4761 4761 + return 0; 4761 4762 } 4762 4763 4763 4764 #define MAX_INPUT_BUF_SZ 255

+3 -18

mm/swapfile.c

reviewed

··· 2831 2831 struct file *swap_file, *victim; 2832 2832 struct address_space *mapping; 2833 2833 struct inode *inode; 2834 2834 - struct filename *pathname; 2835 2834 unsigned int maxpages; 2836 2835 int err, found = 0; 2837 2836 ··· 2839 2840 2840 2841 BUG_ON(!current->mm); 2841 2842 2842 2842 - pathname = getname(specialfile); 2843 2843 - if (IS_ERR(pathname)) 2844 2844 - return PTR_ERR(pathname); 2845 2845 - 2843 2843 + CLASS(filename, pathname)(specialfile); 2846 2844 victim = file_open_name(pathname, O_RDWR|O_LARGEFILE, 0); 2847 2847 - err = PTR_ERR(victim); 2848 2845 if (IS_ERR(victim)) 2849 2849 - goto out; 2846 2846 + return PTR_ERR(victim); 2850 2847 2851 2848 mapping = victim->f_mapping; 2852 2849 spin_lock(&swap_lock); ··· 2959 2964 2960 2965 out_dput: 2961 2966 filp_close(victim, NULL); 2962 2962 - out: 2963 2963 - putname(pathname); 2964 2967 return err; 2965 2968 } 2966 2969 ··· 3385 3392 SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags) 3386 3393 { 3387 3394 struct swap_info_struct *si; 3388 3388 - struct filename *name; 3389 3395 struct file *swap_file = NULL; 3390 3396 struct address_space *mapping; 3391 3397 struct dentry *dentry; ··· 3414 3422 INIT_WORK(&si->discard_work, swap_discard_work); 3415 3423 INIT_WORK(&si->reclaim_work, swap_reclaim_work); 3416 3424 3417 3417 - name = getname(specialfile); 3418 3418 - if (IS_ERR(name)) { 3419 3419 - error = PTR_ERR(name); 3420 3420 - name = NULL; 3421 3421 - goto bad_swap; 3422 3422 - } 3425 3425 + CLASS(filename, name)(specialfile); 3423 3426 swap_file = file_open_name(name, O_RDWR | O_LARGEFILE | O_EXCL, 0); 3424 3427 if (IS_ERR(swap_file)) { 3425 3428 error = PTR_ERR(swap_file); ··· 3622 3635 out: 3623 3636 if (!IS_ERR_OR_NULL(folio)) 3624 3637 folio_release_kmap(folio, swap_header); 3625 3625 - if (name) 3626 3626 - putname(name); 3627 3638 if (inode) 3628 3639 inode_unlock(inode); 3629 3640 return error;