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