 @@ -1,14 +1,14 @@
-/*	$NetBSD: vfs_lookup.c,v 1.116 2009/06/29 05:00:14 dholland Exp $	*/
+/*	$NetBSD: vfs_lookup.c,v 1.117 2009/08/09 03:28:35 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.116 2009/06/29 05:00:14 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: vfs_lookup.c,v 1.117 2009/08/09 03:28:35 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>
 @@ -206,262 +206,404 @@ symlink_magic(struct proc *p, char *cp,
+ *
  * 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
  *	}
  */
 int
-namei(struct nameidata *ndp)
+/*
  * Internal state for a namei operation.
-	struct cwdinfo *cwdi;		/* pointer to cwd state */
+ */
-	char *cp;			/* pointer into pathname argument */
+struct namei_state {
 	struct nameidata *ndp;
 	struct componentname *cnp;
 	struct vnode *dp;		/* the directory we are searching */
-	struct iovec aiov;		/* uio for reading symbolic links */
+};
 	struct lwp *l = curlwp;		/* thread doing namei() */
-	struct uio auio;
+/*
-	int error;
+ * Initialize the namei working state.
-	size_t linklen;
+ */
-	struct componentname *cnp = &ndp->ni_cnd;
+static void
 namei_init(struct namei_state *state, struct nameidata *ndp)
+{
 	state->ndp = ndp;
 	state->cnp = &ndp->ni_cnd;
 	state->dp = NULL;
+}
 /*
  * Clean up the working namei state, leaving things ready for return
  * from namei.
  */
 static void
 namei_cleanup(struct namei_state *state)
+{
 	KASSERT(state->cnp == &state->ndp->ni_cnd);
 	//KASSERT(state->dp == NULL); 	// not yet
 	/* nothing for now */
 	(void)state;
+}
 //////////////////////////////
 /*
  * Start up namei. Early portion.
+ *
  * This is divided from namei_start2 by the emul_retry: point.
  */
 static void
 namei_start1(struct namei_state *state)
+{
 #ifdef DIAGNOSTIC
-	if (!cnp->cn_cred)
+	if (!state->cnp->cn_cred)
 		panic("namei: bad cred/proc");
-	if (cnp->cn_nameiop & (~OPMASK))
+	if (state->cnp->cn_nameiop & (~OPMASK))
 		panic("namei: nameiop contaminated with flags");
-	if (cnp->cn_flags & OPMASK)
+	if (state->cnp->cn_flags & OPMASK)
 		panic("namei: flags contaminated with nameiops");
 #endif
 	/*
 	 * Get a buffer for the name to be translated, and copy the
 	 * name into the buffer.
 	 */
-	if ((cnp->cn_flags & HASBUF) == 0)
+	if ((state->cnp->cn_flags & HASBUF) == 0)
-		cnp->cn_pnbuf = PNBUF_GET();
+		state->cnp->cn_pnbuf = PNBUF_GET();
     emul_retry:
 /*
  * Start up namei. Copy the path, find the root dir and cwd, establish
  * the starting directory for lookup, and lock it.
  */
 static int
 namei_start2(struct namei_state *state)
+{
 	struct nameidata *ndp = state->ndp;
 	struct componentname *cnp = state->cnp;
 	struct cwdinfo *cwdi;		/* pointer to cwd state */
 	struct lwp *self = curlwp;	/* thread doing namei() */
 	int error;
 	if (ndp->ni_segflg == UIO_SYSSPACE)
 		error = copystr(ndp->ni_dirp, cnp->cn_pnbuf,
 			    MAXPATHLEN, &ndp->ni_pathlen);
 	else
 		error = copyinstr(ndp->ni_dirp, cnp->cn_pnbuf,
 			    MAXPATHLEN, &ndp->ni_pathlen);
 	/*
 	 * POSIX.1 requirement: "" is not a valid file name.
 	 */
 	if (!error && ndp->ni_pathlen == 1)
 		error = ENOENT;
 	if (error) {
 		PNBUF_PUT(cnp->cn_pnbuf);
 		ndp->ni_vp = NULL;
 		return (error);
+	}
 	ndp->ni_loopcnt = 0;
 	/*
 	 * Get root directory for the translation.
 	 */
-	cwdi = l->l_proc->p_cwdi;
+	cwdi = self->l_proc->p_cwdi;
 	rw_enter(&cwdi->cwdi_lock, RW_READER);
-	dp = cwdi->cwdi_rdir;
+	state->dp = cwdi->cwdi_rdir;
-	if (dp == NULL)
+	if (state->dp == NULL)
-		dp = rootvnode;
+		state->dp = rootvnode;
-	ndp->ni_rootdir = dp;
+	ndp->ni_rootdir = state->dp;
 	/*
 	 * Check if starting from root directory or current directory.
 	 */
 	if (cnp->cn_pnbuf[0] == '/') {
 		if (cnp->cn_flags & TRYEMULROOT) {
 			if (cnp->cn_flags & EMULROOTSET) {
 				/* Called from (eg) emul_find_interp() */
-				dp = ndp->ni_erootdir;
+				state->dp = ndp->ni_erootdir;
 			} else {
 				if (cwdi->cwdi_edir == NULL
 				    || (cnp->cn_pnbuf[1] == '.'
 					   && cnp->cn_pnbuf[2] == '.'
 					   && cnp->cn_pnbuf[3] == '/')) {
 					ndp->ni_erootdir = NULL;
 				} else {
-					dp = cwdi->cwdi_edir;
+					state->dp = cwdi->cwdi_edir;
-					ndp->ni_erootdir = dp;
+					ndp->ni_erootdir = state->dp;
+				}
+			}
 		} else {
 			ndp->ni_erootdir = NULL;
 			if (cnp->cn_flags & NOCHROOT)
-				dp = ndp->ni_rootdir = rootvnode;
+				state->dp = ndp->ni_rootdir = rootvnode;
+		}
 	} else {
-		dp = cwdi->cwdi_cdir;
+		state->dp = cwdi->cwdi_cdir;
 		ndp->ni_erootdir = NULL;
+	}
-	VREF(dp);
+	VREF(state->dp);
 	rw_exit(&cwdi->cwdi_lock);
 	/*
 	 * Ktrace it.
 	 */
 	if (ktrpoint(KTR_NAMEI)) {
 		if (ndp->ni_erootdir != NULL) {
 			/*
 			 * To make any sense, the trace entry need to have the
 			 * text of the emulation path prepended.
 			 * Usually we can get this from the current process,
 			 * but when called from emul_find_interp() it is only
 			 * in the exec_package - so we get it passed in ni_next
 			 * (this is a hack).
 			 */
 			const char *emul_path;
 			if (cnp->cn_flags & EMULROOTSET)
 				emul_path = ndp->ni_next;
 			else
-				emul_path = l->l_proc->p_emul->e_path;
+				emul_path = self->l_proc->p_emul->e_path;
 			ktrnamei2(emul_path, strlen(emul_path),
 			    cnp->cn_pnbuf, ndp->ni_pathlen);
 		} else
 			ktrnamei(cnp->cn_pnbuf, ndp->ni_pathlen);
+	}
-	vn_lock(dp, LK_EXCLUSIVE | LK_RETRY);
+	vn_lock(state->dp, LK_EXCLUSIVE | LK_RETRY);
 	return 0;
+}
 /*
  * Undo namei_start: unlock and release the current lookup directory,
  * and discard the path buffer.
  */
 static void
 namei_end(struct namei_state *state)
+{
 	vput(state->dp);
 	PNBUF_PUT(state->cnp->cn_pnbuf);
 	//state->cnp->cn_pnbuf = NULL; // not yet (just in case) (XXX)
+}
 /*
  * Check for being at a symlink.
  */
 static inline int
 namei_atsymlink(struct namei_state *state)
+{
 	return (state->cnp->cn_flags & ISSYMLINK) != 0;
+}
 /*
  * Follow a symlink.
  */
 static inline int
 namei_follow(struct namei_state *state)
+{
 	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 */
 	size_t linklen;
 	int error;
 	if (ndp->ni_loopcnt++ >= MAXSYMLINKS) {
 		return ELOOP;
+	}
 	if (ndp->ni_vp->v_mount->mnt_flag & MNT_SYMPERM) {
 		error = VOP_ACCESS(ndp->ni_vp, VEXEC, cnp->cn_cred);
 		if (error != 0)
 			return error;
+	}
 	if (ndp->ni_pathlen > 1)
 		cp = PNBUF_GET();
 	else
 		cp = cnp->cn_pnbuf;
 	aiov.iov_base = cp;
 	aiov.iov_len = MAXPATHLEN;
 	auio.uio_iov = &aiov;
 	auio.uio_iovcnt = 1;
 	auio.uio_offset = 0;
 	auio.uio_rw = UIO_READ;
 	auio.uio_resid = MAXPATHLEN;
 	UIO_SETUP_SYSSPACE(&auio);
 	error = VOP_READLINK(ndp->ni_vp, &auio, cnp->cn_cred);
 	if (error) {
 badlink:
 		if (ndp->ni_pathlen > 1)
 			PNBUF_PUT(cp);
 		return error;
+	}
 	linklen = MAXPATHLEN - auio.uio_resid;
 	if (linklen == 0) {
 		error = ENOENT;
 		goto badlink;
+	}
 	/*
 	 * Do symlink substitution, if appropriate, and
 	 * check length for potential overflow.
 	 */
 	if ((vfs_magiclinks &&
 	     symlink_magic(self->l_proc, cp, &linklen)) ||
 	    (linklen + ndp->ni_pathlen >= MAXPATHLEN)) {
 		error = ENAMETOOLONG;
 		goto badlink;
+	}
 	if (ndp->ni_pathlen > 1) {
 		memcpy(cp + linklen, ndp->ni_next, ndp->ni_pathlen);
 		PNBUF_PUT(cnp->cn_pnbuf);
 		cnp->cn_pnbuf = cp;
 	} else
 		cnp->cn_pnbuf[linklen] = '\0';
 	ndp->ni_pathlen += linklen;
 	vput(ndp->ni_vp);
 	state->dp = ndp->ni_dvp;
 	/*
 	 * Check if root directory should replace current directory.
 	 */
 	if (cnp->cn_pnbuf[0] == '/') {
 		vput(state->dp);
 		/* Keep absolute symbolic links inside emulation root */
 		state->dp = ndp->ni_erootdir;
 		if (state->dp == NULL || (cnp->cn_pnbuf[1] == '.'
 					  && cnp->cn_pnbuf[2] == '.'
 					  && cnp->cn_pnbuf[3] == '/')) {
 			ndp->ni_erootdir = NULL;
 			state->dp = ndp->ni_rootdir;
+		}
 		VREF(state->dp);
 		vn_lock(state->dp, LK_EXCLUSIVE | LK_RETRY);
+	}
 	return 0;
+}
 //////////////////////////////
 static int
 do_namei(struct namei_state *state)
+{
 	int error;
 	struct nameidata *ndp = state->ndp;
 	struct componentname *cnp = state->cnp;
 	KASSERT(cnp == &ndp->ni_cnd);
 	namei_start1(state);
     emul_retry:
 	error = namei_start2(state);
 	if (error) {
 		return error;
+	}
 	/* Loop through symbolic links */
 	for (;;) {
-		if (!dp->v_mount) {
+		if (!state->dp->v_mount) {
 			/* Give up if the directory is no longer mounted */
-			vput(dp);
+			namei_end(state);
 			PNBUF_PUT(cnp->cn_pnbuf);
 			return (ENOENT);
+		}
 		cnp->cn_nameptr = cnp->cn_pnbuf;
-		ndp->ni_startdir = dp;
+		ndp->ni_startdir = state->dp;
 		error = lookup(ndp);
 		if (error != 0) {
 			/* XXX this should use namei_end() */
 			if (ndp->ni_dvp) {
 				vput(ndp->ni_dvp);
+			}
 			if (ndp->ni_erootdir != NULL) {
 				/* Retry the whole thing from the normal root */
 				cnp->cn_flags &= ~TRYEMULROOT;
 				goto emul_retry;
+			}
 			PNBUF_PUT(cnp->cn_pnbuf);
 			return (error);
+		}
 		/*
 		 * Check for symbolic link
 		 */
-		if ((cnp->cn_flags & ISSYMLINK) == 0) {
+		if (namei_atsymlink(state)) {
-			if ((cnp->cn_flags & LOCKPARENT) == 0 && ndp->ni_dvp) {
+			error = namei_follow(state);
-				if (ndp->ni_dvp == ndp->ni_vp) {
+			if (error) {
-					vrele(ndp->ni_dvp);
+				KASSERT(ndp->ni_dvp != ndp->ni_vp);
-				} else {
+				vput(ndp->ni_dvp);
-					vput(ndp->ni_dvp);
+				vput(ndp->ni_vp);
 				ndp->ni_vp = NULL;
 			if ((cnp->cn_flags & (SAVENAME | SAVESTART)) == 0) {
 				PNBUF_PUT(cnp->cn_pnbuf);
-#if defined(DIAGNOSTIC)
+				return error;
 				cnp->cn_pnbuf = NULL;
 #endif /* defined(DIAGNOSTIC) */
 			} else {
 				cnp->cn_flags |= HASBUF;
+			}
 			return (0);
+		}
 		else {
 		if (ndp->ni_loopcnt++ >= MAXSYMLINKS) {
 			error = ELOOP;
 			break;
+		}
 		if (ndp->ni_vp->v_mount->mnt_flag & MNT_SYMPERM) {
 			error = VOP_ACCESS(ndp->ni_vp, VEXEC, cnp->cn_cred);
 			if (error != 0)
 				break;
 		if (ndp->ni_pathlen > 1)
 			cp = PNBUF_GET();
 		else
 			cp = cnp->cn_pnbuf;
 		aiov.iov_base = cp;
 		aiov.iov_len = MAXPATHLEN;
 		auio.uio_iov = &aiov;
 		auio.uio_iovcnt = 1;
 		auio.uio_offset = 0;
 		auio.uio_rw = UIO_READ;
 		auio.uio_resid = MAXPATHLEN;
 		UIO_SETUP_SYSSPACE(&auio);
 		error = VOP_READLINK(ndp->ni_vp, &auio, cnp->cn_cred);
 		if (error) {
 badlink:
 			if (ndp->ni_pathlen > 1)
 				PNBUF_PUT(cp);
 			break;
 		linklen = MAXPATHLEN - auio.uio_resid;
 		if (linklen == 0) {
 			error = ENOENT;
 			goto badlink;
-		/*
+	/*
-		 * Do symlink substitution, if appropriate, and
+	 * Done
-		 * check length for potential overflow.
+	 */
 		 */
 		if ((vfs_magiclinks &&
 		     symlink_magic(l->l_proc, cp, &linklen)) ||
 		    (linklen + ndp->ni_pathlen >= MAXPATHLEN)) {
 			error = ENAMETOOLONG;
 			goto badlink;
 		if (ndp->ni_pathlen > 1) {
 			memcpy(cp + linklen, ndp->ni_next, ndp->ni_pathlen);
 			PNBUF_PUT(cnp->cn_pnbuf);
 			cnp->cn_pnbuf = cp;
 		} else
 			cnp->cn_pnbuf[linklen] = '\0';
 		ndp->ni_pathlen += linklen;
 		vput(ndp->ni_vp);
 		dp = ndp->ni_dvp;
-		/*
+	if ((cnp->cn_flags & LOCKPARENT) == 0 && ndp->ni_dvp) {
-		 * Check if root directory should replace current directory.
+		if (ndp->ni_dvp == ndp->ni_vp) {
-		 */
+			vrele(ndp->ni_dvp);
-		if (cnp->cn_pnbuf[0] == '/') {
+		} else {
-			vput(dp);
+			vput(ndp->ni_dvp);
 			/* Keep absolute symbolic links inside emulation root */
 			dp = ndp->ni_erootdir;
 			if (dp == NULL || (cnp->cn_pnbuf[1] == '.'
 			    && cnp->cn_pnbuf[2] == '.'
 			    && cnp->cn_pnbuf[3] == '/')) {
 				ndp->ni_erootdir = NULL;
 				dp = ndp->ni_rootdir;
 			VREF(dp);
 			vn_lock(dp, LK_EXCLUSIVE | LK_RETRY);
+		}
+	}
-	/* Failed to process a symbolic link */
+	if ((cnp->cn_flags & (SAVENAME | SAVESTART)) == 0) {
-	KASSERT(ndp->ni_dvp != ndp->ni_vp);
+		PNBUF_PUT(cnp->cn_pnbuf);
-	vput(ndp->ni_dvp);
+#if defined(DIAGNOSTIC)
-	vput(ndp->ni_vp);
+		cnp->cn_pnbuf = NULL;
-	ndp->ni_vp = NULL;
+#endif /* defined(DIAGNOSTIC) */
-	PNBUF_PUT(cnp->cn_pnbuf);
+	} else {
-	return (error);
+		cnp->cn_flags |= HASBUF;
+	}
 	return 0;
+}
 int
 namei(struct nameidata *ndp)
+{
 	struct namei_state state;
 	int error;
 	namei_init(&state, ndp);
 	error = do_namei(&state);
 	namei_cleanup(&state);
 	return error;
+}
 /*
  * Determine the namei hash (for cn_hash) for name.
  * If *ep != NULL, hash from name to ep-1.
  * If *ep == NULL, hash from name until the first NUL or '/', and
  * return the location of this termination character in *ep.
+ *
  * This function returns an equivalent hash to the MI hash32_strn().
  * The latter isn't used because in the *ep == NULL case, determining
  * the length of the string to the first NUL or `/' and then calling
  * hash32_strn() involves unnecessary double-handling of the data.
  */