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