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