fs/init.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Routines that mimic syscalls, but don't use the user address space or file
   4  * descriptors.  Only for init/ and related early init code.
   5  */
   6 #include <linux/init.h>
   7 #include <linux/mount.h>
   8 #include <linux/namei.h>
   9 #include <linux/fs.h>
  10 #include <linux/fs_struct.h>
  11 #include <linux/file.h>
  12 #include <linux/init_syscalls.h>
  13 #include <linux/security.h>
  14 #include "internal.h"
  15
  16 int __init init_mount(const char *dev_name, const char *dir_name,
  17                 const char *type_page, unsigned long flags, void *data_page)
  18 {
  19         struct path path;
  20         int ret;
  21
  22         ret = kern_path(dir_name, LOOKUP_FOLLOW, &path);
  23         if (ret)
  24                 return ret;
  25         ret = path_mount(dev_name, &path, type_page, flags, data_page);
  26         path_put(&path);
  27         return ret;
  28 }
  29
  30 int __init init_umount(const char *name, int flags)
  31 {
  32         int lookup_flags = LOOKUP_MOUNTPOINT;
  33         struct path path;
  34         int ret;
  35
  36         if (!(flags & UMOUNT_NOFOLLOW))
  37                 lookup_flags |= LOOKUP_FOLLOW;
  38         ret = kern_path(name, lookup_flags, &path);
  39         if (ret)
  40                 return ret;
  41         return path_umount(&path, flags);
  42 }
  43
  44 int __init init_chdir(const char *filename)
  45 {
  46         struct path path;
  47         int error;
  48
  49         error = kern_path(filename, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &path);
  50         if (error)
  51                 return error;
  52         error = path_permission(&path, MAY_EXEC | MAY_CHDIR);
  53         if (!error)
  54                 set_fs_pwd(current->fs, &path);
  55         path_put(&path);
  56         return error;
  57 }
  58
  59 int __init init_chroot(const char *filename)
  60 {
  61         struct path path;
  62         int error;
  63
  64         error = kern_path(filename, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &path);
  65         if (error)
  66                 return error;
  67         error = path_permission(&path, MAY_EXEC | MAY_CHDIR);
  68         if (error)
  69                 goto dput_and_out;
  70         error = -EPERM;
  71         if (!ns_capable(current_user_ns(), CAP_SYS_CHROOT))
  72                 goto dput_and_out;
  73         error = security_path_chroot(&path);
  74         if (error)
  75                 goto dput_and_out;
  76         set_fs_root(current->fs, &path);
  77 dput_and_out:
  78         path_put(&path);
  79         return error;
  80 }
  81
  82 int __init init_chown(const char *filename, uid_t user, gid_t group, int flags)
  83 {
  84         int lookup_flags = (flags & AT_SYMLINK_NOFOLLOW) ? 0 : LOOKUP_FOLLOW;
  85         struct path path;
  86         int error;
  87
  88         error = kern_path(filename, lookup_flags, &path);
  89         if (error)
  90                 return error;
  91         error = mnt_want_write(path.mnt);
  92         if (!error) {
  93                 error = chown_common(&path, user, group);
  94                 mnt_drop_write(path.mnt);
  95         }
  96         path_put(&path);
  97         return error;
  98 }
  99
 100 int __init init_chmod(const char *filename, umode_t mode)
 101 {
 102         struct path path;
 103         int error;
 104
 105         error = kern_path(filename, LOOKUP_FOLLOW, &path);
 106         if (error)
 107                 return error;
 108         error = chmod_common(&path, mode);
 109         path_put(&path);
 110         return error;
 111 }
 112
 113 int __init init_eaccess(const char *filename)
 114 {
 115         struct path path;
 116         int error;
 117
 118         error = kern_path(filename, LOOKUP_FOLLOW, &path);
 119         if (error)
 120                 return error;
 121         error = path_permission(&path, MAY_ACCESS);
 122         path_put(&path);
 123         return error;
 124 }
 125
 126 int __init init_stat(const char *filename, struct kstat *stat, int flags)
 127 {
 128         int lookup_flags = (flags & AT_SYMLINK_NOFOLLOW) ? 0 : LOOKUP_FOLLOW;
 129         struct path path;
 130         int error;
 131
 132         error = kern_path(filename, lookup_flags, &path);
 133         if (error)
 134                 return error;
 135         error = vfs_getattr(&path, stat, STATX_BASIC_STATS,
 136                             flags | AT_NO_AUTOMOUNT);
 137         path_put(&path);
 138         return error;
 139 }
 140
 141 int __init init_mknod(const char *filename, umode_t mode, unsigned int dev)
 142 {
 143         struct dentry *dentry;
 144         struct path path;
 145         int error;
 146
 147         if (S_ISFIFO(mode) || S_ISSOCK(mode))
 148                 dev = 0;
 149         else if (!(S_ISBLK(mode) || S_ISCHR(mode)))
 150                 return -EINVAL;
 151
 152         dentry = kern_path_create(AT_FDCWD, filename, &path, 0);
 153         if (IS_ERR(dentry))
 154                 return PTR_ERR(dentry);
 155
 156         if (!IS_POSIXACL(path.dentry->d_inode))
 157                 mode &= ~current_umask();
 158         error = security_path_mknod(&path, dentry, mode, dev);
 159         if (!error)
 160                 error = vfs_mknod(mnt_user_ns(path.mnt), path.dentry->d_inode,
 161                                   dentry, mode, new_decode_dev(dev));
 162         done_path_create(&path, dentry);
 163         return error;
 164 }
 165
 166 int __init init_link(const char *oldname, const char *newname)
 167 {
 168         struct dentry *new_dentry;
 169         struct path old_path, new_path;
 170         struct user_namespace *mnt_userns;
 171         int error;
 172
 173         error = kern_path(oldname, 0, &old_path);
 174         if (error)
 175                 return error;
 176
 177         new_dentry = kern_path_create(AT_FDCWD, newname, &new_path, 0);
 178         error = PTR_ERR(new_dentry);
 179         if (IS_ERR(new_dentry))
 180                 goto out;
 181
 182         error = -EXDEV;
 183         if (old_path.mnt != new_path.mnt)
 184                 goto out_dput;
 185         mnt_userns = mnt_user_ns(new_path.mnt);
 186         error = may_linkat(mnt_userns, &old_path);
 187         if (unlikely(error))
 188                 goto out_dput;
 189         error = security_path_link(old_path.dentry, &new_path, new_dentry);
 190         if (error)
 191                 goto out_dput;
 192         error = vfs_link(old_path.dentry, mnt_userns, new_path.dentry->d_inode,
 193                          new_dentry, NULL);
 194 out_dput:
 195         done_path_create(&new_path, new_dentry);
 196 out:
 197         path_put(&old_path);
 198         return error;
 199 }
 200
 201 int __init init_symlink(const char *oldname, const char *newname)
 202 {
 203         struct dentry *dentry;
 204         struct path path;
 205         int error;
 206
 207         dentry = kern_path_create(AT_FDCWD, newname, &path, 0);
 208         if (IS_ERR(dentry))
 209                 return PTR_ERR(dentry);
 210         error = security_path_symlink(&path, dentry, oldname);
 211         if (!error)
 212                 error = vfs_symlink(mnt_user_ns(path.mnt), path.dentry->d_inode,
 213                                     dentry, oldname);
 214         done_path_create(&path, dentry);
 215         return error;
 216 }
 217
 218 int __init init_unlink(const char *pathname)
 219 {
 220         return do_unlinkat(AT_FDCWD, getname_kernel(pathname));
 221 }
 222
 223 int __init init_mkdir(const char *pathname, umode_t mode)
 224 {
 225         struct dentry *dentry;
 226         struct path path;
 227         int error;
 228
 229         dentry = kern_path_create(AT_FDCWD, pathname, &path, LOOKUP_DIRECTORY);
 230         if (IS_ERR(dentry))
 231                 return PTR_ERR(dentry);
 232         if (!IS_POSIXACL(path.dentry->d_inode))
 233                 mode &= ~current_umask();
 234         error = security_path_mkdir(&path, dentry, mode);
 235         if (!error)
 236                 error = vfs_mkdir(mnt_user_ns(path.mnt), path.dentry->d_inode,
 237                                   dentry, mode);
 238         done_path_create(&path, dentry);
 239         return error;
 240 }
 241
 242 int __init init_rmdir(const char *pathname)
 243 {
 244         return do_rmdir(AT_FDCWD, getname_kernel(pathname));
 245 }
 246
 247 int __init init_utimes(char *filename, struct timespec64 *ts)
 248 {
 249         struct path path;
 250         int error;
 251
 252         error = kern_path(filename, 0, &path);
 253         if (error)
 254                 return error;
 255         error = vfs_utimes(&path, ts);
 256         path_put(&path);
 257         return error;
 258 }
 259
 260 int __init init_dup(struct file *file)
 261 {
 262         int fd;
 263
 264         fd = get_unused_fd_flags(0);
 265         if (fd < 0)
 266                 return fd;
 267         fd_install(fd, get_file(file));
 268         return 0;
 269 }