switch simple cases of fget_light to fdget
[linux-3.10.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
34 #include "internal.h"
35
36 int do_truncate(struct dentry *dentry, loff_t length, unsigned int time_attrs,
37         struct file *filp)
38 {
39         int ret;
40         struct iattr newattrs;
41
42         /* Not pretty: "inode->i_size" shouldn't really be signed. But it is. */
43         if (length < 0)
44                 return -EINVAL;
45
46         newattrs.ia_size = length;
47         newattrs.ia_valid = ATTR_SIZE | time_attrs;
48         if (filp) {
49                 newattrs.ia_file = filp;
50                 newattrs.ia_valid |= ATTR_FILE;
51         }
52
53         /* Remove suid/sgid on truncate too */
54         ret = should_remove_suid(dentry);
55         if (ret)
56                 newattrs.ia_valid |= ret | ATTR_FORCE;
57
58         mutex_lock(&dentry->d_inode->i_mutex);
59         ret = notify_change(dentry, &newattrs);
60         mutex_unlock(&dentry->d_inode->i_mutex);
61         return ret;
62 }
63
64 static long do_sys_truncate(const char __user *pathname, loff_t length)
65 {
66         struct path path;
67         struct inode *inode;
68         int error;
69
70         error = -EINVAL;
71         if (length < 0) /* sorry, but loff_t says... */
72                 goto out;
73
74         error = user_path(pathname, &path);
75         if (error)
76                 goto out;
77         inode = path.dentry->d_inode;
78
79         /* For directories it's -EISDIR, for other non-regulars - -EINVAL */
80         error = -EISDIR;
81         if (S_ISDIR(inode->i_mode))
82                 goto dput_and_out;
83
84         error = -EINVAL;
85         if (!S_ISREG(inode->i_mode))
86                 goto dput_and_out;
87
88         error = mnt_want_write(path.mnt);
89         if (error)
90                 goto dput_and_out;
91
92         error = inode_permission(inode, MAY_WRITE);
93         if (error)
94                 goto mnt_drop_write_and_out;
95
96         error = -EPERM;
97         if (IS_APPEND(inode))
98                 goto mnt_drop_write_and_out;
99
100         error = get_write_access(inode);
101         if (error)
102                 goto mnt_drop_write_and_out;
103
104         /*
105          * Make sure that there are no leases.  get_write_access() protects
106          * against the truncate racing with a lease-granting setlease().
107          */
108         error = break_lease(inode, O_WRONLY);
109         if (error)
110                 goto put_write_and_out;
111
112         error = locks_verify_truncate(inode, NULL, length);
113         if (!error)
114                 error = security_path_truncate(&path);
115         if (!error)
116                 error = do_truncate(path.dentry, length, 0, NULL);
117
118 put_write_and_out:
119         put_write_access(inode);
120 mnt_drop_write_and_out:
121         mnt_drop_write(path.mnt);
122 dput_and_out:
123         path_put(&path);
124 out:
125         return error;
126 }
127
128 SYSCALL_DEFINE2(truncate, const char __user *, path, long, length)
129 {
130         return do_sys_truncate(path, length);
131 }
132
133 static long do_sys_ftruncate(unsigned int fd, loff_t length, int small)
134 {
135         struct inode *inode;
136         struct dentry *dentry;
137         struct fd f;
138         int error;
139
140         error = -EINVAL;
141         if (length < 0)
142                 goto out;
143         error = -EBADF;
144         f = fdget(fd);
145         if (!f.file)
146                 goto out;
147
148         /* explicitly opened as large or we are on 64-bit box */
149         if (f.file->f_flags & O_LARGEFILE)
150                 small = 0;
151
152         dentry = f.file->f_path.dentry;
153         inode = dentry->d_inode;
154         error = -EINVAL;
155         if (!S_ISREG(inode->i_mode) || !(f.file->f_mode & FMODE_WRITE))
156                 goto out_putf;
157
158         error = -EINVAL;
159         /* Cannot ftruncate over 2^31 bytes without large file support */
160         if (small && length > MAX_NON_LFS)
161                 goto out_putf;
162
163         error = -EPERM;
164         if (IS_APPEND(inode))
165                 goto out_putf;
166
167         sb_start_write(inode->i_sb);
168         error = locks_verify_truncate(inode, f.file, length);
169         if (!error)
170                 error = security_path_truncate(&f.file->f_path);
171         if (!error)
172                 error = do_truncate(dentry, length, ATTR_MTIME|ATTR_CTIME, f.file);
173         sb_end_write(inode->i_sb);
174 out_putf:
175         fdput(f);
176 out:
177         return error;
178 }
179
180 SYSCALL_DEFINE2(ftruncate, unsigned int, fd, unsigned long, length)
181 {
182         long ret = do_sys_ftruncate(fd, length, 1);
183         /* avoid REGPARM breakage on x86: */
184         asmlinkage_protect(2, ret, fd, length);
185         return ret;
186 }
187
188 /* LFS versions of truncate are only needed on 32 bit machines */
189 #if BITS_PER_LONG == 32
190 SYSCALL_DEFINE(truncate64)(const char __user * path, loff_t length)
191 {
192         return do_sys_truncate(path, length);
193 }
194 #ifdef CONFIG_HAVE_SYSCALL_WRAPPERS
195 asmlinkage long SyS_truncate64(long path, loff_t length)
196 {
197         return SYSC_truncate64((const char __user *) path, length);
198 }
199 SYSCALL_ALIAS(sys_truncate64, SyS_truncate64);
200 #endif
201
202 SYSCALL_DEFINE(ftruncate64)(unsigned int fd, loff_t length)
203 {
204         long ret = do_sys_ftruncate(fd, length, 0);
205         /* avoid REGPARM breakage on x86: */
206         asmlinkage_protect(2, ret, fd, length);
207         return ret;
208 }
209 #ifdef CONFIG_HAVE_SYSCALL_WRAPPERS
210 asmlinkage long SyS_ftruncate64(long fd, loff_t length)
211 {
212         return SYSC_ftruncate64((unsigned int) fd, length);
213 }
214 SYSCALL_ALIAS(sys_ftruncate64, SyS_ftruncate64);
215 #endif
216 #endif /* BITS_PER_LONG == 32 */
217
218
219 int do_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
220 {
221         struct inode *inode = file->f_path.dentry->d_inode;
222         long ret;
223
224         if (offset < 0 || len <= 0)
225                 return -EINVAL;
226
227         /* Return error if mode is not supported */
228         if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE))
229                 return -EOPNOTSUPP;
230
231         /* Punch hole must have keep size set */
232         if ((mode & FALLOC_FL_PUNCH_HOLE) &&
233             !(mode & FALLOC_FL_KEEP_SIZE))
234                 return -EOPNOTSUPP;
235
236         if (!(file->f_mode & FMODE_WRITE))
237                 return -EBADF;
238
239         /* It's not possible punch hole on append only file */
240         if (mode & FALLOC_FL_PUNCH_HOLE && IS_APPEND(inode))
241                 return -EPERM;
242
243         if (IS_IMMUTABLE(inode))
244                 return -EPERM;
245
246         /*
247          * Revalidate the write permissions, in case security policy has
248          * changed since the files were opened.
249          */
250         ret = security_file_permission(file, MAY_WRITE);
251         if (ret)
252                 return ret;
253
254         if (S_ISFIFO(inode->i_mode))
255                 return -ESPIPE;
256
257         /*
258          * Let individual file system decide if it supports preallocation
259          * for directories or not.
260          */
261         if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode))
262                 return -ENODEV;
263
264         /* Check for wrap through zero too */
265         if (((offset + len) > inode->i_sb->s_maxbytes) || ((offset + len) < 0))
266                 return -EFBIG;
267
268         if (!file->f_op->fallocate)
269                 return -EOPNOTSUPP;
270
271         sb_start_write(inode->i_sb);
272         ret = file->f_op->fallocate(file, mode, offset, len);
273         sb_end_write(inode->i_sb);
274         return ret;
275 }
276
277 SYSCALL_DEFINE(fallocate)(int fd, int mode, loff_t offset, loff_t len)
278 {
279         struct fd f = fdget(fd);
280         int error = -EBADF;
281
282         if (f.file) {
283                 error = do_fallocate(f.file, mode, offset, len);
284                 fdput(f);
285         }
286         return error;
287 }
288
289 #ifdef CONFIG_HAVE_SYSCALL_WRAPPERS
290 asmlinkage long SyS_fallocate(long fd, long mode, loff_t offset, loff_t len)
291 {
292         return SYSC_fallocate((int)fd, (int)mode, offset, len);
293 }
294 SYSCALL_ALIAS(sys_fallocate, SyS_fallocate);
295 #endif
296
297 /*
298  * access() needs to use the real uid/gid, not the effective uid/gid.
299  * We do this by temporarily clearing all FS-related capabilities and
300  * switching the fsuid/fsgid around to the real ones.
301  */
302 SYSCALL_DEFINE3(faccessat, int, dfd, const char __user *, filename, int, mode)
303 {
304         const struct cred *old_cred;
305         struct cred *override_cred;
306         struct path path;
307         struct inode *inode;
308         int res;
309
310         if (mode & ~S_IRWXO)    /* where's F_OK, X_OK, W_OK, R_OK? */
311                 return -EINVAL;
312
313         override_cred = prepare_creds();
314         if (!override_cred)
315                 return -ENOMEM;
316
317         override_cred->fsuid = override_cred->uid;
318         override_cred->fsgid = override_cred->gid;
319
320         if (!issecure(SECURE_NO_SETUID_FIXUP)) {
321                 /* Clear the capabilities if we switch to a non-root user */
322                 kuid_t root_uid = make_kuid(override_cred->user_ns, 0);
323                 if (!uid_eq(override_cred->uid, root_uid))
324                         cap_clear(override_cred->cap_effective);
325                 else
326                         override_cred->cap_effective =
327                                 override_cred->cap_permitted;
328         }
329
330         old_cred = override_creds(override_cred);
331
332         res = user_path_at(dfd, filename, LOOKUP_FOLLOW, &path);
333         if (res)
334                 goto out;
335
336         inode = path.dentry->d_inode;
337
338         if ((mode & MAY_EXEC) && S_ISREG(inode->i_mode)) {
339                 /*
340                  * MAY_EXEC on regular files is denied if the fs is mounted
341                  * with the "noexec" flag.
342                  */
343                 res = -EACCES;
344                 if (path.mnt->mnt_flags & MNT_NOEXEC)
345                         goto out_path_release;
346         }
347
348         res = inode_permission(inode, mode | MAY_ACCESS);
349         /* SuS v2 requires we report a read only fs too */
350         if (res || !(mode & S_IWOTH) || special_file(inode->i_mode))
351                 goto out_path_release;
352         /*
353          * This is a rare case where using __mnt_is_readonly()
354          * is OK without a mnt_want/drop_write() pair.  Since
355          * no actual write to the fs is performed here, we do
356          * not need to telegraph to that to anyone.
357          *
358          * By doing this, we accept that this access is
359          * inherently racy and know that the fs may change
360          * state before we even see this result.
361          */
362         if (__mnt_is_readonly(path.mnt))
363                 res = -EROFS;
364
365 out_path_release:
366         path_put(&path);
367 out:
368         revert_creds(old_cred);
369         put_cred(override_cred);
370         return res;
371 }
372
373 SYSCALL_DEFINE2(access, const char __user *, filename, int, mode)
374 {
375         return sys_faccessat(AT_FDCWD, filename, mode);
376 }
377
378 SYSCALL_DEFINE1(chdir, const char __user *, filename)
379 {
380         struct path path;
381         int error;
382
383         error = user_path_dir(filename, &path);
384         if (error)
385                 goto out;
386
387         error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_CHDIR);
388         if (error)
389                 goto dput_and_out;
390
391         set_fs_pwd(current->fs, &path);
392
393 dput_and_out:
394         path_put(&path);
395 out:
396         return error;
397 }
398
399 SYSCALL_DEFINE1(fchdir, unsigned int, fd)
400 {
401         struct fd f = fdget_raw(fd);
402         struct inode *inode;
403         int error = -EBADF;
404
405         error = -EBADF;
406         if (!f.file)
407                 goto out;
408
409         inode = f.file->f_path.dentry->d_inode;
410
411         error = -ENOTDIR;
412         if (!S_ISDIR(inode->i_mode))
413                 goto out_putf;
414
415         error = inode_permission(inode, MAY_EXEC | MAY_CHDIR);
416         if (!error)
417                 set_fs_pwd(current->fs, &f.file->f_path);
418 out_putf:
419         fdput(f);
420 out:
421         return error;
422 }
423
424 SYSCALL_DEFINE1(chroot, const char __user *, filename)
425 {
426         struct path path;
427         int error;
428
429         error = user_path_dir(filename, &path);
430         if (error)
431                 goto out;
432
433         error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_CHDIR);
434         if (error)
435                 goto dput_and_out;
436
437         error = -EPERM;
438         if (!capable(CAP_SYS_CHROOT))
439                 goto dput_and_out;
440         error = security_path_chroot(&path);
441         if (error)
442                 goto dput_and_out;
443
444         set_fs_root(current->fs, &path);
445         error = 0;
446 dput_and_out:
447         path_put(&path);
448 out:
449         return error;
450 }
451
452 static int chmod_common(struct path *path, umode_t mode)
453 {
454         struct inode *inode = path->dentry->d_inode;
455         struct iattr newattrs;
456         int error;
457
458         error = mnt_want_write(path->mnt);
459         if (error)
460                 return error;
461         mutex_lock(&inode->i_mutex);
462         error = security_path_chmod(path, mode);
463         if (error)
464                 goto out_unlock;
465         newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
466         newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
467         error = notify_change(path->dentry, &newattrs);
468 out_unlock:
469         mutex_unlock(&inode->i_mutex);
470         mnt_drop_write(path->mnt);
471         return error;
472 }
473
474 SYSCALL_DEFINE2(fchmod, unsigned int, fd, umode_t, mode)
475 {
476         struct file * file;
477         int err = -EBADF;
478
479         file = fget(fd);
480         if (file) {
481                 audit_inode(NULL, file->f_path.dentry);
482                 err = chmod_common(&file->f_path, mode);
483                 fput(file);
484         }
485         return err;
486 }
487
488 SYSCALL_DEFINE3(fchmodat, int, dfd, const char __user *, filename, umode_t, mode)
489 {
490         struct path path;
491         int error;
492
493         error = user_path_at(dfd, filename, LOOKUP_FOLLOW, &path);
494         if (!error) {
495                 error = chmod_common(&path, mode);
496                 path_put(&path);
497         }
498         return error;
499 }
500
501 SYSCALL_DEFINE2(chmod, const char __user *, filename, umode_t, mode)
502 {
503         return sys_fchmodat(AT_FDCWD, filename, mode);
504 }
505
506 static int chown_common(struct path *path, uid_t user, gid_t group)
507 {
508         struct inode *inode = path->dentry->d_inode;
509         int error;
510         struct iattr newattrs;
511         kuid_t uid;
512         kgid_t gid;
513
514         uid = make_kuid(current_user_ns(), user);
515         gid = make_kgid(current_user_ns(), group);
516
517         newattrs.ia_valid =  ATTR_CTIME;
518         if (user != (uid_t) -1) {
519                 if (!uid_valid(uid))
520                         return -EINVAL;
521                 newattrs.ia_valid |= ATTR_UID;
522                 newattrs.ia_uid = uid;
523         }
524         if (group != (gid_t) -1) {
525                 if (!gid_valid(gid))
526                         return -EINVAL;
527                 newattrs.ia_valid |= ATTR_GID;
528                 newattrs.ia_gid = gid;
529         }
530         if (!S_ISDIR(inode->i_mode))
531                 newattrs.ia_valid |=
532                         ATTR_KILL_SUID | ATTR_KILL_SGID | ATTR_KILL_PRIV;
533         mutex_lock(&inode->i_mutex);
534         error = security_path_chown(path, user, group);
535         if (!error)
536                 error = notify_change(path->dentry, &newattrs);
537         mutex_unlock(&inode->i_mutex);
538
539         return error;
540 }
541
542 SYSCALL_DEFINE5(fchownat, int, dfd, const char __user *, filename, uid_t, user,
543                 gid_t, group, int, flag)
544 {
545         struct path path;
546         int error = -EINVAL;
547         int lookup_flags;
548
549         if ((flag & ~(AT_SYMLINK_NOFOLLOW | AT_EMPTY_PATH)) != 0)
550                 goto out;
551
552         lookup_flags = (flag & AT_SYMLINK_NOFOLLOW) ? 0 : LOOKUP_FOLLOW;
553         if (flag & AT_EMPTY_PATH)
554                 lookup_flags |= LOOKUP_EMPTY;
555         error = user_path_at(dfd, filename, lookup_flags, &path);
556         if (error)
557                 goto out;
558         error = mnt_want_write(path.mnt);
559         if (error)
560                 goto out_release;
561         error = chown_common(&path, user, group);
562         mnt_drop_write(path.mnt);
563 out_release:
564         path_put(&path);
565 out:
566         return error;
567 }
568
569 SYSCALL_DEFINE3(chown, const char __user *, filename, uid_t, user, gid_t, group)
570 {
571         return sys_fchownat(AT_FDCWD, filename, user, group, 0);
572 }
573
574 SYSCALL_DEFINE3(lchown, const char __user *, filename, uid_t, user, gid_t, group)
575 {
576         return sys_fchownat(AT_FDCWD, filename, user, group,
577                             AT_SYMLINK_NOFOLLOW);
578 }
579
580 SYSCALL_DEFINE3(fchown, unsigned int, fd, uid_t, user, gid_t, group)
581 {
582         struct fd f = fdget(fd);
583         int error = -EBADF;
584
585         if (!f.file)
586                 goto out;
587
588         error = mnt_want_write_file(f.file);
589         if (error)
590                 goto out_fput;
591         audit_inode(NULL, f.file->f_path.dentry);
592         error = chown_common(&f.file->f_path, user, group);
593         mnt_drop_write_file(f.file);
594 out_fput:
595         fdput(f);
596 out:
597         return error;
598 }
599
600 /*
601  * You have to be very careful that these write
602  * counts get cleaned up in error cases and
603  * upon __fput().  This should probably never
604  * be called outside of __dentry_open().
605  */
606 static inline int __get_file_write_access(struct inode *inode,
607                                           struct vfsmount *mnt)
608 {
609         int error;
610         error = get_write_access(inode);
611         if (error)
612                 return error;
613         /*
614          * Do not take mount writer counts on
615          * special files since no writes to
616          * the mount itself will occur.
617          */
618         if (!special_file(inode->i_mode)) {
619                 /*
620                  * Balanced in __fput()
621                  */
622                 error = __mnt_want_write(mnt);
623                 if (error)
624                         put_write_access(inode);
625         }
626         return error;
627 }
628
629 int open_check_o_direct(struct file *f)
630 {
631         /* NB: we're sure to have correct a_ops only after f_op->open */
632         if (f->f_flags & O_DIRECT) {
633                 if (!f->f_mapping->a_ops ||
634                     ((!f->f_mapping->a_ops->direct_IO) &&
635                     (!f->f_mapping->a_ops->get_xip_mem))) {
636                         return -EINVAL;
637                 }
638         }
639         return 0;
640 }
641
642 static int do_dentry_open(struct file *f,
643                           int (*open)(struct inode *, struct file *),
644                           const struct cred *cred)
645 {
646         static const struct file_operations empty_fops = {};
647         struct inode *inode;
648         int error;
649
650         f->f_mode = OPEN_FMODE(f->f_flags) | FMODE_LSEEK |
651                                 FMODE_PREAD | FMODE_PWRITE;
652
653         if (unlikely(f->f_flags & O_PATH))
654                 f->f_mode = FMODE_PATH;
655
656         path_get(&f->f_path);
657         inode = f->f_path.dentry->d_inode;
658         if (f->f_mode & FMODE_WRITE) {
659                 error = __get_file_write_access(inode, f->f_path.mnt);
660                 if (error)
661                         goto cleanup_file;
662                 if (!special_file(inode->i_mode))
663                         file_take_write(f);
664         }
665
666         f->f_mapping = inode->i_mapping;
667         f->f_pos = 0;
668         file_sb_list_add(f, inode->i_sb);
669
670         if (unlikely(f->f_mode & FMODE_PATH)) {
671                 f->f_op = &empty_fops;
672                 return 0;
673         }
674
675         f->f_op = fops_get(inode->i_fop);
676
677         error = security_file_open(f, cred);
678         if (error)
679                 goto cleanup_all;
680
681         error = break_lease(inode, f->f_flags);
682         if (error)
683                 goto cleanup_all;
684
685         if (!open && f->f_op)
686                 open = f->f_op->open;
687         if (open) {
688                 error = open(inode, f);
689                 if (error)
690                         goto cleanup_all;
691         }
692         if ((f->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ)
693                 i_readcount_inc(inode);
694
695         f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
696
697         file_ra_state_init(&f->f_ra, f->f_mapping->host->i_mapping);
698
699         return 0;
700
701 cleanup_all:
702         fops_put(f->f_op);
703         file_sb_list_del(f);
704         if (f->f_mode & FMODE_WRITE) {
705                 put_write_access(inode);
706                 if (!special_file(inode->i_mode)) {
707                         /*
708                          * We don't consider this a real
709                          * mnt_want/drop_write() pair
710                          * because it all happenend right
711                          * here, so just reset the state.
712                          */
713                         file_reset_write(f);
714                         __mnt_drop_write(f->f_path.mnt);
715                 }
716         }
717 cleanup_file:
718         path_put(&f->f_path);
719         f->f_path.mnt = NULL;
720         f->f_path.dentry = NULL;
721         return error;
722 }
723
724 /**
725  * finish_open - finish opening a file
726  * @od: opaque open data
727  * @dentry: pointer to dentry
728  * @open: open callback
729  *
730  * This can be used to finish opening a file passed to i_op->atomic_open().
731  *
732  * If the open callback is set to NULL, then the standard f_op->open()
733  * filesystem callback is substituted.
734  */
735 int finish_open(struct file *file, struct dentry *dentry,
736                 int (*open)(struct inode *, struct file *),
737                 int *opened)
738 {
739         int error;
740         BUG_ON(*opened & FILE_OPENED); /* once it's opened, it's opened */
741
742         file->f_path.dentry = dentry;
743         error = do_dentry_open(file, open, current_cred());
744         if (!error)
745                 *opened |= FILE_OPENED;
746
747         return error;
748 }
749 EXPORT_SYMBOL(finish_open);
750
751 /**
752  * finish_no_open - finish ->atomic_open() without opening the file
753  *
754  * @od: opaque open data
755  * @dentry: dentry or NULL (as returned from ->lookup())
756  *
757  * This can be used to set the result of a successful lookup in ->atomic_open().
758  * The filesystem's atomic_open() method shall return NULL after calling this.
759  */
760 int finish_no_open(struct file *file, struct dentry *dentry)
761 {
762         file->f_path.dentry = dentry;
763         return 1;
764 }
765 EXPORT_SYMBOL(finish_no_open);
766
767 struct file *dentry_open(const struct path *path, int flags,
768                          const struct cred *cred)
769 {
770         int error;
771         struct file *f;
772
773         validate_creds(cred);
774
775         /* We must always pass in a valid mount pointer. */
776         BUG_ON(!path->mnt);
777
778         error = -ENFILE;
779         f = get_empty_filp();
780         if (f == NULL)
781                 return ERR_PTR(error);
782
783         f->f_flags = flags;
784         f->f_path = *path;
785         error = do_dentry_open(f, NULL, cred);
786         if (!error) {
787                 error = open_check_o_direct(f);
788                 if (error) {
789                         fput(f);
790                         f = ERR_PTR(error);
791                 }
792         } else { 
793                 put_filp(f);
794                 f = ERR_PTR(error);
795         }
796         return f;
797 }
798 EXPORT_SYMBOL(dentry_open);
799
800 static inline int build_open_flags(int flags, umode_t mode, struct open_flags *op)
801 {
802         int lookup_flags = 0;
803         int acc_mode;
804
805         if (flags & O_CREAT)
806                 op->mode = (mode & S_IALLUGO) | S_IFREG;
807         else
808                 op->mode = 0;
809
810         /* Must never be set by userspace */
811         flags &= ~FMODE_NONOTIFY & ~O_CLOEXEC;
812
813         /*
814          * O_SYNC is implemented as __O_SYNC|O_DSYNC.  As many places only
815          * check for O_DSYNC if the need any syncing at all we enforce it's
816          * always set instead of having to deal with possibly weird behaviour
817          * for malicious applications setting only __O_SYNC.
818          */
819         if (flags & __O_SYNC)
820                 flags |= O_DSYNC;
821
822         /*
823          * If we have O_PATH in the open flag. Then we
824          * cannot have anything other than the below set of flags
825          */
826         if (flags & O_PATH) {
827                 flags &= O_DIRECTORY | O_NOFOLLOW | O_PATH;
828                 acc_mode = 0;
829         } else {
830                 acc_mode = MAY_OPEN | ACC_MODE(flags);
831         }
832
833         op->open_flag = flags;
834
835         /* O_TRUNC implies we need access checks for write permissions */
836         if (flags & O_TRUNC)
837                 acc_mode |= MAY_WRITE;
838
839         /* Allow the LSM permission hook to distinguish append
840            access from general write access. */
841         if (flags & O_APPEND)
842                 acc_mode |= MAY_APPEND;
843
844         op->acc_mode = acc_mode;
845
846         op->intent = flags & O_PATH ? 0 : LOOKUP_OPEN;
847
848         if (flags & O_CREAT) {
849                 op->intent |= LOOKUP_CREATE;
850                 if (flags & O_EXCL)
851                         op->intent |= LOOKUP_EXCL;
852         }
853
854         if (flags & O_DIRECTORY)
855                 lookup_flags |= LOOKUP_DIRECTORY;
856         if (!(flags & O_NOFOLLOW))
857                 lookup_flags |= LOOKUP_FOLLOW;
858         return lookup_flags;
859 }
860
861 /**
862  * filp_open - open file and return file pointer
863  *
864  * @filename:   path to open
865  * @flags:      open flags as per the open(2) second argument
866  * @mode:       mode for the new file if O_CREAT is set, else ignored
867  *
868  * This is the helper to open a file from kernelspace if you really
869  * have to.  But in generally you should not do this, so please move
870  * along, nothing to see here..
871  */
872 struct file *filp_open(const char *filename, int flags, umode_t mode)
873 {
874         struct open_flags op;
875         int lookup = build_open_flags(flags, mode, &op);
876         return do_filp_open(AT_FDCWD, filename, &op, lookup);
877 }
878 EXPORT_SYMBOL(filp_open);
879
880 struct file *file_open_root(struct dentry *dentry, struct vfsmount *mnt,
881                             const char *filename, int flags)
882 {
883         struct open_flags op;
884         int lookup = build_open_flags(flags, 0, &op);
885         if (flags & O_CREAT)
886                 return ERR_PTR(-EINVAL);
887         if (!filename && (flags & O_DIRECTORY))
888                 if (!dentry->d_inode->i_op->lookup)
889                         return ERR_PTR(-ENOTDIR);
890         return do_file_open_root(dentry, mnt, filename, &op, lookup);
891 }
892 EXPORT_SYMBOL(file_open_root);
893
894 long do_sys_open(int dfd, const char __user *filename, int flags, umode_t mode)
895 {
896         struct open_flags op;
897         int lookup = build_open_flags(flags, mode, &op);
898         char *tmp = getname(filename);
899         int fd = PTR_ERR(tmp);
900
901         if (!IS_ERR(tmp)) {
902                 fd = get_unused_fd_flags(flags);
903                 if (fd >= 0) {
904                         struct file *f = do_filp_open(dfd, tmp, &op, lookup);
905                         if (IS_ERR(f)) {
906                                 put_unused_fd(fd);
907                                 fd = PTR_ERR(f);
908                         } else {
909                                 fsnotify_open(f);
910                                 fd_install(fd, f);
911                         }
912                 }
913                 putname(tmp);
914         }
915         return fd;
916 }
917
918 SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, umode_t, mode)
919 {
920         long ret;
921
922         if (force_o_largefile())
923                 flags |= O_LARGEFILE;
924
925         ret = do_sys_open(AT_FDCWD, filename, flags, mode);
926         /* avoid REGPARM breakage on x86: */
927         asmlinkage_protect(3, ret, filename, flags, mode);
928         return ret;
929 }
930
931 SYSCALL_DEFINE4(openat, int, dfd, const char __user *, filename, int, flags,
932                 umode_t, mode)
933 {
934         long ret;
935
936         if (force_o_largefile())
937                 flags |= O_LARGEFILE;
938
939         ret = do_sys_open(dfd, filename, flags, mode);
940         /* avoid REGPARM breakage on x86: */
941         asmlinkage_protect(4, ret, dfd, filename, flags, mode);
942         return ret;
943 }
944
945 #ifndef __alpha__
946
947 /*
948  * For backward compatibility?  Maybe this should be moved
949  * into arch/i386 instead?
950  */
951 SYSCALL_DEFINE2(creat, const char __user *, pathname, umode_t, mode)
952 {
953         return sys_open(pathname, O_CREAT | O_WRONLY | O_TRUNC, mode);
954 }
955
956 #endif
957
958 /*
959  * "id" is the POSIX thread ID. We use the
960  * files pointer for this..
961  */
962 int filp_close(struct file *filp, fl_owner_t id)
963 {
964         int retval = 0;
965
966         if (!file_count(filp)) {
967                 printk(KERN_ERR "VFS: Close: file count is 0\n");
968                 return 0;
969         }
970
971         if (filp->f_op && filp->f_op->flush)
972                 retval = filp->f_op->flush(filp, id);
973
974         if (likely(!(filp->f_mode & FMODE_PATH))) {
975                 dnotify_flush(filp, id);
976                 locks_remove_posix(filp, id);
977         }
978         fput(filp);
979         return retval;
980 }
981
982 EXPORT_SYMBOL(filp_close);
983
984 /*
985  * Careful here! We test whether the file pointer is NULL before
986  * releasing the fd. This ensures that one clone task can't release
987  * an fd while another clone is opening it.
988  */
989 SYSCALL_DEFINE1(close, unsigned int, fd)
990 {
991         int retval = __close_fd(current->files, fd);
992
993         /* can't restart close syscall because file table entry was cleared */
994         if (unlikely(retval == -ERESTARTSYS ||
995                      retval == -ERESTARTNOINTR ||
996                      retval == -ERESTARTNOHAND ||
997                      retval == -ERESTART_RESTARTBLOCK))
998                 retval = -EINTR;
999
1000         return retval;
1001 }
1002 EXPORT_SYMBOL(sys_close);
1003
1004 /*
1005  * This routine simulates a hangup on the tty, to arrange that users
1006  * are given clean terminals at login time.
1007  */
1008 SYSCALL_DEFINE0(vhangup)
1009 {
1010         if (capable(CAP_SYS_TTY_CONFIG)) {
1011                 tty_vhangup_self();
1012                 return 0;
1013         }
1014         return -EPERM;
1015 }
1016
1017 /*
1018  * Called when an inode is about to be open.
1019  * We use this to disallow opening large files on 32bit systems if
1020  * the caller didn't specify O_LARGEFILE.  On 64bit systems we force
1021  * on this flag in sys_open.
1022  */
1023 int generic_file_open(struct inode * inode, struct file * filp)
1024 {
1025         if (!(filp->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
1026                 return -EOVERFLOW;
1027         return 0;
1028 }
1029
1030 EXPORT_SYMBOL(generic_file_open);
1031
1032 /*
1033  * This is used by subsystems that don't want seekable
1034  * file descriptors. The function is not supposed to ever fail, the only
1035  * reason it returns an 'int' and not 'void' is so that it can be plugged
1036  * directly into file_operations structure.
1037  */
1038 int nonseekable_open(struct inode *inode, struct file *filp)
1039 {
1040         filp->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
1041         return 0;
1042 }
1043
1044 EXPORT_SYMBOL(nonseekable_open);