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: &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: &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: &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: &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: &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(mnt: path.mnt); |
92 | if (!error) { |
93 | error = chown_common(path: &path, user, group); |
94 | mnt_drop_write(mnt: 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: &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: &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(ptr: dentry)) |
154 | return PTR_ERR(ptr: dentry); |
155 | |
156 | mode = mode_strip_umask(dir: d_inode(dentry: path.dentry), mode); |
157 | error = security_path_mknod(dir: &path, dentry, mode, dev); |
158 | if (!error) |
159 | error = vfs_mknod(mnt_idmap(mnt: 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(ptr: new_dentry); |
178 | if (IS_ERR(ptr: 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(mnt: new_path.mnt); |
185 | error = may_linkat(idmap, link: &old_path); |
186 | if (unlikely(error)) |
187 | goto out_dput; |
188 | error = security_path_link(old_dentry: old_path.dentry, new_dir: &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(ptr: dentry)) |
208 | return PTR_ERR(ptr: dentry); |
209 | error = security_path_symlink(dir: &path, dentry, old_name: oldname); |
210 | if (!error) |
211 | error = vfs_symlink(mnt_idmap(mnt: 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, name: 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(ptr: dentry)) |
230 | return PTR_ERR(ptr: dentry); |
231 | mode = mode_strip_umask(dir: d_inode(dentry: path.dentry), mode); |
232 | error = security_path_mkdir(dir: &path, dentry, mode); |
233 | if (!error) |
234 | error = vfs_mkdir(mnt_idmap(mnt: 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, name: 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: &path, times: 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(flags: 0); |
263 | if (fd < 0) |
264 | return fd; |
265 | fd_install(fd, file: get_file(f: file)); |
266 | return 0; |
267 | } |
268 | |