Attachment #119050 for bug #161511

View | Details | Raw Unified | Return to bug 161511
Collapse All | Expand All

Lines 350-368 Link Here

(-)/usr/src/sys/fs/unionfs/union_subr.c (-7 / +10 lines)
350	uvp = unp->un_uppervp;	350	uvp = unp->un_uppervp;
351	dvp = unp->un_dvp;	351	dvp = unp->un_dvp;
352	unp->un_lowervp = unp->un_uppervp = NULLVP;	352	unp->un_lowervp = unp->un_uppervp = NULLVP;
353
354	vp->v_vnlock = &(vp->v_lock);	353	vp->v_vnlock = &(vp->v_lock);
355	vp->v_data = NULL;	354	vp->v_data = NULL;
356	lockmgr(vp->v_vnlock, LK_EXCLUSIVE \| LK_INTERLOCK, VI_MTX(vp));	355	vp->v_object = NULL;
		356	VI_UNLOCK(vp);
		357
357	if (lvp != NULLVP)	358	if (lvp != NULLVP)
358	VOP_UNLOCK(lvp, 0);	359	VOP_UNLOCK(lvp, LK_RELEASE);
359	if (uvp != NULLVP)	360	if (uvp != NULLVP)
360	VOP_UNLOCK(uvp, 0);	361	VOP_UNLOCK(uvp, LK_RELEASE);
361	vp->v_object = NULL;
362		362
363	if (dvp != NULLVP && unp->un_hash.le_prev != NULL)	363	if (dvp != NULLVP && unp->un_hash.le_prev != NULL)
364	unionfs_rem_cached_vnode(unp, dvp);	364	unionfs_rem_cached_vnode(unp, dvp);
365		365
		366	if (lockmgr(vp->v_vnlock, LK_EXCLUSIVE, VI_MTX(vp)) != 0)
		367	panic("the lock for deletion is unacquirable.");
		368
366	if (lvp != NULLVP) {	369	if (lvp != NULLVP) {
367	vfslocked = VFS_LOCK_GIANT(lvp->v_mount);	370	vfslocked = VFS_LOCK_GIANT(lvp->v_mount);
368	vrele(lvp);	371	vrele(lvp);
Lines 550-556 Link Here
550	cn->cn_flags \|= (cnp->cn_flags & SAVESTART);	553	cn->cn_flags \|= (cnp->cn_flags & SAVESTART);
551		554
552	vref(dvp);	555	vref(dvp);
553	VOP_UNLOCK(dvp, 0);	556	VOP_UNLOCK(dvp, LK_RELEASE);
554		557
555	if ((error = relookup(dvp, vpp, cn))) {	558	if ((error = relookup(dvp, vpp, cn))) {
556	uma_zfree(namei_zone, cn->cn_pnbuf);	559	uma_zfree(namei_zone, cn->cn_pnbuf);
Lines 957-963 Link Here
957	*vpp = vp;	960	*vpp = vp;
958		961
959	unionfs_vn_create_on_upper_free_out1:	962	unionfs_vn_create_on_upper_free_out1:
960	VOP_UNLOCK(udvp, 0);	963	VOP_UNLOCK(udvp, LK_RELEASE);
961		964
962	unionfs_vn_create_on_upper_free_out2:	965	unionfs_vn_create_on_upper_free_out2:
963	if (cn.cn_flags & HASBUF) {	966	if (cn.cn_flags & HASBUF) {




		uid = va.va_uid;
		gid = va.va_gid;
	}
	VOP_UNLOCK(mp->mnt_vnodecovered, LK_RELEASE);
	if (error)
		return (error);


	 * Save reference
	 */
	if (below) {
		VOP_UNLOCK(upperrootvp, LK_RELEASE);
		vn_lock(lowerrootvp, LK_EXCLUSIVE | LK_RETRY);
		ump->um_lowervp = upperrootvp;
		ump->um_uppervp = lowerrootvp;

	/*
	 * Unlock the node
	 */
	VOP_UNLOCK(ump->um_uppervp, LK_RELEASE);

	/*
	 * Get the unionfs root vnode.




	KASSERT(((vp)->v_op == &unionfs_vnodeops), \
	    ("unionfs: it is not unionfs-vnode"))

/* lockmgr lock <-> reverse table */
struct lk_lr_table {
	int	lock;
	int	revlock;
};

static struct lk_lr_table un_llt[] = {
	{LK_SHARED, LK_RELEASE},
	{LK_EXCLUSIVE, LK_RELEASE},
	{LK_UPGRADE, LK_DOWNGRADE},
	{LK_DOWNGRADE, LK_UPGRADE},
	{0, 0}
};


static int
unionfs_lookup(struct vop_cachedlookup_args *ap)
{

		if (udvp != NULLVP) {
			dtmpvp = udvp;
			if (ldvp != NULLVP)
				VOP_UNLOCK(ldvp, LK_RELEASE);
		}
		else
			dtmpvp = ldvp;

		error = VOP_LOOKUP(dtmpvp, &vp, cnp);

		if (dtmpvp == udvp && ldvp != NULLVP) {
			VOP_UNLOCK(udvp, LK_RELEASE);
			vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
		}


			 */
			if (nameiop == DELETE  || nameiop == RENAME ||
			    (cnp->cn_lkflags & LK_TYPE_MASK))
				VOP_UNLOCK(vp, LK_RELEASE);
			vrele(vp);

			VOP_UNLOCK(dvp, LK_RELEASE);
			*(ap->a_vpp) = dunp->un_dvp;
			vref(dunp->un_dvp);


			}
			if (nameiop == DELETE || nameiop == RENAME ||
			    (cnp->cn_lkflags & LK_TYPE_MASK))
				VOP_UNLOCK(uvp, LK_RELEASE);
		}

		/* check whiteout */

				return (lerror);
			}
			if (cnp->cn_lkflags & LK_TYPE_MASK)
				VOP_UNLOCK(lvp, LK_RELEASE);
		}
	}


			goto unionfs_lookup_out;

		if (LK_SHARED == (cnp->cn_lkflags & LK_TYPE_MASK))
			VOP_UNLOCK(vp, LK_RELEASE);
		if (LK_EXCLUSIVE != VOP_ISLOCKED(vp)) {
			vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
			lockflag = 1;

		error = unionfs_mkshadowdir(MOUNTTOUNIONFSMOUNT(dvp->v_mount),
		    udvp, VTOUNIONFS(vp), cnp, td);
		if (lockflag != 0)
			VOP_UNLOCK(vp, LK_RELEASE);
		if (error != 0) {
			UNIONFSDEBUG("unionfs_lookup: Unable to create shadow dir.");
			if ((cnp->cn_lkflags & LK_TYPE_MASK) == LK_EXCLUSIVE)

		if (vp->v_type == VSOCK)
			*(ap->a_vpp) = vp;
		else {
			VOP_UNLOCK(vp, LK_RELEASE);
			error = unionfs_nodeget(ap->a_dvp->v_mount, vp, NULLVP,
			    ap->a_dvp, ap->a_vpp, cnp, curthread);
			vrele(vp);

		if (vp->v_type == VSOCK)
			*(ap->a_vpp) = vp;
		else {
			VOP_UNLOCK(vp, LK_RELEASE);
			error = unionfs_nodeget(ap->a_dvp->v_mount, vp, NULLVP,
			    ap->a_dvp, ap->a_vpp, cnp, curthread);
			vrele(vp);

	unionfs_tryrem_node_status(unp, unsp);

	if (locked != 0)
		VOP_UNLOCK(ap->a_vp, LK_RELEASE);

	UNIONFS_INTERNAL_DEBUG("unionfs_close: leave (%d)\n", error);


	unionfs_get_node_status(unp, ap->a_td, &unsp);
	ovp = (unsp->uns_upper_opencnt ? unp->un_uppervp : unp->un_lowervp);
	unionfs_tryrem_node_status(unp, unsp);
	VOP_UNLOCK(ap->a_vp, LK_RELEASE);

	if (ovp == NULLVP)
		return (EBADF);

	unionfs_get_node_status(unp, ap->a_td, &unsp);
	ovp = (unsp->uns_upper_opencnt ? unp->un_uppervp : unp->un_lowervp);
	unionfs_tryrem_node_status(unp, unsp);
	VOP_UNLOCK(ap->a_vp, LK_RELEASE);

	if (ovp == NULLVP)
		return (EBADF);

		ump = NULL;
		vp = uvp = lvp = NULLVP;
		/* search vnode */
		VOP_UNLOCK(ap->a_vp, LK_RELEASE);
		error = unionfs_relookup(udvp, &vp, cnp, &cn, td,
		    cnp->cn_nameptr, strlen(cnp->cn_nameptr), DELETE);
		if (error != 0 && error != ENOENT) {

			if ((error = vn_lock(fvp, LK_EXCLUSIVE)) != 0)
				goto unionfs_rename_abort;
			error = unionfs_copyfile(unp, 1, fcnp->cn_cred, td);
			VOP_UNLOCK(fvp, LK_RELEASE);
			if (error != 0)
				goto unionfs_rename_abort;
			break;

			if ((error = vn_lock(fvp, LK_EXCLUSIVE)) != 0)
				goto unionfs_rename_abort;
			error = unionfs_mkshadowdir(ump, rfdvp, unp, fcnp, td);
			VOP_UNLOCK(fvp, LK_RELEASE);
			if (error != 0)
				goto unionfs_rename_abort;
			break;

		if ((error = vn_lock(fdvp, LK_EXCLUSIVE)) != 0)
			goto unionfs_rename_abort;
		error = unionfs_relookup_for_delete(fdvp, fcnp, td);
		VOP_UNLOCK(fdvp, LK_RELEASE);
		if (error != 0)
			goto unionfs_rename_abort;

		/* Locke of tvp is canceled in order to avoid recursive lock. */
		if (tvp != NULLVP && tvp != tdvp)
			VOP_UNLOCK(tvp, LK_RELEASE);
		error = unionfs_relookup_for_rename(tdvp, tcnp, td);
		if (tvp != NULLVP && tvp != tdvp)
			vn_lock(tvp, LK_EXCLUSIVE | LK_RETRY);

	}

	if (ltdvp != NULLVP)
		VOP_UNLOCK(ltdvp, LK_RELEASE);
	if (tdvp != rtdvp)
		vrele(tdvp);
	if (ltvp != NULLVP)
		VOP_UNLOCK(ltvp, LK_RELEASE);
	if (tvp != rtvp && tvp != NULLVP) {
		if (rtvp == NULLVP)
			vput(tvp);

		}

		if ((error = VOP_MKDIR(udvp, &uvp, cnp, ap->a_vap)) == 0) {
			VOP_UNLOCK(uvp, LK_RELEASE);
			cnp->cn_lkflags = LK_EXCLUSIVE;
			error = unionfs_nodeget(ap->a_dvp->v_mount, uvp, NULLVP,
			    ap->a_dvp, ap->a_vpp, cnp, td);

	if (udvp != NULLVP) {
		error = VOP_SYMLINK(udvp, &uvp, cnp, ap->a_vap, ap->a_target);
		if (error == 0) {
			VOP_UNLOCK(uvp, LK_RELEASE);
			cnp->cn_lkflags = LK_EXCLUSIVE;
			error = unionfs_nodeget(ap->a_dvp->v_mount, uvp, NULLVP,
			    ap->a_dvp, ap->a_vpp, cnp, td);

	struct unionfs_node *unp;
	struct unionfs_node_status *unsp;
	struct uio     *uio;
	struct vnode   *vp;
	struct vnode   *uvp;
	struct vnode   *lvp;
	struct thread  *td;

	error = 0;
	eofflag = 0;
	locked = 0;
	unp = VTOUNIONFS(ap->a_vp);
	uio = ap->a_uio;
	uvp = NULLVP;
	lvp = NULLVP;
	td = uio->uio_td;
	ncookies_bk = 0;
	cookies_bk = NULL;

	vp = ap->a_vp;
	if (vp->v_type != VDIR)
		return (ENOTDIR);

	/* check opaque */
	if (uvp != NULLVP && lvp != NULLVP) {
		if ((error = VOP_GETATTR(uvp, &va, ap->a_cred)) != 0)
			goto unionfs_readdir_exit;
		if (va.va_flags & OPAQUE)
			lvp = NULLVP;
	}

	/* check the open count. unionfs needs to open before readdir. */
	if (VOP_ISLOCKED(vp) != LK_EXCLUSIVE) {
		if (vn_lock(vp, LK_UPGRADE) != 0)
			vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
		locked = 1;
	}
	unp = VTOUNIONFS(vp);
	if (unp == NULL)
	    (lvp != NULLVP && unsp->uns_lower_opencnt <= 0)) {
		unionfs_tryrem_node_status(unp, unsp);
		error = EBADF;
	else {
		uvp = unp->un_uppervp;
		lvp = unp->un_lowervp;
		unionfs_get_node_status(unp, td, &unsp);
		if ((uvp != NULLVP && unsp->uns_upper_opencnt <= 0) ||
			(lvp != NULLVP && unsp->uns_lower_opencnt <= 0)) {
			unionfs_tryrem_node_status(unp, unsp);
			error = EBADF;
		}
	}
	if (locked)
		vn_lock(vp, LK_DOWNGRADE | LK_RETRY);
	if (error != 0)
		goto unionfs_readdir_exit;

	/* check opaque */
	if (uvp != NULLVP && lvp != NULLVP) {
		if ((error = VOP_GETATTR(uvp, &va, ap->a_cred)) != 0)
			goto unionfs_readdir_exit;
		if (va.va_flags & OPAQUE)
			lvp = NULLVP;
	}

	/* upper only */
	if (uvp != NULLVP && lvp == NULLVP) {
		error = VOP_READDIR(uvp, uio, ap->a_cred, ap->a_eofflag,

}

static int
unionfs_islocked(struct vop_islocked_args *ap)
{
	struct unionfs_node *unp;

	KASSERT_UNIONFS_VNODE(ap->a_vp);

	unp = VTOUNIONFS(ap->a_vp);
	if (unp == NULL)
		return (vop_stdislocked(ap));

	if (unp->un_uppervp != NULLVP)
		return (VOP_ISLOCKED(unp->un_uppervp));
	if (unp->un_lowervp != NULLVP)
		return (VOP_ISLOCKED(unp->un_lowervp));
	return (vop_stdislocked(ap));
}

static int
unionfs_get_llt_revlock(struct vnode *vp, int flags)
{
	int revlock;

	revlock = 0;

	switch (flags & LK_TYPE_MASK) {
	case LK_SHARED:
		if (VOP_ISLOCKED(vp) == LK_EXCLUSIVE)
			revlock = LK_UPGRADE;
		else
			revlock = LK_RELEASE;
		break;
	case LK_EXCLUSIVE:
	case LK_UPGRADE:
		revlock = LK_RELEASE;
		break;
	case LK_DOWNGRADE:
		revlock = LK_UPGRADE;
		break;
	default:
		break;
	}

	return (revlock);
}

/*
 * The state of an acquired lock is adjusted similarly to
 * the time of error generating. 
 * flags: LK_RELEASE or LK_UPGRADE
 */
static void
unionfs_revlock(struct vnode *vp, int flags)
{
	if (flags & LK_RELEASE)
		VOP_UNLOCK(vp, flags);
	else {
		/* UPGRADE */
		if (vn_lock(vp, flags) != 0)
			vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
	}
}

static int

	int		error;
	int		flags;
	int		revlock;
	int		interlock;
	int		uhold;
	struct mount   *mp;
	struct unionfs_mount *ump;

	KASSERT_UNIONFS_VNODE(ap->a_vp);

	error = 0;
	interlock = 1;
	uhold = 0;
	flags = ap->a_flags;
	vp = ap->a_vp;

	if (LK_RELEASE == (flags & LK_TYPE_MASK) || !(flags & LK_TYPE_MASK))
		return (VOP_UNLOCK(vp, flags | LK_RELEASE));

	if ((revlock = unionfs_get_llt_revlock(flags)) == 0)
		panic("unknown lock type: 0x%x", flags & LK_TYPE_MASK);

	if ((flags & LK_INTERLOCK) == 0)
		VI_LOCK(vp);

	lvp = unp->un_lowervp;
	uvp = unp->un_uppervp;

	if ((revlock = unionfs_get_llt_revlock(vp, flags)) == 0)
		panic("unknown lock type: 0x%x", flags & LK_TYPE_MASK);

	if ((mp->mnt_kern_flag & MNTK_MPSAFE) != 0 &&
	    (vp->v_iflag & VI_OWEINACT) != 0)
		flags |= LK_NOWAIT;

		flags |= LK_CANRECURSE;

	if (lvp != NULLVP) {
		if (uvp != NULLVP && flags & LK_UPGRADE) {
			/* Share Lock is once released and a deadlock is avoided.  */
			VI_LOCK_FLAGS(uvp, MTX_DUPOK);
			vholdl(uvp);
			uhold = 1;
			VI_UNLOCK(vp);
			VOP_UNLOCK(uvp, LK_RELEASE | LK_INTERLOCK);
			VI_LOCK(vp);
			unp = VTOUNIONFS(vp);
			if (unp == NULL) {
				/* vnode is released. */
				VI_UNLOCK(vp);
				VOP_UNLOCK(lvp, LK_RELEASE);
				vdrop(uvp);
				return (EBUSY);
			}
		}
		VI_LOCK_FLAGS(lvp, MTX_DUPOK);
		flags |= LK_INTERLOCK;
		vholdl(lvp);

		VI_LOCK(vp);
		unp = VTOUNIONFS(vp);
		if (unp == NULL) {
			/* vnode is released. */
			VI_UNLOCK(vp);
			if (error == 0)
				VOP_UNLOCK(lvp, LK_RELEASE);
			vdrop(lvp);
			if (uhold != 0)
				vdrop(uvp);
			return (vop_stdlock(ap));
		}
	}

	if (error == 0 && uvp != NULLVP) {
		if (uhold && flags & LK_UPGRADE) {
			flags &= ~LK_TYPE_MASK;
			flags |= LK_EXCLUSIVE;
		}
		VI_LOCK_FLAGS(uvp, MTX_DUPOK);
		flags |= LK_INTERLOCK;
		if (uhold == 0) {
			vholdl(uvp);
			uhold = 1;
		}

		VI_UNLOCK(vp);
		ap->a_flags &= ~LK_INTERLOCK;

		VI_LOCK(vp);
		unp = VTOUNIONFS(vp);
		if (unp == NULL) {
			/* vnode is released. */
			VI_UNLOCK(vp);
			if (error == 0)
				VOP_UNLOCK(uvp, LK_RELEASE);
				if (lvp != NULLVP)
					VOP_UNLOCK(lvp, 0);
			}
			if (lvp != NULLVP)
				vdrop(lvp);
			vdrop(uvp);
			if (lvp != NULLVP) {
				VOP_UNLOCK(lvp, LK_RELEASE);
				vdrop(lvp);
			}
			return (vop_stdlock(ap));
		}

		if (error != 0 && lvp != NULLVP) {
			/* rollback */
			VI_UNLOCK(vp);
			unionfs_revlock(lvp, revlock);
			interlock = 0;
			else
				vn_lock(lvp, revlock | LK_RETRY);
			goto unionfs_lock_abort;
		}
	}

	if (interlock)
		VI_UNLOCK(vp);
	if (lvp != NULLVP)
		vdrop(lvp);
	if (uhold != 0)

			unionfs_tryrem_node_status(unp, unsp);
	}

	VOP_UNLOCK(vp, LK_RELEASE);

	error = VOP_ADVLOCK(uvp, ap->a_id, ap->a_op, ap->a_fl, ap->a_flags);


	return error;

unionfs_advlock_abort:
	VOP_UNLOCK(vp, LK_RELEASE);

	UNIONFS_INTERNAL_DEBUG("unionfs_advlock: leave (%d)\n", error);


	error = VOP_OPENEXTATTR(tvp, ap->a_cred, ap->a_td);

	if (error == 0) {
		if (vn_lock(vp, LK_UPGRADE) != 0)
			vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
		if (tvp == unp->un_uppervp)
			unp->un_flag |= UNIONFS_OPENEXTU;
		else

	error = VOP_CLOSEEXTATTR(tvp, ap->a_commit, ap->a_cred, ap->a_td);

	if (error == 0) {
		if (vn_lock(vp, LK_UPGRADE) != 0)
			vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
		if (tvp == unp->un_uppervp)
			unp->un_flag &= ~UNIONFS_OPENEXTU;
		else

	.vop_getextattr =	unionfs_getextattr,
	.vop_getwritemount =	unionfs_getwritemount,
	.vop_inactive =		unionfs_inactive,
	.vop_islocked =		unionfs_islocked,
	.vop_ioctl =		unionfs_ioctl,
	.vop_link =		unionfs_link,
	.vop_listextattr =	unionfs_listextattr,

Return to bug 161511

Lines 165-171 Link Here

(-)/usr/src/sys/fs/unionfs/union_vfsops.c (-3 / +3 lines)
165	uid = va.va_uid;	165	uid = va.va_uid;
166	gid = va.va_gid;	166	gid = va.va_gid;
167	}	167	}
168	VOP_UNLOCK(mp->mnt_vnodecovered, 0);	168	VOP_UNLOCK(mp->mnt_vnodecovered, LK_RELEASE);
169	if (error)	169	if (error)
170	return (error);	170	return (error);
171		171
Lines 250-256 Link Here
250	* Save reference	250	* Save reference
251	*/	251	*/
252	if (below) {	252	if (below) {
253	VOP_UNLOCK(upperrootvp, 0);	253	VOP_UNLOCK(upperrootvp, LK_RELEASE);
254	vn_lock(lowerrootvp, LK_EXCLUSIVE \| LK_RETRY);	254	vn_lock(lowerrootvp, LK_EXCLUSIVE \| LK_RETRY);
255	ump->um_lowervp = upperrootvp;	255	ump->um_lowervp = upperrootvp;
256	ump->um_uppervp = lowerrootvp;	256	ump->um_uppervp = lowerrootvp;
Lines 281-287 Link Here
281	/*	281	/*
282	* Unlock the node	282	* Unlock the node
283	*/	283	*/
284	VOP_UNLOCK(ump->um_uppervp, 0);	284	VOP_UNLOCK(ump->um_uppervp, LK_RELEASE);
285		285
286	/*	286	/*
287	* Get the unionfs root vnode.	287	* Get the unionfs root vnode.