 @@ -1,14 +1,14 @@
-/*  $NetBSD: ops.c,v 1.18 2010/09/29 08:01:10 manu Exp $ */
+/*  $NetBSD: ops.c,v 1.19 2010/10/03 05:46:47 manu Exp $ */
 /*-
  *  Copyright (c) 2010 Emmanuel Dreyfus. All rights reserved.
+ *
  *  Redistribution and use in source and binary forms, with or without
  *  modification, are permitted provided that the following conditions
  *  are met:
  *  1. Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
  *     documentation and/or other materials provided with the distribution.
+ *
 @@ -174,51 +174,59 @@ xchg_msg(pu, opc, pm, len, wait)
+{
 	struct perfuse_state *ps;
 	struct perfuse_node_data *pnd;
 	int error;
 	ps = puffs_getspecific(pu);
 	pnd = NULL;
 	if ((struct puffs_node *)opc != NULL)
 		pnd = PERFUSE_NODE_DATA(opc);
 #ifdef PERFUSE_DEBUG
 	if ((perfuse_diagflags & PDF_FILENAME) && (opc != 0))
 		DPRINTF("file = \"%s\" flags = 0x%x\n",
-			(char *)PNPATH((struct puffs_node *)opc),
+			perfuse_node_path(opc),
 			PERFUSE_NODE_DATA(opc)->pnd_flags);
 #endif
 	if (pnd)
 		pnd->pnd_flags |= PND_INXCHG;
 	error = ps->ps_xchg_msg(pu, pm, len, wait);
 	if (pnd) {
 		pnd->pnd_flags &= ~PND_INXCHG;
 		(void)dequeue_requests(ps, opc, PCQ_AFTERXCHG, DEQUEUE_ALL);
+	}
 	return error;
+}
 static int
 no_access(opc, pcr, mode)
 	puffs_cookie_t opc;
 	const struct puffs_cred *pcr;
 	mode_t mode;
+{
 	struct puffs_node *pn;
 	struct vattr *va;
 	/*
 	 * pcr is NULL for self open through fsync or readdir.
 	 * In both case, access control is useless, as it was
 	 * done before, at open time.
 	 */
 	if (pcr == NULL)
 		return 0;
 	pn = (struct puffs_node *)opc;
 	va = puffs_pn_getvap(pn);
 	return puffs_access(va->va_type, va->va_mode,
 			    va->va_uid, va->va_gid,
 			    mode, pcr);
+}
 static void
 fuse_attr_to_vap(ps, vap, fa)
 	struct perfuse_state *ps;
 	struct vattr *vap;
 	struct fuse_attr *fa;
 @@ -281,62 +289,93 @@ node_lookup_dir_nodot(pu, opc, name, nam
 		*pnp = (struct puffs_node *)opc;
 		return 0;
+	}
 	/*
 	 * For .. we just forget the name part
 	 */
 	if (strncmp(name, "..", namelen) == 0)
 		namelen = 0;
 	namelen = PNPLEN(dpn) + 1 + namelen + 1;
 	if ((path = malloc(namelen)) == NULL)
 		DERR(EX_OSERR, "malloc failed");
-	(void)snprintf(path, namelen, "%s/%s", (char *)PNPATH(dpn), name);
+	(void)snprintf(path, namelen, "%s/%s",
 		       perfuse_node_path((puffs_cookie_t)dpn), name);
 	error = node_lookup_common(pu, opc, path, pnp);
 	free(path);
 	return error;
+}
 static int
 node_lookup_common(pu, opc, path, pnp)
 	struct puffs_usermount *pu;
 	puffs_cookie_t opc;
 	const char *path;
 	struct puffs_node **pnp;
+{
 	struct perfuse_state *ps;
 	struct perfuse_node_data *pnd;
 	perfuse_msg_t *pm;
 	struct fuse_entry_out *feo;
 	struct puffs_node *pn;
 	size_t len;
 	int error;
 	ps = puffs_getspecific(pu);
 #ifdef PERFUSE_DEBUG
 	if (perfuse_diagflags & PDF_FILENAME)
 		DPRINTF("%s: opc = %p, file = \"%s\" looking up \"%s\"\n",
 			__func__, (void *)opc, perfuse_node_path(opc), path);
 #endif
 	/*
 	 * Is the node already known?
 	 */
 	TAILQ_FOREACH(pnd, &PERFUSE_NODE_DATA(opc)->pnd_children, pnd_next) {
 		if ((pnd->pnd_flags & PND_REMOVED) ||
 		    (strcmp(pnd->pnd_name, path) != 0))
 			continue;
 		/*
 		 * We have a match
 		 */
 		if (pnp != NULL)
 			*pnp = (struct puffs_node *)(pnd->pnd_pn);
 #ifdef PERFUSE_DEBUG
 		if (perfuse_diagflags & PDF_FILENAME)
 			DPRINTF("%s: opc = %p, file = \"%s\" found "
 				"cookie = %p, ino = %"PRId64" for \"%s\"\n",
 				__func__, (void *)opc, perfuse_node_path(opc),
 				(void *)pnd->pnd_pn, pnd->pnd_ino, path);
 #endif
 		return 0;
+	}
 	len = strlen(path) + 1;
 	pm = ps->ps_new_msg(pu, opc, FUSE_LOOKUP, len, NULL);
 	(void)strlcpy(_GET_INPAYLOAD(ps, pm, char *), path, len);
 	if ((error = xchg_msg(pu, opc, pm, sizeof(*feo), wait_reply)) != 0)
 		goto out;
 	feo = GET_OUTPAYLOAD(ps, pm, fuse_entry_out);
-	pn = perfuse_new_pn(pu, opc);
+	pn = perfuse_new_pn(pu, path, opc);
 	PERFUSE_NODE_DATA(pn)->pnd_ino = feo->nodeid;
 	fuse_attr_to_vap(ps, &pn->pn_va, &feo->attr);
 	if (pnp != NULL)
 		*pnp = pn;
 #ifdef PERFUSE_DEBUG
 	if (perfuse_diagflags & PDF_FILENAME)
 		DPRINTF("%s: opc = %p, looked up opc = %p, ino = %"PRId64" "
 			"file = \"%s\"\n", __func__, (void *)opc, pn,
 			feo->nodeid, path);
 #endif
 @@ -366,56 +405,65 @@ node_mk_common(pu, opc, pni, pcn, pm)
 	struct fuse_entry_out *feo;
 	struct fuse_setattr_in *fsi;
 	int error;
 	ps =  puffs_getspecific(pu);
 	if ((error = xchg_msg(pu, opc, pm, sizeof(*feo), wait_reply)) != 0)
 		goto out;
 	feo = GET_OUTPAYLOAD(ps, pm, fuse_entry_out);
 	if (feo->nodeid == PERFUSE_UNKNOWN_INO)
 		DERRX(EX_SOFTWARE, "%s: no ino", __func__);
-	pn = perfuse_new_pn(pu, opc);
+	pn = perfuse_new_pn(pu, pcn->pcn_name, opc);
 	PERFUSE_NODE_DATA(pn)->pnd_ino = feo->nodeid;
 	fuse_attr_to_vap(ps, &pn->pn_va, &feo->attr);
 	puffs_newinfo_setcookie(pni, pn);
 #ifdef PERFUSE_DEBUG
 	if (perfuse_diagflags & PDF_FILENAME)
 		DPRINTF("%s: opc = %p, file = \"%s\", flags = 0x%x "
 			"ino = %"PRId64"\n",
 			__func__, (void *)pn, pcn->pcn_name,
 			PERFUSE_NODE_DATA(pn)->pnd_flags, feo->nodeid);
 #endif
 	ps->ps_destroy_msg(pm);
 	/*
 	 * Set owner and group
 	 */
 	(void)puffs_cred_getuid(pcn->pcn_cred, &pn->pn_va.va_uid);
 	(void)puffs_cred_getgid(pcn->pcn_cred, &pn->pn_va.va_gid);
 	pm = ps->ps_new_msg(pu, (puffs_cookie_t)pn,
 			    FUSE_SETATTR, sizeof(*fsi), NULL);
 	fsi = GET_INPAYLOAD(ps, pm, fuse_setattr_in);
 	fsi->uid = pn->pn_va.va_uid;
 	fsi->gid = pn->pn_va.va_gid;
 	fsi->valid = FUSE_FATTR_UID|FUSE_FATTR_GID;
 	/*
 	 * A fuse_attr_out is returned, but we ignore it.
 	 */
 	error = xchg_msg(pu, (puffs_cookie_t)pn,
 			 pm, sizeof(struct fuse_attr_out), wait_reply);
 	/*
 	 * The parent directory needs a sync
 	 */
 	PERFUSE_NODE_DATA(opc)->pnd_flags |= PND_DIRTY;
 out:
 	ps->ps_destroy_msg(pm);
 	return error;
+}
 static ssize_t
 fuse_to_dirent(pu, opc, fd, fd_len)
 	struct puffs_usermount *pu;
 	puffs_cookie_t opc;
 	struct fuse_dirent *fd;
 	size_t fd_len;
+{
 @@ -985,27 +1033,27 @@ perfuse_node_create(pu, opc, pni, pcn, v
 	len = sizeof(*feo) + sizeof(*foo);
 	if ((error = xchg_msg(pu, opc, pm, len, wait_reply)) != 0)
 		goto out;
 	feo = GET_OUTPAYLOAD(ps, pm, fuse_entry_out);
 	foo = (struct fuse_open_out *)(void *)(feo + 1);
 	if (feo->nodeid == PERFUSE_UNKNOWN_INO)
 		DERRX(EX_SOFTWARE, "%s: no ino", __func__);
 	/*
 	 * Save the file handle and inode in node private data
 	 * so that we can reuse it later
 	 */
-	pn = perfuse_new_pn(pu, opc);
+	pn = perfuse_new_pn(pu, name, opc);
 	perfuse_new_fh((puffs_cookie_t)pn, foo->fh, FWRITE);
 	PERFUSE_NODE_DATA(pn)->pnd_ino = feo->nodeid;
 	fuse_attr_to_vap(ps, &pn->pn_va, &feo->attr);
 	puffs_newinfo_setcookie(pni, pn);
 	/*
 	 * The parent directory needs a sync
 	 */
 	PERFUSE_NODE_DATA(opc)->pnd_flags |= PND_DIRTY;
 #ifdef PERFUSE_DEBUG
 	if (perfuse_diagflags & (PDF_FH|PDF_FILENAME))
 @@ -1105,35 +1153,26 @@ perfuse_node_open(pu, opc, mode, pcr)
 	struct fuse_open_out *foo;
 	struct puffs_node *pn;
 	int error;
 	ps = puffs_getspecific(pu);
 	pn = (struct puffs_node *)opc;
 	pnd = PERFUSE_NODE_DATA(opc);
 	pm = NULL;
 	error = 0;
 	if (pnd->pnd_flags & PND_REMOVED)
 		return ENOENT;
 	/*
 	 * Queue open on a node so that we do not open
 	 * twice. This would be better with read and
 	 * write distinguished.
 	 */
 	while (pnd->pnd_flags & PND_INOPEN)
 		requeue_request(pu, opc, PCQ_OPEN);
 	pnd->pnd_flags |= PND_INOPEN;
 	if (puffs_pn_getvap(pn)->va_type == VDIR) {
 		op = FUSE_OPENDIR;
 		pmode = PUFFS_VREAD|PUFFS_VEXEC;
 	} else {
 		op = FUSE_OPEN;
 		if (mode & FWRITE)
 			pmode = PUFFS_VWRITE|PUFFS_VREAD;
 		else
 			pmode = PUFFS_VREAD;
+	}
 	/*
 	 * Opening a directory require R-X on the directory
 @@ -1156,54 +1195,62 @@ perfuse_node_open(pu, opc, mode, pcr)
 	 * if we already have write handle. Just ask for
 	 * inactive, in case the node was open by a create
 	 * operation (we are not allowed to call puffs_setback
 	 * at create time, puffs interface forbids it)
 	 */
 	if (((mode & FREAD) && (pnd->pnd_flags & PND_RFH)) ||
 	    ((mode & FREAD) && (pnd->pnd_flags & PND_WFH)) ||
 	    ((mode & FWRITE) && (pnd->pnd_flags & PND_WFH))) {
 		error = 0;
 		goto out;
+	}
 	/*
 	 * Queue open on a node so that we do not open
 	 * twice. This would be better with read and
 	 * write distinguished.
 	 */
 	while (pnd->pnd_flags & PND_INOPEN)
 		requeue_request(pu, opc, PCQ_OPEN);
 	pnd->pnd_flags |= PND_INOPEN;
 	/*
 	 * Convert PUFFS mode to FUSE mode: convert FREAD/FWRITE
 	 * to O_RDONLY/O_WRONLY while perserving the other options.
 	 */
 	fmode = mode & ~(FREAD|FWRITE);
 	fmode |= (mode & FWRITE) ? O_RDWR : O_RDONLY;
 	pm = ps->ps_new_msg(pu, opc, op, sizeof(*foi), pcr);
 	foi = GET_INPAYLOAD(ps, pm, fuse_open_in);
 	foi->flags = fmode;
 	foi->unused = 0;
 	if ((error = xchg_msg(pu, opc, pm, sizeof(*foo), wait_reply)) != 0)
 		goto out;
 	foo = GET_OUTPAYLOAD(ps, pm, fuse_open_out);
 	/*
 	 * Save the file handle in node private data
 	 * so that we can reuse it later
 	 */
 	perfuse_new_fh(opc, foo->fh, mode);
 #ifdef PERFUSE_DEBUG
 	if (perfuse_diagflags & (PDF_FH|PDF_FILENAME))
 		DPRINTF("%s: opc = %p, file = \"%s\", "
 			"ino = %"PRId64", %s%sfh = 0x%"PRIx64"\n",
-			__func__, (void *)opc,
+			__func__, (void *)opc, perfuse_node_path(opc),
 			(char *)PNPATH((struct puffs_node *)opc),
 			pnd->pnd_ino, mode & FREAD ? "r" : "",
 			mode & FWRITE ? "w" : "", foo->fh);
 #endif
 out:
 	if (pm != NULL)
 		ps->ps_destroy_msg(pm);
 	pnd->pnd_flags &= ~PND_INOPEN;
 	(void)dequeue_requests(ps, opc, PCQ_OPEN, DEQUEUE_ALL);
 	return error;
+}
 @@ -1631,28 +1678,27 @@ perfuse_node_fsync(pu, opc, pcr, flags,
 	if (puffs_pn_getvap((struct puffs_node *)opc)->va_type == VDIR)
 		op = FUSE_FSYNCDIR;
 	else 		/* VREG but also other types such as VLNK */
 		op = FUSE_FSYNC;
 	/*
 	 * Do not sync if there are no change to sync
 	 * XXX remove that test on files if we implement mmap
 	 */
 #ifdef PERFUSE_DEBUG
 	if (perfuse_diagflags & PDF_SYNC)
 		DPRINTF("%s: TEST opc = %p, file = \"%s\" is %sdirty\n",
-			__func__, (void*)opc,
+			__func__, (void*)opc, perfuse_node_path(opc),
 			(char *)PNPATH((struct puffs_node *)opc),
 			pnd->pnd_flags & PND_DIRTY ? "" : "not ");
 #endif
 	if (!(pnd->pnd_flags & PND_DIRTY))
 		return 0;
 	/*
 	 * It seems NetBSD can call fsync without open first
 	 * glusterfs complain in such a situation:
 	 * "FSYNC() ERR => -1 (Invalid argument)"
 	 * The file will be closed at inactive time.
+	 *
 	 * We open the directory for reading in order to sync.
 	 * This sounds rather counterintuitive, but it works.
 @@ -1685,28 +1731,27 @@ perfuse_node_fsync(pu, opc, pcr, flags,
 	if ((error = xchg_msg(pu, opc, pm,
 			      NO_PAYLOAD_REPLY_LEN, wait_reply)) != 0)
 		goto out;
 	/*
 	 * No reply beyond fuse_out_header: nothing to do on success
 	 * just clear the dirty flag
 	 */
 	pnd->pnd_flags &= ~PND_DIRTY;
 #ifdef PERFUSE_DEBUG
 	if (perfuse_diagflags & PDF_SYNC)
 		DPRINTF("%s: CLEAR opc = %p, file = \"%s\"\n",
-			__func__, (void*)opc,
+			__func__, (void*)opc, perfuse_node_path(opc));
 			(char *)PNPATH((struct puffs_node *)opc));
 #endif
 out:
 	/*
 	 * ENOSYS is not returned to kernel,
 	 */
 	if (error == ENOSYS)
 		error = 0;
 	if (pm != NULL)
 		ps->ps_destroy_msg(pm);
 	return error;
 @@ -1762,40 +1807,39 @@ perfuse_node_remove(pu, opc, targ, pcn)
 	 */
 	if (no_access((puffs_cookie_t)pnd->pnd_parent,
 	    pcn->pcn_cred, PUFFS_VWRITE|PUFFS_VEXEC))
 		return EACCES;
 #ifdef PERFUSE_DEBUG
 	if (targ == NULL)
 		DERRX(EX_SOFTWARE, "%s: targ is NULL", __func__);
 	if (perfuse_diagflags & (PDF_FH|PDF_FILENAME))
 		DPRINTF("%s: opc = %p, remove opc = %p, file = \"%s\"\n",
 			__func__, (void *)opc, (void *)targ, pcn->pcn_name);
 #endif
 	ps = puffs_getspecific(pu);
 	pnd = PERFUSE_NODE_DATA(opc);
 	name = pcn->pcn_name;
 	len = pcn->pcn_namelen + 1;
 	/*
 	 * Await for all operations on the deleted node to drain,
 	 * as the filesystem may be confused to have it deleted
 	 * during a getattr
 	 */
 	while (PERFUSE_NODE_DATA(targ)->pnd_flags & PND_INXCHG)
 		requeue_request(pu, targ, PCQ_AFTERXCHG);
 	ps = puffs_getspecific(pu);
 	pnd = PERFUSE_NODE_DATA(opc);
 	name = pcn->pcn_name;
 	len = pcn->pcn_namelen + 1;
 	pm = ps->ps_new_msg(pu, opc, FUSE_UNLINK, len, pcn->pcn_cred);
 	path = _GET_INPAYLOAD(ps, pm, char *);
 	(void)strlcpy(path, name, len);
 	if ((error = xchg_msg(pu, opc, pm, UNSPEC_REPLY_LEN, wait_reply)) != 0)
 		goto out;
 	PERFUSE_NODE_DATA(targ)->pnd_flags |= PND_REMOVED;
 	if (!(PERFUSE_NODE_DATA(targ)->pnd_flags & PND_OPEN))
 		puffs_setback(puffs_cc_getcc(pu), PUFFS_SETBACK_NOREF_N2);
 	/*
 	 * The parent directory needs a sync
 @@ -1910,68 +1954,62 @@ perfuse_node_rename(pu, opc, src, pcn_sr
 	len = sizeof(*fri) + oldname_len + newname_len;
 	pm = ps->ps_new_msg(pu, opc, FUSE_RENAME, len, pcn_src->pcn_cred);
 	fri = GET_INPAYLOAD(ps, pm, fuse_rename_in);
 	fri->newdir = PERFUSE_NODE_DATA(targ_dir)->pnd_ino;
 	np = (char *)(void *)(fri + 1);
 	(void)strlcpy(np, oldname, oldname_len);
 	np += oldname_len;
 	(void)strlcpy(np, newname, newname_len);
 	if ((error = xchg_msg(pu, opc, pm, UNSPEC_REPLY_LEN, wait_reply)) != 0)
 		goto out;
-	PERFUSE_NODE_DATA(opc)->pnd_childcount--;
+	if (opc != targ_dir) {
-	PERFUSE_NODE_DATA(targ_dir)->pnd_childcount++;
+		struct perfuse_node_data *srcdir_pnd;
 		struct perfuse_node_data *dstdir_pnd;
 		struct perfuse_node_data *src_pnd;
 		srcdir_pnd = PERFUSE_NODE_DATA(opc);
 		dstdir_pnd = PERFUSE_NODE_DATA(targ_dir);
 		src_pnd = PERFUSE_NODE_DATA(src);
-	PERFUSE_NODE_DATA(src)->pnd_parent = targ_dir;
+		TAILQ_REMOVE(&srcdir_pnd->pnd_children, src_pnd, pnd_next);
 		TAILQ_INSERT_TAIL(&dstdir_pnd->pnd_children, src_pnd, pnd_next);
-	PERFUSE_NODE_DATA(opc)->pnd_flags |= PND_DIRTY;
+		srcdir_pnd->pnd_childcount--;
-	PERFUSE_NODE_DATA(targ_dir)->pnd_flags |= PND_DIRTY;
+		dstdir_pnd->pnd_childcount++;
-	if ((struct puffs_node *)targ != NULL) {
+		src_pnd->pnd_parent = targ_dir;
 		struct perfuse_node_data *targ_pnd;
 		struct perfuse_node_data *src_pnd;
-		/*
+		PERFUSE_NODE_DATA(targ_dir)->pnd_flags |= PND_DIRTY;
 		 * We overwrite a node. src must be freed, as it
 		 * is associated in kernel with the old path. We
 		 * therefore have to transfer perfuse_node_data
 		 * from src to targ.
 		 * src cannot be destroyed here as setback is not
 		 * allowed in rename operation. The node is tagged
 		 * with PND_REMOVED, it will be disposed at inactive
 		 * time.
 		 */
 		targ_pnd = PERFUSE_NODE_DATA(targ);
 		src_pnd = PERFUSE_NODE_DATA(src);
 		puffs_pn_setpriv((struct puffs_node *)targ, src_pnd);
 		puffs_pn_setpriv((struct puffs_node *)src, targ_pnd);
 		PERFUSE_NODE_DATA(src)->pnd_flags |= PND_REMOVED;
+	}
 	(void)strlcpy(PERFUSE_NODE_DATA(src)->pnd_name, newname, MAXPATHLEN);
 	PERFUSE_NODE_DATA(opc)->pnd_flags |= PND_DIRTY;
 	if ((struct puffs_node *)targ != NULL)
 		PERFUSE_NODE_DATA(targ)->pnd_flags |= PND_REMOVED;
 #ifdef PERFUSE_DEBUG
 	if (perfuse_diagflags & PDF_FILENAME)
 		DPRINTF("%s: nodeid = %"PRId64" file = \"%s\" renamed \"%s\" "
-			"from nodeid = %"PRId64" \"%s\" "
+			"nodeid = %"PRId64" -> nodeid = %"PRId64" \"%s\"\n",
-			"to nodeid = %"PRId64" \"%s\"\n",
+	 		__func__, PERFUSE_NODE_DATA(src)->pnd_ino,
-	 		__func__,
+			pcn_src->pcn_name, pcn_targ->pcn_name,
-			PERFUSE_NODE_DATA(src)->pnd_ino, pcn_src->pcn_name,
+			PERFUSE_NODE_DATA(opc)->pnd_ino,
 			pcn_targ->pcn_name, PERFUSE_NODE_DATA(opc)->pnd_ino,
 			(char *)PNPATH((struct puffs_node *)targ_dir),
 			PERFUSE_NODE_DATA(targ_dir)->pnd_ino,
-			(char *)PNPATH((struct puffs_node *)opc));
+			perfuse_node_path(targ_dir));
 #endif
 out:
 	if (pm != NULL)
 		ps->ps_destroy_msg(pm);
 	return error;
+}
 int
 perfuse_node_mkdir(pu, opc, pni, pcn, vap)
 	struct puffs_usermount *pu;
 	puffs_cookie_t opc;
 @@ -2034,52 +2072,51 @@ perfuse_node_rmdir(pu, opc, targ, pcn)
 	 */
 	if (no_access((puffs_cookie_t)pnd->pnd_parent,
 	    pcn->pcn_cred, PUFFS_VWRITE|PUFFS_VEXEC))
 		return EACCES;
 	/*
 	 * Await for all operations on the deleted node to drain,
 	 * as the filesystem may be confused to have it deleted
 	 * during a getattr
 	 */
 	while (PERFUSE_NODE_DATA(targ)->pnd_flags & PND_INXCHG)
 		requeue_request(pu, targ, PCQ_AFTERXCHG);
 	ps = puffs_getspecific(pu);
 	name = pcn->pcn_name;
 	len = pcn->pcn_namelen + 1;
 	pm = ps->ps_new_msg(pu, opc, FUSE_RMDIR, len, pcn->pcn_cred);
 	path = _GET_INPAYLOAD(ps, pm, char *);
 	(void)strlcpy(path, name, len);
 	if ((error = xchg_msg(pu, opc, pm, UNSPEC_REPLY_LEN, wait_reply)) != 0)
 		goto out;
 	PERFUSE_NODE_DATA(targ)->pnd_flags |= PND_REMOVED;
 	if (!(PERFUSE_NODE_DATA(targ)->pnd_flags & PND_OPEN))
 		puffs_setback(puffs_cc_getcc(pu), PUFFS_SETBACK_NOREF_N2);
 	/*
 	 * The parent directory needs a sync
 	 */
 	PERFUSE_NODE_DATA(opc)->pnd_flags |= PND_DIRTY;
 #ifdef PERFUSE_DEBUG
 	if (perfuse_diagflags & PDF_FILENAME)
 		DPRINTF("%s: remove nodeid = %"PRId64" file = \"%s\"\n",
 			__func__, PERFUSE_NODE_DATA(targ)->pnd_ino,
-			(char *)PNPATH((struct puffs_node *)targ));
+			perfuse_node_path(targ));
 #endif
 out:
 	ps->ps_destroy_msg(pm);
 	return error;
+}
 /* vap is unused */
 /* ARGSUSED4 */
 int
 perfuse_node_symlink(pu, opc, pni, pcn_src, vap, link_target)
 	struct puffs_usermount *pu;
 	puffs_cookie_t opc;
 @@ -2359,41 +2396,41 @@ perfuse_node_reclaim(pu, opc)
 	pnd = PERFUSE_NODE_DATA(opc);
 	/*
 	 * Never forget the root.
 	 */
 	if (pnd->pnd_ino == FUSE_ROOT_ID)
 		return 0;
 	pnd->pnd_flags |= PND_RECLAIMED;
 #ifdef PERFUSE_DEBUG
 	if (perfuse_diagflags & PDF_RECLAIM)
 		DPRINTF("%s (nodeid %"PRId64") reclaimed\n",
-		       (char *)PNPATH((struct puffs_node *)opc), pnd->pnd_ino);
+			perfuse_node_path(opc), pnd->pnd_ino);
 #endif
 	pn_root = puffs_getroot(pu);
 	pn = (struct puffs_node *)opc;
 	while (pn != pn_root) {
 		struct puffs_node *parent_pn;
 		pnd = PERFUSE_NODE_DATA(pn);
 #ifdef PERFUSE_DEBUG
 	if (perfuse_diagflags & PDF_RECLAIM)
 		DPRINTF("%s (nodeid %"PRId64") is %sreclaimed, "
 			"has childcount %d %s%s%s%s, pending ops:%s%s%s\n",
-		        (char *)PNPATH(pn), pnd->pnd_ino,
+		        perfuse_node_path((puffs_cookie_t)pn), pnd->pnd_ino,
 		        pnd->pnd_flags & PND_RECLAIMED ? "" : "not ",
 		        pnd->pnd_childcount,
 			pnd->pnd_flags & PND_OPEN ? "open " : "not open",
 			pnd->pnd_flags & PND_RFH ? "r" : "",
 			pnd->pnd_flags & PND_WFH ? "w" : "",
 			pnd->pnd_flags & PND_BUSY ? "" : " none",
 			pnd->pnd_flags & PND_INREADDIR ? " readdir" : "",
 			pnd->pnd_flags & PND_INWRITE ? " write" : "",
 			pnd->pnd_flags & PND_INOPEN ? " open" : "");
 #endif
 		if (!(pnd->pnd_flags & PND_RECLAIMED) ||
 		    (pnd->pnd_childcount != 0))
 @@ -2430,28 +2467,30 @@ perfuse_node_reclaim(pu, opc)
 		perfuse_destroy_pn(pu, pn);
 		pn = parent_pn;
+	}
 	return 0;
+}
 int
 perfuse_node_inactive(pu, opc)
 	struct puffs_usermount *pu;
 	puffs_cookie_t opc;
+{
 	struct perfuse_state *ps;
 	struct perfuse_node_data *pnd;
 	ps = puffs_getspecific(pu);
 	pnd = PERFUSE_NODE_DATA(opc);
 	if (!(pnd->pnd_flags & (PND_OPEN|PND_REMOVED)))
 		return 0;
 	/*
 	 * Make sure all operation are finished
 	 * There can be an ongoing write. Other
 	 * operation wait for all data before
 	 * the close/inactive.
 	 */
 	while (pnd->pnd_flags & PND_INWRITE)
 		requeue_request(pu, opc, PCQ_AFTERWRITE);
 @@ -2471,31 +2510,38 @@ perfuse_node_inactive(pu, opc)
 	 */
 	if (pnd->pnd_flags & PND_DIRTY)
 		(void)perfuse_node_fsync(pu, opc, NULL, 0, 0, 0);
 	/*
 	 * Close handles
 	 */
 	if (pnd->pnd_flags & PND_WFH)
 		(void)perfuse_node_close_common(pu, opc, FWRITE);
 	if (pnd->pnd_flags & PND_RFH)
 		(void)perfuse_node_close_common(pu, opc, FREAD);
-	pnd->pnd_flags &= ~PND_INOPEN;
+	/*
 	 * This will cause a reclaim to be sent
 	 */
 	if (pnd->pnd_flags & PND_REMOVED)
 		puffs_setback(puffs_cc_getcc(pu), PUFFS_SETBACK_NOREF_N1);
 	/*
 	 * Schedule awaiting operations
 	 */
 	pnd->pnd_flags &= ~PND_INOPEN;
 	(void)dequeue_requests(ps, opc, PCQ_OPEN, DEQUEUE_ALL);
 	return 0;
+}
 /* ARGSUSED0 */
 int
 perfuse_node_print(pu, opc)
 	struct puffs_usermount *pu;
 	puffs_cookie_t opc;
+{
 	DERRX(EX_SOFTWARE, "%s: UNIMPLEMENTED (FATAL)", __func__);
 	return 0;
+}
 @@ -2804,28 +2850,27 @@ perfuse_node_write(pu, opc, buf, offset,
 	if (ioflag & (IO_SYNC|IO_DSYNC))
 		ps->ps_syncwrites++;
 	else
 		ps->ps_asyncwrites++;
 	/*
 	 * Remember to sync the file
 	 */
 	pnd->pnd_flags |= PND_DIRTY;
 #ifdef PERFUSE_DEBUG
 	if (perfuse_diagflags & PDF_SYNC)
 		DPRINTF("%s: DIRTY opc = %p, file = \"%s\"\n",
-			__func__, (void*)opc,
+			__func__, (void*)opc, perfuse_node_path(opc));
 			(char *)PNPATH((struct puffs_node *)opc));
 #endif
 out:
 	if (pm != NULL)
 		ps->ps_destroy_msg(pm);
 	/*
 	 * If there are no more queued write, we can resume
 	 * an operation awaiting write completion.
 	 */
 	pnd->pnd_flags &= ~PND_INWRITE;
 	if (dequeue_requests(ps, opc, PCQ_WRITE, 1) == 0)
 		(void)dequeue_requests(ps, opc, PCQ_AFTERWRITE, DEQUEUE_ALL);

 @@ -1,14 +1,14 @@
-/*  $NetBSD: perfuse_priv.h,v 1.13 2010/09/29 08:01:10 manu Exp $ */
+/*  $NetBSD: perfuse_priv.h,v 1.14 2010/10/03 05:46:47 manu Exp $ */
 /*-
  *  Copyright (c) 2010 Emmanuel Dreyfus. All rights reserved.
+ *
  *  Redistribution and use in source and binary forms, with or without
  *  modification, are permitted provided that the following conditions
  *  are met:
  *  1. Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
  *     documentation and/or other materials provided with the distribution.
+ *
 @@ -55,28 +55,26 @@ struct perfuse_state {
 	uint64_t ps_asyncwrites;
 	char *ps_source;
 	char *ps_target;
 	char *ps_filesystemtype;
 	int ps_mountflags;
 	uint64_t ps_unique;
 	perfuse_new_msg_fn ps_new_msg;
 	perfuse_xchg_msg_fn ps_xchg_msg;
 	perfuse_destroy_msg_fn ps_destroy_msg;
 	perfuse_get_inhdr_fn ps_get_inhdr;
 	perfuse_get_inpayload_fn ps_get_inpayload;
 	perfuse_get_outhdr_fn ps_get_outhdr;
 	perfuse_get_outpayload_fn ps_get_outpayload;
 	TAILQ_HEAD(, perfuse_node_data) ps_pnd;
 	int ps_pnd_count;
 };
 enum perfuse_qtype {
 	PCQ_READDIR,
 	PCQ_READ,
 	PCQ_WRITE,
 	PCQ_AFTERWRITE,
 	PCQ_OPEN,
 	PCQ_AFTERXCHG
 };
 #ifdef PERFUSE_DEBUG
 @@ -110,53 +108,56 @@ struct perfuse_node_data {
 #define PND_REMOVED		0x020	/* Node was removed */
 #define PND_INWRITE		0x040	/* write in progress */
 #define PND_INOPEN		0x100	/* open in progress */
 #define PND_GOTSIZE		0x200	/* pnd_size was set */
 #define PND_INXCHG		0x400	/* FUSE exchange in progress */
 #define PND_OPEN		(PND_RFH|PND_WFH)	/* File is open */
 #define PND_BUSY		(PND_INREADDIR|PND_INWRITE|PND_INOPEN)
 	puffs_cookie_t pnd_parent;
 	int pnd_childcount;
 	time_t pnd_timestamp;
 	TAILQ_ENTRY(perfuse_node_data) pnd_next;
 	puffs_cookie_t pnd_pn;
 	char pnd_name[MAXPATHLEN];	/* node name */
 	TAILQ_HEAD(,perfuse_node_data) pnd_children;
 };
 #define PERFUSE_NODE_DATA(opc)	\
 	((struct perfuse_node_data *)puffs_pn_getpriv((struct puffs_node *)opc))
 #define UNSPEC_REPLY_LEN PERFUSE_UNSPEC_REPLY_LEN /* shorter! */
 #define NO_PAYLOAD_REPLY_LEN 0
 #define GET_INHDR(ps, pm) ps->ps_get_inhdr(pm)
 #define GET_INPAYLOAD(ps, pm, type) \
 	(struct type *)(void *)ps->ps_get_inpayload(pm)
 #define _GET_INPAYLOAD(ps, pm, type) (type)ps->ps_get_inpayload(pm)
 #define GET_OUTHDR(ps, pm) ps->ps_get_outhdr(pm)
 #define GET_OUTPAYLOAD(ps, pm, type) \
 	(struct type *)(void *)ps->ps_get_outpayload(pm)
 #define _GET_OUTPAYLOAD(ps, pm, type) (type)ps->ps_get_outpayload(pm)
 __BEGIN_DECLS
-struct puffs_node *perfuse_new_pn(struct puffs_usermount *,
+struct puffs_node *perfuse_new_pn(struct puffs_usermount *, const char *,
     struct puffs_node *);
 void perfuse_destroy_pn(struct puffs_usermount *, struct puffs_node *);
 void perfuse_new_fh(puffs_cookie_t, uint64_t, int);
 void perfuse_destroy_fh(puffs_cookie_t, uint64_t);
 uint64_t perfuse_get_fh(puffs_cookie_t, int);
 uint64_t perfuse_next_unique(struct puffs_usermount *);
 char *perfuse_node_path(puffs_cookie_t);
 int perfuse_node_close_common(struct puffs_usermount *, puffs_cookie_t, int);
 char *perfuse_fs_mount(int, ssize_t);
 /*
  * opc.c - filesystem operations
  */
 int perfuse_fs_unmount(struct puffs_usermount *, int);
 int perfuse_fs_statvfs(struct puffs_usermount *, struct statvfs *);
 int perfuse_fs_sync(struct puffs_usermount *, int,
     const struct puffs_cred *);
 int perfuse_fs_fhtonode(struct puffs_usermount *, void *, size_t,

 @@ -1,14 +1,14 @@
-/*  $NetBSD: debug.c,v 1.4 2010/09/29 08:01:10 manu Exp $ */
+/*  $NetBSD: debug.c,v 1.5 2010/10/03 05:46:47 manu Exp $ */
 /*-
  *  Copyright (c) 2010 Emmanuel Dreyfus. All rights reserved.
+ *
  *  Redistribution and use in source and binary forms, with or without
  *  modification, are permitted provided that the following conditions
  *  are met:
  *  1. Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
  *     documentation and/or other materials provided with the distribution.
+ *
 @@ -74,27 +74,27 @@ const struct perfuse_opcode perfuse_opco
 	{ FUSE_BMAP, "BMAP" },
 	{ FUSE_DESTROY, "DESTROY" },
 	{ FUSE_IOCTL, "IOCTL" },
 	{ FUSE_POLL, "POLL" },
 	{ FUSE_CUSE_INIT, "CUSE_INIT" },
 	{ 0, "UNKNOWN" },
 };
 const char *perfuse_qtypestr[] = {
 	"READDIR",
 	"READ",
 	"WRITE",
 	"AFTERWRITE",
-	"OPEN"
+	"OPEN",
 	"AFTERXCHG"
 };
 const char *
 perfuse_opname(opcode)
 	int opcode;
+{
 	const struct perfuse_opcode *po;
 	for (po = perfuse_opcode; po->opcode; po++) {
 		if (po->opcode == opcode)
 			return po->opname;
+	}

 @@ -1,14 +1,14 @@
-/*  $NetBSD: perfuse.c,v 1.9 2010/09/29 08:01:10 manu Exp $ */
+/*  $NetBSD: perfuse.c,v 1.10 2010/10/03 05:46:47 manu Exp $ */
 /*-
  *  Copyright (c) 2010 Emmanuel Dreyfus. All rights reserved.
+ *
  *  Redistribution and use in source and binary forms, with or without
  *  modification, are permitted provided that the following conditions
  *  are met:
  *  1. Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
  *     documentation and/or other materials provided with the distribution.
+ *
 @@ -48,27 +48,26 @@ static struct perfuse_state *init_state(
 static int get_fd(const char *);
 static struct perfuse_state *
 init_state(void)
+{
 	struct perfuse_state *ps;
 	if ((ps = malloc(sizeof(*ps))) == NULL)
 		DERR(EX_OSERR, "malloc failed");
 	(void)memset(ps, 0, sizeof(*ps));
 	ps->ps_max_write = UINT_MAX;
 	ps->ps_max_readahead = UINT_MAX;
 	TAILQ_INIT(&ps->ps_pnd);
 	return ps;
+}
 static int
 get_fd(data)
 	const char *data;
+{
 	char *string;
 	const char fdopt[] = "fd=";
 	char *lastp;
 	char *opt;
 @@ -401,38 +400,35 @@ perfuse_init(pc, pmi)
 	PUFFSOP_SET(pops, perfuse, node, readlink);
 	PUFFSOP_SET(pops, perfuse, node, reclaim);
 	PUFFSOP_SET(pops, perfuse, node, inactive);
 	PUFFSOP_SET(pops, perfuse, node, print);
 	PUFFSOP_SET(pops, perfuse, node, advlock);
 	PUFFSOP_SET(pops, perfuse, node, read);
 	PUFFSOP_SET(pops, perfuse, node, write);
 	puffs_flags = PUFFS_KFLAG_WTCACHE;
 	if (perfuse_diagflags & PDF_PUFFS)
 		puffs_flags |= PUFFS_FLAG_OPDUMP;
 	if (perfuse_diagflags & PDF_FILENAME)
 		puffs_flags |= PUFFS_FLAG_BUILDPATH;
 	if ((pu = puffs_init(pops, _PATH_PUFFS, name, ps, puffs_flags)) == NULL)
 		DERR(EX_OSERR, "puffs_init failed");
 	ps->ps_pu = pu;
 	/*
 	 * Setup filesystem root
 	 */
-	pn_root = perfuse_new_pn(pu, NULL);
+	pn_root = perfuse_new_pn(pu, "", NULL);
 	PERFUSE_NODE_DATA(pn_root)->pnd_ino = FUSE_ROOT_ID;
 	PERFUSE_NODE_DATA(pn_root)->pnd_parent = pn_root;
 	puffs_setroot(pu, pn_root);
 	ps->ps_fsid = pn_root->pn_va.va_fsid;
 	po_root = puffs_getrootpathobj(pu);
 	if ((po_root->po_path = strdup("/")) == NULL)
 		DERRX(EX_OSERR, "perfuse_mount_start() failed");
 	po_root->po_len = 1;
 	puffs_path_buildhash(pu, po_root);
 	puffs_vattr_null(&pn_root->pn_va);

 @@ -1,14 +1,14 @@
-/*  $NetBSD: subr.c,v 1.7 2010/09/29 08:01:10 manu Exp $ */
+/*  $NetBSD: subr.c,v 1.8 2010/10/03 05:46:47 manu Exp $ */
 /*-
  *  Copyright (c) 2010 Emmanuel Dreyfus. All rights reserved.
+ *
  *  Redistribution and use in source and binary forms, with or without
  *  modification, are permitted provided that the following conditions
  *  are met:
  *  1. Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
  *     documentation and/or other materials provided with the distribution.
+ *
 @@ -26,75 +26,87 @@
  */
 #include <stdio.h>
 #include <stdlib.h>
 #include <err.h>
 #include <errno.h>
 #include <sysexits.h>
 #include <syslog.h>
 #include <puffs.h>
 #include <paths.h>
 #include "perfuse_priv.h"
 static size_t node_path(puffs_cookie_t, char *, size_t);
 struct puffs_node *
-perfuse_new_pn(pu, parent)
+perfuse_new_pn(pu, name, parent)
 	struct puffs_usermount *pu;
 	const char *name;
 	struct puffs_node *parent;
+{
 	struct perfuse_state *ps;
 	struct puffs_node *pn;
 	struct perfuse_node_data *pnd;
 	ps = puffs_getspecific(pu);
 	if ((pnd = malloc(sizeof(*pnd))) == NULL)
 		DERR(EX_OSERR, "malloc failed");
 	if ((pn = puffs_pn_new(pu, pnd)) == NULL)
 		DERR(EX_SOFTWARE, "puffs_pn_new failed");
 	(void)memset(pnd, 0, sizeof(*pnd));
 	pnd->pnd_rfh = FUSE_UNKNOWN_FH;
 	pnd->pnd_wfh = FUSE_UNKNOWN_FH;
 	pnd->pnd_ino = PERFUSE_UNKNOWN_INO;
 	pnd->pnd_nlookup = 1;
 	pnd->pnd_parent = parent;
 	pnd->pnd_timestamp = time(NULL);
 	pnd->pnd_pn = (puffs_cookie_t)pn;
 	(void)strlcpy(pnd->pnd_name, name, MAXPATHLEN);
 	TAILQ_INIT(&pnd->pnd_pcq);
 	TAILQ_INIT(&pnd->pnd_children);
 	if (parent != NULL) {
 		struct perfuse_node_data *parent_pnd;
-	TAILQ_INSERT_TAIL(&ps->ps_pnd, pnd, pnd_next);
+		parent_pnd = PERFUSE_NODE_DATA(parent);
-	ps->ps_pnd_count++;
+		TAILQ_INSERT_TAIL(&parent_pnd->pnd_children, pnd, pnd_next);
-	if (parent != NULL)
+		parent_pnd->pnd_childcount++;
 		PERFUSE_NODE_DATA(parent)->pnd_childcount++;
 	return pn;
+}
 void
 perfuse_destroy_pn(pu, pn)
 	struct puffs_usermount *pu;
 	struct puffs_node *pn;
+{
 	struct perfuse_state *ps;
 	struct perfuse_node_data *pnd;
 	ps = puffs_getspecific(pu);
 	pnd = PERFUSE_NODE_DATA(pn);
-	TAILQ_REMOVE(&ps->ps_pnd, pnd, pnd_next);
+	if (pnd->pnd_parent != NULL) {
-	ps->ps_pnd_count--;
+		struct perfuse_node_data *parent_pnd;
 		parent_pnd = PERFUSE_NODE_DATA(pnd->pnd_parent);
 		TAILQ_REMOVE(&parent_pnd->pnd_children, pnd, pnd_next);
+	}
 	if ((pnd = puffs_pn_getpriv(pn)) != NULL) {
 		if (pnd->pnd_parent != NULL)
 			PERFUSE_NODE_DATA(pnd->pnd_parent)->pnd_childcount--;
 		if (pnd->pnd_dirent != NULL)
 			free(pnd->pnd_dirent);
 		if (pnd->pnd_all_fd != NULL)
 			free(pnd->pnd_all_fd);
 #ifdef PERFUSE_DEBUG
 		if (pnd->pnd_flags & PND_OPEN)
 			DERRX(EX_SOFTWARE, "%s: file open", __func__);
 @@ -187,13 +199,44 @@ perfuse_get_fh(opc, mode)
 	if (mode & FREAD) {
 		if (pnd->pnd_flags & PND_RFH)
 			return pnd->pnd_rfh;
 		if (pnd->pnd_flags & PND_WFH)
 			return pnd->pnd_wfh;
+	}
 	return FUSE_UNKNOWN_FH;
+}
 static size_t
 node_path(opc, buf, buflen)
 	puffs_cookie_t opc;
 	char *buf;
 	size_t buflen;
+{
 	struct perfuse_node_data *pnd;
 	size_t written;
 	pnd = PERFUSE_NODE_DATA(opc);
 	if (pnd->pnd_parent == opc)
 		return 0;
 	written = node_path(pnd->pnd_parent, buf, buflen);
 	buf += written;
 	buflen -= written;
 	return written + snprintf(buf, buflen, "/%s", pnd->pnd_name);
+}
 char *
 perfuse_node_path(opc)
 	puffs_cookie_t opc;
+{
 	static char buf[MAXPATHLEN + 1];
 	if (node_path(opc, buf, sizeof(buf)) == 0)
 		sprintf(buf, "/");
 	return buf;
+}