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