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