Remove the now unused interlock argument to the lockmgr() procedure.
authorMatthew Dillon <dillon@dragonflybsd.org>
Sun, 23 Apr 2006 03:08:04 +0000 (03:08 +0000)
committerMatthew Dillon <dillon@dragonflybsd.org>
Sun, 23 Apr 2006 03:08:04 +0000 (03:08 +0000)
This argument has been abused over the years by kernel programmers
attempting to optimize certain locking and data modification sequences,
resulting in a virtually unreadable code in some cases.  The interlock
also made porting between BSDs difficult as each BSD implemented their
interlock differently.  DragonFly has slowly removed use of the interlock
argument and we can now finally be rid of it entirely.

29 files changed:
sys/bus/usb/ehci.c
sys/bus/usb/usb_port.h
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/hpfs/hpfs_subr.h
sys/vfs/hpfs/hpfs_vfsops.c
sys/vfs/nfs/nfsnode.h
sys/vfs/ntfs/ntfs.h
sys/vfs/ntfs/ntfs_subr.c
sys/vfs/nwfs/nwfs_node.c
sys/vfs/smbfs/smbfs_node.c
sys/vm/vm_fault.c
sys/vm/vm_map.h
sys/vm/vm_pageout.c

index 5877ee4..6ec9dfa 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.17 2006/03/02 19:07:54 dillon Exp $
+ * $DragonFly: src/sys/bus/usb/ehci.c,v 1.18 2006/04/23 03:07:58 dillon Exp $
  */
 
 /*
@@ -1397,7 +1397,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, NULL);
+       lockmgr(&sc->sc_doorbell_lock, LK_EXCLUSIVE, NULL);
        crit_enter();
        /* ask for doorbell */
        EOWRITE4(sc, EHCI_USBCMD, EOREAD4(sc, EHCI_USBCMD) | EHCI_CMD_IAAD);
@@ -1408,7 +1408,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, NULL);
+       lockmgr(&sc->sc_doorbell_lock, LK_RELEASE, NULL);
 #ifdef DIAGNOSTIC
        if (error)
                printf("ehci_sync_hc: tsleep() = %d\n", error);
index eaa52c2..e9f4984 100644 (file)
@@ -2,7 +2,7 @@
  * $OpenBSD: usb_port.h,v 1.18 2000/09/06 22:42:10 rahnds Exp $
  * $NetBSD: usb_port.h,v 1.68 2005/07/30 06:14:50 skrll Exp $
  * $FreeBSD: src/sys/dev/usb/usb_port.h,v 1.65 2003/11/09 23:54:21 joe Exp $
- * $DragonFly: src/sys/bus/usb/usb_port.h,v 1.14 2005/11/28 17:13:23 dillon Exp $
+ * $DragonFly: src/sys/bus/usb/usb_port.h,v 1.15 2006/04/23 03:07:58 dillon Exp $
  */
 
 /* Also already merged from NetBSD:
@@ -213,8 +213,6 @@ typedef struct proc *usb_proc_ptr;
 #define usb_kthread_create1    kthread_create
 #define usb_kthread_create     kthread_create_deferred
 
-#define usb_lockmgr(lk, mode, ptr) lockmgr(lk, mode, ptr, curproc)
-
 #define        config_pending_incr()
 #define        config_pending_decr()
 
@@ -398,8 +396,6 @@ typedef struct callout usb_callout_t;
 #define usb_callout(h, t, f, d) callout_reset(&(h), (t), (f), (d))
 #define usb_uncallout(h, f, d)  callout_stop(&(h))
 
-#define usb_lockmgr lockmgr
-
 #define        ETHER_ALIGN             2
 
 #define clalloc(p, s, x) (clist_alloc_cblocks((p), (s), (s)), 0)
index bc6c2e6..d4cc7db 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.18 2006/04/22 23:41:43 dillon Exp $
+ *     $DragonFly: src/sys/dev/agp/agp.c,v 1.19 2006/04/23 03:07:59 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, NULL, curthread);
+       lockmgr(&sc->as_lock, LK_EXCLUSIVE, curthread);
 
        if (mem->am_is_bound) {
                device_printf(dev, "memory already bound\n");
-               lockmgr(&sc->as_lock, LK_RELEASE, NULL, curthread);
+               lockmgr(&sc->as_lock, LK_RELEASE, curthread);
                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, NULL, curthread);
+               lockmgr(&sc->as_lock, LK_RELEASE, curthread);
                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, NULL, curthread);
+                               lockmgr(&sc->as_lock, LK_RELEASE, curthread);
                                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, NULL, curthread);
+       lockmgr(&sc->as_lock, LK_RELEASE, curthread);
 
        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, NULL, curthread);
+       lockmgr(&sc->as_lock, LK_EXCLUSIVE, curthread);
 
        if (!mem->am_is_bound) {
                device_printf(dev, "memory is not bound\n");
-               lockmgr(&sc->as_lock, LK_RELEASE, NULL, curthread);
+               lockmgr(&sc->as_lock, LK_RELEASE, curthread);
                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, NULL, curthread);
+       lockmgr(&sc->as_lock, LK_RELEASE, curthread);
 
        return 0;
 }
index 31e871d..bbca22b 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.13 2005/06/16 16:08:58 dillon Exp $
+ * $DragonFly: src/sys/dev/drm/Attic/drm_os_freebsd.h,v 1.14 2006/04/23 03:08:00 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, NULL, DRM_CURPROC)
-#define DRM_UNLOCK             lockmgr(&dev->dev_lock, LK_RELEASE, NULL, DRM_CURPROC)
+#define DRM_LOCK               lockmgr(&dev->dev_lock, LK_EXCLUSIVE, DRM_CURPROC)
+#define DRM_UNLOCK             lockmgr(&dev->dev_lock, LK_RELEASE, DRM_CURPROC)
 #define DRM_SUSER(td)          suser(td)
 #define DRM_TASKQUEUE_ARGS     void *arg, int pending
 #define DRM_IRQ_ARGS           void *arg
index e9f576b..8df0473 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.13 2006/03/02 19:07:59 dillon Exp $
+ * $DragonFly: src/sys/dev/pccard/pccbb/pccbb.c,v 1.14 2006/04/23 03:08: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, NULL, curthread);
+       lockmgr(&sc->lock, LK_EXCLUSIVE, curthread);
        sc->flags |= CBB_KTHREAD_DONE;
-       lockmgr(&sc->lock, LK_RELEASE, NULL, curthread);
+       lockmgr(&sc->lock, LK_RELEASE, curthread);
        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, NULL, curthread);
+               lockmgr(&sc->lock, LK_EXCLUSIVE, curthread);
                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, NULL, curthread);
+               lockmgr(&sc->lock, LK_RELEASE, curthread);
                /* 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, NULL, curthread);
+       lockmgr(&sc->lock, LK_RELEASE, curthread);
        /* 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, NULL, curthread);
+                       lockmgr(&sc->lock, LK_EXCLUSIVE, curthread);
                        sc->flags &= ~CBB_CARD_OK;
-                       lockmgr(&sc->lock, LK_RELEASE, NULL, curthread);
+                       lockmgr(&sc->lock, LK_RELEASE, curthread);
                        wakeup(sc);
                }
                if (sockevent & CBB_SOCKET_EVENT_CSTS) {
index b56b6c5..0e9ed78 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.8 2006/03/02 19:07:59 dillon Exp $
+ * $DragonFly: src/sys/kern/imgact_resident.c,v 1.9 2006/04/23 03:08:02 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, NULL, td);
+       lockmgr(&exec_list_lock, LK_SHARED, td);
        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, NULL, td);
+       lockmgr(&exec_list_lock, LK_RELEASE, td);
 
        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, NULL, curthread);
+    lockmgr(&exec_list_lock, LK_EXCLUSIVE, curthread);
     TAILQ_INSERT_TAIL(&exec_res_list, vmres, vr_link);
-    lockmgr(&exec_list_lock, LK_RELEASE, NULL, curthread);
+    lockmgr(&exec_list_lock, LK_RELEASE, curthread);
 
     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, NULL, curthread);
+    lockmgr(&exec_list_lock, LK_EXCLUSIVE, curthread);
 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, NULL, curthread);
+    lockmgr(&exec_list_lock, LK_RELEASE, curthread);
     if (error == 0)
        uap->sysmsg_result = count;
     return(error);
index 2e82112..ad1b3c8 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.25 2006/03/02 19:07:59 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_linker.c,v 1.26 2006/04/23 03:08:02 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, NULL, curthread);
+    lockmgr(&lock, LK_SHARED, curthread);
     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, NULL, curthread);
+    lockmgr(&lock, LK_RELEASE, curthread);
 
 out:
     if (koname)
@@ -346,11 +346,11 @@ linker_find_file_by_id(int fileid)
 {
     linker_file_t lf = 0;
 
-    lockmgr(&lock, LK_SHARED, NULL, curthread);
+    lockmgr(&lock, LK_SHARED, curthread);
     for (lf = TAILQ_FIRST(&linker_files); lf; lf = TAILQ_NEXT(lf, link))
        if (lf->id == fileid)
            break;
-    lockmgr(&lock, LK_RELEASE, NULL, curthread);
+    lockmgr(&lock, LK_RELEASE, curthread);
 
     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, NULL, curthread);
+    lockmgr(&lock, LK_EXCLUSIVE, curthread);
     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, NULL, curthread);
+    lockmgr(&lock, LK_RELEASE, curthread);
     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, NULL, curthread);
+    lockmgr(&lock, LK_EXCLUSIVE, curthread);
     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, NULL, curthread);
+               lockmgr(&lock, LK_RELEASE, curthread);
                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, NULL, curthread);
+       lockmgr(&lock, LK_RELEASE, curthread);
        goto out;
     }
 
@@ -471,7 +471,7 @@ linker_file_unload(linker_file_t file)
     }
 
     TAILQ_REMOVE(&linker_files, file, link);
-    lockmgr(&lock, LK_RELEASE, NULL, curthread);
+    lockmgr(&lock, LK_RELEASE, curthread);
 
     for (i = 0; i < file->ndeps; i++)
        linker_file_unload(file->deps[i]);
index 40819ed..8387a04 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.17 2006/04/23 02:41:12 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_lock.c,v 1.18 2006/04/23 03:08:02 dillon Exp $
  */
 
 #include "opt_lint.h"
@@ -167,11 +167,10 @@ acquire(struct lock *lkp, int extflags, int wanted)
  */
 int
 #ifndef        DEBUG_LOCKS
-lockmgr(struct lock *lkp, u_int flags, struct spinlock *interlkp,
-       struct thread *td)
+lockmgr(struct lock *lkp, u_int flags, struct thread *td)
 #else
-debuglockmgr(struct lock *lkp, u_int flags, struct spinlock *interlkp,
-       struct thread *td, const char *name, const char *file, int line)
+debuglockmgr(struct lock *lkp, u_int flags, struct thread *td,
+            const char *name, const char *file, int line)
 #endif
 {
        int error;
@@ -186,8 +185,6 @@ debuglockmgr(struct lock *lkp, u_int flags, struct spinlock *interlkp,
 #ifndef DEBUG_LOCKS
                    if (lockmgr_from_int == 2) {
                            didpanic = 1;
-                           if (flags & LK_INTERLOCK)
-                                   spin_unlock(interlkp);
                            panic(
                                "lockmgr %s from %p: called from interrupt",
                                lkp->lk_wmesg, ((int **)&lkp)[-1]);
@@ -200,8 +197,6 @@ debuglockmgr(struct lock *lkp, u_int flags, struct spinlock *interlkp,
 #else
                    if (lockmgr_from_int == 2) {
                            didpanic = 1;
-                           if (flags & LK_INTERLOCK)
-                                   spin_unlock(interlkp);
                            panic(
                                "lockmgr %s from %s:%d: called from interrupt",
                                lkp->lk_wmesg, file, line);
@@ -215,8 +210,6 @@ debuglockmgr(struct lock *lkp, u_int flags, struct spinlock *interlkp,
        }
 
        spin_lock(&lkp->lk_spinlock);
-       if (flags & LK_INTERLOCK)
-               spin_unlock(interlkp);
 
        extflags = (flags | lkp->lk_flags) & LK_EXTFLG_MASK;
 
index 1afd351..47a72cf 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.19 2006/03/02 19:07:59 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_sysctl.c,v 1.20 2006/04/23 03:08:02 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -1289,23 +1289,23 @@ userland_sysctl(int *name, u_int namelen, void *old, size_t *oldlenp, int inkern
 static void
 sysctl_lock(int flag)
 {
-       lockmgr(&sysctl_lkp, flag, NULL, curthread);
+       lockmgr(&sysctl_lkp, flag, curthread);
 }
 
 static void
 sysctl_unlock(void)
 {
-       lockmgr(&sysctl_lkp, LK_RELEASE, NULL, curthread);
+       lockmgr(&sysctl_lkp, LK_RELEASE, curthread);
 }
 
 static void
 sysctl_ctx_lock(int flag)
 {
-       lockmgr(&sysctl_ctx_lkp, flag, NULL, curthread);
+       lockmgr(&sysctl_ctx_lkp, flag, curthread);
 }
 
 static void
 sysctl_ctx_unlock(void)
 {
-       lockmgr(&sysctl_ctx_lkp, LK_RELEASE, NULL, curthread);
+       lockmgr(&sysctl_ctx_lkp, LK_RELEASE, curthread);
 }
index 3c530c0..a2db0a9 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.32 2006/04/01 20:46:47 dillon Exp $
+ * $DragonFly: src/sys/kern/vfs_default.c,v 1.33 2006/04/23 03:08:02 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -1260,10 +1260,9 @@ vop_stdlock(ap)
        int error;
 
 #ifndef        DEBUG_LOCKS
-       error = lockmgr(&ap->a_vp->v_lock, ap->a_flags, NULL, ap->a_td);
+       error = lockmgr(&ap->a_vp->v_lock, ap->a_flags, ap->a_td);
 #else
-       error = debuglockmgr(&ap->a_vp->v_lock, ap->a_flags,
-                       NULL, ap->a_td,
+       error = debuglockmgr(&ap->a_vp->v_lock, ap->a_flags, ap->a_td,
                        "vop_stdlock", ap->a_vp->filename, ap->a_vp->line);
 #endif
        return(error);
@@ -1279,8 +1278,7 @@ vop_stdunlock(ap)
 {
        int error;
 
-       error = lockmgr(&ap->a_vp->v_lock, ap->a_flags | LK_RELEASE,
-                       NULL, ap->a_td);
+       error = lockmgr(&ap->a_vp->v_lock, ap->a_flags | LK_RELEASE, ap->a_td);
        return(error);
 }
 
index a11c426..1163402 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.13 2006/04/01 20:46:47 dillon Exp $
+ * $DragonFly: src/sys/kern/vfs_lock.c,v 1.14 2006/04/23 03:08:02 dillon Exp $
  */
 
 /*
@@ -235,13 +235,13 @@ vdrop(struct vnode *vp)
 static int
 __vxlock(struct vnode *vp, int flags)
 {
-       return(lockmgr(&vp->v_lock, flags, NULL, curthread));
+       return(lockmgr(&vp->v_lock, flags, curthread));
 }
 
 static void
 __vxunlock(struct vnode *vp)
 {
-       lockmgr(&vp->v_lock, LK_RELEASE, NULL, curthread);
+       lockmgr(&vp->v_lock, LK_RELEASE, curthread);
 }
 
 int
index b063fe9..c10ed7d 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.13 2006/03/29 18:44:50 dillon Exp $
+ * $DragonFly: src/sys/kern/vfs_mount.c,v 1.14 2006/04/23 03:08:02 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, NULL, td))
+       if (lockmgr(&mp->mnt_lock, lkflags, td))
                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, NULL, td);
+       lockmgr(&mp->mnt_lock, LK_RELEASE, td);
 }
 
 /*
index 56281d6..dbb8f52 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.81 2006/04/23 00:54:11 dillon Exp $
+ * $DragonFly: src/sys/kern/vfs_syscalls.c,v 1.82 2006/04/23 03:08:02 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, NULL, td);
+       error = lockmgr(&mp->mnt_lock, lflags, td);
        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, NULL, td);
+               lockmgr(&mp->mnt_lock, LK_RELEASE, td);
                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, NULL, td);
+       lockmgr(&mp->mnt_lock, LK_RELEASE, td);
        if (mp->mnt_kern_flag & MNTK_MWAIT)
                wakeup(mp);
        free(mp, M_MOUNT);
index efa6599..d5974ea 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.10 2006/04/23 02:33:23 dillon Exp $
+ * $DragonFly: src/sys/netproto/ncp/ncp_conn.c,v 1.11 2006/04/23 03:08:04 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, NULL, td);
+       return lockmgr(&listlock, flags | LK_CANRECURSE, td);
 }
 
 void
 ncp_conn_unlocklist(struct thread *td)
 {
-       lockmgr(&listlock, LK_RELEASE, NULL, td);
+       lockmgr(&listlock, LK_RELEASE, td);
 }
 
 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, NULL, td);
+       error = lockmgr(&conn->nc_lock, LK_EXCLUSIVE | LK_CANRECURSE, td);
        if (error == ERESTART)
                return EINTR;
        error = ncp_chkintr(conn, td);
        if (error) {
-               lockmgr(&conn->nc_lock, LK_RELEASE, NULL, td);
+               lockmgr(&conn->nc_lock, LK_RELEASE, td);
                return error;
        }
 
        if (conn->nc_id == 0) {
-               lockmgr(&conn->nc_lock, LK_RELEASE, NULL, td);
+               lockmgr(&conn->nc_lock, LK_RELEASE, td);
                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, NULL, td);
+       lockmgr(&conn->nc_lock, LK_RELEASE, td);
 }
 
 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, NULL, ncp->td);
+               lockmgr(&ncp->nc_lock, LK_EXCLUSIVE, ncp->td);
        }
        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, NULL, td);
+       lockmgr(&lhlock, LK_EXCLUSIVE, td);
        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, NULL, td);
+               lockmgr(&lhlock, LK_RELEASE, td);
                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, NULL, td);
+       lockmgr(&lhlock, LK_RELEASE, td);
        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, NULL, td);
+       lockmgr(&lhlock, LK_EXCLUSIVE, td);
        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, NULL, td);
+       lockmgr(&lhlock, LK_RELEASE, td);
        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, NULL, td);
+       lockmgr(&lhlock, LK_SHARED, td);
        SLIST_FOREACH(refp, &lhlist, nh_next)
                if (refp->nh_td == td && refp->nh_id == connHandle) break;
-       lockmgr(&lhlock, LK_RELEASE, NULL, td);
+       lockmgr(&lhlock, LK_RELEASE, td);
        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, NULL, td);
+       lockmgr(&lhlock, LK_EXCLUSIVE, td);
        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, NULL, td);
+       lockmgr(&lhlock, LK_RELEASE, td);
        return haveone;
 }
 /*
index d1ebff4..7f114f6 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.13 2006/04/23 02:41:14 dillon Exp $
+ * $DragonFly: src/sys/netproto/smb/smb_conn.c,v 1.14 2006/04/23 03:08:04 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, NULL, scred->scr_td);
+       lockmgr(&cp->co_lock, LK_RELEASE, scred->scr_td);
        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, NULL, td);
+               lockmgr(&cp->co_lock, LK_EXCLUSIVE, td);
                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, NULL, scred->scr_td);
+                               lockmgr(&cp->co_lock, LK_EXCLUSIVE, scred->scr_td);
                                smb_co_gone(cp, scred);
                        } else {
                                SMB_CO_UNLOCK(cp);
@@ -345,7 +345,7 @@ smb_co_put(struct smb_connobj *cp, struct smb_cred *scred)
        if (cp->co_usecount > 1) {
                cp->co_usecount--;
                SMB_CO_UNLOCK(cp);
-               lockmgr(&cp->co_lock, LK_RELEASE, NULL, td);
+               lockmgr(&cp->co_lock, LK_RELEASE, td);
                return;
        }
        if (cp->co_usecount <= 0) {
@@ -357,12 +357,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, NULL, td);
-               lockmgr(&cp->co_lock, LK_EXCLUSIVE, NULL, td);
+               lockmgr(&cp->co_lock, LK_RELEASE, td);
+               lockmgr(&cp->co_lock, LK_EXCLUSIVE, td);
                smb_co_gone(cp, scred);
        } else {
                SMB_CO_UNLOCK(cp);
-               lockmgr(&cp->co_lock, LK_RELEASE, NULL, td);
+               lockmgr(&cp->co_lock, LK_RELEASE, td);
                wakeup(&cp->co_lock);
        }
 }
@@ -388,9 +388,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, NULL, td);
+       error = lockmgr(&cp->co_lock, flags, td);
        if (error == 0 && (cp->co_flags & SMBO_GONE)) {
-               lockmgr(&cp->co_lock, LK_RELEASE, NULL, td);
+               lockmgr(&cp->co_lock, LK_RELEASE, td);
                error = EINVAL;
        }
        return (error);
@@ -399,7 +399,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, NULL, td);
+       lockmgr(&cp->co_lock, flags | LK_RELEASE, td);
 }
 
 static void
index 769e538..46bd103 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.15 2006/03/24 18:35:33 dillon Exp $
+ * $DragonFly: src/sys/sys/buf2.h,v 1.16 2006/04/23 03:08:04 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, NULL, curthread));
+       return (lockmgr(&(bp)->b_lock, locktype, curthread));
 }
 /*
  * Get a lock sleeping with specified interruptably and timeout.
@@ -87,8 +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,
-                       NULL, curthread));
+       return (lockmgr(&(bp)->b_lock, locktype | LK_TIMELOCK, curthread));
 }
 /*
  * Release a lock. Only the acquiring process may free the lock unless
@@ -97,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, NULL, curthread);
+       lockmgr(&(bp)->b_lock, LK_RELEASE, curthread);
 }
 
 /*
index 7d41ace..1bf6d9c 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.13 2006/04/23 02:41:15 dillon Exp $
+ * $DragonFly: src/sys/sys/lock.h,v 1.14 2006/04/23 03:08:04 dillon Exp $
  */
 
 #ifndef        _SYS_LOCK_H_
@@ -150,8 +150,7 @@ struct lock {
  *
  * Non-persistent external flags.
  */
-#define LK_INTERLOCK   0x00010000 /* unlock passed simple lock after
-                                     getting lk_spinlock */
+#define LK_UNUSED10000 0x00010000
 #define LK_RETRY       0x00020000 /* vn_lock: retry until locked */
 #define        LK_NOOBJ        0x00040000 /* vget: don't create object */
 #define        LK_THISLAYER    0x00080000 /* vn_lock: lock/unlock only current layer */
@@ -194,16 +193,14 @@ 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 spinlock *, struct thread *p,
+                       struct thread *p,
                        const char *,
                        const char *,
                        int);
-#define lockmgr(lockp, flags, slockp, td) \
-       debuglockmgr((lockp), (flags), (slockp), (td), \
-           "lockmgr", __FILE__, __LINE__)
+#define lockmgr(lockp, flags, td) \
+       debuglockmgr((lockp), (flags), (td), "lockmgr", __FILE__, __LINE__)
 #else
-int    lockmgr (struct lock *, u_int flags,
-                       struct spinlock *, struct thread *td);
+int    lockmgr (struct lock *, u_int flags, struct thread *td);
 #endif
 void   lockmgr_printinfo (struct lock *);
 int    lockstatus (struct lock *, struct thread *);
index d600fe1..bebbb7b 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.33 2006/04/01 20:46:51 dillon Exp $
+ * $DragonFly: src/sys/vfs/coda/Attic/coda_vnops.c,v 1.34 2006/04/23 03:08:04 dillon Exp $
  * 
  */
 
@@ -1709,9 +1709,9 @@ coda_lock(void *v)
     }
 
 #ifndef        DEBUG_LOCKS
-    return (lockmgr(&vp->v_lock, ap->a_flags, NULL, td));
+    return (lockmgr(&vp->v_lock, ap->a_flags, td));
 #else
-    return (debuglockmgr(&vp->v_lock, ap->a_flags, NULL, td,
+    return (debuglockmgr(&vp->v_lock, ap->a_flags, td,
                         "coda_lock", vp->filename, vp->line));
 #endif
 }
@@ -1733,7 +1733,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, NULL, td));
+    return (lockmgr(&vp->v_lock, ap->a_flags | LK_RELEASE, td));
 }
 
 int
index 8336b0e..21122ee 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.15 2006/03/24 18:35:33 dillon Exp $
+ * $DragonFly: src/sys/vfs/hpfs/hpfs.h,v 1.16 2006/04/23 03:08:04 dillon Exp $
  */
 
 /*#define HPFS_DEBUG 10*/
@@ -396,14 +396,14 @@ typedef int (vop_t) (void *);
 #define VOP__UNLOCK(a, b, c)   VOP_UNLOCK((a), 0)
 #define VGET(a, b, c)          vget((a), LK_EXCLUSIVE)
 #define VN_LOCK(a, b, c)       vn_lock((a), LK_EXCLUSIVE)
-#define        LOCKMGR(a, b, c, d)     lockmgr((a), (b), (c))
+#define        LOCKMGR(a, b, d)        lockmgr((a), (b), NULL)
 #else  /* defined(__DragonFly__) */
 #define HASHINIT(a, b, c, d)   hashinit((a), (b), (d))
 #define VOP__LOCK(a, b, c)     VOP_LOCK((a), (b), (c))
 #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, c, d)     lockmgr((a), (b), (c), (d))
+#define        LOCKMGR(a, b, d)        lockmgr((a), (b), (d))
 #endif
 
 struct vfsconf;
index 7b754ec..c947392 100644 (file)
@@ -24,7 +24,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/fs/hpfs/hpfs_subr.h,v 1.1 1999/12/09 19:09:59 semenu Exp $
- * $DragonFly: src/sys/vfs/hpfs/hpfs_subr.h,v 1.2 2003/06/17 04:28:33 dillon Exp $
+ * $DragonFly: src/sys/vfs/hpfs/hpfs_subr.h,v 1.3 2006/04/23 03:08:04 dillon Exp $
  */
 
 #define        hpfs_bmmarkfree(hpmp, bn,bl) hpfs_bmmark(hpmp, bn, bl, 1)
@@ -78,11 +78,6 @@ int          hpfs_breadstruct (struct hpfsmount *, lsn_t, u_int, u_int32_t,
 #define        hpfs_breaddirblk(hpmp, lsn, bpp) \
        hpfs_breadstruct(hpmp, lsn, D_BSIZE, D_MAGIC, bpp)
 
-#if 0
-#define        hpfs_hplock(hp, p)      LOCKMGR(&(hp)->h_intlock, LK_EXCLUSIVE, (p))
-#define        hpfs_hpunlock(hp, p)    LOCKMGR(&(hp)->h_intlock, LK_RELEASE, (p))
-#endif
-
 int            hpfs_hpbmap (struct hpfsnode *, daddr_t, daddr_t *, int *);
 int            hpfs_truncatealblk (struct hpfsmount *, alblk_t *, lsn_t,int *);
 int            hpfs_addextent (struct hpfsmount *, struct hpfsnode *, u_long);
index 5fb57f6..baf8d97 100644 (file)
@@ -24,7 +24,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/fs/hpfs/hpfs_vfsops.c,v 1.3.2.2 2001/12/25 01:44:45 dillon Exp $
- * $DragonFly: src/sys/vfs/hpfs/hpfs_vfsops.c,v 1.32 2006/03/24 18:35:33 dillon Exp $
+ * $DragonFly: src/sys/vfs/hpfs/hpfs_vfsops.c,v 1.33 2006/04/23 03:08:04 dillon Exp $
  */
 
 
@@ -525,11 +525,11 @@ hpfs_vget(struct mount *mp, ino_t ino, struct vnode **vpp)
                        vx_put(vp);
                        return (0);
                }
-       } while(LOCKMGR(&hpfs_hphash_lock,LK_EXCLUSIVE|LK_SLEEPFAIL,NULL,NULL));
+       } while(LOCKMGR(&hpfs_hphash_lock,LK_EXCLUSIVE|LK_SLEEPFAIL,NULL));
 
        hpfs_hphashins(hp);
 
-       LOCKMGR(&hpfs_hphash_lock, LK_RELEASE, NULL, NULL);
+       LOCKMGR(&hpfs_hphash_lock, LK_RELEASE, NULL);
 
        error = bread(hpmp->hpm_devvp, dbtodoff(ino), FNODESIZE, &bp);
        if (error) {
index 8eedf05..750a068 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.15 2006/03/27 16:18:39 dillon Exp $
+ * $DragonFly: src/sys/vfs/nfs/nfsnode.h,v 1.16 2006/04/23 03:08:04 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, NULL, td));
+                      LK_SLEEPFAIL, td));
 }
 
 static __inline
 void
 nfs_rsunlock(struct nfsnode *np, struct thread *td)
 {
-       (void)lockmgr(&np->n_rslock, LK_RELEASE, NULL, td);
+       lockmgr(&np->n_rslock, LK_RELEASE, td);
 }
 
 static __inline
index 5825edf..07b3db3 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.8 2006/03/24 18:35:34 dillon Exp $
+ * $DragonFly: src/sys/vfs/ntfs/ntfs.h,v 1.9 2006/04/23 03:08:04 dillon Exp $
  */
 
 /*#define NTFS_DEBUG 1*/
@@ -321,13 +321,13 @@ typedef int (vop_t) (void *);
 #define VOP__UNLOCK(a, b, c)   VOP_UNLOCK((a), (b))
 #define VGET(a, b, c)          vget((a), (b))
 #define VN_LOCK(a, b, c)       vn_lock((a), (b))
-#define        LOCKMGR(a, b, c)        lockmgr((a), (b), (c))
+#define        LOCKMGR(a, b)           lockmgr((a), (b), NULL)
 #else /* !NetBSD */
 #define HASHINIT(a, b, c, d)   hashinit((a), (b), (d))
 #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, c)        lockmgr((a), (b), (c), curthread)
+#define        LOCKMGR(a, b)           lockmgr((a), (b), curthread)
 
 #endif /* NetBSD */
 
index aa486c3..cc14000 100644 (file)
@@ -26,7 +26,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/ntfs/ntfs_subr.c,v 1.7.2.4 2001/10/12 22:08:49 semenu Exp $
- * $DragonFly: src/sys/vfs/ntfs/ntfs_subr.c,v 1.22 2006/04/23 02:43:19 dillon Exp $
+ * $DragonFly: src/sys/vfs/ntfs/ntfs_subr.c,v 1.23 2006/04/23 03:08:04 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -350,7 +350,7 @@ ntfs_ntget(struct ntnode *ip)
                ip->i_number, ip, ip->i_usecount));
 
        ip->i_usecount++;       /* ZZZ */
-       LOCKMGR(&ip->i_lock, LK_EXCLUSIVE, NULL);
+       LOCKMGR(&ip->i_lock, LK_EXCLUSIVE);
 
        return 0;
 }
@@ -377,7 +377,7 @@ ntfs_ntlookup(struct ntfsmount *ntmp, ino_t ino, struct ntnode **ipp)
                        *ipp = ip;
                        return (0);
                }
-       } while (LOCKMGR(&ntfs_hashlock, LK_EXCLUSIVE | LK_SLEEPFAIL, NULL));
+       } while (LOCKMGR(&ntfs_hashlock, LK_EXCLUSIVE | LK_SLEEPFAIL));
 
        MALLOC(ip, struct ntnode *, sizeof(struct ntnode),
               M_NTFSNTNODE, M_WAITOK);
@@ -400,7 +400,7 @@ ntfs_ntlookup(struct ntfsmount *ntmp, ino_t ino, struct ntnode **ipp)
 
        ntfs_nthashins(ip);
 
-       LOCKMGR(&ntfs_hashlock, LK_RELEASE, NULL);
+       LOCKMGR(&ntfs_hashlock, LK_RELEASE);
 
        *ipp = ip;
 
@@ -437,7 +437,7 @@ ntfs_ntput(struct ntnode *ip)
 
        if (ip->i_usecount > 0) {
                spin_unlock(&ip->i_interlock);
-               LOCKMGR(&ip->i_lock, LK_RELEASE, NULL);
+               LOCKMGR(&ip->i_lock, LK_RELEASE);
                return;
        }
 
@@ -1853,7 +1853,7 @@ ntfs_toupper_use(struct mount *mp, struct ntfsmount *ntmp)
        struct vnode *vp;
 
        /* get exclusive access */
-       LOCKMGR(&ntfs_toupper_lock, LK_EXCLUSIVE, NULL);
+       LOCKMGR(&ntfs_toupper_lock, LK_EXCLUSIVE);
        
        /* only read the translation data from a file if it hasn't been
         * read already */
@@ -1876,7 +1876,7 @@ ntfs_toupper_use(struct mount *mp, struct ntfsmount *ntmp)
 
     out:
        ntfs_toupper_usecount++;
-       LOCKMGR(&ntfs_toupper_lock, LK_RELEASE, NULL);
+       LOCKMGR(&ntfs_toupper_lock, LK_RELEASE);
        return (error);
 }
 
@@ -1888,7 +1888,7 @@ void
 ntfs_toupper_unuse(void)
 {
        /* get exclusive access */
-       LOCKMGR(&ntfs_toupper_lock, LK_EXCLUSIVE, NULL);
+       LOCKMGR(&ntfs_toupper_lock, LK_EXCLUSIVE);
 
        ntfs_toupper_usecount--;
        if (ntfs_toupper_usecount == 0) {
@@ -1903,7 +1903,7 @@ ntfs_toupper_unuse(void)
 #endif
        
        /* release the lock */
-       LOCKMGR(&ntfs_toupper_lock, LK_RELEASE, NULL);
+       LOCKMGR(&ntfs_toupper_lock, LK_RELEASE);
 } 
 
 int
index f9f4da2..965ecb3 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.19 2006/03/02 19:08:00 dillon Exp $
+ * $DragonFly: src/sys/vfs/nwfs/nwfs_node.c,v 1.20 2006/04/23 03:08:04 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, NULL, td);
+       lockmgr(&nwhashlock, LK_EXCLUSIVE, td);
 rescan:
        if (nwfs_hashlookup(nmp, fid, &np) == 0) {
                vp = NWTOV(np);
-               lockmgr(&nwhashlock, LK_RELEASE, NULL, td);
+               lockmgr(&nwhashlock, LK_RELEASE, td);
                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, NULL, td);
+       lockmgr(&nwhashlock, LK_RELEASE, td);
 
        /*
         * 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, NULL, td);
+       lockmgr(&nwhashlock, LK_EXCLUSIVE, td);
        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, NULL, td);
+       lockmgr(&nwhashlock, LK_RELEASE, td);
        return 0;
 }
 
@@ -203,9 +203,9 @@ nwfs_lookupnp(struct nwmount *nmp, ncpfid fid, struct thread *td,
 {
        int error;
 
-       lockmgr(&nwhashlock, LK_EXCLUSIVE, NULL, td);
+       lockmgr(&nwhashlock, LK_EXCLUSIVE, td);
        error = nwfs_hashlookup(nmp, fid, npp);
-       lockmgr(&nwhashlock, LK_RELEASE, NULL, td);
+       lockmgr(&nwhashlock, LK_RELEASE, td);
        return error;
 }
 
@@ -232,9 +232,9 @@ nwfs_reclaim(struct vop_reclaim_args *ap)
                }
        }
        if (np) {
-               lockmgr(&nwhashlock, LK_EXCLUSIVE, NULL, td);
+               lockmgr(&nwhashlock, LK_EXCLUSIVE, td);
                LIST_REMOVE(np, n_hash);
-               lockmgr(&nwhashlock, LK_RELEASE, NULL, td);
+               lockmgr(&nwhashlock, LK_RELEASE, td);
        }
        if (nmp->n_root == np)
                nmp->n_root = NULL;
index 71b1632..942236c 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.17 2005/06/06 15:35:09 dillon Exp $
+ * $DragonFly: src/sys/vfs/smbfs/smbfs_node.c,v 1.18 2006/04/23 03:08:04 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, NULL, td)
-#define        smbfs_hash_unlock(smp, td)      lockmgr(&smp->sm_hashlock, LK_RELEASE, NULL, td)
+#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)
 
 
 MALLOC_DEFINE(M_SMBNODE, "SMBFS node", "SMBFS vnode private part");
index 9ec3c25..8d8bb06 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.21 2006/03/15 07:58:37 dillon Exp $
+ * $DragonFly: src/sys/vm/vm_fault.c,v 1.22 2006/04/23 03:08:04 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, NULL, curthread) == 0)
+                                lockmgr(&fs.map->lock, LK_EXCLUSIVE|LK_NOWAIT, curthread) == 0)
                            ) {
                                
                                fs.lookup_still_valid = 1;
index ea2e510..293fda7 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.18 2006/03/15 07:58:37 dillon Exp $
+ * $DragonFly: src/sys/vm/vm_map.h,v 1.19 2006/04/23 03:08:04 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, NULL, curthread) != 0) { \
+               if (lockmgr(&(map)->lock, LK_EXCLUSIVE, curthread) != 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, NULL, curthread) != 0) { \
+               if (lockmgr(&(map)->lock, LK_EXCLUSIVE, curthread) != 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, NULL, curthread); \
+               lockmgr(&(map)->lock, LK_EXCLUSIVE, curthread); \
                (map)->timestamp++; \
        } while(0)
 #endif /* DIAGNOSTIC */
@@ -298,25 +298,25 @@ struct vmresident {
 #define        vm_map_unlock(map) \
        do { \
                printf ("locking map LK_RELEASE: 0x%x\n", map); \
-               lockmgr(&(map)->lock, LK_RELEASE, NULL, curthread); \
+               lockmgr(&(map)->lock, LK_RELEASE, curthread); \
        } while (0)
 #define        vm_map_lock_read(map) \
        do { \
                printf ("locking map LK_SHARED: 0x%x\n", map); \
-               lockmgr(&(map)->lock, LK_SHARED, NULL, curthread); \
+               lockmgr(&(map)->lock, LK_SHARED, curthread); \
        } while (0)
 #define        vm_map_unlock_read(map) \
        do { \
                printf ("locking map LK_RELEASE: 0x%x\n", map); \
-               lockmgr(&(map)->lock, LK_RELEASE, NULL, curthread); \
+               lockmgr(&(map)->lock, LK_RELEASE, curthread); \
        } while (0)
 #else
 #define        vm_map_unlock(map) \
-       lockmgr(&(map)->lock, LK_RELEASE, NULL, curthread)
+       lockmgr(&(map)->lock, LK_RELEASE, curthread)
 #define        vm_map_lock_read(map) \
-       lockmgr(&(map)->lock, LK_SHARED, NULL, curthread) 
+       lockmgr(&(map)->lock, LK_SHARED, curthread) 
 #define        vm_map_unlock_read(map) \
-       lockmgr(&(map)->lock, LK_RELEASE, NULL, curthread)
+       lockmgr(&(map)->lock, LK_RELEASE, curthread)
 #endif
 
 static __inline__ int
@@ -325,7 +325,7 @@ _vm_map_lock_upgrade(vm_map_t map, struct thread *td) {
 #if defined(MAP_LOCK_DIAGNOSTIC)
        printf("locking map LK_EXCLUPGRADE: 0x%x\n", map); 
 #endif
-       error = lockmgr(&map->lock, LK_EXCLUPGRADE, NULL, td);
+       error = lockmgr(&map->lock, LK_EXCLUPGRADE, td);
        if (error == 0)
                map->timestamp++;
        return error;
@@ -337,11 +337,11 @@ _vm_map_lock_upgrade(vm_map_t map, struct thread *td) {
 #define vm_map_lock_downgrade(map) \
        do { \
                printf ("locking map LK_DOWNGRADE: 0x%x\n", map); \
-               lockmgr(&(map)->lock, LK_DOWNGRADE, NULL, curthread); \
+               lockmgr(&(map)->lock, LK_DOWNGRADE, curthread); \
        } while (0)
 #else
 #define vm_map_lock_downgrade(map) \
-       lockmgr(&(map)->lock, LK_DOWNGRADE, NULL, curthread)
+       lockmgr(&(map)->lock, LK_DOWNGRADE, curthread)
 #endif
 
 #endif /* _KERNEL */
index e0c864b..d441af3 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.18 2006/03/15 07:58:37 dillon Exp $
+ * $DragonFly: src/sys/vm/vm_pageout.c,v 1.19 2006/04/23 03:08:04 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, NULL, curthread)) {
+       if (lockmgr(&map->lock, LK_EXCLUSIVE | LK_NOWAIT, curthread)) {
                return;
        }