Remove all remaining support for LK_DRAIN lockmgr locks. LK_DRAIN was a
authorMatthew Dillon <dillon@dragonflybsd.org>
Sun, 23 Apr 2006 02:41:15 +0000 (02:41 +0000)
committerMatthew Dillon <dillon@dragonflybsd.org>
Sun, 23 Apr 2006 02:41:15 +0000 (02:41 +0000)
mechanism that allowed lock requests to fail while a thread is blocked
disposing of a structure that has not been entirely unlinked from the
rest of the system, but LK_DRAIN's design only works on UP systems or
while the BGL is held.  It cannot be used in concurrent environments.
Just get rid of it entirely.

sys/kern/kern_lock.c
sys/netproto/smb/smb_conn.c
sys/sys/lock.h

index 148fd23..40819ed 100644 (file)
@@ -39,7 +39,7 @@
  *
  *     @(#)kern_lock.c 8.18 (Berkeley) 5/21/95
  * $FreeBSD: src/sys/kern/kern_lock.c,v 1.31.2.3 2001/12/25 01:44:44 dillon Exp $
- * $DragonFly: src/sys/kern/kern_lock.c,v 1.16 2006/03/02 19:07:59 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_lock.c,v 1.17 2006/04/23 02:41:12 dillon Exp $
  */
 
 #include "opt_lint.h"
@@ -84,7 +84,6 @@ SYSCTL_INT(_debug, OID_AUTO, lockmgr_from_int, CTLFLAG_RW, &lockmgr_from_int, 0,
        LK_SHARE_NONZERO | LK_WAIT_NONZERO)
 
 static int acquire(struct lock *lkp, int extflags, int wanted);
-static int acquiredrain(struct lock *lkp, int extflags) ;
 
 static LOCK_INLINE void
 sharelock(struct lock *lkp, int incr) {
@@ -429,87 +428,16 @@ debuglockmgr(struct lock *lkp, u_int flags, struct spinlock *interlkp,
                        wakeup((void *)lkp);
                break;
 
-       case LK_DRAIN:
-               /*
-                * Check that we do not already hold the lock, as it can 
-                * never drain if we do. Unfortunately, we have no way to
-                * check for holding a shared lock, but at least we can
-                * check for an exclusive one.
-                */
-               if (lkp->lk_lockholder == td) {
-                       spin_unlock(&lkp->lk_spinlock);
-                       panic("lockmgr: draining against myself");
-               }
-
-               error = acquiredrain(lkp, extflags);
-               if (error)
-                       break;
-               lkp->lk_flags |= LK_DRAINING | LK_HAVE_EXCL;
-               lkp->lk_lockholder = td;
-               lkp->lk_exclusivecount = 1;
-#if defined(DEBUG_LOCKS)
-                       lkp->lk_filename = file;
-                       lkp->lk_lineno = line;
-                       lkp->lk_lockername = name;
-#endif
-               COUNT(td, 1);
-               break;
-
        default:
                spin_unlock(&lkp->lk_spinlock);
                panic("lockmgr: unknown locktype request %d",
                    flags & LK_TYPE_MASK);
                /* NOTREACHED */
        }
-       if ((lkp->lk_flags & LK_WAITDRAIN) &&
-           (lkp->lk_flags & (LK_HAVE_EXCL | LK_WANT_EXCL | LK_WANT_UPGRADE |
-               LK_SHARE_NONZERO | LK_WAIT_NONZERO)) == 0) {
-               lkp->lk_flags &= ~LK_WAITDRAIN;
-               wakeup((void *)&lkp->lk_flags);
-       }
        spin_unlock(&lkp->lk_spinlock);
        return (error);
 }
 
-/*
- * lock acquisition helper routine.  Called with the lock's spinlock held.
- */
-static int
-acquiredrain(struct lock *lkp, int extflags)
-{
-       int error;
-
-       if ((extflags & LK_NOWAIT) && (lkp->lk_flags & LK_ALL)) {
-               return EBUSY;
-       }
-
-       if ((lkp->lk_flags & LK_ALL) == 0)
-               return 0;
-
-       while (lkp->lk_flags & LK_ALL) {
-               lkp->lk_flags |= LK_WAITDRAIN;
-               /*
-                * Use the _quick version so the critical section is left
-                * intact, protecting the tsleep interlock.  See 
-                * tsleep_interlock() for a description of what is
-                * happening here.
-                */
-               tsleep_interlock(&lkp->lk_flags);
-               spin_unlock_quick(&lkp->lk_spinlock);
-               error = tsleep(&lkp->lk_flags,
-                              ((extflags & LK_PCATCH) ? PCATCH : 0),
-                              lkp->lk_wmesg, 
-                              ((extflags & LK_TIMELOCK) ? lkp->lk_timo : 0));
-               spin_lock_quick(&lkp->lk_spinlock);
-               if (error)
-                       return error;
-               if (extflags & LK_SLEEPFAIL) {
-                       return ENOLCK;
-               }
-       }
-       return 0;
-}
-
 /*
  * Initialize a lock; required before use.
  */
@@ -534,7 +462,7 @@ lockinit(struct lock *lkp, char *wmesg, int timo, int flags)
 void
 lockreinit(struct lock *lkp, char *wmesg, int timo, int flags)
 {
-       lkp->lk_flags = (lkp->lk_flags & ~(LK_EXTFLG_MASK|LK_DRAINING)) |
+       lkp->lk_flags = (lkp->lk_flags & ~LK_EXTFLG_MASK) |
                        (flags & LK_EXTFLG_MASK);
        lkp->lk_wmesg = wmesg;
        lkp->lk_timo = timo;
index 1e2c151..d1ebff4 100644 (file)
@@ -30,7 +30,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/netsmb/smb_conn.c,v 1.1.2.1 2001/05/22 08:32:33 bp Exp $
- * $DragonFly: src/sys/netproto/smb/smb_conn.c,v 1.12 2006/04/23 02:29:33 dillon Exp $
+ * $DragonFly: src/sys/netproto/smb/smb_conn.c,v 1.13 2006/04/23 02:41:14 dillon Exp $
  */
 
 /*
@@ -523,7 +523,6 @@ smb_vc_free(struct smb_connobj *cp)
 
 /*
  * Called when use count of VC dropped to zero.
- * VC should be locked on enter with LK_DRAIN.
  */
 static void
 smb_vc_gone(struct smb_connobj *cp, struct smb_cred *scred)
index 2b62547..7d41ace 100644 (file)
@@ -36,7 +36,7 @@
  *
  *     @(#)lock.h      8.12 (Berkeley) 5/19/95
  * $FreeBSD: src/sys/sys/lock.h,v 1.17.2.3 2001/12/25 01:44:44 dillon Exp $
- * $DragonFly: src/sys/sys/lock.h,v 1.12 2006/03/02 19:08:00 dillon Exp $
+ * $DragonFly: src/sys/sys/lock.h,v 1.13 2006/04/23 02:41:15 dillon Exp $
  */
 
 #ifndef        _SYS_LOCK_H_
@@ -106,9 +106,6 @@ struct lock {
  *     (recursive) exclusive locks, they will all be downgraded to shared
  *     locks.
  *   LK_RELEASE - release one instance of a lock.
- *   LK_DRAIN - wait for all activity on the lock to end, then mark it
- *     decommissioned. This feature is used before freeing a lock that
- *     is part of a piece of memory that is about to be freed.
  *   LK_EXCLOTHER - return for lockstatus().  Used when another process
  *     holds the lock exclusively.
  *
@@ -121,7 +118,7 @@ struct lock {
 #define LK_EXCLUPGRADE 0x00000004      /* first shared-to-exclusive upgrade */
 #define LK_DOWNGRADE   0x00000005      /* exclusive-to-shared downgrade */
 #define LK_RELEASE     0x00000006      /* release any type of lock */
-#define LK_DRAIN       0x00000007      /* wait for all lock activity to end */
+#define LK_UNUSED07    0x00000007
 #define LK_EXCLOTHER   0x00000008      /* other process holds lock */
 /*
  * External lock flags.
@@ -146,8 +143,8 @@ struct lock {
 #define LK_WANT_UPGRADE        0x00000100      /* waiting for share-to-excl upgrade */
 #define LK_WANT_EXCL   0x00000200      /* exclusive lock sought */
 #define LK_HAVE_EXCL   0x00000400      /* exclusive lock obtained */
-#define LK_WAITDRAIN   0x00000800      /* process waiting for lock to drain */
-#define LK_DRAINING    0x00004000      /* lock is being drained */
+#define LK_UNUSED0800  0x00000800
+#define LK_UNUSED4000  0x00004000
 /*
  * Control flags
  *