 @@ -1,14 +1,14 @@
-/*	$NetBSD: puffs_node.c,v 1.19 2011/06/30 20:09:41 wiz Exp $	*/
+/*	$NetBSD: puffs_node.c,v 1.20 2011/08/29 04:12:45 manu Exp $	*/
 /*
  * Copyright (c) 2005, 2006, 2007  Antti Kantee.  All Rights Reserved.
+ *
  * Development of this software was supported by the
  * Google Summer of Code program, the Ulla Tuominen Foundation
  * and the Finnish Cultural Foundation.
+ *
  * 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.
 @@ -20,27 +20,27 @@
  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR 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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: puffs_node.c,v 1.19 2011/06/30 20:09:41 wiz Exp $");
+__KERNEL_RCSID(0, "$NetBSD: puffs_node.c,v 1.20 2011/08/29 04:12:45 manu Exp $");
 #include <sys/param.h>
 #include <sys/hash.h>
 #include <sys/kmem.h>
 #include <sys/malloc.h>
 #include <sys/mount.h>
 #include <sys/namei.h>
 #include <sys/vnode.h>
 #include <fs/puffs/puffs_msgif.h>
 #include <fs/puffs/puffs_sys.h>
 #include <miscfs/genfs/genfs_node.h>
 @@ -145,26 +145,27 @@ puffs_getvnode(struct mount *mp, puffs_c
 	plist = puffs_cookie2hashlist(pmp, ck);
 	mutex_enter(&pmp->pmp_lock);
 	LIST_INSERT_HEAD(plist, pnode, pn_hashent);
 	if (ck != pmp->pmp_root_cookie) {
 		LIST_FOREACH(pnc, &pmp->pmp_newcookie, pnc_entries) {
 			if (pnc->pnc_cookie == ck) {
 				LIST_REMOVE(pnc, pnc_entries);
 				kmem_free(pnc, sizeof(struct puffs_newcookie));
 				break;
+			}
+		}
 		KASSERT(pnc != NULL);
+	}
 	mutex_init(&pnode->pn_sizemtx, MUTEX_DEFAULT, IPL_NONE);
 	mutex_exit(&pmp->pmp_lock);
 	vp->v_data = pnode;
 	vp->v_type = type;
 	pnode->pn_vp = vp;
 	pnode->pn_serversize = vsize;
 	genfs_node_init(vp, &puffs_genfsops);
 	*vpp = vp;
 	DPRINTF(("new vnode at %p, pnode %p, cookie %p\n", vp,
 	    pnode, pnode->pn_cookie));
 @@ -453,19 +454,20 @@ puffs_referencenode(struct puffs_node *p
  * puffs_node instead of the vnode.  Can't use vref()/vrele() on
  * the vnode there, since that causes the lovely VOP_INACTIVE(),
  * which in turn causes the lovely deadlock when called by the one
  * who is supposed to handle it.
  */
 void
 puffs_releasenode(struct puffs_node *pn)
+{
 	mutex_enter(&pn->pn_mtx);
 	if (--pn->pn_refcount == 0) {
 		mutex_exit(&pn->pn_mtx);
 		mutex_destroy(&pn->pn_mtx);
 		mutex_destroy(&pn->pn_sizemtx);
 		seldestroy(&pn->pn_sel);
 		pool_put(&puffs_pnpool, pn);
 	} else {
 		mutex_exit(&pn->pn_mtx);
+	}
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: puffs_vnops.c,v 1.154 2011/07/04 08:07:30 manu Exp $	*/
+/*	$NetBSD: puffs_vnops.c,v 1.155 2011/08/29 04:12:45 manu Exp $	*/
 /*
  * Copyright (c) 2005, 2006, 2007  Antti Kantee.  All Rights Reserved.
+ *
  * Development of this software was supported by the
  * Google Summer of Code program and the Ulla Tuominen Foundation.
  * The Google SoC project was mentored by Bill Studenmund.
+ *
  * 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.
 @@ -20,27 +20,27 @@
  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR 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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: puffs_vnops.c,v 1.154 2011/07/04 08:07:30 manu Exp $");
+__KERNEL_RCSID(0, "$NetBSD: puffs_vnops.c,v 1.155 2011/08/29 04:12:45 manu Exp $");
 #include <sys/param.h>
 #include <sys/buf.h>
 #include <sys/lockf.h>
 #include <sys/malloc.h>
 #include <sys/mount.h>
 #include <sys/namei.h>
 #include <sys/vnode.h>
 #include <sys/proc.h>
 #include <uvm/uvm.h>
 #include <fs/puffs/puffs_msgif.h>
 @@ -829,26 +829,38 @@ puffs_vnop_getattr(void *v)
 		const struct vnodeop_desc *a_desc;
 		struct vnode *a_vp;
 		struct vattr *a_vap;
 		kauth_cred_t a_cred;
 	} */ *ap = v;
 	PUFFS_MSG_VARS(vn, getattr);
 	struct vnode *vp = ap->a_vp;
 	struct mount *mp = vp->v_mount;
 	struct puffs_mount *pmp = MPTOPUFFSMP(mp);
 	struct vattr *vap, *rvap;
 	struct puffs_node *pn = VPTOPP(vp);
 	int error = 0;
 	/*
 	 * A lock is required so that we do not race with
 	 * setattr, write and fsync when changing vp->v_size.
 	 * This is critical, since setting a stall smaler value
 	 * triggers a file truncate in uvm_vnp_setsize(), which
 	 * most of the time means data corruption (a chunk of
 	 * data is replaced by zeroes). This can be removed if
 	 * we decide one day that VOP_GETATTR must operate on
 	 * a locked vnode.
 	 */
 	mutex_enter(&pn->pn_sizemtx);
 	REFPN(pn);
 	vap = ap->a_vap;
 	PUFFS_MSG_ALLOC(vn, getattr);
 	vattr_null(&getattr_msg->pvnr_va);
 	puffs_credcvt(&getattr_msg->pvnr_cred, ap->a_cred);
 	puffs_msg_setinfo(park_getattr, PUFFSOP_VN,
 	    PUFFS_VN_GETATTR, VPTOPNC(vp));
 	PUFFS_MSG_ENQUEUEWAIT2(pmp, park_getattr, vp->v_data, NULL, error);
 	error = checkerr(pmp, error, __func__);
 	if (error)
 		goto out;
 @@ -879,39 +891,44 @@ puffs_vnop_getattr(void *v)
 	if (pn->pn_stat & PNODE_METACACHE_SIZE) {
 		vap->va_size = pn->pn_mc_size;
 	} else {
 		if (rvap->va_size != VNOVAL
 		    && vp->v_type != VBLK && vp->v_type != VCHR) {
 			uvm_vnp_setsize(vp, rvap->va_size);
 			pn->pn_serversize = rvap->va_size;
+		}
+	}
  out:
 	puffs_releasenode(pn);
 	PUFFS_MSG_RELEASE(getattr);
 	mutex_exit(&pn->pn_sizemtx);
 	return error;
+}
 #define SETATTR_CHSIZE	0x01
 #define SETATTR_ASYNC	0x02
 static int
 dosetattr(struct vnode *vp, struct vattr *vap, kauth_cred_t cred, int flags)
+{
 	PUFFS_MSG_VARS(vn, setattr);
 	struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
 	struct puffs_node *pn = vp->v_data;
 	int error = 0;
 	KASSERT(!(flags & SETATTR_CHSIZE) || mutex_owned(&pn->pn_sizemtx));
 	if ((vp->v_mount->mnt_flag & MNT_RDONLY) &&
 	    (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL
 	    || vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL
 	    || vap->va_mode != (mode_t)VNOVAL))
 		return EROFS;
 	if ((vp->v_mount->mnt_flag & MNT_RDONLY)
 	    && vp->v_type == VREG && vap->va_size != VNOVAL)
 		return EROFS;
 	/*
 	 * Flush metacache first.  If we are called with some explicit
 	 * parameters, treat them as information overriding metacache
 @@ -962,28 +979,34 @@ dosetattr(struct vnode *vp, struct vattr
 	return 0;
+}
 int
 puffs_vnop_setattr(void *v)
+{
 	struct vop_getattr_args /* {
 		const struct vnodeop_desc *a_desc;
 		struct vnode *a_vp;
 		struct vattr *a_vap;
 		kauth_cred_t a_cred;
 	} */ *ap = v;
 	struct puffs_node *pn = ap->a_vp->v_data;
 	int error;
-	return dosetattr(ap->a_vp, ap->a_vap, ap->a_cred, SETATTR_CHSIZE);
+	mutex_enter(&pn->pn_sizemtx);
 	error = dosetattr(ap->a_vp, ap->a_vap, ap->a_cred, SETATTR_CHSIZE);
 	mutex_exit(&pn->pn_sizemtx);
 	return error;
+}
 static __inline int
 doinact(struct puffs_mount *pmp, int iaflag)
+{
 	if (EXISTSOP(pmp, INACTIVE))
 		if (pmp->pmp_flags & PUFFS_KFLAG_IAONDEMAND)
 			if (iaflag || ALLOPS(pmp))
 				return 1;
 			else
 				return 0;
 		else
 @@ -1013,48 +1036,50 @@ int
 puffs_vnop_inactive(void *v)
+{
 	struct vop_inactive_args /* {
 		const struct vnodeop_desc *a_desc;
 		struct vnode *a_vp;
 	} */ *ap = v;
 	PUFFS_MSG_VARS(vn, inactive);
 	struct vnode *vp = ap->a_vp;
 	struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
 	struct puffs_node *pnode;
 	int error;
 	pnode = vp->v_data;
 	mutex_enter(&pnode->pn_sizemtx);
 	if (doinact(pmp, pnode->pn_stat & PNODE_DOINACT)) {
 		flushvncache(vp, 0, 0, false);
 		PUFFS_MSG_ALLOC(vn, inactive);
 		puffs_msg_setinfo(park_inactive, PUFFSOP_VN,
 		    PUFFS_VN_INACTIVE, VPTOPNC(vp));
 		PUFFS_MSG_ENQUEUEWAIT2(pmp, park_inactive, vp->v_data,
 		    NULL, error);
 		PUFFS_MSG_RELEASE(inactive);
+	}
 	pnode->pn_stat &= ~PNODE_DOINACT;
 	/*
 	 * file server thinks it's gone?  then don't be afraid care,
 	 * node's life was already all it would ever be
 	 */
 	if (pnode->pn_stat & PNODE_NOREFS) {
 		pnode->pn_stat |= PNODE_DYING;
 		*ap->a_recycle = true;
+	}
 	mutex_exit(&pnode->pn_sizemtx);
 	VOP_UNLOCK(vp);
 	return 0;
+}
 static void
 callreclaim(struct puffs_mount *pmp, puffs_cookie_t ck)
+{
 	PUFFS_MSG_VARS(vn, reclaim);
 	if (!EXISTSOP(pmp, RECLAIM))
 		return;
 @@ -1318,43 +1343,45 @@ flushvncache(struct vnode *vp, off_t off
 int
 puffs_vnop_fsync(void *v)
+{
 	struct vop_fsync_args /* {
 		const struct vnodeop_desc *a_desc;
 		struct vnode *a_vp;
 		kauth_cred_t a_cred;
 		int a_flags;
 		off_t a_offlo;
 		off_t a_offhi;
 	} */ *ap = v;
 	PUFFS_MSG_VARS(vn, fsync);
 	struct vnode *vp = ap->a_vp;
 	struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
 	struct puffs_node *pn = VPTOPP(vp);
 	struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
 	int error, dofaf;
 	mutex_enter(&pn->pn_sizemtx);
 	error = flushvncache(vp, ap->a_offlo, ap->a_offhi,
 	    (ap->a_flags & FSYNC_WAIT) == FSYNC_WAIT);
 	if (error)
-		return error;
+		goto out;
 	/*
 	 * HELLO!  We exit already here if the user server does not
 	 * support fsync OR if we should call fsync for a node which
 	 * has references neither in the kernel or the fs server.
 	 * Otherwise we continue to issue fsync() forward.
 	 */
 	error = 0;
 	if (!EXISTSOP(pmp, FSYNC) || (pn->pn_stat & PNODE_DYING))
-		return 0;
+		goto out;
 	dofaf = (ap->a_flags & FSYNC_WAIT) == 0 || ap->a_flags == FSYNC_LAZY;
 	/*
 	 * We abuse VXLOCK to mean "vnode is going to die", so we issue
 	 * only FAFs for those.  Otherwise there's a danger of deadlock,
 	 * since the execution context here might be the user server
 	 * doing some operation on another fs, which in turn caused a
 	 * vnode to be reclaimed from the freelist for this fs.
 	 */
 	if (dofaf == 0) {
 		mutex_enter(vp->v_interlock);
 		if (vp->v_iflag & VI_XLOCK)
 			dofaf = 1;
 @@ -1367,26 +1394,28 @@ puffs_vnop_fsync(void *v)
 	puffs_credcvt(&fsync_msg->pvnr_cred, ap->a_cred);
 	fsync_msg->pvnr_flags = ap->a_flags;
 	fsync_msg->pvnr_offlo = ap->a_offlo;
 	fsync_msg->pvnr_offhi = ap->a_offhi;
 	puffs_msg_setinfo(park_fsync, PUFFSOP_VN,
 	    PUFFS_VN_FSYNC, VPTOPNC(vp));
 	PUFFS_MSG_ENQUEUEWAIT2(pmp, park_fsync, vp->v_data, NULL, error);
 	PUFFS_MSG_RELEASE(fsync);
 	error = checkerr(pmp, error, __func__);
 out:
 	mutex_exit(&pn->pn_sizemtx);
 	return error;
+}
 int
 puffs_vnop_seek(void *v)
+{
 	struct vop_seek_args /* {
 		const struct vnodeop_desc *a_desc;
 		struct vnode *a_vp;
 		off_t a_oldoff;
 		off_t a_newoff;
 		kauth_cred_t a_cred;
 	} */ *ap = v;
 @@ -1892,37 +1921,40 @@ puffs_vnop_read(void *v)
  */
 int
 puffs_vnop_write(void *v)
+{
 	struct vop_write_args /* {
 		const struct vnodeop_desc *a_desc;
 		struct vnode *a_vp;
 		struct uio *a_uio;
 		int a_ioflag;
 		kauth_cred_t a_cred;
 	} */ *ap = v;
 	PUFFS_MSG_VARS(vn, write);
 	struct vnode *vp = ap->a_vp;
 	struct puffs_node *pn = VPTOPP(vp);
 	struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
 	struct uio *uio = ap->a_uio;
 	size_t tomove, argsize;
 	off_t oldoff, newoff, origoff;
 	vsize_t bytelen;
 	int error, uflags;
 	int ubcflags;
 	error = uflags = 0;
 	write_msg = NULL;
 	mutex_enter(&pn->pn_sizemtx);
 	if (vp->v_type == VREG && PUFFS_USE_PAGECACHE(pmp)) {
 		ubcflags = UBC_WRITE | UBC_PARTIALOK | UBC_UNMAP_FLAG(vp);
 		/*
 		 * userspace *should* be allowed to control this,
 		 * but with UBC it's a bit unclear how to handle it
 		 */
 		if (ap->a_ioflag & IO_APPEND)
 			uio->uio_offset = vp->v_size;
 		origoff = uio->uio_offset;
 		while (uio->uio_resid > 0) {
 			uflags |= PUFFS_UPDATECTIME;
 @@ -2024,26 +2056,27 @@ puffs_vnop_write(void *v)
 			/* adjust file size */
 			if (vp->v_size < uio->uio_offset)
 				uvm_vnp_setsize(vp, uio->uio_offset);
 			/* didn't move everything?  bad userspace.  bail */
 			if (write_msg->pvnr_resid != 0) {
 				error = EIO;
 				break;
+			}
+		}
 		puffs_msgmem_release(park_write);
+	}
 	mutex_exit(&pn->pn_sizemtx);
 	return error;
+}
 int
 puffs_vnop_print(void *v)
+{
 	struct vop_print_args /* {
 		struct vnode *a_vp;
 	} */ *ap = v;
 	PUFFS_MSG_VARS(vn, print);
 	struct vnode *vp = ap->a_vp;
 	struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
 	struct puffs_node *pn = vp->v_data;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: puffs_sys.h,v 1.77 2011/01/11 14:04:54 kefren Exp $	*/
+/*	$NetBSD: puffs_sys.h,v 1.78 2011/08/29 04:12:45 manu Exp $	*/
 /*
  * Copyright (c) 2005, 2006  Antti Kantee.  All Rights Reserved.
+ *
  * Development of this software was supported by the
  * Google Summer of Code program and the Ulla Tuominen Foundation.
  * The Google SoC project was mentored by Bill Studenmund.
+ *
  * 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.
 @@ -199,26 +199,28 @@ struct puffs_node {
 	struct selinfo	pn_sel;		/* for selecting on the node	*/
 	short		pn_revents;	/* available events		*/
 	/* metacache */
 	struct timespec	pn_mc_atime;
 	struct timespec	pn_mc_ctime;
 	struct timespec	pn_mc_mtime;
 	u_quad_t	pn_mc_size;
 	voff_t		pn_serversize;
 	struct lockf *	pn_lockf;
 	kmutex_t	pn_sizemtx;	/* size modification mutex	*/
 	LIST_ENTRY(puffs_node) pn_hashent;
 };
 typedef void (*parkdone_fn)(struct puffs_mount *, struct puffs_req *, void *);
 struct puffs_msgpark;
 void	puffs_msgif_init(void);
 void	puffs_msgif_destroy(void);
 int	puffs_msgmem_alloc(size_t, struct puffs_msgpark **, void **, int);
 void	puffs_msgmem_release(struct puffs_msgpark *);
 void	puffs_sop_thread(void *);