Index: sys/fs/smbfs/smbfs_vfsops.c
===================================================================
--- sys/fs/smbfs/smbfs_vfsops.c	(revision 241435)
+++ sys/fs/smbfs/smbfs_vfsops.c	(working copy)
@@ -169,7 +169,7 @@ smbfs_mount(struct mount *mp)
 		return error;
 	}
 	vcp = SSTOVC(ssp);
-	smb_share_unlock(ssp, 0);
+	smb_share_unlock(ssp);
 	mp->mnt_stat.f_iosize = SSTOVC(ssp)->vc_txmax;
 
 #ifdef SMBFS_USEZONE
@@ -302,7 +302,7 @@ smbfs_unmount(struct mount *mp, int mntflags)
 	if (error)
 		return error;
 	smb_makescred(&scred, td, td->td_ucred);
-	error = smb_share_lock(smp->sm_share, LK_EXCLUSIVE);
+	error = smb_share_lock(smp->sm_share);
 	if (error)
 		return error;
 	smb_share_put(smp->sm_share, &scred);
Index: sys/netsmb/smb_iod.c
===================================================================
--- sys/netsmb/smb_iod.c	(revision 241435)
+++ sys/netsmb/smb_iod.c	(working copy)
@@ -55,6 +55,10 @@ __FBSDID("$FreeBSD$");
 #define	SMB_IOD_RQLOCK(iod)	smb_sl_lock(&((iod)->iod_rqlock))
 #define	SMB_IOD_RQUNLOCK(iod)	smb_sl_unlock(&((iod)->iod_rqlock))
 
+#define	SMB_IOD_FLAGSLOCKPTR(iod)	(&((iod)->iod_flagslock))
+#define	SMB_IOD_FLAGSLOCK(iod)		smb_sl_lock(&((iod)->iod_flagslock))
+#define	SMB_IOD_FLAGSUNLOCK(iod)	smb_sl_unlock(&((iod)->iod_flagslock))
+
 #define	smb_iod_wakeup(iod)	wakeup(&(iod)->iod_flags)
 
 
@@ -149,7 +153,9 @@ smb_iod_connect(struct smbiod *iod)
 	error = (int)SMB_TRAN_CONNECT(vcp, vcp->vc_paddr, td);
 	if (error)
 		goto fail;
+	SMB_IOD_FLAGSLOCK(iod);
 	SMB_TRAN_SETPARAM(vcp, SMBTP_SELECTID, &iod->iod_flags);
+	SMB_IOD_FLAGSUNLOCK(iod);	
 	iod->iod_state = SMBIOD_ST_TRANACTIVE;
 	SMBIODEBUG("tconnect\n");
 	/* vcp->vc_mid = 0;*/
@@ -615,7 +621,9 @@ smb_iod_main(struct smbiod *iod)
 			evp->ev_error = smb_iod_treeconnect(iod, evp->ev_ident);
 			break;
 		    case SMBIOD_EV_SHUTDOWN:
+			SMB_IOD_FLAGSLOCK(iod);
 			iod->iod_flags |= SMBIOD_SHUTDOWN;
+			SMB_IOD_FLAGSUNLOCK(iod);
 			break;
 		    case SMBIOD_EV_NEWRQ:
 			break;
@@ -646,22 +654,24 @@ smb_iod_thread(void *arg)
 {
 	struct smbiod *iod = arg;
 
-	mtx_lock(&Giant);
-
 	/*
 	 * Here we assume that the thread structure will be the same
 	 * for an entire kthread (kproc, to be more precise) life.
 	 */
 	iod->iod_td = curthread;
 	smb_makescred(&iod->iod_scred, iod->iod_td, NULL);
+	SMB_IOD_FLAGSLOCK(iod);
 	while ((iod->iod_flags & SMBIOD_SHUTDOWN) == 0) {
+		SMB_IOD_FLAGSUNLOCK(iod);
 		smb_iod_main(iod);
 		SMBIODEBUG("going to sleep for %d ticks\n", iod->iod_sleeptimo);
-		if (iod->iod_flags & SMBIOD_SHUTDOWN)
+		SMB_IOD_FLAGSLOCK(iod);
+		if (iod->iod_flags & SMBIOD_SHUTDOWN) 
 			break;
-		tsleep(&iod->iod_flags, PWAIT, "90idle", iod->iod_sleeptimo);
+		msleep(&iod->iod_flags, SMB_IOD_FLAGSLOCKPTR(iod), PWAIT | PDROP, 
+		    "90idle", iod->iod_sleeptimo);
 	}
-	mtx_unlock(&Giant);
+	SMB_IOD_FLAGSUNLOCK(iod);
 	kproc_exit(0);
 }
 
@@ -683,6 +693,7 @@ smb_iod_create(struct smb_vc *vcp)
 	TAILQ_INIT(&iod->iod_rqlist);
 	smb_sl_init(&iod->iod_evlock, "90evl");
 	STAILQ_INIT(&iod->iod_evlist);
+	smb_sl_init(&iod->iod_flagslock, "90fll");
 	error = kproc_create(smb_iod_thread, iod, &iod->iod_p,
 	    RFNOWAIT, 0, "smbiod%d", iod->iod_id);
 	if (error) {
@@ -699,6 +710,7 @@ smb_iod_destroy(struct smbiod *iod)
 	smb_iod_request(iod, SMBIOD_EV_SHUTDOWN | SMBIOD_EV_SYNC, NULL);
 	smb_sl_destroy(&iod->iod_rqlock);
 	smb_sl_destroy(&iod->iod_evlock);
+	smb_sl_destroy(&iod->iod_flagslock);
 	free(iod, M_SMBIOD);
 	return 0;
 }
Index: sys/netsmb/smb_dev.c
===================================================================
--- sys/netsmb/smb_dev.c	(revision 241435)
+++ sys/netsmb/smb_dev.c	(working copy)
@@ -83,7 +83,7 @@ int smb_dev_queue(struct smb_dev *ndp, struct smb_
 
 static struct cdevsw nsmb_cdevsw = {
 	.d_version =	D_VERSION,
-	.d_flags =	D_NEEDGIANT | D_NEEDMINOR,
+	.d_flags =	D_NEEDMINOR,
 	.d_open =	nsmb_dev_open,
 	.d_close =	nsmb_dev_close,
 	.d_ioctl =	nsmb_dev_ioctl,
@@ -168,11 +168,15 @@ nsmb_dev_close(struct cdev *dev, int flag, int fmt
 	}
 	smb_makescred(&scred, td, NULL);
 	ssp = sdp->sd_share;
-	if (ssp != NULL)
+	if (ssp != NULL) {
+		smb_share_lock(ssp);
 		smb_share_rele(ssp, &scred);
+	}
 	vcp = sdp->sd_vc;
-	if (vcp != NULL)
+	if (vcp != NULL) {
+		smb_vc_lock(vcp);
 		smb_vc_rele(vcp, &scred);
+	}
 /*
 	smb_flushq(&sdp->sd_rqlist);
 	smb_flushq(&sdp->sd_rplist);
@@ -208,7 +212,7 @@ nsmb_dev_ioctl(struct cdev *dev, u_long cmd, caddr
 		if (error)
 			break;
 		sdp->sd_vc = vcp;
-		smb_vc_unlock(vcp, 0);
+		smb_vc_unlock(vcp);
 		sdp->sd_level = SMBL_VC;
 		break;
 	    case SMBIOC_OPENSHARE:
@@ -221,7 +225,7 @@ nsmb_dev_ioctl(struct cdev *dev, u_long cmd, caddr
 		if (error)
 			break;
 		sdp->sd_share = ssp;
-		smb_share_unlock(ssp, 0);
+		smb_share_unlock(ssp);
 		sdp->sd_level = SMBL_SHARE;
 		break;
 	    case SMBIOC_REQUEST:
@@ -245,7 +249,7 @@ nsmb_dev_ioctl(struct cdev *dev, u_long cmd, caddr
 				on = fl->ioc_flags & SMBV_PERMANENT;
 				if ((vcp = sdp->sd_vc) == NULL)
 					return ENOTCONN;
-				error = smb_vc_get(vcp, LK_EXCLUSIVE, &scred);
+				error = smb_vc_get(vcp, &scred);
 				if (error)
 					break;
 				if (on && (vcp->obj.co_flags & SMBV_PERMANENT) == 0) {
@@ -263,7 +267,7 @@ nsmb_dev_ioctl(struct cdev *dev, u_long cmd, caddr
 				on = fl->ioc_flags & SMBS_PERMANENT;
 				if ((ssp = sdp->sd_share) == NULL)
 					return ENOTCONN;
-				error = smb_share_get(ssp, LK_EXCLUSIVE, &scred);
+				error = smb_share_get(ssp, &scred);
 				if (error)
 					break;
 				if (on && (ssp->obj.co_flags & SMBS_PERMANENT) == 0) {
@@ -291,12 +295,12 @@ nsmb_dev_ioctl(struct cdev *dev, u_long cmd, caddr
 			break;
 		if (vcp) {
 			sdp->sd_vc = vcp;
-			smb_vc_unlock(vcp, 0);
+			smb_vc_unlock(vcp);
 			sdp->sd_level = SMBL_VC;
 		}
 		if (ssp) {
 			sdp->sd_share = ssp;
-			smb_share_unlock(ssp, 0);
+			smb_share_unlock(ssp);
 			sdp->sd_level = SMBL_SHARE;
 		}
 		break;
@@ -416,7 +420,7 @@ smb_dev2share(int fd, int mode, struct smb_cred *s
 		fdrop(fp, curthread);
 		return ENOTCONN;
 	}
-	error = smb_share_get(ssp, LK_EXCLUSIVE, scred);
+	error = smb_share_get(ssp, scred);
 	if (error == 0) 
 		*sspp = ssp;
 	fdrop(fp, curthread);
Index: sys/netsmb/smb_smb.c
===================================================================
--- sys/netsmb/smb_smb.c	(revision 241435)
+++ sys/netsmb/smb_smb.c	(working copy)
@@ -267,9 +267,13 @@ smb_smb_negotiate(struct smb_vc *vcp, struct smb_c
 		else
 			sp->sv_maxtx = min(sp->sv_maxtx,
 					   63*1024 + SMB_HDRLEN + 16);
+		SMB_IOD_FLAGSLOCK(vcp->vc_iod);
 		SMB_TRAN_GETPARAM(vcp, SMBTP_RCVSZ, &maxqsz);
+		SMB_IOD_FLAGSUNLOCK(vcp->vc_iod);
 		vcp->vc_rxmax = min(smb_vc_maxread(vcp), maxqsz - 1024);
+		SMB_IOD_FLAGSLOCK(vcp->vc_iod);
 		SMB_TRAN_GETPARAM(vcp, SMBTP_SNDSZ, &maxqsz);
+		SMB_IOD_FLAGSUNLOCK(vcp->vc_iod);
 		vcp->vc_wxmax = min(smb_vc_maxwrite(vcp), maxqsz - 1024);
 		vcp->vc_txmax = min(sp->sv_maxtx, maxqsz);
 		SMBSDEBUG("TZ = %d\n", sp->sv_tz);
Index: sys/netsmb/smb_conn.c
===================================================================
--- sys/netsmb/smb_conn.c	(revision 241435)
+++ sys/netsmb/smb_conn.c	(working copy)
@@ -59,8 +59,6 @@ static MALLOC_DEFINE(M_SMBCONN, "smb_conn", "SMB c
 static void smb_co_init(struct smb_connobj *cp, int level, char *ilockname,
     char *lockname);
 static void smb_co_done(struct smb_connobj *cp);
-static int  smb_co_lockstatus(struct smb_connobj *cp);
-
 static int  smb_vc_disconnect(struct smb_vc *vcp);
 static void smb_vc_free(struct smb_connobj *cp);
 static void smb_vc_gone(struct smb_connobj *cp, struct smb_cred *scred);
@@ -77,7 +75,9 @@ smb_sm_init(void)
 {
 
 	smb_co_init(&smb_vclist, SMBL_SM, "smbsm ilock", "smbsm");
-	smb_co_unlock(&smb_vclist, 0);
+	sx_xlock(&smb_vclist.co_interlock);
+	smb_co_unlock(&smb_vclist);
+	sx_unlock(&smb_vclist.co_interlock);
 	return 0;
 }
 
@@ -90,23 +90,29 @@ smb_sm_done(void)
 		SMBERROR("%d connections still active\n", smb_vclist.co_usecount - 1);
 		return EBUSY;
 	}
-	lockmgr(&smb_vclist.co_lock, LK_DRAIN, NULL);
 	smb_co_done(&smb_vclist);
 	return 0;
 }
 
 static int
-smb_sm_lockvclist(int flags)
+smb_sm_lockvclist(void)
 {
+	int error;
 
-	return smb_co_lock(&smb_vclist, flags | LK_CANRECURSE);
+	sx_xlock(&smb_vclist.co_interlock);
+	error = smb_co_lock(&smb_vclist);
+	sx_unlock(&smb_vclist.co_interlock);
+
+	return error;
 }
 
 static void
 smb_sm_unlockvclist(void)
 {
 
-	smb_co_unlock(&smb_vclist, LK_RELEASE);
+	sx_xlock(&smb_vclist.co_interlock);
+	smb_co_unlock(&smb_vclist);
+	sx_unlock(&smb_vclist.co_interlock);
 }
 
 static int
@@ -123,7 +129,7 @@ smb_sm_lookupint(struct smb_vcspec *vcspec, struct
 	vcp = NULL;
 	SMBCO_FOREACH(scp, &smb_vclist) {
 		vcp = (struct smb_vc *)scp;
-		error = smb_vc_lock(vcp, LK_EXCLUSIVE);
+		error = smb_vc_lock(vcp);
 		if (error)
 			continue;
 
@@ -160,7 +166,7 @@ smb_sm_lookupint(struct smb_vcspec *vcspec, struct
 	err1:
 		error = 1;
 	fail:
-		smb_vc_unlock(vcp, 0);
+		smb_vc_unlock(vcp);
 	}
 	if (vcp) {
 		smb_vc_ref(vcp);
@@ -179,7 +185,7 @@ smb_sm_lookup(struct smb_vcspec *vcspec, struct sm
 
 	*vcpp = vcp = NULL;
 
-	error = smb_sm_lockvclist(LK_EXCLUSIVE);
+	error = smb_sm_lockvclist();
 	if (error)
 		return error;
 	error = smb_sm_lookupint(vcspec, shspec, scred, vcpp);
@@ -211,7 +217,7 @@ out:
 	if (error == 0)
 		*vcpp = vcp;
 	else if (vcp) {
-		smb_vc_lock(vcp, LK_EXCLUSIVE);
+		smb_vc_lock(vcp);
 		smb_vc_put(vcp, scred);
 	}
 	return error;
@@ -224,20 +230,26 @@ static void
 smb_co_init(struct smb_connobj *cp, int level, char *ilockname, char *lockname)
 {
 	SLIST_INIT(&cp->co_children);
-	smb_sl_init(&cp->co_interlock, ilockname);
-	lockinit(&cp->co_lock, PZERO, lockname, 0, 0);
+	sx_init_flags(&cp->co_interlock, ilockname, SX_RECURSE);
+	cv_init(&cp->co_lock, "smblock");
+	cp->co_lockcnt = 0;
+	cp->co_locker = NULL;
 	cp->co_level = level;
 	cp->co_usecount = 1;
-	if (smb_co_lock(cp, LK_EXCLUSIVE) != 0)
-	    panic("smb_co_init: lock failed");
+	sx_xlock(&cp->co_interlock);
+	smb_co_lock(cp);
+	sx_unlock(&cp->co_interlock);
 }
 
 static void
 smb_co_done(struct smb_connobj *cp)
 {
-	smb_sl_destroy(&cp->co_interlock);
-	lockmgr(&cp->co_lock, LK_RELEASE, NULL);
-	lockdestroy(&cp->co_lock);
+
+	sx_destroy(&cp->co_interlock);
+	cv_destroy(&cp->co_lock);
+	cp->co_locker = NULL;
+	cp->co_flags = 0;
+	cp->co_lockcnt = 0;
 }
 
 static void
@@ -249,7 +261,9 @@ smb_co_gone(struct smb_connobj *cp, struct smb_cre
 		cp->co_gone(cp, scred);
 	parent = cp->co_parent;
 	if (parent) {
-		smb_co_lock(parent, LK_EXCLUSIVE);
+		sx_xlock(&parent->co_interlock);
+		smb_co_lock(parent);
+		sx_unlock(&parent->co_interlock);
 		SLIST_REMOVE(&parent->co_children, cp, smb_connobj, co_next);
 		smb_co_put(parent, scred);
 	}
@@ -261,56 +275,51 @@ void
 smb_co_ref(struct smb_connobj *cp)
 {
 
-	SMB_CO_LOCK(cp);
+	sx_xlock(&cp->co_interlock);
 	cp->co_usecount++;
-	SMB_CO_UNLOCK(cp);
+	sx_unlock(&cp->co_interlock);
 }
 
 void
 smb_co_rele(struct smb_connobj *cp, struct smb_cred *scred)
 {
 
-	SMB_CO_LOCK(cp);
+	sx_xlock(&cp->co_interlock);
+	smb_co_unlock(cp);
 	if (cp->co_usecount > 1) {
 		cp->co_usecount--;
-		SMB_CO_UNLOCK(cp);
+		sx_unlock(&cp->co_interlock);
 		return;
 	}
 	if (cp->co_usecount == 0) {
 		SMBERROR("negative use_count for object %d", cp->co_level);
-		SMB_CO_UNLOCK(cp);
+		sx_unlock(&cp->co_interlock);
 		return;
 	}
 	cp->co_usecount--;
 	cp->co_flags |= SMBO_GONE;
-
-	lockmgr(&cp->co_lock, LK_DRAIN | LK_INTERLOCK, &cp->co_interlock);
+	sx_unlock(&cp->co_interlock);
 	smb_co_gone(cp, scred);
 }
 
 int
-smb_co_get(struct smb_connobj *cp, int flags, struct smb_cred *scred)
+smb_co_get(struct smb_connobj *cp, struct smb_cred *scred)
 {
 	int error;
 
-	if ((flags & LK_INTERLOCK) == 0)
-		SMB_CO_LOCK(cp);
+	MPASS(sx_xholder(&cp->co_interlock) == curthread);
 	cp->co_usecount++;
-	error = smb_co_lock(cp, flags | LK_INTERLOCK);
-	if (error) {
-		SMB_CO_LOCK(cp);
+	error = smb_co_lock(cp);
+	if (error) 
 		cp->co_usecount--;
-		SMB_CO_UNLOCK(cp);
-		return error;
-	}
-	return 0;
+	return error;
 }
 
 void
 smb_co_put(struct smb_connobj *cp, struct smb_cred *scred)
 {
 
-	SMB_CO_LOCK(cp);
+	sx_xlock(&cp->co_interlock);
 	if (cp->co_usecount > 1) {
 		cp->co_usecount--;
 	} else if (cp->co_usecount == 1) {
@@ -319,50 +328,51 @@ smb_co_put(struct smb_connobj *cp, struct smb_cred
 	} else {
 		SMBERROR("negative usecount");
 	}
-	lockmgr(&cp->co_lock, LK_RELEASE | LK_INTERLOCK, &cp->co_interlock);
+	smb_co_unlock(cp);
+	sx_unlock(&cp->co_interlock);
 	if ((cp->co_flags & SMBO_GONE) == 0)
 		return;
-	lockmgr(&cp->co_lock, LK_DRAIN, NULL);
 	smb_co_gone(cp, scred);
 }
 
 int
-smb_co_lockstatus(struct smb_connobj *cp)
+smb_co_lock(struct smb_connobj *cp)
 {
-	return lockstatus(&cp->co_lock);
-}
 
-int
-smb_co_lock(struct smb_connobj *cp, int flags)
-{
-
-	if (cp->co_flags & SMBO_GONE)
-		return EINVAL;
-	if ((flags & LK_TYPE_MASK) == 0)
-		flags |= LK_EXCLUSIVE;
-	if (smb_co_lockstatus(cp) == LK_EXCLUSIVE && 
-	    (flags & LK_CANRECURSE) == 0) {
-		SMBERROR("recursive lock for object %d\n", cp->co_level);
-		return 0;
+	MPASS(sx_xholder(&cp->co_interlock) == curthread); 
+	for (;;) {
+		if (cp->co_flags & SMBO_GONE)
+			return EINVAL;
+		if (cp->co_locker == NULL) {
+			cp->co_locker = curthread;
+			return 0;
+		}
+		if (cp->co_locker == curthread) {
+			cp->co_lockcnt++;
+			return 0;
+		}
+		cv_wait(&cp->co_lock, &cp->co_interlock);
 	}
-	return lockmgr(&cp->co_lock, flags, &cp->co_interlock);
 }
 
 void
-smb_co_unlock(struct smb_connobj *cp, int flags)
+smb_co_unlock(struct smb_connobj *cp)
 {
-	(void)lockmgr(&cp->co_lock, flags | LK_RELEASE, &cp->co_interlock);
+
+	MPASS(sx_xholder(&cp->co_interlock) == curthread); 
+	MPASS(cp->co_locker == curthread);
+	if (cp->co_lockcnt != 0) {
+		cp->co_lockcnt--;
+		return;
+	}
+	cp->co_locker = NULL;
+	cv_signal(&cp->co_lock);
 }
 
 static void
 smb_co_addchild(struct smb_connobj *parent, struct smb_connobj *child)
 {
 
-	KASSERT(smb_co_lockstatus(parent) == LK_EXCLUSIVE,
-	    ("smb_co_addchild: parent not locked"));
-	KASSERT(smb_co_lockstatus(child) == LK_EXCLUSIVE,
-	    ("smb_co_addchild: child not locked"));
-
 	smb_co_ref(parent);
 	SLIST_INSERT_HEAD(&parent->co_children, child, co_next);
 	child->co_parent = parent;
@@ -543,9 +553,16 @@ smb_vc_rele(struct smb_vc *vcp, struct smb_cred *s
 }
 
 int
-smb_vc_get(struct smb_vc *vcp, int flags, struct smb_cred *scred)
+smb_vc_get(struct smb_vc *vcp, struct smb_cred *scred)
 {
-	return smb_co_get(VCTOCP(vcp), flags, scred);
+	struct smb_connobj *cp;
+	int error;
+
+	cp = VCTOCP(vcp);
+	sx_xlock(&cp->co_interlock);
+	error = smb_co_get(cp, scred);
+	sx_unlock(&cp->co_interlock);
+	return error;
 }
 
 void
@@ -555,15 +572,28 @@ smb_vc_put(struct smb_vc *vcp, struct smb_cred *sc
 }
 
 int
-smb_vc_lock(struct smb_vc *vcp, int flags)
+smb_vc_lock(struct smb_vc *vcp)
 {
-	return smb_co_lock(VCTOCP(vcp), flags);
+	struct smb_connobj *cp;
+	int error;
+
+	cp = VCTOCP(vcp);
+	sx_xlock(&cp->co_interlock);
+	error = smb_co_lock(cp);
+	sx_unlock(&cp->co_interlock);
+	return error;
 }
 
 void
-smb_vc_unlock(struct smb_vc *vcp, int flags)
+smb_vc_unlock(struct smb_vc *vcp)
 {
-	smb_co_unlock(VCTOCP(vcp), flags);
+
+	struct smb_connobj *cp;
+
+	cp = VCTOCP(vcp);
+	sx_xlock(&cp->co_interlock);
+	smb_co_unlock(cp);
+	sx_unlock(&cp->co_interlock);
 }
 
 int
@@ -623,12 +653,12 @@ smb_vc_lookupshare(struct smb_vc *vcp, struct smb_
 	dp->scred = scred;
 	SMBCO_FOREACH(scp, VCTOCP(vcp)) {
 		ssp = (struct smb_share *)scp;
-		error = smb_share_lock(ssp, LK_EXCLUSIVE);
+		error = smb_share_lock(ssp);
 		if (error)
 			continue;
 		if (smb_vc_cmpshare(ssp, dp) == 0)
 			break;
-		smb_share_unlock(ssp, 0);
+		smb_share_unlock(ssp);
 	}
 	if (ssp) {
 		smb_share_ref(ssp);
@@ -690,10 +720,10 @@ u_short
 smb_vc_nextmid(struct smb_vc *vcp)
 {
 	u_short r;
-
-	SMB_CO_LOCK(&vcp->obj);
+	
+	sx_xlock(&vcp->obj.co_interlock);
 	r = vcp->vc_mid++;
-	SMB_CO_UNLOCK(&vcp->obj);
+	sx_unlock(&vcp->obj.co_interlock);
 	return r;
 }
 
@@ -784,27 +814,46 @@ smb_share_rele(struct smb_share *ssp, struct smb_c
 }
 
 int
-smb_share_get(struct smb_share *ssp, int flags, struct smb_cred *scred)
+smb_share_get(struct smb_share *ssp, struct smb_cred *scred)
 {
-	return smb_co_get(SSTOCP(ssp), flags, scred);
+	struct smb_connobj *cp = SSTOCP(ssp);
+	int error;
+
+	sx_xlock(&cp->co_interlock);
+	error = smb_co_get(cp, scred);
+	sx_unlock(&cp->co_interlock);
+	return error;
 }
 
 void
 smb_share_put(struct smb_share *ssp, struct smb_cred *scred)
 {
+	
 	smb_co_put(SSTOCP(ssp), scred);
 }
 
 int
-smb_share_lock(struct smb_share *ssp, int flags)
+smb_share_lock(struct smb_share *ssp)
 {
-	return smb_co_lock(SSTOCP(ssp), flags);
+	struct smb_connobj *cp;
+	int error;
+	
+	cp = SSTOCP(ssp);
+	sx_xlock(&cp->co_interlock);
+	error = smb_co_lock(cp);
+	sx_unlock(&cp->co_interlock);
+	return error;
 }
 
 void
-smb_share_unlock(struct smb_share *ssp, int flags)
+smb_share_unlock(struct smb_share *ssp)
 {
-	smb_co_unlock(SSTOCP(ssp), flags);
+	struct smb_connobj *cp;
+	
+	cp = SSTOCP(ssp);
+	sx_xlock(&cp->co_interlock);
+	smb_co_unlock(cp);
+	sx_unlock(&cp->co_interlock);
 }
 
 int
@@ -881,34 +930,34 @@ smb_sysctl_treedump(SYSCTL_HANDLER_ARGS)
 	error = sysctl_wire_old_buffer(req, 0);
 	if (error)
 		return (error);
-	error = smb_sm_lockvclist(LK_SHARED);
+	error = smb_sm_lockvclist();
 	if (error)
 		return error;
 	SMBCO_FOREACH(scp1, &smb_vclist) {
 		vcp = (struct smb_vc *)scp1;
-		error = smb_vc_lock(vcp, LK_SHARED);
+		error = smb_vc_lock(vcp);
 		if (error)
 			continue;
 		smb_vc_getinfo(vcp, &vci);
 		error = SYSCTL_OUT(req, &vci, sizeof(struct smb_vc_info));
 		if (error) {
-			smb_vc_unlock(vcp, 0);
+			smb_vc_unlock(vcp);
 			break;
 		}
 		SMBCO_FOREACH(scp2, VCTOCP(vcp)) {
 			ssp = (struct smb_share *)scp2;
-			error = smb_share_lock(ssp, LK_SHARED);
+			error = smb_share_lock(ssp);
 			if (error) {
 				error = 0;
 				continue;
 			}
 			smb_share_getinfo(ssp, &ssi);
-			smb_share_unlock(ssp, 0);
+			smb_share_unlock(ssp);
 			error = SYSCTL_OUT(req, &ssi, sizeof(struct smb_share_info));
 			if (error)
 				break;
 		}
-		smb_vc_unlock(vcp, 0);
+		smb_vc_unlock(vcp);
 		if (error)
 			break;
 	}
Index: sys/netsmb/smb_conn.h
===================================================================
--- sys/netsmb/smb_conn.h	(revision 241435)
+++ sys/netsmb/smb_conn.h	(working copy)
@@ -158,9 +158,11 @@ struct smb_share_info {
 
 #ifdef _KERNEL
 
+#include <netsmb/smb_subr.h>
+#include <sys/param.h>
 #include <sys/lock.h>
-#include <sys/lockmgr.h>
-#include <netsmb/smb_subr.h>
+#include <sys/condvar.h>
+#include <sys/sx.h>
 
 #define CONNADDREQ(a1,a2)	((a1)->sa_len == (a2)->sa_len && \
 				 bcmp(a1, a2, (a1)->sa_len) == 0)
@@ -190,14 +192,13 @@ struct smb_connobj;
 typedef void smb_co_gone_t (struct smb_connobj *cp, struct smb_cred *scred);
 typedef void smb_co_free_t (struct smb_connobj *cp);
 
-#define	SMB_CO_LOCK(cp)		smb_sl_lock(&(cp)->co_interlock)
-#define	SMB_CO_UNLOCK(cp)	smb_sl_unlock(&(cp)->co_interlock)
-
 struct smb_connobj {
+	struct cv		co_lock;
+	struct thread		*co_locker;
+	struct sx		co_interlock;
+	int			co_lockcnt;
 	int			co_level;	/* SMBL_ */
 	int			co_flags;
-	struct lock		co_lock;
-	struct smb_slock	co_interlock;
 	int			co_usecount;
 	struct smb_connobj *	co_parent;
 	SLIST_HEAD(,smb_connobj)co_children;
@@ -225,7 +226,6 @@ struct smb_connobj {
 #define	SMBC_ST_LOCK(vcp)	smb_sl_lock(&(vcp)->vc_stlock)
 #define	SMBC_ST_UNLOCK(vcp)	smb_sl_unlock(&(vcp)->vc_stlock)
 
-
 struct smb_vc {
 	struct smb_connobj obj;
 	char *		vc_srvname;
@@ -361,10 +361,10 @@ int  smb_sm_lookup(struct smb_vcspec *vcspec,
  */
 void smb_co_ref(struct smb_connobj *cp);
 void smb_co_rele(struct smb_connobj *cp, struct smb_cred *scred);
-int  smb_co_get(struct smb_connobj *cp, int flags, struct smb_cred *scred);
+int  smb_co_get(struct smb_connobj *cp, struct smb_cred *scred);
 void smb_co_put(struct smb_connobj *cp, struct smb_cred *scred);
-int  smb_co_lock(struct smb_connobj *cp, int flags);
-void smb_co_unlock(struct smb_connobj *cp, int flags);
+int  smb_co_lock(struct smb_connobj *cp);
+void smb_co_unlock(struct smb_connobj *cp);
 
 /*
  * session level functions
@@ -373,12 +373,12 @@ int  smb_vc_create(struct smb_vcspec *vcspec,
 	struct smb_cred *scred, struct smb_vc **vcpp);
 int  smb_vc_connect(struct smb_vc *vcp, struct smb_cred *scred);
 int  smb_vc_access(struct smb_vc *vcp, struct smb_cred *scred, mode_t mode);
-int  smb_vc_get(struct smb_vc *vcp, int flags, struct smb_cred *scred);
+int  smb_vc_get(struct smb_vc *vcp, struct smb_cred *scred);
 void smb_vc_put(struct smb_vc *vcp, struct smb_cred *scred);
 void smb_vc_ref(struct smb_vc *vcp);
 void smb_vc_rele(struct smb_vc *vcp, struct smb_cred *scred);
-int  smb_vc_lock(struct smb_vc *vcp, int flags);
-void smb_vc_unlock(struct smb_vc *vcp, int flags);
+int  smb_vc_lock(struct smb_vc *vcp);
+void smb_vc_unlock(struct smb_vc *vcp);
 int  smb_vc_lookupshare(struct smb_vc *vcp, struct smb_sharespec *shspec,
 	struct smb_cred *scred, struct smb_share **sspp);
 const char * smb_vc_getpass(struct smb_vc *vcp);
@@ -392,10 +392,10 @@ int  smb_share_create(struct smb_vc *vcp, struct s
 int  smb_share_access(struct smb_share *ssp, struct smb_cred *scred, mode_t mode);
 void smb_share_ref(struct smb_share *ssp);
 void smb_share_rele(struct smb_share *ssp, struct smb_cred *scred);
-int  smb_share_get(struct smb_share *ssp, int flags, struct smb_cred *scred);
+int  smb_share_get(struct smb_share *ssp, struct smb_cred *scred);
 void smb_share_put(struct smb_share *ssp, struct smb_cred *scred);
-int  smb_share_lock(struct smb_share *ssp, int flags);
-void smb_share_unlock(struct smb_share *ssp, int flags);
+int  smb_share_lock(struct smb_share *ssp);
+void smb_share_unlock(struct smb_share *ssp);
 void smb_share_invalidate(struct smb_share *ssp);
 int  smb_share_valid(struct smb_share *ssp);
 const char * smb_share_getpass(struct smb_share *ssp);
@@ -440,6 +440,7 @@ struct smbiod {
 	int			iod_id;
 	int			iod_flags;
 	enum smbiod_state	iod_state;
+	struct smb_slock	iod_flagslock;	/* iod_flags */
 	int			iod_muxcnt;	/* number of active outstanding requests */
 	int			iod_sleeptimo;
 	struct smb_vc *		iod_vc;
@@ -455,6 +456,13 @@ struct smbiod {
 	struct timespec 	iod_pingtimo;
 };
 
+/*
+ * This lock protects iod_flags
+ */
+#define SMB_IOD_FLAGSLOCKPTR(iod)       (&((iod)->iod_flagslock))
+#define SMB_IOD_FLAGSLOCK(iod)          smb_sl_lock(&((iod)->iod_flagslock))
+#define SMB_IOD_FLAGSUNLOCK(iod)        smb_sl_unlock(&((iod)->iod_flagslock))
+
 int  smb_iod_init(void);
 int  smb_iod_done(void);
 int  smb_iod_create(struct smb_vc *vcp);