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