1
2
3
4
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 <asm/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
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
55 ret = should_remove_suid(dentry);
56 if (ret)
57 newattrs.ia_valid |= ret | ATTR_FORCE;
58
59 mutex_lock(&dentry->d_inode->i_mutex);
60 ret = notify_change(dentry, &newattrs);
61 mutex_unlock(&dentry->d_inode->i_mutex);
62 return ret;
63}
64
65long vfs_truncate(struct path *path, loff_t length)
66{
67 struct inode *inode;
68 long error;
69
70 inode = path->dentry->d_inode;
71
72
73 if (S_ISDIR(inode->i_mode))
74 return -EISDIR;
75 if (!S_ISREG(inode->i_mode))
76 return -EINVAL;
77
78 error = mnt_want_write(path->mnt);
79 if (error)
80 goto out;
81
82 error = inode_permission(inode, MAY_WRITE);
83 if (error)
84 goto mnt_drop_write_and_out;
85
86 error = -EPERM;
87 if (IS_APPEND(inode))
88 goto mnt_drop_write_and_out;
89
90 error = get_write_access(inode);
91 if (error)
92 goto mnt_drop_write_and_out;
93
94
95
96
97
98 error = break_lease(inode, O_WRONLY);
99 if (error)
100 goto put_write_and_out;
101
102 error = locks_verify_truncate(inode, NULL, length);
103 if (!error)
104 error = security_path_truncate(path);
105 if (!error)
106 error = do_truncate(path->dentry, length, 0, NULL);
107
108put_write_and_out:
109 put_write_access(inode);
110mnt_drop_write_and_out:
111 mnt_drop_write(path->mnt);
112out:
113 return error;
114}
115EXPORT_SYMBOL_GPL(vfs_truncate);
116
117static long do_sys_truncate(const char __user *pathname, loff_t length)
118{
119 unsigned int lookup_flags = LOOKUP_FOLLOW;
120 struct path path;
121 int error;
122
123 if (length < 0)
124 return -EINVAL;
125
126retry:
127 error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
128 if (!error) {
129 error = vfs_truncate(&path, length);
130 path_put(&path);
131 }
132 if (retry_estale(error, lookup_flags)) {
133 lookup_flags |= LOOKUP_REVAL;
134 goto retry;
135 }
136 return error;
137}
138
139SYSCALL_DEFINE2(truncate, const char __user *, path, long, length)
140{
141 return do_sys_truncate(path, length);
142}
143
144#ifdef CONFIG_COMPAT
145COMPAT_SYSCALL_DEFINE2(truncate, const char __user *, path, compat_off_t, length)
146{
147 return do_sys_truncate(path, length);
148}
149#endif
150
151static long do_sys_ftruncate(unsigned int fd, loff_t length, int small)
152{
153 struct inode *inode;
154 struct dentry *dentry;
155 struct fd f;
156 int error;
157
158 error = -EINVAL;
159 if (length < 0)
160 goto out;
161 error = -EBADF;
162 f = fdget(fd);
163 if (!f.file)
164 goto out;
165
166
167 if (f.file->f_flags & O_LARGEFILE)
168 small = 0;
169
170 dentry = f.file->f_path.dentry;
171 inode = dentry->d_inode;
172 error = -EINVAL;
173 if (!S_ISREG(inode->i_mode) || !(f.file->f_mode & FMODE_WRITE))
174 goto out_putf;
175
176 error = -EINVAL;
177
178 if (small && length > MAX_NON_LFS)
179 goto out_putf;
180
181 error = -EPERM;
182 if (IS_APPEND(inode))
183 goto out_putf;
184
185 sb_start_write(inode->i_sb);
186 error = locks_verify_truncate(inode, f.file, length);
187 if (!error)
188 error = security_path_truncate(&f.file->f_path);
189 if (!error)
190 error = do_truncate(dentry, length, ATTR_MTIME|ATTR_CTIME, f.file);
191 sb_end_write(inode->i_sb);
192out_putf:
193 fdput(f);
194out:
195 return error;
196}
197
198SYSCALL_DEFINE2(ftruncate, unsigned int, fd, unsigned long, length)
199{
200 return do_sys_ftruncate(fd, length, 1);
201}
202
203#ifdef CONFIG_COMPAT
204COMPAT_SYSCALL_DEFINE2(ftruncate, unsigned int, fd, compat_ulong_t, length)
205{
206 return do_sys_ftruncate(fd, length, 1);
207}
208#endif
209
210
211#if BITS_PER_LONG == 32
212SYSCALL_DEFINE2(truncate64, const char __user *, path, loff_t, length)
213{
214 return do_sys_truncate(path, length);
215}
216
217SYSCALL_DEFINE2(ftruncate64, unsigned int, fd, loff_t, length)
218{
219 return do_sys_ftruncate(fd, length, 0);
220}
221#endif
222
223
224int do_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
225{
226 struct inode *inode = file_inode(file);
227 long ret;
228
229 if (offset < 0 || len <= 0)
230 return -EINVAL;
231
232
233 if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE))
234 return -EOPNOTSUPP;
235
236
237 if ((mode & FALLOC_FL_PUNCH_HOLE) &&
238 !(mode & FALLOC_FL_KEEP_SIZE))
239 return -EOPNOTSUPP;
240
241 if (!(file->f_mode & FMODE_WRITE))
242 return -EBADF;
243
244
245 if (mode & FALLOC_FL_PUNCH_HOLE && IS_APPEND(inode))
246 return -EPERM;
247
248 if (IS_IMMUTABLE(inode))
249 return -EPERM;
250
251
252
253
254
255 ret = security_file_permission(file, MAY_WRITE);
256 if (ret)
257 return ret;
258
259 if (S_ISFIFO(inode->i_mode))
260 return -ESPIPE;
261
262
263
264
265
266 if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode))
267 return -ENODEV;
268
269
270 if (((offset + len) > inode->i_sb->s_maxbytes) || ((offset + len) < 0))
271 return -EFBIG;
272
273 if (!file->f_op->fallocate)
274 return -EOPNOTSUPP;
275
276 sb_start_write(inode->i_sb);
277 ret = file->f_op->fallocate(file, mode, offset, len);
278 sb_end_write(inode->i_sb);
279 return ret;
280}
281
282SYSCALL_DEFINE4(fallocate, int, fd, int, mode, loff_t, offset, loff_t, len)
283{
284 struct fd f = fdget(fd);
285 int error = -EBADF;
286
287 if (f.file) {
288 error = do_fallocate(f.file, mode, offset, len);
289 fdput(f);
290 }
291 return error;
292}
293
294
295
296
297
298
299SYSCALL_DEFINE3(faccessat, int, dfd, const char __user *, filename, int, mode)
300{
301 const struct cred *old_cred;
302 struct cred *override_cred;
303 struct path path;
304 struct inode *inode;
305 int res;
306 unsigned int lookup_flags = LOOKUP_FOLLOW;
307
308 if (mode & ~S_IRWXO)
309 return -EINVAL;
310
311 override_cred = prepare_creds();
312 if (!override_cred)
313 return -ENOMEM;
314
315 override_cred->fsuid = override_cred->uid;
316 override_cred->fsgid = override_cred->gid;
317
318 if (!issecure(SECURE_NO_SETUID_FIXUP)) {
319
320 kuid_t root_uid = make_kuid(override_cred->user_ns, 0);
321 if (!uid_eq(override_cred->uid, root_uid))
322 cap_clear(override_cred->cap_effective);
323 else
324 override_cred->cap_effective =
325 override_cred->cap_permitted;
326 }
327
328 old_cred = override_creds(override_cred);
329retry:
330 res = user_path_at(dfd, filename, lookup_flags, &path);
331 if (res)
332 goto out;
333
334 inode = path.dentry->d_inode;
335
336 if ((mode & MAY_EXEC) && S_ISREG(inode->i_mode)) {
337
338
339
340
341 res = -EACCES;
342 if (path.mnt->mnt_flags & MNT_NOEXEC)
343 goto out_path_release;
344 }
345
346 res = inode_permission(inode, mode | MAY_ACCESS);
347
348 if (res || !(mode & S_IWOTH) || special_file(inode->i_mode))
349 goto out_path_release;
350
351
352
353
354
355
356
357
358
359
360 if (__mnt_is_readonly(path.mnt))
361 res = -EROFS;
362
363out_path_release:
364 path_put(&path);
365 if (retry_estale(res, lookup_flags)) {
366 lookup_flags |= LOOKUP_REVAL;
367 goto retry;
368 }
369out:
370 revert_creds(old_cred);
371 put_cred(override_cred);
372 return res;
373}
374
375SYSCALL_DEFINE2(access, const char __user *, filename, int, mode)
376{
377 return sys_faccessat(AT_FDCWD, filename, mode);
378}
379
380SYSCALL_DEFINE1(chdir, const char __user *, filename)
381{
382 struct path path;
383 int error;
384 unsigned int lookup_flags = LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
385retry:
386 error = user_path_at(AT_FDCWD, filename, lookup_flags, &path);
387 if (error)
388 goto out;
389
390 error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_CHDIR);
391 if (error)
392 goto dput_and_out;
393
394 set_fs_pwd(current->fs, &path);
395
396dput_and_out:
397 path_put(&path);
398 if (retry_estale(error, lookup_flags)) {
399 lookup_flags |= LOOKUP_REVAL;
400 goto retry;
401 }
402out:
403 return error;
404}
405
406SYSCALL_DEFINE1(fchdir, unsigned int, fd)
407{
408 struct fd f = fdget_raw(fd);
409 struct inode *inode;
410 int error = -EBADF;
411
412 error = -EBADF;
413 if (!f.file)
414 goto out;
415
416 inode = file_inode(f.file);
417
418 error = -ENOTDIR;
419 if (!S_ISDIR(inode->i_mode))
420 goto out_putf;
421
422 error = inode_permission(inode, MAY_EXEC | MAY_CHDIR);
423 if (!error)
424 set_fs_pwd(current->fs, &f.file->f_path);
425out_putf:
426 fdput(f);
427out:
428 return error;
429}
430
431SYSCALL_DEFINE1(chroot, const char __user *, filename)
432{
433 struct path path;
434 int error;
435 unsigned int lookup_flags = LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
436retry:
437 error = user_path_at(AT_FDCWD, filename, lookup_flags, &path);
438 if (error)
439 goto out;
440
441 error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_CHDIR);
442 if (error)
443 goto dput_and_out;
444
445 error = -EPERM;
446 if (!ns_capable(current_user_ns(), CAP_SYS_CHROOT))
447 goto dput_and_out;
448 error = security_path_chroot(&path);
449 if (error)
450 goto dput_and_out;
451
452 set_fs_root(current->fs, &path);
453 error = 0;
454dput_and_out:
455 path_put(&path);
456 if (retry_estale(error, lookup_flags)) {
457 lookup_flags |= LOOKUP_REVAL;
458 goto retry;
459 }
460out:
461 return error;
462}
463
464static int chmod_common(struct path *path, umode_t mode)
465{
466 struct inode *inode = path->dentry->d_inode;
467 struct iattr newattrs;
468 int error;
469
470 error = mnt_want_write(path->mnt);
471 if (error)
472 return error;
473 mutex_lock(&inode->i_mutex);
474 error = security_path_chmod(path, mode);
475 if (error)
476 goto out_unlock;
477 newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
478 newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
479 error = notify_change(path->dentry, &newattrs);
480out_unlock:
481 mutex_unlock(&inode->i_mutex);
482 mnt_drop_write(path->mnt);
483 return error;
484}
485
486SYSCALL_DEFINE2(fchmod, unsigned int, fd, umode_t, mode)
487{
488 struct fd f = fdget(fd);
489 int err = -EBADF;
490
491 if (f.file) {
492 audit_inode(NULL, f.file->f_path.dentry, 0);
493 err = chmod_common(&f.file->f_path, mode);
494 fdput(f);
495 }
496 return err;
497}
498
499SYSCALL_DEFINE3(fchmodat, int, dfd, const char __user *, filename, umode_t, mode)
500{
501 struct path path;
502 int error;
503 unsigned int lookup_flags = LOOKUP_FOLLOW;
504retry:
505 error = user_path_at(dfd, filename, lookup_flags, &path);
506 if (!error) {
507 error = chmod_common(&path, mode);
508 path_put(&path);
509 if (retry_estale(error, lookup_flags)) {
510 lookup_flags |= LOOKUP_REVAL;
511 goto retry;
512 }
513 }
514 return error;
515}
516
517SYSCALL_DEFINE2(chmod, const char __user *, filename, umode_t, mode)
518{
519 return sys_fchmodat(AT_FDCWD, filename, mode);
520}
521
522static int chown_common(struct path *path, uid_t user, gid_t group)
523{
524 struct inode *inode = path->dentry->d_inode;
525 int error;
526 struct iattr newattrs;
527 kuid_t uid;
528 kgid_t gid;
529
530 uid = make_kuid(current_user_ns(), user);
531 gid = make_kgid(current_user_ns(), group);
532
533 newattrs.ia_valid = ATTR_CTIME;
534 if (user != (uid_t) -1) {
535 if (!uid_valid(uid))
536 return -EINVAL;
537 newattrs.ia_valid |= ATTR_UID;
538 newattrs.ia_uid = uid;
539 }
540 if (group != (gid_t) -1) {
541 if (!gid_valid(gid))
542 return -EINVAL;
543 newattrs.ia_valid |= ATTR_GID;
544 newattrs.ia_gid = gid;
545 }
546 if (!S_ISDIR(inode->i_mode))
547 newattrs.ia_valid |=
548 ATTR_KILL_SUID | ATTR_KILL_SGID | ATTR_KILL_PRIV;
549 mutex_lock(&inode->i_mutex);
550 error = security_path_chown(path, uid, gid);
551 if (!error)
552 error = notify_change(path->dentry, &newattrs);
553 mutex_unlock(&inode->i_mutex);
554
555 return error;
556}
557
558SYSCALL_DEFINE5(fchownat, int, dfd, const char __user *, filename, uid_t, user,
559 gid_t, group, int, flag)
560{
561 struct path path;
562 int error = -EINVAL;
563 int lookup_flags;
564
565 if ((flag & ~(AT_SYMLINK_NOFOLLOW | AT_EMPTY_PATH)) != 0)
566 goto out;
567
568 lookup_flags = (flag & AT_SYMLINK_NOFOLLOW) ? 0 : LOOKUP_FOLLOW;
569 if (flag & AT_EMPTY_PATH)
570 lookup_flags |= LOOKUP_EMPTY;
571retry:
572 error = user_path_at(dfd, filename, lookup_flags, &path);
573 if (error)
574 goto out;
575 error = mnt_want_write(path.mnt);
576 if (error)
577 goto out_release;
578 error = chown_common(&path, user, group);
579 mnt_drop_write(path.mnt);
580out_release:
581 path_put(&path);
582 if (retry_estale(error, lookup_flags)) {
583 lookup_flags |= LOOKUP_REVAL;
584 goto retry;
585 }
586out:
587 return error;
588}
589
590SYSCALL_DEFINE3(chown, const char __user *, filename, uid_t, user, gid_t, group)
591{
592 return sys_fchownat(AT_FDCWD, filename, user, group, 0);
593}
594
595SYSCALL_DEFINE3(lchown, const char __user *, filename, uid_t, user, gid_t, group)
596{
597 return sys_fchownat(AT_FDCWD, filename, user, group,
598 AT_SYMLINK_NOFOLLOW);
599}
600
601SYSCALL_DEFINE3(fchown, unsigned int, fd, uid_t, user, gid_t, group)
602{
603 struct fd f = fdget(fd);
604 int error = -EBADF;
605
606 if (!f.file)
607 goto out;
608
609 error = mnt_want_write_file(f.file);
610 if (error)
611 goto out_fput;
612 audit_inode(NULL, f.file->f_path.dentry, 0);
613 error = chown_common(&f.file->f_path, user, group);
614 mnt_drop_write_file(f.file);
615out_fput:
616 fdput(f);
617out:
618 return error;
619}
620
621
622
623
624
625
626
627static inline int __get_file_write_access(struct inode *inode,
628 struct vfsmount *mnt)
629{
630 int error;
631 error = get_write_access(inode);
632 if (error)
633 return error;
634
635
636
637
638
639 if (!special_file(inode->i_mode)) {
640
641
642
643 error = __mnt_want_write(mnt);
644 if (error)
645 put_write_access(inode);
646 }
647 return error;
648}
649
650int open_check_o_direct(struct file *f)
651{
652
653 if (f->f_flags & O_DIRECT) {
654 if (!f->f_mapping->a_ops ||
655 ((!f->f_mapping->a_ops->direct_IO) &&
656 (!f->f_mapping->a_ops->get_xip_mem))) {
657 return -EINVAL;
658 }
659 }
660 return 0;
661}
662
663static int do_dentry_open(struct file *f,
664 int (*open)(struct inode *, struct file *),
665 const struct cred *cred)
666{
667 static const struct file_operations empty_fops = {};
668 struct inode *inode;
669 int error;
670
671 f->f_mode = OPEN_FMODE(f->f_flags) | FMODE_LSEEK |
672 FMODE_PREAD | FMODE_PWRITE;
673
674 if (unlikely(f->f_flags & O_PATH))
675 f->f_mode = FMODE_PATH;
676
677 path_get(&f->f_path);
678 inode = f->f_inode = f->f_path.dentry->d_inode;
679 if (f->f_mode & FMODE_WRITE) {
680 error = __get_file_write_access(inode, f->f_path.mnt);
681 if (error)
682 goto cleanup_file;
683 if (!special_file(inode->i_mode))
684 file_take_write(f);
685 }
686
687 f->f_mapping = inode->i_mapping;
688 file_sb_list_add(f, inode->i_sb);
689
690 if (unlikely(f->f_mode & FMODE_PATH)) {
691 f->f_op = &empty_fops;
692 return 0;
693 }
694
695 f->f_op = fops_get(inode->i_fop);
696
697 error = security_file_open(f, cred);
698 if (error)
699 goto cleanup_all;
700
701 error = break_lease(inode, f->f_flags);
702 if (error)
703 goto cleanup_all;
704
705 if (!open && f->f_op)
706 open = f->f_op->open;
707 if (open) {
708 error = open(inode, f);
709 if (error)
710 goto cleanup_all;
711 }
712 if ((f->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ)
713 i_readcount_inc(inode);
714
715 f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
716
717 file_ra_state_init(&f->f_ra, f->f_mapping->host->i_mapping);
718
719 return 0;
720
721cleanup_all:
722 fops_put(f->f_op);
723 file_sb_list_del(f);
724 if (f->f_mode & FMODE_WRITE) {
725 put_write_access(inode);
726 if (!special_file(inode->i_mode)) {
727
728
729
730
731
732
733 file_reset_write(f);
734 __mnt_drop_write(f->f_path.mnt);
735 }
736 }
737cleanup_file:
738 path_put(&f->f_path);
739 f->f_path.mnt = NULL;
740 f->f_path.dentry = NULL;
741 f->f_inode = NULL;
742 return error;
743}
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766int finish_open(struct file *file, struct dentry *dentry,
767 int (*open)(struct inode *, struct file *),
768 int *opened)
769{
770 int error;
771 BUG_ON(*opened & FILE_OPENED);
772
773 file->f_path.dentry = dentry;
774 error = do_dentry_open(file, open, current_cred());
775 if (!error)
776 *opened |= FILE_OPENED;
777
778 return error;
779}
780EXPORT_SYMBOL(finish_open);
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796int finish_no_open(struct file *file, struct dentry *dentry)
797{
798 file->f_path.dentry = dentry;
799 return 1;
800}
801EXPORT_SYMBOL(finish_no_open);
802
803struct file *dentry_open(const struct path *path, int flags,
804 const struct cred *cred)
805{
806 int error;
807 struct file *f;
808
809 validate_creds(cred);
810
811
812 BUG_ON(!path->mnt);
813
814 f = get_empty_filp();
815 if (!IS_ERR(f)) {
816 f->f_flags = flags;
817 f->f_path = *path;
818 error = do_dentry_open(f, NULL, cred);
819 if (!error) {
820
821 error = open_check_o_direct(f);
822 if (error) {
823 fput(f);
824 f = ERR_PTR(error);
825 }
826 } else {
827 put_filp(f);
828 f = ERR_PTR(error);
829 }
830 }
831 return f;
832}
833EXPORT_SYMBOL(dentry_open);
834
835static inline int build_open_flags(int flags, umode_t mode, struct open_flags *op)
836{
837 int lookup_flags = 0;
838 int acc_mode;
839
840 if (flags & (O_CREAT | __O_TMPFILE))
841 op->mode = (mode & S_IALLUGO) | S_IFREG;
842 else
843 op->mode = 0;
844
845
846 flags &= ~FMODE_NONOTIFY & ~O_CLOEXEC;
847
848
849
850
851
852
853
854 if (flags & __O_SYNC)
855 flags |= O_DSYNC;
856
857 if (flags & __O_TMPFILE) {
858 if ((flags & O_TMPFILE_MASK) != O_TMPFILE)
859 return -EINVAL;
860 acc_mode = MAY_OPEN | ACC_MODE(flags);
861 if (!(acc_mode & MAY_WRITE))
862 return -EINVAL;
863 } else if (flags & O_PATH) {
864
865
866
867
868 flags &= O_DIRECTORY | O_NOFOLLOW | O_PATH;
869 acc_mode = 0;
870 } else {
871 acc_mode = MAY_OPEN | ACC_MODE(flags);
872 }
873
874 op->open_flag = flags;
875
876
877 if (flags & O_TRUNC)
878 acc_mode |= MAY_WRITE;
879
880
881
882 if (flags & O_APPEND)
883 acc_mode |= MAY_APPEND;
884
885 op->acc_mode = acc_mode;
886
887 op->intent = flags & O_PATH ? 0 : LOOKUP_OPEN;
888
889 if (flags & O_CREAT) {
890 op->intent |= LOOKUP_CREATE;
891 if (flags & O_EXCL)
892 op->intent |= LOOKUP_EXCL;
893 }
894
895 if (flags & O_DIRECTORY)
896 lookup_flags |= LOOKUP_DIRECTORY;
897 if (!(flags & O_NOFOLLOW))
898 lookup_flags |= LOOKUP_FOLLOW;
899 op->lookup_flags = lookup_flags;
900 return 0;
901}
902
903
904
905
906
907
908
909
910
911
912
913
914struct file *file_open_name(struct filename *name, int flags, umode_t mode)
915{
916 struct open_flags op;
917 int err = build_open_flags(flags, mode, &op);
918 return err ? ERR_PTR(err) : do_filp_open(AT_FDCWD, name, &op);
919}
920
921
922
923
924
925
926
927
928
929
930
931
932struct file *filp_open(const char *filename, int flags, umode_t mode)
933{
934 struct filename name = {.name = filename};
935 return file_open_name(&name, flags, mode);
936}
937EXPORT_SYMBOL(filp_open);
938
939struct file *file_open_root(struct dentry *dentry, struct vfsmount *mnt,
940 const char *filename, int flags)
941{
942 struct open_flags op;
943 int err = build_open_flags(flags, 0, &op);
944 if (err)
945 return ERR_PTR(err);
946 if (flags & O_CREAT)
947 return ERR_PTR(-EINVAL);
948 if (!filename && (flags & O_DIRECTORY))
949 if (!dentry->d_inode->i_op->lookup)
950 return ERR_PTR(-ENOTDIR);
951 return do_file_open_root(dentry, mnt, filename, &op);
952}
953EXPORT_SYMBOL(file_open_root);
954
955long do_sys_open(int dfd, const char __user *filename, int flags, umode_t mode)
956{
957 struct open_flags op;
958 int fd = build_open_flags(flags, mode, &op);
959 struct filename *tmp;
960
961 if (fd)
962 return fd;
963
964 tmp = getname(filename);
965 if (IS_ERR(tmp))
966 return PTR_ERR(tmp);
967
968 fd = get_unused_fd_flags(flags);
969 if (fd >= 0) {
970 struct file *f = do_filp_open(dfd, tmp, &op);
971 if (IS_ERR(f)) {
972 put_unused_fd(fd);
973 fd = PTR_ERR(f);
974 } else {
975 fsnotify_open(f);
976 fd_install(fd, f);
977 }
978 }
979 putname(tmp);
980 return fd;
981}
982
983SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, umode_t, mode)
984{
985 if (force_o_largefile())
986 flags |= O_LARGEFILE;
987
988 return do_sys_open(AT_FDCWD, filename, flags, mode);
989}
990
991SYSCALL_DEFINE4(openat, int, dfd, const char __user *, filename, int, flags,
992 umode_t, mode)
993{
994 if (force_o_largefile())
995 flags |= O_LARGEFILE;
996
997 return do_sys_open(dfd, filename, flags, mode);
998}
999
1000#ifndef __alpha__
1001
1002
1003
1004
1005
1006SYSCALL_DEFINE2(creat, const char __user *, pathname, umode_t, mode)
1007{
1008 return sys_open(pathname, O_CREAT | O_WRONLY | O_TRUNC, mode);
1009}
1010
1011#endif
1012
1013
1014
1015
1016
1017int filp_close(struct file *filp, fl_owner_t id)
1018{
1019 int retval = 0;
1020
1021 if (!file_count(filp)) {
1022 printk(KERN_ERR "VFS: Close: file count is 0\n");
1023 return 0;
1024 }
1025
1026 if (filp->f_op && filp->f_op->flush)
1027 retval = filp->f_op->flush(filp, id);
1028
1029 if (likely(!(filp->f_mode & FMODE_PATH))) {
1030 dnotify_flush(filp, id);
1031 locks_remove_posix(filp, id);
1032 }
1033 fput(filp);
1034 return retval;
1035}
1036
1037EXPORT_SYMBOL(filp_close);
1038
1039
1040
1041
1042
1043
1044SYSCALL_DEFINE1(close, unsigned int, fd)
1045{
1046 int retval = __close_fd(current->files, fd);
1047
1048
1049 if (unlikely(retval == -ERESTARTSYS ||
1050 retval == -ERESTARTNOINTR ||
1051 retval == -ERESTARTNOHAND ||
1052 retval == -ERESTART_RESTARTBLOCK))
1053 retval = -EINTR;
1054
1055 return retval;
1056}
1057EXPORT_SYMBOL(sys_close);
1058
1059
1060
1061
1062
1063SYSCALL_DEFINE0(vhangup)
1064{
1065 if (capable(CAP_SYS_TTY_CONFIG)) {
1066 tty_vhangup_self();
1067 return 0;
1068 }
1069 return -EPERM;
1070}
1071
1072
1073
1074
1075
1076
1077
1078int generic_file_open(struct inode * inode, struct file * filp)
1079{
1080 if (!(filp->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
1081 return -EOVERFLOW;
1082 return 0;
1083}
1084
1085EXPORT_SYMBOL(generic_file_open);
1086
1087
1088
1089
1090
1091
1092
1093int nonseekable_open(struct inode *inode, struct file *filp)
1094{
1095 filp->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
1096 return 0;
1097}
1098
1099EXPORT_SYMBOL(nonseekable_open);
1100