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
 16int __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
 30int __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
 44int __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
 59int __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);
 77dput_and_out:
 78	path_put(&path);
 79	return error;
 80}
 81
 82int __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
100int __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
113int __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
126int __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
141int __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
166int __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);
194out_dput:
195	done_path_create(&new_path, new_dentry);
196out:
197	path_put(&old_path);
198	return error;
199}
200
201int __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
218int __init init_unlink(const char *pathname)
219{
220	return do_unlinkat(AT_FDCWD, getname_kernel(pathname));
221}
222
223int __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
242int __init init_rmdir(const char *pathname)
243{
244	return do_rmdir(AT_FDCWD, getname_kernel(pathname));
245}
246
247int __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
260int __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}