1 /* 2 * linux/fs/namei.c 3 * 4 * Copyright (C) 1991, 1992 Linus Torvalds 5 */ 6 7 /* 8 * Some corrections by tytso. 9 */ 10 11 /* [Feb 1997 T. Schoebel-Theuer] Complete rewrite of the pathname 12 * lookup logic. 13 */ 14 /* [Feb-Apr 2000, AV] Rewrite to the new namespace architecture. 15 */ 16 17 #include <linux/init.h> 18 #include <linux/module.h> 19 #include <linux/slab.h> 20 #include <linux/fs.h> 21 #include <linux/namei.h> 22 #include <linux/quotaops.h> 23 #include <linux/pagemap.h> 24 #include <linux/fsnotify.h> 25 #include <linux/personality.h> 26 #include <linux/security.h> 27 #include <linux/syscalls.h> 28 #include <linux/mount.h> 29 #include <linux/audit.h> 30 #include <linux/capability.h> 31 #include <linux/file.h> 32 #include <linux/fcntl.h> 33 #include <linux/device_cgroup.h> 34 #include <asm/uaccess.h> 35 36 #define ACC_MODE(x) ("\000\004\002\006"[(x)&O_ACCMODE]) 37 38 /* [Feb-1997 T. Schoebel-Theuer] 39 * Fundamental changes in the pathname lookup mechanisms (namei) 40 * were necessary because of omirr. The reason is that omirr needs 41 * to know the _real_ pathname, not the user-supplied one, in case 42 * of symlinks (and also when transname replacements occur). 43 * 44 * The new code replaces the old recursive symlink resolution with 45 * an iterative one (in case of non-nested symlink chains). It does 46 * this with calls to <fs>_follow_link(). 47 * As a side effect, dir_namei(), _namei() and follow_link() are now 48 * replaced with a single function lookup_dentry() that can handle all 49 * the special cases of the former code. 50 * 51 * With the new dcache, the pathname is stored at each inode, at least as 52 * long as the refcount of the inode is positive. As a side effect, the 53 * size of the dcache depends on the inode cache and thus is dynamic. 54 * 55 * [29-Apr-1998 C. Scott Ananian] Updated above description of symlink 56 * resolution to correspond with current state of the code. 57 * 58 * Note that the symlink resolution is not *completely* iterative. 59 * There is still a significant amount of tail- and mid- recursion in 60 * the algorithm. Also, note that <fs>_readlink() is not used in 61 * lookup_dentry(): lookup_dentry() on the result of <fs>_readlink() 62 * may return different results than <fs>_follow_link(). Many virtual 63 * filesystems (including /proc) exhibit this behavior. 64 */ 65 66 /* [24-Feb-97 T. Schoebel-Theuer] Side effects caused by new implementation: 67 * New symlink semantics: when open() is called with flags O_CREAT | O_EXCL 68 * and the name already exists in form of a symlink, try to create the new 69 * name indicated by the symlink. The old code always complained that the 70 * name already exists, due to not following the symlink even if its target 71 * is nonexistent. The new semantics affects also mknod() and link() when 72 * the name is a symlink pointing to a non-existant name. 73 * 74 * I don't know which semantics is the right one, since I have no access 75 * to standards. But I found by trial that HP-UX 9.0 has the full "new" 76 * semantics implemented, while SunOS 4.1.1 and Solaris (SunOS 5.4) have the 77 * "old" one. Personally, I think the new semantics is much more logical. 78 * Note that "ln old new" where "new" is a symlink pointing to a non-existing 79 * file does succeed in both HP-UX and SunOs, but not in Solaris 80 * and in the old Linux semantics. 81 */ 82 83 /* [16-Dec-97 Kevin Buhr] For security reasons, we change some symlink 84 * semantics. See the comments in "open_namei" and "do_link" below. 85 * 86 * [10-Sep-98 Alan Modra] Another symlink change. 87 */ 88 89 /* [Feb-Apr 2000 AV] Complete rewrite. Rules for symlinks: 90 * inside the path - always follow. 91 * in the last component in creation/removal/renaming - never follow. 92 * if LOOKUP_FOLLOW passed - follow. 93 * if the pathname has trailing slashes - follow. 94 * otherwise - don't follow. 95 * (applied in that order). 96 * 97 * [Jun 2000 AV] Inconsistent behaviour of open() in case if flags==O_CREAT 98 * restored for 2.4. This is the last surviving part of old 4.2BSD bug. 99 * During the 2.4 we need to fix the userland stuff depending on it - 100 * hopefully we will be able to get rid of that wart in 2.5. So far only 101 * XEmacs seems to be relying on it... 102 */ 103 /* 104 * [Sep 2001 AV] Single-semaphore locking scheme (kudos to David Holland) 105 * implemented. Let's see if raised priority of ->s_vfs_rename_mutex gives 106 * any extra contention... 107 */ 108 109 static int __link_path_walk(const char *name, struct nameidata *nd); 110 111 /* In order to reduce some races, while at the same time doing additional 112 * checking and hopefully speeding things up, we copy filenames to the 113 * kernel data space before using them.. 114 * 115 * POSIX.1 2.4: an empty pathname is invalid (ENOENT). 116 * PATH_MAX includes the nul terminator --RR. 117 */ 118 static int do_getname(const char __user *filename, char *page) 119 { 120 int retval; 121 unsigned long len = PATH_MAX; 122 123 if (!segment_eq(get_fs(), KERNEL_DS)) { 124 if ((unsigned long) filename >= TASK_SIZE) 125 return -EFAULT; 126 if (TASK_SIZE - (unsigned long) filename < PATH_MAX) 127 len = TASK_SIZE - (unsigned long) filename; 128 } 129 130 retval = strncpy_from_user(page, filename, len); 131 if (retval > 0) { 132 if (retval < len) 133 return 0; 134 return -ENAMETOOLONG; 135 } else if (!retval) 136 retval = -ENOENT; 137 return retval; 138 } 139 140 char * getname(const char __user * filename) 141 { 142 char *tmp, *result; 143 144 result = ERR_PTR(-ENOMEM); 145 tmp = __getname(); 146 if (tmp) { 147 int retval = do_getname(filename, tmp); 148 149 result = tmp; 150 if (retval < 0) { 151 __putname(tmp); 152 result = ERR_PTR(retval); 153 } 154 } 155 audit_getname(result); 156 return result; 157 } 158 159 #ifdef CONFIG_AUDITSYSCALL 160 void putname(const char *name) 161 { 162 if (unlikely(!audit_dummy_context())) 163 audit_putname(name); 164 else 165 __putname(name); 166 } 167 EXPORT_SYMBOL(putname); 168 #endif 169 170 171 /** 172 * generic_permission - check for access rights on a Posix-like filesystem 173 * @inode: inode to check access rights for 174 * @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC) 175 * @check_acl: optional callback to check for Posix ACLs 176 * 177 * Used to check for read/write/execute permissions on a file. 178 * We use "fsuid" for this, letting us set arbitrary permissions 179 * for filesystem access without changing the "normal" uids which 180 * are used for other things.. 181 */ 182 int generic_permission(struct inode *inode, int mask, 183 int (*check_acl)(struct inode *inode, int mask)) 184 { 185 umode_t mode = inode->i_mode; 186 187 mask &= MAY_READ | MAY_WRITE | MAY_EXEC; 188 189 if (current_fsuid() == inode->i_uid) 190 mode >>= 6; 191 else { 192 if (IS_POSIXACL(inode) && (mode & S_IRWXG) && check_acl) { 193 int error = check_acl(inode, mask); 194 if (error == -EACCES) 195 goto check_capabilities; 196 else if (error != -EAGAIN) 197 return error; 198 } 199 200 if (in_group_p(inode->i_gid)) 201 mode >>= 3; 202 } 203 204 /* 205 * If the DACs are ok we don't need any capability check. 206 */ 207 if ((mask & ~mode) == 0) 208 return 0; 209 210 check_capabilities: 211 /* 212 * Read/write DACs are always overridable. 213 * Executable DACs are overridable if at least one exec bit is set. 214 */ 215 if (!(mask & MAY_EXEC) || execute_ok(inode)) 216 if (capable(CAP_DAC_OVERRIDE)) 217 return 0; 218 219 /* 220 * Searching includes executable on directories, else just read. 221 */ 222 if (mask == MAY_READ || (S_ISDIR(inode->i_mode) && !(mask & MAY_WRITE))) 223 if (capable(CAP_DAC_READ_SEARCH)) 224 return 0; 225 226 return -EACCES; 227 } 228 229 /** 230 * inode_permission - check for access rights to a given inode 231 * @inode: inode to check permission on 232 * @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC) 233 * 234 * Used to check for read/write/execute permissions on an inode. 235 * We use "fsuid" for this, letting us set arbitrary permissions 236 * for filesystem access without changing the "normal" uids which 237 * are used for other things. 238 */ 239 int inode_permission(struct inode *inode, int mask) 240 { 241 int retval; 242 243 if (mask & MAY_WRITE) { 244 umode_t mode = inode->i_mode; 245 246 /* 247 * Nobody gets write access to a read-only fs. 248 */ 249 if (IS_RDONLY(inode) && 250 (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))) 251 return -EROFS; 252 253 /* 254 * Nobody gets write access to an immutable file. 255 */ 256 if (IS_IMMUTABLE(inode)) 257 return -EACCES; 258 } 259 260 if (inode->i_op->permission) 261 retval = inode->i_op->permission(inode, mask); 262 else 263 retval = generic_permission(inode, mask, NULL); 264 265 if (retval) 266 return retval; 267 268 retval = devcgroup_inode_permission(inode, mask); 269 if (retval) 270 return retval; 271 272 return security_inode_permission(inode, 273 mask & (MAY_READ|MAY_WRITE|MAY_EXEC|MAY_APPEND)); 274 } 275 276 /** 277 * file_permission - check for additional access rights to a given file 278 * @file: file to check access rights for 279 * @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC) 280 * 281 * Used to check for read/write/execute permissions on an already opened 282 * file. 283 * 284 * Note: 285 * Do not use this function in new code. All access checks should 286 * be done using inode_permission(). 287 */ 288 int file_permission(struct file *file, int mask) 289 { 290 return inode_permission(file->f_path.dentry->d_inode, mask); 291 } 292 293 /* 294 * get_write_access() gets write permission for a file. 295 * put_write_access() releases this write permission. 296 * This is used for regular files. 297 * We cannot support write (and maybe mmap read-write shared) accesses and 298 * MAP_DENYWRITE mmappings simultaneously. The i_writecount field of an inode 299 * can have the following values: 300 * 0: no writers, no VM_DENYWRITE mappings 301 * < 0: (-i_writecount) vm_area_structs with VM_DENYWRITE set exist 302 * > 0: (i_writecount) users are writing to the file. 303 * 304 * Normally we operate on that counter with atomic_{inc,dec} and it's safe 305 * except for the cases where we don't hold i_writecount yet. Then we need to 306 * use {get,deny}_write_access() - these functions check the sign and refuse 307 * to do the change if sign is wrong. Exclusion between them is provided by 308 * the inode->i_lock spinlock. 309 */ 310 311 int get_write_access(struct inode * inode) 312 { 313 spin_lock(&inode->i_lock); 314 if (atomic_read(&inode->i_writecount) < 0) { 315 spin_unlock(&inode->i_lock); 316 return -ETXTBSY; 317 } 318 atomic_inc(&inode->i_writecount); 319 spin_unlock(&inode->i_lock); 320 321 return 0; 322 } 323 324 int deny_write_access(struct file * file) 325 { 326 struct inode *inode = file->f_path.dentry->d_inode; 327 328 spin_lock(&inode->i_lock); 329 if (atomic_read(&inode->i_writecount) > 0) { 330 spin_unlock(&inode->i_lock); 331 return -ETXTBSY; 332 } 333 atomic_dec(&inode->i_writecount); 334 spin_unlock(&inode->i_lock); 335 336 return 0; 337 } 338 339 /** 340 * path_get - get a reference to a path 341 * @path: path to get the reference to 342 * 343 * Given a path increment the reference count to the dentry and the vfsmount. 344 */ 345 void path_get(struct path *path) 346 { 347 mntget(path->mnt); 348 dget(path->dentry); 349 } 350 EXPORT_SYMBOL(path_get); 351 352 /** 353 * path_put - put a reference to a path 354 * @path: path to put the reference to 355 * 356 * Given a path decrement the reference count to the dentry and the vfsmount. 357 */ 358 void path_put(struct path *path) 359 { 360 dput(path->dentry); 361 mntput(path->mnt); 362 } 363 EXPORT_SYMBOL(path_put); 364 365 /** 366 * release_open_intent - free up open intent resources 367 * @nd: pointer to nameidata 368 */ 369 void release_open_intent(struct nameidata *nd) 370 { 371 if (nd->intent.open.file->f_path.dentry == NULL) 372 put_filp(nd->intent.open.file); 373 else 374 fput(nd->intent.open.file); 375 } 376 377 static inline struct dentry * 378 do_revalidate(struct dentry *dentry, struct nameidata *nd) 379 { 380 int status = dentry->d_op->d_revalidate(dentry, nd); 381 if (unlikely(status <= 0)) { 382 /* 383 * The dentry failed validation. 384 * If d_revalidate returned 0 attempt to invalidate 385 * the dentry otherwise d_revalidate is asking us 386 * to return a fail status. 387 */ 388 if (!status) { 389 if (!d_invalidate(dentry)) { 390 dput(dentry); 391 dentry = NULL; 392 } 393 } else { 394 dput(dentry); 395 dentry = ERR_PTR(status); 396 } 397 } 398 return dentry; 399 } 400 401 /* 402 * Internal lookup() using the new generic dcache. 403 * SMP-safe 404 */ 405 static struct dentry * cached_lookup(struct dentry * parent, struct qstr * name, struct nameidata *nd) 406 { 407 struct dentry * dentry = __d_lookup(parent, name); 408 409 /* lockess __d_lookup may fail due to concurrent d_move() 410 * in some unrelated directory, so try with d_lookup 411 */ 412 if (!dentry) 413 dentry = d_lookup(parent, name); 414 415 if (dentry && dentry->d_op && dentry->d_op->d_revalidate) 416 dentry = do_revalidate(dentry, nd); 417 418 return dentry; 419 } 420 421 /* 422 * Short-cut version of permission(), for calling by 423 * path_walk(), when dcache lock is held. Combines parts 424 * of permission() and generic_permission(), and tests ONLY for 425 * MAY_EXEC permission. 426 * 427 * If appropriate, check DAC only. If not appropriate, or 428 * short-cut DAC fails, then call permission() to do more 429 * complete permission check. 430 */ 431 static int exec_permission_lite(struct inode *inode) 432 { 433 umode_t mode = inode->i_mode; 434 435 if (inode->i_op->permission) 436 return -EAGAIN; 437 438 if (current_fsuid() == inode->i_uid) 439 mode >>= 6; 440 else if (in_group_p(inode->i_gid)) 441 mode >>= 3; 442 443 if (mode & MAY_EXEC) 444 goto ok; 445 446 if ((inode->i_mode & S_IXUGO) && capable(CAP_DAC_OVERRIDE)) 447 goto ok; 448 449 if (S_ISDIR(inode->i_mode) && capable(CAP_DAC_OVERRIDE)) 450 goto ok; 451 452 if (S_ISDIR(inode->i_mode) && capable(CAP_DAC_READ_SEARCH)) 453 goto ok; 454 455 return -EACCES; 456 ok: 457 return security_inode_permission(inode, MAY_EXEC); 458 } 459 460 /* 461 * This is called when everything else fails, and we actually have 462 * to go to the low-level filesystem to find out what we should do.. 463 * 464 * We get the directory semaphore, and after getting that we also 465 * make sure that nobody added the entry to the dcache in the meantime.. 466 * SMP-safe 467 */ 468 static struct dentry * real_lookup(struct dentry * parent, struct qstr * name, struct nameidata *nd) 469 { 470 struct dentry * result; 471 struct inode *dir = parent->d_inode; 472 473 mutex_lock(&dir->i_mutex); 474 /* 475 * First re-do the cached lookup just in case it was created 476 * while we waited for the directory semaphore.. 477 * 478 * FIXME! This could use version numbering or similar to 479 * avoid unnecessary cache lookups. 480 * 481 * The "dcache_lock" is purely to protect the RCU list walker 482 * from concurrent renames at this point (we mustn't get false 483 * negatives from the RCU list walk here, unlike the optimistic 484 * fast walk). 485 * 486 * so doing d_lookup() (with seqlock), instead of lockfree __d_lookup 487 */ 488 result = d_lookup(parent, name); 489 if (!result) { 490 struct dentry *dentry; 491 492 /* Don't create child dentry for a dead directory. */ 493 result = ERR_PTR(-ENOENT); 494 if (IS_DEADDIR(dir)) 495 goto out_unlock; 496 497 dentry = d_alloc(parent, name); 498 result = ERR_PTR(-ENOMEM); 499 if (dentry) { 500 result = dir->i_op->lookup(dir, dentry, nd); 501 if (result) 502 dput(dentry); 503 else 504 result = dentry; 505 } 506 out_unlock: 507 mutex_unlock(&dir->i_mutex); 508 return result; 509 } 510 511 /* 512 * Uhhuh! Nasty case: the cache was re-populated while 513 * we waited on the semaphore. Need to revalidate. 514 */ 515 mutex_unlock(&dir->i_mutex); 516 if (result->d_op && result->d_op->d_revalidate) { 517 result = do_revalidate(result, nd); 518 if (!result) 519 result = ERR_PTR(-ENOENT); 520 } 521 return result; 522 } 523 524 /* 525 * Wrapper to retry pathname resolution whenever the underlying 526 * file system returns an ESTALE. 527 * 528 * Retry the whole path once, forcing real lookup requests 529 * instead of relying on the dcache. 530 */ 531 static __always_inline int link_path_walk(const char *name, struct nameidata *nd) 532 { 533 struct path save = nd->path; 534 int result; 535 536 /* make sure the stuff we saved doesn't go away */ 537 path_get(&save); 538 539 result = __link_path_walk(name, nd); 540 if (result == -ESTALE) { 541 /* nd->path had been dropped */ 542 nd->path = save; 543 path_get(&nd->path); 544 nd->flags |= LOOKUP_REVAL; 545 result = __link_path_walk(name, nd); 546 } 547 548 path_put(&save); 549 550 return result; 551 } 552 553 static __always_inline int __vfs_follow_link(struct nameidata *nd, const char *link) 554 { 555 int res = 0; 556 char *name; 557 if (IS_ERR(link)) 558 goto fail; 559 560 if (*link == '/') { 561 struct fs_struct *fs = current->fs; 562 563 path_put(&nd->path); 564 565 read_lock(&fs->lock); 566 nd->path = fs->root; 567 path_get(&fs->root); 568 read_unlock(&fs->lock); 569 } 570 571 res = link_path_walk(link, nd); 572 if (nd->depth || res || nd->last_type!=LAST_NORM) 573 return res; 574 /* 575 * If it is an iterative symlinks resolution in open_namei() we 576 * have to copy the last component. And all that crap because of 577 * bloody create() on broken symlinks. Furrfu... 578 */ 579 name = __getname(); 580 if (unlikely(!name)) { 581 path_put(&nd->path); 582 return -ENOMEM; 583 } 584 strcpy(name, nd->last.name); 585 nd->last.name = name; 586 return 0; 587 fail: 588 path_put(&nd->path); 589 return PTR_ERR(link); 590 } 591 592 static void path_put_conditional(struct path *path, struct nameidata *nd) 593 { 594 dput(path->dentry); 595 if (path->mnt != nd->path.mnt) 596 mntput(path->mnt); 597 } 598 599 static inline void path_to_nameidata(struct path *path, struct nameidata *nd) 600 { 601 dput(nd->path.dentry); 602 if (nd->path.mnt != path->mnt) 603 mntput(nd->path.mnt); 604 nd->path.mnt = path->mnt; 605 nd->path.dentry = path->dentry; 606 } 607 608 static __always_inline int __do_follow_link(struct path *path, struct nameidata *nd) 609 { 610 int error; 611 void *cookie; 612 struct dentry *dentry = path->dentry; 613 614 touch_atime(path->mnt, dentry); 615 nd_set_link(nd, NULL); 616 617 if (path->mnt != nd->path.mnt) { 618 path_to_nameidata(path, nd); 619 dget(dentry); 620 } 621 mntget(path->mnt); 622 cookie = dentry->d_inode->i_op->follow_link(dentry, nd); 623 error = PTR_ERR(cookie); 624 if (!IS_ERR(cookie)) { 625 char *s = nd_get_link(nd); 626 error = 0; 627 if (s) 628 error = __vfs_follow_link(nd, s); 629 if (dentry->d_inode->i_op->put_link) 630 dentry->d_inode->i_op->put_link(dentry, nd, cookie); 631 } 632 path_put(path); 633 634 return error; 635 } 636 637 /* 638 * This limits recursive symlink follows to 8, while 639 * limiting consecutive symlinks to 40. 640 * 641 * Without that kind of total limit, nasty chains of consecutive 642 * symlinks can cause almost arbitrarily long lookups. 643 */ 644 static inline int do_follow_link(struct path *path, struct nameidata *nd) 645 { 646 int err = -ELOOP; 647 if (current->link_count >= MAX_NESTED_LINKS) 648 goto loop; 649 if (current->total_link_count >= 40) 650 goto loop; 651 BUG_ON(nd->depth >= MAX_NESTED_LINKS); 652 cond_resched(); 653 err = security_inode_follow_link(path->dentry, nd); 654 if (err) 655 goto loop; 656 current->link_count++; 657 current->total_link_count++; 658 nd->depth++; 659 err = __do_follow_link(path, nd); 660 current->link_count--; 661 nd->depth--; 662 return err; 663 loop: 664 path_put_conditional(path, nd); 665 path_put(&nd->path); 666 return err; 667 } 668 669 int follow_up(struct vfsmount **mnt, struct dentry **dentry) 670 { 671 struct vfsmount *parent; 672 struct dentry *mountpoint; 673 spin_lock(&vfsmount_lock); 674 parent=(*mnt)->mnt_parent; 675 if (parent == *mnt) { 676 spin_unlock(&vfsmount_lock); 677 return 0; 678 } 679 mntget(parent); 680 mountpoint=dget((*mnt)->mnt_mountpoint); 681 spin_unlock(&vfsmount_lock); 682 dput(*dentry); 683 *dentry = mountpoint; 684 mntput(*mnt); 685 *mnt = parent; 686 return 1; 687 } 688 689 /* no need for dcache_lock, as serialization is taken care in 690 * namespace.c 691 */ 692 static int __follow_mount(struct path *path) 693 { 694 int res = 0; 695 while (d_mountpoint(path->dentry)) { 696 struct vfsmount *mounted = lookup_mnt(path->mnt, path->dentry); 697 if (!mounted) 698 break; 699 dput(path->dentry); 700 if (res) 701 mntput(path->mnt); 702 path->mnt = mounted; 703 path->dentry = dget(mounted->mnt_root); 704 res = 1; 705 } 706 return res; 707 } 708 709 static void follow_mount(struct vfsmount **mnt, struct dentry **dentry) 710 { 711 while (d_mountpoint(*dentry)) { 712 struct vfsmount *mounted = lookup_mnt(*mnt, *dentry); 713 if (!mounted) 714 break; 715 dput(*dentry); 716 mntput(*mnt); 717 *mnt = mounted; 718 *dentry = dget(mounted->mnt_root); 719 } 720 } 721 722 /* no need for dcache_lock, as serialization is taken care in 723 * namespace.c 724 */ 725 int follow_down(struct vfsmount **mnt, struct dentry **dentry) 726 { 727 struct vfsmount *mounted; 728 729 mounted = lookup_mnt(*mnt, *dentry); 730 if (mounted) { 731 dput(*dentry); 732 mntput(*mnt); 733 *mnt = mounted; 734 *dentry = dget(mounted->mnt_root); 735 return 1; 736 } 737 return 0; 738 } 739 740 static __always_inline void follow_dotdot(struct nameidata *nd) 741 { 742 struct fs_struct *fs = current->fs; 743 744 while(1) { 745 struct vfsmount *parent; 746 struct dentry *old = nd->path.dentry; 747 748 read_lock(&fs->lock); 749 if (nd->path.dentry == fs->root.dentry && 750 nd->path.mnt == fs->root.mnt) { 751 read_unlock(&fs->lock); 752 break; 753 } 754 read_unlock(&fs->lock); 755 spin_lock(&dcache_lock); 756 if (nd->path.dentry != nd->path.mnt->mnt_root) { 757 nd->path.dentry = dget(nd->path.dentry->d_parent); 758 spin_unlock(&dcache_lock); 759 dput(old); 760 break; 761 } 762 spin_unlock(&dcache_lock); 763 spin_lock(&vfsmount_lock); 764 parent = nd->path.mnt->mnt_parent; 765 if (parent == nd->path.mnt) { 766 spin_unlock(&vfsmount_lock); 767 break; 768 } 769 mntget(parent); 770 nd->path.dentry = dget(nd->path.mnt->mnt_mountpoint); 771 spin_unlock(&vfsmount_lock); 772 dput(old); 773 mntput(nd->path.mnt); 774 nd->path.mnt = parent; 775 } 776 follow_mount(&nd->path.mnt, &nd->path.dentry); 777 } 778 779 /* 780 * It's more convoluted than I'd like it to be, but... it's still fairly 781 * small and for now I'd prefer to have fast path as straight as possible. 782 * It _is_ time-critical. 783 */ 784 static int do_lookup(struct nameidata *nd, struct qstr *name, 785 struct path *path) 786 { 787 struct vfsmount *mnt = nd->path.mnt; 788 struct dentry *dentry = __d_lookup(nd->path.dentry, name); 789 790 if (!dentry) 791 goto need_lookup; 792 if (dentry->d_op && dentry->d_op->d_revalidate) 793 goto need_revalidate; 794 done: 795 path->mnt = mnt; 796 path->dentry = dentry; 797 __follow_mount(path); 798 return 0; 799 800 need_lookup: 801 dentry = real_lookup(nd->path.dentry, name, nd); 802 if (IS_ERR(dentry)) 803 goto fail; 804 goto done; 805 806 need_revalidate: 807 dentry = do_revalidate(dentry, nd); 808 if (!dentry) 809 goto need_lookup; 810 if (IS_ERR(dentry)) 811 goto fail; 812 goto done; 813 814 fail: 815 return PTR_ERR(dentry); 816 } 817 818 /* 819 * Name resolution. 820 * This is the basic name resolution function, turning a pathname into 821 * the final dentry. We expect 'base' to be positive and a directory. 822 * 823 * Returns 0 and nd will have valid dentry and mnt on success. 824 * Returns error and drops reference to input namei data on failure. 825 */ 826 static int __link_path_walk(const char *name, struct nameidata *nd) 827 { 828 struct path next; 829 struct inode *inode; 830 int err; 831 unsigned int lookup_flags = nd->flags; 832 833 while (*name=='/') 834 name++; 835 if (!*name) 836 goto return_reval; 837 838 inode = nd->path.dentry->d_inode; 839 if (nd->depth) 840 lookup_flags = LOOKUP_FOLLOW | (nd->flags & LOOKUP_CONTINUE); 841 842 /* At this point we know we have a real path component. */ 843 for(;;) { 844 unsigned long hash; 845 struct qstr this; 846 unsigned int c; 847 848 nd->flags |= LOOKUP_CONTINUE; 849 err = exec_permission_lite(inode); 850 if (err == -EAGAIN) 851 err = inode_permission(nd->path.dentry->d_inode, 852 MAY_EXEC); 853 if (err) 854 break; 855 856 this.name = name; 857 c = *(const unsigned char *)name; 858 859 hash = init_name_hash(); 860 do { 861 name++; 862 hash = partial_name_hash(c, hash); 863 c = *(const unsigned char *)name; 864 } while (c && (c != '/')); 865 this.len = name - (const char *) this.name; 866 this.hash = end_name_hash(hash); 867 868 /* remove trailing slashes? */ 869 if (!c) 870 goto last_component; 871 while (*++name == '/'); 872 if (!*name) 873 goto last_with_slashes; 874 875 /* 876 * "." and ".." are special - ".." especially so because it has 877 * to be able to know about the current root directory and 878 * parent relationships. 879 */ 880 if (this.name[0] == '.') switch (this.len) { 881 default: 882 break; 883 case 2: 884 if (this.name[1] != '.') 885 break; 886 follow_dotdot(nd); 887 inode = nd->path.dentry->d_inode; 888 /* fallthrough */ 889 case 1: 890 continue; 891 } 892 /* 893 * See if the low-level filesystem might want 894 * to use its own hash.. 895 */ 896 if (nd->path.dentry->d_op && nd->path.dentry->d_op->d_hash) { 897 err = nd->path.dentry->d_op->d_hash(nd->path.dentry, 898 &this); 899 if (err < 0) 900 break; 901 } 902 /* This does the actual lookups.. */ 903 err = do_lookup(nd, &this, &next); 904 if (err) 905 break; 906 907 err = -ENOENT; 908 inode = next.dentry->d_inode; 909 if (!inode) 910 goto out_dput; 911 912 if (inode->i_op->follow_link) { 913 err = do_follow_link(&next, nd); 914 if (err) 915 goto return_err; 916 err = -ENOENT; 917 inode = nd->path.dentry->d_inode; 918 if (!inode) 919 break; 920 } else 921 path_to_nameidata(&next, nd); 922 err = -ENOTDIR; 923 if (!inode->i_op->lookup) 924 break; 925 continue; 926 /* here ends the main loop */ 927 928 last_with_slashes: 929 lookup_flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY; 930 last_component: 931 /* Clear LOOKUP_CONTINUE iff it was previously unset */ 932 nd->flags &= lookup_flags | ~LOOKUP_CONTINUE; 933 if (lookup_flags & LOOKUP_PARENT) 934 goto lookup_parent; 935 if (this.name[0] == '.') switch (this.len) { 936 default: 937 break; 938 case 2: 939 if (this.name[1] != '.') 940 break; 941 follow_dotdot(nd); 942 inode = nd->path.dentry->d_inode; 943 /* fallthrough */ 944 case 1: 945 goto return_reval; 946 } 947 if (nd->path.dentry->d_op && nd->path.dentry->d_op->d_hash) { 948 err = nd->path.dentry->d_op->d_hash(nd->path.dentry, 949 &this); 950 if (err < 0) 951 break; 952 } 953 err = do_lookup(nd, &this, &next); 954 if (err) 955 break; 956 inode = next.dentry->d_inode; 957 if ((lookup_flags & LOOKUP_FOLLOW) 958 && inode && inode->i_op->follow_link) { 959 err = do_follow_link(&next, nd); 960 if (err) 961 goto return_err; 962 inode = nd->path.dentry->d_inode; 963 } else 964 path_to_nameidata(&next, nd); 965 err = -ENOENT; 966 if (!inode) 967 break; 968 if (lookup_flags & LOOKUP_DIRECTORY) { 969 err = -ENOTDIR; 970 if (!inode->i_op->lookup) 971 break; 972 } 973 goto return_base; 974 lookup_parent: 975 nd->last = this; 976 nd->last_type = LAST_NORM; 977 if (this.name[0] != '.') 978 goto return_base; 979 if (this.len == 1) 980 nd->last_type = LAST_DOT; 981 else if (this.len == 2 && this.name[1] == '.') 982 nd->last_type = LAST_DOTDOT; 983 else 984 goto return_base; 985 return_reval: 986 /* 987 * We bypassed the ordinary revalidation routines. 988 * We may need to check the cached dentry for staleness. 989 */ 990 if (nd->path.dentry && nd->path.dentry->d_sb && 991 (nd->path.dentry->d_sb->s_type->fs_flags & FS_REVAL_DOT)) { 992 err = -ESTALE; 993 /* Note: we do not d_invalidate() */ 994 if (!nd->path.dentry->d_op->d_revalidate( 995 nd->path.dentry, nd)) 996 break; 997 } 998 return_base: 999 return 0; 1000 out_dput: 1001 path_put_conditional(&next, nd); 1002 break; 1003 } 1004 path_put(&nd->path); 1005 return_err: 1006 return err; 1007 } 1008 1009 static int path_walk(const char *name, struct nameidata *nd) 1010 { 1011 current->total_link_count = 0; 1012 return link_path_walk(name, nd); 1013 } 1014 1015 /* Returns 0 and nd will be valid on success; Retuns error, otherwise. */ 1016 static int do_path_lookup(int dfd, const char *name, 1017 unsigned int flags, struct nameidata *nd) 1018 { 1019 int retval = 0; 1020 int fput_needed; 1021 struct file *file; 1022 struct fs_struct *fs = current->fs; 1023 1024 nd->last_type = LAST_ROOT; /* if there are only slashes... */ 1025 nd->flags = flags; 1026 nd->depth = 0; 1027 1028 if (*name=='/') { 1029 read_lock(&fs->lock); 1030 nd->path = fs->root; 1031 path_get(&fs->root); 1032 read_unlock(&fs->lock); 1033 } else if (dfd == AT_FDCWD) { 1034 read_lock(&fs->lock); 1035 nd->path = fs->pwd; 1036 path_get(&fs->pwd); 1037 read_unlock(&fs->lock); 1038 } else { 1039 struct dentry *dentry; 1040 1041 file = fget_light(dfd, &fput_needed); 1042 retval = -EBADF; 1043 if (!file) 1044 goto out_fail; 1045 1046 dentry = file->f_path.dentry; 1047 1048 retval = -ENOTDIR; 1049 if (!S_ISDIR(dentry->d_inode->i_mode)) 1050 goto fput_fail; 1051 1052 retval = file_permission(file, MAY_EXEC); 1053 if (retval) 1054 goto fput_fail; 1055 1056 nd->path = file->f_path; 1057 path_get(&file->f_path); 1058 1059 fput_light(file, fput_needed); 1060 } 1061 1062 retval = path_walk(name, nd); 1063 if (unlikely(!retval && !audit_dummy_context() && nd->path.dentry && 1064 nd->path.dentry->d_inode)) 1065 audit_inode(name, nd->path.dentry); 1066 out_fail: 1067 return retval; 1068 1069 fput_fail: 1070 fput_light(file, fput_needed); 1071 goto out_fail; 1072 } 1073 1074 int path_lookup(const char *name, unsigned int flags, 1075 struct nameidata *nd) 1076 { 1077 return do_path_lookup(AT_FDCWD, name, flags, nd); 1078 } 1079 1080 int kern_path(const char *name, unsigned int flags, struct path *path) 1081 { 1082 struct nameidata nd; 1083 int res = do_path_lookup(AT_FDCWD, name, flags, &nd); 1084 if (!res) 1085 *path = nd.path; 1086 return res; 1087 } 1088 1089 /** 1090 * vfs_path_lookup - lookup a file path relative to a dentry-vfsmount pair 1091 * @dentry: pointer to dentry of the base directory 1092 * @mnt: pointer to vfs mount of the base directory 1093 * @name: pointer to file name 1094 * @flags: lookup flags 1095 * @nd: pointer to nameidata 1096 */ 1097 int vfs_path_lookup(struct dentry *dentry, struct vfsmount *mnt, 1098 const char *name, unsigned int flags, 1099 struct nameidata *nd) 1100 { 1101 int retval; 1102 1103 /* same as do_path_lookup */ 1104 nd->last_type = LAST_ROOT; 1105 nd->flags = flags; 1106 nd->depth = 0; 1107 1108 nd->path.dentry = dentry; 1109 nd->path.mnt = mnt; 1110 path_get(&nd->path); 1111 1112 retval = path_walk(name, nd); 1113 if (unlikely(!retval && !audit_dummy_context() && nd->path.dentry && 1114 nd->path.dentry->d_inode)) 1115 audit_inode(name, nd->path.dentry); 1116 1117 return retval; 1118 1119 } 1120 1121 /** 1122 * path_lookup_open - lookup a file path with open intent 1123 * @dfd: the directory to use as base, or AT_FDCWD 1124 * @name: pointer to file name 1125 * @lookup_flags: lookup intent flags 1126 * @nd: pointer to nameidata 1127 * @open_flags: open intent flags 1128 */ 1129 int path_lookup_open(int dfd, const char *name, unsigned int lookup_flags, 1130 struct nameidata *nd, int open_flags) 1131 { 1132 struct file *filp = get_empty_filp(); 1133 int err; 1134 1135 if (filp == NULL) 1136 return -ENFILE; 1137 nd->intent.open.file = filp; 1138 nd->intent.open.flags = open_flags; 1139 nd->intent.open.create_mode = 0; 1140 err = do_path_lookup(dfd, name, lookup_flags|LOOKUP_OPEN, nd); 1141 if (IS_ERR(nd->intent.open.file)) { 1142 if (err == 0) { 1143 err = PTR_ERR(nd->intent.open.file); 1144 path_put(&nd->path); 1145 } 1146 } else if (err != 0) 1147 release_open_intent(nd); 1148 return err; 1149 } 1150 1151 static struct dentry *__lookup_hash(struct qstr *name, 1152 struct dentry *base, struct nameidata *nd) 1153 { 1154 struct dentry *dentry; 1155 struct inode *inode; 1156 int err; 1157 1158 inode = base->d_inode; 1159 1160 /* 1161 * See if the low-level filesystem might want 1162 * to use its own hash.. 1163 */ 1164 if (base->d_op && base->d_op->d_hash) { 1165 err = base->d_op->d_hash(base, name); 1166 dentry = ERR_PTR(err); 1167 if (err < 0) 1168 goto out; 1169 } 1170 1171 dentry = cached_lookup(base, name, nd); 1172 if (!dentry) { 1173 struct dentry *new; 1174 1175 /* Don't create child dentry for a dead directory. */ 1176 dentry = ERR_PTR(-ENOENT); 1177 if (IS_DEADDIR(inode)) 1178 goto out; 1179 1180 new = d_alloc(base, name); 1181 dentry = ERR_PTR(-ENOMEM); 1182 if (!new) 1183 goto out; 1184 dentry = inode->i_op->lookup(inode, new, nd); 1185 if (!dentry) 1186 dentry = new; 1187 else 1188 dput(new); 1189 } 1190 out: 1191 return dentry; 1192 } 1193 1194 /* 1195 * Restricted form of lookup. Doesn't follow links, single-component only, 1196 * needs parent already locked. Doesn't follow mounts. 1197 * SMP-safe. 1198 */ 1199 static struct dentry *lookup_hash(struct nameidata *nd) 1200 { 1201 int err; 1202 1203 err = inode_permission(nd->path.dentry->d_inode, MAY_EXEC); 1204 if (err) 1205 return ERR_PTR(err); 1206 return __lookup_hash(&nd->last, nd->path.dentry, nd); 1207 } 1208 1209 static int __lookup_one_len(const char *name, struct qstr *this, 1210 struct dentry *base, int len) 1211 { 1212 unsigned long hash; 1213 unsigned int c; 1214 1215 this->name = name; 1216 this->len = len; 1217 if (!len) 1218 return -EACCES; 1219 1220 hash = init_name_hash(); 1221 while (len--) { 1222 c = *(const unsigned char *)name++; 1223 if (c == '/' || c == '\0') 1224 return -EACCES; 1225 hash = partial_name_hash(c, hash); 1226 } 1227 this->hash = end_name_hash(hash); 1228 return 0; 1229 } 1230 1231 /** 1232 * lookup_one_len - filesystem helper to lookup single pathname component 1233 * @name: pathname component to lookup 1234 * @base: base directory to lookup from 1235 * @len: maximum length @len should be interpreted to 1236 * 1237 * Note that this routine is purely a helper for filesystem usage and should 1238 * not be called by generic code. Also note that by using this function the 1239 * nameidata argument is passed to the filesystem methods and a filesystem 1240 * using this helper needs to be prepared for that. 1241 */ 1242 struct dentry *lookup_one_len(const char *name, struct dentry *base, int len) 1243 { 1244 int err; 1245 struct qstr this; 1246 1247 err = __lookup_one_len(name, &this, base, len); 1248 if (err) 1249 return ERR_PTR(err); 1250 1251 err = inode_permission(base->d_inode, MAY_EXEC); 1252 if (err) 1253 return ERR_PTR(err); 1254 return __lookup_hash(&this, base, NULL); 1255 } 1256 1257 /** 1258 * lookup_one_noperm - bad hack for sysfs 1259 * @name: pathname component to lookup 1260 * @base: base directory to lookup from 1261 * 1262 * This is a variant of lookup_one_len that doesn't perform any permission 1263 * checks. It's a horrible hack to work around the braindead sysfs 1264 * architecture and should not be used anywhere else. 1265 * 1266 * DON'T USE THIS FUNCTION EVER, thanks. 1267 */ 1268 struct dentry *lookup_one_noperm(const char *name, struct dentry *base) 1269 { 1270 int err; 1271 struct qstr this; 1272 1273 err = __lookup_one_len(name, &this, base, strlen(name)); 1274 if (err) 1275 return ERR_PTR(err); 1276 return __lookup_hash(&this, base, NULL); 1277 } 1278 1279 int user_path_at(int dfd, const char __user *name, unsigned flags, 1280 struct path *path) 1281 { 1282 struct nameidata nd; 1283 char *tmp = getname(name); 1284 int err = PTR_ERR(tmp); 1285 if (!IS_ERR(tmp)) { 1286 1287 BUG_ON(flags & LOOKUP_PARENT); 1288 1289 err = do_path_lookup(dfd, tmp, flags, &nd); 1290 putname(tmp); 1291 if (!err) 1292 *path = nd.path; 1293 } 1294 return err; 1295 } 1296 1297 static int user_path_parent(int dfd, const char __user *path, 1298 struct nameidata *nd, char **name) 1299 { 1300 char *s = getname(path); 1301 int error; 1302 1303 if (IS_ERR(s)) 1304 return PTR_ERR(s); 1305 1306 error = do_path_lookup(dfd, s, LOOKUP_PARENT, nd); 1307 if (error) 1308 putname(s); 1309 else 1310 *name = s; 1311 1312 return error; 1313 } 1314 1315 /* 1316 * It's inline, so penalty for filesystems that don't use sticky bit is 1317 * minimal. 1318 */ 1319 static inline int check_sticky(struct inode *dir, struct inode *inode) 1320 { 1321 uid_t fsuid = current_fsuid(); 1322 1323 if (!(dir->i_mode & S_ISVTX)) 1324 return 0; 1325 if (inode->i_uid == fsuid) 1326 return 0; 1327 if (dir->i_uid == fsuid) 1328 return 0; 1329 return !capable(CAP_FOWNER); 1330 } 1331 1332 /* 1333 * Check whether we can remove a link victim from directory dir, check 1334 * whether the type of victim is right. 1335 * 1. We can't do it if dir is read-only (done in permission()) 1336 * 2. We should have write and exec permissions on dir 1337 * 3. We can't remove anything from append-only dir 1338 * 4. We can't do anything with immutable dir (done in permission()) 1339 * 5. If the sticky bit on dir is set we should either 1340 * a. be owner of dir, or 1341 * b. be owner of victim, or 1342 * c. have CAP_FOWNER capability 1343 * 6. If the victim is append-only or immutable we can't do antyhing with 1344 * links pointing to it. 1345 * 7. If we were asked to remove a directory and victim isn't one - ENOTDIR. 1346 * 8. If we were asked to remove a non-directory and victim isn't one - EISDIR. 1347 * 9. We can't remove a root or mountpoint. 1348 * 10. We don't allow removal of NFS sillyrenamed files; it's handled by 1349 * nfs_async_unlink(). 1350 */ 1351 static int may_delete(struct inode *dir,struct dentry *victim,int isdir) 1352 { 1353 int error; 1354 1355 if (!victim->d_inode) 1356 return -ENOENT; 1357 1358 BUG_ON(victim->d_parent->d_inode != dir); 1359 audit_inode_child(victim->d_name.name, victim, dir); 1360 1361 error = inode_permission(dir, MAY_WRITE | MAY_EXEC); 1362 if (error) 1363 return error; 1364 if (IS_APPEND(dir)) 1365 return -EPERM; 1366 if (check_sticky(dir, victim->d_inode)||IS_APPEND(victim->d_inode)|| 1367 IS_IMMUTABLE(victim->d_inode) || IS_SWAPFILE(victim->d_inode)) 1368 return -EPERM; 1369 if (isdir) { 1370 if (!S_ISDIR(victim->d_inode->i_mode)) 1371 return -ENOTDIR; 1372 if (IS_ROOT(victim)) 1373 return -EBUSY; 1374 } else if (S_ISDIR(victim->d_inode->i_mode)) 1375 return -EISDIR; 1376 if (IS_DEADDIR(dir)) 1377 return -ENOENT; 1378 if (victim->d_flags & DCACHE_NFSFS_RENAMED) 1379 return -EBUSY; 1380 return 0; 1381 } 1382 1383 /* Check whether we can create an object with dentry child in directory 1384 * dir. 1385 * 1. We can't do it if child already exists (open has special treatment for 1386 * this case, but since we are inlined it's OK) 1387 * 2. We can't do it if dir is read-only (done in permission()) 1388 * 3. We should have write and exec permissions on dir 1389 * 4. We can't do it if dir is immutable (done in permission()) 1390 */ 1391 static inline int may_create(struct inode *dir, struct dentry *child) 1392 { 1393 if (child->d_inode) 1394 return -EEXIST; 1395 if (IS_DEADDIR(dir)) 1396 return -ENOENT; 1397 return inode_permission(dir, MAY_WRITE | MAY_EXEC); 1398 } 1399 1400 /* 1401 * O_DIRECTORY translates into forcing a directory lookup. 1402 */ 1403 static inline int lookup_flags(unsigned int f) 1404 { 1405 unsigned long retval = LOOKUP_FOLLOW; 1406 1407 if (f & O_NOFOLLOW) 1408 retval &= ~LOOKUP_FOLLOW; 1409 1410 if (f & O_DIRECTORY) 1411 retval |= LOOKUP_DIRECTORY; 1412 1413 return retval; 1414 } 1415 1416 /* 1417 * p1 and p2 should be directories on the same fs. 1418 */ 1419 struct dentry *lock_rename(struct dentry *p1, struct dentry *p2) 1420 { 1421 struct dentry *p; 1422 1423 if (p1 == p2) { 1424 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT); 1425 return NULL; 1426 } 1427 1428 mutex_lock(&p1->d_inode->i_sb->s_vfs_rename_mutex); 1429 1430 p = d_ancestor(p2, p1); 1431 if (p) { 1432 mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_PARENT); 1433 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_CHILD); 1434 return p; 1435 } 1436 1437 p = d_ancestor(p1, p2); 1438 if (p) { 1439 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT); 1440 mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD); 1441 return p; 1442 } 1443 1444 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT); 1445 mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD); 1446 return NULL; 1447 } 1448 1449 void unlock_rename(struct dentry *p1, struct dentry *p2) 1450 { 1451 mutex_unlock(&p1->d_inode->i_mutex); 1452 if (p1 != p2) { 1453 mutex_unlock(&p2->d_inode->i_mutex); 1454 mutex_unlock(&p1->d_inode->i_sb->s_vfs_rename_mutex); 1455 } 1456 } 1457 1458 int vfs_create(struct inode *dir, struct dentry *dentry, int mode, 1459 struct nameidata *nd) 1460 { 1461 int error = may_create(dir, dentry); 1462 1463 if (error) 1464 return error; 1465 1466 if (!dir->i_op->create) 1467 return -EACCES; /* shouldn't it be ENOSYS? */ 1468 mode &= S_IALLUGO; 1469 mode |= S_IFREG; 1470 error = security_inode_create(dir, dentry, mode); 1471 if (error) 1472 return error; 1473 DQUOT_INIT(dir); 1474 error = dir->i_op->create(dir, dentry, mode, nd); 1475 if (!error) 1476 fsnotify_create(dir, dentry); 1477 return error; 1478 } 1479 1480 int may_open(struct path *path, int acc_mode, int flag) 1481 { 1482 struct dentry *dentry = path->dentry; 1483 struct inode *inode = dentry->d_inode; 1484 int error; 1485 1486 if (!inode) 1487 return -ENOENT; 1488 1489 if (S_ISLNK(inode->i_mode)) 1490 return -ELOOP; 1491 1492 if (S_ISDIR(inode->i_mode) && (acc_mode & MAY_WRITE)) 1493 return -EISDIR; 1494 1495 /* 1496 * FIFO's, sockets and device files are special: they don't 1497 * actually live on the filesystem itself, and as such you 1498 * can write to them even if the filesystem is read-only. 1499 */ 1500 if (S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) { 1501 flag &= ~O_TRUNC; 1502 } else if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) { 1503 if (path->mnt->mnt_flags & MNT_NODEV) 1504 return -EACCES; 1505 1506 flag &= ~O_TRUNC; 1507 } 1508 1509 error = inode_permission(inode, acc_mode); 1510 if (error) 1511 return error; 1512 /* 1513 * An append-only file must be opened in append mode for writing. 1514 */ 1515 if (IS_APPEND(inode)) { 1516 if ((flag & FMODE_WRITE) && !(flag & O_APPEND)) 1517 return -EPERM; 1518 if (flag & O_TRUNC) 1519 return -EPERM; 1520 } 1521 1522 /* O_NOATIME can only be set by the owner or superuser */ 1523 if (flag & O_NOATIME) 1524 if (!is_owner_or_cap(inode)) 1525 return -EPERM; 1526 1527 /* 1528 * Ensure there are no outstanding leases on the file. 1529 */ 1530 error = break_lease(inode, flag); 1531 if (error) 1532 return error; 1533 1534 if (flag & O_TRUNC) { 1535 error = get_write_access(inode); 1536 if (error) 1537 return error; 1538 1539 /* 1540 * Refuse to truncate files with mandatory locks held on them. 1541 */ 1542 error = locks_verify_locked(inode); 1543 if (!error) 1544 error = security_path_truncate(path, 0, 1545 ATTR_MTIME|ATTR_CTIME|ATTR_OPEN); 1546 if (!error) { 1547 DQUOT_INIT(inode); 1548 1549 error = do_truncate(dentry, 0, 1550 ATTR_MTIME|ATTR_CTIME|ATTR_OPEN, 1551 NULL); 1552 } 1553 put_write_access(inode); 1554 if (error) 1555 return error; 1556 } else 1557 if (flag & FMODE_WRITE) 1558 DQUOT_INIT(inode); 1559 1560 return 0; 1561 } 1562 1563 /* 1564 * Be careful about ever adding any more callers of this 1565 * function. Its flags must be in the namei format, not 1566 * what get passed to sys_open(). 1567 */ 1568 static int __open_namei_create(struct nameidata *nd, struct path *path, 1569 int flag, int mode) 1570 { 1571 int error; 1572 struct dentry *dir = nd->path.dentry; 1573 1574 if (!IS_POSIXACL(dir->d_inode)) 1575 mode &= ~current->fs->umask; 1576 error = security_path_mknod(&nd->path, path->dentry, mode, 0); 1577 if (error) 1578 goto out_unlock; 1579 error = vfs_create(dir->d_inode, path->dentry, mode, nd); 1580 out_unlock: 1581 mutex_unlock(&dir->d_inode->i_mutex); 1582 dput(nd->path.dentry); 1583 nd->path.dentry = path->dentry; 1584 if (error) 1585 return error; 1586 /* Don't check for write permission, don't truncate */ 1587 return may_open(&nd->path, 0, flag & ~O_TRUNC); 1588 } 1589 1590 /* 1591 * Note that while the flag value (low two bits) for sys_open means: 1592 * 00 - read-only 1593 * 01 - write-only 1594 * 10 - read-write 1595 * 11 - special 1596 * it is changed into 1597 * 00 - no permissions needed 1598 * 01 - read-permission 1599 * 10 - write-permission 1600 * 11 - read-write 1601 * for the internal routines (ie open_namei()/follow_link() etc) 1602 * This is more logical, and also allows the 00 "no perm needed" 1603 * to be used for symlinks (where the permissions are checked 1604 * later). 1605 * 1606 */ 1607 static inline int open_to_namei_flags(int flag) 1608 { 1609 if ((flag+1) & O_ACCMODE) 1610 flag++; 1611 return flag; 1612 } 1613 1614 static int open_will_write_to_fs(int flag, struct inode *inode) 1615 { 1616 /* 1617 * We'll never write to the fs underlying 1618 * a device file. 1619 */ 1620 if (special_file(inode->i_mode)) 1621 return 0; 1622 return (flag & O_TRUNC); 1623 } 1624 1625 /* 1626 * Note that the low bits of the passed in "open_flag" 1627 * are not the same as in the local variable "flag". See 1628 * open_to_namei_flags() for more details. 1629 */ 1630 struct file *do_filp_open(int dfd, const char *pathname, 1631 int open_flag, int mode) 1632 { 1633 struct file *filp; 1634 struct nameidata nd; 1635 int acc_mode, error; 1636 struct path path; 1637 struct dentry *dir; 1638 int count = 0; 1639 int will_write; 1640 int flag = open_to_namei_flags(open_flag); 1641 1642 acc_mode = MAY_OPEN | ACC_MODE(flag); 1643 1644 /* O_TRUNC implies we need access checks for write permissions */ 1645 if (flag & O_TRUNC) 1646 acc_mode |= MAY_WRITE; 1647 1648 /* Allow the LSM permission hook to distinguish append 1649 access from general write access. */ 1650 if (flag & O_APPEND) 1651 acc_mode |= MAY_APPEND; 1652 1653 /* 1654 * The simplest case - just a plain lookup. 1655 */ 1656 if (!(flag & O_CREAT)) { 1657 error = path_lookup_open(dfd, pathname, lookup_flags(flag), 1658 &nd, flag); 1659 if (error) 1660 return ERR_PTR(error); 1661 goto ok; 1662 } 1663 1664 /* 1665 * Create - we need to know the parent. 1666 */ 1667 error = do_path_lookup(dfd, pathname, LOOKUP_PARENT, &nd); 1668 if (error) 1669 return ERR_PTR(error); 1670 1671 /* 1672 * We have the parent and last component. First of all, check 1673 * that we are not asked to creat(2) an obvious directory - that 1674 * will not do. 1675 */ 1676 error = -EISDIR; 1677 if (nd.last_type != LAST_NORM || nd.last.name[nd.last.len]) 1678 goto exit_parent; 1679 1680 error = -ENFILE; 1681 filp = get_empty_filp(); 1682 if (filp == NULL) 1683 goto exit_parent; 1684 nd.intent.open.file = filp; 1685 nd.intent.open.flags = flag; 1686 nd.intent.open.create_mode = mode; 1687 dir = nd.path.dentry; 1688 nd.flags &= ~LOOKUP_PARENT; 1689 nd.flags |= LOOKUP_CREATE | LOOKUP_OPEN; 1690 if (flag & O_EXCL) 1691 nd.flags |= LOOKUP_EXCL; 1692 mutex_lock(&dir->d_inode->i_mutex); 1693 path.dentry = lookup_hash(&nd); 1694 path.mnt = nd.path.mnt; 1695 1696 do_last: 1697 error = PTR_ERR(path.dentry); 1698 if (IS_ERR(path.dentry)) { 1699 mutex_unlock(&dir->d_inode->i_mutex); 1700 goto exit; 1701 } 1702 1703 if (IS_ERR(nd.intent.open.file)) { 1704 error = PTR_ERR(nd.intent.open.file); 1705 goto exit_mutex_unlock; 1706 } 1707 1708 /* Negative dentry, just create the file */ 1709 if (!path.dentry->d_inode) { 1710 /* 1711 * This write is needed to ensure that a 1712 * ro->rw transition does not occur between 1713 * the time when the file is created and when 1714 * a permanent write count is taken through 1715 * the 'struct file' in nameidata_to_filp(). 1716 */ 1717 error = mnt_want_write(nd.path.mnt); 1718 if (error) 1719 goto exit_mutex_unlock; 1720 error = __open_namei_create(&nd, &path, flag, mode); 1721 if (error) { 1722 mnt_drop_write(nd.path.mnt); 1723 goto exit; 1724 } 1725 filp = nameidata_to_filp(&nd, open_flag); 1726 mnt_drop_write(nd.path.mnt); 1727 return filp; 1728 } 1729 1730 /* 1731 * It already exists. 1732 */ 1733 mutex_unlock(&dir->d_inode->i_mutex); 1734 audit_inode(pathname, path.dentry); 1735 1736 error = -EEXIST; 1737 if (flag & O_EXCL) 1738 goto exit_dput; 1739 1740 if (__follow_mount(&path)) { 1741 error = -ELOOP; 1742 if (flag & O_NOFOLLOW) 1743 goto exit_dput; 1744 } 1745 1746 error = -ENOENT; 1747 if (!path.dentry->d_inode) 1748 goto exit_dput; 1749 if (path.dentry->d_inode->i_op->follow_link) 1750 goto do_link; 1751 1752 path_to_nameidata(&path, &nd); 1753 error = -EISDIR; 1754 if (path.dentry->d_inode && S_ISDIR(path.dentry->d_inode->i_mode)) 1755 goto exit; 1756 ok: 1757 /* 1758 * Consider: 1759 * 1. may_open() truncates a file 1760 * 2. a rw->ro mount transition occurs 1761 * 3. nameidata_to_filp() fails due to 1762 * the ro mount. 1763 * That would be inconsistent, and should 1764 * be avoided. Taking this mnt write here 1765 * ensures that (2) can not occur. 1766 */ 1767 will_write = open_will_write_to_fs(flag, nd.path.dentry->d_inode); 1768 if (will_write) { 1769 error = mnt_want_write(nd.path.mnt); 1770 if (error) 1771 goto exit; 1772 } 1773 error = may_open(&nd.path, acc_mode, flag); 1774 if (error) { 1775 if (will_write) 1776 mnt_drop_write(nd.path.mnt); 1777 goto exit; 1778 } 1779 filp = nameidata_to_filp(&nd, open_flag); 1780 /* 1781 * It is now safe to drop the mnt write 1782 * because the filp has had a write taken 1783 * on its behalf. 1784 */ 1785 if (will_write) 1786 mnt_drop_write(nd.path.mnt); 1787 return filp; 1788 1789 exit_mutex_unlock: 1790 mutex_unlock(&dir->d_inode->i_mutex); 1791 exit_dput: 1792 path_put_conditional(&path, &nd); 1793 exit: 1794 if (!IS_ERR(nd.intent.open.file)) 1795 release_open_intent(&nd); 1796 exit_parent: 1797 path_put(&nd.path); 1798 return ERR_PTR(error); 1799 1800 do_link: 1801 error = -ELOOP; 1802 if (flag & O_NOFOLLOW) 1803 goto exit_dput; 1804 /* 1805 * This is subtle. Instead of calling do_follow_link() we do the 1806 * thing by hands. The reason is that this way we have zero link_count 1807 * and path_walk() (called from ->follow_link) honoring LOOKUP_PARENT. 1808 * After that we have the parent and last component, i.e. 1809 * we are in the same situation as after the first path_walk(). 1810 * Well, almost - if the last component is normal we get its copy 1811 * stored in nd->last.name and we will have to putname() it when we 1812 * are done. Procfs-like symlinks just set LAST_BIND. 1813 */ 1814 nd.flags |= LOOKUP_PARENT; 1815 error = security_inode_follow_link(path.dentry, &nd); 1816 if (error) 1817 goto exit_dput; 1818 error = __do_follow_link(&path, &nd); 1819 if (error) { 1820 /* Does someone understand code flow here? Or it is only 1821 * me so stupid? Anathema to whoever designed this non-sense 1822 * with "intent.open". 1823 */ 1824 release_open_intent(&nd); 1825 return ERR_PTR(error); 1826 } 1827 nd.flags &= ~LOOKUP_PARENT; 1828 if (nd.last_type == LAST_BIND) 1829 goto ok; 1830 error = -EISDIR; 1831 if (nd.last_type != LAST_NORM) 1832 goto exit; 1833 if (nd.last.name[nd.last.len]) { 1834 __putname(nd.last.name); 1835 goto exit; 1836 } 1837 error = -ELOOP; 1838 if (count++==32) { 1839 __putname(nd.last.name); 1840 goto exit; 1841 } 1842 dir = nd.path.dentry; 1843 mutex_lock(&dir->d_inode->i_mutex); 1844 path.dentry = lookup_hash(&nd); 1845 path.mnt = nd.path.mnt; 1846 __putname(nd.last.name); 1847 goto do_last; 1848 } 1849 1850 /** 1851 * filp_open - open file and return file pointer 1852 * 1853 * @filename: path to open 1854 * @flags: open flags as per the open(2) second argument 1855 * @mode: mode for the new file if O_CREAT is set, else ignored 1856 * 1857 * This is the helper to open a file from kernelspace if you really 1858 * have to. But in generally you should not do this, so please move 1859 * along, nothing to see here.. 1860 */ 1861 struct file *filp_open(const char *filename, int flags, int mode) 1862 { 1863 return do_filp_open(AT_FDCWD, filename, flags, mode); 1864 } 1865 EXPORT_SYMBOL(filp_open); 1866 1867 /** 1868 * lookup_create - lookup a dentry, creating it if it doesn't exist 1869 * @nd: nameidata info 1870 * @is_dir: directory flag 1871 * 1872 * Simple function to lookup and return a dentry and create it 1873 * if it doesn't exist. Is SMP-safe. 1874 * 1875 * Returns with nd->path.dentry->d_inode->i_mutex locked. 1876 */ 1877 struct dentry *lookup_create(struct nameidata *nd, int is_dir) 1878 { 1879 struct dentry *dentry = ERR_PTR(-EEXIST); 1880 1881 mutex_lock_nested(&nd->path.dentry->d_inode->i_mutex, I_MUTEX_PARENT); 1882 /* 1883 * Yucky last component or no last component at all? 1884 * (foo/., foo/.., /////) 1885 */ 1886 if (nd->last_type != LAST_NORM) 1887 goto fail; 1888 nd->flags &= ~LOOKUP_PARENT; 1889 nd->flags |= LOOKUP_CREATE | LOOKUP_EXCL; 1890 nd->intent.open.flags = O_EXCL; 1891 1892 /* 1893 * Do the final lookup. 1894 */ 1895 dentry = lookup_hash(nd); 1896 if (IS_ERR(dentry)) 1897 goto fail; 1898 1899 if (dentry->d_inode) 1900 goto eexist; 1901 /* 1902 * Special case - lookup gave negative, but... we had foo/bar/ 1903 * From the vfs_mknod() POV we just have a negative dentry - 1904 * all is fine. Let's be bastards - you had / on the end, you've 1905 * been asking for (non-existent) directory. -ENOENT for you. 1906 */ 1907 if (unlikely(!is_dir && nd->last.name[nd->last.len])) { 1908 dput(dentry); 1909 dentry = ERR_PTR(-ENOENT); 1910 } 1911 return dentry; 1912 eexist: 1913 dput(dentry); 1914 dentry = ERR_PTR(-EEXIST); 1915 fail: 1916 return dentry; 1917 } 1918 EXPORT_SYMBOL_GPL(lookup_create); 1919 1920 int vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev) 1921 { 1922 int error = may_create(dir, dentry); 1923 1924 if (error) 1925 return error; 1926 1927 if ((S_ISCHR(mode) || S_ISBLK(mode)) && !capable(CAP_MKNOD)) 1928 return -EPERM; 1929 1930 if (!dir->i_op->mknod) 1931 return -EPERM; 1932 1933 error = devcgroup_inode_mknod(mode, dev); 1934 if (error) 1935 return error; 1936 1937 error = security_inode_mknod(dir, dentry, mode, dev); 1938 if (error) 1939 return error; 1940 1941 DQUOT_INIT(dir); 1942 error = dir->i_op->mknod(dir, dentry, mode, dev); 1943 if (!error) 1944 fsnotify_create(dir, dentry); 1945 return error; 1946 } 1947 1948 static int may_mknod(mode_t mode) 1949 { 1950 switch (mode & S_IFMT) { 1951 case S_IFREG: 1952 case S_IFCHR: 1953 case S_IFBLK: 1954 case S_IFIFO: 1955 case S_IFSOCK: 1956 case 0: /* zero mode translates to S_IFREG */ 1957 return 0; 1958 case S_IFDIR: 1959 return -EPERM; 1960 default: 1961 return -EINVAL; 1962 } 1963 } 1964 1965 SYSCALL_DEFINE4(mknodat, int, dfd, const char __user *, filename, int, mode, 1966 unsigned, dev) 1967 { 1968 int error; 1969 char *tmp; 1970 struct dentry *dentry; 1971 struct nameidata nd; 1972 1973 if (S_ISDIR(mode)) 1974 return -EPERM; 1975 1976 error = user_path_parent(dfd, filename, &nd, &tmp); 1977 if (error) 1978 return error; 1979 1980 dentry = lookup_create(&nd, 0); 1981 if (IS_ERR(dentry)) { 1982 error = PTR_ERR(dentry); 1983 goto out_unlock; 1984 } 1985 if (!IS_POSIXACL(nd.path.dentry->d_inode)) 1986 mode &= ~current->fs->umask; 1987 error = may_mknod(mode); 1988 if (error) 1989 goto out_dput; 1990 error = mnt_want_write(nd.path.mnt); 1991 if (error) 1992 goto out_dput; 1993 error = security_path_mknod(&nd.path, dentry, mode, dev); 1994 if (error) 1995 goto out_drop_write; 1996 switch (mode & S_IFMT) { 1997 case 0: case S_IFREG: 1998 error = vfs_create(nd.path.dentry->d_inode,dentry,mode,&nd); 1999 break; 2000 case S_IFCHR: case S_IFBLK: 2001 error = vfs_mknod(nd.path.dentry->d_inode,dentry,mode, 2002 new_decode_dev(dev)); 2003 break; 2004 case S_IFIFO: case S_IFSOCK: 2005 error = vfs_mknod(nd.path.dentry->d_inode,dentry,mode,0); 2006 break; 2007 } 2008 out_drop_write: 2009 mnt_drop_write(nd.path.mnt); 2010 out_dput: 2011 dput(dentry); 2012 out_unlock: 2013 mutex_unlock(&nd.path.dentry->d_inode->i_mutex); 2014 path_put(&nd.path); 2015 putname(tmp); 2016 2017 return error; 2018 } 2019 2020 SYSCALL_DEFINE3(mknod, const char __user *, filename, int, mode, unsigned, dev) 2021 { 2022 return sys_mknodat(AT_FDCWD, filename, mode, dev); 2023 } 2024 2025 int vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode) 2026 { 2027 int error = may_create(dir, dentry); 2028 2029 if (error) 2030 return error; 2031 2032 if (!dir->i_op->mkdir) 2033 return -EPERM; 2034 2035 mode &= (S_IRWXUGO|S_ISVTX); 2036 error = security_inode_mkdir(dir, dentry, mode); 2037 if (error) 2038 return error; 2039 2040 DQUOT_INIT(dir); 2041 error = dir->i_op->mkdir(dir, dentry, mode); 2042 if (!error) 2043 fsnotify_mkdir(dir, dentry); 2044 return error; 2045 } 2046 2047 SYSCALL_DEFINE3(mkdirat, int, dfd, const char __user *, pathname, int, mode) 2048 { 2049 int error = 0; 2050 char * tmp; 2051 struct dentry *dentry; 2052 struct nameidata nd; 2053 2054 error = user_path_parent(dfd, pathname, &nd, &tmp); 2055 if (error) 2056 goto out_err; 2057 2058 dentry = lookup_create(&nd, 1); 2059 error = PTR_ERR(dentry); 2060 if (IS_ERR(dentry)) 2061 goto out_unlock; 2062 2063 if (!IS_POSIXACL(nd.path.dentry->d_inode)) 2064 mode &= ~current->fs->umask; 2065 error = mnt_want_write(nd.path.mnt); 2066 if (error) 2067 goto out_dput; 2068 error = security_path_mkdir(&nd.path, dentry, mode); 2069 if (error) 2070 goto out_drop_write; 2071 error = vfs_mkdir(nd.path.dentry->d_inode, dentry, mode); 2072 out_drop_write: 2073 mnt_drop_write(nd.path.mnt); 2074 out_dput: 2075 dput(dentry); 2076 out_unlock: 2077 mutex_unlock(&nd.path.dentry->d_inode->i_mutex); 2078 path_put(&nd.path); 2079 putname(tmp); 2080 out_err: 2081 return error; 2082 } 2083 2084 SYSCALL_DEFINE2(mkdir, const char __user *, pathname, int, mode) 2085 { 2086 return sys_mkdirat(AT_FDCWD, pathname, mode); 2087 } 2088 2089 /* 2090 * We try to drop the dentry early: we should have 2091 * a usage count of 2 if we're the only user of this 2092 * dentry, and if that is true (possibly after pruning 2093 * the dcache), then we drop the dentry now. 2094 * 2095 * A low-level filesystem can, if it choses, legally 2096 * do a 2097 * 2098 * if (!d_unhashed(dentry)) 2099 * return -EBUSY; 2100 * 2101 * if it cannot handle the case of removing a directory 2102 * that is still in use by something else.. 2103 */ 2104 void dentry_unhash(struct dentry *dentry) 2105 { 2106 dget(dentry); 2107 shrink_dcache_parent(dentry); 2108 spin_lock(&dcache_lock); 2109 spin_lock(&dentry->d_lock); 2110 if (atomic_read(&dentry->d_count) == 2) 2111 __d_drop(dentry); 2112 spin_unlock(&dentry->d_lock); 2113 spin_unlock(&dcache_lock); 2114 } 2115 2116 int vfs_rmdir(struct inode *dir, struct dentry *dentry) 2117 { 2118 int error = may_delete(dir, dentry, 1); 2119 2120 if (error) 2121 return error; 2122 2123 if (!dir->i_op->rmdir) 2124 return -EPERM; 2125 2126 DQUOT_INIT(dir); 2127 2128 mutex_lock(&dentry->d_inode->i_mutex); 2129 dentry_unhash(dentry); 2130 if (d_mountpoint(dentry)) 2131 error = -EBUSY; 2132 else { 2133 error = security_inode_rmdir(dir, dentry); 2134 if (!error) { 2135 error = dir->i_op->rmdir(dir, dentry); 2136 if (!error) 2137 dentry->d_inode->i_flags |= S_DEAD; 2138 } 2139 } 2140 mutex_unlock(&dentry->d_inode->i_mutex); 2141 if (!error) { 2142 d_delete(dentry); 2143 } 2144 dput(dentry); 2145 2146 return error; 2147 } 2148 2149 static long do_rmdir(int dfd, const char __user *pathname) 2150 { 2151 int error = 0; 2152 char * name; 2153 struct dentry *dentry; 2154 struct nameidata nd; 2155 2156 error = user_path_parent(dfd, pathname, &nd, &name); 2157 if (error) 2158 return error; 2159 2160 switch(nd.last_type) { 2161 case LAST_DOTDOT: 2162 error = -ENOTEMPTY; 2163 goto exit1; 2164 case LAST_DOT: 2165 error = -EINVAL; 2166 goto exit1; 2167 case LAST_ROOT: 2168 error = -EBUSY; 2169 goto exit1; 2170 } 2171 2172 nd.flags &= ~LOOKUP_PARENT; 2173 2174 mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT); 2175 dentry = lookup_hash(&nd); 2176 error = PTR_ERR(dentry); 2177 if (IS_ERR(dentry)) 2178 goto exit2; 2179 error = mnt_want_write(nd.path.mnt); 2180 if (error) 2181 goto exit3; 2182 error = security_path_rmdir(&nd.path, dentry); 2183 if (error) 2184 goto exit4; 2185 error = vfs_rmdir(nd.path.dentry->d_inode, dentry); 2186 exit4: 2187 mnt_drop_write(nd.path.mnt); 2188 exit3: 2189 dput(dentry); 2190 exit2: 2191 mutex_unlock(&nd.path.dentry->d_inode->i_mutex); 2192 exit1: 2193 path_put(&nd.path); 2194 putname(name); 2195 return error; 2196 } 2197 2198 SYSCALL_DEFINE1(rmdir, const char __user *, pathname) 2199 { 2200 return do_rmdir(AT_FDCWD, pathname); 2201 } 2202 2203 int vfs_unlink(struct inode *dir, struct dentry *dentry) 2204 { 2205 int error = may_delete(dir, dentry, 0); 2206 2207 if (error) 2208 return error; 2209 2210 if (!dir->i_op->unlink) 2211 return -EPERM; 2212 2213 DQUOT_INIT(dir); 2214 2215 mutex_lock(&dentry->d_inode->i_mutex); 2216 if (d_mountpoint(dentry)) 2217 error = -EBUSY; 2218 else { 2219 error = security_inode_unlink(dir, dentry); 2220 if (!error) 2221 error = dir->i_op->unlink(dir, dentry); 2222 } 2223 mutex_unlock(&dentry->d_inode->i_mutex); 2224 2225 /* We don't d_delete() NFS sillyrenamed files--they still exist. */ 2226 if (!error && !(dentry->d_flags & DCACHE_NFSFS_RENAMED)) { 2227 fsnotify_link_count(dentry->d_inode); 2228 d_delete(dentry); 2229 } 2230 2231 return error; 2232 } 2233 2234 /* 2235 * Make sure that the actual truncation of the file will occur outside its 2236 * directory's i_mutex. Truncate can take a long time if there is a lot of 2237 * writeout happening, and we don't want to prevent access to the directory 2238 * while waiting on the I/O. 2239 */ 2240 static long do_unlinkat(int dfd, const char __user *pathname) 2241 { 2242 int error; 2243 char *name; 2244 struct dentry *dentry; 2245 struct nameidata nd; 2246 struct inode *inode = NULL; 2247 2248 error = user_path_parent(dfd, pathname, &nd, &name); 2249 if (error) 2250 return error; 2251 2252 error = -EISDIR; 2253 if (nd.last_type != LAST_NORM) 2254 goto exit1; 2255 2256 nd.flags &= ~LOOKUP_PARENT; 2257 2258 mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT); 2259 dentry = lookup_hash(&nd); 2260 error = PTR_ERR(dentry); 2261 if (!IS_ERR(dentry)) { 2262 /* Why not before? Because we want correct error value */ 2263 if (nd.last.name[nd.last.len]) 2264 goto slashes; 2265 inode = dentry->d_inode; 2266 if (inode) 2267 atomic_inc(&inode->i_count); 2268 error = mnt_want_write(nd.path.mnt); 2269 if (error) 2270 goto exit2; 2271 error = security_path_unlink(&nd.path, dentry); 2272 if (error) 2273 goto exit3; 2274 error = vfs_unlink(nd.path.dentry->d_inode, dentry); 2275 exit3: 2276 mnt_drop_write(nd.path.mnt); 2277 exit2: 2278 dput(dentry); 2279 } 2280 mutex_unlock(&nd.path.dentry->d_inode->i_mutex); 2281 if (inode) 2282 iput(inode); /* truncate the inode here */ 2283 exit1: 2284 path_put(&nd.path); 2285 putname(name); 2286 return error; 2287 2288 slashes: 2289 error = !dentry->d_inode ? -ENOENT : 2290 S_ISDIR(dentry->d_inode->i_mode) ? -EISDIR : -ENOTDIR; 2291 goto exit2; 2292 } 2293 2294 SYSCALL_DEFINE3(unlinkat, int, dfd, const char __user *, pathname, int, flag) 2295 { 2296 if ((flag & ~AT_REMOVEDIR) != 0) 2297 return -EINVAL; 2298 2299 if (flag & AT_REMOVEDIR) 2300 return do_rmdir(dfd, pathname); 2301 2302 return do_unlinkat(dfd, pathname); 2303 } 2304 2305 SYSCALL_DEFINE1(unlink, const char __user *, pathname) 2306 { 2307 return do_unlinkat(AT_FDCWD, pathname); 2308 } 2309 2310 int vfs_symlink(struct inode *dir, struct dentry *dentry, const char *oldname) 2311 { 2312 int error = may_create(dir, dentry); 2313 2314 if (error) 2315 return error; 2316 2317 if (!dir->i_op->symlink) 2318 return -EPERM; 2319 2320 error = security_inode_symlink(dir, dentry, oldname); 2321 if (error) 2322 return error; 2323 2324 DQUOT_INIT(dir); 2325 error = dir->i_op->symlink(dir, dentry, oldname); 2326 if (!error) 2327 fsnotify_create(dir, dentry); 2328 return error; 2329 } 2330 2331 SYSCALL_DEFINE3(symlinkat, const char __user *, oldname, 2332 int, newdfd, const char __user *, newname) 2333 { 2334 int error; 2335 char *from; 2336 char *to; 2337 struct dentry *dentry; 2338 struct nameidata nd; 2339 2340 from = getname(oldname); 2341 if (IS_ERR(from)) 2342 return PTR_ERR(from); 2343 2344 error = user_path_parent(newdfd, newname, &nd, &to); 2345 if (error) 2346 goto out_putname; 2347 2348 dentry = lookup_create(&nd, 0); 2349 error = PTR_ERR(dentry); 2350 if (IS_ERR(dentry)) 2351 goto out_unlock; 2352 2353 error = mnt_want_write(nd.path.mnt); 2354 if (error) 2355 goto out_dput; 2356 error = security_path_symlink(&nd.path, dentry, from); 2357 if (error) 2358 goto out_drop_write; 2359 error = vfs_symlink(nd.path.dentry->d_inode, dentry, from); 2360 out_drop_write: 2361 mnt_drop_write(nd.path.mnt); 2362 out_dput: 2363 dput(dentry); 2364 out_unlock: 2365 mutex_unlock(&nd.path.dentry->d_inode->i_mutex); 2366 path_put(&nd.path); 2367 putname(to); 2368 out_putname: 2369 putname(from); 2370 return error; 2371 } 2372 2373 SYSCALL_DEFINE2(symlink, const char __user *, oldname, const char __user *, newname) 2374 { 2375 return sys_symlinkat(oldname, AT_FDCWD, newname); 2376 } 2377 2378 int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry) 2379 { 2380 struct inode *inode = old_dentry->d_inode; 2381 int error; 2382 2383 if (!inode) 2384 return -ENOENT; 2385 2386 error = may_create(dir, new_dentry); 2387 if (error) 2388 return error; 2389 2390 if (dir->i_sb != inode->i_sb) 2391 return -EXDEV; 2392 2393 /* 2394 * A link to an append-only or immutable file cannot be created. 2395 */ 2396 if (IS_APPEND(inode) || IS_IMMUTABLE(inode)) 2397 return -EPERM; 2398 if (!dir->i_op->link) 2399 return -EPERM; 2400 if (S_ISDIR(inode->i_mode)) 2401 return -EPERM; 2402 2403 error = security_inode_link(old_dentry, dir, new_dentry); 2404 if (error) 2405 return error; 2406 2407 mutex_lock(&inode->i_mutex); 2408 DQUOT_INIT(dir); 2409 error = dir->i_op->link(old_dentry, dir, new_dentry); 2410 mutex_unlock(&inode->i_mutex); 2411 if (!error) 2412 fsnotify_link(dir, inode, new_dentry); 2413 return error; 2414 } 2415 2416 /* 2417 * Hardlinks are often used in delicate situations. We avoid 2418 * security-related surprises by not following symlinks on the 2419 * newname. --KAB 2420 * 2421 * We don't follow them on the oldname either to be compatible 2422 * with linux 2.0, and to avoid hard-linking to directories 2423 * and other special files. --ADM 2424 */ 2425 SYSCALL_DEFINE5(linkat, int, olddfd, const char __user *, oldname, 2426 int, newdfd, const char __user *, newname, int, flags) 2427 { 2428 struct dentry *new_dentry; 2429 struct nameidata nd; 2430 struct path old_path; 2431 int error; 2432 char *to; 2433 2434 if ((flags & ~AT_SYMLINK_FOLLOW) != 0) 2435 return -EINVAL; 2436 2437 error = user_path_at(olddfd, oldname, 2438 flags & AT_SYMLINK_FOLLOW ? LOOKUP_FOLLOW : 0, 2439 &old_path); 2440 if (error) 2441 return error; 2442 2443 error = user_path_parent(newdfd, newname, &nd, &to); 2444 if (error) 2445 goto out; 2446 error = -EXDEV; 2447 if (old_path.mnt != nd.path.mnt) 2448 goto out_release; 2449 new_dentry = lookup_create(&nd, 0); 2450 error = PTR_ERR(new_dentry); 2451 if (IS_ERR(new_dentry)) 2452 goto out_unlock; 2453 error = mnt_want_write(nd.path.mnt); 2454 if (error) 2455 goto out_dput; 2456 error = security_path_link(old_path.dentry, &nd.path, new_dentry); 2457 if (error) 2458 goto out_drop_write; 2459 error = vfs_link(old_path.dentry, nd.path.dentry->d_inode, new_dentry); 2460 out_drop_write: 2461 mnt_drop_write(nd.path.mnt); 2462 out_dput: 2463 dput(new_dentry); 2464 out_unlock: 2465 mutex_unlock(&nd.path.dentry->d_inode->i_mutex); 2466 out_release: 2467 path_put(&nd.path); 2468 putname(to); 2469 out: 2470 path_put(&old_path); 2471 2472 return error; 2473 } 2474 2475 SYSCALL_DEFINE2(link, const char __user *, oldname, const char __user *, newname) 2476 { 2477 return sys_linkat(AT_FDCWD, oldname, AT_FDCWD, newname, 0); 2478 } 2479 2480 /* 2481 * The worst of all namespace operations - renaming directory. "Perverted" 2482 * doesn't even start to describe it. Somebody in UCB had a heck of a trip... 2483 * Problems: 2484 * a) we can get into loop creation. Check is done in is_subdir(). 2485 * b) race potential - two innocent renames can create a loop together. 2486 * That's where 4.4 screws up. Current fix: serialization on 2487 * sb->s_vfs_rename_mutex. We might be more accurate, but that's another 2488 * story. 2489 * c) we have to lock _three_ objects - parents and victim (if it exists). 2490 * And that - after we got ->i_mutex on parents (until then we don't know 2491 * whether the target exists). Solution: try to be smart with locking 2492 * order for inodes. We rely on the fact that tree topology may change 2493 * only under ->s_vfs_rename_mutex _and_ that parent of the object we 2494 * move will be locked. Thus we can rank directories by the tree 2495 * (ancestors first) and rank all non-directories after them. 2496 * That works since everybody except rename does "lock parent, lookup, 2497 * lock child" and rename is under ->s_vfs_rename_mutex. 2498 * HOWEVER, it relies on the assumption that any object with ->lookup() 2499 * has no more than 1 dentry. If "hybrid" objects will ever appear, 2500 * we'd better make sure that there's no link(2) for them. 2501 * d) some filesystems don't support opened-but-unlinked directories, 2502 * either because of layout or because they are not ready to deal with 2503 * all cases correctly. The latter will be fixed (taking this sort of 2504 * stuff into VFS), but the former is not going away. Solution: the same 2505 * trick as in rmdir(). 2506 * e) conversion from fhandle to dentry may come in the wrong moment - when 2507 * we are removing the target. Solution: we will have to grab ->i_mutex 2508 * in the fhandle_to_dentry code. [FIXME - current nfsfh.c relies on 2509 * ->i_mutex on parents, which works but leads to some truely excessive 2510 * locking]. 2511 */ 2512 static int vfs_rename_dir(struct inode *old_dir, struct dentry *old_dentry, 2513 struct inode *new_dir, struct dentry *new_dentry) 2514 { 2515 int error = 0; 2516 struct inode *target; 2517 2518 /* 2519 * If we are going to change the parent - check write permissions, 2520 * we'll need to flip '..'. 2521 */ 2522 if (new_dir != old_dir) { 2523 error = inode_permission(old_dentry->d_inode, MAY_WRITE); 2524 if (error) 2525 return error; 2526 } 2527 2528 error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry); 2529 if (error) 2530 return error; 2531 2532 target = new_dentry->d_inode; 2533 if (target) { 2534 mutex_lock(&target->i_mutex); 2535 dentry_unhash(new_dentry); 2536 } 2537 if (d_mountpoint(old_dentry)||d_mountpoint(new_dentry)) 2538 error = -EBUSY; 2539 else 2540 error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry); 2541 if (target) { 2542 if (!error) 2543 target->i_flags |= S_DEAD; 2544 mutex_unlock(&target->i_mutex); 2545 if (d_unhashed(new_dentry)) 2546 d_rehash(new_dentry); 2547 dput(new_dentry); 2548 } 2549 if (!error) 2550 if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE)) 2551 d_move(old_dentry,new_dentry); 2552 return error; 2553 } 2554 2555 static int vfs_rename_other(struct inode *old_dir, struct dentry *old_dentry, 2556 struct inode *new_dir, struct dentry *new_dentry) 2557 { 2558 struct inode *target; 2559 int error; 2560 2561 error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry); 2562 if (error) 2563 return error; 2564 2565 dget(new_dentry); 2566 target = new_dentry->d_inode; 2567 if (target) 2568 mutex_lock(&target->i_mutex); 2569 if (d_mountpoint(old_dentry)||d_mountpoint(new_dentry)) 2570 error = -EBUSY; 2571 else 2572 error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry); 2573 if (!error) { 2574 if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE)) 2575 d_move(old_dentry, new_dentry); 2576 } 2577 if (target) 2578 mutex_unlock(&target->i_mutex); 2579 dput(new_dentry); 2580 return error; 2581 } 2582 2583 int vfs_rename(struct inode *old_dir, struct dentry *old_dentry, 2584 struct inode *new_dir, struct dentry *new_dentry) 2585 { 2586 int error; 2587 int is_dir = S_ISDIR(old_dentry->d_inode->i_mode); 2588 const char *old_name; 2589 2590 if (old_dentry->d_inode == new_dentry->d_inode) 2591 return 0; 2592 2593 error = may_delete(old_dir, old_dentry, is_dir); 2594 if (error) 2595 return error; 2596 2597 if (!new_dentry->d_inode) 2598 error = may_create(new_dir, new_dentry); 2599 else 2600 error = may_delete(new_dir, new_dentry, is_dir); 2601 if (error) 2602 return error; 2603 2604 if (!old_dir->i_op->rename) 2605 return -EPERM; 2606 2607 DQUOT_INIT(old_dir); 2608 DQUOT_INIT(new_dir); 2609 2610 old_name = fsnotify_oldname_init(old_dentry->d_name.name); 2611 2612 if (is_dir) 2613 error = vfs_rename_dir(old_dir,old_dentry,new_dir,new_dentry); 2614 else 2615 error = vfs_rename_other(old_dir,old_dentry,new_dir,new_dentry); 2616 if (!error) { 2617 const char *new_name = old_dentry->d_name.name; 2618 fsnotify_move(old_dir, new_dir, old_name, new_name, is_dir, 2619 new_dentry->d_inode, old_dentry); 2620 } 2621 fsnotify_oldname_free(old_name); 2622 2623 return error; 2624 } 2625 2626 SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname, 2627 int, newdfd, const char __user *, newname) 2628 { 2629 struct dentry *old_dir, *new_dir; 2630 struct dentry *old_dentry, *new_dentry; 2631 struct dentry *trap; 2632 struct nameidata oldnd, newnd; 2633 char *from; 2634 char *to; 2635 int error; 2636 2637 error = user_path_parent(olddfd, oldname, &oldnd, &from); 2638 if (error) 2639 goto exit; 2640 2641 error = user_path_parent(newdfd, newname, &newnd, &to); 2642 if (error) 2643 goto exit1; 2644 2645 error = -EXDEV; 2646 if (oldnd.path.mnt != newnd.path.mnt) 2647 goto exit2; 2648 2649 old_dir = oldnd.path.dentry; 2650 error = -EBUSY; 2651 if (oldnd.last_type != LAST_NORM) 2652 goto exit2; 2653 2654 new_dir = newnd.path.dentry; 2655 if (newnd.last_type != LAST_NORM) 2656 goto exit2; 2657 2658 oldnd.flags &= ~LOOKUP_PARENT; 2659 newnd.flags &= ~LOOKUP_PARENT; 2660 newnd.flags |= LOOKUP_RENAME_TARGET; 2661 2662 trap = lock_rename(new_dir, old_dir); 2663 2664 old_dentry = lookup_hash(&oldnd); 2665 error = PTR_ERR(old_dentry); 2666 if (IS_ERR(old_dentry)) 2667 goto exit3; 2668 /* source must exist */ 2669 error = -ENOENT; 2670 if (!old_dentry->d_inode) 2671 goto exit4; 2672 /* unless the source is a directory trailing slashes give -ENOTDIR */ 2673 if (!S_ISDIR(old_dentry->d_inode->i_mode)) { 2674 error = -ENOTDIR; 2675 if (oldnd.last.name[oldnd.last.len]) 2676 goto exit4; 2677 if (newnd.last.name[newnd.last.len]) 2678 goto exit4; 2679 } 2680 /* source should not be ancestor of target */ 2681 error = -EINVAL; 2682 if (old_dentry == trap) 2683 goto exit4; 2684 new_dentry = lookup_hash(&newnd); 2685 error = PTR_ERR(new_dentry); 2686 if (IS_ERR(new_dentry)) 2687 goto exit4; 2688 /* target should not be an ancestor of source */ 2689 error = -ENOTEMPTY; 2690 if (new_dentry == trap) 2691 goto exit5; 2692 2693 error = mnt_want_write(oldnd.path.mnt); 2694 if (error) 2695 goto exit5; 2696 error = security_path_rename(&oldnd.path, old_dentry, 2697 &newnd.path, new_dentry); 2698 if (error) 2699 goto exit6; 2700 error = vfs_rename(old_dir->d_inode, old_dentry, 2701 new_dir->d_inode, new_dentry); 2702 exit6: 2703 mnt_drop_write(oldnd.path.mnt); 2704 exit5: 2705 dput(new_dentry); 2706 exit4: 2707 dput(old_dentry); 2708 exit3: 2709 unlock_rename(new_dir, old_dir); 2710 exit2: 2711 path_put(&newnd.path); 2712 putname(to); 2713 exit1: 2714 path_put(&oldnd.path); 2715 putname(from); 2716 exit: 2717 return error; 2718 } 2719 2720 SYSCALL_DEFINE2(rename, const char __user *, oldname, const char __user *, newname) 2721 { 2722 return sys_renameat(AT_FDCWD, oldname, AT_FDCWD, newname); 2723 } 2724 2725 int vfs_readlink(struct dentry *dentry, char __user *buffer, int buflen, const char *link) 2726 { 2727 int len; 2728 2729 len = PTR_ERR(link); 2730 if (IS_ERR(link)) 2731 goto out; 2732 2733 len = strlen(link); 2734 if (len > (unsigned) buflen) 2735 len = buflen; 2736 if (copy_to_user(buffer, link, len)) 2737 len = -EFAULT; 2738 out: 2739 return len; 2740 } 2741 2742 /* 2743 * A helper for ->readlink(). This should be used *ONLY* for symlinks that 2744 * have ->follow_link() touching nd only in nd_set_link(). Using (or not 2745 * using) it for any given inode is up to filesystem. 2746 */ 2747 int generic_readlink(struct dentry *dentry, char __user *buffer, int buflen) 2748 { 2749 struct nameidata nd; 2750 void *cookie; 2751 int res; 2752 2753 nd.depth = 0; 2754 cookie = dentry->d_inode->i_op->follow_link(dentry, &nd); 2755 if (IS_ERR(cookie)) 2756 return PTR_ERR(cookie); 2757 2758 res = vfs_readlink(dentry, buffer, buflen, nd_get_link(&nd)); 2759 if (dentry->d_inode->i_op->put_link) 2760 dentry->d_inode->i_op->put_link(dentry, &nd, cookie); 2761 return res; 2762 } 2763 2764 int vfs_follow_link(struct nameidata *nd, const char *link) 2765 { 2766 return __vfs_follow_link(nd, link); 2767 } 2768 2769 /* get the link contents into pagecache */ 2770 static char *page_getlink(struct dentry * dentry, struct page **ppage) 2771 { 2772 char *kaddr; 2773 struct page *page; 2774 struct address_space *mapping = dentry->d_inode->i_mapping; 2775 page = read_mapping_page(mapping, 0, NULL); 2776 if (IS_ERR(page)) 2777 return (char*)page; 2778 *ppage = page; 2779 kaddr = kmap(page); 2780 nd_terminate_link(kaddr, dentry->d_inode->i_size, PAGE_SIZE - 1); 2781 return kaddr; 2782 } 2783 2784 int page_readlink(struct dentry *dentry, char __user *buffer, int buflen) 2785 { 2786 struct page *page = NULL; 2787 char *s = page_getlink(dentry, &page); 2788 int res = vfs_readlink(dentry,buffer,buflen,s); 2789 if (page) { 2790 kunmap(page); 2791 page_cache_release(page); 2792 } 2793 return res; 2794 } 2795 2796 void *page_follow_link_light(struct dentry *dentry, struct nameidata *nd) 2797 { 2798 struct page *page = NULL; 2799 nd_set_link(nd, page_getlink(dentry, &page)); 2800 return page; 2801 } 2802 2803 void page_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie) 2804 { 2805 struct page *page = cookie; 2806 2807 if (page) { 2808 kunmap(page); 2809 page_cache_release(page); 2810 } 2811 } 2812 2813 /* 2814 * The nofs argument instructs pagecache_write_begin to pass AOP_FLAG_NOFS 2815 */ 2816 int __page_symlink(struct inode *inode, const char *symname, int len, int nofs) 2817 { 2818 struct address_space *mapping = inode->i_mapping; 2819 struct page *page; 2820 void *fsdata; 2821 int err; 2822 char *kaddr; 2823 unsigned int flags = AOP_FLAG_UNINTERRUPTIBLE; 2824 if (nofs) 2825 flags |= AOP_FLAG_NOFS; 2826 2827 retry: 2828 err = pagecache_write_begin(NULL, mapping, 0, len-1, 2829 flags, &page, &fsdata); 2830 if (err) 2831 goto fail; 2832 2833 kaddr = kmap_atomic(page, KM_USER0); 2834 memcpy(kaddr, symname, len-1); 2835 kunmap_atomic(kaddr, KM_USER0); 2836 2837 err = pagecache_write_end(NULL, mapping, 0, len-1, len-1, 2838 page, fsdata); 2839 if (err < 0) 2840 goto fail; 2841 if (err < len-1) 2842 goto retry; 2843 2844 mark_inode_dirty(inode); 2845 return 0; 2846 fail: 2847 return err; 2848 } 2849 2850 int page_symlink(struct inode *inode, const char *symname, int len) 2851 { 2852 return __page_symlink(inode, symname, len, 2853 !(mapping_gfp_mask(inode->i_mapping) & __GFP_FS)); 2854 } 2855 2856 const struct inode_operations page_symlink_inode_operations = { 2857 .readlink = generic_readlink, 2858 .follow_link = page_follow_link_light, 2859 .put_link = page_put_link, 2860 }; 2861 2862 EXPORT_SYMBOL(user_path_at); 2863 EXPORT_SYMBOL(follow_down); 2864 EXPORT_SYMBOL(follow_up); 2865 EXPORT_SYMBOL(get_write_access); /* binfmt_aout */ 2866 EXPORT_SYMBOL(getname); 2867 EXPORT_SYMBOL(lock_rename); 2868 EXPORT_SYMBOL(lookup_one_len); 2869 EXPORT_SYMBOL(page_follow_link_light); 2870 EXPORT_SYMBOL(page_put_link); 2871 EXPORT_SYMBOL(page_readlink); 2872 EXPORT_SYMBOL(__page_symlink); 2873 EXPORT_SYMBOL(page_symlink); 2874 EXPORT_SYMBOL(page_symlink_inode_operations); 2875 EXPORT_SYMBOL(path_lookup); 2876 EXPORT_SYMBOL(kern_path); 2877 EXPORT_SYMBOL(vfs_path_lookup); 2878 EXPORT_SYMBOL(inode_permission); 2879 EXPORT_SYMBOL(file_permission); 2880 EXPORT_SYMBOL(unlock_rename); 2881 EXPORT_SYMBOL(vfs_create); 2882 EXPORT_SYMBOL(vfs_follow_link); 2883 EXPORT_SYMBOL(vfs_link); 2884 EXPORT_SYMBOL(vfs_mkdir); 2885 EXPORT_SYMBOL(vfs_mknod); 2886 EXPORT_SYMBOL(generic_permission); 2887 EXPORT_SYMBOL(vfs_readlink); 2888 EXPORT_SYMBOL(vfs_rename); 2889 EXPORT_SYMBOL(vfs_rmdir); 2890 EXPORT_SYMBOL(vfs_symlink); 2891 EXPORT_SYMBOL(vfs_unlink); 2892 EXPORT_SYMBOL(dentry_unhash); 2893 EXPORT_SYMBOL(generic_readlink); 2894 2895 /* to be mentioned only in INIT_TASK */ 2896 struct fs_struct init_fs = { 2897 .count = ATOMIC_INIT(1), 2898 .lock = __RW_LOCK_UNLOCKED(init_fs.lock), 2899 .umask = 0022, 2900 }; 2901