fs/namei.c

   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/pagemap.h>
  23 #include <linux/fsnotify.h>
  24 #include <linux/personality.h>
  25 #include <linux/security.h>
  26 #include <linux/ima.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 <linux/fs_struct.h>
  35 #include <linux/posix_acl.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-existent 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 static char *getname_flags(const char __user *filename, int flags, int *empty)
 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                         if (retval == -ENOENT && empty)
 152                                 *empty = 1;
 153                         if (retval != -ENOENT || !(flags & LOOKUP_EMPTY)) {
 154                                 __putname(tmp);
 155                                 result = ERR_PTR(retval);
 156                         }
 157                 }
 158         }
 159         audit_getname(result);
 160         return result;
 161 }
 162
 163 char *getname(const char __user * filename)
 164 {
 165         return getname_flags(filename, 0, 0);
 166 }
 167
 168 #ifdef CONFIG_AUDITSYSCALL
 169 void putname(const char *name)
 170 {
 171         if (unlikely(!audit_dummy_context()))
 172                 audit_putname(name);
 173         else
 174                 __putname(name);
 175 }
 176 EXPORT_SYMBOL(putname);
 177 #endif
 178
 179 static int check_acl(struct inode *inode, int mask)
 180 {
 181 #ifdef CONFIG_FS_POSIX_ACL
 182         struct posix_acl *acl;
 183
 184         if (mask & MAY_NOT_BLOCK) {
 185                 acl = get_cached_acl_rcu(inode, ACL_TYPE_ACCESS);
 186                 if (!acl)
 187                         return -EAGAIN;
 188                 /* no ->get_acl() calls in RCU mode... */
 189                 if (acl == ACL_NOT_CACHED)
 190                         return -ECHILD;
 191                 return posix_acl_permission(inode, acl, mask & ~MAY_NOT_BLOCK);
 192         }
 193
 194         acl = get_cached_acl(inode, ACL_TYPE_ACCESS);
 195
 196         /*
 197          * A filesystem can force a ACL callback by just never filling the
 198          * ACL cache. But normally you'd fill the cache either at inode
 199          * instantiation time, or on the first ->get_acl call.
 200          *
 201          * If the filesystem doesn't have a get_acl() function at all, we'll
 202          * just create the negative cache entry.
 203          */
 204         if (acl == ACL_NOT_CACHED) {
 205                 if (inode->i_op->get_acl) {
 206                         acl = inode->i_op->get_acl(inode, ACL_TYPE_ACCESS);
 207                         if (IS_ERR(acl))
 208                                 return PTR_ERR(acl);
 209                 } else {
 210                         set_cached_acl(inode, ACL_TYPE_ACCESS, NULL);
 211                         return -EAGAIN;
 212                 }
 213         }
 214
 215         if (acl) {
 216                 int error = posix_acl_permission(inode, acl, mask);
 217                 posix_acl_release(acl);
 218                 return error;
 219         }
 220 #endif
 221
 222         return -EAGAIN;
 223 }
 224
 225 /*
 226  * This does the basic permission checking
 227  */
 228 static int acl_permission_check(struct inode *inode, int mask)
 229 {
 230         unsigned int mode = inode->i_mode;
 231
 232         if (current_user_ns() != inode_userns(inode))
 233                 goto other_perms;
 234
 235         if (likely(current_fsuid() == inode->i_uid))
 236                 mode >>= 6;
 237         else {
 238                 if (IS_POSIXACL(inode) && (mode & S_IRWXG)) {
 239                         int error = check_acl(inode, mask);
 240                         if (error != -EAGAIN)
 241                                 return error;
 242                 }
 243
 244                 if (in_group_p(inode->i_gid))
 245                         mode >>= 3;
 246         }
 247
 248 other_perms:
 249         /*
 250          * If the DACs are ok we don't need any capability check.
 251          */
 252         if ((mask & ~mode & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0)
 253                 return 0;
 254         return -EACCES;
 255 }
 256
 257 /**
 258  * generic_permission -  check for access rights on a Posix-like filesystem
 259  * @inode:      inode to check access rights for
 260  * @mask:       right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC, ...)
 261  *
 262  * Used to check for read/write/execute permissions on a file.
 263  * We use "fsuid" for this, letting us set arbitrary permissions
 264  * for filesystem access without changing the "normal" uids which
 265  * are used for other things.
 266  *
 267  * generic_permission is rcu-walk aware. It returns -ECHILD in case an rcu-walk
 268  * request cannot be satisfied (eg. requires blocking or too much complexity).
 269  * It would then be called again in ref-walk mode.
 270  */
 271 int generic_permission(struct inode *inode, int mask)
 272 {
 273         int ret;
 274
 275         /*
 276          * Do the basic permission checks.
 277          */
 278         ret = acl_permission_check(inode, mask);
 279         if (ret != -EACCES)
 280                 return ret;
 281
 282         if (S_ISDIR(inode->i_mode)) {
 283                 /* DACs are overridable for directories */
 284                 if (ns_capable(inode_userns(inode), CAP_DAC_OVERRIDE))
 285                         return 0;
 286                 if (!(mask & MAY_WRITE))
 287                         if (ns_capable(inode_userns(inode), CAP_DAC_READ_SEARCH))
 288                                 return 0;
 289                 return -EACCES;
 290         }
 291         /*
 292          * Read/write DACs are always overridable.
 293          * Executable DACs are overridable when there is
 294          * at least one exec bit set.
 295          */
 296         if (!(mask & MAY_EXEC) || (inode->i_mode & S_IXUGO))
 297                 if (ns_capable(inode_userns(inode), CAP_DAC_OVERRIDE))
 298                         return 0;
 299
 300         /*
 301          * Searching includes executable on directories, else just read.
 302          */
 303         mask &= MAY_READ | MAY_WRITE | MAY_EXEC;
 304         if (mask == MAY_READ)
 305                 if (ns_capable(inode_userns(inode), CAP_DAC_READ_SEARCH))
 306                         return 0;
 307
 308         return -EACCES;
 309 }
 310
 311 /*
 312  * We _really_ want to just do "generic_permission()" without
 313  * even looking at the inode->i_op values. So we keep a cache
 314  * flag in inode->i_opflags, that says "this has not special
 315  * permission function, use the fast case".
 316  */
 317 static inline int do_inode_permission(struct inode *inode, int mask)
 318 {
 319         if (unlikely(!(inode->i_opflags & IOP_FASTPERM))) {
 320                 if (likely(inode->i_op->permission))
 321                         return inode->i_op->permission(inode, mask);
 322
 323                 /* This gets set once for the inode lifetime */
 324                 spin_lock(&inode->i_lock);
 325                 inode->i_opflags |= IOP_FASTPERM;
 326                 spin_unlock(&inode->i_lock);
 327         }
 328         return generic_permission(inode, mask);
 329 }
 330
 331 /**
 332  * inode_permission  -  check for access rights to a given inode
 333  * @inode:      inode to check permission on
 334  * @mask:       right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC, ...)
 335  *
 336  * Used to check for read/write/execute permissions on an inode.
 337  * We use "fsuid" for this, letting us set arbitrary permissions
 338  * for filesystem access without changing the "normal" uids which
 339  * are used for other things.
 340  *
 341  * When checking for MAY_APPEND, MAY_WRITE must also be set in @mask.
 342  */
 343 int inode_permission(struct inode *inode, int mask)
 344 {
 345         int retval;
 346
 347         if (unlikely(mask & MAY_WRITE)) {
 348                 umode_t mode = inode->i_mode;
 349
 350                 /*
 351                  * Nobody gets write access to a read-only fs.
 352                  */
 353                 if (IS_RDONLY(inode) &&
 354                     (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
 355                         return -EROFS;
 356
 357                 /*
 358                  * Nobody gets write access to an immutable file.
 359                  */
 360                 if (IS_IMMUTABLE(inode))
 361                         return -EACCES;
 362         }
 363
 364         retval = do_inode_permission(inode, mask);
 365         if (retval)
 366                 return retval;
 367
 368         retval = devcgroup_inode_permission(inode, mask);
 369         if (retval)
 370                 return retval;
 371
 372         return security_inode_permission(inode, mask);
 373 }
 374
 375 /**
 376  * path_get - get a reference to a path
 377  * @path: path to get the reference to
 378  *
 379  * Given a path increment the reference count to the dentry and the vfsmount.
 380  */
 381 void path_get(struct path *path)
 382 {
 383         mntget(path->mnt);
 384         dget(path->dentry);
 385 }
 386 EXPORT_SYMBOL(path_get);
 387
 388 /**
 389  * path_put - put a reference to a path
 390  * @path: path to put the reference to
 391  *
 392  * Given a path decrement the reference count to the dentry and the vfsmount.
 393  */
 394 void path_put(struct path *path)
 395 {
 396         dput(path->dentry);
 397         mntput(path->mnt);
 398 }
 399 EXPORT_SYMBOL(path_put);
 400
 401 /**
 402  * path_connected - Verify that a path->dentry is below path->mnt.mnt_root
 403  * @path: nameidate to verify
 404  *
 405  * Rename can sometimes move a file or directory outside of a bind
 406  * mount, path_connected allows those cases to be detected.
 407  */
 408 static bool path_connected(const struct path *path)
 409 {
 410         struct vfsmount *mnt = path->mnt;
 411
 412         /* Only bind mounts can have disconnected paths */
 413         if (mnt->mnt_root == mnt->mnt_sb->s_root)
 414                 return true;
 415
 416         return is_subdir(path->dentry, mnt->mnt_root);
 417 }
 418
 419 /*
 420  * Path walking has 2 modes, rcu-walk and ref-walk (see
 421  * Documentation/filesystems/path-lookup.txt).  In situations when we can't
 422  * continue in RCU mode, we attempt to drop out of rcu-walk mode and grab
 423  * normal reference counts on dentries and vfsmounts to transition to rcu-walk
 424  * mode.  Refcounts are grabbed at the last known good point before rcu-walk
 425  * got stuck, so ref-walk may continue from there. If this is not successful
 426  * (eg. a seqcount has changed), then failure is returned and it's up to caller
 427  * to restart the path walk from the beginning in ref-walk mode.
 428  */
 429
 430 /**
 431  * unlazy_walk - try to switch to ref-walk mode.
 432  * @nd: nameidata pathwalk data
 433  * @dentry: child of nd->path.dentry or NULL
 434  * Returns: 0 on success, -ECHILD on failure
 435  *
 436  * unlazy_walk attempts to legitimize the current nd->path, nd->root and dentry
 437  * for ref-walk mode.  @dentry must be a path found by a do_lookup call on
 438  * @nd or NULL.  Must be called from rcu-walk context.
 439  */
 440 static int unlazy_walk(struct nameidata *nd, struct dentry *dentry)
 441 {
 442         struct fs_struct *fs = current->fs;
 443         struct dentry *parent = nd->path.dentry;
 444         int want_root = 0;
 445
 446         BUG_ON(!(nd->flags & LOOKUP_RCU));
 447         if (nd->root.mnt && !(nd->flags & LOOKUP_ROOT)) {
 448                 want_root = 1;
 449                 spin_lock(&fs->lock);
 450                 if (nd->root.mnt != fs->root.mnt ||
 451                                 nd->root.dentry != fs->root.dentry)
 452                         goto err_root;
 453         }
 454         spin_lock(&parent->d_lock);
 455         if (!dentry) {
 456                 if (!__d_rcu_to_refcount(parent, nd->seq))
 457                         goto err_parent;
 458                 BUG_ON(nd->inode != parent->d_inode);
 459         } else {
 460                 if (dentry->d_parent != parent)
 461                         goto err_parent;
 462                 spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
 463                 if (!__d_rcu_to_refcount(dentry, nd->seq))
 464                         goto err_child;
 465                 /*
 466                  * If the sequence check on the child dentry passed, then
 467                  * the child has not been removed from its parent. This
 468                  * means the parent dentry must be valid and able to take
 469                  * a reference at this point.
 470                  */
 471                 BUG_ON(!IS_ROOT(dentry) && dentry->d_parent != parent);
 472                 BUG_ON(!parent->d_count);
 473                 parent->d_count++;
 474                 spin_unlock(&dentry->d_lock);
 475         }
 476         spin_unlock(&parent->d_lock);
 477         if (want_root) {
 478                 path_get(&nd->root);
 479                 spin_unlock(&fs->lock);
 480         }
 481         mntget(nd->path.mnt);
 482
 483         rcu_read_unlock();
 484         br_read_unlock(vfsmount_lock);
 485         nd->flags &= ~LOOKUP_RCU;
 486         return 0;
 487
 488 err_child:
 489         spin_unlock(&dentry->d_lock);
 490 err_parent:
 491         spin_unlock(&parent->d_lock);
 492 err_root:
 493         if (want_root)
 494                 spin_unlock(&fs->lock);
 495         return -ECHILD;
 496 }
 497
 498 /**
 499  * release_open_intent - free up open intent resources
 500  * @nd: pointer to nameidata
 501  */
 502 void release_open_intent(struct nameidata *nd)
 503 {
 504         struct file *file = nd->intent.open.file;
 505
 506         if (file && !IS_ERR(file)) {
 507                 if (file->f_path.dentry == NULL)
 508                         put_filp(file);
 509                 else
 510                         fput(file);
 511         }
 512 }
 513
 514 static inline int d_revalidate(struct dentry *dentry, struct nameidata *nd)
 515 {
 516         return dentry->d_op->d_revalidate(dentry, nd);
 517 }
 518
 519 /**
 520  * complete_walk - successful completion of path walk
 521  * @nd:  pointer nameidata
 522  *
 523  * If we had been in RCU mode, drop out of it and legitimize nd->path.
 524  * Revalidate the final result, unless we'd already done that during
 525  * the path walk or the filesystem doesn't ask for it.  Return 0 on
 526  * success, -error on failure.  In case of failure caller does not
 527  * need to drop nd->path.
 528  */
 529 static int complete_walk(struct nameidata *nd)
 530 {
 531         struct dentry *dentry = nd->path.dentry;
 532         int status;
 533
 534         if (nd->flags & LOOKUP_RCU) {
 535                 nd->flags &= ~LOOKUP_RCU;
 536                 if (!(nd->flags & LOOKUP_ROOT))
 537                         nd->root.mnt = NULL;
 538                 spin_lock(&dentry->d_lock);
 539                 if (unlikely(!__d_rcu_to_refcount(dentry, nd->seq))) {
 540                         spin_unlock(&dentry->d_lock);
 541                         rcu_read_unlock();
 542                         br_read_unlock(vfsmount_lock);
 543                         return -ECHILD;
 544                 }
 545                 BUG_ON(nd->inode != dentry->d_inode);
 546                 spin_unlock(&dentry->d_lock);
 547                 mntget(nd->path.mnt);
 548                 rcu_read_unlock();
 549                 br_read_unlock(vfsmount_lock);
 550         }
 551
 552         if (likely(!(nd->flags & LOOKUP_JUMPED)))
 553                 return 0;
 554
 555         if (likely(!(dentry->d_flags & DCACHE_OP_REVALIDATE)))
 556                 return 0;
 557
 558         if (likely(!(dentry->d_sb->s_type->fs_flags & FS_REVAL_DOT)))
 559                 return 0;
 560
 561         /* Note: we do not d_invalidate() */
 562         status = d_revalidate(dentry, nd);
 563         if (status > 0)
 564                 return 0;
 565
 566         if (!status)
 567                 status = -ESTALE;
 568
 569         path_put(&nd->path);
 570         return status;
 571 }
 572
 573 static __always_inline void set_root(struct nameidata *nd)
 574 {
 575         get_fs_root(current->fs, &nd->root);
 576 }
 577
 578 static int link_path_walk(const char *, struct nameidata *);
 579
 580 static __always_inline unsigned set_root_rcu(struct nameidata *nd)
 581 {
 582         struct fs_struct *fs = current->fs;
 583         unsigned seq, res;
 584
 585         do {
 586                 seq = read_seqcount_begin(&fs->seq);
 587                 nd->root = fs->root;
 588                 res = __read_seqcount_begin(&nd->root.dentry->d_seq);
 589         } while (read_seqcount_retry(&fs->seq, seq));
 590         return res;
 591 }
 592
 593 static __always_inline int __vfs_follow_link(struct nameidata *nd, const char *link)
 594 {
 595         int ret;
 596
 597         if (IS_ERR(link))
 598                 goto fail;
 599
 600         if (*link == '/') {
 601                 if (!nd->root.mnt)
 602                         set_root(nd);
 603                 path_put(&nd->path);
 604                 nd->path = nd->root;
 605                 path_get(&nd->root);
 606                 nd->flags |= LOOKUP_JUMPED;
 607         }
 608         nd->inode = nd->path.dentry->d_inode;
 609
 610         ret = link_path_walk(link, nd);
 611         return ret;
 612 fail:
 613         path_put(&nd->path);
 614         return PTR_ERR(link);
 615 }
 616
 617 static void path_put_conditional(struct path *path, struct nameidata *nd)
 618 {
 619         dput(path->dentry);
 620         if (path->mnt != nd->path.mnt)
 621                 mntput(path->mnt);
 622 }
 623
 624 static inline void path_to_nameidata(const struct path *path,
 625                                         struct nameidata *nd)
 626 {
 627         if (!(nd->flags & LOOKUP_RCU)) {
 628                 dput(nd->path.dentry);
 629                 if (nd->path.mnt != path->mnt)
 630                         mntput(nd->path.mnt);
 631         }
 632         nd->path.mnt = path->mnt;
 633         nd->path.dentry = path->dentry;
 634 }
 635
 636 static inline void put_link(struct nameidata *nd, struct path *link, void *cookie)
 637 {
 638         struct inode *inode = link->dentry->d_inode;
 639         if (!IS_ERR(cookie) && inode->i_op->put_link)
 640                 inode->i_op->put_link(link->dentry, nd, cookie);
 641         path_put(link);
 642 }
 643
 644 static __always_inline int
 645 follow_link(struct path *link, struct nameidata *nd, void **p)
 646 {
 647         int error;
 648         struct dentry *dentry = link->dentry;
 649
 650         BUG_ON(nd->flags & LOOKUP_RCU);
 651
 652         if (link->mnt == nd->path.mnt)
 653                 mntget(link->mnt);
 654
 655         if (unlikely(current->total_link_count >= 40)) {
 656                 *p = ERR_PTR(-ELOOP); /* no ->put_link(), please */
 657                 path_put(&nd->path);
 658                 return -ELOOP;
 659         }
 660         cond_resched();
 661         current->total_link_count++;
 662
 663         touch_atime(link->mnt, dentry);
 664         nd_set_link(nd, NULL);
 665
 666         error = security_inode_follow_link(link->dentry, nd);
 667         if (error) {
 668                 *p = ERR_PTR(error); /* no ->put_link(), please */
 669                 path_put(&nd->path);
 670                 return error;
 671         }
 672
 673         nd->last_type = LAST_BIND;
 674         *p = dentry->d_inode->i_op->follow_link(dentry, nd);
 675         error = PTR_ERR(*p);
 676         if (!IS_ERR(*p)) {
 677                 char *s = nd_get_link(nd);
 678                 error = 0;
 679                 if (s)
 680                         error = __vfs_follow_link(nd, s);
 681                 else if (nd->last_type == LAST_BIND) {
 682                         nd->flags |= LOOKUP_JUMPED;
 683                         nd->inode = nd->path.dentry->d_inode;
 684                         if (nd->inode->i_op->follow_link) {
 685                                 /* stepped on a _really_ weird one */
 686                                 path_put(&nd->path);
 687                                 error = -ELOOP;
 688                         }
 689                 }
 690         }
 691         return error;
 692 }
 693
 694 static int follow_up_rcu(struct path *path)
 695 {
 696         struct vfsmount *parent;
 697         struct dentry *mountpoint;
 698
 699         parent = path->mnt->mnt_parent;
 700         if (parent == path->mnt)
 701                 return 0;
 702         mountpoint = path->mnt->mnt_mountpoint;
 703         path->dentry = mountpoint;
 704         path->mnt = parent;
 705         return 1;
 706 }
 707
 708 int follow_up(struct path *path)
 709 {
 710         struct vfsmount *parent;
 711         struct dentry *mountpoint;
 712
 713         br_read_lock(vfsmount_lock);
 714         parent = path->mnt->mnt_parent;
 715         if (parent == path->mnt) {
 716                 br_read_unlock(vfsmount_lock);
 717                 return 0;
 718         }
 719         mntget(parent);
 720         mountpoint = dget(path->mnt->mnt_mountpoint);
 721         br_read_unlock(vfsmount_lock);
 722         dput(path->dentry);
 723         path->dentry = mountpoint;
 724         mntput(path->mnt);
 725         path->mnt = parent;
 726         return 1;
 727 }
 728
 729 /*
 730  * Perform an automount
 731  * - return -EISDIR to tell follow_managed() to stop and return the path we
 732  *   were called with.
 733  */
 734 static int follow_automount(struct path *path, unsigned flags,
 735                             bool *need_mntput)
 736 {
 737         struct vfsmount *mnt;
 738         int err;
 739
 740         if (!path->dentry->d_op || !path->dentry->d_op->d_automount)
 741                 return -EREMOTE;
 742
 743         /* We don't want to mount if someone's just doing a stat -
 744          * unless they're stat'ing a directory and appended a '/' to
 745          * the name.
 746          *
 747          * We do, however, want to mount if someone wants to open or
 748          * create a file of any type under the mountpoint, wants to
 749          * traverse through the mountpoint or wants to open the
 750          * mounted directory.  Also, autofs may mark negative dentries
 751          * as being automount points.  These will need the attentions
 752          * of the daemon to instantiate them before they can be used.
 753          */
 754         if (!(flags & (LOOKUP_PARENT | LOOKUP_DIRECTORY |
 755                      LOOKUP_OPEN | LOOKUP_CREATE | LOOKUP_AUTOMOUNT)) &&
 756             path->dentry->d_inode)
 757                 return -EISDIR;
 758
 759         current->total_link_count++;
 760         if (current->total_link_count >= 40)
 761                 return -ELOOP;
 762
 763         mnt = path->dentry->d_op->d_automount(path);
 764         if (IS_ERR(mnt)) {
 765                 /*
 766                  * The filesystem is allowed to return -EISDIR here to indicate
 767                  * it doesn't want to automount.  For instance, autofs would do
 768                  * this so that its userspace daemon can mount on this dentry.
 769                  *
 770                  * However, we can only permit this if it's a terminal point in
 771                  * the path being looked up; if it wasn't then the remainder of
 772                  * the path is inaccessible and we should say so.
 773                  */
 774                 if (PTR_ERR(mnt) == -EISDIR && (flags & LOOKUP_PARENT))
 775                         return -EREMOTE;
 776                 return PTR_ERR(mnt);
 777         }
 778
 779         if (!mnt) /* mount collision */
 780                 return 0;
 781
 782         if (!*need_mntput) {
 783                 /* lock_mount() may release path->mnt on error */
 784                 mntget(path->mnt);
 785                 *need_mntput = true;
 786         }
 787         err = finish_automount(mnt, path);
 788
 789         switch (err) {
 790         case -EBUSY:
 791                 /* Someone else made a mount here whilst we were busy */
 792                 return 0;
 793         case 0:
 794                 path_put(path);
 795                 path->mnt = mnt;
 796                 path->dentry = dget(mnt->mnt_root);
 797                 return 0;
 798         default:
 799                 return err;
 800         }
 801
 802 }
 803
 804 /*
 805  * Handle a dentry that is managed in some way.
 806  * - Flagged for transit management (autofs)
 807  * - Flagged as mountpoint
 808  * - Flagged as automount point
 809  *
 810  * This may only be called in refwalk mode.
 811  *
 812  * Serialization is taken care of in namespace.c
 813  */
 814 static int follow_managed(struct path *path, unsigned flags)
 815 {
 816         struct vfsmount *mnt = path->mnt; /* held by caller, must be left alone */
 817         unsigned managed;
 818         bool need_mntput = false;
 819         int ret = 0;
 820
 821         /* Given that we're not holding a lock here, we retain the value in a
 822          * local variable for each dentry as we look at it so that we don't see
 823          * the components of that value change under us */
 824         while (managed = ACCESS_ONCE(path->dentry->d_flags),
 825                managed &= DCACHE_MANAGED_DENTRY,
 826                unlikely(managed != 0)) {
 827                 /* Allow the filesystem to manage the transit without i_mutex
 828                  * being held. */
 829                 if (managed & DCACHE_MANAGE_TRANSIT) {
 830                         BUG_ON(!path->dentry->d_op);
 831                         BUG_ON(!path->dentry->d_op->d_manage);
 832                         ret = path->dentry->d_op->d_manage(path->dentry, false);
 833                         if (ret < 0)
 834                                 break;
 835                 }
 836
 837                 /* Transit to a mounted filesystem. */
 838                 if (managed & DCACHE_MOUNTED) {
 839                         struct vfsmount *mounted = lookup_mnt(path);
 840                         if (mounted) {
 841                                 dput(path->dentry);
 842                                 if (need_mntput)
 843                                         mntput(path->mnt);
 844                                 path->mnt = mounted;
 845                                 path->dentry = dget(mounted->mnt_root);
 846                                 need_mntput = true;
 847                                 continue;
 848                         }
 849
 850                         /* Something is mounted on this dentry in another
 851                          * namespace and/or whatever was mounted there in this
 852                          * namespace got unmounted before we managed to get the
 853                          * vfsmount_lock */
 854                 }
 855
 856                 /* Handle an automount point */
 857                 if (managed & DCACHE_NEED_AUTOMOUNT) {
 858                         ret = follow_automount(path, flags, &need_mntput);
 859                         if (ret < 0)
 860                                 break;
 861                         continue;
 862                 }
 863
 864                 /* We didn't change the current path point */
 865                 break;
 866         }
 867
 868         if (need_mntput && path->mnt == mnt)
 869                 mntput(path->mnt);
 870         if (ret == -EISDIR)
 871                 ret = 0;
 872         return ret < 0 ? ret : need_mntput;
 873 }
 874
 875 int follow_down_one(struct path *path)
 876 {
 877         struct vfsmount *mounted;
 878
 879         mounted = lookup_mnt(path);
 880         if (mounted) {
 881                 dput(path->dentry);
 882                 mntput(path->mnt);
 883                 path->mnt = mounted;
 884                 path->dentry = dget(mounted->mnt_root);
 885                 return 1;
 886         }
 887         return 0;
 888 }
 889
 890 static inline bool managed_dentry_might_block(struct dentry *dentry)
 891 {
 892         return (dentry->d_flags & DCACHE_MANAGE_TRANSIT &&
 893                 dentry->d_op->d_manage(dentry, true) < 0);
 894 }
 895
 896 /*
 897  * Try to skip to top of mountpoint pile in rcuwalk mode.  Fail if
 898  * we meet a managed dentry that would need blocking.
 899  */
 900 static bool __follow_mount_rcu(struct nameidata *nd, struct path *path,
 901                                struct inode **inode)
 902 {
 903         for (;;) {
 904                 struct vfsmount *mounted;
 905                 /*
 906                  * Don't forget we might have a non-mountpoint managed dentry
 907                  * that wants to block transit.
 908                  */
 909                 if (unlikely(managed_dentry_might_block(path->dentry)))
 910                         return false;
 911
 912                 if (!d_mountpoint(path->dentry))
 913                         break;
 914
 915                 mounted = __lookup_mnt(path->mnt, path->dentry, 1);
 916                 if (!mounted)
 917                         break;
 918                 path->mnt = mounted;
 919                 path->dentry = mounted->mnt_root;
 920                 nd->flags |= LOOKUP_JUMPED;
 921                 nd->seq = read_seqcount_begin(&path->dentry->d_seq);
 922                 /*
 923                  * Update the inode too. We don't need to re-check the
 924                  * dentry sequence number here after this d_inode read,
 925                  * because a mount-point is always pinned.
 926                  */
 927                 *inode = path->dentry->d_inode;
 928         }
 929         return true;
 930 }
 931
 932 static int follow_dotdot_rcu(struct nameidata *nd)
 933 {
 934         struct inode *inode = nd->inode;
 935         if (!nd->root.mnt)
 936                 set_root_rcu(nd);
 937
 938         while (1) {
 939                 if (nd->path.dentry == nd->root.dentry &&
 940                     nd->path.mnt == nd->root.mnt) {
 941                         break;
 942                 }
 943                 if (nd->path.dentry != nd->path.mnt->mnt_root) {
 944                         struct dentry *old = nd->path.dentry;
 945                         struct dentry *parent = old->d_parent;
 946                         unsigned seq;
 947
 948                         inode = parent->d_inode;
 949                         seq = read_seqcount_begin(&parent->d_seq);
 950                         if (read_seqcount_retry(&old->d_seq, nd->seq))
 951                                 goto failed;
 952                         nd->path.dentry = parent;
 953                         nd->seq = seq;
 954                         if (unlikely(!path_connected(&nd->path)))
 955                                 goto failed;
 956                         break;
 957                 }
 958                 if (!follow_up_rcu(&nd->path))
 959                         break;
 960                 inode = nd->path.dentry->d_inode;
 961                 nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq);
 962         }
 963         while (d_mountpoint(nd->path.dentry)) {
 964                 struct vfsmount *mounted;
 965                 mounted = __lookup_mnt(nd->path.mnt, nd->path.dentry, 1);
 966                 if (!mounted)
 967                         break;
 968                 nd->path.mnt = mounted;
 969                 nd->path.dentry = mounted->mnt_root;
 970                 inode = nd->path.dentry->d_inode;
 971                 nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq);
 972         }
 973         nd->inode = inode;
 974         return 0;
 975
 976 failed:
 977         nd->flags &= ~LOOKUP_RCU;
 978         if (!(nd->flags & LOOKUP_ROOT))
 979                 nd->root.mnt = NULL;
 980         rcu_read_unlock();
 981         br_read_unlock(vfsmount_lock);
 982         return -ECHILD;
 983 }
 984
 985 /*
 986  * Follow down to the covering mount currently visible to userspace.  At each
 987  * point, the filesystem owning that dentry may be queried as to whether the
 988  * caller is permitted to proceed or not.
 989  */
 990 int follow_down(struct path *path)
 991 {
 992         unsigned managed;
 993         int ret;
 994
 995         while (managed = ACCESS_ONCE(path->dentry->d_flags),
 996                unlikely(managed & DCACHE_MANAGED_DENTRY)) {
 997                 /* Allow the filesystem to manage the transit without i_mutex
 998                  * being held.
 999                  *
1000                  * We indicate to the filesystem if someone is trying to mount
1001                  * something here.  This gives autofs the chance to deny anyone
1002                  * other than its daemon the right to mount on its
1003                  * superstructure.
1004                  *
1005                  * The filesystem may sleep at this point.
1006                  */
1007                 if (managed & DCACHE_MANAGE_TRANSIT) {
1008                         BUG_ON(!path->dentry->d_op);
1009                         BUG_ON(!path->dentry->d_op->d_manage);
1010                         ret = path->dentry->d_op->d_manage(
1011                                 path->dentry, false);
1012                         if (ret < 0)
1013                                 return ret == -EISDIR ? 0 : ret;
1014                 }
1015
1016                 /* Transit to a mounted filesystem. */
1017                 if (managed & DCACHE_MOUNTED) {
1018                         struct vfsmount *mounted = lookup_mnt(path);
1019                         if (!mounted)
1020                                 break;
1021                         dput(path->dentry);
1022                         mntput(path->mnt);
1023                         path->mnt = mounted;
1024                         path->dentry = dget(mounted->mnt_root);
1025                         continue;
1026                 }
1027
1028                 /* Don't handle automount points here */
1029                 break;
1030         }
1031         return 0;
1032 }
1033
1034 /*
1035  * Skip to top of mountpoint pile in refwalk mode for follow_dotdot()
1036  */
1037 static void follow_mount(struct path *path)
1038 {
1039         while (d_mountpoint(path->dentry)) {
1040                 struct vfsmount *mounted = lookup_mnt(path);
1041                 if (!mounted)
1042                         break;
1043                 dput(path->dentry);
1044                 mntput(path->mnt);
1045                 path->mnt = mounted;
1046                 path->dentry = dget(mounted->mnt_root);
1047         }
1048 }
1049
1050 static int follow_dotdot(struct nameidata *nd)
1051 {
1052         if (!nd->root.mnt)
1053                 set_root(nd);
1054
1055         while(1) {
1056                 struct dentry *old = nd->path.dentry;
1057
1058                 if (nd->path.dentry == nd->root.dentry &&
1059                     nd->path.mnt == nd->root.mnt) {
1060                         break;
1061                 }
1062                 if (nd->path.dentry != nd->path.mnt->mnt_root) {
1063                         /* rare case of legitimate dget_parent()... */
1064                         nd->path.dentry = dget_parent(nd->path.dentry);
1065                         dput(old);
1066                         if (unlikely(!path_connected(&nd->path))) {
1067                                 path_put(&nd->path);
1068                                 return -ENOENT;
1069                         }
1070                         break;
1071                 }
1072                 if (!follow_up(&nd->path))
1073                         break;
1074         }
1075         follow_mount(&nd->path);
1076         nd->inode = nd->path.dentry->d_inode;
1077         return 0;
1078 }
1079
1080 /*
1081  * Allocate a dentry with name and parent, and perform a parent
1082  * directory ->lookup on it. Returns the new dentry, or ERR_PTR
1083  * on error. parent->d_inode->i_mutex must be held. d_lookup must
1084  * have verified that no child exists while under i_mutex.
1085  */
1086 static struct dentry *d_alloc_and_lookup(struct dentry *parent,
1087                                 struct qstr *name, struct nameidata *nd)
1088 {
1089         struct inode *inode = parent->d_inode;
1090         struct dentry *dentry;
1091         struct dentry *old;
1092
1093         /* Don't create child dentry for a dead directory. */
1094         if (unlikely(IS_DEADDIR(inode)))
1095                 return ERR_PTR(-ENOENT);
1096
1097         dentry = d_alloc(parent, name);
1098         if (unlikely(!dentry))
1099                 return ERR_PTR(-ENOMEM);
1100
1101         old = inode->i_op->lookup(inode, dentry, nd);
1102         if (unlikely(old)) {
1103                 dput(dentry);
1104                 dentry = old;
1105         }
1106         return dentry;
1107 }
1108
1109 /*
1110  * We already have a dentry, but require a lookup to be performed on the parent
1111  * directory to fill in d_inode. Returns the new dentry, or ERR_PTR on error.
1112  * parent->d_inode->i_mutex must be held. d_lookup must have verified that no
1113  * child exists while under i_mutex.
1114  */
1115 static struct dentry *d_inode_lookup(struct dentry *parent, struct dentry *dentry,
1116                                      struct nameidata *nd)
1117 {
1118         struct inode *inode = parent->d_inode;
1119         struct dentry *old;
1120
1121         /* Don't create child dentry for a dead directory. */
1122         if (unlikely(IS_DEADDIR(inode))) {
1123                 dput(dentry);
1124                 return ERR_PTR(-ENOENT);
1125         }
1126
1127         old = inode->i_op->lookup(inode, dentry, nd);
1128         if (unlikely(old)) {
1129                 dput(dentry);
1130                 dentry = old;
1131         }
1132         return dentry;
1133 }
1134
1135 /*
1136  *  It's more convoluted than I'd like it to be, but... it's still fairly
1137  *  small and for now I'd prefer to have fast path as straight as possible.
1138  *  It _is_ time-critical.
1139  */
1140 static int do_lookup(struct nameidata *nd, struct qstr *name,
1141                         struct path *path, struct inode **inode)
1142 {
1143         struct vfsmount *mnt = nd->path.mnt;
1144         struct dentry *dentry, *parent = nd->path.dentry;
1145         int need_reval = 1;
1146         int status = 1;
1147         int err;
1148
1149         /*
1150          * Rename seqlock is not required here because in the off chance
1151          * of a false negative due to a concurrent rename, we're going to
1152          * do the non-racy lookup, below.
1153          */
1154         if (nd->flags & LOOKUP_RCU) {
1155                 unsigned seq;
1156                 *inode = nd->inode;
1157                 dentry = __d_lookup_rcu(parent, name, &seq, inode);
1158                 if (!dentry)
1159                         goto unlazy;
1160
1161                 /* Memory barrier in read_seqcount_begin of child is enough */
1162                 if (__read_seqcount_retry(&parent->d_seq, nd->seq))
1163                         return -ECHILD;
1164                 nd->seq = seq;
1165
1166                 if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE)) {
1167                         status = d_revalidate(dentry, nd);
1168                         if (unlikely(status <= 0)) {
1169                                 if (status != -ECHILD)
1170                                         need_reval = 0;
1171                                 goto unlazy;
1172                         }
1173                 }
1174                 if (unlikely(d_need_lookup(dentry)))
1175                         goto unlazy;
1176                 path->mnt = mnt;
1177                 path->dentry = dentry;
1178                 if (unlikely(!__follow_mount_rcu(nd, path, inode)))
1179                         goto unlazy;
1180                 if (unlikely(path->dentry->d_flags & DCACHE_NEED_AUTOMOUNT))
1181                         goto unlazy;
1182                 return 0;
1183 unlazy:
1184                 if (unlazy_walk(nd, dentry))
1185                         return -ECHILD;
1186         } else {
1187                 dentry = __d_lookup(parent, name);
1188         }
1189
1190         if (dentry && unlikely(d_need_lookup(dentry))) {
1191                 dput(dentry);
1192                 dentry = NULL;
1193         }
1194 retry:
1195         if (unlikely(!dentry)) {
1196                 struct inode *dir = parent->d_inode;
1197                 BUG_ON(nd->inode != dir);
1198
1199                 mutex_lock(&dir->i_mutex);
1200                 dentry = d_lookup(parent, name);
1201                 if (likely(!dentry)) {
1202                         dentry = d_alloc_and_lookup(parent, name, nd);
1203                         if (IS_ERR(dentry)) {
1204                                 mutex_unlock(&dir->i_mutex);
1205                                 return PTR_ERR(dentry);
1206                         }
1207                         /* known good */
1208                         need_reval = 0;
1209                         status = 1;
1210                 } else if (unlikely(d_need_lookup(dentry))) {
1211                         dentry = d_inode_lookup(parent, dentry, nd);
1212                         if (IS_ERR(dentry)) {
1213                                 mutex_unlock(&dir->i_mutex);
1214                                 return PTR_ERR(dentry);
1215                         }
1216                         /* known good */
1217                         need_reval = 0;
1218                         status = 1;
1219                 }
1220                 mutex_unlock(&dir->i_mutex);
1221         }
1222         if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE) && need_reval)
1223                 status = d_revalidate(dentry, nd);
1224         if (unlikely(status <= 0)) {
1225                 if (status < 0) {
1226                         dput(dentry);
1227                         return status;
1228                 }
1229                 if (!d_invalidate(dentry)) {
1230                         dput(dentry);
1231                         dentry = NULL;
1232                         need_reval = 1;
1233                         goto retry;
1234                 }
1235         }
1236
1237         path->mnt = mnt;
1238         path->dentry = dentry;
1239         err = follow_managed(path, nd->flags);
1240         if (unlikely(err < 0)) {
1241                 path_put_conditional(path, nd);
1242                 return err;
1243         }
1244         if (err)
1245                 nd->flags |= LOOKUP_JUMPED;
1246         *inode = path->dentry->d_inode;
1247         return 0;
1248 }
1249
1250 static inline int may_lookup(struct nameidata *nd)
1251 {
1252         if (nd->flags & LOOKUP_RCU) {
1253                 int err = inode_permission(nd->inode, MAY_EXEC|MAY_NOT_BLOCK);
1254                 if (err != -ECHILD)
1255                         return err;
1256                 if (unlazy_walk(nd, NULL))
1257                         return -ECHILD;
1258         }
1259         return inode_permission(nd->inode, MAY_EXEC);
1260 }
1261
1262 static inline int handle_dots(struct nameidata *nd, int type)
1263 {
1264         if (type == LAST_DOTDOT) {
1265                 if (nd->flags & LOOKUP_RCU) {
1266                         if (follow_dotdot_rcu(nd))
1267                                 return -ECHILD;
1268                 } else
1269                         return follow_dotdot(nd);
1270         }
1271         return 0;
1272 }
1273
1274 static void terminate_walk(struct nameidata *nd)
1275 {
1276         if (!(nd->flags & LOOKUP_RCU)) {
1277                 path_put(&nd->path);
1278         } else {
1279                 nd->flags &= ~LOOKUP_RCU;
1280                 if (!(nd->flags & LOOKUP_ROOT))
1281                         nd->root.mnt = NULL;
1282                 rcu_read_unlock();
1283                 br_read_unlock(vfsmount_lock);
1284         }
1285 }
1286
1287 /*
1288  * Do we need to follow links? We _really_ want to be able
1289  * to do this check without having to look at inode->i_op,
1290  * so we keep a cache of "no, this doesn't need follow_link"
1291  * for the common case.
1292  */
1293 static inline int should_follow_link(struct inode *inode, int follow)
1294 {
1295         if (unlikely(!(inode->i_opflags & IOP_NOFOLLOW))) {
1296                 if (likely(inode->i_op->follow_link))
1297                         return follow;
1298
1299                 /* This gets set once for the inode lifetime */
1300                 spin_lock(&inode->i_lock);
1301                 inode->i_opflags |= IOP_NOFOLLOW;
1302                 spin_unlock(&inode->i_lock);
1303         }
1304         return 0;
1305 }
1306
1307 static inline int walk_component(struct nameidata *nd, struct path *path,
1308                 struct qstr *name, int type, int follow)
1309 {
1310         struct inode *inode;
1311         int err;
1312         /*
1313          * "." and ".." are special - ".." especially so because it has
1314          * to be able to know about the current root directory and
1315          * parent relationships.
1316          */
1317         if (unlikely(type != LAST_NORM))
1318                 return handle_dots(nd, type);
1319         err = do_lookup(nd, name, path, &inode);
1320         if (unlikely(err)) {
1321                 terminate_walk(nd);
1322                 return err;
1323         }
1324         if (!inode) {
1325                 path_to_nameidata(path, nd);
1326                 terminate_walk(nd);
1327                 return -ENOENT;
1328         }
1329         if (should_follow_link(inode, follow)) {
1330                 if (nd->flags & LOOKUP_RCU) {
1331                         if (unlikely(unlazy_walk(nd, path->dentry))) {
1332                                 terminate_walk(nd);
1333                                 return -ECHILD;
1334                         }
1335                 }
1336                 BUG_ON(inode != path->dentry->d_inode);
1337                 return 1;
1338         }
1339         path_to_nameidata(path, nd);
1340         nd->inode = inode;
1341         return 0;
1342 }
1343
1344 /*
1345  * This limits recursive symlink follows to 8, while
1346  * limiting consecutive symlinks to 40.
1347  *
1348  * Without that kind of total limit, nasty chains of consecutive
1349  * symlinks can cause almost arbitrarily long lookups.
1350  */
1351 static inline int nested_symlink(struct path *path, struct nameidata *nd)
1352 {
1353         int res;
1354
1355         if (unlikely(current->link_count >= MAX_NESTED_LINKS)) {
1356                 path_put_conditional(path, nd);
1357                 path_put(&nd->path);
1358                 return -ELOOP;
1359         }
1360         BUG_ON(nd->depth >= MAX_NESTED_LINKS);
1361
1362         nd->depth++;
1363         current->link_count++;
1364
1365         do {
1366                 struct path link = *path;
1367                 void *cookie;
1368
1369                 res = follow_link(&link, nd, &cookie);
1370                 if (!res)
1371                         res = walk_component(nd, path, &nd->last,
1372                                              nd->last_type, LOOKUP_FOLLOW);
1373                 put_link(nd, &link, cookie);
1374         } while (res > 0);
1375
1376         current->link_count--;
1377         nd->depth--;
1378         return res;
1379 }
1380
1381 /*
1382  * We really don't want to look at inode->i_op->lookup
1383  * when we don't have to. So we keep a cache bit in
1384  * the inode ->i_opflags field that says "yes, we can
1385  * do lookup on this inode".
1386  */
1387 static inline int can_lookup(struct inode *inode)
1388 {
1389         if (likely(inode->i_opflags & IOP_LOOKUP))
1390                 return 1;
1391         if (likely(!inode->i_op->lookup))
1392                 return 0;
1393
1394         /* We do this once for the lifetime of the inode */
1395         spin_lock(&inode->i_lock);
1396         inode->i_opflags |= IOP_LOOKUP;
1397         spin_unlock(&inode->i_lock);
1398         return 1;
1399 }
1400
1401 /*
1402  * Name resolution.
1403  * This is the basic name resolution function, turning a pathname into
1404  * the final dentry. We expect 'base' to be positive and a directory.
1405  *
1406  * Returns 0 and nd will have valid dentry and mnt on success.
1407  * Returns error and drops reference to input namei data on failure.
1408  */
1409 static int link_path_walk(const char *name, struct nameidata *nd)
1410 {
1411         struct path next;
1412         int err;
1413
1414         while (*name=='/')
1415                 name++;
1416         if (!*name)
1417                 return 0;
1418
1419         /* At this point we know we have a real path component. */
1420         for(;;) {
1421                 unsigned long hash;
1422                 struct qstr this;
1423                 unsigned int c;
1424                 int type;
1425
1426                 err = may_lookup(nd);
1427                 if (err)
1428                         break;
1429
1430                 this.name = name;
1431                 c = *(const unsigned char *)name;
1432
1433                 hash = init_name_hash();
1434                 do {
1435                         name++;
1436                         hash = partial_name_hash(c, hash);
1437                         c = *(const unsigned char *)name;
1438                 } while (c && (c != '/'));
1439                 this.len = name - (const char *) this.name;
1440                 this.hash = end_name_hash(hash);
1441
1442                 type = LAST_NORM;
1443                 if (this.name[0] == '.') switch (this.len) {
1444                         case 2:
1445                                 if (this.name[1] == '.') {
1446                                         type = LAST_DOTDOT;
1447                                         nd->flags |= LOOKUP_JUMPED;
1448                                 }
1449                                 break;
1450                         case 1:
1451                                 type = LAST_DOT;
1452                 }
1453                 if (likely(type == LAST_NORM)) {
1454                         struct dentry *parent = nd->path.dentry;
1455                         nd->flags &= ~LOOKUP_JUMPED;
1456                         if (unlikely(parent->d_flags & DCACHE_OP_HASH)) {
1457                                 err = parent->d_op->d_hash(parent, nd->inode,
1458                                                            &this);
1459                                 if (err < 0)
1460                                         break;
1461                         }
1462                 }
1463
1464                 /* remove trailing slashes? */
1465                 if (!c)
1466                         goto last_component;
1467                 while (*++name == '/');
1468                 if (!*name)
1469                         goto last_component;
1470
1471                 err = walk_component(nd, &next, &this, type, LOOKUP_FOLLOW);
1472                 if (err < 0)
1473                         return err;
1474
1475                 if (err) {
1476                         err = nested_symlink(&next, nd);
1477                         if (err)
1478                                 return err;
1479                 }
1480                 if (can_lookup(nd->inode))
1481                         continue;
1482                 err = -ENOTDIR;
1483                 break;
1484                 /* here ends the main loop */
1485
1486 last_component:
1487                 nd->last = this;
1488                 nd->last_type = type;
1489                 return 0;
1490         }
1491         terminate_walk(nd);
1492         return err;
1493 }
1494
1495 static int path_init(int dfd, const char *name, unsigned int flags,
1496                      struct nameidata *nd, struct file **fp)
1497 {
1498         int retval = 0;
1499         int fput_needed;
1500         struct file *file;
1501
1502         nd->last_type = LAST_ROOT; /* if there are only slashes... */
1503         nd->flags = flags | LOOKUP_JUMPED;
1504         nd->depth = 0;
1505         if (flags & LOOKUP_ROOT) {
1506                 struct inode *inode = nd->root.dentry->d_inode;
1507                 if (*name) {
1508                         if (!inode->i_op->lookup)
1509                                 return -ENOTDIR;
1510                         retval = inode_permission(inode, MAY_EXEC);
1511                         if (retval)
1512                                 return retval;
1513                 }
1514                 nd->path = nd->root;
1515                 nd->inode = inode;
1516                 if (flags & LOOKUP_RCU) {
1517                         br_read_lock(vfsmount_lock);
1518                         rcu_read_lock();
1519                         nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
1520                 } else {
1521                         path_get(&nd->path);
1522                 }
1523                 return 0;
1524         }
1525
1526         nd->root.mnt = NULL;
1527
1528         if (*name=='/') {
1529                 if (flags & LOOKUP_RCU) {
1530                         br_read_lock(vfsmount_lock);
1531                         rcu_read_lock();
1532                         nd->seq = set_root_rcu(nd);
1533                 } else {
1534                         set_root(nd);
1535                         path_get(&nd->root);
1536                 }
1537                 nd->path = nd->root;
1538         } else if (dfd == AT_FDCWD) {
1539                 if (flags & LOOKUP_RCU) {
1540                         struct fs_struct *fs = current->fs;
1541                         unsigned seq;
1542
1543                         br_read_lock(vfsmount_lock);
1544                         rcu_read_lock();
1545
1546                         do {
1547                                 seq = read_seqcount_begin(&fs->seq);
1548                                 nd->path = fs->pwd;
1549                                 nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
1550                         } while (read_seqcount_retry(&fs->seq, seq));
1551                 } else {
1552                         get_fs_pwd(current->fs, &nd->path);
1553                 }
1554         } else {
1555                 struct dentry *dentry;
1556
1557                 file = fget_raw_light(dfd, &fput_needed);
1558                 retval = -EBADF;
1559                 if (!file)
1560                         goto out_fail;
1561
1562                 dentry = file->f_path.dentry;
1563
1564                 if (*name) {
1565                         retval = -ENOTDIR;
1566                         if (!S_ISDIR(dentry->d_inode->i_mode))
1567                                 goto fput_fail;
1568
1569                         retval = inode_permission(dentry->d_inode, MAY_EXEC);
1570                         if (retval)
1571                                 goto fput_fail;
1572                 }
1573
1574                 nd->path = file->f_path;
1575                 if (flags & LOOKUP_RCU) {
1576                         if (fput_needed)
1577                                 *fp = file;
1578                         nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
1579                         br_read_lock(vfsmount_lock);
1580                         rcu_read_lock();
1581                 } else {
1582                         path_get(&file->f_path);
1583                         fput_light(file, fput_needed);
1584                 }
1585         }
1586
1587         nd->inode = nd->path.dentry->d_inode;
1588         if (!(flags & LOOKUP_RCU))
1589                 return 0;
1590         if (likely(!read_seqcount_retry(&nd->path.dentry->d_seq, nd->seq)))
1591                 return 0;
1592         if (!(nd->flags & LOOKUP_ROOT))
1593                 nd->root.mnt = NULL;
1594         rcu_read_unlock();
1595         br_read_unlock(vfsmount_lock);
1596         return -ECHILD;
1597
1598 fput_fail:
1599         fput_light(file, fput_needed);
1600 out_fail:
1601         return retval;
1602 }
1603
1604 static inline int lookup_last(struct nameidata *nd, struct path *path)
1605 {
1606         if (nd->last_type == LAST_NORM && nd->last.name[nd->last.len])
1607                 nd->flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
1608
1609         nd->flags &= ~LOOKUP_PARENT;
1610         return walk_component(nd, path, &nd->last, nd->last_type,
1611                                         nd->flags & LOOKUP_FOLLOW);
1612 }
1613
1614 /* Returns 0 and nd will be valid on success; Retuns error, otherwise. */
1615 static int path_lookupat(int dfd, const char *name,
1616                                 unsigned int flags, struct nameidata *nd)
1617 {
1618         struct file *base = NULL;
1619         struct path path;
1620         int err;
1621
1622         /*
1623          * Path walking is largely split up into 2 different synchronisation
1624          * schemes, rcu-walk and ref-walk (explained in
1625          * Documentation/filesystems/path-lookup.txt). These share much of the
1626          * path walk code, but some things particularly setup, cleanup, and
1627          * following mounts are sufficiently divergent that functions are
1628          * duplicated. Typically there is a function foo(), and its RCU
1629          * analogue, foo_rcu().
1630          *
1631          * -ECHILD is the error number of choice (just to avoid clashes) that
1632          * is returned if some aspect of an rcu-walk fails. Such an error must
1633          * be handled by restarting a traditional ref-walk (which will always
1634          * be able to complete).
1635          */
1636         err = path_init(dfd, name, flags | LOOKUP_PARENT, nd, &base);
1637
1638         if (unlikely(err))
1639                 return err;
1640
1641         current->total_link_count = 0;
1642         err = link_path_walk(name, nd);
1643
1644         if (!err && !(flags & LOOKUP_PARENT)) {
1645                 err = lookup_last(nd, &path);
1646                 while (err > 0) {
1647                         void *cookie;
1648                         struct path link = path;
1649                         nd->flags |= LOOKUP_PARENT;
1650                         err = follow_link(&link, nd, &cookie);
1651                         if (!err)
1652                                 err = lookup_last(nd, &path);
1653                         put_link(nd, &link, cookie);
1654                 }
1655         }
1656
1657         if (!err)
1658                 err = complete_walk(nd);
1659
1660         if (!err && nd->flags & LOOKUP_DIRECTORY) {
1661                 if (!nd->inode->i_op->lookup) {
1662                         path_put(&nd->path);
1663                         err = -ENOTDIR;
1664                 }
1665         }
1666
1667         if (base)
1668                 fput(base);
1669
1670         if (nd->root.mnt && !(nd->flags & LOOKUP_ROOT)) {
1671                 path_put(&nd->root);
1672                 nd->root.mnt = NULL;
1673         }
1674         return err;
1675 }
1676
1677 static int do_path_lookup(int dfd, const char *name,
1678                                 unsigned int flags, struct nameidata *nd)
1679 {
1680         int retval = path_lookupat(dfd, name, flags | LOOKUP_RCU, nd);
1681         if (unlikely(retval == -ECHILD))
1682                 retval = path_lookupat(dfd, name, flags, nd);
1683         if (unlikely(retval == -ESTALE))
1684                 retval = path_lookupat(dfd, name, flags | LOOKUP_REVAL, nd);
1685
1686         if (likely(!retval)) {
1687                 if (unlikely(!audit_dummy_context())) {
1688                         if (nd->path.dentry && nd->inode)
1689                                 audit_inode(name, nd->path.dentry);
1690                 }
1691         }
1692         return retval;
1693 }
1694
1695 int kern_path_parent(const char *name, struct nameidata *nd)
1696 {
1697         return do_path_lookup(AT_FDCWD, name, LOOKUP_PARENT, nd);
1698 }
1699
1700 int kern_path(const char *name, unsigned int flags, struct path *path)
1701 {
1702         struct nameidata nd;
1703         int res = do_path_lookup(AT_FDCWD, name, flags, &nd);
1704         if (!res)
1705                 *path = nd.path;
1706         return res;
1707 }
1708
1709 /**
1710  * vfs_path_lookup - lookup a file path relative to a dentry-vfsmount pair
1711  * @dentry:  pointer to dentry of the base directory
1712  * @mnt: pointer to vfs mount of the base directory
1713  * @name: pointer to file name
1714  * @flags: lookup flags
1715  * @path: pointer to struct path to fill
1716  */
1717 int vfs_path_lookup(struct dentry *dentry, struct vfsmount *mnt,
1718                     const char *name, unsigned int flags,
1719                     struct path *path)
1720 {
1721         struct nameidata nd;
1722         int err;
1723         nd.root.dentry = dentry;
1724         nd.root.mnt = mnt;
1725         BUG_ON(flags & LOOKUP_PARENT);
1726         /* the first argument of do_path_lookup() is ignored with LOOKUP_ROOT */
1727         err = do_path_lookup(AT_FDCWD, name, flags | LOOKUP_ROOT, &nd);
1728         if (!err)
1729                 *path = nd.path;
1730         return err;
1731 }
1732
1733 static struct dentry *__lookup_hash(struct qstr *name,
1734                 struct dentry *base, struct nameidata *nd)
1735 {
1736         struct inode *inode = base->d_inode;
1737         struct dentry *dentry;
1738         int err;
1739
1740         err = inode_permission(inode, MAY_EXEC);
1741         if (err)
1742                 return ERR_PTR(err);
1743
1744         /*
1745          * Don't bother with __d_lookup: callers are for creat as
1746          * well as unlink, so a lot of the time it would cost
1747          * a double lookup.
1748          */
1749         dentry = d_lookup(base, name);
1750
1751         if (dentry && d_need_lookup(dentry)) {
1752                 /*
1753                  * __lookup_hash is called with the parent dir's i_mutex already
1754                  * held, so we are good to go here.
1755                  */
1756                 dentry = d_inode_lookup(base, dentry, nd);
1757                 if (IS_ERR(dentry))
1758                         return dentry;
1759         }
1760
1761         if (dentry && (dentry->d_flags & DCACHE_OP_REVALIDATE)) {
1762                 int status = d_revalidate(dentry, nd);
1763                 if (unlikely(status <= 0)) {
1764                         /*
1765                          * The dentry failed validation.
1766                          * If d_revalidate returned 0 attempt to invalidate
1767                          * the dentry otherwise d_revalidate is asking us
1768                          * to return a fail status.
1769                          */
1770                         if (status < 0) {
1771                                 dput(dentry);
1772                                 return ERR_PTR(status);
1773                         } else if (!d_invalidate(dentry)) {
1774                                 dput(dentry);
1775                                 dentry = NULL;
1776                         }
1777                 }
1778         }
1779
1780         if (!dentry)
1781                 dentry = d_alloc_and_lookup(base, name, nd);
1782
1783         return dentry;
1784 }
1785
1786 /*
1787  * Restricted form of lookup. Doesn't follow links, single-component only,
1788  * needs parent already locked. Doesn't follow mounts.
1789  * SMP-safe.
1790  */
1791 static struct dentry *lookup_hash(struct nameidata *nd)
1792 {
1793         return __lookup_hash(&nd->last, nd->path.dentry, nd);
1794 }
1795
1796 /**
1797  * lookup_one_len - filesystem helper to lookup single pathname component
1798  * @name:       pathname component to lookup
1799  * @base:       base directory to lookup from
1800  * @len:        maximum length @len should be interpreted to
1801  *
1802  * Note that this routine is purely a helper for filesystem usage and should
1803  * not be called by generic code.  Also note that by using this function the
1804  * nameidata argument is passed to the filesystem methods and a filesystem
1805  * using this helper needs to be prepared for that.
1806  */
1807 struct dentry *lookup_one_len(const char *name, struct dentry *base, int len)
1808 {
1809         struct qstr this;
1810         unsigned long hash;
1811         unsigned int c;
1812
1813         WARN_ON_ONCE(!mutex_is_locked(&base->d_inode->i_mutex));
1814
1815         this.name = name;
1816         this.len = len;
1817         if (!len)
1818                 return ERR_PTR(-EACCES);
1819
1820         hash = init_name_hash();
1821         while (len--) {
1822                 c = *(const unsigned char *)name++;
1823                 if (c == '/' || c == '\0')
1824                         return ERR_PTR(-EACCES);
1825                 hash = partial_name_hash(c, hash);
1826         }
1827         this.hash = end_name_hash(hash);
1828         /*
1829          * See if the low-level filesystem might want
1830          * to use its own hash..
1831          */
1832         if (base->d_flags & DCACHE_OP_HASH) {
1833                 int err = base->d_op->d_hash(base, base->d_inode, &this);
1834                 if (err < 0)
1835                         return ERR_PTR(err);
1836         }
1837
1838         return __lookup_hash(&this, base, NULL);
1839 }
1840
1841 int user_path_at_empty(int dfd, const char __user *name, unsigned flags,
1842                  struct path *path, int *empty)
1843 {
1844         struct nameidata nd;
1845         char *tmp = getname_flags(name, flags, empty);
1846         int err = PTR_ERR(tmp);
1847         if (!IS_ERR(tmp)) {
1848
1849                 BUG_ON(flags & LOOKUP_PARENT);
1850
1851                 err = do_path_lookup(dfd, tmp, flags, &nd);
1852                 putname(tmp);
1853                 if (!err)
1854                         *path = nd.path;
1855         }
1856         return err;
1857 }
1858
1859 int user_path_at(int dfd, const char __user *name, unsigned flags,
1860                  struct path *path)
1861 {
1862         return user_path_at_empty(dfd, name, flags, path, 0);
1863 }
1864
1865 static int user_path_parent(int dfd, const char __user *path,
1866                         struct nameidata *nd, char **name)
1867 {
1868         char *s = getname(path);
1869         int error;
1870
1871         if (IS_ERR(s))
1872                 return PTR_ERR(s);
1873
1874         error = do_path_lookup(dfd, s, LOOKUP_PARENT, nd);
1875         if (error)
1876                 putname(s);
1877         else
1878                 *name = s;
1879
1880         return error;
1881 }
1882
1883 /*
1884  * It's inline, so penalty for filesystems that don't use sticky bit is
1885  * minimal.
1886  */
1887 static inline int check_sticky(struct inode *dir, struct inode *inode)
1888 {
1889         uid_t fsuid = current_fsuid();
1890
1891         if (!(dir->i_mode & S_ISVTX))
1892                 return 0;
1893         if (current_user_ns() != inode_userns(inode))
1894                 goto other_userns;
1895         if (inode->i_uid == fsuid)
1896                 return 0;
1897         if (dir->i_uid == fsuid)
1898                 return 0;
1899
1900 other_userns:
1901         return !ns_capable(inode_userns(inode), CAP_FOWNER);
1902 }
1903
1904 /*
1905  *      Check whether we can remove a link victim from directory dir, check
1906  *  whether the type of victim is right.
1907  *  1. We can't do it if dir is read-only (done in permission())
1908  *  2. We should have write and exec permissions on dir
1909  *  3. We can't remove anything from append-only dir
1910  *  4. We can't do anything with immutable dir (done in permission())
1911  *  5. If the sticky bit on dir is set we should either
1912  *      a. be owner of dir, or
1913  *      b. be owner of victim, or
1914  *      c. have CAP_FOWNER capability
1915  *  6. If the victim is append-only or immutable we can't do antyhing with
1916  *     links pointing to it.
1917  *  7. If we were asked to remove a directory and victim isn't one - ENOTDIR.
1918  *  8. If we were asked to remove a non-directory and victim isn't one - EISDIR.
1919  *  9. We can't remove a root or mountpoint.
1920  * 10. We don't allow removal of NFS sillyrenamed files; it's handled by
1921  *     nfs_async_unlink().
1922  */
1923 static int may_delete(struct inode *dir,struct dentry *victim,int isdir)
1924 {
1925         int error;
1926
1927         if (!victim->d_inode)
1928                 return -ENOENT;
1929
1930         BUG_ON(victim->d_parent->d_inode != dir);
1931         audit_inode_child(victim, dir);
1932
1933         error = inode_permission(dir, MAY_WRITE | MAY_EXEC);
1934         if (error)
1935                 return error;
1936         if (IS_APPEND(dir))
1937                 return -EPERM;
1938         if (check_sticky(dir, victim->d_inode)||IS_APPEND(victim->d_inode)||
1939             IS_IMMUTABLE(victim->d_inode) || IS_SWAPFILE(victim->d_inode))
1940                 return -EPERM;
1941         if (isdir) {
1942                 if (!S_ISDIR(victim->d_inode->i_mode))
1943                         return -ENOTDIR;
1944                 if (IS_ROOT(victim))
1945                         return -EBUSY;
1946         } else if (S_ISDIR(victim->d_inode->i_mode))
1947                 return -EISDIR;
1948         if (IS_DEADDIR(dir))
1949                 return -ENOENT;
1950         if (victim->d_flags & DCACHE_NFSFS_RENAMED)
1951                 return -EBUSY;
1952         return 0;
1953 }
1954
1955 /*      Check whether we can create an object with dentry child in directory
1956  *  dir.
1957  *  1. We can't do it if child already exists (open has special treatment for
1958  *     this case, but since we are inlined it's OK)
1959  *  2. We can't do it if dir is read-only (done in permission())
1960  *  3. We should have write and exec permissions on dir
1961  *  4. We can't do it if dir is immutable (done in permission())
1962  */
1963 static inline int may_create(struct inode *dir, struct dentry *child)
1964 {
1965         if (child->d_inode)
1966                 return -EEXIST;
1967         if (IS_DEADDIR(dir))
1968                 return -ENOENT;
1969         return inode_permission(dir, MAY_WRITE | MAY_EXEC);
1970 }
1971
1972 /*
1973  * p1 and p2 should be directories on the same fs.
1974  */
1975 struct dentry *lock_rename(struct dentry *p1, struct dentry *p2)
1976 {
1977         struct dentry *p;
1978
1979         if (p1 == p2) {
1980                 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
1981                 return NULL;
1982         }
1983
1984         mutex_lock(&p1->d_inode->i_sb->s_vfs_rename_mutex);
1985
1986         p = d_ancestor(p2, p1);
1987         if (p) {
1988                 mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_PARENT);
1989                 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_CHILD);
1990                 return p;
1991         }
1992
1993         p = d_ancestor(p1, p2);
1994         if (p) {
1995                 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
1996                 mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD);
1997                 return p;
1998         }
1999
2000         mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
2001         mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD);
2002         return NULL;
2003 }
2004
2005 void unlock_rename(struct dentry *p1, struct dentry *p2)
2006 {
2007         mutex_unlock(&p1->d_inode->i_mutex);
2008         if (p1 != p2) {
2009                 mutex_unlock(&p2->d_inode->i_mutex);
2010                 mutex_unlock(&p1->d_inode->i_sb->s_vfs_rename_mutex);
2011         }
2012 }
2013
2014 int vfs_create(struct inode *dir, struct dentry *dentry, int mode,
2015                 struct nameidata *nd)
2016 {
2017         int error = may_create(dir, dentry);
2018
2019         if (error)
2020                 return error;
2021
2022         if (!dir->i_op->create)
2023                 return -EACCES; /* shouldn't it be ENOSYS? */
2024         mode &= S_IALLUGO;
2025         mode |= S_IFREG;
2026         error = security_inode_create(dir, dentry, mode);
2027         if (error)
2028                 return error;
2029         error = dir->i_op->create(dir, dentry, mode, nd);
2030         if (!error)
2031                 fsnotify_create(dir, dentry);
2032         return error;
2033 }
2034
2035 static int may_open(struct path *path, int acc_mode, int flag)
2036 {
2037         struct dentry *dentry = path->dentry;
2038         struct inode *inode = dentry->d_inode;
2039         int error;
2040
2041         /* O_PATH? */
2042         if (!acc_mode)
2043                 return 0;
2044
2045         if (!inode)
2046                 return -ENOENT;
2047
2048         switch (inode->i_mode & S_IFMT) {
2049         case S_IFLNK:
2050                 return -ELOOP;
2051         case S_IFDIR:
2052                 if (acc_mode & MAY_WRITE)
2053                         return -EISDIR;
2054                 break;
2055         case S_IFBLK:
2056         case S_IFCHR:
2057                 if (path->mnt->mnt_flags & MNT_NODEV)
2058                         return -EACCES;
2059                 /*FALLTHRU*/
2060         case S_IFIFO:
2061         case S_IFSOCK:
2062                 flag &= ~O_TRUNC;
2063                 break;
2064         }
2065
2066         error = inode_permission(inode, acc_mode);
2067         if (error)
2068                 return error;
2069
2070         /*
2071          * An append-only file must be opened in append mode for writing.
2072          */
2073         if (IS_APPEND(inode)) {
2074                 if  ((flag & O_ACCMODE) != O_RDONLY && !(flag & O_APPEND))
2075                         return -EPERM;
2076                 if (flag & O_TRUNC)
2077                         return -EPERM;
2078         }
2079
2080         /* O_NOATIME can only be set by the owner or superuser */
2081         if (flag & O_NOATIME && !inode_owner_or_capable(inode))
2082                 return -EPERM;
2083
2084         return 0;
2085 }
2086
2087 static int handle_truncate(struct file *filp)
2088 {
2089         struct path *path = &filp->f_path;
2090         struct inode *inode = path->dentry->d_inode;
2091         int error = get_write_access(inode);
2092         if (error)
2093                 return error;
2094         /*
2095          * Refuse to truncate files with mandatory locks held on them.
2096          */
2097         error = locks_verify_locked(inode);
2098         if (!error)
2099                 error = security_path_truncate(path);
2100         if (!error) {
2101                 error = do_truncate(path->dentry, 0,
2102                                     ATTR_MTIME|ATTR_CTIME|ATTR_OPEN,
2103                                     filp);
2104         }
2105         put_write_access(inode);
2106         return error;
2107 }
2108
2109 static inline int open_to_namei_flags(int flag)
2110 {
2111         if ((flag & O_ACCMODE) == 3)
2112                 flag--;
2113         return flag;
2114 }
2115
2116 /*
2117  * Handle the last step of open()
2118  */
2119 static struct file *do_last(struct nameidata *nd, struct path *path,
2120                             const struct open_flags *op, const char *pathname)
2121 {
2122         struct dentry *dir = nd->path.dentry;
2123         struct dentry *dentry;
2124         int open_flag = op->open_flag;
2125         int will_truncate = open_flag & O_TRUNC;
2126         int want_write = 0;
2127         int acc_mode = op->acc_mode;
2128         struct file *filp;
2129         int error;
2130
2131         nd->flags &= ~LOOKUP_PARENT;
2132         nd->flags |= op->intent;
2133
2134         switch (nd->last_type) {
2135         case LAST_DOTDOT:
2136         case LAST_DOT:
2137                 error = handle_dots(nd, nd->last_type);
2138                 if (error)
2139                         return ERR_PTR(error);
2140                 /* fallthrough */
2141         case LAST_ROOT:
2142                 error = complete_walk(nd);
2143                 if (error)
2144                         return ERR_PTR(error);
2145                 audit_inode(pathname, nd->path.dentry);
2146                 if (open_flag & O_CREAT) {
2147                         error = -EISDIR;
2148                         goto exit;
2149                 }
2150                 goto ok;
2151         case LAST_BIND:
2152                 error = complete_walk(nd);
2153                 if (error)
2154                         return ERR_PTR(error);
2155                 audit_inode(pathname, dir);
2156                 goto ok;
2157         }
2158
2159         if (!(open_flag & O_CREAT)) {
2160                 int symlink_ok = 0;
2161                 if (nd->last.name[nd->last.len])
2162                         nd->flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
2163                 if (open_flag & O_PATH && !(nd->flags & LOOKUP_FOLLOW))
2164                         symlink_ok = 1;
2165                 /* we _can_ be in RCU mode here */
2166                 error = walk_component(nd, path, &nd->last, LAST_NORM,
2167                                         !symlink_ok);
2168                 if (error < 0)
2169                         return ERR_PTR(error);
2170                 if (error) /* symlink */
2171                         return NULL;
2172                 /* sayonara */
2173                 error = complete_walk(nd);
2174                 if (error)
2175                         return ERR_PTR(error);
2176
2177                 error = -ENOTDIR;
2178                 if (nd->flags & LOOKUP_DIRECTORY) {
2179                         if (!nd->inode->i_op->lookup)
2180                                 goto exit;
2181                 }
2182                 audit_inode(pathname, nd->path.dentry);
2183                 goto ok;
2184         }
2185
2186         /* create side of things */
2187         /*
2188          * This will *only* deal with leaving RCU mode - LOOKUP_JUMPED has been
2189          * cleared when we got to the last component we are about to look up
2190          */
2191         error = complete_walk(nd);
2192         if (error)
2193                 return ERR_PTR(error);
2194
2195         audit_inode(pathname, dir);
2196         error = -EISDIR;
2197         /* trailing slashes? */
2198         if (nd->last.name[nd->last.len])
2199                 goto exit;
2200
2201         mutex_lock(&dir->d_inode->i_mutex);
2202
2203         dentry = lookup_hash(nd);
2204         error = PTR_ERR(dentry);
2205         if (IS_ERR(dentry)) {
2206                 mutex_unlock(&dir->d_inode->i_mutex);
2207                 goto exit;
2208         }
2209
2210         path->dentry = dentry;
2211         path->mnt = nd->path.mnt;
2212
2213         /* Negative dentry, just create the file */
2214         if (!dentry->d_inode) {
2215                 int mode = op->mode;
2216                 if (!IS_POSIXACL(dir->d_inode))
2217                         mode &= ~current_umask();
2218                 /*
2219                  * This write is needed to ensure that a
2220                  * rw->ro transition does not occur between
2221                  * the time when the file is created and when
2222                  * a permanent write count is taken through
2223                  * the 'struct file' in nameidata_to_filp().
2224                  */
2225                 error = mnt_want_write(nd->path.mnt);
2226                 if (error)
2227                         goto exit_mutex_unlock;
2228                 want_write = 1;
2229                 /* Don't check for write permission, don't truncate */
2230                 open_flag &= ~O_TRUNC;
2231                 will_truncate = 0;
2232                 acc_mode = MAY_OPEN;
2233                 error = security_path_mknod(&nd->path, dentry, mode, 0);
2234                 if (error)
2235                         goto exit_mutex_unlock;
2236                 error = vfs_create(dir->d_inode, dentry, mode, nd);
2237                 if (error)
2238                         goto exit_mutex_unlock;
2239                 mutex_unlock(&dir->d_inode->i_mutex);
2240                 dput(nd->path.dentry);
2241                 nd->path.dentry = dentry;
2242                 goto common;
2243         }
2244
2245         /*
2246          * It already exists.
2247          */
2248         mutex_unlock(&dir->d_inode->i_mutex);
2249         audit_inode(pathname, path->dentry);
2250
2251         error = -EEXIST;
2252         if (open_flag & O_EXCL)
2253                 goto exit_dput;
2254
2255         error = follow_managed(path, nd->flags);
2256         if (error < 0)
2257                 goto exit_dput;
2258
2259         if (error)
2260                 nd->flags |= LOOKUP_JUMPED;
2261
2262         error = -ENOENT;
2263         if (!path->dentry->d_inode)
2264                 goto exit_dput;
2265
2266         if (path->dentry->d_inode->i_op->follow_link)
2267                 return NULL;
2268
2269         path_to_nameidata(path, nd);
2270         nd->inode = path->dentry->d_inode;
2271         /* Why this, you ask?  _Now_ we might have grown LOOKUP_JUMPED... */
2272         error = complete_walk(nd);
2273         if (error)
2274                 return ERR_PTR(error);
2275         error = -EISDIR;
2276         if (S_ISDIR(nd->inode->i_mode))
2277                 goto exit;
2278 ok:
2279         if (!S_ISREG(nd->inode->i_mode))
2280                 will_truncate = 0;
2281
2282         if (will_truncate) {
2283                 error = mnt_want_write(nd->path.mnt);
2284                 if (error)
2285                         goto exit;
2286                 want_write = 1;
2287         }
2288 common:
2289         error = may_open(&nd->path, acc_mode, open_flag);
2290         if (error)
2291                 goto exit;
2292         filp = nameidata_to_filp(nd);
2293         if (!IS_ERR(filp)) {
2294                 error = ima_file_check(filp, op->acc_mode);
2295                 if (error) {
2296                         fput(filp);
2297                         filp = ERR_PTR(error);
2298                 }
2299         }
2300         if (!IS_ERR(filp)) {
2301                 if (will_truncate) {
2302                         error = handle_truncate(filp);
2303                         if (error) {
2304                                 fput(filp);
2305                                 filp = ERR_PTR(error);
2306                         }
2307                 }
2308         }
2309 out:
2310         if (want_write)
2311                 mnt_drop_write(nd->path.mnt);
2312         path_put(&nd->path);
2313         return filp;
2314
2315 exit_mutex_unlock:
2316         mutex_unlock(&dir->d_inode->i_mutex);
2317 exit_dput:
2318         path_put_conditional(path, nd);
2319 exit:
2320         filp = ERR_PTR(error);
2321         goto out;
2322 }
2323
2324 static struct file *path_openat(int dfd, const char *pathname,
2325                 struct nameidata *nd, const struct open_flags *op, int flags)
2326 {
2327         struct file *base = NULL;
2328         struct file *filp;
2329         struct path path;
2330         int error;
2331
2332         filp = get_empty_filp();
2333         if (!filp)
2334                 return ERR_PTR(-ENFILE);
2335
2336         filp->f_flags = op->open_flag;
2337         nd->intent.open.file = filp;
2338         nd->intent.open.flags = open_to_namei_flags(op->open_flag);
2339         nd->intent.open.create_mode = op->mode;
2340
2341         error = path_init(dfd, pathname, flags | LOOKUP_PARENT, nd, &base);
2342         if (unlikely(error))
2343                 goto out_filp;
2344
2345         current->total_link_count = 0;
2346         error = link_path_walk(pathname, nd);
2347         if (unlikely(error))
2348                 goto out_filp;
2349
2350         filp = do_last(nd, &path, op, pathname);
2351         while (unlikely(!filp)) { /* trailing symlink */
2352                 struct path link = path;
2353                 void *cookie;
2354                 if (!(nd->flags & LOOKUP_FOLLOW)) {
2355                         path_put_conditional(&path, nd);
2356                         path_put(&nd->path);
2357                         filp = ERR_PTR(-ELOOP);
2358                         break;
2359                 }
2360                 nd->flags |= LOOKUP_PARENT;
2361                 nd->flags &= ~(LOOKUP_OPEN|LOOKUP_CREATE|LOOKUP_EXCL);
2362                 error = follow_link(&link, nd, &cookie);
2363                 if (unlikely(error))
2364                         filp = ERR_PTR(error);
2365                 else
2366                         filp = do_last(nd, &path, op, pathname);
2367                 put_link(nd, &link, cookie);
2368         }
2369 out:
2370         if (nd->root.mnt && !(nd->flags & LOOKUP_ROOT))
2371                 path_put(&nd->root);
2372         if (base)
2373                 fput(base);
2374         release_open_intent(nd);
2375         return filp;
2376
2377 out_filp:
2378         filp = ERR_PTR(error);
2379         goto out;
2380 }
2381
2382 struct file *do_filp_open(int dfd, const char *pathname,
2383                 const struct open_flags *op, int flags)
2384 {
2385         struct nameidata nd;
2386         struct file *filp;
2387
2388         filp = path_openat(dfd, pathname, &nd, op, flags | LOOKUP_RCU);
2389         if (unlikely(filp == ERR_PTR(-ECHILD)))
2390                 filp = path_openat(dfd, pathname, &nd, op, flags);
2391         if (unlikely(filp == ERR_PTR(-ESTALE)))
2392                 filp = path_openat(dfd, pathname, &nd, op, flags | LOOKUP_REVAL);
2393         return filp;
2394 }
2395
2396 struct file *do_file_open_root(struct dentry *dentry, struct vfsmount *mnt,
2397                 const char *name, const struct open_flags *op, int flags)
2398 {
2399         struct nameidata nd;
2400         struct file *file;
2401
2402         nd.root.mnt = mnt;
2403         nd.root.dentry = dentry;
2404
2405         flags |= LOOKUP_ROOT;
2406
2407         if (dentry->d_inode->i_op->follow_link && op->intent & LOOKUP_OPEN)
2408                 return ERR_PTR(-ELOOP);
2409
2410         file = path_openat(-1, name, &nd, op, flags | LOOKUP_RCU);
2411         if (unlikely(file == ERR_PTR(-ECHILD)))
2412                 file = path_openat(-1, name, &nd, op, flags);
2413         if (unlikely(file == ERR_PTR(-ESTALE)))
2414                 file = path_openat(-1, name, &nd, op, flags | LOOKUP_REVAL);
2415         return file;
2416 }
2417
2418 struct dentry *kern_path_create(int dfd, const char *pathname, struct path *path, int is_dir)
2419 {
2420         struct dentry *dentry = ERR_PTR(-EEXIST);
2421         struct nameidata nd;
2422         int error = do_path_lookup(dfd, pathname, LOOKUP_PARENT, &nd);
2423         if (error)
2424                 return ERR_PTR(error);
2425
2426         /*
2427          * Yucky last component or no last component at all?
2428          * (foo/., foo/.., /////)
2429          */
2430         if (nd.last_type != LAST_NORM)
2431                 goto out;
2432         nd.flags &= ~LOOKUP_PARENT;
2433         nd.flags |= LOOKUP_CREATE | LOOKUP_EXCL;
2434         nd.intent.open.flags = O_EXCL;
2435
2436         /*
2437          * Do the final lookup.
2438          */
2439         mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
2440         dentry = lookup_hash(&nd);
2441         if (IS_ERR(dentry))
2442                 goto fail;
2443
2444         if (dentry->d_inode)
2445                 goto eexist;
2446         /*
2447          * Special case - lookup gave negative, but... we had foo/bar/
2448          * From the vfs_mknod() POV we just have a negative dentry -
2449          * all is fine. Let's be bastards - you had / on the end, you've
2450          * been asking for (non-existent) directory. -ENOENT for you.
2451          */
2452         if (unlikely(!is_dir && nd.last.name[nd.last.len])) {
2453                 dput(dentry);
2454                 dentry = ERR_PTR(-ENOENT);
2455                 goto fail;
2456         }
2457         *path = nd.path;
2458         return dentry;
2459 eexist:
2460         dput(dentry);
2461         dentry = ERR_PTR(-EEXIST);
2462 fail:
2463         mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2464 out:
2465         path_put(&nd.path);
2466         return dentry;
2467 }
2468 EXPORT_SYMBOL(kern_path_create);
2469
2470 struct dentry *user_path_create(int dfd, const char __user *pathname, struct path *path, int is_dir)
2471 {
2472         char *tmp = getname(pathname);
2473         struct dentry *res;
2474         if (IS_ERR(tmp))
2475                 return ERR_CAST(tmp);
2476         res = kern_path_create(dfd, tmp, path, is_dir);
2477         putname(tmp);
2478         return res;
2479 }
2480 EXPORT_SYMBOL(user_path_create);
2481
2482 int vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
2483 {
2484         int error = may_create(dir, dentry);
2485
2486         if (error)
2487                 return error;
2488
2489         if ((S_ISCHR(mode) || S_ISBLK(mode)) &&
2490             !ns_capable(inode_userns(dir), CAP_MKNOD))
2491                 return -EPERM;
2492
2493         if (!dir->i_op->mknod)
2494                 return -EPERM;
2495
2496         error = devcgroup_inode_mknod(mode, dev);
2497         if (error)
2498                 return error;
2499
2500         error = security_inode_mknod(dir, dentry, mode, dev);
2501         if (error)
2502                 return error;
2503
2504         error = dir->i_op->mknod(dir, dentry, mode, dev);
2505         if (!error)
2506                 fsnotify_create(dir, dentry);
2507         return error;
2508 }
2509
2510 static int may_mknod(mode_t mode)
2511 {
2512         switch (mode & S_IFMT) {
2513         case S_IFREG:
2514         case S_IFCHR:
2515         case S_IFBLK:
2516         case S_IFIFO:
2517         case S_IFSOCK:
2518         case 0: /* zero mode translates to S_IFREG */
2519                 return 0;
2520         case S_IFDIR:
2521                 return -EPERM;
2522         default:
2523                 return -EINVAL;
2524         }
2525 }
2526
2527 SYSCALL_DEFINE4(mknodat, int, dfd, const char __user *, filename, int, mode,
2528                 unsigned, dev)
2529 {
2530         struct dentry *dentry;
2531         struct path path;
2532         int error;
2533
2534         if (S_ISDIR(mode))
2535                 return -EPERM;
2536
2537         dentry = user_path_create(dfd, filename, &path, 0);
2538         if (IS_ERR(dentry))
2539                 return PTR_ERR(dentry);
2540
2541         if (!IS_POSIXACL(path.dentry->d_inode))
2542                 mode &= ~current_umask();
2543         error = may_mknod(mode);
2544         if (error)
2545                 goto out_dput;
2546         error = mnt_want_write(path.mnt);
2547         if (error)
2548                 goto out_dput;
2549         error = security_path_mknod(&path, dentry, mode, dev);
2550         if (error)
2551                 goto out_drop_write;
2552         switch (mode & S_IFMT) {
2553                 case 0: case S_IFREG:
2554                         error = vfs_create(path.dentry->d_inode,dentry,mode,NULL);
2555                         break;
2556                 case S_IFCHR: case S_IFBLK:
2557                         error = vfs_mknod(path.dentry->d_inode,dentry,mode,
2558                                         new_decode_dev(dev));
2559                         break;
2560                 case S_IFIFO: case S_IFSOCK:
2561                         error = vfs_mknod(path.dentry->d_inode,dentry,mode,0);
2562                         break;
2563         }
2564 out_drop_write:
2565         mnt_drop_write(path.mnt);
2566 out_dput:
2567         dput(dentry);
2568         mutex_unlock(&path.dentry->d_inode->i_mutex);
2569         path_put(&path);
2570
2571         return error;
2572 }
2573
2574 SYSCALL_DEFINE3(mknod, const char __user *, filename, int, mode, unsigned, dev)
2575 {
2576         return sys_mknodat(AT_FDCWD, filename, mode, dev);
2577 }
2578
2579 int vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
2580 {
2581         int error = may_create(dir, dentry);
2582
2583         if (error)
2584                 return error;
2585
2586         if (!dir->i_op->mkdir)
2587                 return -EPERM;
2588
2589         mode &= (S_IRWXUGO|S_ISVTX);
2590         error = security_inode_mkdir(dir, dentry, mode);
2591         if (error)
2592                 return error;
2593
2594         error = dir->i_op->mkdir(dir, dentry, mode);
2595         if (!error)
2596                 fsnotify_mkdir(dir, dentry);
2597         return error;
2598 }
2599
2600 SYSCALL_DEFINE3(mkdirat, int, dfd, const char __user *, pathname, int, mode)
2601 {
2602         struct dentry *dentry;
2603         struct path path;
2604         int error;
2605
2606         dentry = user_path_create(dfd, pathname, &path, 1);
2607         if (IS_ERR(dentry))
2608                 return PTR_ERR(dentry);
2609
2610         if (!IS_POSIXACL(path.dentry->d_inode))
2611                 mode &= ~current_umask();
2612         error = mnt_want_write(path.mnt);
2613         if (error)
2614                 goto out_dput;
2615         error = security_path_mkdir(&path, dentry, mode);
2616         if (error)
2617                 goto out_drop_write;
2618         error = vfs_mkdir(path.dentry->d_inode, dentry, mode);
2619 out_drop_write:
2620         mnt_drop_write(path.mnt);
2621 out_dput:
2622         dput(dentry);
2623         mutex_unlock(&path.dentry->d_inode->i_mutex);
2624         path_put(&path);
2625         return error;
2626 }
2627
2628 SYSCALL_DEFINE2(mkdir, const char __user *, pathname, int, mode)
2629 {
2630         return sys_mkdirat(AT_FDCWD, pathname, mode);
2631 }
2632
2633 /*
2634  * The dentry_unhash() helper will try to drop the dentry early: we
2635  * should have a usage count of 2 if we're the only user of this
2636  * dentry, and if that is true (possibly after pruning the dcache),
2637  * then we drop the dentry now.
2638  *
2639  * A low-level filesystem can, if it choses, legally
2640  * do a
2641  *
2642  *      if (!d_unhashed(dentry))
2643  *              return -EBUSY;
2644  *
2645  * if it cannot handle the case of removing a directory
2646  * that is still in use by something else..
2647  */
2648 void dentry_unhash(struct dentry *dentry)
2649 {
2650         shrink_dcache_parent(dentry);
2651         spin_lock(&dentry->d_lock);
2652         if (dentry->d_count == 1)
2653                 __d_drop(dentry);
2654         spin_unlock(&dentry->d_lock);
2655 }
2656
2657 int vfs_rmdir(struct inode *dir, struct dentry *dentry)
2658 {
2659         int error = may_delete(dir, dentry, 1);
2660
2661         if (error)
2662                 return error;
2663
2664         if (!dir->i_op->rmdir)
2665                 return -EPERM;
2666
2667         dget(dentry);
2668         mutex_lock(&dentry->d_inode->i_mutex);
2669
2670         error = -EBUSY;
2671         if (d_mountpoint(dentry))
2672                 goto out;
2673
2674         error = security_inode_rmdir(dir, dentry);
2675         if (error)
2676                 goto out;
2677
2678         shrink_dcache_parent(dentry);
2679         error = dir->i_op->rmdir(dir, dentry);
2680         if (error)
2681                 goto out;
2682
2683         dentry->d_inode->i_flags |= S_DEAD;
2684         dont_mount(dentry);
2685
2686 out:
2687         mutex_unlock(&dentry->d_inode->i_mutex);
2688         dput(dentry);
2689         if (!error)
2690                 d_delete(dentry);
2691         return error;
2692 }
2693
2694 static long do_rmdir(int dfd, const char __user *pathname)
2695 {
2696         int error = 0;
2697         char * name;
2698         struct dentry *dentry;
2699         struct nameidata nd;
2700
2701         error = user_path_parent(dfd, pathname, &nd, &name);
2702         if (error)
2703                 return error;
2704
2705         switch(nd.last_type) {
2706         case LAST_DOTDOT:
2707                 error = -ENOTEMPTY;
2708                 goto exit1;
2709         case LAST_DOT:
2710                 error = -EINVAL;
2711                 goto exit1;
2712         case LAST_ROOT:
2713                 error = -EBUSY;
2714                 goto exit1;
2715         }
2716
2717         nd.flags &= ~LOOKUP_PARENT;
2718
2719         mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
2720         dentry = lookup_hash(&nd);
2721         error = PTR_ERR(dentry);
2722         if (IS_ERR(dentry))
2723                 goto exit2;
2724         if (!dentry->d_inode) {
2725                 error = -ENOENT;
2726                 goto exit3;
2727         }
2728         error = mnt_want_write(nd.path.mnt);
2729         if (error)
2730                 goto exit3;
2731         error = security_path_rmdir(&nd.path, dentry);
2732         if (error)
2733                 goto exit4;
2734         error = vfs_rmdir(nd.path.dentry->d_inode, dentry);
2735 exit4:
2736         mnt_drop_write(nd.path.mnt);
2737 exit3:
2738         dput(dentry);
2739 exit2:
2740         mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2741 exit1:
2742         path_put(&nd.path);
2743         putname(name);
2744         return error;
2745 }
2746
2747 SYSCALL_DEFINE1(rmdir, const char __user *, pathname)
2748 {
2749         return do_rmdir(AT_FDCWD, pathname);
2750 }
2751
2752 int vfs_unlink(struct inode *dir, struct dentry *dentry)
2753 {
2754         int error = may_delete(dir, dentry, 0);
2755
2756         if (error)
2757                 return error;
2758
2759         if (!dir->i_op->unlink)
2760                 return -EPERM;
2761
2762         mutex_lock(&dentry->d_inode->i_mutex);
2763         if (d_mountpoint(dentry))
2764                 error = -EBUSY;
2765         else {
2766                 error = security_inode_unlink(dir, dentry);
2767                 if (!error) {
2768                         error = dir->i_op->unlink(dir, dentry);
2769                         if (!error)
2770                                 dont_mount(dentry);
2771                 }
2772         }
2773         mutex_unlock(&dentry->d_inode->i_mutex);
2774
2775         /* We don't d_delete() NFS sillyrenamed files--they still exist. */
2776         if (!error && !(dentry->d_flags & DCACHE_NFSFS_RENAMED)) {
2777                 fsnotify_link_count(dentry->d_inode);
2778                 d_delete(dentry);
2779         }
2780
2781         return error;
2782 }
2783
2784 /*
2785  * Make sure that the actual truncation of the file will occur outside its
2786  * directory's i_mutex.  Truncate can take a long time if there is a lot of
2787  * writeout happening, and we don't want to prevent access to the directory
2788  * while waiting on the I/O.
2789  */
2790 static long do_unlinkat(int dfd, const char __user *pathname)
2791 {
2792         int error;
2793         char *name;
2794         struct dentry *dentry;
2795         struct nameidata nd;
2796         struct inode *inode = NULL;
2797
2798         error = user_path_parent(dfd, pathname, &nd, &name);
2799         if (error)
2800                 return error;
2801
2802         error = -EISDIR;
2803         if (nd.last_type != LAST_NORM)
2804                 goto exit1;
2805
2806         nd.flags &= ~LOOKUP_PARENT;
2807
2808         mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
2809         dentry = lookup_hash(&nd);
2810         error = PTR_ERR(dentry);
2811         if (!IS_ERR(dentry)) {
2812                 /* Why not before? Because we want correct error value */
2813                 if (nd.last.name[nd.last.len])
2814                         goto slashes;
2815                 inode = dentry->d_inode;
2816                 if (!inode)
2817                         goto slashes;
2818                 ihold(inode);
2819                 error = mnt_want_write(nd.path.mnt);
2820                 if (error)
2821                         goto exit2;
2822                 error = security_path_unlink(&nd.path, dentry);
2823                 if (error)
2824                         goto exit3;
2825                 error = vfs_unlink(nd.path.dentry->d_inode, dentry);
2826 exit3:
2827                 mnt_drop_write(nd.path.mnt);
2828         exit2:
2829                 dput(dentry);
2830         }
2831         mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2832         if (inode)
2833                 iput(inode);    /* truncate the inode here */
2834 exit1:
2835         path_put(&nd.path);
2836         putname(name);
2837         return error;
2838
2839 slashes:
2840         error = !dentry->d_inode ? -ENOENT :
2841                 S_ISDIR(dentry->d_inode->i_mode) ? -EISDIR : -ENOTDIR;
2842         goto exit2;
2843 }
2844
2845 SYSCALL_DEFINE3(unlinkat, int, dfd, const char __user *, pathname, int, flag)
2846 {
2847         if ((flag & ~AT_REMOVEDIR) != 0)
2848                 return -EINVAL;
2849
2850         if (flag & AT_REMOVEDIR)
2851                 return do_rmdir(dfd, pathname);
2852
2853         return do_unlinkat(dfd, pathname);
2854 }
2855
2856 SYSCALL_DEFINE1(unlink, const char __user *, pathname)
2857 {
2858         return do_unlinkat(AT_FDCWD, pathname);
2859 }
2860
2861 int vfs_symlink(struct inode *dir, struct dentry *dentry, const char *oldname)
2862 {
2863         int error = may_create(dir, dentry);
2864
2865         if (error)
2866                 return error;
2867
2868         if (!dir->i_op->symlink)
2869                 return -EPERM;
2870
2871         error = security_inode_symlink(dir, dentry, oldname);
2872         if (error)
2873                 return error;
2874
2875         error = dir->i_op->symlink(dir, dentry, oldname);
2876         if (!error)
2877                 fsnotify_create(dir, dentry);
2878         return error;
2879 }
2880
2881 SYSCALL_DEFINE3(symlinkat, const char __user *, oldname,
2882                 int, newdfd, const char __user *, newname)
2883 {
2884         int error;
2885         char *from;
2886         struct dentry *dentry;
2887         struct path path;
2888
2889         from = getname(oldname);
2890         if (IS_ERR(from))
2891                 return PTR_ERR(from);
2892
2893         dentry = user_path_create(newdfd, newname, &path, 0);
2894         error = PTR_ERR(dentry);
2895         if (IS_ERR(dentry))
2896                 goto out_putname;
2897
2898         error = mnt_want_write(path.mnt);
2899         if (error)
2900                 goto out_dput;
2901         error = security_path_symlink(&path, dentry, from);
2902         if (error)
2903                 goto out_drop_write;
2904         error = vfs_symlink(path.dentry->d_inode, dentry, from);
2905 out_drop_write:
2906         mnt_drop_write(path.mnt);
2907 out_dput:
2908         dput(dentry);
2909         mutex_unlock(&path.dentry->d_inode->i_mutex);
2910         path_put(&path);
2911 out_putname:
2912         putname(from);
2913         return error;
2914 }
2915
2916 SYSCALL_DEFINE2(symlink, const char __user *, oldname, const char __user *, newname)
2917 {
2918         return sys_symlinkat(oldname, AT_FDCWD, newname);
2919 }
2920
2921 int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry)
2922 {
2923         struct inode *inode = old_dentry->d_inode;
2924         int error;
2925
2926         if (!inode)
2927                 return -ENOENT;
2928
2929         error = may_create(dir, new_dentry);
2930         if (error)
2931                 return error;
2932
2933         if (dir->i_sb != inode->i_sb)
2934                 return -EXDEV;
2935
2936         /*
2937          * A link to an append-only or immutable file cannot be created.
2938          */
2939         if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
2940                 return -EPERM;
2941         if (!dir->i_op->link)
2942                 return -EPERM;
2943         if (S_ISDIR(inode->i_mode))
2944                 return -EPERM;
2945
2946         error = security_inode_link(old_dentry, dir, new_dentry);
2947         if (error)
2948                 return error;
2949
2950         mutex_lock(&inode->i_mutex);
2951         /* Make sure we don't allow creating hardlink to an unlinked file */
2952         if (inode->i_nlink == 0)
2953                 error =  -ENOENT;
2954         else
2955                 error = dir->i_op->link(old_dentry, dir, new_dentry);
2956         mutex_unlock(&inode->i_mutex);
2957         if (!error)
2958                 fsnotify_link(dir, inode, new_dentry);
2959         return error;
2960 }
2961
2962 /*
2963  * Hardlinks are often used in delicate situations.  We avoid
2964  * security-related surprises by not following symlinks on the
2965  * newname.  --KAB
2966  *
2967  * We don't follow them on the oldname either to be compatible
2968  * with linux 2.0, and to avoid hard-linking to directories
2969  * and other special files.  --ADM
2970  */
2971 SYSCALL_DEFINE5(linkat, int, olddfd, const char __user *, oldname,
2972                 int, newdfd, const char __user *, newname, int, flags)
2973 {
2974         struct dentry *new_dentry;
2975         struct path old_path, new_path;
2976         int how = 0;
2977         int error;
2978
2979         if ((flags & ~(AT_SYMLINK_FOLLOW | AT_EMPTY_PATH)) != 0)
2980                 return -EINVAL;
2981         /*
2982          * To use null names we require CAP_DAC_READ_SEARCH
2983          * This ensures that not everyone will be able to create
2984          * handlink using the passed filedescriptor.
2985          */
2986         if (flags & AT_EMPTY_PATH) {
2987                 if (!capable(CAP_DAC_READ_SEARCH))
2988                         return -ENOENT;
2989                 how = LOOKUP_EMPTY;
2990         }
2991
2992         if (flags & AT_SYMLINK_FOLLOW)
2993                 how |= LOOKUP_FOLLOW;
2994
2995         error = user_path_at(olddfd, oldname, how, &old_path);
2996         if (error)
2997                 return error;
2998
2999         new_dentry = user_path_create(newdfd, newname, &new_path, 0);
3000         error = PTR_ERR(new_dentry);
3001         if (IS_ERR(new_dentry))
3002                 goto out;
3003
3004         error = -EXDEV;
3005         if (old_path.mnt != new_path.mnt)
3006                 goto out_dput;
3007         error = mnt_want_write(new_path.mnt);
3008         if (error)
3009                 goto out_dput;
3010         error = security_path_link(old_path.dentry, &new_path, new_dentry);
3011         if (error)
3012                 goto out_drop_write;
3013         error = vfs_link(old_path.dentry, new_path.dentry->d_inode, new_dentry);
3014 out_drop_write:
3015         mnt_drop_write(new_path.mnt);
3016 out_dput:
3017         dput(new_dentry);
3018         mutex_unlock(&new_path.dentry->d_inode->i_mutex);
3019         path_put(&new_path);
3020 out:
3021         path_put(&old_path);
3022
3023         return error;
3024 }
3025
3026 SYSCALL_DEFINE2(link, const char __user *, oldname, const char __user *, newname)
3027 {
3028         return sys_linkat(AT_FDCWD, oldname, AT_FDCWD, newname, 0);
3029 }
3030
3031 /*
3032  * The worst of all namespace operations - renaming directory. "Perverted"
3033  * doesn't even start to describe it. Somebody in UCB had a heck of a trip...
3034  * Problems:
3035  *      a) we can get into loop creation. Check is done in is_subdir().
3036  *      b) race potential - two innocent renames can create a loop together.
3037  *         That's where 4.4 screws up. Current fix: serialization on
3038  *         sb->s_vfs_rename_mutex. We might be more accurate, but that's another
3039  *         story.
3040  *      c) we have to lock _three_ objects - parents and victim (if it exists).
3041  *         And that - after we got ->i_mutex on parents (until then we don't know
3042  *         whether the target exists).  Solution: try to be smart with locking
3043  *         order for inodes.  We rely on the fact that tree topology may change
3044  *         only under ->s_vfs_rename_mutex _and_ that parent of the object we
3045  *         move will be locked.  Thus we can rank directories by the tree
3046  *         (ancestors first) and rank all non-directories after them.
3047  *         That works since everybody except rename does "lock parent, lookup,
3048  *         lock child" and rename is under ->s_vfs_rename_mutex.
3049  *         HOWEVER, it relies on the assumption that any object with ->lookup()
3050  *         has no more than 1 dentry.  If "hybrid" objects will ever appear,
3051  *         we'd better make sure that there's no link(2) for them.
3052  *      d) conversion from fhandle to dentry may come in the wrong moment - when
3053  *         we are removing the target. Solution: we will have to grab ->i_mutex
3054  *         in the fhandle_to_dentry code. [FIXME - current nfsfh.c relies on
3055  *         ->i_mutex on parents, which works but leads to some truly excessive
3056  *         locking].
3057  */
3058 static int vfs_rename_dir(struct inode *old_dir, struct dentry *old_dentry,
3059                           struct inode *new_dir, struct dentry *new_dentry)
3060 {
3061         int error = 0;
3062         struct inode *target = new_dentry->d_inode;
3063
3064         /*
3065          * If we are going to change the parent - check write permissions,
3066          * we'll need to flip '..'.
3067          */
3068         if (new_dir != old_dir) {
3069                 error = inode_permission(old_dentry->d_inode, MAY_WRITE);
3070                 if (error)
3071                         return error;
3072         }
3073
3074         error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry);
3075         if (error)
3076                 return error;
3077
3078         dget(new_dentry);
3079         if (target)
3080                 mutex_lock(&target->i_mutex);
3081
3082         error = -EBUSY;
3083         if (d_mountpoint(old_dentry) || d_mountpoint(new_dentry))
3084                 goto out;
3085
3086         if (target)
3087                 shrink_dcache_parent(new_dentry);
3088         error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
3089         if (error)
3090                 goto out;
3091
3092         if (target) {
3093                 target->i_flags |= S_DEAD;
3094                 dont_mount(new_dentry);
3095         }
3096 out:
3097         if (target)
3098                 mutex_unlock(&target->i_mutex);
3099         dput(new_dentry);
3100         if (!error)
3101                 if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
3102                         d_move(old_dentry,new_dentry);
3103         return error;
3104 }
3105
3106 static int vfs_rename_other(struct inode *old_dir, struct dentry *old_dentry,
3107                             struct inode *new_dir, struct dentry *new_dentry)
3108 {
3109         struct inode *target = new_dentry->d_inode;
3110         int error;
3111
3112         error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry);
3113         if (error)
3114                 return error;
3115
3116         dget(new_dentry);
3117         if (target)
3118                 mutex_lock(&target->i_mutex);
3119
3120         error = -EBUSY;
3121         if (d_mountpoint(old_dentry)||d_mountpoint(new_dentry))
3122                 goto out;
3123
3124         error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
3125         if (error)
3126                 goto out;
3127
3128         if (target)
3129                 dont_mount(new_dentry);
3130         if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
3131                 d_move(old_dentry, new_dentry);
3132 out:
3133         if (target)
3134                 mutex_unlock(&target->i_mutex);
3135         dput(new_dentry);
3136         return error;
3137 }
3138
3139 int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
3140                struct inode *new_dir, struct dentry *new_dentry)
3141 {
3142         int error;
3143         int is_dir = S_ISDIR(old_dentry->d_inode->i_mode);
3144         const unsigned char *old_name;
3145
3146         if (old_dentry->d_inode == new_dentry->d_inode)
3147                 return 0;
3148
3149         error = may_delete(old_dir, old_dentry, is_dir);
3150         if (error)
3151                 return error;
3152
3153         if (!new_dentry->d_inode)
3154                 error = may_create(new_dir, new_dentry);
3155         else
3156                 error = may_delete(new_dir, new_dentry, is_dir);
3157         if (error)
3158                 return error;
3159
3160         if (!old_dir->i_op->rename)
3161                 return -EPERM;
3162
3163         old_name = fsnotify_oldname_init(old_dentry->d_name.name);
3164
3165         if (is_dir)
3166                 error = vfs_rename_dir(old_dir,old_dentry,new_dir,new_dentry);
3167         else
3168                 error = vfs_rename_other(old_dir,old_dentry,new_dir,new_dentry);
3169         if (!error)
3170                 fsnotify_move(old_dir, new_dir, old_name, is_dir,
3171                               new_dentry->d_inode, old_dentry);
3172         fsnotify_oldname_free(old_name);
3173
3174         return error;
3175 }
3176
3177 SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname,
3178                 int, newdfd, const char __user *, newname)
3179 {
3180         struct dentry *old_dir, *new_dir;
3181         struct dentry *old_dentry, *new_dentry;
3182         struct dentry *trap;
3183         struct nameidata oldnd, newnd;
3184         char *from;
3185         char *to;
3186         int error;
3187
3188         error = user_path_parent(olddfd, oldname, &oldnd, &from);
3189         if (error)
3190                 goto exit;
3191
3192         error = user_path_parent(newdfd, newname, &newnd, &to);
3193         if (error)
3194                 goto exit1;
3195
3196         error = -EXDEV;
3197         if (oldnd.path.mnt != newnd.path.mnt)
3198                 goto exit2;
3199
3200         old_dir = oldnd.path.dentry;
3201         error = -EBUSY;
3202         if (oldnd.last_type != LAST_NORM)
3203                 goto exit2;
3204
3205         new_dir = newnd.path.dentry;
3206         if (newnd.last_type != LAST_NORM)
3207                 goto exit2;
3208
3209         oldnd.flags &= ~LOOKUP_PARENT;
3210         newnd.flags &= ~LOOKUP_PARENT;
3211         newnd.flags |= LOOKUP_RENAME_TARGET;
3212
3213         trap = lock_rename(new_dir, old_dir);
3214
3215         old_dentry = lookup_hash(&oldnd);
3216         error = PTR_ERR(old_dentry);
3217         if (IS_ERR(old_dentry))
3218                 goto exit3;
3219         /* source must exist */
3220         error = -ENOENT;
3221         if (!old_dentry->d_inode)
3222                 goto exit4;
3223         /* unless the source is a directory trailing slashes give -ENOTDIR */
3224         if (!S_ISDIR(old_dentry->d_inode->i_mode)) {
3225                 error = -ENOTDIR;
3226                 if (oldnd.last.name[oldnd.last.len])
3227                         goto exit4;
3228                 if (newnd.last.name[newnd.last.len])
3229                         goto exit4;
3230         }
3231         /* source should not be ancestor of target */
3232         error = -EINVAL;
3233         if (old_dentry == trap)
3234                 goto exit4;
3235         new_dentry = lookup_hash(&newnd);
3236         error = PTR_ERR(new_dentry);
3237         if (IS_ERR(new_dentry))
3238                 goto exit4;
3239         /* target should not be an ancestor of source */
3240         error = -ENOTEMPTY;
3241         if (new_dentry == trap)
3242                 goto exit5;
3243
3244         error = mnt_want_write(oldnd.path.mnt);
3245         if (error)
3246                 goto exit5;
3247         error = security_path_rename(&oldnd.path, old_dentry,
3248                                      &newnd.path, new_dentry);
3249         if (error)
3250                 goto exit6;
3251         error = vfs_rename(old_dir->d_inode, old_dentry,
3252                                    new_dir->d_inode, new_dentry);
3253 exit6:
3254         mnt_drop_write(oldnd.path.mnt);
3255 exit5:
3256         dput(new_dentry);
3257 exit4:
3258         dput(old_dentry);
3259 exit3:
3260         unlock_rename(new_dir, old_dir);
3261 exit2:
3262         path_put(&newnd.path);
3263         putname(to);
3264 exit1:
3265         path_put(&oldnd.path);
3266         putname(from);
3267 exit:
3268         return error;
3269 }
3270
3271 SYSCALL_DEFINE2(rename, const char __user *, oldname, const char __user *, newname)
3272 {
3273         return sys_renameat(AT_FDCWD, oldname, AT_FDCWD, newname);
3274 }
3275
3276 int vfs_readlink(struct dentry *dentry, char __user *buffer, int buflen, const char *link)
3277 {
3278         int len;
3279
3280         len = PTR_ERR(link);
3281         if (IS_ERR(link))
3282                 goto out;
3283
3284         len = strlen(link);
3285         if (len > (unsigned) buflen)
3286                 len = buflen;
3287         if (copy_to_user(buffer, link, len))
3288                 len = -EFAULT;
3289 out:
3290         return len;
3291 }
3292
3293 /*
3294  * A helper for ->readlink().  This should be used *ONLY* for symlinks that
3295  * have ->follow_link() touching nd only in nd_set_link().  Using (or not
3296  * using) it for any given inode is up to filesystem.
3297  */
3298 int generic_readlink(struct dentry *dentry, char __user *buffer, int buflen)
3299 {
3300         struct nameidata nd;
3301         void *cookie;
3302         int res;
3303
3304         nd.depth = 0;
3305         cookie = dentry->d_inode->i_op->follow_link(dentry, &nd);
3306         if (IS_ERR(cookie))
3307                 return PTR_ERR(cookie);
3308
3309         res = vfs_readlink(dentry, buffer, buflen, nd_get_link(&nd));
3310         if (dentry->d_inode->i_op->put_link)
3311                 dentry->d_inode->i_op->put_link(dentry, &nd, cookie);
3312         return res;
3313 }
3314
3315 int vfs_follow_link(struct nameidata *nd, const char *link)
3316 {
3317         return __vfs_follow_link(nd, link);
3318 }
3319
3320 /* get the link contents into pagecache */
3321 static char *page_getlink(struct dentry * dentry, struct page **ppage)
3322 {
3323         char *kaddr;
3324         struct page *page;
3325         struct address_space *mapping = dentry->d_inode->i_mapping;
3326         page = read_mapping_page(mapping, 0, NULL);
3327         if (IS_ERR(page))
3328                 return (char*)page;
3329         *ppage = page;
3330         kaddr = kmap(page);
3331         nd_terminate_link(kaddr, dentry->d_inode->i_size, PAGE_SIZE - 1);
3332         return kaddr;
3333 }
3334
3335 int page_readlink(struct dentry *dentry, char __user *buffer, int buflen)
3336 {
3337         struct page *page = NULL;
3338         char *s = page_getlink(dentry, &page);
3339         int res = vfs_readlink(dentry,buffer,buflen,s);
3340         if (page) {
3341                 kunmap(page);
3342                 page_cache_release(page);
3343         }
3344         return res;
3345 }
3346
3347 void *page_follow_link_light(struct dentry *dentry, struct nameidata *nd)
3348 {
3349         struct page *page = NULL;
3350         nd_set_link(nd, page_getlink(dentry, &page));
3351         return page;
3352 }
3353
3354 void page_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie)
3355 {
3356         struct page *page = cookie;
3357
3358         if (page) {
3359                 kunmap(page);
3360                 page_cache_release(page);
3361         }
3362 }
3363
3364 /*
3365  * The nofs argument instructs pagecache_write_begin to pass AOP_FLAG_NOFS
3366  */
3367 int __page_symlink(struct inode *inode, const char *symname, int len, int nofs)
3368 {
3369         struct address_space *mapping = inode->i_mapping;
3370         struct page *page;
3371         void *fsdata;
3372         int err;
3373         char *kaddr;
3374         unsigned int flags = AOP_FLAG_UNINTERRUPTIBLE;
3375         if (nofs)
3376                 flags |= AOP_FLAG_NOFS;
3377
3378 retry:
3379         err = pagecache_write_begin(NULL, mapping, 0, len-1,
3380                                 flags, &page, &fsdata);
3381         if (err)
3382                 goto fail;
3383
3384         kaddr = kmap_atomic(page, KM_USER0);
3385         memcpy(kaddr, symname, len-1);
3386         kunmap_atomic(kaddr, KM_USER0);
3387
3388         err = pagecache_write_end(NULL, mapping, 0, len-1, len-1,
3389                                                         page, fsdata);
3390         if (err < 0)
3391                 goto fail;
3392         if (err < len-1)
3393                 goto retry;
3394
3395         mark_inode_dirty(inode);
3396         return 0;
3397 fail:
3398         return err;
3399 }
3400
3401 int page_symlink(struct inode *inode, const char *symname, int len)
3402 {
3403         return __page_symlink(inode, symname, len,
3404                         !(mapping_gfp_mask(inode->i_mapping) & __GFP_FS));
3405 }
3406
3407 const struct inode_operations page_symlink_inode_operations = {
3408         .readlink       = generic_readlink,
3409         .follow_link    = page_follow_link_light,
3410         .put_link       = page_put_link,
3411 };
3412
3413 EXPORT_SYMBOL(user_path_at);
3414 EXPORT_SYMBOL(follow_down_one);
3415 EXPORT_SYMBOL(follow_down);
3416 EXPORT_SYMBOL(follow_up);
3417 EXPORT_SYMBOL(get_write_access); /* binfmt_aout */
3418 EXPORT_SYMBOL(getname);
3419 EXPORT_SYMBOL(lock_rename);
3420 EXPORT_SYMBOL(lookup_one_len);
3421 EXPORT_SYMBOL(page_follow_link_light);
3422 EXPORT_SYMBOL(page_put_link);
3423 EXPORT_SYMBOL(page_readlink);
3424 EXPORT_SYMBOL(__page_symlink);
3425 EXPORT_SYMBOL(page_symlink);
3426 EXPORT_SYMBOL(page_symlink_inode_operations);
3427 EXPORT_SYMBOL(kern_path);
3428 EXPORT_SYMBOL(vfs_path_lookup);
3429 EXPORT_SYMBOL(inode_permission);
3430 EXPORT_SYMBOL(unlock_rename);
3431 EXPORT_SYMBOL(vfs_create);
3432 EXPORT_SYMBOL(vfs_follow_link);
3433 EXPORT_SYMBOL(vfs_link);
3434 EXPORT_SYMBOL(vfs_mkdir);
3435 EXPORT_SYMBOL(vfs_mknod);
3436 EXPORT_SYMBOL(generic_permission);
3437 EXPORT_SYMBOL(vfs_readlink);
3438 EXPORT_SYMBOL(vfs_rename);
3439 EXPORT_SYMBOL(vfs_rmdir);
3440 EXPORT_SYMBOL(vfs_symlink);
3441 EXPORT_SYMBOL(vfs_unlink);
3442 EXPORT_SYMBOL(dentry_unhash);
3443 EXPORT_SYMBOL(generic_readlink);