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