[people/ms/linux.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/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_unlink(const char *pathname)
{
	return do_unlinkat(AT_FDCWD, getname_kernel(pathname));
}

int __init init_rmdir(const char *pathname)
{
	return do_rmdir(AT_FDCWD, getname_kernel(pathname));
}
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>
c60166f0	11	#include <linux/init_syscalls.h>
4b7ca501	12	#include <linux/security.h>
c60166f0 CH	13	#include "internal.h"
	14
	15	int __init init_mount(const char dev_name, const char dir_name,
	16	const char type_page, unsigned long flags, void data_page)
	17	{
	18	struct path path;
	19	int ret;
	20
	21	ret = kern_path(dir_name, LOOKUP_FOLLOW, &path);
	22	if (ret)
	23	return ret;
	24	ret = path_mount(dev_name, &path, type_page, flags, data_page);
	25	path_put(&path);
	26	return ret;
	27	}
09267def CH	28
	29	int __init init_umount(const char *name, int flags)
	30	{
	31	int lookup_flags = LOOKUP_MOUNTPOINT;
	32	struct path path;
	33	int ret;
	34
	35	if (!(flags & UMOUNT_NOFOLLOW))
	36	lookup_flags \|= LOOKUP_FOLLOW;
	37	ret = kern_path(name, lookup_flags, &path);
	38	if (ret)
	39	return ret;
	40	return path_umount(&path, flags);
	41	}
8fb9f73e	42
db63f1e3 CH	43	int __init init_chdir(const char *filename)
	44	{
	45	struct path path;
	46	int error;
	47
	48	error = kern_path(filename, LOOKUP_FOLLOW \| LOOKUP_DIRECTORY, &path);
	49	if (error)
	50	return error;
	51	error = inode_permission(path.dentry->d_inode, MAY_EXEC \| MAY_CHDIR);
	52	if (!error)
	53	set_fs_pwd(current->fs, &path);
	54	path_put(&path);
	55	return error;
	56	}
	57
4b7ca501 CH	58	int __init init_chroot(const char *filename)
	59	{
	60	struct path path;
	61	int error;
	62
	63	error = kern_path(filename, LOOKUP_FOLLOW \| LOOKUP_DIRECTORY, &path);
	64	if (error)
	65	return error;
	66	error = inode_permission(path.dentry->d_inode, MAY_EXEC \| MAY_CHDIR);
	67	if (error)
	68	goto dput_and_out;
	69	error = -EPERM;
	70	if (!ns_capable(current_user_ns(), CAP_SYS_CHROOT))
	71	goto dput_and_out;
	72	error = security_path_chroot(&path);
	73	if (error)
	74	goto dput_and_out;
	75	set_fs_root(current->fs, &path);
	76	dput_and_out:
	77	path_put(&path);
	78	return error;
	79	}
	80
b873498f CH	81	int __init init_chown(const char *filename, uid_t user, gid_t group, int flags)
	82	{
	83	int lookup_flags = (flags & AT_SYMLINK_NOFOLLOW) ? 0 : LOOKUP_FOLLOW;
	84	struct path path;
	85	int error;
	86
	87	error = kern_path(filename, lookup_flags, &path);
	88	if (error)
	89	return error;
	90	error = mnt_want_write(path.mnt);
	91	if (!error) {
	92	error = chown_common(&path, user, group);
	93	mnt_drop_write(path.mnt);
	94	}
	95	path_put(&path);
	96	return error;
	97	}
	98
1097742e CH	99	int __init init_chmod(const char *filename, umode_t mode)
	100	{
	101	struct path path;
	102	int error;
	103
	104	error = kern_path(filename, LOOKUP_FOLLOW, &path);
	105	if (error)
	106	return error;
	107	error = chmod_common(&path, mode);
	108	path_put(&path);
	109	return error;
	110	}
	111
8fb9f73e CH	112	int __init init_unlink(const char *pathname)
	113	{
	114	return do_unlinkat(AT_FDCWD, getname_kernel(pathname));
	115	}
20cce026 CH	116
	117	int __init init_rmdir(const char *pathname)
	118	{
	119	return do_rmdir(AT_FDCWD, getname_kernel(pathname));
	120	}