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