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