 @@ -1,14 +1,14 @@
-/*	$NetBSD: vfs_lookup.c,v 1.172 2011/04/11 02:21:01 dholland Exp $	*/
+/*	$NetBSD: vfs_lookup.c,v 1.173 2011/04/11 02:21:17 dholland Exp $	*/
 /*
  * Copyright (c) 1982, 1986, 1989, 1993
  *	The Regents of the University of California.  All rights reserved.
  * (c) UNIX System Laboratories, Inc.
  * All or some portions of this file are derived from material licensed
  * to the University of California by American Telephone and Telegraph
  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  * the permission of UNIX System Laboratories, Inc.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
 @@ -27,27 +27,27 @@
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
+ *
  *	@(#)vfs_lookup.c	8.10 (Berkeley) 5/27/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: vfs_lookup.c,v 1.172 2011/04/11 02:21:01 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: vfs_lookup.c,v 1.173 2011/04/11 02:21:17 dholland Exp $");
 #include "opt_magiclinks.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/syslimits.h>
 #include <sys/time.h>
 #include <sys/namei.h>
 #include <sys/vnode.h>
 #include <sys/mount.h>
 #include <sys/errno.h>
 #include <sys/filedesc.h>
 @@ -307,27 +307,30 @@ pathbuf_copyin(const char *userpath, str
 	if (pb == NULL) {
 		return ENOMEM;
+	}
 	error = copyinstr(userpath, pb->pb_path, PATH_MAX, NULL);
 	if (error) {
 		pathbuf_destroy(pb);
 		return error;
+	}
 	*ret = pb;
 	return 0;
+}
 /*
- * XXX should not exist
+ * XXX should not exist:
  *   1. whether a pointer is kernel or user should be statically checkable
  *   2. copyin should be handled by the upper part of the syscall layer,
  *      not in here.
  */
 int
 pathbuf_maybe_copyin(const char *path, enum uio_seg seg, struct pathbuf **ret)
+{
 	if (seg == UIO_USERSPACE) {
 		return pathbuf_copyin(path, ret);
 	} else {
 		*ret = pathbuf_create(path);
 		if (*ret == NULL) {
 			return ENOMEM;
+		}
 		return 0;
+	}
 @@ -366,48 +369,91 @@ pathbuf_stringcopy_put(struct pathbuf *p
 	KASSERT(str == pb->pb_pathcopy);
 	KASSERT(pb->pb_pathcopyuses > 0);
 	pb->pb_pathcopyuses--;
 	if (pb->pb_pathcopyuses == 0) {
 		PNBUF_PUT(pb->pb_pathcopy);
 		pb->pb_pathcopy = NULL;
+	}
+}
 ////////////////////////////////////////////////////////////
 /*
- * Convert a pathname into a pointer to a locked vnode.
+ * namei: convert a pathname into a pointer to a (maybe-locked) vnode,
  * and maybe also its parent directory vnode, and assorted other guff.
  * See namei(9) for the interface documentation.
+ *
+ *
  * The FOLLOW flag is set when symbolic links are to be followed
  * when they occur at the end of the name translation process.
  * Symbolic links are always followed for all other pathname
  * components other than the last.
+ *
  * The segflg defines whether the name is to be copied from user
  * space or kernel space.
+ *
  * Overall outline of namei:
+ *
  *	copy in name
  *	get starting directory
  *	while (!done && !error) {
  *		call lookup to search path.
  *		if symbolic link, massage name in buffer and continue
  *	}
  */
 /*
  * Search a pathname.
  * This is a very central and rather complicated routine.
+ *
  * The pathname is pointed to by ni_ptr and is of length ni_pathlen.
  * The starting directory is passed in. The pathname is descended
  * until done, or a symbolic link is encountered. The variable ni_more
  * is clear if the path is completed; it is set to one if a symbolic
  * link needing interpretation is encountered.
+ *
  * The flag argument is LOOKUP, CREATE, RENAME, or DELETE depending on
  * whether the name is to be looked up, created, renamed, or deleted.
  * When CREATE, RENAME, or DELETE is specified, information usable in
  * creating, renaming, or deleting a directory entry may be calculated.
  * If flag has LOCKPARENT or'ed into it, the parent directory is returned
  * locked.  Otherwise the parent directory is not returned. If the target
  * of the pathname exists and LOCKLEAF is or'ed into the flag the target
  * is returned locked, otherwise it is returned unlocked.  When creating
  * or renaming and LOCKPARENT is specified, the target may not be ".".
  * When deleting and LOCKPARENT is specified, the target may be ".".
+ *
  * Overall outline of lookup:
+ *
  * dirloop:
  *	identify next component of name at ndp->ni_ptr
  *	handle degenerate case where name is null string
  *	if .. and crossing mount points and on mounted filesys, find parent
  *	call VOP_LOOKUP routine for next component name
  *	    directory vnode returned in ni_dvp, locked.
  *	    component vnode returned in ni_vp (if it exists), locked.
  *	if result vnode is mounted on and crossing mount points,
  *	    find mounted on vnode
  *	if more components of name, do next level at dirloop
  *	return the answer in ni_vp, locked if LOCKLEAF set
  *	    if LOCKPARENT set, return locked parent in ni_dvp
  */
 /*
  * Internal state for a namei operation.
+ *
  * cnp is always equal to &ndp->ni_cnp.
  */
 struct namei_state {
 	struct nameidata *ndp;
 	struct componentname *cnp;
 	int docache;			/* == 0 do not cache last component */
 	int rdonly;			/* lookup read-only flag bit */
 	int slashes;
 	unsigned attempt_retry:1;	/* true if error allows emul retry */
 };
 @@ -517,27 +563,27 @@ namei_getstartdir(struct namei_state *st
 	 * XXX: should we hold references to rootdir and erootdir while
 	 * we're running? What happens if a multithreaded process chroots
 	 * during namei?
 	 */
 	vref(startdir);
 	rw_exit(&cwdi->cwdi_lock);
 	return startdir;
+}
 /*
  * Get the directory context for the nfsd case, in parallel to
  * getstartdir. Initializes the rootdir and erootdir state and
- * returns a reference to the passed-instarting dir.
+ * returns a reference to the passed-in starting dir.
  */
 static struct vnode *
 namei_getstartdir_for_nfsd(struct namei_state *state, struct vnode *startdir)
+{
 	/* always use the real root, and never set an emulation root */
 	state->ndp->ni_rootdir = rootvnode;
 	state->ndp->ni_erootdir = NULL;
 	vref(startdir);
 	return startdir;
+}
 @@ -603,37 +649,40 @@ namei_start(struct namei_state *state, s
 		/* no ktrace */
 	} else {
 		startdir = namei_getstartdir(state);
 		namei_ktrace(state);
+	}
 	vn_lock(startdir, LK_EXCLUSIVE | LK_RETRY);
 	*startdir_ret = startdir;
 	return 0;
+}
 /*
- * Check for being at a symlink.
+ * Check for being at a symlink that we're going to follow.
  */
 static inline int
 namei_atsymlink(struct namei_state *state, struct vnode *foundobj)
+{
 	return (foundobj->v_type == VLNK) &&
 		(state->cnp->cn_flags & (FOLLOW|REQUIREDIR));
+}
 /*
  * Follow a symlink.
+ *
  * Updates searchdir. inhibitmagic causes magic symlinks to not be
  * interpreted; this is used by nfsd.
  */
 static inline int
 namei_follow(struct namei_state *state, int inhibitmagic,
 	     struct vnode *searchdir, struct vnode *foundobj,
 	     struct vnode **newsearchdir_ret)
+{
 	struct nameidata *ndp = state->ndp;
 	struct componentname *cnp = state->cnp;
 	struct lwp *self = curlwp;	/* thread doing namei() */
 	struct iovec aiov;		/* uio for reading symbolic links */
 	struct uio auio;
 	char *cp;			/* pointer into pathname argument */
 @@ -711,62 +760,28 @@ namei_follow(struct namei_state *state,
 			searchdir = ndp->ni_rootdir;
+		}
 		vref(searchdir);
 		vn_lock(searchdir, LK_EXCLUSIVE | LK_RETRY);
+	}
 	*newsearchdir_ret = searchdir;
 	return 0;
+}
 //////////////////////////////
 /*
- * Search a pathname.
+ * Inspect the leading path component and update the state accordingly.
  * This is a very central and rather complicated routine.
  * The pathname is pointed to by ni_ptr and is of length ni_pathlen.
  * The starting directory is passed in. The pathname is descended
  * until done, or a symbolic link is encountered. The variable ni_more
  * is clear if the path is completed; it is set to one if a symbolic
  * link needing interpretation is encountered.
  * The flag argument is LOOKUP, CREATE, RENAME, or DELETE depending on
  * whether the name is to be looked up, created, renamed, or deleted.
  * When CREATE, RENAME, or DELETE is specified, information usable in
  * creating, renaming, or deleting a directory entry may be calculated.
  * If flag has LOCKPARENT or'ed into it, the parent directory is returned
  * locked.  Otherwise the parent directory is not returned. If the target
  * of the pathname exists and LOCKLEAF is or'ed into the flag the target
  * is returned locked, otherwise it is returned unlocked.  When creating
  * or renaming and LOCKPARENT is specified, the target may not be ".".
  * When deleting and LOCKPARENT is specified, the target may be ".".
  * Overall outline of lookup:
  * dirloop:
  *	identify next component of name at ndp->ni_ptr
  *	handle degenerate case where name is null string
  *	if .. and crossing mount points and on mounted filesys, find parent
  *	call VOP_LOOKUP routine for next component name
  *	    directory vnode returned in ni_dvp, locked.
  *	    component vnode returned in ni_vp (if it exists), locked.
  *	if result vnode is mounted on and crossing mount points,
  *	    find mounted on vnode
  *	if more components of name, do next level at dirloop
  *	return the answer in ni_vp, locked if LOCKLEAF set
  *	    if LOCKPARENT set, return locked parent in ni_dvp
  */
 static int
 lookup_parsepath(struct namei_state *state)
+{
 	const char *cp;			/* pointer into pathname argument */
 	struct componentname *cnp = state->cnp;
 	struct nameidata *ndp = state->ndp;
 	KASSERT(cnp == &ndp->ni_cnd);
 	/*
 	 * Search a new directory.
+	 *
 @@ -824,26 +839,31 @@ lookup_parsepath(struct namei_state *sta
 	} else {
 		cnp->cn_flags |= MAKEENTRY;
 		cnp->cn_flags &= ~ISLASTCN;
+	}
 	if (cnp->cn_namelen == 2 &&
 	    cnp->cn_nameptr[1] == '.' && cnp->cn_nameptr[0] == '.')
 		cnp->cn_flags |= ISDOTDOT;
 	else
 		cnp->cn_flags &= ~ISDOTDOT;
 	return 0;
+}
 /*
  * Call VOP_LOOKUP for a single lookup; return a new search directory
  * (used when crossing mountpoints up or searching union mounts down) and
  * the found object, which for create operations may be NULL on success.
  */
 static int
 lookup_once(struct namei_state *state,
 	    struct vnode *searchdir,
 	    struct vnode **newsearchdir_ret,
 	    struct vnode **foundobj_ret)
+{
 	struct vnode *tmpvn;		/* scratch vnode */
 	struct vnode *foundobj;		/* result */
 	struct mount *mp;		/* mount table entry */
 	struct lwp *l = curlwp;
 	int error;
 	struct componentname *cnp = state->cnp;
 @@ -955,28 +975,28 @@ unionlookup:
+		}
 		/*
 		 * If creating and at end of pathname, then can consider
 		 * allowing file to be created.
 		 */
 		if (state->rdonly) {
 			return EROFS;
+		}
 		/*
 		 * We return success and a NULL foundobj to indicate
 		 * that the entry doesn't currently exist, leaving a
-		 * pointer to the (possibly locked) directory vnode as
+		 * pointer to the (normally, locked) directory vnode
-		 * searchdir.
+		 * as searchdir.
 		 */
 		*foundobj_ret = NULL;
 		return (0);
+	}
 #ifdef NAMEI_DIAGNOSTIC
 	printf("found\n");
 #endif /* NAMEI_DIAGNOSTIC */
 	/*
 	 * Take into account any additional components consumed by the
 	 * underlying filesystem.  This will include any trailing slashes after
 	 * the last component consumed.
 	 */
 @@ -1015,26 +1035,30 @@ unionlookup:
 			return error;
+		}
 		VOP_UNLOCK(foundobj);
 		vn_lock(searchdir, LK_EXCLUSIVE | LK_RETRY);
 		vn_lock(foundobj, LK_EXCLUSIVE | LK_RETRY);
+	}
 	*foundobj_ret = foundobj;
 	return 0;
+}
 //////////////////////////////
 /*
  * Do a complete path search from a single root directory.
  * (This is called up to twice if TRYEMULROOT is in effect.)
  */
 static int
 namei_oneroot(struct namei_state *state, struct vnode *forcecwd,
 	 int neverfollow, int inhibitmagic)
+{
 	struct nameidata *ndp = state->ndp;
 	struct componentname *cnp = state->cnp;
 	struct vnode *searchdir, *foundobj;
 	const char *cp;
 	int error;
 	error = namei_start(state, forcecwd, &searchdir);
 	if (error) {
 		ndp->ni_dvp = NULL;
 @@ -1320,26 +1344,29 @@ namei_oneroot(struct namei_state *state,
 		if (searchdir == foundobj) {
 			vrele(searchdir);
 		} else {
 			vput(searchdir);
+		}
 		searchdir = NULL;
+	}
 	ndp->ni_dvp = searchdir;
 	ndp->ni_vp = foundobj;
 	return 0;
+}
 /*
  * Do namei; wrapper layer that handles TRYEMULROOT.
  */
 static int
 namei_tryemulroot(struct namei_state *state, struct vnode *forcecwd,
 	 int neverfollow, int inhibitmagic)
+{
 	int error;
 	struct nameidata *ndp = state->ndp;
 	struct componentname *cnp = state->cnp;
 	const char *savepath = NULL;
 	KASSERT(cnp == &ndp->ni_cnd);
 	if (cnp->cn_flags & TRYEMULROOT) {
 @@ -1365,82 +1392,98 @@ namei_tryemulroot(struct namei_state *st
 			strcpy(ndp->ni_pathbuf->pb_path, savepath);
 			pathbuf_stringcopy_put(ndp->ni_pathbuf, savepath);
 			savepath = NULL;
 			goto emul_retry;
+		}
+	}
 	if (savepath != NULL) {
 		pathbuf_stringcopy_put(ndp->ni_pathbuf, savepath);
+	}
 	return error;
+}
 /*
  * External interface.
  */
 int
 namei(struct nameidata *ndp)
+{
 	struct namei_state state;
 	int error;
 	namei_init(&state, ndp);
 	error = namei_tryemulroot(&state, NULL,
 /*!neverfollow*/, 0/*!inhibitmagic*/);
 	namei_cleanup(&state);
 	if (error) {
 		/* make sure no stray refs leak out */
 		KASSERT(ndp->ni_dvp == NULL);
 		KASSERT(ndp->ni_vp == NULL);
+	}
 	return error;
+}
 ////////////////////////////////////////////////////////////
 /*
- * Externally visible interfaces used by nfsd (bletch, yuk, XXX)
+ * External interface used by nfsd. This is basically different from
  * namei only in that it has the ability to pass in the "current
  * directory", and uses an extra flag "neverfollow" for which there's
  * no physical flag defined in namei.h. (There used to be a cut&paste
  * copy of about half of namei in nfsd to allow these minor
  * adjustments to exist.)
+ *
- * The "index" version differs from the "main" version in that it's
+ * XXX: the namei interface should be adjusted so nfsd can just use
- * called from a different place in a different context. For now I
+ * ordinary namei().
  * want to be able to shuffle code in from one call site without
  * affecting the other.
  * It turns out that the "main" version was a cut and pasted copy of
  * namei with a few changes; the "index" version on the other hand
  * always takes a single component and is an elaborate form of calling
  * VOP_LOOKUP once.
  */
 int
 lookup_for_nfsd(struct nameidata *ndp, struct vnode *forcecwd, int neverfollow)
+{
 	struct namei_state state;
 	int error;
 	namei_init(&state, ndp);
 	error = namei_tryemulroot(&state, forcecwd,
 				  neverfollow, 1/*inhibitmagic*/);
 	namei_cleanup(&state);
 	if (error) {
 		/* make sure no stray refs leak out */
 		KASSERT(ndp->ni_dvp == NULL);
 		KASSERT(ndp->ni_vp == NULL);
+	}
 	return error;
+}
 /*
  * A second external interface used by nfsd. This turns out to be a
  * single lookup used by the WebNFS code (ha!) to get "index.html" or
  * equivalent when asked for a directory. It should eventually evolve
  * into some kind of namei_once() call; for the time being it's kind
  * of a mess. XXX.
+ *
  * dholland 20110109: I don't think it works, and I don't think it
  * worked before I started hacking and slashing either, and I doubt
  * anyone will ever notice.
  */
 /*
  * Internals. This calls lookup_once() after setting up the assorted
  * pieces of state the way they ought to be.
  */
 static int
 do_lookup_for_nfsd_index(struct namei_state *state, struct vnode *startdir)
+{
 	int error = 0;
 	struct componentname *cnp = state->cnp;
 	struct nameidata *ndp = state->ndp;
 	struct vnode *foundobj;
 	const char *cp;			/* pointer into pathname argument */
 	KASSERT(cnp == &ndp->ni_cnd);
 	cnp->cn_nameptr = ndp->ni_pnbuf;
 @@ -1484,26 +1527,32 @@ do_lookup_for_nfsd_index(struct namei_st
+	}
 	KASSERT((cnp->cn_flags & LOCKPARENT) == 0);
 	if ((cnp->cn_flags & LOCKLEAF) == 0) {
 		VOP_UNLOCK(foundobj);
+	}
 	return (0);
 bad:
 	ndp->ni_vp = NULL;
 	return (error);
+}
 /*
  * External interface. The partitioning between this function and the
  * above isn't very clear - the above function exists mostly so code
  * that uses "state->" can be shuffled around without having to change
  * it to "state.".
  */
 int
 lookup_for_nfsd_index(struct nameidata *ndp, struct vnode *startdir)
+{
 	struct namei_state state;
 	int error;
 	/*
 	 * Note: the name sent in here (is not|should not be) allowed
 	 * to contain a slash.
 	 */
 	if (strlen(ndp->ni_pathbuf->pb_path) > NAME_MAX) {
 		return ENAMETOOLONG;
+	}