Remove the thread pointer argument to lockmgr(). All lockmgr() ops use the
authorMatthew Dillon <dillon@dragonflybsd.org>
Fri, 5 May 2006 20:15:02 +0000 (20:15 +0000)
committerMatthew Dillon <dillon@dragonflybsd.org>
Fri, 5 May 2006 20:15:02 +0000 (20:15 +0000)
current thread.

Move the lockmgr code in BUF_KERNPROC to lockmgr_kernproc().  This code
allows the lock owner to be set to a special value so any thread can unlock
the lock and is required for B_ASYNC I/O so biodone() can release the lock.

26 files changed:
sys/bus/usb/ehci.c
sys/dev/agp/agp.c
sys/dev/drm/drm_os_freebsd.h
sys/dev/pccard/pccbb/pccbb.c
sys/kern/imgact_resident.c
sys/kern/kern_linker.c
sys/kern/kern_lock.c
sys/kern/kern_sysctl.c
sys/kern/vfs_default.c
sys/kern/vfs_lock.c
sys/kern/vfs_mount.c
sys/kern/vfs_syscalls.c
sys/netproto/ncp/ncp_conn.c
sys/netproto/smb/smb_conn.c
sys/sys/buf2.h
sys/sys/lock.h
sys/vfs/coda/coda_vnops.c
sys/vfs/hpfs/hpfs.h
sys/vfs/nfs/nfsnode.h
sys/vfs/ntfs/ntfs.h
sys/vfs/nwfs/nwfs_node.c
sys/vfs/smbfs/smbfs_node.c
sys/vfs/specfs/spec_vnops.c
sys/vm/vm_fault.c
sys/vm/vm_map.h
sys/vm/vm_pageout.c

index 43b64fa..9a646f4 100644 (file)
@@ -1,7 +1,7 @@
 /*
  * $NetBSD: ehci.c,v 1.67 2004/07/06 04:18:05 mycroft Exp $
  * $FreeBSD: src/sys/dev/usb/ehci.c,v 1.5 2003/11/10 00:20:52 joe Exp $
- * $DragonFly: src/sys/bus/usb/ehci.c,v 1.20 2006/05/02 16:12:01 dillon Exp $
+ * $DragonFly: src/sys/bus/usb/ehci.c,v 1.21 2006/05/05 20:14:58 dillon Exp $
  */
 
 /*
@@ -1406,7 +1406,7 @@ ehci_sync_hc(ehci_softc_t *sc)
        }
        DPRINTFN(2,("ehci_sync_hc: enter\n"));
        /* get doorbell */
-       lockmgr(&sc->sc_doorbell_lock, LK_EXCLUSIVE, NULL);
+       lockmgr(&sc->sc_doorbell_lock, LK_EXCLUSIVE);
        crit_enter();
        /* ask for doorbell */
        EOWRITE4(sc, EHCI_USBCMD, EOREAD4(sc, EHCI_USBCMD) | EHCI_CMD_IAAD);
@@ -1417,7 +1417,7 @@ ehci_sync_hc(ehci_softc_t *sc)
                    EOREAD4(sc, EHCI_USBCMD), EOREAD4(sc, EHCI_USBSTS)));
        crit_exit();
        /* release doorbell */
-       lockmgr(&sc->sc_doorbell_lock, LK_RELEASE, NULL);
+       lockmgr(&sc->sc_doorbell_lock, LK_RELEASE);
 #ifdef DIAGNOSTIC
        if (error)
                printf("ehci_sync_hc: tsleep() = %d\n", error);
index d4cc7db..8fe66ea 100644 (file)
@@ -24,7 +24,7 @@
  * SUCH DAMAGE.
  *
  *     $FreeBSD: src/sys/pci/agp.c,v 1.3.2.4 2002/08/11 19:58:12 alc Exp $
- *     $DragonFly: src/sys/dev/agp/agp.c,v 1.19 2006/04/23 03:07:59 dillon Exp $
+ *     $DragonFly: src/sys/dev/agp/agp.c,v 1.20 2006/05/05 20:15:01 dillon Exp $
  */
 
 #include "opt_bus.h"
@@ -485,11 +485,11 @@ agp_generic_bind_memory(device_t dev, struct agp_memory *mem,
        vm_page_t m;
        int error;
 
-       lockmgr(&sc->as_lock, LK_EXCLUSIVE, curthread);
+       lockmgr(&sc->as_lock, LK_EXCLUSIVE);
 
        if (mem->am_is_bound) {
                device_printf(dev, "memory already bound\n");
-               lockmgr(&sc->as_lock, LK_RELEASE, curthread);
+               lockmgr(&sc->as_lock, LK_RELEASE);
                return EINVAL;
        }
        
@@ -500,7 +500,7 @@ agp_generic_bind_memory(device_t dev, struct agp_memory *mem,
                              (int) offset, (int)mem->am_size,
                              (int)AGP_GET_APERTURE(dev));
                printf("Check BIOS's aperature size vs X\n");
-               lockmgr(&sc->as_lock, LK_RELEASE, curthread);
+               lockmgr(&sc->as_lock, LK_RELEASE);
                return EINVAL;
        }
 
@@ -548,7 +548,7 @@ agp_generic_bind_memory(device_t dev, struct agp_memory *mem,
                                                           OFF_TO_IDX(k));
                                        vm_page_unwire(m, 0);
                                }
-                               lockmgr(&sc->as_lock, LK_RELEASE, curthread);
+                               lockmgr(&sc->as_lock, LK_RELEASE);
                                return error;
                        }
                }
@@ -569,7 +569,7 @@ agp_generic_bind_memory(device_t dev, struct agp_memory *mem,
        mem->am_offset = offset;
        mem->am_is_bound = 1;
 
-       lockmgr(&sc->as_lock, LK_RELEASE, curthread);
+       lockmgr(&sc->as_lock, LK_RELEASE);
 
        return 0;
 }
@@ -581,11 +581,11 @@ agp_generic_unbind_memory(device_t dev, struct agp_memory *mem)
        vm_page_t m;
        int i;
 
-       lockmgr(&sc->as_lock, LK_EXCLUSIVE, curthread);
+       lockmgr(&sc->as_lock, LK_EXCLUSIVE);
 
        if (!mem->am_is_bound) {
                device_printf(dev, "memory is not bound\n");
-               lockmgr(&sc->as_lock, LK_RELEASE, curthread);
+               lockmgr(&sc->as_lock, LK_RELEASE);
                return EINVAL;
        }
 
@@ -607,7 +607,7 @@ agp_generic_unbind_memory(device_t dev, struct agp_memory *mem)
        mem->am_offset = 0;
        mem->am_is_bound = 0;
 
-       lockmgr(&sc->as_lock, LK_RELEASE, curthread);
+       lockmgr(&sc->as_lock, LK_RELEASE);
 
        return 0;
 }
index bbca22b..a607ef8 100644 (file)
@@ -1,6 +1,6 @@
 /*
  * $FreeBSD: src/sys/dev/drm/drm_os_freebsd.h,v 1.10.2.1 2003/04/26 07:05:28 anholt Exp $
- * $DragonFly: src/sys/dev/drm/Attic/drm_os_freebsd.h,v 1.14 2006/04/23 03:08:00 dillon Exp $
+ * $DragonFly: src/sys/dev/drm/Attic/drm_os_freebsd.h,v 1.15 2006/05/05 20:15:01 dillon Exp $
  */
 #include <sys/param.h>
 #include <sys/queue.h>
  * code for that is not yet written */
 #define DRMFILE                        void *
 #define DRM_IOCTL_ARGS         dev_t kdev, u_long cmd, caddr_t data, int flags, DRM_STRUCTPROC *p, DRMFILE filp
-#define DRM_LOCK               lockmgr(&dev->dev_lock, LK_EXCLUSIVE, DRM_CURPROC)
-#define DRM_UNLOCK             lockmgr(&dev->dev_lock, LK_RELEASE, DRM_CURPROC)
+#define DRM_LOCK               lockmgr(&dev->dev_lock, LK_EXCLUSIVE)
+#define DRM_UNLOCK             lockmgr(&dev->dev_lock, LK_RELEASE)
 #define DRM_SUSER(td)          suser(td)
 #define DRM_TASKQUEUE_ARGS     void *arg, int pending
 #define DRM_IRQ_ARGS           void *arg
index 8df0473..006b5e4 100644 (file)
@@ -27,7 +27,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/dev/pccbb/pccbb.c,v 1.64 2002/11/23 23:09:45 imp Exp $
- * $DragonFly: src/sys/dev/pccard/pccbb/pccbb.c,v 1.14 2006/04/23 03:08:01 dillon Exp $
+ * $DragonFly: src/sys/dev/pccard/pccbb/pccbb.c,v 1.15 2006/05/05 20:15:01 dillon Exp $
  */
 
 /*
@@ -703,9 +703,9 @@ cbb_release_helper(device_t brdev)
 {
        struct cbb_softc *sc = device_get_softc(brdev);
 
-       lockmgr(&sc->lock, LK_EXCLUSIVE, curthread);
+       lockmgr(&sc->lock, LK_EXCLUSIVE);
        sc->flags |= CBB_KTHREAD_DONE;
-       lockmgr(&sc->lock, LK_RELEASE, curthread);
+       lockmgr(&sc->lock, LK_RELEASE);
        if (sc->flags & CBB_KTHREAD_RUNNING) {
                wakeup(sc);
                tsleep(cbb_detach, 0, "pccbb", 2);
@@ -916,7 +916,7 @@ cbb_event_thread(void *arg)
                 * if there's a card already inserted, we do the
                 * right thing.
                 */
-               lockmgr(&sc->lock, LK_EXCLUSIVE, curthread);
+               lockmgr(&sc->lock, LK_EXCLUSIVE);
                if (sc->flags & CBB_KTHREAD_DONE)
                        break;
 
@@ -926,7 +926,7 @@ cbb_event_thread(void *arg)
                        cbb_insert(sc);
                else
                        cbb_removal(sc);
-               lockmgr(&sc->lock, LK_RELEASE, curthread);
+               lockmgr(&sc->lock, LK_RELEASE);
                /* mtx_unlock(&Giant); */
 
                /*
@@ -940,7 +940,7 @@ cbb_event_thread(void *arg)
                        err = tsleep(sc, 0, "pccbb", 1 * hz);
        }
        sc->flags &= ~CBB_KTHREAD_RUNNING;
-       lockmgr(&sc->lock, LK_RELEASE, curthread);
+       lockmgr(&sc->lock, LK_RELEASE);
        /* mtx_lock(&Giant); */
        kthread_exit();
 }
@@ -1041,9 +1041,9 @@ cbb_intr(void *arg)
                 * excellent results.
                 */
                if (sockevent & CBB_SOCKET_EVENT_CD) {
-                       lockmgr(&sc->lock, LK_EXCLUSIVE, curthread);
+                       lockmgr(&sc->lock, LK_EXCLUSIVE);
                        sc->flags &= ~CBB_CARD_OK;
-                       lockmgr(&sc->lock, LK_RELEASE, curthread);
+                       lockmgr(&sc->lock, LK_RELEASE);
                        wakeup(sc);
                }
                if (sockevent & CBB_SOCKET_EVENT_CSTS) {
index 0e9ed78..c803a88 100644 (file)
@@ -31,7 +31,7 @@
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * 
- * $DragonFly: src/sys/kern/imgact_resident.c,v 1.9 2006/04/23 03:08:02 dillon Exp $
+ * $DragonFly: src/sys/kern/imgact_resident.c,v 1.10 2006/05/05 20:15:01 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -142,7 +142,7 @@ sysctl_vm_resident(SYSCTL_HANDLER_ARGS)
        if (!req->oldptr)
            return SYSCTL_OUT(req, 0, exec_res_id);
 
-       lockmgr(&exec_list_lock, LK_SHARED, td);
+       lockmgr(&exec_list_lock, LK_SHARED);
        TAILQ_FOREACH(vmres, &exec_res_list, vr_link) {
                struct xresident xres;
                error = fill_xresident(vmres, &xres, td);
@@ -154,7 +154,7 @@ sysctl_vm_resident(SYSCTL_HANDLER_ARGS)
                if (error != 0)
                        break;
        }
-       lockmgr(&exec_list_lock, LK_RELEASE, td);
+       lockmgr(&exec_list_lock, LK_RELEASE);
 
        return (error);
 }
@@ -210,9 +210,9 @@ exec_sys_register(struct exec_sys_register_args *uap)
     vmres->vr_entry_addr = (intptr_t)uap->entry;
     vmres->vr_vmspace = vmspace_fork(p->p_vmspace); /* XXX order */
 
-    lockmgr(&exec_list_lock, LK_EXCLUSIVE, curthread);
+    lockmgr(&exec_list_lock, LK_EXCLUSIVE);
     TAILQ_INSERT_TAIL(&exec_res_list, vmres, vr_link);
-    lockmgr(&exec_list_lock, LK_RELEASE, curthread);
+    lockmgr(&exec_list_lock, LK_RELEASE);
 
     return(0);
 }
@@ -249,7 +249,7 @@ exec_sys_unregister(struct exec_sys_unregister_args *uap)
     error = ENOENT;
     count = 0;
 
-    lockmgr(&exec_list_lock, LK_EXCLUSIVE, curthread);
+    lockmgr(&exec_list_lock, LK_EXCLUSIVE);
 restart:
     TAILQ_FOREACH(vmres, &exec_res_list, vr_link) {
        if (id == -2 || vmres->vr_id == id) {
@@ -270,7 +270,7 @@ restart:
            goto restart;
        }
     }
-    lockmgr(&exec_list_lock, LK_RELEASE, curthread);
+    lockmgr(&exec_list_lock, LK_RELEASE);
     if (error == 0)
        uap->sysmsg_result = count;
     return(error);
index ad1b3c8..846d447 100644 (file)
@@ -24,7 +24,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/kern/kern_linker.c,v 1.41.2.3 2001/11/21 17:50:35 luigi Exp $
- * $DragonFly: src/sys/kern/kern_linker.c,v 1.26 2006/04/23 03:08:02 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_linker.c,v 1.27 2006/05/05 20:15:01 dillon Exp $
  */
 
 #include "opt_ddb.h"
@@ -326,14 +326,14 @@ linker_find_file_by_name(const char* filename)
        goto out;
     sprintf(koname, "%s.ko", filename);
 
-    lockmgr(&lock, LK_SHARED, curthread);
+    lockmgr(&lock, LK_SHARED);
     for (lf = TAILQ_FIRST(&linker_files); lf; lf = TAILQ_NEXT(lf, link)) {
        if (!strcmp(lf->filename, koname))
            break;
        if (!strcmp(lf->filename, filename))
            break;
     }
-    lockmgr(&lock, LK_RELEASE, curthread);
+    lockmgr(&lock, LK_RELEASE);
 
 out:
     if (koname)
@@ -346,11 +346,11 @@ linker_find_file_by_id(int fileid)
 {
     linker_file_t lf = 0;
 
-    lockmgr(&lock, LK_SHARED, curthread);
+    lockmgr(&lock, LK_SHARED);
     for (lf = TAILQ_FIRST(&linker_files); lf; lf = TAILQ_NEXT(lf, link))
        if (lf->id == fileid)
            break;
-    lockmgr(&lock, LK_RELEASE, curthread);
+    lockmgr(&lock, LK_RELEASE);
 
     return lf;
 }
@@ -369,7 +369,7 @@ linker_make_file(const char* pathname, void* priv, struct linker_file_ops* ops)
        filename = pathname;
 
     KLD_DPF(FILE, ("linker_make_file: new file, filename=%s\n", filename));
-    lockmgr(&lock, LK_EXCLUSIVE, curthread);
+    lockmgr(&lock, LK_EXCLUSIVE);
     namelen = strlen(filename) + 1;
     lf = malloc(sizeof(struct linker_file) + namelen, M_LINKER, M_WAITOK);
     if (!lf)
@@ -392,7 +392,7 @@ linker_make_file(const char* pathname, void* priv, struct linker_file_ops* ops)
     TAILQ_INSERT_TAIL(&linker_files, lf, link);
 
 out:
-    lockmgr(&lock, LK_RELEASE, curthread);
+    lockmgr(&lock, LK_RELEASE);
     return lf;
 }
 
@@ -409,7 +409,7 @@ linker_file_unload(linker_file_t file)
        return EPERM; 
 
     KLD_DPF(FILE, ("linker_file_unload: lf->refs=%d\n", file->refs));
-    lockmgr(&lock, LK_EXCLUSIVE, curthread);
+    lockmgr(&lock, LK_EXCLUSIVE);
     if (file->refs == 1) {
        KLD_DPF(FILE, ("linker_file_unload: file is unloading, informing modules\n"));
        /*
@@ -430,7 +430,7 @@ linker_file_unload(linker_file_t file)
            if ((error = module_unload(mod)) != 0) {
                KLD_DPF(FILE, ("linker_file_unload: module %x vetoes unload\n",
                               mod));
-               lockmgr(&lock, LK_RELEASE, curthread);
+               lockmgr(&lock, LK_RELEASE);
                file->refs--;
                goto out;
            }
@@ -460,7 +460,7 @@ linker_file_unload(linker_file_t file)
 
     file->refs--;
     if (file->refs > 0) {
-       lockmgr(&lock, LK_RELEASE, curthread);
+       lockmgr(&lock, LK_RELEASE);
        goto out;
     }
 
@@ -471,7 +471,7 @@ linker_file_unload(linker_file_t file)
     }
 
     TAILQ_REMOVE(&linker_files, file, link);
-    lockmgr(&lock, LK_RELEASE, curthread);
+    lockmgr(&lock, LK_RELEASE);
 
     for (i = 0; i < file->ndeps; i++)
        linker_file_unload(file->deps[i]);
index 8387a04..41cc757 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.18 2006/04/23 03:08:02 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_lock.c,v 1.19 2006/05/05 20:15:01 dillon Exp $
  */
 
 #include "opt_lint.h"
@@ -167,12 +167,13 @@ acquire(struct lock *lkp, int extflags, int wanted)
  */
 int
 #ifndef        DEBUG_LOCKS
-lockmgr(struct lock *lkp, u_int flags, struct thread *td)
+lockmgr(struct lock *lkp, u_int flags)
 #else
-debuglockmgr(struct lock *lkp, u_int flags, struct thread *td,
+debuglockmgr(struct lock *lkp, u_int flags,
             const char *name, const char *file, int line)
 #endif
 {
+       thread_t td;
        int error;
        int extflags;
        static int didpanic;
@@ -212,6 +213,7 @@ debuglockmgr(struct lock *lkp, u_int flags, struct thread *td,
        spin_lock(&lkp->lk_spinlock);
 
        extflags = (flags | lkp->lk_flags) & LK_EXTFLG_MASK;
+       td = curthread;
 
        switch (flags & LK_TYPE_MASK) {
        case LK_SHARED:
@@ -431,6 +433,16 @@ debuglockmgr(struct lock *lkp, u_int flags, struct thread *td,
        return (error);
 }
 
+void
+lockmgr_kernproc(struct lock *lp)
+{
+       struct thread *td = curthread;
+
+       KASSERT(lp->lk_lockholder == td, ("lockmgr_kernproc: lock not owned by curthread %p", td));
+       COUNT(td, -1);
+       lp->lk_lockholder = LK_KERNTHREAD;
+}
+
 /*
  * Initialize a lock; required before use.
  */
index 47a72cf..ec7c360 100644 (file)
@@ -38,7 +38,7 @@
  *
  *     @(#)kern_sysctl.c       8.4 (Berkeley) 4/14/94
  * $FreeBSD: src/sys/kern/kern_sysctl.c,v 1.92.2.9 2003/05/01 22:48:09 trhodes Exp $
- * $DragonFly: src/sys/kern/kern_sysctl.c,v 1.20 2006/04/23 03:08:02 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_sysctl.c,v 1.21 2006/05/05 20:15:01 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -1289,23 +1289,24 @@ userland_sysctl(int *name, u_int namelen, void *old, size_t *oldlenp, int inkern
 static void
 sysctl_lock(int flag)
 {
-       lockmgr(&sysctl_lkp, flag, curthread);
+       lockmgr(&sysctl_lkp, flag);
 }
 
 static void
 sysctl_unlock(void)
 {
-       lockmgr(&sysctl_lkp, LK_RELEASE, curthread);
+       lockmgr(&sysctl_lkp, LK_RELEASE);
 }
 
 static void
 sysctl_ctx_lock(int flag)
 {
-       lockmgr(&sysctl_ctx_lkp, flag, curthread);
+       lockmgr(&sysctl_ctx_lkp, flag);
 }
 
 static void
 sysctl_ctx_unlock(void)
 {
-       lockmgr(&sysctl_ctx_lkp, LK_RELEASE, curthread);
+       lockmgr(&sysctl_ctx_lkp, LK_RELEASE);
 }
+
index b289328..1f38e36 100644 (file)
@@ -37,7 +37,7 @@
  *
  *
  * $FreeBSD: src/sys/kern/vfs_default.c,v 1.28.2.7 2003/01/10 18:23:26 bde Exp $
- * $DragonFly: src/sys/kern/vfs_default.c,v 1.36 2006/05/05 16:35:00 dillon Exp $
+ * $DragonFly: src/sys/kern/vfs_default.c,v 1.37 2006/05/05 20:15:01 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -1252,15 +1252,15 @@ vop_stdlock(ap)
        struct vop_lock_args /* {
                struct vnode *a_vp;
                int a_flags;
-               struct proc *a_p;
+               struct thread *a_td;
        } */ *ap;
 {               
        int error;
 
 #ifndef        DEBUG_LOCKS
-       error = lockmgr(&ap->a_vp->v_lock, ap->a_flags, ap->a_td);
+       error = lockmgr(&ap->a_vp->v_lock, ap->a_flags);
 #else
-       error = debuglockmgr(&ap->a_vp->v_lock, ap->a_flags, ap->a_td,
+       error = debuglockmgr(&ap->a_vp->v_lock, ap->a_flags,
                        "vop_stdlock", ap->a_vp->filename, ap->a_vp->line);
 #endif
        return(error);
@@ -1276,7 +1276,7 @@ vop_stdunlock(ap)
 {
        int error;
 
-       error = lockmgr(&ap->a_vp->v_lock, ap->a_flags | LK_RELEASE, ap->a_td);
+       error = lockmgr(&ap->a_vp->v_lock, ap->a_flags | LK_RELEASE);
        return(error);
 }
 
index 1163402..2b27e3e 100644 (file)
@@ -31,7 +31,7 @@
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * $DragonFly: src/sys/kern/vfs_lock.c,v 1.14 2006/04/23 03:08:02 dillon Exp $
+ * $DragonFly: src/sys/kern/vfs_lock.c,v 1.15 2006/05/05 20:15:01 dillon Exp $
  */
 
 /*
@@ -235,13 +235,13 @@ vdrop(struct vnode *vp)
 static int
 __vxlock(struct vnode *vp, int flags)
 {
-       return(lockmgr(&vp->v_lock, flags, curthread));
+       return(lockmgr(&vp->v_lock, flags));
 }
 
 static void
 __vxunlock(struct vnode *vp)
 {
-       lockmgr(&vp->v_lock, LK_RELEASE, curthread);
+       lockmgr(&vp->v_lock, LK_RELEASE);
 }
 
 int
index c10ed7d..b870e25 100644 (file)
@@ -67,7 +67,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * $DragonFly: src/sys/kern/vfs_mount.c,v 1.14 2006/04/23 03:08:02 dillon Exp $
+ * $DragonFly: src/sys/kern/vfs_mount.c,v 1.15 2006/05/05 20:15:01 dillon Exp $
  */
 
 /*
@@ -261,7 +261,7 @@ vfs_busy(struct mount *mp, int flags, struct thread *td)
                return (ENOENT);
        }
        lkflags = LK_SHARED | LK_NOPAUSE;
-       if (lockmgr(&mp->mnt_lock, lkflags, td))
+       if (lockmgr(&mp->mnt_lock, lkflags))
                panic("vfs_busy: unexpected lock failure");
        return (0);
 }
@@ -272,7 +272,7 @@ vfs_busy(struct mount *mp, int flags, struct thread *td)
 void
 vfs_unbusy(struct mount *mp, struct thread *td)
 {
-       lockmgr(&mp->mnt_lock, LK_RELEASE, td);
+       lockmgr(&mp->mnt_lock, LK_RELEASE);
 }
 
 /*
index dbb8f52..8caee36 100644 (file)
@@ -37,7 +37,7 @@
  *
  *     @(#)vfs_syscalls.c      8.13 (Berkeley) 4/15/94
  * $FreeBSD: src/sys/kern/vfs_syscalls.c,v 1.151.2.18 2003/04/04 20:35:58 tegge Exp $
- * $DragonFly: src/sys/kern/vfs_syscalls.c,v 1.82 2006/04/23 03:08:02 dillon Exp $
+ * $DragonFly: src/sys/kern/vfs_syscalls.c,v 1.83 2006/05/05 20:15:01 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -534,7 +534,7 @@ dounmount(struct mount *mp, int flags, struct thread *td)
        if (flags & MNT_FORCE)
                mp->mnt_kern_flag |= MNTK_UNMOUNTF;
        lflags = LK_EXCLUSIVE | ((flags & MNT_FORCE) ? 0 : LK_NOWAIT);
-       error = lockmgr(&mp->mnt_lock, lflags, td);
+       error = lockmgr(&mp->mnt_lock, lflags);
        if (error) {
                mp->mnt_kern_flag &= ~(MNTK_UNMOUNT | MNTK_UNMOUNTF);
                if (mp->mnt_kern_flag & MNTK_MWAIT)
@@ -560,7 +560,7 @@ dounmount(struct mount *mp, int flags, struct thread *td)
                        vfs_allocate_syncvnode(mp);
                mp->mnt_kern_flag &= ~(MNTK_UNMOUNT | MNTK_UNMOUNTF);
                mp->mnt_flag |= async_flag;
-               lockmgr(&mp->mnt_lock, LK_RELEASE, td);
+               lockmgr(&mp->mnt_lock, LK_RELEASE);
                if (mp->mnt_kern_flag & MNTK_MWAIT)
                        wakeup(mp);
                return (error);
@@ -593,7 +593,7 @@ dounmount(struct mount *mp, int flags, struct thread *td)
        mp->mnt_vfc->vfc_refcount--;
        if (!TAILQ_EMPTY(&mp->mnt_nvnodelist))
                panic("unmount: dangling vnode");
-       lockmgr(&mp->mnt_lock, LK_RELEASE, td);
+       lockmgr(&mp->mnt_lock, LK_RELEASE);
        if (mp->mnt_kern_flag & MNTK_MWAIT)
                wakeup(mp);
        free(mp, M_MOUNT);
index d5974ea..0bc6604 100644 (file)
@@ -29,7 +29,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * $FreeBSD: src/sys/netncp/ncp_conn.c,v 1.3.2.5 2001/02/22 08:54:11 bp Exp $
- * $DragonFly: src/sys/netproto/ncp/ncp_conn.c,v 1.11 2006/04/23 03:08:04 dillon Exp $
+ * $DragonFly: src/sys/netproto/ncp/ncp_conn.c,v 1.12 2006/05/05 20:15:01 dillon Exp $
  *
  * Connection tables
  */
@@ -80,13 +80,13 @@ ncp_conn_init(void) {
 int
 ncp_conn_locklist(int flags, struct thread *td)
 {
-       return lockmgr(&listlock, flags | LK_CANRECURSE, td);
+       return lockmgr(&listlock, flags | LK_CANRECURSE);
 }
 
 void
 ncp_conn_unlocklist(struct thread *td)
 {
-       lockmgr(&listlock, LK_RELEASE, td);
+       lockmgr(&listlock, LK_RELEASE);
 }
 
 int
@@ -114,17 +114,17 @@ ncp_conn_lock_any(struct ncp_conn *conn, struct thread *td, struct ucred *cred)
 
        if (conn->nc_id == 0) 
                return EACCES;
-       error = lockmgr(&conn->nc_lock, LK_EXCLUSIVE | LK_CANRECURSE, td);
+       error = lockmgr(&conn->nc_lock, LK_EXCLUSIVE | LK_CANRECURSE);
        if (error == ERESTART)
                return EINTR;
        error = ncp_chkintr(conn, td);
        if (error) {
-               lockmgr(&conn->nc_lock, LK_RELEASE, td);
+               lockmgr(&conn->nc_lock, LK_RELEASE);
                return error;
        }
 
        if (conn->nc_id == 0) {
-               lockmgr(&conn->nc_lock, LK_RELEASE, td);
+               lockmgr(&conn->nc_lock, LK_RELEASE);
                return EACCES;
        }
        conn->td = td;  /* who currently operates */
@@ -178,7 +178,7 @@ ncp_conn_unlock(struct ncp_conn *conn, struct thread *td) {
         * note, that LK_RELASE will do wakeup() instead of wakeup_one().
         * this will do a little overhead
         */
-       lockmgr(&conn->nc_lock, LK_RELEASE, td);
+       lockmgr(&conn->nc_lock, LK_RELEASE);
 }
 
 int 
@@ -251,7 +251,7 @@ ncp_conn_free(struct ncp_conn *ncp)
                ncp_conn_unlock(ncp, ncp->td);
                printf("lwant = %d\n", ncp->nc_lwant);
                tsleep(&ncp->nc_lwant, 0, "ncpdr", 2*hz);
-               lockmgr(&ncp->nc_lock, LK_EXCLUSIVE, ncp->td);
+               lockmgr(&ncp->nc_lock, LK_EXCLUSIVE);
        }
        ncp_conn_locklist(LK_EXCLUSIVE, ncp->td);
        SLIST_FOREACH(ncp1, &conn_list, nc_next) {
@@ -409,14 +409,14 @@ int
 ncp_conn_gethandle(struct ncp_conn *conn, struct thread *td, struct ncp_handle **handle){
        struct ncp_handle *refp;
 
-       lockmgr(&lhlock, LK_EXCLUSIVE, td);
+       lockmgr(&lhlock, LK_EXCLUSIVE);
        SLIST_FOREACH(refp, &lhlist, nh_next)
                if (refp->nh_conn == conn && td == refp->nh_td) break;
        if (refp) {
                conn->ref_cnt++;
                refp->nh_ref++;
                *handle = refp;
-               lockmgr(&lhlock, LK_RELEASE, td);
+               lockmgr(&lhlock, LK_RELEASE);
                return 0;
        }
        MALLOC(refp,struct ncp_handle *,sizeof(struct ncp_handle),M_NCPDATA,
@@ -428,7 +428,7 @@ ncp_conn_gethandle(struct ncp_conn *conn, struct thread *td, struct ncp_handle *
        refp->nh_id = ncp_next_handle++;
        *handle = refp;
        conn->ref_cnt++;
-       lockmgr(&lhlock, LK_RELEASE, td);
+       lockmgr(&lhlock, LK_RELEASE);
        return 0;
 }
 /*
@@ -438,7 +438,7 @@ int
 ncp_conn_puthandle(struct ncp_handle *handle, struct thread *td, int force) {
        struct ncp_handle *refp = handle;
 
-       lockmgr(&lhlock, LK_EXCLUSIVE, td);
+       lockmgr(&lhlock, LK_EXCLUSIVE);
        refp->nh_ref--;
        refp->nh_conn->ref_cnt--;
        if (force) {
@@ -449,7 +449,7 @@ ncp_conn_puthandle(struct ncp_handle *handle, struct thread *td, int force) {
                SLIST_REMOVE(&lhlist, refp, ncp_handle, nh_next);
                FREE(refp, M_NCPDATA);
        }
-       lockmgr(&lhlock, LK_RELEASE, td);
+       lockmgr(&lhlock, LK_RELEASE);
        return 0;
 }
 /*
@@ -459,10 +459,10 @@ int
 ncp_conn_findhandle(int connHandle, struct thread *td, struct ncp_handle **handle) {
        struct ncp_handle *refp;
 
-       lockmgr(&lhlock, LK_SHARED, td);
+       lockmgr(&lhlock, LK_SHARED);
        SLIST_FOREACH(refp, &lhlist, nh_next)
                if (refp->nh_td == td && refp->nh_id == connHandle) break;
-       lockmgr(&lhlock, LK_RELEASE, td);
+       lockmgr(&lhlock, LK_RELEASE);
        if (refp == NULL) {
                return EBADF;
        }
@@ -477,7 +477,7 @@ ncp_conn_putprochandles(struct thread *td) {
        struct ncp_handle *hp, *nhp;
        int haveone = 0;
 
-       lockmgr(&lhlock, LK_EXCLUSIVE, td);
+       lockmgr(&lhlock, LK_EXCLUSIVE);
        for (hp = SLIST_FIRST(&lhlist); hp; hp = nhp) {
                nhp = SLIST_NEXT(hp, nh_next);
                if (hp->nh_td != td) continue;
@@ -486,7 +486,7 @@ ncp_conn_putprochandles(struct thread *td) {
                SLIST_REMOVE(&lhlist, hp, ncp_handle, nh_next);
                FREE(hp, M_NCPDATA);
        }
-       lockmgr(&lhlock, LK_RELEASE, td);
+       lockmgr(&lhlock, LK_RELEASE);
        return haveone;
 }
 /*
index 7f114f6..12c9ec7 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.14 2006/04/23 03:08:04 dillon Exp $
+ * $DragonFly: src/sys/netproto/smb/smb_conn.c,v 1.15 2006/05/05 20:15:01 dillon Exp $
  */
 
 /*
@@ -259,7 +259,7 @@ smb_co_gone(struct smb_connobj *cp, struct smb_cred *scred)
                SLIST_REMOVE(&parent->co_children, cp, smb_connobj, co_next);
                smb_co_put(parent, scred);
        }
-       lockmgr(&cp->co_lock, LK_RELEASE, scred->scr_td);
+       lockmgr(&cp->co_lock, LK_RELEASE);
        while (cp->co_usecount > 0) {
                tsleep(&cp->co_lock, 0, "smbgone", hz);
        }
@@ -295,7 +295,7 @@ smb_co_rele(struct smb_connobj *cp, struct smb_cred *scred)
        if ((cp->co_flags & SMBO_GONE) == 0) {
                cp->co_flags |= SMBO_GONE;
                SMB_CO_UNLOCK(cp);
-               lockmgr(&cp->co_lock, LK_EXCLUSIVE, td);
+               lockmgr(&cp->co_lock, LK_EXCLUSIVE);
                smb_co_gone(cp, scred);
        } else {
                SMB_CO_UNLOCK(cp);
@@ -325,7 +325,7 @@ smb_co_get(struct smb_connobj *cp, int flags, struct smb_cred *scred)
                        if ((cp->co_flags & SMBO_GONE) == 0) {
                                cp->co_flags |= SMBO_GONE;
                                SMB_CO_UNLOCK(cp);
-                               lockmgr(&cp->co_lock, LK_EXCLUSIVE, scred->scr_td);
+                               lockmgr(&cp->co_lock, LK_EXCLUSIVE);
                                smb_co_gone(cp, scred);
                        } else {
                                SMB_CO_UNLOCK(cp);
@@ -339,13 +339,11 @@ smb_co_get(struct smb_connobj *cp, int flags, struct smb_cred *scred)
 void
 smb_co_put(struct smb_connobj *cp, struct smb_cred *scred)
 {
-       struct thread *td = scred->scr_td;
-
        SMB_CO_LOCK(cp);
        if (cp->co_usecount > 1) {
                cp->co_usecount--;
                SMB_CO_UNLOCK(cp);
-               lockmgr(&cp->co_lock, LK_RELEASE, td);
+               lockmgr(&cp->co_lock, LK_RELEASE);
                return;
        }
        if (cp->co_usecount <= 0) {
@@ -357,12 +355,12 @@ smb_co_put(struct smb_connobj *cp, struct smb_cred *scred)
        if ((cp->co_flags & SMBO_GONE) == 0) {
                cp->co_flags |= SMBO_GONE;
                SMB_CO_UNLOCK(cp);
-               lockmgr(&cp->co_lock, LK_RELEASE, td);
-               lockmgr(&cp->co_lock, LK_EXCLUSIVE, td);
+               lockmgr(&cp->co_lock, LK_RELEASE);
+               lockmgr(&cp->co_lock, LK_EXCLUSIVE);
                smb_co_gone(cp, scred);
        } else {
                SMB_CO_UNLOCK(cp);
-               lockmgr(&cp->co_lock, LK_RELEASE, td);
+               lockmgr(&cp->co_lock, LK_RELEASE);
                wakeup(&cp->co_lock);
        }
 }
@@ -388,9 +386,9 @@ smb_co_lock(struct smb_connobj *cp, int flags, struct thread *td)
                SMBERROR("recursive lock for object %d\n", cp->co_level);
                return 0;
        }
-       error = lockmgr(&cp->co_lock, flags, td);
+       error = lockmgr(&cp->co_lock, flags);
        if (error == 0 && (cp->co_flags & SMBO_GONE)) {
-               lockmgr(&cp->co_lock, LK_RELEASE, td);
+               lockmgr(&cp->co_lock, LK_RELEASE);
                error = EINVAL;
        }
        return (error);
@@ -399,7 +397,7 @@ smb_co_lock(struct smb_connobj *cp, int flags, struct thread *td)
 void
 smb_co_unlock(struct smb_connobj *cp, int flags, struct thread *td)
 {
-       lockmgr(&cp->co_lock, flags | LK_RELEASE, td);
+       lockmgr(&cp->co_lock, flags | LK_RELEASE);
 }
 
 static void
index 46bd103..9796a64 100644 (file)
@@ -37,7 +37,7 @@
  *
  *     @(#)buf.h       8.9 (Berkeley) 3/30/95
  * $FreeBSD: src/sys/sys/buf.h,v 1.88.2.10 2003/01/25 19:02:23 dillon Exp $
- * $DragonFly: src/sys/sys/buf2.h,v 1.16 2006/04/23 03:08:04 dillon Exp $
+ * $DragonFly: src/sys/sys/buf2.h,v 1.17 2006/05/05 20:15:01 dillon Exp $
  */
 
 #ifndef _SYS_BUF2_H_
@@ -71,7 +71,7 @@ static __inline int
 BUF_LOCK(struct buf *bp, int locktype)
 {
        bp->b_lock.lk_wmesg = buf_wmesg;
-       return (lockmgr(&(bp)->b_lock, locktype, curthread));
+       return (lockmgr(&(bp)->b_lock, locktype));
 }
 /*
  * Get a lock sleeping with specified interruptably and timeout.
@@ -87,7 +87,7 @@ BUF_TIMELOCK(struct buf *bp, int locktype, char *wmesg, int timo)
 {
        bp->b_lock.lk_wmesg = wmesg;
        bp->b_lock.lk_timo = timo;
-       return (lockmgr(&(bp)->b_lock, locktype | LK_TIMELOCK, curthread));
+       return (lockmgr(&(bp)->b_lock, locktype | LK_TIMELOCK));
 }
 /*
  * Release a lock. Only the acquiring process may free the lock unless
@@ -96,7 +96,7 @@ BUF_TIMELOCK(struct buf *bp, int locktype, char *wmesg, int timo)
 static __inline void
 BUF_UNLOCK(struct buf *bp)
 {
-       lockmgr(&(bp)->b_lock, LK_RELEASE, curthread);
+       lockmgr(&(bp)->b_lock, LK_RELEASE);
 }
 
 /*
@@ -108,11 +108,7 @@ BUF_UNLOCK(struct buf *bp)
 static __inline void
 BUF_KERNPROC(struct buf *bp)
 {
-       struct thread *td = curthread;
-
-       if (bp->b_lock.lk_lockholder == td)
-               td->td_locks--;
-       bp->b_lock.lk_lockholder = LK_KERNTHREAD;
+       lockmgr_kernproc(&(bp)->b_lock);
 }
 /*
  * Find out the number of references to a lock.
index 74d5cf9..0ceaea5 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.15 2006/04/23 06:31:47 dillon Exp $
+ * $DragonFly: src/sys/sys/lock.h,v 1.16 2006/05/05 20:15:01 dillon Exp $
  */
 
 #ifndef        _SYS_LOCK_H_
@@ -192,15 +192,15 @@ void      lockinit (struct lock *, char *wmesg, int timo, int flags);
 void   lockreinit (struct lock *, char *wmesg, int timo, int flags);
 #ifdef DEBUG_LOCKS
 int    debuglockmgr (struct lock *, u_int flags,
-                       struct thread *p,
                        const char *,
                        const char *,
                        int);
-#define lockmgr(lockp, flags, td) \
-       debuglockmgr((lockp), (flags), (td), "lockmgr", __FILE__, __LINE__)
+#define lockmgr(lockp, flags) \
+       debuglockmgr((lockp), (flags), "lockmgr", __FILE__, __LINE__)
 #else
-int    lockmgr (struct lock *, u_int flags, struct thread *td);
+int    lockmgr (struct lock *, u_int flags);
 #endif
+void   lockmgr_kernproc (struct lock *);
 void   lockmgr_printinfo (struct lock *);
 int    lockstatus (struct lock *, struct thread *);
 int    lockcount (struct lock *);
index a7aa2ec..e6ba171 100644 (file)
@@ -28,7 +28,7 @@
  * 
  *     @(#) src/sys/coda/coda_vnops.c,v 1.1.1.1 1998/08/29 21:14:52 rvb Exp $
  * $FreeBSD: src/sys/coda/coda_vnops.c,v 1.22.2.1 2001/06/29 16:26:22 shafeeq Exp $
- * $DragonFly: src/sys/vfs/coda/Attic/coda_vnops.c,v 1.35 2006/05/05 16:35:04 dillon Exp $
+ * $DragonFly: src/sys/vfs/coda/Attic/coda_vnops.c,v 1.36 2006/05/05 20:15:01 dillon Exp $
  * 
  */
 
@@ -1696,7 +1696,6 @@ coda_lock(void *v)
     struct vop_lock_args *ap = v;
     struct vnode *vp = ap->a_vp;
     struct cnode *cp = VTOC(vp);
-    struct thread *td = ap->a_td;
 /* upcall decl */
 /* locals */
 
@@ -1708,9 +1707,9 @@ coda_lock(void *v)
     }
 
 #ifndef        DEBUG_LOCKS
-    return (lockmgr(&vp->v_lock, ap->a_flags, td));
+    return (lockmgr(&vp->v_lock, ap->a_flags));
 #else
-    return (debuglockmgr(&vp->v_lock, ap->a_flags, td,
+    return (debuglockmgr(&vp->v_lock, ap->a_flags,
                         "coda_lock", vp->filename, vp->line));
 #endif
 }
@@ -1722,7 +1721,6 @@ coda_unlock(void *v)
     struct vop_unlock_args *ap = v;
     struct vnode *vp = ap->a_vp;
     struct cnode *cp = VTOC(vp);
-    struct thread *td = ap->a_td;
 /* upcall decl */
 /* locals */
 
@@ -1732,7 +1730,7 @@ coda_unlock(void *v)
                  cp->c_fid.Volume, cp->c_fid.Vnode, cp->c_fid.Unique));
     }
 
-    return (lockmgr(&vp->v_lock, ap->a_flags | LK_RELEASE, td));
+    return (lockmgr(&vp->v_lock, ap->a_flags | LK_RELEASE));
 }
 
 int
index 21122ee..4b1d34f 100644 (file)
@@ -24,7 +24,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/fs/hpfs/hpfs.h,v 1.1 1999/12/09 19:09:58 semenu Exp $
- * $DragonFly: src/sys/vfs/hpfs/hpfs.h,v 1.16 2006/04/23 03:08:04 dillon Exp $
+ * $DragonFly: src/sys/vfs/hpfs/hpfs.h,v 1.17 2006/05/05 20:15:01 dillon Exp $
  */
 
 /*#define HPFS_DEBUG 10*/
@@ -403,7 +403,7 @@ typedef int (vop_t) (void *);
 #define VOP__UNLOCK(a, b, c)   VOP_UNLOCK((a), (b), (c))
 #define VGET(a, b, c)          vget((a), (b), (c))
 #define VN_LOCK(a, b, c)       vn_lock((a), (b), (c))
-#define        LOCKMGR(a, b, d)        lockmgr((a), (b), (d))
+#define        LOCKMGR(a, b, d)        lockmgr((a), (b))
 #endif
 
 struct vfsconf;
index 750a068..9217d49 100644 (file)
@@ -35,7 +35,7 @@
  *
  *     @(#)nfsnode.h   8.9 (Berkeley) 5/14/95
  * $FreeBSD: /repoman/r/ncvs/src/sys/nfsclient/nfsnode.h,v 1.43 2004/04/14 23:23:55 peadar Exp $
- * $DragonFly: src/sys/vfs/nfs/nfsnode.h,v 1.16 2006/04/23 03:08:04 dillon Exp $
+ * $DragonFly: src/sys/vfs/nfs/nfsnode.h,v 1.17 2006/05/05 20:15:01 dillon Exp $
  */
 
 
@@ -195,14 +195,14 @@ int
 nfs_rslock(struct nfsnode *np, struct thread *td)
 {
         return(lockmgr(&np->n_rslock, LK_EXCLUSIVE | LK_CANRECURSE |
-                      LK_SLEEPFAIL, td));
+                      LK_SLEEPFAIL));
 }
 
 static __inline
 void
 nfs_rsunlock(struct nfsnode *np, struct thread *td)
 {
-       lockmgr(&np->n_rslock, LK_RELEASE, td);
+       lockmgr(&np->n_rslock, LK_RELEASE);
 }
 
 static __inline
index 07b3db3..686628d 100644 (file)
@@ -26,7 +26,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/ntfs/ntfs.h,v 1.8.2.2 2001/10/12 22:08:49 semenu Exp $
- * $DragonFly: src/sys/vfs/ntfs/ntfs.h,v 1.9 2006/04/23 03:08:04 dillon Exp $
+ * $DragonFly: src/sys/vfs/ntfs/ntfs.h,v 1.10 2006/05/05 20:15:01 dillon Exp $
  */
 
 /*#define NTFS_DEBUG 1*/
@@ -327,7 +327,7 @@ typedef int (vop_t) (void *);
 #define VOP__UNLOCK(a, b, c)   VOP_UNLOCK((a), (b), (c))
 #define VGET(a, b, c)          vget((a), (b), (c))
 #define VN_LOCK(a, b, c)       vn_lock((a), (b), (c))
-#define        LOCKMGR(a, b)           lockmgr((a), (b), curthread)
+#define        LOCKMGR(a, b)           lockmgr((a), (b))
 
 #endif /* NetBSD */
 
index 965ecb3..a0b3d32 100644 (file)
@@ -30,7 +30,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/nwfs/nwfs_node.c,v 1.3.2.8 2001/12/25 01:44:45 dillon Exp $
- * $DragonFly: src/sys/vfs/nwfs/nwfs_node.c,v 1.20 2006/04/23 03:08:04 dillon Exp $
+ * $DragonFly: src/sys/vfs/nwfs/nwfs_node.c,v 1.21 2006/05/05 20:15:02 dillon Exp $
  */
 #include <sys/param.h>
 #include <sys/systm.h>
@@ -144,11 +144,11 @@ nwfs_allocvp(struct mount *mp, ncpfid fid, struct vnode **vpp)
        int error;
 
 loop:
-       lockmgr(&nwhashlock, LK_EXCLUSIVE, td);
+       lockmgr(&nwhashlock, LK_EXCLUSIVE);
 rescan:
        if (nwfs_hashlookup(nmp, fid, &np) == 0) {
                vp = NWTOV(np);
-               lockmgr(&nwhashlock, LK_RELEASE, td);
+               lockmgr(&nwhashlock, LK_RELEASE);
                if (vget(vp, LK_EXCLUSIVE, td))
                        goto loop;
                if (nwfs_hashlookup(nmp, fid, &np) || NWTOV(np) != vp) {
@@ -158,7 +158,7 @@ rescan:
                *vpp = vp;
                return(0);
        }
-       lockmgr(&nwhashlock, LK_RELEASE, td);
+       lockmgr(&nwhashlock, LK_RELEASE);
 
        /*
         * Do the MALLOC before the getnewvnode since doing so afterward
@@ -179,7 +179,7 @@ rescan:
         * Another process can create vnode while we blocked in malloc() or
         * getnewvnode(). Rescan list again.
         */
-       lockmgr(&nwhashlock, LK_EXCLUSIVE, td);
+       lockmgr(&nwhashlock, LK_EXCLUSIVE);
        if (nwfs_hashlookup(nmp, fid, NULL) == 0) {
                np->n_vnode = NULL;
                vx_put(vp);
@@ -193,7 +193,7 @@ rescan:
        lockinit(&np->n_lock, "nwnode", VLKTIMEOUT, LK_CANRECURSE);
        nhpp = NWNOHASH(fid);
        LIST_INSERT_HEAD(nhpp, np, n_hash);
-       lockmgr(&nwhashlock, LK_RELEASE, td);
+       lockmgr(&nwhashlock, LK_RELEASE);
        return 0;
 }
 
@@ -203,9 +203,9 @@ nwfs_lookupnp(struct nwmount *nmp, ncpfid fid, struct thread *td,
 {
        int error;
 
-       lockmgr(&nwhashlock, LK_EXCLUSIVE, td);
+       lockmgr(&nwhashlock, LK_EXCLUSIVE);
        error = nwfs_hashlookup(nmp, fid, npp);
-       lockmgr(&nwhashlock, LK_RELEASE, td);
+       lockmgr(&nwhashlock, LK_RELEASE);
        return error;
 }
 
@@ -232,9 +232,9 @@ nwfs_reclaim(struct vop_reclaim_args *ap)
                }
        }
        if (np) {
-               lockmgr(&nwhashlock, LK_EXCLUSIVE, td);
+               lockmgr(&nwhashlock, LK_EXCLUSIVE);
                LIST_REMOVE(np, n_hash);
-               lockmgr(&nwhashlock, LK_RELEASE, td);
+               lockmgr(&nwhashlock, LK_RELEASE);
        }
        if (nmp->n_root == np)
                nmp->n_root = NULL;
index 942236c..4c2edd8 100644 (file)
@@ -30,7 +30,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/fs/smbfs/smbfs_node.c,v 1.2.2.3 2003/01/17 08:20:26 tjr Exp $
- * $DragonFly: src/sys/vfs/smbfs/smbfs_node.c,v 1.18 2006/04/23 03:08:04 dillon Exp $
+ * $DragonFly: src/sys/vfs/smbfs/smbfs_node.c,v 1.19 2006/05/05 20:15:02 dillon Exp $
  */
 #include <sys/param.h>
 #include <sys/systm.h>
@@ -56,8 +56,8 @@
 #include "smbfs_subr.h"
 
 #define        SMBFS_NOHASH(smp, hval) (&(smp)->sm_hash[(hval) & (smp)->sm_hashlen])
-#define        smbfs_hash_lock(smp, td)        lockmgr(&smp->sm_hashlock, LK_EXCLUSIVE, td)
-#define        smbfs_hash_unlock(smp, td)      lockmgr(&smp->sm_hashlock, LK_RELEASE, td)
+#define        smbfs_hash_lock(smp, td)        lockmgr(&smp->sm_hashlock, LK_EXCLUSIVE)
+#define        smbfs_hash_unlock(smp, td)      lockmgr(&smp->sm_hashlock, LK_RELEASE)
 
 
 MALLOC_DEFINE(M_SMBNODE, "SMBFS node", "SMBFS vnode private part");
@@ -299,7 +299,6 @@ int
 smbfs_reclaim(struct vop_reclaim_args *ap)
 {
        struct vnode *vp = ap->a_vp;
-       struct thread *td = ap->a_td;
        struct vnode *dvp;
        struct smbnode *np = VTOSMB(vp);
        struct smbmount *smp = VTOSMBFS(vp);
index ec7f598..365d72e 100644 (file)
@@ -32,7 +32,7 @@
  *
  *     @(#)spec_vnops.c        8.14 (Berkeley) 5/21/95
  * $FreeBSD: src/sys/miscfs/specfs/spec_vnops.c,v 1.131.2.4 2001/02/26 04:23:20 jlemon Exp $
- * $DragonFly: src/sys/vfs/specfs/spec_vnops.c,v 1.40 2006/05/03 20:44:49 dillon Exp $
+ * $DragonFly: src/sys/vfs/specfs/spec_vnops.c,v 1.41 2006/05/05 20:15:02 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -464,12 +464,12 @@ spec_strategy(struct vop_strategy_args *ap)
        KKASSERT(vp->v_rdev != NULL);   /* XXX */
        if (vn_isdisk(vp, NULL) && (mp = vp->v_rdev->si_mountpoint) != NULL) {
                if (bp->b_cmd == BUF_CMD_READ) {
-                       if (bp->b_lock.lk_lockholder == LK_KERNTHREAD)
+                       if (bp->b_flags & B_ASYNC)
                                mp->mnt_stat.f_asyncreads++;
                        else
                                mp->mnt_stat.f_syncreads++;
                } else {
-                       if (bp->b_lock.lk_lockholder == LK_KERNTHREAD)
+                       if (bp->b_flags & B_ASYNC)
                                mp->mnt_stat.f_asyncwrites++;
                        else
                                mp->mnt_stat.f_syncwrites++;
index 8d8bb06..b73fba3 100644 (file)
@@ -67,7 +67,7 @@
  * rights to redistribute these changes.
  *
  * $FreeBSD: src/sys/vm/vm_fault.c,v 1.108.2.8 2002/02/26 05:49:27 silby Exp $
- * $DragonFly: src/sys/vm/vm_fault.c,v 1.22 2006/04/23 03:08:04 dillon Exp $
+ * $DragonFly: src/sys/vm/vm_fault.c,v 1.23 2006/05/05 20:15:02 dillon Exp $
  */
 
 /*
@@ -705,7 +705,7 @@ readrest:
                                 * grab the lock if we need to
                                 */
                                (fs.lookup_still_valid ||
-                                lockmgr(&fs.map->lock, LK_EXCLUSIVE|LK_NOWAIT, curthread) == 0)
+                                lockmgr(&fs.map->lock, LK_EXCLUSIVE|LK_NOWAIT) == 0)
                            ) {
                                
                                fs.lookup_still_valid = 1;
index 293fda7..bcdea82 100644 (file)
@@ -62,7 +62,7 @@
  * rights to redistribute these changes.
  *
  * $FreeBSD: src/sys/vm/vm_map.h,v 1.54.2.5 2003/01/13 22:51:17 dillon Exp $
- * $DragonFly: src/sys/vm/vm_map.h,v 1.19 2006/04/23 03:08:04 dillon Exp $
+ * $DragonFly: src/sys/vm/vm_map.h,v 1.20 2006/05/05 20:15:02 dillon Exp $
  */
 
 /*
@@ -272,7 +272,7 @@ struct vmresident {
 #define        vm_map_lock(map) \
        do { \
                printf ("locking map LK_EXCLUSIVE: 0x%x\n", map); \
-               if (lockmgr(&(map)->lock, LK_EXCLUSIVE, curthread) != 0) { \
+               if (lockmgr(&(map)->lock, LK_EXCLUSIVE) != 0) { \
                        panic("vm_map_lock: failed to get lock"); \
                } \
                (map)->timestamp++; \
@@ -280,7 +280,7 @@ struct vmresident {
 #else
 #define        vm_map_lock(map) \
        do { \
-               if (lockmgr(&(map)->lock, LK_EXCLUSIVE, curthread) != 0) { \
+               if (lockmgr(&(map)->lock, LK_EXCLUSIVE) != 0) { \
                        panic("vm_map_lock: failed to get lock"); \
                } \
                (map)->timestamp++; \
@@ -289,7 +289,7 @@ struct vmresident {
 #else
 #define        vm_map_lock(map) \
        do { \
-               lockmgr(&(map)->lock, LK_EXCLUSIVE, curthread); \
+               lockmgr(&(map)->lock, LK_EXCLUSIVE); \
                (map)->timestamp++; \
        } while(0)
 #endif /* DIAGNOSTIC */
@@ -298,50 +298,48 @@ struct vmresident {
 #define        vm_map_unlock(map) \
        do { \
                printf ("locking map LK_RELEASE: 0x%x\n", map); \
-               lockmgr(&(map)->lock, LK_RELEASE, curthread); \
+               lockmgr(&(map)->lock, LK_RELEASE); \
        } while (0)
 #define        vm_map_lock_read(map) \
        do { \
                printf ("locking map LK_SHARED: 0x%x\n", map); \
-               lockmgr(&(map)->lock, LK_SHARED, curthread); \
+               lockmgr(&(map)->lock, LK_SHARED); \
        } while (0)
 #define        vm_map_unlock_read(map) \
        do { \
                printf ("locking map LK_RELEASE: 0x%x\n", map); \
-               lockmgr(&(map)->lock, LK_RELEASE, curthread); \
+               lockmgr(&(map)->lock, LK_RELEASE); \
        } while (0)
 #else
 #define        vm_map_unlock(map) \
-       lockmgr(&(map)->lock, LK_RELEASE, curthread)
+       lockmgr(&(map)->lock, LK_RELEASE)
 #define        vm_map_lock_read(map) \
-       lockmgr(&(map)->lock, LK_SHARED, curthread
+       lockmgr(&(map)->lock, LK_SHARED) 
 #define        vm_map_unlock_read(map) \
-       lockmgr(&(map)->lock, LK_RELEASE, curthread)
+       lockmgr(&(map)->lock, LK_RELEASE)
 #endif
 
 static __inline__ int
-_vm_map_lock_upgrade(vm_map_t map, struct thread *td) {
+vm_map_lock_upgrade(vm_map_t map) {
        int error;
 #if defined(MAP_LOCK_DIAGNOSTIC)
        printf("locking map LK_EXCLUPGRADE: 0x%x\n", map); 
 #endif
-       error = lockmgr(&map->lock, LK_EXCLUPGRADE, td);
+       error = lockmgr(&map->lock, LK_EXCLUPGRADE);
        if (error == 0)
                map->timestamp++;
        return error;
 }
 
-#define vm_map_lock_upgrade(map) _vm_map_lock_upgrade(map, curthread)
-
 #if defined(MAP_LOCK_DIAGNOSTIC)
 #define vm_map_lock_downgrade(map) \
        do { \
                printf ("locking map LK_DOWNGRADE: 0x%x\n", map); \
-               lockmgr(&(map)->lock, LK_DOWNGRADE, curthread); \
+               lockmgr(&(map)->lock, LK_DOWNGRADE); \
        } while (0)
 #else
 #define vm_map_lock_downgrade(map) \
-       lockmgr(&(map)->lock, LK_DOWNGRADE, curthread)
+       lockmgr(&(map)->lock, LK_DOWNGRADE)
 #endif
 
 #endif /* _KERNEL */
index d441af3..0d1004a 100644 (file)
@@ -66,7 +66,7 @@
  * rights to redistribute these changes.
  *
  * $FreeBSD: src/sys/vm/vm_pageout.c,v 1.151.2.15 2002/12/29 18:21:04 dillon Exp $
- * $DragonFly: src/sys/vm/vm_pageout.c,v 1.19 2006/04/23 03:08:04 dillon Exp $
+ * $DragonFly: src/sys/vm/vm_pageout.c,v 1.20 2006/05/05 20:15:02 dillon Exp $
  */
 
 /*
@@ -569,7 +569,7 @@ vm_pageout_map_deactivate_pages(vm_map_t map, vm_pindex_t desired)
        vm_object_t obj, bigobj;
        int nothingwired;
 
-       if (lockmgr(&map->lock, LK_EXCLUSIVE | LK_NOWAIT, curthread)) {
+       if (lockmgr(&map->lock, LK_EXCLUSIVE | LK_NOWAIT)) {
                return;
        }