[mirror_ubuntu-hirsute-kernel.git] / fs / init.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Routines that mimic syscalls, but don't use the user address space or file
 * descriptors.  Only for init/ and related early init code.
 */
#include <linux/init.h>
#include <linux/mount.h>
#include <linux/namei.h>
#include <linux/fs.h>
#include <linux/fs_struct.h>
#include <linux/file.h>
#include <linux/init_syscalls.h>
#include <linux/security.h>
#include "internal.h"

int __init init_mount(const char *dev_name, const char *dir_name,
		const char *type_page, unsigned long flags, void *data_page)
{
	struct path path;
	int ret;

	ret = kern_path(dir_name, LOOKUP_FOLLOW, &path);
	if (ret)
		return ret;
	ret = path_mount(dev_name, &path, type_page, flags, data_page);
	path_put(&path);
	return ret;
}

int __init init_umount(const char *name, int flags)
{
	int lookup_flags = LOOKUP_MOUNTPOINT;
	struct path path;
	int ret;

	if (!(flags & UMOUNT_NOFOLLOW))
		lookup_flags |= LOOKUP_FOLLOW;
	ret = kern_path(name, lookup_flags, &path);
	if (ret)
		return ret;
	return path_umount(&path, flags);
}

int __init init_chdir(const char *filename)
{
	struct path path;
	int error;

	error = kern_path(filename, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &path);
	if (error)
		return error;
	error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_CHDIR);
	if (!error)
		set_fs_pwd(current->fs, &path);
	path_put(&path);
	return error;
}

int __init init_chroot(const char *filename)
{
	struct path path;
	int error;

	error = kern_path(filename, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &path);
	if (error)
		return error;
	error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_CHDIR);
	if (error)
		goto dput_and_out;
	error = -EPERM;
	if (!ns_capable(current_user_ns(), CAP_SYS_CHROOT))
		goto dput_and_out;
	error = security_path_chroot(&path);
	if (error)
		goto dput_and_out;
	set_fs_root(current->fs, &path);
dput_and_out:
	path_put(&path);
	return error;
}

int __init init_chown(const char *filename, uid_t user, gid_t group, int flags)
{
	int lookup_flags = (flags & AT_SYMLINK_NOFOLLOW) ? 0 : LOOKUP_FOLLOW;
	struct path path;
	int error;

	error = kern_path(filename, lookup_flags, &path);
	if (error)
		return error;
	error = mnt_want_write(path.mnt);
	if (!error) {
		error = chown_common(&path, user, group);
		mnt_drop_write(path.mnt);
	}
	path_put(&path);
	return error;
}

int __init init_chmod(const char *filename, umode_t mode)
{
	struct path path;
	int error;

	error = kern_path(filename, LOOKUP_FOLLOW, &path);
	if (error)
		return error;
	error = chmod_common(&path, mode);
	path_put(&path);
	return error;
}

int __init init_eaccess(const char *filename)
{
	struct path path;
	int error;

	error = kern_path(filename, LOOKUP_FOLLOW, &path);
	if (error)
		return error;
	error = inode_permission(d_inode(path.dentry), MAY_ACCESS);
	path_put(&path);
	return error;
}

int __init init_stat(const char *filename, struct kstat *stat, int flags)
{
	int lookup_flags = (flags & AT_SYMLINK_NOFOLLOW) ? 0 : LOOKUP_FOLLOW;
	struct path path;
	int error;

	error = kern_path(filename, lookup_flags, &path);
	if (error)
		return error;
	error = vfs_getattr(&path, stat, STATX_BASIC_STATS,
			    flags | AT_NO_AUTOMOUNT);
	path_put(&path);
	return error;
}

int __init init_mknod(const char *filename, umode_t mode, unsigned int dev)
{
	struct dentry *dentry;
	struct path path;
	int error;

	if (S_ISFIFO(mode) || S_ISSOCK(mode))
		dev = 0;
	else if (!(S_ISBLK(mode) || S_ISCHR(mode)))
		return -EINVAL;

	dentry = kern_path_create(AT_FDCWD, filename, &path, 0);
	if (IS_ERR(dentry))
		return PTR_ERR(dentry);

	if (!IS_POSIXACL(path.dentry->d_inode))
		mode &= ~current_umask();
	error = security_path_mknod(&path, dentry, mode, dev);
	if (!error)
		error = vfs_mknod(path.dentry->d_inode, dentry, mode,
				  new_decode_dev(dev));
	done_path_create(&path, dentry);
	return error;
}

int __init init_link(const char *oldname, const char *newname)
{
	struct dentry *new_dentry;
	struct path old_path, new_path;
	int error;

	error = kern_path(oldname, 0, &old_path);
	if (error)
		return error;

	new_dentry = kern_path_create(AT_FDCWD, newname, &new_path, 0);
	error = PTR_ERR(new_dentry);
	if (IS_ERR(new_dentry))
		goto out;

	error = -EXDEV;
	if (old_path.mnt != new_path.mnt)
		goto out_dput;
	error = may_linkat(&old_path);
	if (unlikely(error))
		goto out_dput;
	error = security_path_link(old_path.dentry, &new_path, new_dentry);
	if (error)
		goto out_dput;
	error = vfs_link(old_path.dentry, new_path.dentry->d_inode, new_dentry,
			 NULL);
out_dput:
	done_path_create(&new_path, new_dentry);
out:
	path_put(&old_path);
	return error;
}

int __init init_symlink(const char *oldname, const char *newname)
{
	struct dentry *dentry;
	struct path path;
	int error;

	dentry = kern_path_create(AT_FDCWD, newname, &path, 0);
	if (IS_ERR(dentry))
		return PTR_ERR(dentry);
	error = security_path_symlink(&path, dentry, oldname);
	if (!error)
		error = vfs_symlink(path.dentry->d_inode, dentry, oldname);
	done_path_create(&path, dentry);
	return error;
}

int __init init_unlink(const char *pathname)
{
	return do_unlinkat(AT_FDCWD, getname_kernel(pathname));
}

int __init init_mkdir(const char *pathname, umode_t mode)
{
	struct dentry *dentry;
	struct path path;
	int error;

	dentry = kern_path_create(AT_FDCWD, pathname, &path, LOOKUP_DIRECTORY);
	if (IS_ERR(dentry))
		return PTR_ERR(dentry);
	if (!IS_POSIXACL(path.dentry->d_inode))
		mode &= ~current_umask();
	error = security_path_mkdir(&path, dentry, mode);
	if (!error)
		error = vfs_mkdir(path.dentry->d_inode, dentry, mode);
	done_path_create(&path, dentry);
	return error;
}

int __init init_rmdir(const char *pathname)
{
	return do_rmdir(AT_FDCWD, getname_kernel(pathname));
}

int __init init_utimes(char *filename, struct timespec64 *ts)
{
	struct path path;
	int error;

	error = kern_path(filename, 0, &path);
	if (error)
		return error;
	error = vfs_utimes(&path, ts);
	path_put(&path);
	return error;
}

int __init init_dup(struct file *file)
{
	int fd;

	fd = get_unused_fd_flags(0);
	if (fd < 0)
		return fd;
	fd_install(fd, get_file(file));
	return 0;
}
Commit	Line	Data
c60166f0 CH	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>
db63f1e3	10	#include <linux/fs_struct.h>
f0735310	11	#include <linux/file.h>
c60166f0	12	#include <linux/init_syscalls.h>
4b7ca501	13	#include <linux/security.h>
c60166f0 CH	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	}
09267def CH	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	}
8fb9f73e	43
db63f1e3 CH	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
4b7ca501 CH	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
b873498f CH	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
1097742e CH	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
eb9d7d39 CH	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
716308a5 CH	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
5fee64fc CH	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
812931d6 CH	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
cd3acb6a CH	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
8fb9f73e CH	215	int __init init_unlink(const char *pathname)
	216	{
	217	return do_unlinkat(AT_FDCWD, getname_kernel(pathname));
	218	}
20cce026	219
83ff98c3 CH	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
20cce026 CH	238	int __init init_rmdir(const char *pathname)
	239	{
	240	return do_rmdir(AT_FDCWD, getname_kernel(pathname));
	241	}
235e5793 CH	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	}
f0735310 CH	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	}