kernel - Major mtx lock cleanup
authorMatthew Dillon <dillon@apollo.backplane.com>
Mon, 23 Mar 2015 03:23:52 +0000 (20:23 -0700)
committerMatthew Dillon <dillon@apollo.backplane.com>
Mon, 23 Mar 2015 03:23:52 +0000 (20:23 -0700)
* Integrate the ident into the mtx structure, remove the ident parameter from
  all locking calls.

* Rename some of the functions, shortening them.

* Add a few new functions which hammer2 will use.

17 files changed:
sys/dev/disk/iscsi/initiator/isc_sm.c
sys/dev/disk/iscsi/initiator/iscsivar.h
sys/dev/drm/drm_vm.c
sys/dev/misc/syscons/syscons.c
sys/emulation/ndis/subr_ntoskrnl.c
sys/kern/kern_mutex.c
sys/kern/kern_synch.c
sys/libprop/prop_object_impl.h
sys/net/if.c
sys/netinet6/nd6.c
sys/sys/mutex.h
sys/sys/mutex2.h
sys/vfs/nfs/nfs_socket.c
sys/vfs/nfs/nfs_syscalls.c
sys/vfs/nfs/nfs_vfsops.c
sys/vm/device_pager.c
sys/vm/vm_swap.c

index 62b8dc1..8fe7c7e 100644 (file)
@@ -792,12 +792,12 @@ ism_start(isc_session_t *sp)
      TAILQ_INIT(&sp->wsnd);
      TAILQ_INIT(&sp->hld);
 
-     mtx_init(&sp->rsv_mtx);
-     mtx_init(&sp->rsp_mtx);
-     mtx_init(&sp->snd_mtx);
-     mtx_init(&sp->hld_mtx);
+     mtx_init(&sp->rsv_mtx, "irsv");
+     mtx_init(&sp->rsp_mtx, "irsp");
+     mtx_init(&sp->snd_mtx, "isnd");
+     mtx_init(&sp->hld_mtx, "ihld");
 
-     mtx_init(&sp->io_mtx);
+     mtx_init(&sp->io_mtx, "isio");
 
      isc_add_sysctls(sp);
 
index 12b64b6..d8aad90 100644 (file)
@@ -284,7 +284,7 @@ XPT_DONE(struct isc_softc *isp, union ccb *ccb)
 
 #endif /* _CAM_CAM_XPT_SIM_H */
 
-#define iscsi_lock_ex(mtx)     mtx_lock_ex_quick(mtx, __func__)
+#define iscsi_lock_ex(mtx)     mtx_lock_ex_quick(mtx)
 #define iscsi_unlock_ex(mtx)   mtx_unlock(mtx)
 #define issleep(id, mtx, flags, wmesg, to)     \
                                mtxsleep(id, mtx, flags, wmesg, to)
index 2f01e64..6b7b8c0 100644 (file)
@@ -149,7 +149,7 @@ static struct vm_phys_fictitious_seg {
         vm_paddr_t      end;
         vm_page_t       first_page;
 } vm_phys_fictitious_segs[VM_PHYS_FICTITIOUS_NSEGS];
-static struct mtx vm_phys_fictitious_reg_mtx = MTX_INITIALIZER;
+static struct mtx vm_phys_fictitious_reg_mtx = MTX_INITIALIZER("vmphy");
 
 vm_page_t
 vm_phys_fictitious_to_vm_page(vm_paddr_t pa)
index fa4c668..feba21e 100644 (file)
@@ -146,7 +146,7 @@ static      cdev_t  cctl_dev;
 static timeout_t blink_screen_callout;
 #endif
 static  void   sc_blink_screen(scr_stat *scp);
-static struct mtx      syscons_mtx = MTX_INITIALIZER;
+static struct mtx      syscons_mtx = MTX_INITIALIZER("syscons");
 
 /* prototypes */
 static int scvidprobe(int unit, int flags, int cons);
index 0048f10..d92469a 100644 (file)
@@ -293,14 +293,14 @@ ntoskrnl_libinit(void)
        int                     i;
 
        lockinit(&ntoskrnl_dispatchlock, MTX_NDIS_LOCK, 0, LK_CANRECURSE);
-       mtx_init(&ntoskrnl_interlock);
+       mtx_init(&ntoskrnl_interlock, "ndis1");
        KeInitializeSpinLock(&ntoskrnl_cancellock);
        KeInitializeSpinLock(&ntoskrnl_intlock);
        TAILQ_INIT(&ntoskrnl_reflist);
 
        InitializeListHead(&ntoskrnl_calllist);
        InitializeListHead(&ntoskrnl_intlist);
-       mtx_init(&ntoskrnl_calllock);
+       mtx_init(&ntoskrnl_calllock, "ndis2");
 
        kq_queues = ExAllocatePoolWithTag(NonPagedPool,
 #ifdef NTOSKRNL_MULTIPLE_DPCS
index 2841086..3c7adfa 100644 (file)
@@ -91,8 +91,7 @@ static void mtx_delete_link(mtx_t *mtx, mtx_link_t *link);
  * A tsleep() error can only be returned if PCATCH is specified in the flags.
  */
 static __inline int
-__mtx_lock_ex(mtx_t *mtx, mtx_link_t *link,
-             const char *ident, int flags, int to)
+__mtx_lock_ex(mtx_t *mtx, mtx_link_t *link, int flags, int to)
 {
        thread_t td;
        u_int   lock;
@@ -202,35 +201,34 @@ __mtx_lock_ex(mtx_t *mtx, mtx_link_t *link,
                /*
                 * Wait for lock
                 */
-               error = mtx_wait_link(mtx, link, ident, flags, to);
+               error = mtx_wait_link(mtx, link, flags, to);
                break;
        }
        return (error);
 }
 
 int
-_mtx_lock_ex_link(mtx_t *mtx, mtx_link_t *link,
-                 const char *ident, int flags, int to)
+_mtx_lock_ex_link(mtx_t *mtx, mtx_link_t *link, int flags, int to)
 {
-       return(__mtx_lock_ex(mtx, link, ident, flags, to));
+       return(__mtx_lock_ex(mtx, link, flags, to));
 }
 
 int
-_mtx_lock_ex(mtx_t *mtx, const char *ident, int flags, int to)
+_mtx_lock_ex(mtx_t *mtx, int flags, int to)
 {
        mtx_link_t link;
 
        mtx_link_init(&link);
-       return(__mtx_lock_ex(mtx, &link, ident, flags, to));
+       return(__mtx_lock_ex(mtx, &link, flags, to));
 }
 
 int
-_mtx_lock_ex_quick(mtx_t *mtx, const char *ident)
+_mtx_lock_ex_quick(mtx_t *mtx)
 {
        mtx_link_t link;
 
        mtx_link_init(&link);
-       return(__mtx_lock_ex(mtx, &link, ident, 0, 0));
+       return(__mtx_lock_ex(mtx, &link, 0, 0));
 }
 
 /*
@@ -243,8 +241,7 @@ _mtx_lock_ex_quick(mtx_t *mtx, const char *ident)
  *      do not have to chain the wakeup().
  */
 static __inline int
-__mtx_lock_sh(mtx_t *mtx, mtx_link_t *link,
-             const char *ident, int flags, int to)
+__mtx_lock_sh(mtx_t *mtx, mtx_link_t *link, int flags, int to)
 {
        thread_t td;
        u_int   lock;
@@ -353,35 +350,34 @@ __mtx_lock_sh(mtx_t *mtx, mtx_link_t *link,
                /*
                 * Wait for lock
                 */
-               error = mtx_wait_link(mtx, link, ident, flags, to);
+               error = mtx_wait_link(mtx, link, flags, to);
                break;
        }
        return (error);
 }
 
 int
-_mtx_lock_sh_link(mtx_t *mtx, mtx_link_t *link,
-                 const char *ident, int flags, int to)
+_mtx_lock_sh_link(mtx_t *mtx, mtx_link_t *link, int flags, int to)
 {
-       return(__mtx_lock_sh(mtx, link, ident, flags, to));
+       return(__mtx_lock_sh(mtx, link, flags, to));
 }
 
 int
-_mtx_lock_sh(mtx_t *mtx, const char *ident, int flags, int to)
+_mtx_lock_sh(mtx_t *mtx, int flags, int to)
 {
        mtx_link_t link;
 
        mtx_link_init(&link);
-       return(__mtx_lock_sh(mtx, &link, ident, flags, to));
+       return(__mtx_lock_sh(mtx, &link, flags, to));
 }
 
 int
-_mtx_lock_sh_quick(mtx_t *mtx, const char *ident)
+_mtx_lock_sh_quick(mtx_t *mtx)
 {
        mtx_link_t link;
 
        mtx_link_init(&link);
-       return(__mtx_lock_sh(mtx, &link, ident, 0, 0));
+       return(__mtx_lock_sh(mtx, &link, 0, 0));
 }
 
 /*
@@ -948,8 +944,7 @@ mtx_delete_link(mtx_t *mtx, mtx_link_t *link)
  * occurred.
  */
 int
-mtx_wait_link(mtx_t *mtx, mtx_link_t *link,
-             const char *ident, int flags, int to)
+mtx_wait_link(mtx_t *mtx, mtx_link_t *link, int flags, int to)
 {
        int error;
 
@@ -968,12 +963,12 @@ mtx_wait_link(mtx_t *mtx, mtx_link_t *link,
                        else
                                mycpu->gd_cnt.v_lock_name[0] = 'X';
                        strncpy(mycpu->gd_cnt.v_lock_name + 1,
-                               ident,
+                               mtx->mtx_ident,
                                sizeof(mycpu->gd_cnt.v_lock_name) - 2);
                        ++mycpu->gd_cnt.v_lock_colls;
 
                        error = tsleep(link, flags | PINTERLOCKED,
-                                      ident, to);
+                                      mtx->mtx_ident, to);
                        if (error)
                                break;
                }
index 5e87337..f863948 100644 (file)
@@ -734,7 +734,7 @@ mtxsleep(const volatile void *ident, struct mtx *mtx, int flags,
        _tsleep_interlock(gd, ident, flags);
        mtx_unlock(mtx);
        error = tsleep(ident, flags | PINTERLOCKED, wmesg, timo);
-       mtx_lock_ex_quick(mtx, wmesg);
+       mtx_lock_ex_quick(mtx);
 
        return (error);
 }
index ec37bdf..f63e748 100644 (file)
@@ -295,7 +295,7 @@ SYSINIT(pp##_init, SI_SUB_PRE_DRIVERS, SI_ORDER_ANY, pp##_init, NULL)
 #define        _PROP_MUTEX_UNLOCK(x)           lockmgr(&(x), LK_RELEASE)
 
 #define        _PROP_RWLOCK_DECL(x)            struct mtx x;
-#define        _PROP_RWLOCK_INIT(x)            mtx_init(&(x))
+#define        _PROP_RWLOCK_INIT(x)            mtx_init(&(x), "prop")
 #define        _PROP_RWLOCK_RDLOCK(x)          mtx_lock(&(x))
 #define        _PROP_RWLOCK_WRLOCK(x)          mtx_lock(&(x))
 #define        _PROP_RWLOCK_UNLOCK(x)          mtx_unlock(&(x))
index 675cae2..f9169f7 100644 (file)
@@ -168,7 +168,7 @@ static struct netmsg_base   if_slowtimo_netmsg;
 int                    if_index = 0;
 struct ifnet           **ifindex2ifnet = NULL;
 static struct thread   ifnet_threads[MAXCPU];
-static struct mtx      ifnet_mtx = MTX_INITIALIZER;
+static struct mtx      ifnet_mtx = MTX_INITIALIZER("ifnet");
 
 static struct ifsubq_stage_head        ifsubq_stage_heads[MAXCPU];
 
index 42fd51c..5951cb6 100644 (file)
@@ -108,7 +108,7 @@ static int nd6_inuse, nd6_allocated;
 struct llinfo_nd6 llinfo_nd6 = {&llinfo_nd6, &llinfo_nd6};
 struct nd_drhead nd_defrouter;
 struct nd_prhead nd_prefix = { 0 };
-struct mtx nd6_mtx = MTX_INITIALIZER;
+struct mtx nd6_mtx = MTX_INITIALIZER("nd6");
 
 int nd6_recalc_reachtm_interval = ND6_RECALC_REACHTM_INTERVAL;
 static struct sockaddr_in6 all1_sa;
index 3f5b32b..51b7ea2 100644 (file)
@@ -69,12 +69,15 @@ struct mtx {
        struct thread   *mtx_owner;
        mtx_link_t      *mtx_exlink;
        mtx_link_t      *mtx_shlink;
+       const char      *mtx_ident;
 } __cachealign;
 
-typedef struct mtx mtx_t;
+typedef struct mtx     mtx_t;
+typedef u_int          mtx_state_t;
 
-#define MTX_INITIALIZER        { .mtx_lock = 0, .mtx_owner = NULL, \
-                         .mtx_exlink = NULL, .mtx_shlink = NULL }
+#define MTX_INITIALIZER(ident) { .mtx_lock = 0, .mtx_owner = NULL, \
+                                 .mtx_exlink = NULL, .mtx_shlink = NULL, \
+                                 .mtx_ident = ident }
 
 #define MTX_EXCLUSIVE  0x80000000
 #define MTX_SHWANTED   0x40000000
@@ -101,14 +104,12 @@ typedef struct mtx mtx_t;
  */
 #ifdef _KERNEL
 
-int    _mtx_lock_ex_link(mtx_t *mtx, mtx_link_t *link,
-                               const char *ident, int flags, int to);
-int    _mtx_lock_ex(mtx_t *mtx, const char *ident, int flags, int to);
-int    _mtx_lock_sh_link(mtx_t *mtx, mtx_link_t *link,
-                               const char *ident, int flags, int to);
-int    _mtx_lock_sh(mtx_t *mtx, const char *ident, int flags, int to);
-int    _mtx_lock_ex_quick(mtx_t *mtx, const char *ident);
-int    _mtx_lock_sh_quick(mtx_t *mtx, const char *ident);
+int    _mtx_lock_ex_link(mtx_t *mtx, mtx_link_t *link, int flags, int to);
+int    _mtx_lock_ex(mtx_t *mtx, int flags, int to);
+int    _mtx_lock_sh_link(mtx_t *mtx, mtx_link_t *link, int flags, int to);
+int    _mtx_lock_sh(mtx_t *mtx, int flags, int to);
+int    _mtx_lock_ex_quick(mtx_t *mtx);
+int    _mtx_lock_sh_quick(mtx_t *mtx);
 void   _mtx_spinlock(mtx_t *mtx);
 int    _mtx_spinlock_try(mtx_t *mtx);
 int    _mtx_lock_ex_try(mtx_t *mtx);
@@ -117,8 +118,7 @@ void        _mtx_downgrade(mtx_t *mtx);
 int    _mtx_upgrade_try(mtx_t *mtx);
 void   _mtx_unlock(mtx_t *mtx);
 void   mtx_abort_link(mtx_t *mtx, mtx_link_t *link);
-int    mtx_wait_link(mtx_t *mtx, mtx_link_t *link,
-                               const char *ident, int flags, int to);
+int    mtx_wait_link(mtx_t *mtx, mtx_link_t *link, int flags, int to);
 
 #endif
 
index 016b464..8b11627 100644 (file)
  * Initialize a new mutex, placing it in an unlocked state with no refs.
  */
 static __inline void
-mtx_init(mtx_t *mtx)
+mtx_init(mtx_t *mtx, const char *ident)
 {
        mtx->mtx_lock = 0;
        mtx->mtx_owner = NULL;
        mtx->mtx_exlink = NULL;
        mtx->mtx_shlink = NULL;
+       mtx->mtx_ident = ident;
 }
 
 /*
@@ -106,11 +107,10 @@ mtx_uninit(mtx_t *mtx)
  * is valid.
  */
 static __inline int
-mtx_lock_ex_link(mtx_t *mtx, mtx_link_t *link,
-                 const char *ident, int flags, int to)
+mtx_lock_ex_link(mtx_t *mtx, mtx_link_t *link, int flags, int to)
 {
        if (atomic_cmpset_int(&mtx->mtx_lock, 0, MTX_EXCLUSIVE | 1) == 0)
-               return(_mtx_lock_ex_link(mtx, link, ident, flags, to));
+               return(_mtx_lock_ex_link(mtx, link, flags, to));
        mtx->mtx_owner = curthread;
        link->state = MTX_LINK_ACQUIRED;
 
@@ -125,7 +125,7 @@ static __inline void
 mtx_lock(mtx_t *mtx)
 {
        if (atomic_cmpset_int(&mtx->mtx_lock, 0, MTX_EXCLUSIVE | 1) == 0) {
-               _mtx_lock_ex(mtx, "mtxex", 0, 0);
+               _mtx_lock_ex(mtx, 0, 0);
                return;
        }
        mtx->mtx_owner = curthread;
@@ -138,29 +138,28 @@ mtx_lock(mtx_t *mtx)
  * An error can only be returned if PCATCH is specified in the flags.
  */
 static __inline int
-mtx_lock_ex(mtx_t *mtx, const char *ident, int flags, int to)
+mtx_lock_ex(mtx_t *mtx, int flags, int to)
 {
        if (atomic_cmpset_int(&mtx->mtx_lock, 0, MTX_EXCLUSIVE | 1) == 0)
-               return(_mtx_lock_ex(mtx, ident, flags, to));
+               return(_mtx_lock_ex(mtx, flags, to));
        mtx->mtx_owner = curthread;
        return(0);
 }
 
 static __inline int
-mtx_lock_ex_quick(mtx_t *mtx, const char *ident)
+mtx_lock_ex_quick(mtx_t *mtx)
 {
        if (atomic_cmpset_int(&mtx->mtx_lock, 0, MTX_EXCLUSIVE | 1) == 0)
-               return(_mtx_lock_ex_quick(mtx, ident));
+               return(_mtx_lock_ex_quick(mtx));
        mtx->mtx_owner = curthread;
        return(0);
 }
 
 static __inline int
-mtx_lock_sh_link(mtx_t *mtx, mtx_link_t *link,
-                const char *ident, int flags, int to)
+mtx_lock_sh_link(mtx_t *mtx, mtx_link_t *link, int flags, int to)
 {
        if (atomic_cmpset_int(&mtx->mtx_lock, 0, 1) == 0)
-               return(_mtx_lock_sh_link(mtx, link, ident, flags, to));
+               return(_mtx_lock_sh_link(mtx, link, flags, to));
        link->state = MTX_LINK_ACQUIRED;
        return(0);
 }
@@ -172,18 +171,18 @@ mtx_lock_sh_link(mtx_t *mtx, mtx_link_t *link,
  * An error can only be returned if PCATCH is specified in the flags.
  */
 static __inline int
-mtx_lock_sh(mtx_t *mtx, const char *ident, int flags, int to)
+mtx_lock_sh(mtx_t *mtx, int flags, int to)
 {
        if (atomic_cmpset_int(&mtx->mtx_lock, 0, 1) == 0)
-               return(_mtx_lock_sh(mtx, ident, flags, to));
+               return(_mtx_lock_sh(mtx, flags, to));
        return(0);
 }
 
 static __inline int
-mtx_lock_sh_quick(mtx_t *mtx, const char *ident)
+mtx_lock_sh_quick(mtx_t *mtx)
 {
        if (atomic_cmpset_int(&mtx->mtx_lock, 0, 1) == 0)
-               return(_mtx_lock_sh_quick(mtx, ident));
+               return(_mtx_lock_sh_quick(mtx));
        return(0);
 }
 
@@ -276,7 +275,7 @@ static __inline void
 mtx_downgrade(mtx_t *mtx)
 {
        mtx->mtx_owner = NULL;
-       if (atomic_cmpset_int(&mtx->mtx_lock, MTX_EXCLUSIVE | 1, 0) == 0)
+       if (atomic_cmpset_int(&mtx->mtx_lock, MTX_EXCLUSIVE | 1, 1) == 0)
                _mtx_downgrade(mtx);
 }
 
@@ -375,9 +374,11 @@ mtx_islocked(mtx_t *mtx)
 
 /*
  * Return TRUE (non-zero) if the mutex is locked exclusively by anyone,
- * including the owner.
+ * including the owner.  Returns FALSE (0) if the mutex is unlocked or
+ * if it is locked shared by one or more entities.
  *
- * The mutex may in an unlocked or shared lock state.
+ * A caller wishing to check whether a lock is owned exclusively by it
+ * should use mtx_owned().
  */
 static __inline int
 mtx_islocked_ex(mtx_t *mtx)
@@ -432,10 +433,42 @@ mtx_notowned(mtx_t *mtx)
  * NOTE: If the mutex is held exclusively by someone other then the
  *      caller the lock count for the other owner is still returned.
  */
-static __inline int
+static __inline
+int
 mtx_lockrefs(mtx_t *mtx)
 {
        return(mtx->mtx_lock & MTX_MASK);
 }
 
+/*
+ * Lock must held and will be released on return.  Returns state
+ * which can be passed to mtx_lock_temp_restore() to return the
+ * lock to its previous state.
+ */
+static __inline
+mtx_state_t
+mtx_lock_temp_release(mtx_t *mtx)
+{
+       mtx_state_t state;
+
+       state = (mtx->mtx_lock & MTX_EXCLUSIVE);
+       mtx_unlock(mtx);
+
+       return state;
+}
+
+/*
+ * Restore the previous state of a lock released with
+ * mtx_lock_temp_release() or mtx_lock_upgrade().
+ */
+static __inline
+void
+mtx_lock_temp_restore(mtx_t *mtx, mtx_state_t state)
+{
+       if (state & MTX_EXCLUSIVE)
+               mtx_lock_ex_quick(mtx);
+       else
+               mtx_lock_sh_quick(mtx);
+}
+
 #endif
index fe22210..4ae4dee 100644 (file)
@@ -2112,7 +2112,7 @@ nfs_sndlock(struct nfsmount *nmp, struct nfsreq *rep)
                        error = EINTR;
                        break;
                }
-               error = mtx_lock_ex(mtx, "nfsndlck", slpflag, slptimeo);
+               error = mtx_lock_ex(mtx, slpflag, slptimeo);
                if (error == 0)
                        break;
                if (slpflag == PCATCH) {
@@ -2185,10 +2185,9 @@ nfs_rcvlock(struct nfsmount *nmp, struct nfsreq *rep)
                 */
                if (rep) {
                        error = mtx_lock_ex_link(mtx, &rep->r_link,
-                                                "nfsrcvlk",
                                                 slpflag, slptimeo);
                } else {
-                       error = mtx_lock_ex(mtx, "nfsrcvlk", slpflag, slptimeo);
+                       error = mtx_lock_ex(mtx, slpflag, slptimeo);
                }
                if (error == 0)
                        break;
index 1af18f8..faf6a11 100644 (file)
@@ -409,7 +409,7 @@ nfssvc_addsock(struct file *fp, struct sockaddr *mynam, struct thread *td)
        atomic_clear_int(&so->so_snd.ssb_flags, SSB_AUTOSIZE);
 
        slp = kmalloc(sizeof (struct nfssvc_sock), M_NFSSVC, M_WAITOK | M_ZERO);
-       mtx_init(&slp->ns_solock);
+       mtx_init(&slp->ns_solock, "nfsvc");
        STAILQ_INIT(&slp->ns_rec);
        TAILQ_INIT(&slp->ns_uidlruhead);
        lwkt_token_init(&slp->ns_token, "nfssrv_token");
@@ -923,7 +923,7 @@ nfs_slplock(struct nfssvc_sock *slp, int wait)
        mtx_t *mtx = &slp->ns_solock;
 
        if (wait) {
-               mtx_lock_ex(mtx, "nfsslplck", 0, 0);
+               mtx_lock_ex(mtx, 0, 0);
                return(1);
        } else if (mtx_lock_ex_try(mtx) == 0) {
                return(1);
index 3d0879c..58d6bda 100644 (file)
@@ -1033,8 +1033,8 @@ mountnfs(struct nfs_args *argp, struct mount *mp, struct sockaddr *nam,
        } else {
                nmp = objcache_get(nfsmount_objcache, M_WAITOK);
                bzero((caddr_t)nmp, sizeof (struct nfsmount));
-               mtx_init(&nmp->nm_rxlock);
-               mtx_init(&nmp->nm_txlock);
+               mtx_init(&nmp->nm_rxlock, "nfsrx");
+               mtx_init(&nmp->nm_txlock, "nfstx");
                TAILQ_INIT(&nmp->nm_uidlruhead);
                TAILQ_INIT(&nmp->nm_bioq);
                TAILQ_INIT(&nmp->nm_reqq);
index 7328279..67c4dea 100644 (file)
@@ -80,7 +80,7 @@ struct pagerops devicepagerops = {
 static struct pagerlst dev_pager_object_list =
                TAILQ_HEAD_INITIALIZER(dev_pager_object_list);
 /* protect list manipulation */
-static struct mtx dev_pager_mtx = MTX_INITIALIZER;
+static struct mtx dev_pager_mtx = MTX_INITIALIZER("devpgr");
 
 static int old_dev_pager_ctor(void *handle, vm_ooffset_t size, vm_prot_t prot,
     vm_ooffset_t foff, struct ucred *cred, u_short *pg_color);
index 047ade7..a6c2aac 100644 (file)
@@ -72,7 +72,7 @@
 static struct swdevt should_be_malloced[NSWAPDEV];
 struct swdevt *swdevt = should_be_malloced;    /* exported to pstat/systat */
 static swblk_t nswap;          /* first block after the interleaved devs */
-static struct mtx swap_mtx = MTX_INITIALIZER;
+static struct mtx swap_mtx = MTX_INITIALIZER("swpmtx");
 int nswdev = NSWAPDEV;                         /* exported to pstat/systat */
 int vm_swap_size;
 int vm_swap_max;