/*
   *  linux/fs/namei.c
   *
   *  Copyright (C) 1991, 1992  Linus Torvalds
   */
  
  /*
   * Some corrections by tytso.
   */
  
  /* [Feb 1997 T. Schoebel-Theuer] Complete rewrite of the pathname
   * lookup logic.
   */
  /* [Feb-Apr 2000, AV] Rewrite to the new namespace architecture.
   */
  
  #include <linux/init.h>

  #include <linux/export.h>

  #include <linux/kernel.h>

  #include <linux/slab.h>
  #include <linux/fs.h>
  #include <linux/namei.h>

  #include <linux/pagemap.h>

  #include <linux/fsnotify.h>

  #include <linux/personality.h>
  #include <linux/security.h>

  #include <linux/ima.h>

  #include <linux/syscalls.h>
  #include <linux/mount.h>
  #include <linux/audit.h>

  #include <linux/capability.h>

  #include <linux/file.h>

  #include <linux/fcntl.h>

  #include <linux/device_cgroup.h>

  #include <linux/fs_struct.h>

  #include <linux/posix_acl.h>

  #include <asm/uaccess.h>

  #include "internal.h"

  #include "mount.h"

  /* [Feb-1997 T. Schoebel-Theuer]
   * Fundamental changes in the pathname lookup mechanisms (namei)
   * were necessary because of omirr.  The reason is that omirr needs
   * to know the _real_ pathname, not the user-supplied one, in case
   * of symlinks (and also when transname replacements occur).
   *
   * The new code replaces the old recursive symlink resolution with
   * an iterative one (in case of non-nested symlink chains).  It does
   * this with calls to <fs>_follow_link().
   * As a side effect, dir_namei(), _namei() and follow_link() are now 
   * replaced with a single function lookup_dentry() that can handle all 
   * the special cases of the former code.
   *
   * With the new dcache, the pathname is stored at each inode, at least as
   * long as the refcount of the inode is positive.  As a side effect, the
   * size of the dcache depends on the inode cache and thus is dynamic.
   *
   * [29-Apr-1998 C. Scott Ananian] Updated above description of symlink
   * resolution to correspond with current state of the code.
   *
   * Note that the symlink resolution is not *completely* iterative.
   * There is still a significant amount of tail- and mid- recursion in
   * the algorithm.  Also, note that <fs>_readlink() is not used in
   * lookup_dentry(): lookup_dentry() on the result of <fs>_readlink()
   * may return different results than <fs>_follow_link().  Many virtual
   * filesystems (including /proc) exhibit this behavior.
   */
  
  /* [24-Feb-97 T. Schoebel-Theuer] Side effects caused by new implementation:
   * New symlink semantics: when open() is called with flags O_CREAT | O_EXCL
   * and the name already exists in form of a symlink, try to create the new
   * name indicated by the symlink. The old code always complained that the
   * name already exists, due to not following the symlink even if its target
   * is nonexistent.  The new semantics affects also mknod() and link() when

   * the name is a symlink pointing to a non-existent name.

   *
   * I don't know which semantics is the right one, since I have no access
   * to standards. But I found by trial that HP-UX 9.0 has the full "new"
   * semantics implemented, while SunOS 4.1.1 and Solaris (SunOS 5.4) have the
   * "old" one. Personally, I think the new semantics is much more logical.
   * Note that "ln old new" where "new" is a symlink pointing to a non-existing
   * file does succeed in both HP-UX and SunOs, but not in Solaris
   * and in the old Linux semantics.
   */
  
  /* [16-Dec-97 Kevin Buhr] For security reasons, we change some symlink
   * semantics.  See the comments in "open_namei" and "do_link" below.
   *
   * [10-Sep-98 Alan Modra] Another symlink change.
   */
  
  /* [Feb-Apr 2000 AV] Complete rewrite. Rules for symlinks:
   *	inside the path - always follow.
   *	in the last component in creation/removal/renaming - never follow.
   *	if LOOKUP_FOLLOW passed - follow.
   *	if the pathname has trailing slashes - follow.
   *	otherwise - don't follow.
   * (applied in that order).
   *
   * [Jun 2000 AV] Inconsistent behaviour of open() in case if flags==O_CREAT
   * restored for 2.4. This is the last surviving part of old 4.2BSD bug.
   * During the 2.4 we need to fix the userland stuff depending on it -
   * hopefully we will be able to get rid of that wart in 2.5. So far only
   * XEmacs seems to be relying on it...
   */
  /*
   * [Sep 2001 AV] Single-semaphore locking scheme (kudos to David Holland)

   * implemented.  Let's see if raised priority of ->s_vfs_rename_mutex gives

   * any extra contention...
   */
  
  /* In order to reduce some races, while at the same time doing additional
   * checking and hopefully speeding things up, we copy filenames to the
   * kernel data space before using them..
   *
   * POSIX.1 2.4: an empty pathname is invalid (ENOENT).
   * PATH_MAX includes the nul terminator --RR.
   */

  void final_putname(struct filename *name)

  {

  	if (name->separate) {
  		__putname(name->name);
  		kfree(name);
  	} else {
  		__putname(name);
  	}

  }

  #define EMBEDDED_NAME_MAX	(PATH_MAX - sizeof(struct filename))

  static struct filename *
  getname_flags(const char __user *filename, int flags, int *empty)
  {
  	struct filename *result, *err;

  	int len;

  	long max;
  	char *kname;

  	result = audit_reusename(filename);
  	if (result)
  		return result;

  	result = __getname();

  	if (unlikely(!result))

  		return ERR_PTR(-ENOMEM);

  	/*
  	 * First, try to embed the struct filename inside the names_cache
  	 * allocation
  	 */
  	kname = (char *)result + sizeof(*result);

  	result->name = kname;

  	result->separate = false;
  	max = EMBEDDED_NAME_MAX;
  
  recopy:
  	len = strncpy_from_user(kname, filename, max);

  	if (unlikely(len < 0)) {
  		err = ERR_PTR(len);

  		goto error;

  	}

  	/*
  	 * Uh-oh. We have a name that's approaching PATH_MAX. Allocate a
  	 * separate struct filename so we can dedicate the entire
  	 * names_cache allocation for the pathname, and re-do the copy from
  	 * userland.
  	 */
  	if (len == EMBEDDED_NAME_MAX && max == EMBEDDED_NAME_MAX) {
  		kname = (char *)result;
  
  		result = kzalloc(sizeof(*result), GFP_KERNEL);
  		if (!result) {
  			err = ERR_PTR(-ENOMEM);
  			result = (struct filename *)kname;
  			goto error;
  		}
  		result->name = kname;
  		result->separate = true;
  		max = PATH_MAX;
  		goto recopy;
  	}

  	/* The empty path is special. */
  	if (unlikely(!len)) {
  		if (empty)

  			*empty = 1;

  		err = ERR_PTR(-ENOENT);
  		if (!(flags & LOOKUP_EMPTY))
  			goto error;

  	}

  
  	err = ERR_PTR(-ENAMETOOLONG);

  	if (unlikely(len >= PATH_MAX))
  		goto error;
  
  	result->uptr = filename;
  	audit_getname(result);
  	return result;

  
  error:

  	final_putname(result);

  	return err;

  }

  struct filename *
  getname(const char __user * filename)

  {

  	return getname_flags(filename, 0, NULL);

  }

  EXPORT_SYMBOL(getname);

  #ifdef CONFIG_AUDITSYSCALL

  void putname(struct filename *name)

  {

  	if (unlikely(!audit_dummy_context()))

  		return audit_putname(name);
  	final_putname(name);

  }

  #endif

  static int check_acl(struct inode *inode, int mask)
  {

  #ifdef CONFIG_FS_POSIX_ACL

  	struct posix_acl *acl;

  	if (mask & MAY_NOT_BLOCK) {

  		acl = get_cached_acl_rcu(inode, ACL_TYPE_ACCESS);
  	        if (!acl)

  	                return -EAGAIN;

  		/* no ->get_acl() calls in RCU mode... */
  		if (acl == ACL_NOT_CACHED)
  			return -ECHILD;

  	        return posix_acl_permission(inode, acl, mask & ~MAY_NOT_BLOCK);

  	}
  
  	acl = get_cached_acl(inode, ACL_TYPE_ACCESS);
  
  	/*

  	 * A filesystem can force a ACL callback by just never filling the
  	 * ACL cache. But normally you'd fill the cache either at inode
  	 * instantiation time, or on the first ->get_acl call.

  	 *

  	 * If the filesystem doesn't have a get_acl() function at all, we'll
  	 * just create the negative cache entry.

  	 */
  	if (acl == ACL_NOT_CACHED) {

  	        if (inode->i_op->get_acl) {
  			acl = inode->i_op->get_acl(inode, ACL_TYPE_ACCESS);
  			if (IS_ERR(acl))
  				return PTR_ERR(acl);
  		} else {
  		        set_cached_acl(inode, ACL_TYPE_ACCESS, NULL);
  		        return -EAGAIN;
  		}

  	}
  
  	if (acl) {
  	        int error = posix_acl_permission(inode, acl, mask);
  	        posix_acl_release(acl);
  	        return error;
  	}

  #endif

  
  	return -EAGAIN;
  }

  /*

   * This does the basic permission checking

   */

  static int acl_permission_check(struct inode *inode, int mask)

  {

  	unsigned int mode = inode->i_mode;

  	if (likely(uid_eq(current_fsuid(), inode->i_uid)))

  		mode >>= 6;
  	else {

  		if (IS_POSIXACL(inode) && (mode & S_IRWXG)) {

  			int error = check_acl(inode, mask);

  			if (error != -EAGAIN)
  				return error;

  		}
  
  		if (in_group_p(inode->i_gid))
  			mode >>= 3;
  	}
  
  	/*
  	 * If the DACs are ok we don't need any capability check.
  	 */

  	if ((mask & ~mode & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0)

  		return 0;

  	return -EACCES;
  }
  
  /**

   * generic_permission -  check for access rights on a Posix-like filesystem

   * @inode:	inode to check access rights for

   * @mask:	right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC, ...)

   *
   * Used to check for read/write/execute permissions on a file.
   * We use "fsuid" for this, letting us set arbitrary permissions
   * for filesystem access without changing the "normal" uids which

   * are used for other things.
   *
   * generic_permission is rcu-walk aware. It returns -ECHILD in case an rcu-walk
   * request cannot be satisfied (eg. requires blocking or too much complexity).
   * It would then be called again in ref-walk mode.

   */

  int generic_permission(struct inode *inode, int mask)

  {
  	int ret;
  
  	/*

  	 * Do the basic permission checks.

  	 */

  	ret = acl_permission_check(inode, mask);

  	if (ret != -EACCES)
  		return ret;

  	if (S_ISDIR(inode->i_mode)) {
  		/* DACs are overridable for directories */

  		if (inode_capable(inode, CAP_DAC_OVERRIDE))

  			return 0;
  		if (!(mask & MAY_WRITE))

  			if (inode_capable(inode, CAP_DAC_READ_SEARCH))

  				return 0;
  		return -EACCES;
  	}

  	/*
  	 * Read/write DACs are always overridable.

  	 * Executable DACs are overridable when there is
  	 * at least one exec bit set.

  	 */

  	if (!(mask & MAY_EXEC) || (inode->i_mode & S_IXUGO))

  		if (inode_capable(inode, CAP_DAC_OVERRIDE))

  			return 0;
  
  	/*
  	 * Searching includes executable on directories, else just read.
  	 */

  	mask &= MAY_READ | MAY_WRITE | MAY_EXEC;

  	if (mask == MAY_READ)

  		if (inode_capable(inode, CAP_DAC_READ_SEARCH))

  			return 0;
  
  	return -EACCES;
  }

  /*
   * We _really_ want to just do "generic_permission()" without
   * even looking at the inode->i_op values. So we keep a cache
   * flag in inode->i_opflags, that says "this has not special
   * permission function, use the fast case".
   */
  static inline int do_inode_permission(struct inode *inode, int mask)
  {
  	if (unlikely(!(inode->i_opflags & IOP_FASTPERM))) {
  		if (likely(inode->i_op->permission))
  			return inode->i_op->permission(inode, mask);
  
  		/* This gets set once for the inode lifetime */
  		spin_lock(&inode->i_lock);
  		inode->i_opflags |= IOP_FASTPERM;
  		spin_unlock(&inode->i_lock);
  	}
  	return generic_permission(inode, mask);
  }

  /**

   * __inode_permission - Check for access rights to a given inode
   * @inode: Inode to check permission on
   * @mask: Right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)

   *

   * Check for read/write/execute permissions on an inode.

   *
   * When checking for MAY_APPEND, MAY_WRITE must also be set in @mask.

   *
   * This does not check for a read-only file system.  You probably want
   * inode_permission().

   */

  int __inode_permission(struct inode *inode, int mask)

  {

  	int retval;

  	if (unlikely(mask & MAY_WRITE)) {

  		/*
  		 * Nobody gets write access to an immutable file.
  		 */
  		if (IS_IMMUTABLE(inode))
  			return -EACCES;
  	}

  	retval = do_inode_permission(inode, mask);

  	if (retval)
  		return retval;

  	retval = devcgroup_inode_permission(inode, mask);
  	if (retval)
  		return retval;

  	return security_inode_permission(inode, mask);

  }

  /**

   * sb_permission - Check superblock-level permissions
   * @sb: Superblock of inode to check permission on

   * @inode: Inode to check permission on

   * @mask: Right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
   *
   * Separate out file-system wide checks from inode-specific permission checks.
   */
  static int sb_permission(struct super_block *sb, struct inode *inode, int mask)
  {
  	if (unlikely(mask & MAY_WRITE)) {
  		umode_t mode = inode->i_mode;
  
  		/* Nobody gets write access to a read-only fs. */
  		if ((sb->s_flags & MS_RDONLY) &&
  		    (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
  			return -EROFS;
  	}
  	return 0;
  }
  
  /**
   * inode_permission - Check for access rights to a given inode
   * @inode: Inode to check permission on
   * @mask: Right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
   *
   * Check for read/write/execute permissions on an inode.  We use fs[ug]id for
   * this, letting us set arbitrary permissions for filesystem access without
   * changing the "normal" UIDs which are used for other things.
   *
   * When checking for MAY_APPEND, MAY_WRITE must also be set in @mask.
   */
  int inode_permission(struct inode *inode, int mask)
  {
  	int retval;
  
  	retval = sb_permission(inode->i_sb, inode, mask);
  	if (retval)
  		return retval;
  	return __inode_permission(inode, mask);
  }
  
  /**

   * path_get - get a reference to a path
   * @path: path to get the reference to
   *
   * Given a path increment the reference count to the dentry and the vfsmount.
   */

  void path_get(const struct path *path)

  {
  	mntget(path->mnt);
  	dget(path->dentry);
  }
  EXPORT_SYMBOL(path_get);
  
  /**

   * path_put - put a reference to a path
   * @path: path to put the reference to
   *
   * Given a path decrement the reference count to the dentry and the vfsmount.
   */

  void path_put(const struct path *path)

  {

  	dput(path->dentry);
  	mntput(path->mnt);

  }

  EXPORT_SYMBOL(path_put);

  /*

   * Path walking has 2 modes, rcu-walk and ref-walk (see

   * Documentation/filesystems/path-lookup.txt).  In situations when we can't
   * continue in RCU mode, we attempt to drop out of rcu-walk mode and grab
   * normal reference counts on dentries and vfsmounts to transition to rcu-walk
   * mode.  Refcounts are grabbed at the last known good point before rcu-walk
   * got stuck, so ref-walk may continue from there. If this is not successful
   * (eg. a seqcount has changed), then failure is returned and it's up to caller
   * to restart the path walk from the beginning in ref-walk mode.

   */

  static inline void lock_rcu_walk(void)
  {
  	br_read_lock(&vfsmount_lock);
  	rcu_read_lock();
  }
  
  static inline void unlock_rcu_walk(void)
  {
  	rcu_read_unlock();
  	br_read_unlock(&vfsmount_lock);
  }

  /**

   * unlazy_walk - try to switch to ref-walk mode.
   * @nd: nameidata pathwalk data
   * @dentry: child of nd->path.dentry or NULL

   * Returns: 0 on success, -ECHILD on failure

   *

   * unlazy_walk attempts to legitimize the current nd->path, nd->root and dentry
   * for ref-walk mode.  @dentry must be a path found by a do_lookup call on
   * @nd or NULL.  Must be called from rcu-walk context.

   */

  static int unlazy_walk(struct nameidata *nd, struct dentry *dentry)

  {
  	struct fs_struct *fs = current->fs;
  	struct dentry *parent = nd->path.dentry;

  	int want_root = 0;

  
  	BUG_ON(!(nd->flags & LOOKUP_RCU));

  	if (nd->root.mnt && !(nd->flags & LOOKUP_ROOT)) {
  		want_root = 1;

  		spin_lock(&fs->lock);
  		if (nd->root.mnt != fs->root.mnt ||
  				nd->root.dentry != fs->root.dentry)
  			goto err_root;
  	}
  	spin_lock(&parent->d_lock);

  	if (!dentry) {
  		if (!__d_rcu_to_refcount(parent, nd->seq))
  			goto err_parent;
  		BUG_ON(nd->inode != parent->d_inode);
  	} else {

  		if (dentry->d_parent != parent)
  			goto err_parent;

  		spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
  		if (!__d_rcu_to_refcount(dentry, nd->seq))
  			goto err_child;
  		/*
  		 * If the sequence check on the child dentry passed, then
  		 * the child has not been removed from its parent. This
  		 * means the parent dentry must be valid and able to take
  		 * a reference at this point.
  		 */
  		BUG_ON(!IS_ROOT(dentry) && dentry->d_parent != parent);
  		BUG_ON(!parent->d_count);
  		parent->d_count++;
  		spin_unlock(&dentry->d_lock);
  	}

  	spin_unlock(&parent->d_lock);

  	if (want_root) {

  		path_get(&nd->root);
  		spin_unlock(&fs->lock);
  	}
  	mntget(nd->path.mnt);

  	unlock_rcu_walk();

  	nd->flags &= ~LOOKUP_RCU;
  	return 0;

  
  err_child:

  	spin_unlock(&dentry->d_lock);

  err_parent:

  	spin_unlock(&parent->d_lock);
  err_root:

  	if (want_root)

  		spin_unlock(&fs->lock);
  	return -ECHILD;
  }

  static inline int d_revalidate(struct dentry *dentry, unsigned int flags)

  {

  	return dentry->d_op->d_revalidate(dentry, flags);

  }

  /**
   * complete_walk - successful completion of path walk
   * @nd:  pointer nameidata

   *

   * If we had been in RCU mode, drop out of it and legitimize nd->path.
   * Revalidate the final result, unless we'd already done that during
   * the path walk or the filesystem doesn't ask for it.  Return 0 on
   * success, -error on failure.  In case of failure caller does not
   * need to drop nd->path.

   */

  static int complete_walk(struct nameidata *nd)

  {

  	struct dentry *dentry = nd->path.dentry;

  	int status;

  	if (nd->flags & LOOKUP_RCU) {
  		nd->flags &= ~LOOKUP_RCU;
  		if (!(nd->flags & LOOKUP_ROOT))
  			nd->root.mnt = NULL;
  		spin_lock(&dentry->d_lock);
  		if (unlikely(!__d_rcu_to_refcount(dentry, nd->seq))) {
  			spin_unlock(&dentry->d_lock);

  			unlock_rcu_walk();

  			return -ECHILD;
  		}
  		BUG_ON(nd->inode != dentry->d_inode);
  		spin_unlock(&dentry->d_lock);
  		mntget(nd->path.mnt);

  		unlock_rcu_walk();

  	}

  	if (likely(!(nd->flags & LOOKUP_JUMPED)))
  		return 0;

  	if (likely(!(dentry->d_flags & DCACHE_OP_WEAK_REVALIDATE)))

  		return 0;

  	status = dentry->d_op->d_weak_revalidate(dentry, nd->flags);

  	if (status > 0)
  		return 0;

  	if (!status)

  		status = -ESTALE;

  	path_put(&nd->path);

  	return status;
  }

  static __always_inline void set_root(struct nameidata *nd)
  {

  	if (!nd->root.mnt)
  		get_fs_root(current->fs, &nd->root);

  }

  static int link_path_walk(const char *, struct nameidata *);

  static __always_inline void set_root_rcu(struct nameidata *nd)
  {
  	if (!nd->root.mnt) {
  		struct fs_struct *fs = current->fs;

  		unsigned seq;
  
  		do {
  			seq = read_seqcount_begin(&fs->seq);
  			nd->root = fs->root;

  			nd->seq = __read_seqcount_begin(&nd->root.dentry->d_seq);

  		} while (read_seqcount_retry(&fs->seq, seq));

  	}
  }

  static __always_inline int __vfs_follow_link(struct nameidata *nd, const char *link)

  {

  	int ret;

  	if (IS_ERR(link))
  		goto fail;
  
  	if (*link == '/') {

  		set_root(nd);

  		path_put(&nd->path);

  		nd->path = nd->root;
  		path_get(&nd->root);

  		nd->flags |= LOOKUP_JUMPED;

  	}

  	nd->inode = nd->path.dentry->d_inode;

  	ret = link_path_walk(link, nd);
  	return ret;

  fail:

  	path_put(&nd->path);

  	return PTR_ERR(link);
  }

  static void path_put_conditional(struct path *path, struct nameidata *nd)

  {
  	dput(path->dentry);

  	if (path->mnt != nd->path.mnt)

  		mntput(path->mnt);
  }

  static inline void path_to_nameidata(const struct path *path,
  					struct nameidata *nd)

  {

  	if (!(nd->flags & LOOKUP_RCU)) {
  		dput(nd->path.dentry);
  		if (nd->path.mnt != path->mnt)
  			mntput(nd->path.mnt);

  	}

  	nd->path.mnt = path->mnt;

  	nd->path.dentry = path->dentry;

  }

  /*
   * Helper to directly jump to a known parsed path from ->follow_link,
   * caller must have taken a reference to path beforehand.
   */
  void nd_jump_link(struct nameidata *nd, struct path *path)
  {
  	path_put(&nd->path);
  
  	nd->path = *path;
  	nd->inode = nd->path.dentry->d_inode;
  	nd->flags |= LOOKUP_JUMPED;

  }

  static inline void put_link(struct nameidata *nd, struct path *link, void *cookie)
  {
  	struct inode *inode = link->dentry->d_inode;

  	if (inode->i_op->put_link)

  		inode->i_op->put_link(link->dentry, nd, cookie);
  	path_put(link);
  }

  int sysctl_protected_symlinks __read_mostly = 0;
  int sysctl_protected_hardlinks __read_mostly = 0;

  
  /**
   * may_follow_link - Check symlink following for unsafe situations
   * @link: The path of the symlink

   * @nd: nameidata pathwalk data

   *
   * In the case of the sysctl_protected_symlinks sysctl being enabled,
   * CAP_DAC_OVERRIDE needs to be specifically ignored if the symlink is
   * in a sticky world-writable directory. This is to protect privileged
   * processes from failing races against path names that may change out
   * from under them by way of other users creating malicious symlinks.
   * It will permit symlinks to be followed only when outside a sticky
   * world-writable directory, or when the uid of the symlink and follower
   * match, or when the directory owner matches the symlink's owner.
   *
   * Returns 0 if following the symlink is allowed, -ve on error.
   */
  static inline int may_follow_link(struct path *link, struct nameidata *nd)
  {
  	const struct inode *inode;
  	const struct inode *parent;
  
  	if (!sysctl_protected_symlinks)
  		return 0;
  
  	/* Allowed if owner and follower match. */
  	inode = link->dentry->d_inode;

  	if (uid_eq(current_cred()->fsuid, inode->i_uid))

  		return 0;
  
  	/* Allowed if parent directory not sticky and world-writable. */
  	parent = nd->path.dentry->d_inode;
  	if ((parent->i_mode & (S_ISVTX|S_IWOTH)) != (S_ISVTX|S_IWOTH))
  		return 0;
  
  	/* Allowed if parent directory and link owner match. */

  	if (uid_eq(parent->i_uid, inode->i_uid))

  		return 0;

  	audit_log_link_denied("follow_link", link);

  	path_put_conditional(link, nd);
  	path_put(&nd->path);
  	return -EACCES;
  }
  
  /**
   * safe_hardlink_source - Check for safe hardlink conditions
   * @inode: the source inode to hardlink from
   *
   * Return false if at least one of the following conditions:
   *    - inode is not a regular file
   *    - inode is setuid
   *    - inode is setgid and group-exec
   *    - access failure for read and write
   *
   * Otherwise returns true.
   */
  static bool safe_hardlink_source(struct inode *inode)
  {
  	umode_t mode = inode->i_mode;
  
  	/* Special files should not get pinned to the filesystem. */
  	if (!S_ISREG(mode))
  		return false;
  
  	/* Setuid files should not get pinned to the filesystem. */
  	if (mode & S_ISUID)
  		return false;
  
  	/* Executable setgid files should not get pinned to the filesystem. */
  	if ((mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP))
  		return false;
  
  	/* Hardlinking to unreadable or unwritable sources is dangerous. */
  	if (inode_permission(inode, MAY_READ | MAY_WRITE))
  		return false;
  
  	return true;
  }
  
  /**
   * may_linkat - Check permissions for creating a hardlink
   * @link: the source to hardlink from
   *
   * Block hardlink when all of:
   *  - sysctl_protected_hardlinks enabled
   *  - fsuid does not match inode
   *  - hardlink source is unsafe (see safe_hardlink_source() above)
   *  - not CAP_FOWNER
   *
   * Returns 0 if successful, -ve on error.
   */
  static int may_linkat(struct path *link)
  {
  	const struct cred *cred;
  	struct inode *inode;
  
  	if (!sysctl_protected_hardlinks)
  		return 0;
  
  	cred = current_cred();
  	inode = link->dentry->d_inode;
  
  	/* Source inode owner (or CAP_FOWNER) can hardlink all they like,
  	 * otherwise, it must be a safe source.
  	 */

  	if (uid_eq(cred->fsuid, inode->i_uid) || safe_hardlink_source(inode) ||

  	    capable(CAP_FOWNER))
  		return 0;

  	audit_log_link_denied("linkat", link);

  	return -EPERM;
  }

  static __always_inline int

  follow_link(struct path *link, struct nameidata *nd, void **p)

  {

  	struct dentry *dentry = link->dentry;

  	int error;
  	char *s;

  	BUG_ON(nd->flags & LOOKUP_RCU);

  	if (link->mnt == nd->path.mnt)
  		mntget(link->mnt);

  	error = -ELOOP;
  	if (unlikely(current->total_link_count >= 40))
  		goto out_put_nd_path;

  	cond_resched();
  	current->total_link_count++;

  	touch_atime(link);

  	nd_set_link(nd, NULL);

  	error = security_inode_follow_link(link->dentry, nd);

  	if (error)
  		goto out_put_nd_path;

  	nd->last_type = LAST_BIND;

  	*p = dentry->d_inode->i_op->follow_link(dentry, nd);
  	error = PTR_ERR(*p);

  	if (IS_ERR(*p))

  		goto out_put_nd_path;

  
  	error = 0;
  	s = nd_get_link(nd);
  	if (s) {
  		error = __vfs_follow_link(nd, s);

  		if (unlikely(error))
  			put_link(nd, link, *p);

  	}

  
  	return error;
  
  out_put_nd_path:

  	*p = NULL;

  	path_put(&nd->path);

  	path_put(link);

  	return error;
  }

  static int follow_up_rcu(struct path *path)
  {

  	struct mount *mnt = real_mount(path->mnt);
  	struct mount *parent;

  	struct dentry *mountpoint;

  	parent = mnt->mnt_parent;
  	if (&parent->mnt == path->mnt)

  		return 0;

  	mountpoint = mnt->mnt_mountpoint;

  	path->dentry = mountpoint;

  	path->mnt = &parent->mnt;

  	return 1;
  }

  /*
   * follow_up - Find the mountpoint of path's vfsmount
   *
   * Given a path, find the mountpoint of its source file system.
   * Replace @path with the path of the mountpoint in the parent mount.
   * Up is towards /.
   *
   * Return 1 if we went up a level and 0 if we were already at the
   * root.
   */

  int follow_up(struct path *path)

  {

  	struct mount *mnt = real_mount(path->mnt);
  	struct mount *parent;

  	struct dentry *mountpoint;

  	br_read_lock(&vfsmount_lock);

  	parent = mnt->mnt_parent;

  	if (parent == mnt) {

  		br_read_unlock(&vfsmount_lock);

  		return 0;
  	}

  	mntget(&parent->mnt);

  	mountpoint = dget(mnt->mnt_mountpoint);

  	br_read_unlock(&vfsmount_lock);

  	dput(path->dentry);
  	path->dentry = mountpoint;
  	mntput(path->mnt);

  	path->mnt = &parent->mnt;

  	return 1;
  }

  /*

   * Perform an automount
   * - return -EISDIR to tell follow_managed() to stop and return the path we
   *   were called with.

   */

  static int follow_automount(struct path *path, unsigned flags,
  			    bool *need_mntput)

  {

  	struct vfsmount *mnt;

  	int err;

  
  	if (!path->dentry->d_op || !path->dentry->d_op->d_automount)
  		return -EREMOTE;

  	/* We don't want to mount if someone's just doing a stat -
  	 * unless they're stat'ing a directory and appended a '/' to
  	 * the name.
  	 *
  	 * We do, however, want to mount if someone wants to open or
  	 * create a file of any type under the mountpoint, wants to
  	 * traverse through the mountpoint or wants to open the
  	 * mounted directory.  Also, autofs may mark negative dentries
  	 * as being automount points.  These will need the attentions
  	 * of the daemon to instantiate them before they can be used.

  	 */

  	if (!(flags & (LOOKUP_PARENT | LOOKUP_DIRECTORY |

  		     LOOKUP_OPEN | LOOKUP_CREATE | LOOKUP_AUTOMOUNT)) &&

  	    path->dentry->d_inode)
  		return -EISDIR;

  	current->total_link_count++;
  	if (current->total_link_count >= 40)
  		return -ELOOP;
  
  	mnt = path->dentry->d_op->d_automount(path);
  	if (IS_ERR(mnt)) {
  		/*
  		 * The filesystem is allowed to return -EISDIR here to indicate
  		 * it doesn't want to automount.  For instance, autofs would do
  		 * this so that its userspace daemon can mount on this dentry.
  		 *
  		 * However, we can only permit this if it's a terminal point in
  		 * the path being looked up; if it wasn't then the remainder of
  		 * the path is inaccessible and we should say so.
  		 */

  		if (PTR_ERR(mnt) == -EISDIR && (flags & LOOKUP_PARENT))

  			return -EREMOTE;
  		return PTR_ERR(mnt);

  	}

  	if (!mnt) /* mount collision */
  		return 0;

  	if (!*need_mntput) {
  		/* lock_mount() may release path->mnt on error */
  		mntget(path->mnt);
  		*need_mntput = true;
  	}

  	err = finish_automount(mnt, path);

  	switch (err) {
  	case -EBUSY:
  		/* Someone else made a mount here whilst we were busy */

  		return 0;

  	case 0:

  		path_put(path);

  		path->mnt = mnt;
  		path->dentry = dget(mnt->mnt_root);

  		return 0;

  	default:
  		return err;

  	}

  }

  /*
   * Handle a dentry that is managed in some way.

   * - Flagged for transit management (autofs)

   * - Flagged as mountpoint
   * - Flagged as automount point
   *
   * This may only be called in refwalk mode.
   *
   * Serialization is taken care of in namespace.c
   */
  static int follow_managed(struct path *path, unsigned flags)

  {

  	struct vfsmount *mnt = path->mnt; /* held by caller, must be left alone */

  	unsigned managed;
  	bool need_mntput = false;

  	int ret = 0;

  
  	/* Given that we're not holding a lock here, we retain the value in a
  	 * local variable for each dentry as we look at it so that we don't see
  	 * the components of that value change under us */
  	while (managed = ACCESS_ONCE(path->dentry->d_flags),
  	       managed &= DCACHE_MANAGED_DENTRY,
  	       unlikely(managed != 0)) {

  		/* Allow the filesystem to manage the transit without i_mutex
  		 * being held. */
  		if (managed & DCACHE_MANAGE_TRANSIT) {
  			BUG_ON(!path->dentry->d_op);
  			BUG_ON(!path->dentry->d_op->d_manage);

  			ret = path->dentry->d_op->d_manage(path->dentry, false);

  			if (ret < 0)

  				break;

  		}

  		/* Transit to a mounted filesystem. */
  		if (managed & DCACHE_MOUNTED) {
  			struct vfsmount *mounted = lookup_mnt(path);
  			if (mounted) {
  				dput(path->dentry);
  				if (need_mntput)
  					mntput(path->mnt);
  				path->mnt = mounted;
  				path->dentry = dget(mounted->mnt_root);
  				need_mntput = true;
  				continue;
  			}
  
  			/* Something is mounted on this dentry in another
  			 * namespace and/or whatever was mounted there in this
  			 * namespace got unmounted before we managed to get the
  			 * vfsmount_lock */
  		}
  
  		/* Handle an automount point */
  		if (managed & DCACHE_NEED_AUTOMOUNT) {
  			ret = follow_automount(path, flags, &need_mntput);
  			if (ret < 0)

  				break;

  			continue;
  		}
  
  		/* We didn't change the current path point */
  		break;

  	}

  
  	if (need_mntput && path->mnt == mnt)
  		mntput(path->mnt);
  	if (ret == -EISDIR)
  		ret = 0;

  	return ret < 0 ? ret : need_mntput;

  }

  int follow_down_one(struct path *path)

  {
  	struct vfsmount *mounted;

  	mounted = lookup_mnt(path);

  	if (mounted) {

  		dput(path->dentry);
  		mntput(path->mnt);
  		path->mnt = mounted;
  		path->dentry = dget(mounted->mnt_root);

  		return 1;
  	}
  	return 0;
  }

  static inline bool managed_dentry_might_block(struct dentry *dentry)
  {
  	return (dentry->d_flags & DCACHE_MANAGE_TRANSIT &&
  		dentry->d_op->d_manage(dentry, true) < 0);
  }

  /*

   * Try to skip to top of mountpoint pile in rcuwalk mode.  Fail if
   * we meet a managed dentry that would need blocking.

   */
  static bool __follow_mount_rcu(struct nameidata *nd, struct path *path,

  			       struct inode **inode)

  {

  	for (;;) {

  		struct mount *mounted;

  		/*
  		 * Don't forget we might have a non-mountpoint managed dentry
  		 * that wants to block transit.
  		 */

  		if (unlikely(managed_dentry_might_block(path->dentry)))

  			return false;

  
  		if (!d_mountpoint(path->dentry))
  			break;

  		mounted = __lookup_mnt(path->mnt, path->dentry, 1);
  		if (!mounted)
  			break;

  		path->mnt = &mounted->mnt;
  		path->dentry = mounted->mnt.mnt_root;

  		nd->flags |= LOOKUP_JUMPED;

  		nd->seq = read_seqcount_begin(&path->dentry->d_seq);

  		/*
  		 * Update the inode too. We don't need to re-check the
  		 * dentry sequence number here after this d_inode read,
  		 * because a mount-point is always pinned.
  		 */
  		*inode = path->dentry->d_inode;

  	}

  	return true;
  }

  static void follow_mount_rcu(struct nameidata *nd)

  {

  	while (d_mountpoint(nd->path.dentry)) {

  		struct mount *mounted;

  		mounted = __lookup_mnt(nd->path.mnt, nd->path.dentry, 1);

  		if (!mounted)
  			break;

  		nd->path.mnt = &mounted->mnt;
  		nd->path.dentry = mounted->mnt.mnt_root;

  		nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq);

  	}
  }

  static int follow_dotdot_rcu(struct nameidata *nd)
  {

  	set_root_rcu(nd);

  	while (1) {

  		if (nd->path.dentry == nd->root.dentry &&
  		    nd->path.mnt == nd->root.mnt) {
  			break;
  		}
  		if (nd->path.dentry != nd->path.mnt->mnt_root) {
  			struct dentry *old = nd->path.dentry;
  			struct dentry *parent = old->d_parent;
  			unsigned seq;
  
  			seq = read_seqcount_begin(&parent->d_seq);
  			if (read_seqcount_retry(&old->d_seq, nd->seq))

  				goto failed;

  			nd->path.dentry = parent;
  			nd->seq = seq;
  			break;
  		}
  		if (!follow_up_rcu(&nd->path))
  			break;
  		nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq);

  	}

  	follow_mount_rcu(nd);
  	nd->inode = nd->path.dentry->d_inode;

  	return 0;

  
  failed:
  	nd->flags &= ~LOOKUP_RCU;

  	if (!(nd->flags & LOOKUP_ROOT))
  		nd->root.mnt = NULL;

  	unlock_rcu_walk();

  	return -ECHILD;

  }

  /*

   * Follow down to the covering mount currently visible to userspace.  At each
   * point, the filesystem owning that dentry may be queried as to whether the
   * caller is permitted to proceed or not.

   */

  int follow_down(struct path *path)

  {
  	unsigned managed;
  	int ret;
  
  	while (managed = ACCESS_ONCE(path->dentry->d_flags),
  	       unlikely(managed & DCACHE_MANAGED_DENTRY)) {
  		/* Allow the filesystem to manage the transit without i_mutex
  		 * being held.
  		 *
  		 * We indicate to the filesystem if someone is trying to mount
  		 * something here.  This gives autofs the chance to deny anyone
  		 * other than its daemon the right to mount on its
  		 * superstructure.
  		 *
  		 * The filesystem may sleep at this point.
  		 */
  		if (managed & DCACHE_MANAGE_TRANSIT) {
  			BUG_ON(!path->dentry->d_op);
  			BUG_ON(!path->dentry->d_op->d_manage);

  			ret = path->dentry->d_op->d_manage(

  				path->dentry, false);

  			if (ret < 0)
  				return ret == -EISDIR ? 0 : ret;
  		}
  
  		/* Transit to a mounted filesystem. */
  		if (managed & DCACHE_MOUNTED) {
  			struct vfsmount *mounted = lookup_mnt(path);
  			if (!mounted)
  				break;
  			dput(path->dentry);
  			mntput(path->mnt);
  			path->mnt = mounted;
  			path->dentry = dget(mounted->mnt_root);
  			continue;
  		}
  
  		/* Don't handle automount points here */
  		break;
  	}
  	return 0;
  }
  
  /*

   * Skip to top of mountpoint pile in refwalk mode for follow_dotdot()
   */
  static void follow_mount(struct path *path)
  {
  	while (d_mountpoint(path->dentry)) {
  		struct vfsmount *mounted = lookup_mnt(path);
  		if (!mounted)
  			break;
  		dput(path->dentry);
  		mntput(path->mnt);
  		path->mnt = mounted;
  		path->dentry = dget(mounted->mnt_root);
  	}
  }

  static void follow_dotdot(struct nameidata *nd)

  {

  	set_root(nd);

  	while(1) {

  		struct dentry *old = nd->path.dentry;

  		if (nd->path.dentry == nd->root.dentry &&
  		    nd->path.mnt == nd->root.mnt) {

  			break;
  		}

  		if (nd->path.dentry != nd->path.mnt->mnt_root) {

  			/* rare case of legitimate dget_parent()... */
  			nd->path.dentry = dget_parent(nd->path.dentry);

  			dput(old);
  			break;
  		}

  		if (!follow_up(&nd->path))

  			break;

  	}

  	follow_mount(&nd->path);

  	nd->inode = nd->path.dentry->d_inode;

  }

  /*

   * This looks up the name in dcache, possibly revalidates the old dentry and
   * allocates a new one if not found or not valid.  In the need_lookup argument
   * returns whether i_op->lookup is necessary.
   *
   * dir->d_inode->i_mutex must be held

   */

  static struct dentry *lookup_dcache(struct qstr *name, struct dentry *dir,

  				    unsigned int flags, bool *need_lookup)

  {

  	struct dentry *dentry;

  	int error;

  	*need_lookup = false;
  	dentry = d_lookup(dir, name);
  	if (dentry) {

  		if (dentry->d_flags & DCACHE_OP_REVALIDATE) {

  			error = d_revalidate(dentry, flags);

  			if (unlikely(error <= 0)) {
  				if (error < 0) {
  					dput(dentry);
  					return ERR_PTR(error);
  				} else if (!d_invalidate(dentry)) {
  					dput(dentry);
  					dentry = NULL;
  				}
  			}
  		}
  	}

  	if (!dentry) {
  		dentry = d_alloc(dir, name);
  		if (unlikely(!dentry))
  			return ERR_PTR(-ENOMEM);

  		*need_lookup = true;

  	}
  	return dentry;
  }
  
  /*

   * Call i_op->lookup on the dentry.  The dentry must be negative but may be
   * hashed if it was pouplated with DCACHE_NEED_LOOKUP.
   *
   * dir->d_inode->i_mutex must be held

   */

  static struct dentry *lookup_real(struct inode *dir, struct dentry *dentry,

  				  unsigned int flags)

  {

  	struct dentry *old;
  
  	/* Don't create child dentry for a dead directory. */

  	if (unlikely(IS_DEADDIR(dir))) {

  		dput(dentry);

  		return ERR_PTR(-ENOENT);

  	}

  	old = dir->i_op->lookup(dir, dentry, flags);

  	if (unlikely(old)) {
  		dput(dentry);
  		dentry = old;
  	}
  	return dentry;
  }

  static struct dentry *__lookup_hash(struct qstr *name,

  		struct dentry *base, unsigned int flags)

  {

  	bool need_lookup;

  	struct dentry *dentry;

  	dentry = lookup_dcache(name, base, flags, &need_lookup);

  	if (!need_lookup)
  		return dentry;

  	return lookup_real(base->d_inode, dentry, flags);

  }

  /*

   *  It's more convoluted than I'd like it to be, but... it's still fairly
   *  small and for now I'd prefer to have fast path as straight as possible.
   *  It _is_ time-critical.
   */

  static int lookup_fast(struct nameidata *nd,

  		       struct path *path, struct inode **inode)

  {

  	struct vfsmount *mnt = nd->path.mnt;

  	struct dentry *dentry, *parent = nd->path.dentry;

  	int need_reval = 1;
  	int status = 1;

  	int err;

  	/*

  	 * Rename seqlock is not required here because in the off chance
  	 * of a false negative due to a concurrent rename, we're going to
  	 * do the non-racy lookup, below.
  	 */

  	if (nd->flags & LOOKUP_RCU) {
  		unsigned seq;

  		dentry = __d_lookup_rcu(parent, &nd->last, &seq, nd->inode);

  		if (!dentry)
  			goto unlazy;

  		/*
  		 * This sequence count validates that the inode matches
  		 * the dentry name information from lookup.
  		 */
  		*inode = dentry->d_inode;
  		if (read_seqcount_retry(&dentry->d_seq, seq))
  			return -ECHILD;
  
  		/*
  		 * This sequence count validates that the parent had no
  		 * changes while we did the lookup of the dentry above.
  		 *
  		 * The memory barrier in read_seqcount_begin of child is
  		 *  enough, we can use __read_seqcount_retry here.
  		 */

  		if (__read_seqcount_retry(&parent->d_seq, nd->seq))
  			return -ECHILD;

  		nd->seq = seq;

  		if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE)) {

  			status = d_revalidate(dentry, nd->flags);

  			if (unlikely(status <= 0)) {
  				if (status != -ECHILD)
  					need_reval = 0;
  				goto unlazy;
  			}

  		}

  		path->mnt = mnt;
  		path->dentry = dentry;

  		if (unlikely(!__follow_mount_rcu(nd, path, inode)))
  			goto unlazy;
  		if (unlikely(path->dentry->d_flags & DCACHE_NEED_AUTOMOUNT))
  			goto unlazy;
  		return 0;

  unlazy:

  		if (unlazy_walk(nd, dentry))
  			return -ECHILD;

  	} else {

  		dentry = __d_lookup(parent, &nd->last);

  	}

  	if (unlikely(!dentry))
  		goto need_lookup;

  	if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE) && need_reval)

  		status = d_revalidate(dentry, nd->flags);

  	if (unlikely(status <= 0)) {
  		if (status < 0) {
  			dput(dentry);
  			return status;
  		}
  		if (!d_invalidate(dentry)) {
  			dput(dentry);

  			goto need_lookup;

  		}

  	}

  	path->mnt = mnt;
  	path->dentry = dentry;
  	err = follow_managed(path, nd->flags);

  	if (unlikely(err < 0)) {
  		path_put_conditional(path, nd);

  		return err;

  	}

  	if (err)
  		nd->flags |= LOOKUP_JUMPED;

  	*inode = path->dentry->d_inode;

  	return 0;

  
  need_lookup:

  	return 1;
  }
  
  /* Fast lookup failed, do it the slow way */

  static int lookup_slow(struct nameidata *nd, struct path *path)

  {
  	struct dentry *dentry, *parent;
  	int err;
  
  	parent = nd->path.dentry;

  	BUG_ON(nd->inode != parent->d_inode);
  
  	mutex_lock(&parent->d_inode->i_mutex);

  	dentry = __lookup_hash(&nd->last, parent, nd->flags);

  	mutex_unlock(&parent->d_inode->i_mutex);
  	if (IS_ERR(dentry))
  		return PTR_ERR(dentry);

  	path->mnt = nd->path.mnt;
  	path->dentry = dentry;
  	err = follow_managed(path, nd->flags);
  	if (unlikely(err < 0)) {
  		path_put_conditional(path, nd);
  		return err;
  	}
  	if (err)
  		nd->flags |= LOOKUP_JUMPED;
  	return 0;

  }

  static inline int may_lookup(struct nameidata *nd)
  {
  	if (nd->flags & LOOKUP_RCU) {

  		int err = inode_permission(nd->inode, MAY_EXEC|MAY_NOT_BLOCK);

  		if (err != -ECHILD)
  			return err;

  		if (unlazy_walk(nd, NULL))

  			return -ECHILD;
  	}

  	return inode_permission(nd->inode, MAY_EXEC);

  }

  static inline int handle_dots(struct nameidata *nd, int type)
  {
  	if (type == LAST_DOTDOT) {
  		if (nd->flags & LOOKUP_RCU) {
  			if (follow_dotdot_rcu(nd))
  				return -ECHILD;
  		} else
  			follow_dotdot(nd);
  	}
  	return 0;
  }

  static void terminate_walk(struct nameidata *nd)
  {
  	if (!(nd->flags & LOOKUP_RCU)) {
  		path_put(&nd->path);
  	} else {
  		nd->flags &= ~LOOKUP_RCU;

  		if (!(nd->flags & LOOKUP_ROOT))
  			nd->root.mnt = NULL;

  		unlock_rcu_walk();

  	}
  }

  /*
   * Do we need to follow links? We _really_ want to be able
   * to do this check without having to look at inode->i_op,
   * so we keep a cache of "no, this doesn't need follow_link"
   * for the common case.
   */

  static inline int should_follow_link(struct inode *inode, int follow)

  {
  	if (unlikely(!(inode->i_opflags & IOP_NOFOLLOW))) {
  		if (likely(inode->i_op->follow_link))
  			return follow;
  
  		/* This gets set once for the inode lifetime */
  		spin_lock(&inode->i_lock);
  		inode->i_opflags |= IOP_NOFOLLOW;
  		spin_unlock(&inode->i_lock);
  	}
  	return 0;
  }

  static inline int walk_component(struct nameidata *nd, struct path *path,

  		int follow)

  {
  	struct inode *inode;
  	int err;
  	/*
  	 * "." and ".." are special - ".." especially so because it has
  	 * to be able to know about the current root directory and
  	 * parent relationships.
  	 */

  	if (unlikely(nd->last_type != LAST_NORM))
  		return handle_dots(nd, nd->last_type);

  	err = lookup_fast(nd, path, &inode);

  	if (unlikely(err)) {

  		if (err < 0)
  			goto out_err;

  		err = lookup_slow(nd, path);

  		if (err < 0)
  			goto out_err;
  
  		inode = path->dentry->d_inode;

  	}

  	err = -ENOENT;
  	if (!inode)
  		goto out_path_put;

  	if (should_follow_link(inode, follow)) {

  		if (nd->flags & LOOKUP_RCU) {
  			if (unlikely(unlazy_walk(nd, path->dentry))) {

  				err = -ECHILD;
  				goto out_err;

  			}
  		}

  		BUG_ON(inode != path->dentry->d_inode);
  		return 1;
  	}
  	path_to_nameidata(path, nd);
  	nd->inode = inode;
  	return 0;

  
  out_path_put:
  	path_to_nameidata(path, nd);
  out_err:
  	terminate_walk(nd);
  	return err;

  }

  /*

   * This limits recursive symlink follows to 8, while
   * limiting consecutive symlinks to 40.
   *
   * Without that kind of total limit, nasty chains of consecutive
   * symlinks can cause almost arbitrarily long lookups.
   */
  static inline int nested_symlink(struct path *path, struct nameidata *nd)
  {
  	int res;

  	if (unlikely(current->link_count >= MAX_NESTED_LINKS)) {
  		path_put_conditional(path, nd);
  		path_put(&nd->path);
  		return -ELOOP;
  	}

  	BUG_ON(nd->depth >= MAX_NESTED_LINKS);

  
  	nd->depth++;
  	current->link_count++;
  
  	do {
  		struct path link = *path;
  		void *cookie;

  
  		res = follow_link(&link, nd, &cookie);

  		if (res)
  			break;

  		res = walk_component(nd, path, LOOKUP_FOLLOW);

  		put_link(nd, &link, cookie);

  	} while (res > 0);
  
  	current->link_count--;
  	nd->depth--;
  	return res;
  }
  
  /*

   * We really don't want to look at inode->i_op->lookup
   * when we don't have to. So we keep a cache bit in
   * the inode ->i_opflags field that says "yes, we can
   * do lookup on this inode".
   */
  static inline int can_lookup(struct inode *inode)
  {
  	if (likely(inode->i_opflags & IOP_LOOKUP))
  		return 1;
  	if (likely(!inode->i_op->lookup))
  		return 0;
  
  	/* We do this once for the lifetime of the inode */
  	spin_lock(&inode->i_lock);
  	inode->i_opflags |= IOP_LOOKUP;
  	spin_unlock(&inode->i_lock);
  	return 1;
  }

  /*
   * We can do the critical dentry name comparison and hashing
   * operations one word at a time, but we are limited to:
   *
   * - Architectures with fast unaligned word accesses. We could
   *   do a "get_unaligned()" if this helps and is sufficiently
   *   fast.
   *
   * - Little-endian machines (so that we can generate the mask
   *   of low bytes efficiently). Again, we *could* do a byte
   *   swapping load on big-endian architectures if that is not
   *   expensive enough to make the optimization worthless.
   *
   * - non-CONFIG_DEBUG_PAGEALLOC configurations (so that we
   *   do not trap on the (extremely unlikely) case of a page
   *   crossing operation.
   *
   * - Furthermore, we need an efficient 64-bit compile for the
   *   64-bit case in order to generate the "number of bytes in
   *   the final mask". Again, that could be replaced with a
   *   efficient population count instruction or similar.
   */
  #ifdef CONFIG_DCACHE_WORD_ACCESS

  #include <asm/word-at-a-time.h>

  #ifdef CONFIG_64BIT

  
  static inline unsigned int fold_hash(unsigned long hash)
  {
  	hash += hash >> (8*sizeof(int));
  	return hash;
  }
  
  #else	/* 32-bit case */

  #define fold_hash(x) (x)
  
  #endif
  
  unsigned int full_name_hash(const unsigned char *name, unsigned int len)
  {
  	unsigned long a, mask;
  	unsigned long hash = 0;
  
  	for (;;) {

  		a = load_unaligned_zeropad(name);

  		if (len < sizeof(unsigned long))
  			break;
  		hash += a;

  		hash *= 9;

  		name += sizeof(unsigned long);
  		len -= sizeof(unsigned long);
  		if (!len)
  			goto done;
  	}
  	mask = ~(~0ul << len*8);
  	hash += mask & a;
  done:
  	return fold_hash(hash);
  }
  EXPORT_SYMBOL(full_name_hash);

  /*
   * Calculate the length and hash of the path component, and
   * return the length of the component;
   */
  static inline unsigned long hash_name(const char *name, unsigned int *hashp)
  {

  	unsigned long a, b, adata, bdata, mask, hash, len;
  	const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS;

  
  	hash = a = 0;
  	len = -sizeof(unsigned long);
  	do {
  		hash = (hash + a) * 9;
  		len += sizeof(unsigned long);

  		a = load_unaligned_zeropad(name+len);

  		b = a ^ REPEAT_BYTE('/');
  	} while (!(has_zero(a, &adata, &constants) | has_zero(b, &bdata, &constants)));
  
  	adata = prep_zero_mask(a, adata, &constants);
  	bdata = prep_zero_mask(b, bdata, &constants);
  
  	mask = create_zero_mask(adata | bdata);
  
  	hash += a & zero_bytemask(mask);

  	*hashp = fold_hash(hash);

  	return len + find_zero(mask);

  }
  
  #else

  unsigned int full_name_hash(const unsigned char *name, unsigned int len)
  {
  	unsigned long hash = init_name_hash();
  	while (len--)
  		hash = partial_name_hash(*name++, hash);
  	return end_name_hash(hash);
  }

  EXPORT_SYMBOL(full_name_hash);

  /*

   * We know there's a real path component here of at least
   * one character.
   */
  static inline unsigned long hash_name(const char *name, unsigned int *hashp)
  {
  	unsigned long hash = init_name_hash();
  	unsigned long len = 0, c;
  
  	c = (unsigned char)*name;
  	do {
  		len++;
  		hash = partial_name_hash(c, hash);
  		c = (unsigned char)name[len];
  	} while (c && c != '/');
  	*hashp = end_name_hash(hash);
  	return len;
  }

  #endif

  /*

   * Name resolution.

   * This is the basic name resolution function, turning a pathname into
   * the final dentry. We expect 'base' to be positive and a directory.

   *

   * Returns 0 and nd will have valid dentry and mnt on success.
   * Returns error and drops reference to input namei data on failure.

   */

  static int link_path_walk(const char *name, struct nameidata *nd)

  {
  	struct path next;

  	int err;

  	
  	while (*name=='/')
  		name++;
  	if (!*name)

  		return 0;

  	/* At this point we know we have a real path component. */
  	for(;;) {

  		struct qstr this;

  		long len;

  		int type;

  		err = may_lookup(nd);

   		if (err)
  			break;

  		len = hash_name(name, &this.hash);

  		this.name = name;

  		this.len = len;

  		type = LAST_NORM;

  		if (name[0] == '.') switch (len) {

  			case 2:

  				if (name[1] == '.') {

  					type = LAST_DOTDOT;

  					nd->flags |= LOOKUP_JUMPED;
  				}

  				break;
  			case 1:
  				type = LAST_DOT;
  		}

  		if (likely(type == LAST_NORM)) {
  			struct dentry *parent = nd->path.dentry;

  			nd->flags &= ~LOOKUP_JUMPED;

  			if (unlikely(parent->d_flags & DCACHE_OP_HASH)) {
  				err = parent->d_op->d_hash(parent, nd->inode,
  							   &this);
  				if (err < 0)
  					break;
  			}
  		}

  		nd->last = this;
  		nd->last_type = type;

  		if (!name[len])

  			return 0;

  		/*
  		 * If it wasn't NUL, we know it was '/'. Skip that
  		 * slash, and continue until no more slashes.
  		 */
  		do {
  			len++;
  		} while (unlikely(name[len] == '/'));
  		if (!name[len])

  			return 0;

  		name += len;

  		err = walk_component(nd, &next, LOOKUP_FOLLOW);