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