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