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