Merge branch 'next' into for-linus
[platform/kernel/linux-starfive.git] / 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 }