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/utime.h>
10 #include <linux/file.h>
11 #include <linux/smp_lock.h>
12 #include <linux/quotaops.h>
13 #include <linux/dnotify.h>
14 #include <linux/module.h>
15 #include <linux/slab.h>
16 #include <linux/tty.h>
17 #include <linux/namei.h>
18 #include <linux/backing-dev.h>
19 #include <linux/security.h>
20 #include <linux/mount.h>
21 #include <linux/vfs.h>
22 #include <asm/uaccess.h>
23 #include <linux/fs.h>
24 #include <linux/pagemap.h>
25 #include <linux/syscalls.h>
26
27 #include <asm/unistd.h>
28
29 int vfs_statfs(struct super_block *sb, struct kstatfs *buf)
30 {
31 int retval = -ENODEV;
32
33 if (sb) {
34 retval = -ENOSYS;
35 if (sb->s_op->statfs) {
36 memset(buf, 0, sizeof(*buf));
37 retval = security_sb_statfs(sb);
38 if (retval)
39 return retval;
40 retval = sb->s_op->statfs(sb, buf);
41 if (retval == 0 && buf->f_frsize == 0)
42 buf->f_frsize = buf->f_bsize;
43 }
44 }
45 return retval;
46 }
47
48 EXPORT_SYMBOL(vfs_statfs);
49
50 static int vfs_statfs_native(struct super_block *sb, struct statfs *buf)
51 {
52 struct kstatfs st;
53 int retval;
54
55 retval = vfs_statfs(sb, &st);
56 if (retval)
57 return retval;
58
59 if (sizeof(*buf) == sizeof(st))
60 memcpy(buf, &st, sizeof(st));
61 else {
62 if (sizeof buf->f_blocks == 4) {
63 if ((st.f_blocks | st.f_bfree | st.f_bavail) &
64 0xffffffff00000000ULL)
65 return -EOVERFLOW;
66 /*
67 * f_files and f_ffree may be -1; it's okay to stuff
68 * that into 32 bits
69 */
70 if (st.f_files != -1 &&
71 (st.f_files & 0xffffffff00000000ULL))
72 return -EOVERFLOW;
73 if (st.f_ffree != -1 &&
74 (st.f_ffree & 0xffffffff00000000ULL))
75 return -EOVERFLOW;
76 }
77
78 buf->f_type = st.f_type;
79 buf->f_bsize = st.f_bsize;
80 buf->f_blocks = st.f_blocks;
81 buf->f_bfree = st.f_bfree;
82 buf->f_bavail = st.f_bavail;
83 buf->f_files = st.f_files;
84 buf->f_ffree = st.f_ffree;
85 buf->f_fsid = st.f_fsid;
86 buf->f_namelen = st.f_namelen;
87 buf->f_frsize = st.f_frsize;
88 memset(buf->f_spare, 0, sizeof(buf->f_spare));
89 }
90 return 0;
91 }
92
93 static int vfs_statfs64(struct super_block *sb, struct statfs64 *buf)
94 {
95 struct kstatfs st;
96 int retval;
97
98 retval = vfs_statfs(sb, &st);
99 if (retval)
100 return retval;
101
102 if (sizeof(*buf) == sizeof(st))
103 memcpy(buf, &st, sizeof(st));
104 else {
105 buf->f_type = st.f_type;
106 buf->f_bsize = st.f_bsize;
107 buf->f_blocks = st.f_blocks;
108 buf->f_bfree = st.f_bfree;
109 buf->f_bavail = st.f_bavail;
110 buf->f_files = st.f_files;
111 buf->f_ffree = st.f_ffree;
112 buf->f_fsid = st.f_fsid;
113 buf->f_namelen = st.f_namelen;
114 buf->f_frsize = st.f_frsize;
115 memset(buf->f_spare, 0, sizeof(buf->f_spare));
116 }
117 return 0;
118 }
119
120 asmlinkage long sys_statfs(const char __user * path, struct statfs __user * buf)
121 {
122 struct nameidata nd;
123 int error;
124
125 error = user_path_walk(path, &nd);
126 if (!error) {
127 struct statfs tmp;
128 error = vfs_statfs_native(nd.dentry->d_inode->i_sb, &tmp);
129 if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
130 error = -EFAULT;
131 path_release(&nd);
132 }
133 return error;
134 }
135
136
137 asmlinkage long sys_statfs64(const char __user *path, size_t sz, struct statfs64 __user *buf)
138 {
139 struct nameidata nd;
140 long error;
141
142 if (sz != sizeof(*buf))
143 return -EINVAL;
144 error = user_path_walk(path, &nd);
145 if (!error) {
146 struct statfs64 tmp;
147 error = vfs_statfs64(nd.dentry->d_inode->i_sb, &tmp);
148 if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
149 error = -EFAULT;
150 path_release(&nd);
151 }
152 return error;
153 }
154
155
156 asmlinkage long sys_fstatfs(unsigned int fd, struct statfs __user * buf)
157 {
158 struct file * file;
159 struct statfs tmp;
160 int error;
161
162 error = -EBADF;
163 file = fget(fd);
164 if (!file)
165 goto out;
166 error = vfs_statfs_native(file->f_dentry->d_inode->i_sb, &tmp);
167 if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
168 error = -EFAULT;
169 fput(file);
170 out:
171 return error;
172 }
173
174 asmlinkage long sys_fstatfs64(unsigned int fd, size_t sz, struct statfs64 __user *buf)
175 {
176 struct file * file;
177 struct statfs64 tmp;
178 int error;
179
180 if (sz != sizeof(*buf))
181 return -EINVAL;
182
183 error = -EBADF;
184 file = fget(fd);
185 if (!file)
186 goto out;
187 error = vfs_statfs64(file->f_dentry->d_inode->i_sb, &tmp);
188 if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
189 error = -EFAULT;
190 fput(file);
191 out:
192 return error;
193 }
194
195 int do_truncate(struct dentry *dentry, loff_t length)
196 {
197 int err;
198 struct iattr newattrs;
199
200 /* Not pretty: "inode->i_size" shouldn't really be signed. But it is. */
201 if (length < 0)
202 return -EINVAL;
203
204 newattrs.ia_size = length;
205 newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
206
207 down(&dentry->d_inode->i_sem);
208 err = notify_change(dentry, &newattrs);
209 up(&dentry->d_inode->i_sem);
210 return err;
211 }
212
213 static inline long do_sys_truncate(const char __user * path, loff_t length)
214 {
215 struct nameidata nd;
216 struct inode * inode;
217 int error;
218
219 error = -EINVAL;
220 if (length < 0) /* sorry, but loff_t says... */
221 goto out;
222
223 error = user_path_walk(path, &nd);
224 if (error)
225 goto out;
226 inode = nd.dentry->d_inode;
227
228 /* For directories it's -EISDIR, for other non-regulars - -EINVAL */
229 error = -EISDIR;
230 if (S_ISDIR(inode->i_mode))
231 goto dput_and_out;
232
233 error = -EINVAL;
234 if (!S_ISREG(inode->i_mode))
235 goto dput_and_out;
236
237 error = permission(inode,MAY_WRITE,&nd);
238 if (error)
239 goto dput_and_out;
240
241 error = -EROFS;
242 if (IS_RDONLY(inode))
243 goto dput_and_out;
244
245 error = -EPERM;
246 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
247 goto dput_and_out;
248
249 /*
250 * Make sure that there are no leases.
251 */
252 error = break_lease(inode, FMODE_WRITE);
253 if (error)
254 goto dput_and_out;
255
256 error = get_write_access(inode);
257 if (error)
258 goto dput_and_out;
259
260 error = locks_verify_truncate(inode, NULL, length);
261 if (!error) {
262 DQUOT_INIT(inode);
263 error = do_truncate(nd.dentry, length);
264 }
265 put_write_access(inode);
266
267 dput_and_out:
268 path_release(&nd);
269 out:
270 return error;
271 }
272
273 asmlinkage long sys_truncate(const char __user * path, unsigned long length)
274 {
275 /* on 32-bit boxen it will cut the range 2^31--2^32-1 off */
276 return do_sys_truncate(path, (long)length);
277 }
278
279 static inline long do_sys_ftruncate(unsigned int fd, loff_t length, int small)
280 {
281 struct inode * inode;
282 struct dentry *dentry;
283 struct file * file;
284 int error;
285
286 error = -EINVAL;
287 if (length < 0)
288 goto out;
289 error = -EBADF;
290 file = fget(fd);
291 if (!file)
292 goto out;
293
294 /* explicitly opened as large or we are on 64-bit box */
295 if (file->f_flags & O_LARGEFILE)
296 small = 0;
297
298 dentry = file->f_dentry;
299 inode = dentry->d_inode;
300 error = -EINVAL;
301 if (!S_ISREG(inode->i_mode) || !(file->f_mode & FMODE_WRITE))
302 goto out_putf;
303
304 error = -EINVAL;
305 /* Cannot ftruncate over 2^31 bytes without large file support */
306 if (small && length > MAX_NON_LFS)
307 goto out_putf;
308
309 error = -EPERM;
310 if (IS_APPEND(inode))
311 goto out_putf;
312
313 error = locks_verify_truncate(inode, file, length);
314 if (!error)
315 error = do_truncate(dentry, length);
316 out_putf:
317 fput(file);
318 out:
319 return error;
320 }
321
322 asmlinkage long sys_ftruncate(unsigned int fd, unsigned long length)
323 {
324 return do_sys_ftruncate(fd, length, 1);
325 }
326
327 /* LFS versions of truncate are only needed on 32 bit machines */
328 #if BITS_PER_LONG == 32
329 asmlinkage long sys_truncate64(const char __user * path, loff_t length)
330 {
331 return do_sys_truncate(path, length);
332 }
333
334 asmlinkage long sys_ftruncate64(unsigned int fd, loff_t length)
335 {
336 return do_sys_ftruncate(fd, length, 0);
337 }
338 #endif
339
340 #ifdef __ARCH_WANT_SYS_UTIME
341
342 /*
343 * sys_utime() can be implemented in user-level using sys_utimes().
344 * Is this for backwards compatibility? If so, why not move it
345 * into the appropriate arch directory (for those architectures that
346 * need it).
347 */
348
349 /* If times==NULL, set access and modification to current time,
350 * must be owner or have write permission.
351 * Else, update from *times, must be owner or super user.
352 */
353 asmlinkage long sys_utime(char __user * filename, struct utimbuf __user * times)
354 {
355 int error;
356 struct nameidata nd;
357 struct inode * inode;
358 struct iattr newattrs;
359
360 error = user_path_walk(filename, &nd);
361 if (error)
362 goto out;
363 inode = nd.dentry->d_inode;
364
365 error = -EROFS;
366 if (IS_RDONLY(inode))
367 goto dput_and_out;
368
369 /* Don't worry, the checks are done in inode_change_ok() */
370 newattrs.ia_valid = ATTR_CTIME | ATTR_MTIME | ATTR_ATIME;
371 if (times) {
372 error = -EPERM;
373 if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
374 goto dput_and_out;
375
376 error = get_user(newattrs.ia_atime.tv_sec, ×->actime);
377 newattrs.ia_atime.tv_nsec = 0;
378 if (!error)
379 error = get_user(newattrs.ia_mtime.tv_sec, ×->modtime);
380 newattrs.ia_mtime.tv_nsec = 0;
381 if (error)
382 goto dput_and_out;
383
384 newattrs.ia_valid |= ATTR_ATIME_SET | ATTR_MTIME_SET;
385 } else {
386 error = -EACCES;
387 if (IS_IMMUTABLE(inode))
388 goto dput_and_out;
389
390 if (current->fsuid != inode->i_uid &&
391 (error = permission(inode,MAY_WRITE,&nd)) != 0)
392 goto dput_and_out;
393 }
394 down(&inode->i_sem);
395 error = notify_change(nd.dentry, &newattrs);
396 up(&inode->i_sem);
397 dput_and_out:
398 path_release(&nd);
399 out:
400 return error;
401 }
402
403 #endif
404
405 /* If times==NULL, set access and modification to current time,
406 * must be owner or have write permission.
407 * Else, update from *times, must be owner or super user.
408 */
409 long do_utimes(char __user * filename, struct timeval * times)
410 {
411 int error;
412 struct nameidata nd;
413 struct inode * inode;
414 struct iattr newattrs;
415
416 error = user_path_walk(filename, &nd);
417
418 if (error)
419 goto out;
420 inode = nd.dentry->d_inode;
421
422 error = -EROFS;
423 if (IS_RDONLY(inode))
424 goto dput_and_out;
425
426 /* Don't worry, the checks are done in inode_change_ok() */
427 newattrs.ia_valid = ATTR_CTIME | ATTR_MTIME | ATTR_ATIME;
428 if (times) {
429 error = -EPERM;
430 if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
431 goto dput_and_out;
432
433 newattrs.ia_atime.tv_sec = times[0].tv_sec;
434 newattrs.ia_atime.tv_nsec = times[0].tv_usec * 1000;
435 newattrs.ia_mtime.tv_sec = times[1].tv_sec;
436 newattrs.ia_mtime.tv_nsec = times[1].tv_usec * 1000;
437 newattrs.ia_valid |= ATTR_ATIME_SET | ATTR_MTIME_SET;
438 } else {
439 error = -EACCES;
440 if (IS_IMMUTABLE(inode))
441 goto dput_and_out;
442
443 if (current->fsuid != inode->i_uid &&
444 (error = permission(inode,MAY_WRITE,&nd)) != 0)
445 goto dput_and_out;
446 }
447 down(&inode->i_sem);
448 error = notify_change(nd.dentry, &newattrs);
449 up(&inode->i_sem);
450 dput_and_out:
451 path_release(&nd);
452 out:
453 return error;
454 }
455
456 asmlinkage long sys_utimes(char __user * filename, struct timeval __user * utimes)
457 {
458 struct timeval times[2];
459
460 if (utimes && copy_from_user(×, utimes, sizeof(times)))
461 return -EFAULT;
462 return do_utimes(filename, utimes ? times : NULL);
463 }
464
465
466 /*
467 * access() needs to use the real uid/gid, not the effective uid/gid.
468 * We do this by temporarily clearing all FS-related capabilities and
469 * switching the fsuid/fsgid around to the real ones.
470 */
471 asmlinkage long sys_access(const char __user * filename, int mode)
472 {
473 struct nameidata nd;
474 int old_fsuid, old_fsgid;
475 kernel_cap_t old_cap;
476 int res;
477
478 if (mode & ~S_IRWXO) /* where's F_OK, X_OK, W_OK, R_OK? */
479 return -EINVAL;
480
481 old_fsuid = current->fsuid;
482 old_fsgid = current->fsgid;
483 old_cap = current->cap_effective;
484
485 current->fsuid = current->uid;
486 current->fsgid = current->gid;
487
488 /*
489 * Clear the capabilities if we switch to a non-root user
490 *
491 * FIXME: There is a race here against sys_capset. The
492 * capabilities can change yet we will restore the old
493 * value below. We should hold task_capabilities_lock,
494 * but we cannot because user_path_walk can sleep.
495 */
496 if (current->uid)
497 cap_clear(current->cap_effective);
498 else
499 current->cap_effective = current->cap_permitted;
500
501 res = __user_walk(filename, LOOKUP_FOLLOW|LOOKUP_ACCESS, &nd);
502 if (!res) {
503 res = permission(nd.dentry->d_inode, mode, &nd);
504 /* SuS v2 requires we report a read only fs too */
505 if(!res && (mode & S_IWOTH) && IS_RDONLY(nd.dentry->d_inode)
506 && !special_file(nd.dentry->d_inode->i_mode))
507 res = -EROFS;
508 path_release(&nd);
509 }
510
511 current->fsuid = old_fsuid;
512 current->fsgid = old_fsgid;
513 current->cap_effective = old_cap;
514
515 return res;
516 }
517
518 asmlinkage long sys_chdir(const char __user * filename)
519 {
520 struct nameidata nd;
521 int error;
522
523 error = __user_walk(filename, LOOKUP_FOLLOW|LOOKUP_DIRECTORY, &nd);
524 if (error)
525 goto out;
526
527 error = permission(nd.dentry->d_inode,MAY_EXEC,&nd);
528 if (error)
529 goto dput_and_out;
530
531 set_fs_pwd(current->fs, nd.mnt, nd.dentry);
532
533 dput_and_out:
534 path_release(&nd);
535 out:
536 return error;
537 }
538
539 asmlinkage long sys_fchdir(unsigned int fd)
540 {
541 struct file *file;
542 struct dentry *dentry;
543 struct inode *inode;
544 struct vfsmount *mnt;
545 int error;
546
547 error = -EBADF;
548 file = fget(fd);
549 if (!file)
550 goto out;
551
552 dentry = file->f_dentry;
553 mnt = file->f_vfsmnt;
554 inode = dentry->d_inode;
555
556 error = -ENOTDIR;
557 if (!S_ISDIR(inode->i_mode))
558 goto out_putf;
559
560 error = permission(inode, MAY_EXEC, NULL);
561 if (!error)
562 set_fs_pwd(current->fs, mnt, dentry);
563 out_putf:
564 fput(file);
565 out:
566 return error;
567 }
568
569 asmlinkage long sys_chroot(const char __user * filename)
570 {
571 struct nameidata nd;
572 int error;
573
574 error = __user_walk(filename, LOOKUP_FOLLOW | LOOKUP_DIRECTORY | LOOKUP_NOALT, &nd);
575 if (error)
576 goto out;
577
578 error = permission(nd.dentry->d_inode,MAY_EXEC,&nd);
579 if (error)
580 goto dput_and_out;
581
582 error = -EPERM;
583 if (!capable(CAP_SYS_CHROOT))
584 goto dput_and_out;
585
586 set_fs_root(current->fs, nd.mnt, nd.dentry);
587 set_fs_altroot();
588 error = 0;
589 dput_and_out:
590 path_release(&nd);
591 out:
592 return error;
593 }
594
595 asmlinkage long sys_fchmod(unsigned int fd, mode_t mode)
596 {
597 struct inode * inode;
598 struct dentry * dentry;
599 struct file * file;
600 int err = -EBADF;
601 struct iattr newattrs;
602
603 file = fget(fd);
604 if (!file)
605 goto out;
606
607 dentry = file->f_dentry;
608 inode = dentry->d_inode;
609
610 err = -EROFS;
611 if (IS_RDONLY(inode))
612 goto out_putf;
613 err = -EPERM;
614 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
615 goto out_putf;
616 down(&inode->i_sem);
617 if (mode == (mode_t) -1)
618 mode = inode->i_mode;
619 newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
620 newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
621 err = notify_change(dentry, &newattrs);
622 up(&inode->i_sem);
623
624 out_putf:
625 fput(file);
626 out:
627 return err;
628 }
629
630 asmlinkage long sys_chmod(const char __user * filename, mode_t mode)
631 {
632 struct nameidata nd;
633 struct inode * inode;
634 int error;
635 struct iattr newattrs;
636
637 error = user_path_walk(filename, &nd);
638 if (error)
639 goto out;
640 inode = nd.dentry->d_inode;
641
642 error = -EROFS;
643 if (IS_RDONLY(inode))
644 goto dput_and_out;
645
646 error = -EPERM;
647 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
648 goto dput_and_out;
649
650 down(&inode->i_sem);
651 if (mode == (mode_t) -1)
652 mode = inode->i_mode;
653 newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
654 newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
655 error = notify_change(nd.dentry, &newattrs);
656 up(&inode->i_sem);
657
658 dput_and_out:
659 path_release(&nd);
660 out:
661 return error;
662 }
663
664 static int chown_common(struct dentry * dentry, uid_t user, gid_t group)
665 {
666 struct inode * inode;
667 int error;
668 struct iattr newattrs;
669
670 error = -ENOENT;
671 if (!(inode = dentry->d_inode)) {
672 printk(KERN_ERR "chown_common: NULL inode\n");
673 goto out;
674 }
675 error = -EROFS;
676 if (IS_RDONLY(inode))
677 goto out;
678 error = -EPERM;
679 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
680 goto out;
681 newattrs.ia_valid = ATTR_CTIME;
682 if (user != (uid_t) -1) {
683 newattrs.ia_valid |= ATTR_UID;
684 newattrs.ia_uid = user;
685 }
686 if (group != (gid_t) -1) {
687 newattrs.ia_valid |= ATTR_GID;
688 newattrs.ia_gid = group;
689 }
690 if (!S_ISDIR(inode->i_mode))
691 newattrs.ia_valid |= ATTR_KILL_SUID|ATTR_KILL_SGID;
692 down(&inode->i_sem);
693 error = notify_change(dentry, &newattrs);
694 up(&inode->i_sem);
695 out:
696 return error;
697 }
698
699 asmlinkage long sys_chown(const char __user * filename, uid_t user, gid_t group)
700 {
701 struct nameidata nd;
702 int error;
703
704 error = user_path_walk(filename, &nd);
705 if (!error) {
706 error = chown_common(nd.dentry, user, group);
707 path_release(&nd);
708 }
709 return error;
710 }
711
712 asmlinkage long sys_lchown(const char __user * filename, uid_t user, gid_t group)
713 {
714 struct nameidata nd;
715 int error;
716
717 error = user_path_walk_link(filename, &nd);
718 if (!error) {
719 error = chown_common(nd.dentry, user, group);
720 path_release(&nd);
721 }
722 return error;
723 }
724
725
726 asmlinkage long sys_fchown(unsigned int fd, uid_t user, gid_t group)
727 {
728 struct file * file;
729 int error = -EBADF;
730
731 file = fget(fd);
732 if (file) {
733 error = chown_common(file->f_dentry, user, group);
734 fput(file);
735 }
736 return error;
737 }
738
739 /*
740 * Note that while the flag value (low two bits) for sys_open means:
741 * 00 - read-only
742 * 01 - write-only
743 * 10 - read-write
744 * 11 - special
745 * it is changed into
746 * 00 - no permissions needed
747 * 01 - read-permission
748 * 10 - write-permission
749 * 11 - read-write
750 * for the internal routines (ie open_namei()/follow_link() etc). 00 is
751 * used by symlinks.
752 */
753 struct file *filp_open(const char * filename, int flags, int mode)
754 {
755 int namei_flags, error;
756 struct nameidata nd;
757
758 namei_flags = flags;
759 if ((namei_flags+1) & O_ACCMODE)
760 namei_flags++;
761 if (namei_flags & O_TRUNC)
762 namei_flags |= 2;
763
764 error = open_namei(filename, namei_flags, mode, &nd);
765 if (!error)
766 return dentry_open(nd.dentry, nd.mnt, flags);
767
768 return ERR_PTR(error);
769 }
770
771 EXPORT_SYMBOL(filp_open);
772
773 struct file *dentry_open(struct dentry *dentry, struct vfsmount *mnt, int flags)
774 {
775 struct file * f;
776 struct inode *inode;
777 int error;
778
779 error = -ENFILE;
780 f = get_empty_filp();
781 if (!f)
782 goto cleanup_dentry;
783 f->f_flags = flags;
784 f->f_mode = ((flags+1) & O_ACCMODE) | FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE;
785 inode = dentry->d_inode;
786 if (f->f_mode & FMODE_WRITE) {
787 error = get_write_access(inode);
788 if (error)
789 goto cleanup_file;
790 }
791
792 f->f_mapping = inode->i_mapping;
793 f->f_dentry = dentry;
794 f->f_vfsmnt = mnt;
795 f->f_pos = 0;
796 f->f_op = fops_get(inode->i_fop);
797 file_move(f, &inode->i_sb->s_files);
798
799 if (f->f_op && f->f_op->open) {
800 error = f->f_op->open(inode,f);
801 if (error)
802 goto cleanup_all;
803 }
804 f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
805
806 file_ra_state_init(&f->f_ra, f->f_mapping->host->i_mapping);
807
808 /* NB: we're sure to have correct a_ops only after f_op->open */
809 if (f->f_flags & O_DIRECT) {
810 if (!f->f_mapping->a_ops || !f->f_mapping->a_ops->direct_IO) {
811 fput(f);
812 f = ERR_PTR(-EINVAL);
813 }
814 }
815
816 return f;
817
818 cleanup_all:
819 fops_put(f->f_op);
820 if (f->f_mode & FMODE_WRITE)
821 put_write_access(inode);
822 file_kill(f);
823 f->f_dentry = NULL;
824 f->f_vfsmnt = NULL;
825 cleanup_file:
826 put_filp(f);
827 cleanup_dentry:
828 dput(dentry);
829 mntput(mnt);
830 return ERR_PTR(error);
831 }
832
833 EXPORT_SYMBOL(dentry_open);
834
835 /*
836 * Find an empty file descriptor entry, and mark it busy.
837 */
838 int get_unused_fd(void)
839 {
840 struct files_struct * files = current->files;
841 int fd, error;
842
843 error = -EMFILE;
844 spin_lock(&files->file_lock);
845
846 repeat:
847 fd = find_next_zero_bit(files->open_fds->fds_bits,
848 files->max_fdset,
849 files->next_fd);
850
851 /*
852 * N.B. For clone tasks sharing a files structure, this test
853 * will limit the total number of files that can be opened.
854 */
855 if (fd >= current->signal->rlim[RLIMIT_NOFILE].rlim_cur)
856 goto out;
857
858 /* Do we need to expand the fd array or fd set? */
859 error = expand_files(files, fd);
860 if (error < 0)
861 goto out;
862
863 if (error) {
864 /*
865 * If we needed to expand the fs array we
866 * might have blocked - try again.
867 */
868 error = -EMFILE;
869 goto repeat;
870 }
871
872 FD_SET(fd, files->open_fds);
873 FD_CLR(fd, files->close_on_exec);
874 files->next_fd = fd + 1;
875 #if 1
876 /* Sanity check */
877 if (files->fd[fd] != NULL) {
878 printk(KERN_WARNING "get_unused_fd: slot %d not NULL!\n", fd);
879 files->fd[fd] = NULL;
880 }
881 #endif
882 error = fd;
883
884 out:
885 spin_unlock(&files->file_lock);
886 return error;
887 }
888
889 EXPORT_SYMBOL(get_unused_fd);
890
891 static inline void __put_unused_fd(struct files_struct *files, unsigned int fd)
892 {
893 __FD_CLR(fd, files->open_fds);
894 if (fd < files->next_fd)
895 files->next_fd = fd;
896 }
897
898 void fastcall put_unused_fd(unsigned int fd)
899 {
900 struct files_struct *files = current->files;
901 spin_lock(&files->file_lock);
902 __put_unused_fd(files, fd);
903 spin_unlock(&files->file_lock);
904 }
905
906 EXPORT_SYMBOL(put_unused_fd);
907
908 /*
909 * Install a file pointer in the fd array.
910 *
911 * The VFS is full of places where we drop the files lock between
912 * setting the open_fds bitmap and installing the file in the file
913 * array. At any such point, we are vulnerable to a dup2() race
914 * installing a file in the array before us. We need to detect this and
915 * fput() the struct file we are about to overwrite in this case.
916 *
917 * It should never happen - if we allow dup2() do it, _really_ bad things
918 * will follow.
919 */
920
921 void fastcall fd_install(unsigned int fd, struct file * file)
922 {
923 struct files_struct *files = current->files;
924 spin_lock(&files->file_lock);
925 if (unlikely(files->fd[fd] != NULL))
926 BUG();
927 files->fd[fd] = file;
928 spin_unlock(&files->file_lock);
929 }
930
931 EXPORT_SYMBOL(fd_install);
932
933 asmlinkage long sys_open(const char __user * filename, int flags, int mode)
934 {
935 char * tmp;
936 int fd, error;
937
938 #if BITS_PER_LONG != 32
939 flags |= O_LARGEFILE;
940 #endif
941 tmp = getname(filename);
942 fd = PTR_ERR(tmp);
943 if (!IS_ERR(tmp)) {
944 fd = get_unused_fd();
945 if (fd >= 0) {
946 struct file *f = filp_open(tmp, flags, mode);
947 error = PTR_ERR(f);
948 if (IS_ERR(f))
949 goto out_error;
950 fd_install(fd, f);
951 }
952 out:
953 putname(tmp);
954 }
955 return fd;
956
957 out_error:
958 put_unused_fd(fd);
959 fd = error;
960 goto out;
961 }
962 EXPORT_SYMBOL_GPL(sys_open);
963
964 #ifndef __alpha__
965
966 /*
967 * For backward compatibility? Maybe this should be moved
968 * into arch/i386 instead?
969 */
970 asmlinkage long sys_creat(const char __user * pathname, int mode)
971 {
972 return sys_open(pathname, O_CREAT | O_WRONLY | O_TRUNC, mode);
973 }
974
975 #endif
976
977 /*
978 * "id" is the POSIX thread ID. We use the
979 * files pointer for this..
980 */
981 int filp_close(struct file *filp, fl_owner_t id)
982 {
983 int retval;
984
985 /* Report and clear outstanding errors */
986 retval = filp->f_error;
987 if (retval)
988 filp->f_error = 0;
989
990 if (!file_count(filp)) {
991 printk(KERN_ERR "VFS: Close: file count is 0\n");
992 return retval;
993 }
994
995 if (filp->f_op && filp->f_op->flush) {
996 int err = filp->f_op->flush(filp);
997 if (!retval)
998 retval = err;
999 }
1000
1001 dnotify_flush(filp, id);
1002 locks_remove_posix(filp, id);
1003 fput(filp);
1004 return retval;
1005 }
1006
1007 EXPORT_SYMBOL(filp_close);
1008
1009 /*
1010 * Careful here! We test whether the file pointer is NULL before
1011 * releasing the fd. This ensures that one clone task can't release
1012 * an fd while another clone is opening it.
1013 */
1014 asmlinkage long sys_close(unsigned int fd)
1015 {
1016 struct file * filp;
1017 struct files_struct *files = current->files;
1018
1019 spin_lock(&files->file_lock);
1020 if (fd >= files->max_fds)
1021 goto out_unlock;
1022 filp = files->fd[fd];
1023 if (!filp)
1024 goto out_unlock;
1025 files->fd[fd] = NULL;
1026 FD_CLR(fd, files->close_on_exec);
1027 __put_unused_fd(files, fd);
1028 spin_unlock(&files->file_lock);
1029 return filp_close(filp, files);
1030
1031 out_unlock:
1032 spin_unlock(&files->file_lock);
1033 return -EBADF;
1034 }
1035
1036 EXPORT_SYMBOL(sys_close);
1037
1038 /*
1039 * This routine simulates a hangup on the tty, to arrange that users
1040 * are given clean terminals at login time.
1041 */
1042 asmlinkage long sys_vhangup(void)
1043 {
1044 if (capable(CAP_SYS_TTY_CONFIG)) {
1045 tty_vhangup(current->signal->tty);
1046 return 0;
1047 }
1048 return -EPERM;
1049 }
1050
1051 /*
1052 * Called when an inode is about to be open.
1053 * We use this to disallow opening large files on 32bit systems if
1054 * the caller didn't specify O_LARGEFILE. On 64bit systems we force
1055 * on this flag in sys_open.
1056 */
1057 int generic_file_open(struct inode * inode, struct file * filp)
1058 {
1059 if (!(filp->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
1060 return -EFBIG;
1061 return 0;
1062 }
1063
1064 EXPORT_SYMBOL(generic_file_open);
1065
1066 /*
1067 * This is used by subsystems that don't want seekable
1068 * file descriptors
1069 */
1070 int nonseekable_open(struct inode *inode, struct file *filp)
1071 {
1072 filp->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
1073 return 0;
1074 }
1075
1076 EXPORT_SYMBOL(nonseekable_open);
1077
|
This page was automatically generated by the
LXR engine.
|