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 = inode_permission(path.dentry->d_inode, 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 = inode_permission(path.dentry->d_inode, 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 = inode_permission(d_inode(path.dentry), 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(path.dentry->d_inode, dentry, mode,
 161                                   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         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         error = may_linkat(&old_path);
 185         if (unlikely(error))
 186                 goto out_dput;
 187         error = security_path_link(old_path.dentry, &new_path, new_dentry);
 188         if (error)
 189                 goto out_dput;
 190         error = vfs_link(old_path.dentry, new_path.dentry->d_inode, new_dentry,
 191                          NULL);
 192 out_dput:
 193         done_path_create(&new_path, new_dentry);
 194 out:
 195         path_put(&old_path);
 196         return error;
 197 }
 198
 199 int __init init_symlink(const char *oldname, const char *newname)
 200 {
 201         struct dentry *dentry;
 202         struct path path;
 203         int error;
 204
 205         dentry = kern_path_create(AT_FDCWD, newname, &path, 0);
 206         if (IS_ERR(dentry))
 207                 return PTR_ERR(dentry);
 208         error = security_path_symlink(&path, dentry, oldname);
 209         if (!error)
 210                 error = vfs_symlink(path.dentry->d_inode, dentry, oldname);
 211         done_path_create(&path, dentry);
 212         return error;
 213 }
 214
 215 int __init init_unlink(const char *pathname)
 216 {
 217         return do_unlinkat(AT_FDCWD, getname_kernel(pathname));
 218 }
 219
 220 int __init init_mkdir(const char *pathname, umode_t mode)
 221 {
 222         struct dentry *dentry;
 223         struct path path;
 224         int error;
 225
 226         dentry = kern_path_create(AT_FDCWD, pathname, &path, LOOKUP_DIRECTORY);
 227         if (IS_ERR(dentry))
 228                 return PTR_ERR(dentry);
 229         if (!IS_POSIXACL(path.dentry->d_inode))
 230                 mode &= ~current_umask();
 231         error = security_path_mkdir(&path, dentry, mode);
 232         if (!error)
 233                 error = vfs_mkdir(path.dentry->d_inode, dentry, mode);
 234         done_path_create(&path, dentry);
 235         return error;
 236 }
 237
 238 int __init init_rmdir(const char *pathname)
 239 {
 240         return do_rmdir(AT_FDCWD, getname_kernel(pathname));
 241 }
 242
 243 int __init init_utimes(char *filename, struct timespec64 *ts)
 244 {
 245         struct path path;
 246         int error;
 247
 248         error = kern_path(filename, 0, &path);
 249         if (error)
 250                 return error;
 251         error = vfs_utimes(&path, ts);
 252         path_put(&path);
 253         return error;
 254 }
 255
 256 int __init init_dup(struct file *file)
 257 {
 258         int fd;
 259
 260         fd = get_unused_fd_flags(0);
 261         if (fd < 0)
 262                 return fd;
 263         fd_install(fd, get_file(file));
 264         return 0;
 265 }