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  
init_mount(const char * dev_name,const char * dir_name,const char * type_page,unsigned long flags,void * data_page)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  
init_umount(const char * name,int flags)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  
init_chdir(const char * filename)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  
init_chroot(const char * filename)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  
init_chown(const char * filename,uid_t user,gid_t group,int flags)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  
init_chmod(const char * filename,umode_t mode)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  
init_eaccess(const char * filename)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  
init_stat(const char * filename,struct kstat * stat,int flags)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  
init_mknod(const char * filename,umode_t mode,unsigned int dev)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  	mode = mode_strip_umask(d_inode(path.dentry), mode);
157  	error = security_path_mknod(&path, dentry, mode, dev);
158  	if (!error)
159  		error = vfs_mknod(mnt_idmap(path.mnt), path.dentry->d_inode,
160  				  dentry, mode, new_decode_dev(dev));
161  	done_path_create(&path, dentry);
162  	return error;
163  }
164  
init_link(const char * oldname,const char * newname)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(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  	idmap = mnt_idmap(new_path.mnt);
185  	error = may_linkat(idmap, &old_path);
186  	if (unlikely(error))
187  		goto out_dput;
188  	error = security_path_link(old_path.dentry, &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  
init_symlink(const char * oldname,const char * newname)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(dentry))
208  		return PTR_ERR(dentry);
209  	error = security_path_symlink(&path, dentry, oldname);
210  	if (!error)
211  		error = vfs_symlink(mnt_idmap(path.mnt), path.dentry->d_inode,
212  				    dentry, oldname);
213  	done_path_create(&path, dentry);
214  	return error;
215  }
216  
init_unlink(const char * pathname)217  int __init init_unlink(const char *pathname)
218  {
219  	return do_unlinkat(AT_FDCWD, getname_kernel(pathname));
220  }
221  
init_mkdir(const char * pathname,umode_t mode)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(dentry))
230  		return PTR_ERR(dentry);
231  	mode = mode_strip_umask(d_inode(path.dentry), mode);
232  	error = security_path_mkdir(&path, dentry, mode);
233  	if (!error)
234  		error = vfs_mkdir(mnt_idmap(path.mnt), path.dentry->d_inode,
235  				  dentry, mode);
236  	done_path_create(&path, dentry);
237  	return error;
238  }
239  
init_rmdir(const char * pathname)240  int __init init_rmdir(const char *pathname)
241  {
242  	return do_rmdir(AT_FDCWD, getname_kernel(pathname));
243  }
244  
init_utimes(char * filename,struct timespec64 * ts)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, ts);
254  	path_put(&path);
255  	return error;
256  }
257  
init_dup(struct file * file)258  int __init init_dup(struct file *file)
259  {
260  	int fd;
261  
262  	fd = get_unused_fd_flags(0);
263  	if (fd < 0)
264  		return fd;
265  	fd_install(fd, get_file(file));
266  	return 0;
267  }
268