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