Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * linux/fs/open.c
4 : : *
5 : : * Copyright (C) 1991, 1992 Linus Torvalds
6 : : */
7 : :
8 : : #include <linux/string.h>
9 : : #include <linux/mm.h>
10 : : #include <linux/file.h>
11 : : #include <linux/fdtable.h>
12 : : #include <linux/fsnotify.h>
13 : : #include <linux/module.h>
14 : : #include <linux/tty.h>
15 : : #include <linux/namei.h>
16 : : #include <linux/backing-dev.h>
17 : : #include <linux/capability.h>
18 : : #include <linux/securebits.h>
19 : : #include <linux/security.h>
20 : : #include <linux/mount.h>
21 : : #include <linux/fcntl.h>
22 : : #include <linux/slab.h>
23 : : #include <linux/uaccess.h>
24 : : #include <linux/fs.h>
25 : : #include <linux/personality.h>
26 : : #include <linux/pagemap.h>
27 : : #include <linux/syscalls.h>
28 : : #include <linux/rcupdate.h>
29 : : #include <linux/audit.h>
30 : : #include <linux/falloc.h>
31 : : #include <linux/fs_struct.h>
32 : : #include <linux/ima.h>
33 : : #include <linux/dnotify.h>
34 : : #include <linux/compat.h>
35 : :
36 : : #include "internal.h"
37 : :
38 : 397 : int do_truncate(struct dentry *dentry, loff_t length, unsigned int time_attrs,
39 : : struct file *filp)
40 : : {
41 : 397 : int ret;
42 : 397 : struct iattr newattrs;
43 : :
44 : : /* Not pretty: "inode->i_size" shouldn't really be signed. But it is. */
45 [ + - ]: 397 : if (length < 0)
46 : : return -EINVAL;
47 : :
48 : 397 : newattrs.ia_size = length;
49 : 397 : newattrs.ia_valid = ATTR_SIZE | time_attrs;
50 [ + - ]: 397 : if (filp) {
51 : 397 : newattrs.ia_file = filp;
52 : 397 : newattrs.ia_valid |= ATTR_FILE;
53 : : }
54 : :
55 : : /* Remove suid, sgid, and file capabilities on truncate too */
56 : 397 : ret = dentry_needs_remove_privs(dentry);
57 [ + - ]: 397 : if (ret < 0)
58 : : return ret;
59 [ - + ]: 397 : if (ret)
60 : 0 : newattrs.ia_valid |= ret | ATTR_FORCE;
61 : :
62 : 397 : inode_lock(dentry->d_inode);
63 : : /* Note any delegations or leases have already been broken: */
64 : 397 : ret = notify_change(dentry, &newattrs, NULL);
65 : 397 : inode_unlock(dentry->d_inode);
66 : 397 : return ret;
67 : : }
68 : :
69 : 0 : long vfs_truncate(const struct path *path, loff_t length)
70 : : {
71 : 0 : struct inode *inode;
72 : 0 : long error;
73 : :
74 : 0 : inode = path->dentry->d_inode;
75 : :
76 : : /* For directories it's -EISDIR, for other non-regulars - -EINVAL */
77 [ # # ]: 0 : if (S_ISDIR(inode->i_mode))
78 : : return -EISDIR;
79 [ # # ]: 0 : if (!S_ISREG(inode->i_mode))
80 : : return -EINVAL;
81 : :
82 : 0 : error = mnt_want_write(path->mnt);
83 [ # # ]: 0 : if (error)
84 : 0 : goto out;
85 : :
86 : 0 : error = inode_permission(inode, MAY_WRITE);
87 [ # # ]: 0 : if (error)
88 : 0 : goto mnt_drop_write_and_out;
89 : :
90 : 0 : error = -EPERM;
91 [ # # ]: 0 : if (IS_APPEND(inode))
92 : 0 : goto mnt_drop_write_and_out;
93 : :
94 : 0 : error = get_write_access(inode);
95 [ # # ]: 0 : if (error)
96 : 0 : goto mnt_drop_write_and_out;
97 : :
98 : : /*
99 : : * Make sure that there are no leases. get_write_access() protects
100 : : * against the truncate racing with a lease-granting setlease().
101 : : */
102 : 0 : error = break_lease(inode, O_WRONLY);
103 [ # # ]: 0 : if (error)
104 : 0 : goto put_write_and_out;
105 : :
106 : 0 : error = locks_verify_truncate(inode, NULL, length);
107 [ # # ]: 0 : if (!error)
108 : 0 : error = security_path_truncate(path);
109 : 0 : if (!error)
110 : 0 : error = do_truncate(path->dentry, length, 0, NULL);
111 : :
112 : 0 : put_write_and_out:
113 : 0 : put_write_access(inode);
114 : 0 : mnt_drop_write_and_out:
115 : 0 : mnt_drop_write(path->mnt);
116 : : out:
117 : : return error;
118 : : }
119 : : EXPORT_SYMBOL_GPL(vfs_truncate);
120 : :
121 : 0 : long do_sys_truncate(const char __user *pathname, loff_t length)
122 : : {
123 : 0 : unsigned int lookup_flags = LOOKUP_FOLLOW;
124 : 0 : struct path path;
125 : 0 : int error;
126 : :
127 [ # # ]: 0 : if (length < 0) /* sorry, but loff_t says... */
128 : : return -EINVAL;
129 : :
130 : 0 : retry:
131 : 0 : error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
132 [ # # ]: 0 : if (!error) {
133 : 0 : error = vfs_truncate(&path, length);
134 : 0 : path_put(&path);
135 : : }
136 [ # # # # ]: 0 : if (retry_estale(error, lookup_flags)) {
137 : 0 : lookup_flags |= LOOKUP_REVAL;
138 : 0 : goto retry;
139 : : }
140 : : return error;
141 : : }
142 : :
143 : 0 : SYSCALL_DEFINE2(truncate, const char __user *, path, long, length)
144 : : {
145 : 0 : return do_sys_truncate(path, length);
146 : : }
147 : :
148 : : #ifdef CONFIG_COMPAT
149 : 0 : COMPAT_SYSCALL_DEFINE2(truncate, const char __user *, path, compat_off_t, length)
150 : : {
151 : 0 : return do_sys_truncate(path, length);
152 : : }
153 : : #endif
154 : :
155 : 285 : long do_sys_ftruncate(unsigned int fd, loff_t length, int small)
156 : : {
157 : 285 : struct inode *inode;
158 : 285 : struct dentry *dentry;
159 : 285 : struct fd f;
160 : 285 : int error;
161 : :
162 : 285 : error = -EINVAL;
163 [ - + ]: 285 : if (length < 0)
164 : 0 : goto out;
165 : 285 : error = -EBADF;
166 : 285 : f = fdget(fd);
167 [ - + ]: 285 : if (!f.file)
168 : 0 : goto out;
169 : :
170 : : /* explicitly opened as large or we are on 64-bit box */
171 [ + - ]: 285 : if (f.file->f_flags & O_LARGEFILE)
172 : 285 : small = 0;
173 : :
174 : 285 : dentry = f.file->f_path.dentry;
175 : 285 : inode = dentry->d_inode;
176 : 285 : error = -EINVAL;
177 [ + - - + ]: 285 : if (!S_ISREG(inode->i_mode) || !(f.file->f_mode & FMODE_WRITE))
178 : 0 : goto out_putf;
179 : :
180 : 285 : error = -EINVAL;
181 : : /* Cannot ftruncate over 2^31 bytes without large file support */
182 [ - + ]: 285 : if (small && length > MAX_NON_LFS)
183 : 0 : goto out_putf;
184 : :
185 : 285 : error = -EPERM;
186 : : /* Check IS_APPEND on real upper inode */
187 [ - + ]: 285 : if (IS_APPEND(file_inode(f.file)))
188 : 0 : goto out_putf;
189 : :
190 : 285 : sb_start_write(inode->i_sb);
191 : 285 : error = locks_verify_truncate(inode, f.file, length);
192 [ + - ]: 285 : if (!error)
193 : 285 : error = security_path_truncate(&f.file->f_path);
194 : 285 : if (!error)
195 : 285 : error = do_truncate(dentry, length, ATTR_MTIME|ATTR_CTIME, f.file);
196 : 285 : sb_end_write(inode->i_sb);
197 : 285 : out_putf:
198 [ - + ]: 285 : fdput(f);
199 : 285 : out:
200 : 285 : return error;
201 : : }
202 : :
203 : 570 : SYSCALL_DEFINE2(ftruncate, unsigned int, fd, unsigned long, length)
204 : : {
205 : 285 : return do_sys_ftruncate(fd, length, 1);
206 : : }
207 : :
208 : : #ifdef CONFIG_COMPAT
209 : 0 : COMPAT_SYSCALL_DEFINE2(ftruncate, unsigned int, fd, compat_ulong_t, length)
210 : : {
211 : 0 : return do_sys_ftruncate(fd, length, 1);
212 : : }
213 : : #endif
214 : :
215 : : /* LFS versions of truncate are only needed on 32 bit machines */
216 : : #if BITS_PER_LONG == 32
217 : : SYSCALL_DEFINE2(truncate64, const char __user *, path, loff_t, length)
218 : : {
219 : : return do_sys_truncate(path, length);
220 : : }
221 : :
222 : : SYSCALL_DEFINE2(ftruncate64, unsigned int, fd, loff_t, length)
223 : : {
224 : : return do_sys_ftruncate(fd, length, 0);
225 : : }
226 : : #endif /* BITS_PER_LONG == 32 */
227 : :
228 : :
229 : 56 : int vfs_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
230 : : {
231 [ + - ]: 56 : struct inode *inode = file_inode(file);
232 : 56 : long ret;
233 : :
234 [ + - ]: 56 : if (offset < 0 || len <= 0)
235 : : return -EINVAL;
236 : :
237 : : /* Return error if mode is not supported */
238 [ + - ]: 56 : if (mode & ~FALLOC_FL_SUPPORTED_MASK)
239 : : return -EOPNOTSUPP;
240 : :
241 : : /* Punch hole and zero range are mutually exclusive */
242 [ + - ]: 56 : if ((mode & (FALLOC_FL_PUNCH_HOLE | FALLOC_FL_ZERO_RANGE)) ==
243 : : (FALLOC_FL_PUNCH_HOLE | FALLOC_FL_ZERO_RANGE))
244 : : return -EOPNOTSUPP;
245 : :
246 : : /* Punch hole must have keep size set */
247 [ + - ]: 56 : if ((mode & FALLOC_FL_PUNCH_HOLE) &&
248 : : !(mode & FALLOC_FL_KEEP_SIZE))
249 : : return -EOPNOTSUPP;
250 : :
251 : : /* Collapse range should only be used exclusively. */
252 [ - + ]: 56 : if ((mode & FALLOC_FL_COLLAPSE_RANGE) &&
253 [ # # ]: 0 : (mode & ~FALLOC_FL_COLLAPSE_RANGE))
254 : : return -EINVAL;
255 : :
256 : : /* Insert range should only be used exclusively. */
257 [ - + ]: 56 : if ((mode & FALLOC_FL_INSERT_RANGE) &&
258 [ # # ]: 0 : (mode & ~FALLOC_FL_INSERT_RANGE))
259 : : return -EINVAL;
260 : :
261 : : /* Unshare range should only be used with allocate mode. */
262 [ - + ]: 56 : if ((mode & FALLOC_FL_UNSHARE_RANGE) &&
263 [ # # ]: 0 : (mode & ~(FALLOC_FL_UNSHARE_RANGE | FALLOC_FL_KEEP_SIZE)))
264 : : return -EINVAL;
265 : :
266 [ + - ]: 56 : if (!(file->f_mode & FMODE_WRITE))
267 : : return -EBADF;
268 : :
269 : : /*
270 : : * We can only allow pure fallocate on append only files
271 : : */
272 [ - + - - ]: 56 : if ((mode & ~FALLOC_FL_KEEP_SIZE) && IS_APPEND(inode))
273 : : return -EPERM;
274 : :
275 [ + - ]: 56 : if (IS_IMMUTABLE(inode))
276 : : return -EPERM;
277 : :
278 : : /*
279 : : * We cannot allow any fallocate operation on an active swapfile
280 : : */
281 [ + - ]: 56 : if (IS_SWAPFILE(inode))
282 : : return -ETXTBSY;
283 : :
284 : : /*
285 : : * Revalidate the write permissions, in case security policy has
286 : : * changed since the files were opened.
287 : : */
288 : 56 : ret = security_file_permission(file, MAY_WRITE);
289 [ + - ]: 56 : if (ret)
290 : : return ret;
291 : :
292 [ + - ]: 56 : if (S_ISFIFO(inode->i_mode))
293 : : return -ESPIPE;
294 : :
295 [ + - ]: 56 : if (S_ISDIR(inode->i_mode))
296 : : return -EISDIR;
297 : :
298 [ + - ]: 56 : if (!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode))
299 : : return -ENODEV;
300 : :
301 : : /* Check for wrap through zero too */
302 [ + - + - ]: 56 : if (((offset + len) > inode->i_sb->s_maxbytes) || ((offset + len) < 0))
303 : : return -EFBIG;
304 : :
305 [ + - ]: 56 : if (!file->f_op->fallocate)
306 : : return -EOPNOTSUPP;
307 : :
308 : 56 : file_start_write(file);
309 : 56 : ret = file->f_op->fallocate(file, mode, offset, len);
310 : :
311 : : /*
312 : : * Create inotify and fanotify events.
313 : : *
314 : : * To keep the logic simple always create events if fallocate succeeds.
315 : : * This implies that events are even created if the file size remains
316 : : * unchanged, e.g. when using flag FALLOC_FL_KEEP_SIZE.
317 : : */
318 [ + - ]: 56 : if (ret == 0)
319 : 56 : fsnotify_modify(file);
320 : :
321 [ + - ]: 56 : file_end_write(file);
322 : 56 : return ret;
323 : : }
324 : : EXPORT_SYMBOL_GPL(vfs_fallocate);
325 : :
326 : 56 : int ksys_fallocate(int fd, int mode, loff_t offset, loff_t len)
327 : : {
328 : 56 : struct fd f = fdget(fd);
329 : 56 : int error = -EBADF;
330 : :
331 [ + - ]: 56 : if (f.file) {
332 : 56 : error = vfs_fallocate(f.file, mode, offset, len);
333 [ - + ]: 56 : fdput(f);
334 : : }
335 : 56 : return error;
336 : : }
337 : :
338 : 112 : SYSCALL_DEFINE4(fallocate, int, fd, int, mode, loff_t, offset, loff_t, len)
339 : : {
340 : 56 : return ksys_fallocate(fd, mode, offset, len);
341 : : }
342 : :
343 : : /*
344 : : * access() needs to use the real uid/gid, not the effective uid/gid.
345 : : * We do this by temporarily clearing all FS-related capabilities and
346 : : * switching the fsuid/fsgid around to the real ones.
347 : : */
348 : 105500 : long do_faccessat(int dfd, const char __user *filename, int mode)
349 : : {
350 : 105500 : const struct cred *old_cred;
351 : 105500 : struct cred *override_cred;
352 : 105500 : struct path path;
353 : 105500 : struct inode *inode;
354 : 105500 : int res;
355 : 105500 : unsigned int lookup_flags = LOOKUP_FOLLOW;
356 : :
357 [ + - ]: 105500 : if (mode & ~S_IRWXO) /* where's F_OK, X_OK, W_OK, R_OK? */
358 : : return -EINVAL;
359 : :
360 : 105500 : override_cred = prepare_creds();
361 [ + - ]: 105500 : if (!override_cred)
362 : : return -ENOMEM;
363 : :
364 : 105500 : override_cred->fsuid = override_cred->uid;
365 : 105500 : override_cred->fsgid = override_cred->gid;
366 : :
367 [ + - ]: 105500 : if (!issecure(SECURE_NO_SETUID_FIXUP)) {
368 : : /* Clear the capabilities if we switch to a non-root user */
369 [ + + ]: 105500 : kuid_t root_uid = make_kuid(override_cred->user_ns, 0);
370 [ + + ]: 105500 : if (!uid_eq(override_cred->uid, root_uid))
371 : 84 : cap_clear(override_cred->cap_effective);
372 : : else
373 : 105416 : override_cred->cap_effective =
374 : : override_cred->cap_permitted;
375 : : }
376 : :
377 : : /*
378 : : * The new set of credentials can *only* be used in
379 : : * task-synchronous circumstances, and does not need
380 : : * RCU freeing, unless somebody then takes a separate
381 : : * reference to it.
382 : : *
383 : : * NOTE! This is _only_ true because this credential
384 : : * is used purely for override_creds() that installs
385 : : * it as the subjective cred. Other threads will be
386 : : * accessing ->real_cred, not the subjective cred.
387 : : *
388 : : * If somebody _does_ make a copy of this (using the
389 : : * 'get_current_cred()' function), that will clear the
390 : : * non_rcu field, because now that other user may be
391 : : * expecting RCU freeing. But normal thread-synchronous
392 : : * cred accesses will keep things non-RCY.
393 : : */
394 : 105500 : override_cred->non_rcu = 1;
395 : :
396 : 105500 : old_cred = override_creds(override_cred);
397 : 105500 : retry:
398 : 105500 : res = user_path_at(dfd, filename, lookup_flags, &path);
399 [ + + ]: 105500 : if (res)
400 : 65641 : goto out;
401 : :
402 [ + + ]: 39859 : inode = d_backing_inode(path.dentry);
403 : :
404 [ + + + - ]: 39859 : if ((mode & MAY_EXEC) && S_ISREG(inode->i_mode)) {
405 : : /*
406 : : * MAY_EXEC on regular files is denied if the fs is mounted
407 : : * with the "noexec" flag.
408 : : */
409 : 1120 : res = -EACCES;
410 [ - + ]: 1120 : if (path_noexec(&path))
411 : 0 : goto out_path_release;
412 : : }
413 : :
414 : 39859 : res = inode_permission(inode, mode | MAY_ACCESS);
415 : : /* SuS v2 requires we report a read only fs too */
416 [ + + + + : 39859 : if (res || !(mode & S_IWOTH) || special_file(inode->i_mode))
+ - + - -
+ ]
417 : 39355 : goto out_path_release;
418 : : /*
419 : : * This is a rare case where using __mnt_is_readonly()
420 : : * is OK without a mnt_want/drop_write() pair. Since
421 : : * no actual write to the fs is performed here, we do
422 : : * not need to telegraph to that to anyone.
423 : : *
424 : : * By doing this, we accept that this access is
425 : : * inherently racy and know that the fs may change
426 : : * state before we even see this result.
427 : : */
428 [ + - ]: 504 : if (__mnt_is_readonly(path.mnt))
429 : 0 : res = -EROFS;
430 : :
431 : 504 : out_path_release:
432 : 39859 : path_put(&path);
433 [ - + - + ]: 79718 : if (retry_estale(res, lookup_flags)) {
434 : 0 : lookup_flags |= LOOKUP_REVAL;
435 : 0 : goto retry;
436 : : }
437 : 39859 : out:
438 : 105500 : revert_creds(old_cred);
439 : 105500 : put_cred(override_cred);
440 : 105500 : return res;
441 : : }
442 : :
443 : 896 : SYSCALL_DEFINE3(faccessat, int, dfd, const char __user *, filename, int, mode)
444 : : {
445 : 448 : return do_faccessat(dfd, filename, mode);
446 : : }
447 : :
448 : 210048 : SYSCALL_DEFINE2(access, const char __user *, filename, int, mode)
449 : : {
450 : 105024 : return do_faccessat(AT_FDCWD, filename, mode);
451 : : }
452 : :
453 : 83664 : int ksys_chdir(const char __user *filename)
454 : : {
455 : 83664 : struct path path;
456 : 83664 : int error;
457 : 83664 : unsigned int lookup_flags = LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
458 : 83664 : retry:
459 : 83664 : error = user_path_at(AT_FDCWD, filename, lookup_flags, &path);
460 [ - + ]: 83664 : if (error)
461 : 0 : goto out;
462 : :
463 : 83664 : error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_CHDIR);
464 [ - + ]: 83664 : if (error)
465 : 0 : goto dput_and_out;
466 : :
467 : 83664 : set_fs_pwd(current->fs, &path);
468 : :
469 : 83664 : dput_and_out:
470 : 83664 : path_put(&path);
471 [ - + - + ]: 167328 : if (retry_estale(error, lookup_flags)) {
472 : 0 : lookup_flags |= LOOKUP_REVAL;
473 : 0 : goto retry;
474 : : }
475 : 83664 : out:
476 : 83664 : return error;
477 : : }
478 : :
479 : 167216 : SYSCALL_DEFINE1(chdir, const char __user *, filename)
480 : : {
481 : 83608 : return ksys_chdir(filename);
482 : : }
483 : :
484 : 28952 : SYSCALL_DEFINE1(fchdir, unsigned int, fd)
485 : : {
486 : 14476 : struct fd f = fdget_raw(fd);
487 : 14476 : int error;
488 : :
489 : 14476 : error = -EBADF;
490 [ - + ]: 14476 : if (!f.file)
491 : 0 : goto out;
492 : :
493 : 14476 : error = -ENOTDIR;
494 [ - + ]: 14476 : if (!d_can_lookup(f.file->f_path.dentry))
495 : 0 : goto out_putf;
496 : :
497 : 14476 : error = inode_permission(file_inode(f.file), MAY_EXEC | MAY_CHDIR);
498 [ - + ]: 14476 : if (!error)
499 : 14476 : set_fs_pwd(current->fs, &f.file->f_path);
500 : 0 : out_putf:
501 [ - + ]: 14476 : fdput(f);
502 : 14476 : out:
503 : 14476 : return error;
504 : : }
505 : :
506 : 112 : int ksys_chroot(const char __user *filename)
507 : : {
508 : 112 : struct path path;
509 : 112 : int error;
510 : 112 : unsigned int lookup_flags = LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
511 : 112 : retry:
512 : 112 : error = user_path_at(AT_FDCWD, filename, lookup_flags, &path);
513 [ - + ]: 112 : if (error)
514 : 0 : goto out;
515 : :
516 : 112 : error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_CHDIR);
517 [ - + ]: 112 : if (error)
518 : 0 : goto dput_and_out;
519 : :
520 : 112 : error = -EPERM;
521 [ - + ]: 112 : if (!ns_capable(current_user_ns(), CAP_SYS_CHROOT))
522 : 0 : goto dput_and_out;
523 : 112 : error = security_path_chroot(&path);
524 : 112 : if (error)
525 : : goto dput_and_out;
526 : :
527 : 112 : set_fs_root(current->fs, &path);
528 : 112 : error = 0;
529 : 112 : dput_and_out:
530 : 112 : path_put(&path);
531 [ - + - + ]: 224 : if (retry_estale(error, lookup_flags)) {
532 : 0 : lookup_flags |= LOOKUP_REVAL;
533 : 0 : goto retry;
534 : : }
535 : 112 : out:
536 : 112 : return error;
537 : : }
538 : :
539 : 112 : SYSCALL_DEFINE1(chroot, const char __user *, filename)
540 : : {
541 : 56 : return ksys_chroot(filename);
542 : : }
543 : :
544 : 9014 : static int chmod_common(const struct path *path, umode_t mode)
545 : : {
546 : 9014 : struct inode *inode = path->dentry->d_inode;
547 : 9014 : struct inode *delegated_inode = NULL;
548 : 9014 : struct iattr newattrs;
549 : 9014 : int error;
550 : :
551 : 9014 : error = mnt_want_write(path->mnt);
552 [ + - ]: 9014 : if (error)
553 : : return error;
554 : 9014 : retry_deleg:
555 : 9014 : inode_lock(inode);
556 : 9014 : error = security_path_chmod(path, mode);
557 : 9014 : if (error)
558 : : goto out_unlock;
559 : 9014 : newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
560 : 9014 : newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
561 : 9014 : error = notify_change(path->dentry, &newattrs, &delegated_inode);
562 : : out_unlock:
563 : 9014 : inode_unlock(inode);
564 [ - + ]: 9014 : if (delegated_inode) {
565 : 0 : error = break_deleg_wait(&delegated_inode);
566 [ # # ]: 0 : if (!error)
567 : 0 : goto retry_deleg;
568 : : }
569 : 9014 : mnt_drop_write(path->mnt);
570 : 9014 : return error;
571 : : }
572 : :
573 : 5038 : int ksys_fchmod(unsigned int fd, umode_t mode)
574 : : {
575 : 5038 : struct fd f = fdget(fd);
576 : 5038 : int err = -EBADF;
577 : :
578 [ + - ]: 5038 : if (f.file) {
579 : 5038 : audit_file(f.file);
580 : 5038 : err = chmod_common(&f.file->f_path, mode);
581 [ - + ]: 5038 : fdput(f);
582 : : }
583 : 5038 : return err;
584 : : }
585 : :
586 : 10076 : SYSCALL_DEFINE2(fchmod, unsigned int, fd, umode_t, mode)
587 : : {
588 : 5038 : return ksys_fchmod(fd, mode);
589 : : }
590 : :
591 : 3976 : int do_fchmodat(int dfd, const char __user *filename, umode_t mode)
592 : : {
593 : 3976 : struct path path;
594 : 3976 : int error;
595 : 3976 : unsigned int lookup_flags = LOOKUP_FOLLOW;
596 : 3976 : retry:
597 : 3976 : error = user_path_at(dfd, filename, lookup_flags, &path);
598 [ + - ]: 3976 : if (!error) {
599 : 3976 : error = chmod_common(&path, mode);
600 : 3976 : path_put(&path);
601 [ - + - + ]: 7952 : if (retry_estale(error, lookup_flags)) {
602 : 0 : lookup_flags |= LOOKUP_REVAL;
603 : 0 : goto retry;
604 : : }
605 : : }
606 : 3976 : return error;
607 : : }
608 : :
609 : 0 : SYSCALL_DEFINE3(fchmodat, int, dfd, const char __user *, filename,
610 : : umode_t, mode)
611 : : {
612 : 0 : return do_fchmodat(dfd, filename, mode);
613 : : }
614 : :
615 : 7784 : SYSCALL_DEFINE2(chmod, const char __user *, filename, umode_t, mode)
616 : : {
617 : 3892 : return do_fchmodat(AT_FDCWD, filename, mode);
618 : : }
619 : :
620 : : static int chown_common(const struct path *path, uid_t user, gid_t group)
621 : : {
622 : : struct inode *inode = path->dentry->d_inode;
623 : : struct inode *delegated_inode = NULL;
624 : : int error;
625 : : struct iattr newattrs;
626 : : kuid_t uid;
627 : : kgid_t gid;
628 : :
629 : : uid = make_kuid(current_user_ns(), user);
630 : : gid = make_kgid(current_user_ns(), group);
631 : :
632 : : retry_deleg:
633 : : newattrs.ia_valid = ATTR_CTIME;
634 : : if (user != (uid_t) -1) {
635 : : if (!uid_valid(uid))
636 : : return -EINVAL;
637 : : newattrs.ia_valid |= ATTR_UID;
638 : : newattrs.ia_uid = uid;
639 : : }
640 : : if (group != (gid_t) -1) {
641 : : if (!gid_valid(gid))
642 : : return -EINVAL;
643 : : newattrs.ia_valid |= ATTR_GID;
644 : : newattrs.ia_gid = gid;
645 : : }
646 : : if (!S_ISDIR(inode->i_mode))
647 : : newattrs.ia_valid |=
648 : : ATTR_KILL_SUID | ATTR_KILL_SGID | ATTR_KILL_PRIV;
649 : : inode_lock(inode);
650 : : error = security_path_chown(path, uid, gid);
651 : : if (!error)
652 : : error = notify_change(path->dentry, &newattrs, &delegated_inode);
653 : : inode_unlock(inode);
654 : : if (delegated_inode) {
655 : : error = break_deleg_wait(&delegated_inode);
656 : : if (!error)
657 : : goto retry_deleg;
658 : : }
659 : : return error;
660 : : }
661 : :
662 : 3052 : int do_fchownat(int dfd, const char __user *filename, uid_t user, gid_t group,
663 : : int flag)
664 : : {
665 : 3052 : struct path path;
666 : 3052 : int error = -EINVAL;
667 : 3052 : int lookup_flags;
668 : :
669 [ - + ]: 3052 : if ((flag & ~(AT_SYMLINK_NOFOLLOW | AT_EMPTY_PATH)) != 0)
670 : 0 : goto out;
671 : :
672 : 3052 : lookup_flags = (flag & AT_SYMLINK_NOFOLLOW) ? 0 : LOOKUP_FOLLOW;
673 [ + + ]: 3052 : if (flag & AT_EMPTY_PATH)
674 : 56 : lookup_flags |= LOOKUP_EMPTY;
675 : 2996 : retry:
676 : 3052 : error = user_path_at(dfd, filename, lookup_flags, &path);
677 [ - + ]: 3052 : if (error)
678 : 0 : goto out;
679 : 3052 : error = mnt_want_write(path.mnt);
680 [ - + ]: 3052 : if (error)
681 : 0 : goto out_release;
682 : 3052 : error = chown_common(&path, user, group);
683 : 3052 : mnt_drop_write(path.mnt);
684 : 3052 : out_release:
685 : 3052 : path_put(&path);
686 [ - + - + ]: 6104 : if (retry_estale(error, lookup_flags)) {
687 : 0 : lookup_flags |= LOOKUP_REVAL;
688 : 0 : goto retry;
689 : : }
690 : 3052 : out:
691 : 3052 : return error;
692 : : }
693 : :
694 : 112 : SYSCALL_DEFINE5(fchownat, int, dfd, const char __user *, filename, uid_t, user,
695 : : gid_t, group, int, flag)
696 : : {
697 : 56 : return do_fchownat(dfd, filename, user, group, flag);
698 : : }
699 : :
700 : 5824 : SYSCALL_DEFINE3(chown, const char __user *, filename, uid_t, user, gid_t, group)
701 : : {
702 : 2912 : return do_fchownat(AT_FDCWD, filename, user, group, 0);
703 : : }
704 : :
705 : 0 : SYSCALL_DEFINE3(lchown, const char __user *, filename, uid_t, user, gid_t, group)
706 : : {
707 : 0 : return do_fchownat(AT_FDCWD, filename, user, group,
708 : : AT_SYMLINK_NOFOLLOW);
709 : : }
710 : :
711 : 420 : int ksys_fchown(unsigned int fd, uid_t user, gid_t group)
712 : : {
713 : 420 : struct fd f = fdget(fd);
714 : 420 : int error = -EBADF;
715 : :
716 [ - + ]: 420 : if (!f.file)
717 : 0 : goto out;
718 : :
719 : 420 : error = mnt_want_write_file(f.file);
720 [ - + ]: 420 : if (error)
721 : 0 : goto out_fput;
722 : 420 : audit_file(f.file);
723 : 420 : error = chown_common(&f.file->f_path, user, group);
724 : 420 : mnt_drop_write_file(f.file);
725 : 420 : out_fput:
726 [ + + ]: 420 : fdput(f);
727 : 420 : out:
728 : 420 : return error;
729 : : }
730 : :
731 : 840 : SYSCALL_DEFINE3(fchown, unsigned int, fd, uid_t, user, gid_t, group)
732 : : {
733 : 420 : return ksys_fchown(fd, user, group);
734 : : }
735 : :
736 : 1164217 : static int do_dentry_open(struct file *f,
737 : : struct inode *inode,
738 : : int (*open)(struct inode *, struct file *))
739 : : {
740 : 1164217 : static const struct file_operations empty_fops = {};
741 : 1164217 : int error;
742 : :
743 : 1164217 : path_get(&f->f_path);
744 : 1164217 : f->f_inode = inode;
745 : 1164217 : f->f_mapping = inode->i_mapping;
746 : :
747 : : /* Ensure that we skip any errors that predate opening of the file */
748 : 1164217 : f->f_wb_err = filemap_sample_wb_err(f->f_mapping);
749 : :
750 [ + + ]: 1164217 : if (unlikely(f->f_flags & O_PATH)) {
751 : 652628 : f->f_mode = FMODE_PATH | FMODE_OPENED;
752 : 652628 : f->f_op = &empty_fops;
753 : 652628 : return 0;
754 : : }
755 : :
756 : : /* Any file opened for execve()/uselib() has to be a regular file. */
757 [ + + - + ]: 511589 : if (unlikely(f->f_flags & FMODE_EXEC && !S_ISREG(inode->i_mode))) {
758 : 0 : error = -EACCES;
759 : 0 : goto cleanup_file;
760 : : }
761 : :
762 [ + + + + : 511589 : if (f->f_mode & FMODE_WRITE && !special_file(inode->i_mode)) {
+ + + - ]
763 : 37350 : error = get_write_access(inode);
764 [ - + ]: 37350 : if (unlikely(error))
765 : 0 : goto cleanup_file;
766 : 37350 : error = __mnt_want_write(f->f_path.mnt);
767 [ - + ]: 37350 : if (unlikely(error)) {
768 : 0 : put_write_access(inode);
769 : 0 : goto cleanup_file;
770 : : }
771 : 37350 : f->f_mode |= FMODE_WRITER;
772 : : }
773 : :
774 : : /* POSIX.1-2008/SUSv4 Section XSI 2.9.7 */
775 [ + + ]: 511589 : if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))
776 : 504089 : f->f_mode |= FMODE_ATOMIC_POS;
777 : :
778 [ + - + - ]: 511589 : f->f_op = fops_get(inode->i_fop);
779 [ - + - + ]: 511589 : if (WARN_ON(!f->f_op)) {
780 : 0 : error = -ENODEV;
781 : 0 : goto cleanup_all;
782 : : }
783 : :
784 : 511589 : error = security_file_open(f);
785 [ - + ]: 511589 : if (error)
786 : 0 : goto cleanup_all;
787 : :
788 : 511589 : error = break_lease(locks_inode(f), f->f_flags);
789 [ - + ]: 511589 : if (error)
790 : 0 : goto cleanup_all;
791 : :
792 : : /* normally all 3 are set; ->open() can clear them if needed */
793 : 511589 : f->f_mode |= FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE;
794 [ + - ]: 511589 : if (!open)
795 : 511589 : open = f->f_op->open;
796 [ + + ]: 511589 : if (open) {
797 : 489917 : error = open(inode, f);
798 [ + + ]: 489889 : if (error)
799 : 14700 : goto cleanup_all;
800 : : }
801 : 496861 : f->f_mode |= FMODE_OPENED;
802 [ + + ]: 496861 : if ((f->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ)
803 : 456095 : i_readcount_inc(inode);
804 [ + + ]: 496861 : if ((f->f_mode & FMODE_READ) &&
805 [ + + + + ]: 462421 : likely(f->f_op->read || f->f_op->read_iter))
806 : 462365 : f->f_mode |= FMODE_CAN_READ;
807 [ + + ]: 496861 : if ((f->f_mode & FMODE_WRITE) &&
808 [ + + + + ]: 40766 : likely(f->f_op->write || f->f_op->write_iter))
809 : 40738 : f->f_mode |= FMODE_CAN_WRITE;
810 : :
811 : 496861 : f->f_write_hint = WRITE_LIFE_NOT_SET;
812 : 496861 : f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
813 : :
814 : 496861 : file_ra_state_init(&f->f_ra, f->f_mapping->host->i_mapping);
815 : :
816 : : /* NB: we're sure to have correct a_ops only after f_op->open */
817 [ - + ]: 496861 : if (f->f_flags & O_DIRECT) {
818 [ # # # # ]: 0 : if (!f->f_mapping->a_ops || !f->f_mapping->a_ops->direct_IO)
819 : : return -EINVAL;
820 : : }
821 : :
822 : : /*
823 : : * XXX: Huge page cache doesn't support writing yet. Drop all page
824 : : * cache for this file before processing writes.
825 : : */
826 : 496861 : if ((f->f_mode & FMODE_WRITE) && filemap_nr_thps(inode->i_mapping))
827 : : truncate_pagecache(inode, 0);
828 : :
829 : : return 0;
830 : :
831 : 14700 : cleanup_all:
832 [ - + - + ]: 14700 : if (WARN_ON_ONCE(error > 0))
833 : 0 : error = -EINVAL;
834 [ + - ]: 14700 : fops_put(f->f_op);
835 [ + - ]: 14700 : if (f->f_mode & FMODE_WRITER) {
836 : 0 : put_write_access(inode);
837 : 0 : __mnt_drop_write(f->f_path.mnt);
838 : : }
839 : 14700 : cleanup_file:
840 : 14700 : path_put(&f->f_path);
841 : 14700 : f->f_path.mnt = NULL;
842 : 14700 : f->f_path.dentry = NULL;
843 : 14700 : f->f_inode = NULL;
844 : 14700 : return error;
845 : : }
846 : :
847 : : /**
848 : : * finish_open - finish opening a file
849 : : * @file: file pointer
850 : : * @dentry: pointer to dentry
851 : : * @open: open callback
852 : : * @opened: state of open
853 : : *
854 : : * This can be used to finish opening a file passed to i_op->atomic_open().
855 : : *
856 : : * If the open callback is set to NULL, then the standard f_op->open()
857 : : * filesystem callback is substituted.
858 : : *
859 : : * NB: the dentry reference is _not_ consumed. If, for example, the dentry is
860 : : * the return value of d_splice_alias(), then the caller needs to perform dput()
861 : : * on it after finish_open().
862 : : *
863 : : * Returns zero on success or -errno if the open failed.
864 : : */
865 : 0 : int finish_open(struct file *file, struct dentry *dentry,
866 : : int (*open)(struct inode *, struct file *))
867 : : {
868 [ # # ]: 0 : BUG_ON(file->f_mode & FMODE_OPENED); /* once it's opened, it's opened */
869 : :
870 : 0 : file->f_path.dentry = dentry;
871 : 0 : return do_dentry_open(file, d_backing_inode(dentry), open);
872 : : }
873 : : EXPORT_SYMBOL(finish_open);
874 : :
875 : : /**
876 : : * finish_no_open - finish ->atomic_open() without opening the file
877 : : *
878 : : * @file: file pointer
879 : : * @dentry: dentry or NULL (as returned from ->lookup())
880 : : *
881 : : * This can be used to set the result of a successful lookup in ->atomic_open().
882 : : *
883 : : * NB: unlike finish_open() this function does consume the dentry reference and
884 : : * the caller need not dput() it.
885 : : *
886 : : * Returns "0" which must be the return value of ->atomic_open() after having
887 : : * called this function.
888 : : */
889 : 0 : int finish_no_open(struct file *file, struct dentry *dentry)
890 : : {
891 : 0 : file->f_path.dentry = dentry;
892 : 0 : return 0;
893 : : }
894 : : EXPORT_SYMBOL(finish_no_open);
895 : :
896 : 0 : char *file_path(struct file *filp, char *buf, int buflen)
897 : : {
898 : 0 : return d_path(&filp->f_path, buf, buflen);
899 : : }
900 : : EXPORT_SYMBOL(file_path);
901 : :
902 : : /**
903 : : * vfs_open - open the file at the given path
904 : : * @path: path to open
905 : : * @file: newly allocated file with f_flag initialized
906 : : * @cred: credentials to use
907 : : */
908 : 1164217 : int vfs_open(const struct path *path, struct file *file)
909 : : {
910 : 1164217 : file->f_path = *path;
911 : 1164189 : return do_dentry_open(file, d_backing_inode(path->dentry), NULL);
912 : : }
913 : :
914 : 28 : struct file *dentry_open(const struct path *path, int flags,
915 : : const struct cred *cred)
916 : : {
917 : 28 : int error;
918 : 28 : struct file *f;
919 : :
920 [ - + ]: 28 : validate_creds(cred);
921 : :
922 : : /* We must always pass in a valid mount pointer. */
923 [ - + ]: 28 : BUG_ON(!path->mnt);
924 : :
925 : 28 : f = alloc_empty_file(flags, cred);
926 [ + - ]: 28 : if (!IS_ERR(f)) {
927 : 28 : error = vfs_open(path, f);
928 [ - + ]: 28 : if (error) {
929 : 0 : fput(f);
930 : 0 : f = ERR_PTR(error);
931 : : }
932 : : }
933 : 28 : return f;
934 : : }
935 : : EXPORT_SYMBOL(dentry_open);
936 : :
937 : 0 : struct file *open_with_fake_path(const struct path *path, int flags,
938 : : struct inode *inode, const struct cred *cred)
939 : : {
940 : 0 : struct file *f = alloc_empty_file_noaccount(flags, cred);
941 [ # # ]: 0 : if (!IS_ERR(f)) {
942 : 0 : int error;
943 : :
944 : 0 : f->f_path = *path;
945 : 0 : error = do_dentry_open(f, inode, NULL);
946 [ # # ]: 0 : if (error) {
947 : 0 : fput(f);
948 : 0 : f = ERR_PTR(error);
949 : : }
950 : : }
951 : 0 : return f;
952 : : }
953 : : EXPORT_SYMBOL(open_with_fake_path);
954 : :
955 : : #define WILL_CREATE(flags) (flags & (O_CREAT | __O_TMPFILE))
956 : : #define O_PATH_FLAGS (O_DIRECTORY | O_NOFOLLOW | O_PATH | O_CLOEXEC)
957 : :
958 : 1378085 : inline struct open_how build_open_how(int flags, umode_t mode)
959 : : {
960 : 1378085 : struct open_how how = {
961 : 0 : .flags = flags & VALID_OPEN_FLAGS,
962 : : .mode = mode & S_IALLUGO,
963 : : };
964 : :
965 : : /* O_PATH beats everything else. */
966 [ # # ]: 0 : if (how.flags & O_PATH)
967 : 742312 : how.flags &= O_PATH_FLAGS;
968 : : /* Modes should only be set for create-like flags. */
969 [ + + - - : 1378085 : if (!WILL_CREATE(how.flags))
+ - - - ]
970 : 1343397 : how.mode = 0;
971 : 1378085 : return how;
972 : : }
973 : :
974 : 1378085 : inline int build_open_flags(const struct open_how *how, struct open_flags *op)
975 : : {
976 : 1378085 : int flags = how->flags;
977 : 1378085 : int lookup_flags = 0;
978 : 1378085 : int acc_mode = ACC_MODE(flags);
979 : :
980 : : /* Must never be set by userspace */
981 : 1378085 : flags &= ~(FMODE_NONOTIFY | O_CLOEXEC);
982 : :
983 : : /*
984 : : * Older syscalls implicitly clear all of the invalid flags or argument
985 : : * values before calling build_open_flags(), but openat2(2) checks all
986 : : * of its arguments.
987 : : */
988 [ + - ]: 1378085 : if (flags & ~VALID_OPEN_FLAGS)
989 : : return -EINVAL;
990 [ + - ]: 1378085 : if (how->resolve & ~VALID_RESOLVE_FLAGS)
991 : : return -EINVAL;
992 : :
993 : : /* Deal with the mode. */
994 [ + + ]: 1378085 : if (WILL_CREATE(flags)) {
995 [ + - ]: 34688 : if (how->mode & ~S_IALLUGO)
996 : : return -EINVAL;
997 : 34688 : op->mode = how->mode | S_IFREG;
998 : : } else {
999 [ + - ]: 1343397 : if (how->mode != 0)
1000 : : return -EINVAL;
1001 : 1343397 : op->mode = 0;
1002 : : }
1003 : :
1004 : : /*
1005 : : * In order to ensure programs get explicit errors when trying to use
1006 : : * O_TMPFILE on old kernels, O_TMPFILE is implemented such that it
1007 : : * looks like (O_DIRECTORY|O_RDWR & ~O_CREAT) to old kernels. But we
1008 : : * have to require userspace to explicitly set it.
1009 : : */
1010 [ - + ]: 1378085 : if (flags & __O_TMPFILE) {
1011 [ # # ]: 0 : if ((flags & O_TMPFILE_MASK) != O_TMPFILE)
1012 : : return -EINVAL;
1013 [ # # ]: 0 : if (!(acc_mode & MAY_WRITE))
1014 : : return -EINVAL;
1015 : : }
1016 [ + + ]: 1378085 : if (flags & O_PATH) {
1017 : : /* O_PATH only permits certain other flags to be set. */
1018 [ + - ]: 742312 : if (flags & ~O_PATH_FLAGS)
1019 : : return -EINVAL;
1020 : : acc_mode = 0;
1021 : : }
1022 : :
1023 : : /*
1024 : : * O_SYNC is implemented as __O_SYNC|O_DSYNC. As many places only
1025 : : * check for O_DSYNC if the need any syncing at all we enforce it's
1026 : : * always set instead of having to deal with possibly weird behaviour
1027 : : * for malicious applications setting only __O_SYNC.
1028 : : */
1029 [ - + ]: 1378085 : if (flags & __O_SYNC)
1030 : 0 : flags |= O_DSYNC;
1031 : :
1032 : 1378085 : op->open_flag = flags;
1033 : :
1034 : : /* O_TRUNC implies we need access checks for write permissions */
1035 [ + + ]: 1378085 : if (flags & O_TRUNC)
1036 : 8568 : acc_mode |= MAY_WRITE;
1037 : :
1038 : : /* Allow the LSM permission hook to distinguish append
1039 : : access from general write access. */
1040 [ + + ]: 1378085 : if (flags & O_APPEND)
1041 : 476 : acc_mode |= MAY_APPEND;
1042 : :
1043 : 1378085 : op->acc_mode = acc_mode;
1044 : :
1045 [ + + ]: 1378085 : op->intent = flags & O_PATH ? 0 : LOOKUP_OPEN;
1046 : :
1047 [ + + ]: 1378085 : if (flags & O_CREAT) {
1048 : 34688 : op->intent |= LOOKUP_CREATE;
1049 [ + + ]: 34688 : if (flags & O_EXCL)
1050 : 8734 : op->intent |= LOOKUP_EXCL;
1051 : : }
1052 : :
1053 [ + + ]: 1378085 : if (flags & O_DIRECTORY)
1054 : 26432 : lookup_flags |= LOOKUP_DIRECTORY;
1055 [ + + ]: 1378085 : if (!(flags & O_NOFOLLOW))
1056 : 616929 : lookup_flags |= LOOKUP_FOLLOW;
1057 : :
1058 [ - + ]: 1378085 : if (how->resolve & RESOLVE_NO_XDEV)
1059 : 0 : lookup_flags |= LOOKUP_NO_XDEV;
1060 [ - + ]: 1378085 : if (how->resolve & RESOLVE_NO_MAGICLINKS)
1061 : 0 : lookup_flags |= LOOKUP_NO_MAGICLINKS;
1062 [ - + ]: 1378085 : if (how->resolve & RESOLVE_NO_SYMLINKS)
1063 : 0 : lookup_flags |= LOOKUP_NO_SYMLINKS;
1064 [ - + ]: 1378085 : if (how->resolve & RESOLVE_BENEATH)
1065 : 0 : lookup_flags |= LOOKUP_BENEATH;
1066 [ - + ]: 1378085 : if (how->resolve & RESOLVE_IN_ROOT)
1067 : 0 : lookup_flags |= LOOKUP_IN_ROOT;
1068 : :
1069 : 1378085 : op->lookup_flags = lookup_flags;
1070 : 1378085 : return 0;
1071 : : }
1072 : :
1073 : : /**
1074 : : * file_open_name - open file and return file pointer
1075 : : *
1076 : : * @name: struct filename containing path to open
1077 : : * @flags: open flags as per the open(2) second argument
1078 : : * @mode: mode for the new file if O_CREAT is set, else ignored
1079 : : *
1080 : : * This is the helper to open a file from kernelspace if you really
1081 : : * have to. But in generally you should not do this, so please move
1082 : : * along, nothing to see here..
1083 : : */
1084 : 112 : struct file *file_open_name(struct filename *name, int flags, umode_t mode)
1085 : : {
1086 : 112 : struct open_flags op;
1087 [ - + ]: 112 : struct open_how how = build_open_how(flags, mode);
1088 : 112 : int err = build_open_flags(&how, &op);
1089 [ - + ]: 112 : if (err)
1090 : 0 : return ERR_PTR(err);
1091 : 112 : return do_filp_open(AT_FDCWD, name, &op);
1092 : : }
1093 : :
1094 : : /**
1095 : : * filp_open - open file and return file pointer
1096 : : *
1097 : : * @filename: path to open
1098 : : * @flags: open flags as per the open(2) second argument
1099 : : * @mode: mode for the new file if O_CREAT is set, else ignored
1100 : : *
1101 : : * This is the helper to open a file from kernelspace if you really
1102 : : * have to. But in generally you should not do this, so please move
1103 : : * along, nothing to see here..
1104 : : */
1105 : 112 : struct file *filp_open(const char *filename, int flags, umode_t mode)
1106 : : {
1107 : 112 : struct filename *name = getname_kernel(filename);
1108 [ + - ]: 112 : struct file *file = ERR_CAST(name);
1109 : :
1110 [ + - ]: 112 : if (!IS_ERR(name)) {
1111 : 112 : file = file_open_name(name, flags, mode);
1112 : 112 : putname(name);
1113 : : }
1114 : 112 : return file;
1115 : : }
1116 : : EXPORT_SYMBOL(filp_open);
1117 : :
1118 : 0 : struct file *file_open_root(struct dentry *dentry, struct vfsmount *mnt,
1119 : : const char *filename, int flags, umode_t mode)
1120 : : {
1121 : 0 : struct open_flags op;
1122 [ # # ]: 0 : struct open_how how = build_open_how(flags, mode);
1123 : 0 : int err = build_open_flags(&how, &op);
1124 [ # # ]: 0 : if (err)
1125 : 0 : return ERR_PTR(err);
1126 : 0 : return do_file_open_root(dentry, mnt, filename, &op);
1127 : : }
1128 : : EXPORT_SYMBOL(file_open_root);
1129 : :
1130 : 1377973 : static long do_sys_openat2(int dfd, const char __user *filename,
1131 : : struct open_how *how)
1132 : : {
1133 : 1377973 : struct open_flags op;
1134 : 1377973 : int fd = build_open_flags(how, &op);
1135 : 1377973 : struct filename *tmp;
1136 : :
1137 [ - + ]: 1377973 : if (fd)
1138 : 0 : return fd;
1139 : :
1140 : 1377973 : tmp = getname(filename);
1141 [ - + ]: 1377973 : if (IS_ERR(tmp))
1142 : 0 : return PTR_ERR(tmp);
1143 : :
1144 : 1377973 : fd = get_unused_fd_flags(how->flags);
1145 [ + - ]: 1377973 : if (fd >= 0) {
1146 : 1377973 : struct file *f = do_filp_open(dfd, tmp, &op);
1147 [ + + ]: 1377945 : if (IS_ERR(f)) {
1148 : 278632 : put_unused_fd(fd);
1149 : 278632 : fd = PTR_ERR(f);
1150 : : } else {
1151 : 1099313 : fsnotify_open(f);
1152 : 1099313 : fd_install(fd, f);
1153 : : }
1154 : : }
1155 : 1377945 : putname(tmp);
1156 : 1377945 : return fd;
1157 : : }
1158 : :
1159 : 1377973 : long do_sys_open(int dfd, const char __user *filename, int flags, umode_t mode)
1160 : : {
1161 [ + + ]: 1377973 : struct open_how how = build_open_how(flags, mode);
1162 : 1377973 : return do_sys_openat2(dfd, filename, &how);
1163 : : }
1164 : :
1165 : :
1166 : 0 : SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, umode_t, mode)
1167 : : {
1168 : 0 : return ksys_open(filename, flags, mode);
1169 : : }
1170 : :
1171 : 2755750 : SYSCALL_DEFINE4(openat, int, dfd, const char __user *, filename, int, flags,
1172 : : umode_t, mode)
1173 : : {
1174 : 1377889 : if (force_o_largefile())
1175 : 1377889 : flags |= O_LARGEFILE;
1176 : 1377889 : return do_sys_open(dfd, filename, flags, mode);
1177 : : }
1178 : :
1179 : 0 : SYSCALL_DEFINE4(openat2, int, dfd, const char __user *, filename,
1180 : : struct open_how __user *, how, size_t, usize)
1181 : : {
1182 : 0 : int err;
1183 : 0 : struct open_how tmp;
1184 : :
1185 : 0 : BUILD_BUG_ON(sizeof(struct open_how) < OPEN_HOW_SIZE_VER0);
1186 : 0 : BUILD_BUG_ON(sizeof(struct open_how) != OPEN_HOW_SIZE_LATEST);
1187 : :
1188 [ # # ]: 0 : if (unlikely(usize < OPEN_HOW_SIZE_VER0))
1189 : : return -EINVAL;
1190 : :
1191 [ # # ]: 0 : err = copy_struct_from_user(&tmp, sizeof(tmp), how, usize);
1192 : 0 : if (err)
1193 : 0 : return err;
1194 : :
1195 : : /* O_LARGEFILE is only allowed for non-O_PATH. */
1196 [ # # ]: 0 : if (!(tmp.flags & O_PATH) && force_o_largefile())
1197 : 0 : tmp.flags |= O_LARGEFILE;
1198 : :
1199 : 0 : return do_sys_openat2(dfd, filename, &tmp);
1200 : : }
1201 : :
1202 : : #ifdef CONFIG_COMPAT
1203 : : /*
1204 : : * Exactly like sys_open(), except that it doesn't set the
1205 : : * O_LARGEFILE flag.
1206 : : */
1207 : 0 : COMPAT_SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, umode_t, mode)
1208 : : {
1209 : 0 : return do_sys_open(AT_FDCWD, filename, flags, mode);
1210 : : }
1211 : :
1212 : : /*
1213 : : * Exactly like sys_openat(), except that it doesn't set the
1214 : : * O_LARGEFILE flag.
1215 : : */
1216 : 0 : COMPAT_SYSCALL_DEFINE4(openat, int, dfd, const char __user *, filename, int, flags, umode_t, mode)
1217 : : {
1218 : 0 : return do_sys_open(dfd, filename, flags, mode);
1219 : : }
1220 : : #endif
1221 : :
1222 : : #ifndef __alpha__
1223 : :
1224 : : /*
1225 : : * For backward compatibility? Maybe this should be moved
1226 : : * into arch/i386 instead?
1227 : : */
1228 : 56 : SYSCALL_DEFINE2(creat, const char __user *, pathname, umode_t, mode)
1229 : : {
1230 : 28 : return ksys_open(pathname, O_CREAT | O_WRONLY | O_TRUNC, mode);
1231 : : }
1232 : :
1233 : : #endif
1234 : :
1235 : : /*
1236 : : * "id" is the POSIX thread ID. We use the
1237 : : * files pointer for this..
1238 : : */
1239 : 1411803 : int filp_close(struct file *filp, fl_owner_t id)
1240 : : {
1241 : 1411803 : int retval = 0;
1242 : :
1243 [ - + ]: 1411803 : if (!file_count(filp)) {
1244 : 0 : printk(KERN_ERR "VFS: Close: file count is 0\n");
1245 : 0 : return 0;
1246 : : }
1247 : :
1248 [ + + ]: 1411803 : if (filp->f_op->flush)
1249 : 84 : retval = filp->f_op->flush(filp, id);
1250 : :
1251 [ + + ]: 1411803 : if (likely(!(filp->f_mode & FMODE_PATH))) {
1252 : 758783 : dnotify_flush(filp, id);
1253 : 758783 : locks_remove_posix(filp, id);
1254 : : }
1255 : 1411803 : fput(filp);
1256 : 1411803 : return retval;
1257 : : }
1258 : :
1259 : : EXPORT_SYMBOL(filp_close);
1260 : :
1261 : : /*
1262 : : * Careful here! We test whether the file pointer is NULL before
1263 : : * releasing the fd. This ensures that one clone task can't release
1264 : : * an fd while another clone is opening it.
1265 : : */
1266 : 2466606 : SYSCALL_DEFINE1(close, unsigned int, fd)
1267 : : {
1268 : 1233303 : int retval = __close_fd(current->files, fd);
1269 : :
1270 : : /* can't restart close syscall because file table entry was cleared */
1271 [ + - - + ]: 1233303 : if (unlikely(retval == -ERESTARTSYS ||
1272 : : retval == -ERESTARTNOINTR ||
1273 : : retval == -ERESTARTNOHAND ||
1274 : : retval == -ERESTART_RESTARTBLOCK))
1275 : 0 : retval = -EINTR;
1276 : :
1277 : 1233303 : return retval;
1278 : : }
1279 : :
1280 : : /*
1281 : : * This routine simulates a hangup on the tty, to arrange that users
1282 : : * are given clean terminals at login time.
1283 : : */
1284 : 0 : SYSCALL_DEFINE0(vhangup)
1285 : : {
1286 [ # # ]: 0 : if (capable(CAP_SYS_TTY_CONFIG)) {
1287 : 0 : tty_vhangup_self();
1288 : 0 : return 0;
1289 : : }
1290 : : return -EPERM;
1291 : : }
1292 : :
1293 : : /*
1294 : : * Called when an inode is about to be open.
1295 : : * We use this to disallow opening large files on 32bit systems if
1296 : : * the caller didn't specify O_LARGEFILE. On 64bit systems we force
1297 : : * on this flag in sys_open.
1298 : : */
1299 : 373380 : int generic_file_open(struct inode * inode, struct file * filp)
1300 : : {
1301 [ - + - - ]: 373380 : if (!(filp->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
1302 : 0 : return -EOVERFLOW;
1303 : : return 0;
1304 : : }
1305 : :
1306 : : EXPORT_SYMBOL(generic_file_open);
1307 : :
1308 : : /*
1309 : : * This is used by subsystems that don't want seekable
1310 : : * file descriptors. The function is not supposed to ever fail, the only
1311 : : * reason it returns an 'int' and not 'void' is so that it can be plugged
1312 : : * directly into file_operations structure.
1313 : : */
1314 : 2800 : int nonseekable_open(struct inode *inode, struct file *filp)
1315 : : {
1316 : 2800 : filp->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
1317 : 2800 : return 0;
1318 : : }
1319 : :
1320 : : EXPORT_SYMBOL(nonseekable_open);
1321 : :
1322 : : /*
1323 : : * stream_open is used by subsystems that want stream-like file descriptors.
1324 : : * Such file descriptors are not seekable and don't have notion of position
1325 : : * (file.f_pos is always 0 and ppos passed to .read()/.write() is always NULL).
1326 : : * Contrary to file descriptors of other regular files, .read() and .write()
1327 : : * can run simultaneously.
1328 : : *
1329 : : * stream_open never fails and is marked to return int so that it could be
1330 : : * directly used as file_operations.open .
1331 : : */
1332 : 10752 : int stream_open(struct inode *inode, struct file *filp)
1333 : : {
1334 : 10752 : filp->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE | FMODE_ATOMIC_POS);
1335 : 10752 : filp->f_mode |= FMODE_STREAM;
1336 : 10752 : return 0;
1337 : : }
1338 : :
1339 : : EXPORT_SYMBOL(stream_open);
|
