Merge tag 'rtc-5.9' of git://git.kernel.org/pub/scm/linux/kernel/git/abelloni/linux
[linux-2.6-microblaze.git] / fs / init.c
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, 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, 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 = 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
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
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
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
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
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(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
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
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
215 int __init init_unlink(const char *pathname)
216 {
217         return do_unlinkat(AT_FDCWD, getname_kernel(pathname));
218 }
219
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
238 int __init init_rmdir(const char *pathname)
239 {
240         return do_rmdir(AT_FDCWD, getname_kernel(pathname));
241 }
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 }
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 }