Allow toggling lock counting at runtime

The implementation is still hidden behind ERTS_ENABLE_LOCK_COUNT, and
all categories are still enabled by default, but the actual counting can be
toggled at will.

OTP-13170

62 files changed, 1139 insertions, 899 deletions

diff --git a/erts/emulator/beam/atom.c b/erts/emulator/beam/atom.c
index 2055c29190..c2d78aaccb 100644
--- a/erts/emulator/beam/atom.c
+++ b/erts/emulator/beam/atom.c
@@ -442,7 +442,8 @@ init_atom_table(void)
     erts_smp_atomic_init_nob(&atom_put_ops, 0);
 #endif
 
-    erts_smp_rwmtx_init_opt(&atom_table_lock, &rwmtx_opt, "atom_tab");
+    erts_smp_rwmtx_init_opt(&atom_table_lock, &rwmtx_opt, "atom_tab", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
 
     f.hash = (H_FUN) atom_hash;
     f.cmp  = (HCMP_FUN) atom_cmp;
diff --git a/erts/emulator/beam/beam_bif_load.c b/erts/emulator/beam/beam_bif_load.c
index 5aceae8ffe..ffa33d6303 100644
--- a/erts/emulator/beam/beam_bif_load.c
+++ b/erts/emulator/beam/beam_bif_load.c
@@ -97,7 +97,8 @@ init_purge_state(void)
 {
     purge_state.module = THE_NON_VALUE;
 
-    erts_smp_mtx_init(&purge_state.mtx, "purge_state");
+    erts_smp_mtx_init(&purge_state.mtx, "purge_state", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
 
     purge_state.pending_purge_lambda =
 	erts_export_put(am_erts_code_purger, am_pending_purge_lambda, 3);
@@ -118,7 +119,9 @@ init_purge_state(void)
 void
 erts_beam_bif_load_init(void)
 {
-    erts_smp_mtx_init(&release_literal_areas.mtx, "release_literal_areas");
+    erts_smp_mtx_init(&release_literal_areas.mtx, "release_literal_areas", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
+
     release_literal_areas.first = NULL;
     release_literal_areas.last = NULL;
     erts_smp_atomic_init_nob(&erts_copy_literal_area__,
diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index b9453c1d9a..950639f7ae 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -165,7 +165,8 @@ erts_bp_init(void) {
     erts_smp_atomic32_init_nob(&erts_active_bp_index, 0);
     erts_smp_atomic32_init_nob(&erts_staging_bp_index, 1);
 #ifdef ERTS_DIRTY_SCHEDULERS
-    erts_smp_mtx_init(&erts_dirty_bp_ix_mtx, "dirty_break_point_index");
+    erts_smp_mtx_init(&erts_dirty_bp_ix_mtx, "dirty_break_point_index", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_DEBUG);
 #endif
 }
 
diff --git a/erts/emulator/beam/bif.c b/erts/emulator/beam/bif.c
index 7134d2da56..b9384b28a1 100644
--- a/erts/emulator/beam/bif.c
+++ b/erts/emulator/beam/bif.c
@@ -62,9 +62,6 @@ static erts_smp_atomic32_t msacc;
 static Export *await_sched_wall_time_mod_trap;
 static erts_smp_atomic32_t sched_wall_time;
 
-static erts_smp_mtx_t ports_snapshot_mtx;
-erts_smp_atomic_t erts_dead_ports_ptr; /* To store dying ports during snapshot */
-
 #define DECL_AM(S) Eterm AM_ ## S = am_atom_put(#S, sizeof(#S) - 1)
 
 /*
@@ -5140,9 +5137,6 @@ void erts_init_trap_export(Export* ep, Eterm m, Eterm f, Uint a,
 
 void erts_init_bif(void)
 {
-    erts_smp_mtx_init(&ports_snapshot_mtx, "ports_snapshot");
-    erts_smp_atomic_init_nob(&erts_dead_ports_ptr, (erts_aint_t) NULL);
-
     /*
      * bif_return_trap/2 is a hidden BIF that bifs that need to
      * yield the calling process traps to.
diff --git a/erts/emulator/beam/code_ix.c b/erts/emulator/beam/code_ix.c
index ec6267711b..8a3d1b20b4 100644
--- a/erts/emulator/beam/code_ix.c
+++ b/erts/emulator/beam/code_ix.c
@@ -57,7 +57,8 @@ void erts_code_ix_init(void)
      */
     erts_smp_atomic32_init_nob(&the_active_code_index, 0);
     erts_smp_atomic32_init_nob(&the_staging_code_index, 0);
-    erts_smp_mtx_init(&code_write_permission_mtx, "code_write_permission");
+    erts_smp_mtx_init(&code_write_permission_mtx, "code_write_permission", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
 #ifdef ERTS_ENABLE_LOCK_CHECK
     erts_tsd_key_create(&has_code_write_permission,
 			"erts_has_code_write_permission");
diff --git a/erts/emulator/beam/dist.c b/erts/emulator/beam/dist.c
index 982f1066df..09fdb897f5 100644
--- a/erts/emulator/beam/dist.c
+++ b/erts/emulator/beam/dist.c
@@ -3223,7 +3223,8 @@ static ErtsNodesMonitor *nodes_monitors_end;
 static void
 init_nodes_monitors(void)
 {
-    erts_smp_mtx_init(&nodes_monitors_mtx, "nodes_monitors");
+    erts_smp_mtx_init(&nodes_monitors_mtx, "nodes_monitors", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_DISTRIBUTION);
     nodes_monitors = NULL;
     nodes_monitors_end = NULL;
 }
diff --git a/erts/emulator/beam/erl_alloc.c b/erts/emulator/beam/erl_alloc.c
index 169e1e423d..c7ab444c96 100644
--- a/erts/emulator/beam/erl_alloc.c
+++ b/erts/emulator/beam/erl_alloc.c
@@ -3819,7 +3819,8 @@ hdbg_init(void)
     hdbg_mblks[ERL_ALC_HDBG_MAX_MBLK-1].next = NULL;
     free_hdbg_mblks = &hdbg_mblks[0];
     used_hdbg_mblks = NULL;
-    erts_mtx_init(&hdbg_mblk_mtx, "erts_alloc_hard_debug");
+    erts_mtx_init(&hdbg_mblk_mtx, "erts_alloc_hard_debug", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_ALLOCATOR);
 }
 
 static void *check_memory_fence(void *ptr,
diff --git a/erts/emulator/beam/erl_alloc.h b/erts/emulator/beam/erl_alloc.h
index 758d529f87..d743c62a02 100644
--- a/erts/emulator/beam/erl_alloc.h
+++ b/erts/emulator/beam/erl_alloc.h
@@ -344,7 +344,8 @@ ERTS_QUICK_ALLOC_IMPL(NAME, TYPE, PASZ, ALCT,				\
 #define ERTS_SMP_QUALLOC_IMPL(NAME, TYPE, PASZ, ALCT)			\
 static erts_smp_spinlock_t NAME##_lck;					\
 ERTS_QUICK_ALLOC_IMPL(NAME, TYPE, PASZ, ALCT,				\
-		      erts_smp_spinlock_init(&NAME##_lck, #NAME "_alloc_lock"),\
+		      erts_smp_spinlock_init(&NAME##_lck, #NAME "_alloc_lock", NIL, \
+		          ERTS_LOCK_FLAGS_CATEGORY_ALLOCATOR),\
 		      erts_smp_spin_lock(&NAME##_lck),			\
 		      erts_smp_spin_unlock(&NAME##_lck))
 
@@ -358,7 +359,8 @@ ERTS_SMP_QUALLOC_IMPL(NAME, TYPE, PASZ, ALCT)
 #define ERTS_TS_QUALLOC_IMPL(NAME, TYPE, PASZ, ALCT)			\
 static erts_mtx_t NAME##_lck;						\
 ERTS_QUICK_ALLOC_IMPL(NAME, TYPE, PASZ, ALCT,				\
-		      erts_mtx_init(NAME##_lck, #NAME "_alloc_lock"),	\
+		      erts_mtx_init(NAME##_lck, #NAME "_alloc_lock", NIL, \
+		          ERTS_LOCK_FLAGS_CATEGORY_ALLOCATOR),\
 		      erts_mtx_lock(&NAME##_lck),			\
 		      erts_mtx_unlock(&NAME##_lck))
 
@@ -371,7 +373,8 @@ ERTS_PRE_ALLOC_IMPL(NAME, TYPE, PASZ, (void) 0, (void) 0, (void) 0)
 #define ERTS_TS_PALLOC_IMPL(NAME, TYPE, PASZ)				\
 static erts_spinlock_t NAME##_lck;					\
 ERTS_PRE_ALLOC_IMPL(NAME, TYPE, PASZ,					\
-		    erts_spinlock_init(&NAME##_lck, #NAME "_alloc_lock"),\
+		    erts_spinlock_init(&NAME##_lck, #NAME "_alloc_lock", NIL, \
+		          ERTS_LOCK_FLAGS_CATEGORY_ALLOCATOR),\
 		    erts_spin_lock(&NAME##_lck),			\
 		    erts_spin_unlock(&NAME##_lck))
 
diff --git a/erts/emulator/beam/erl_alloc.types b/erts/emulator/beam/erl_alloc.types
index c155630765..50a1d97dd5 100644
--- a/erts/emulator/beam/erl_alloc.types
+++ b/erts/emulator/beam/erl_alloc.types
@@ -371,7 +371,7 @@ type	SSB		SHORT_LIVED	PROCESSES	ssb
 +if lcnt
 
 type    LCNT_CARRIER   STANDARD    SYSTEM  lcnt_lock_info_carrier
-type    LCNT_VECTOR SHORT_LIVED SYSTEM lcnt_lock_info_vector
+type    LCNT_VECTOR SHORT_LIVED SYSTEM lcnt_sample_vector
 
 +endif
 
diff --git a/erts/emulator/beam/erl_alloc_util.c b/erts/emulator/beam/erl_alloc_util.c
index 4889fac923..c246143b3f 100644
--- a/erts/emulator/beam/erl_alloc_util.c
+++ b/erts/emulator/beam/erl_alloc_util.c
@@ -6135,16 +6135,8 @@ erts_alcu_start(Allctr_t *allctr, AllctrInit_t *init)
     if (init->ts) {
 	allctr->thread_safe = 1;
 
-#ifdef ERTS_ENABLE_LOCK_COUNT
-	erts_mtx_init_x_opt(&allctr->mutex,
-			    "alcu_allocator",
-			    make_small(allctr->alloc_no),
-			    ERTS_LCNT_LT_ALLOC);
-#else
-	erts_mtx_init_x(&allctr->mutex,
-			"alcu_allocator",
-			make_small(allctr->alloc_no));
-#endif /*ERTS_ENABLE_LOCK_COUNT*/
+        erts_mtx_init(&allctr->mutex, "alcu_allocator", make_small(allctr->alloc_no),
+            ERTS_LOCK_FLAGS_CATEGORY_ALLOCATOR);
 
 #ifdef DEBUG
 	allctr->debug.saved_tid = 0;
@@ -6324,7 +6316,8 @@ erts_alcu_init(AlcUInit_t *init)
     carrier_alignment = sizeof(Unit_t);
 #endif
 
-    erts_mtx_init(&init_atoms_mtx, "alcu_init_atoms");
+    erts_mtx_init(&init_atoms_mtx, "alcu_init_atoms", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_ALLOCATOR);
 
     atoms_initialized = 0;
     initialized = 1;
@@ -6592,3 +6585,45 @@ check_blk_carrier(Allctr_t *allctr, Block_t *iblk)
 
 #endif /* ERTS_ALLOC_UTIL_HARD_DEBUG */
 
+#ifdef ERTS_ENABLE_LOCK_COUNT
+
+static void lcnt_enable_allocator_lock_count(Allctr_t *allocator, int enable) {
+    if(!allocator->thread_safe) {
+        return;
+    }
+
+    if(enable) {
+        erts_lcnt_install_new_lock_info(&allocator->mutex.lcnt,
+            "alcu_allocator", make_small(allocator->alloc_no),
+            ERTS_LOCK_TYPE_MUTEX | ERTS_LOCK_FLAGS_CATEGORY_ALLOCATOR);
+    } else {
+        erts_lcnt_uninstall(&allocator->mutex.lcnt);
+    }
+}
+
+static void lcnt_update_thread_spec_locks(ErtsAllocatorThrSpec_t *tspec, int enable) {
+    if(tspec->enabled) {
+        int i;
+
+        for(i = 0; i < tspec->size; i++) {
+            lcnt_enable_allocator_lock_count(tspec->allctr[i], enable);
+        }
+    }
+}
+
+void erts_lcnt_update_allocator_locks(int enable) {
+    int i;
+
+    for(i = ERTS_ALC_A_MIN; i < ERTS_ALC_A_MAX; i++) {
+        ErtsAllocatorInfo_t *ai = &erts_allctrs_info[i];
+
+        if(ai->enabled && ai->alloc_util) {
+            if(ai->thr_spec) {
+                lcnt_update_thread_spec_locks((ErtsAllocatorThrSpec_t*)ai->extra, enable);
+            } else {
+                lcnt_enable_allocator_lock_count((Allctr_t*)ai->extra, enable);
+            }
+        }
+    }
+}
+#endif /* ERTS_ENABLE_LOCK_COUNT */
diff --git a/erts/emulator/beam/erl_alloc_util.h b/erts/emulator/beam/erl_alloc_util.h
index f570703f25..431ce430be 100644
--- a/erts/emulator/beam/erl_alloc_util.h
+++ b/erts/emulator/beam/erl_alloc_util.h
@@ -227,6 +227,10 @@ void* erts_alcu_literal_32_sys_realloc(Allctr_t*, void *ptr, Uint *size_p, Uint
 void  erts_alcu_literal_32_sys_dealloc(Allctr_t*, void *ptr, Uint size, int superalign);
 #endif
 
+#ifdef ERTS_ENABLE_LOCK_COUNT
+void erts_lcnt_update_allocator_locks(int enable);
+#endif
+
 #endif /* !ERL_ALLOC_UTIL__ */
 
 #if defined(GET_ERL_ALLOC_UTIL_IMPL) && !defined(ERL_ALLOC_UTIL_IMPL__)
@@ -680,7 +684,6 @@ void erts_alcu_assert_failed(char* expr, char* file, int line, char *func);
 int is_sbc_blk(Block_t*);
 #endif
 
-
 #endif /* #if defined(GET_ERL_ALLOC_UTIL_IMPL)
 	      && !defined(ERL_ALLOC_UTIL_IMPL__) */
 
diff --git a/erts/emulator/beam/erl_async.c b/erts/emulator/beam/erl_async.c
index 84254af0c2..9a93034fcb 100644
--- a/erts/emulator/beam/erl_async.c
+++ b/erts/emulator/beam/erl_async.c
@@ -194,7 +194,8 @@ erts_init_async(void)
 	ptr += ERTS_ALC_CACHE_LINE_ALIGN_SIZE(sizeof(ErtsAsyncData));
 
 	async->init.data.no_initialized = 0;
-	erts_mtx_init(&async->init.data.mtx, "async_init_mtx");
+        erts_mtx_init(&async->init.data.mtx, "async_init_mtx", NIL,
+            ERTS_LOCK_FLAGS_CATEGORY_SCHEDULER);
 	erts_cnd_init(&async->init.data.cnd);
 	erts_atomic_init_nob(&async->init.data.id, 0);
 
@@ -213,7 +214,8 @@ erts_init_async(void)
 	for (i = 1; i <= erts_no_schedulers; i++) {
 	    ErtsAsyncReadyQ *arq = async_ready_q(i);
 #if ERTS_USE_ASYNC_READY_ENQ_MTX
-	    erts_mtx_init(&arq->x.data.enq_mtx, "async_enq_mtx");
+            erts_mtx_init(&arq->x.data.enq_mtx, "async_enq_mtx", make_small(i),
+                ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_SCHEDULER);
 #endif
 	    erts_thr_q_finalize_dequeue_state_init(&arq->fin_deq);
 	    qinit.arg = (void *) (SWord) i;
diff --git a/erts/emulator/beam/erl_bif_info.c b/erts/emulator/beam/erl_bif_info.c
index 8f7de32f12..02e34014e3 100644
--- a/erts/emulator/beam/erl_bif_info.c
+++ b/erts/emulator/beam/erl_bif_info.c
@@ -4431,44 +4431,56 @@ BIF_RETTYPE erts_debug_set_internal_state_2(BIF_ALIST_2)
 
 #ifdef ERTS_ENABLE_LOCK_COUNT
 
-typedef struct lcnt_lock_info_vector_ {
-    erts_lcnt_lock_info_t **elements;
+typedef struct {
+    /* info->location_count may increase between size calculation and term
+     * building, so we cap it at the value sampled in lcnt_build_result_vector.
+     *
+     * Shrinking is safe though. */
+    int max_location_count;
+    erts_lcnt_lock_info_t *info;
+} lcnt_sample_t;
+
+typedef struct lcnt_sample_vector_ {
+    lcnt_sample_t *elements;
     size_t size;
-} lcnt_lock_info_vector_t;
+} lcnt_sample_vector_t;
 
-static lcnt_lock_info_vector_t lcnt_build_lock_info_vector(erts_lcnt_lock_info_list_t *list) {
+static lcnt_sample_vector_t lcnt_build_sample_vector(erts_lcnt_lock_info_list_t *list) {
     erts_lcnt_lock_info_t *iterator;
-    lcnt_lock_info_vector_t result;
+    lcnt_sample_vector_t result;
     size_t allocated_entries;
 
     allocated_entries = 64;
     result.size = 0;
 
     result.elements = erts_alloc(ERTS_ALC_T_LCNT_VECTOR,
-        allocated_entries * sizeof(erts_lcnt_lock_info_t*));
+        allocated_entries * sizeof(lcnt_sample_t));
 
     iterator = NULL;
     while(erts_lcnt_iterate_list(list, &iterator)) {
         erts_lcnt_retain_lock_info(iterator);
 
-        result.elements[result.size++] = iterator;
+        result.elements[result.size].max_location_count = iterator->location_count;
+        result.elements[result.size].info = iterator;
+
+        result.size++;
 
         if(result.size >= allocated_entries) {
             allocated_entries *= 2;
 
             result.elements = erts_realloc(ERTS_ALC_T_LCNT_VECTOR, result.elements,
-                allocated_entries * sizeof(erts_lcnt_lock_info_t*));
+                allocated_entries * sizeof(lcnt_sample_t));
         }
     }
 
     return result;
 }
 
-static void lcnt_destroy_lock_info_vector(lcnt_lock_info_vector_t *vector) {
+static void lcnt_destroy_sample_vector(lcnt_sample_vector_t *vector) {
     size_t i;
 
     for(i = 0; i < vector->size; i++) {
-        erts_lcnt_release_lock_info(vector->elements[i]);
+        erts_lcnt_release_lock_info(vector->elements[i].info);
     }
 
     erts_free(ERTS_ALC_T_LCNT_VECTOR, vector->elements);
@@ -4508,9 +4520,9 @@ static Eterm lcnt_build_lock_stats_term(Eterm **hpp, Uint *szp, erts_lcnt_lock_s
     Eterm thist, vhist[ERTS_LCNT_HISTOGRAM_SLOT_SIZE];
 
     /* term:
-        * [{{file, line}, {tries, colls, {seconds, nanoseconds, n_blocks}},
-        *   { .. histogram .. }]
-        */
+     *  [{{file, line},
+         {tries, colls, {seconds, nanoseconds, n_blocks}},
+     *   { .. histogram .. }] */
 
     file = stats->file ? stats->file : "undefined";
 
@@ -4543,13 +4555,7 @@ static Eterm lcnt_build_lock_stats_term(Eterm **hpp, Uint *szp, erts_lcnt_lock_s
 static Eterm lcnt_pretty_print_lock_id(erts_lcnt_lock_info_t *info) {
     Eterm id = info->id;
 
-    if(info->flag & ERTS_LCNT_LT_ALLOC) {
-        /* Use allocator type names as id's for allocator locks. This blatantly
-         * assumes that all locks in this category are identified by their
-         * allocator number. */
-        const char *ltype = (const char*)ERTS_ALC_A2AD(signed_val(info->id));
-        id = erts_atom_put((byte*)ltype, strlen(ltype), ERTS_ATOM_ENC_LATIN1, 1);
-    } else if(info->flag & ERTS_LCNT_LT_PROCLOCK) {
+    if((info->flags & ERTS_LOCK_FLAGS_MASK_TYPE) == ERTS_LOCK_TYPE_PROCLOCK) {
         /* Use registered names as id's for process locks if available. Thread
          * progress is delayed since we may be running on a dirty scheduler. */
         ErtsThrPrgrDelayHandle delay_handle;
@@ -4563,27 +4569,30 @@ static Eterm lcnt_pretty_print_lock_id(erts_lcnt_lock_info_t *info) {
         }
 
         erts_thr_progress_unmanaged_continue(delay_handle);
+    } else if(info->flags & ERTS_LOCK_FLAGS_CATEGORY_ALLOCATOR) {
+        if(is_small(id) && !sys_strcmp(info->name, "alcu_allocator")) {
+            const char *name = (const char*)ERTS_ALC_A2AD(signed_val(id));
+            id = erts_atom_put((byte*)name, strlen(name), ERTS_ATOM_ENC_LATIN1, 1);
+        }
     }
 
     return id;
 }
 
-static Eterm lcnt_build_lock_term(Eterm **hpp, Uint *szp, erts_lcnt_lock_info_t *info, Eterm res) {
+static Eterm lcnt_build_lock_term(Eterm **hpp, Uint *szp, lcnt_sample_t *sample, Eterm res) {
+    erts_lcnt_lock_info_t *info = sample->info;
+
     Eterm name, type, id, stats = NIL, t;
-    const char *ltype;
+    const char *lock_desc;
     int i;
-    
-    /* term:
-     * [{name, id, type, stats()}] 
-     */
+
+    /* term: [{name, id, type, stats()}] */
 
     ASSERT(info->name);
     
-    ltype = erts_lcnt_lock_type(info->flag);
-    
-    ASSERT(ltype);
-    
-    type  = erts_atom_put((byte*)ltype, strlen(ltype), ERTS_ATOM_ENC_LATIN1, 1);
+    lock_desc = erts_lock_flags_get_type_name(info->flags);
+
+    type  = erts_atom_put((byte*)lock_desc, strlen(lock_desc), ERTS_ATOM_ENC_LATIN1, 1);
     name  = erts_atom_put((byte*)info->name, strlen(info->name), ERTS_ATOM_ENC_LATIN1, 1);
 
     /* Only attempt to resolve ids when actually emitting the term. This ought
@@ -4594,8 +4603,7 @@ static Eterm lcnt_build_lock_term(Eterm **hpp, Uint *szp, erts_lcnt_lock_info_t
         id = NIL;
     }
 
-    /* info->location_count is ignored since it can be changed at any time. */
-    for(i = 0; i < ERTS_LCNT_MAX_LOCK_LOCATIONS; i++) {
+    for(i = 0; i < MIN(info->location_count, sample->max_location_count); i++) {
         stats = lcnt_build_lock_stats_term(hpp, szp, &(info->location_stats[i]), stats);
     }
 
@@ -4606,18 +4614,15 @@ static Eterm lcnt_build_lock_term(Eterm **hpp, Uint *szp, erts_lcnt_lock_info_t
 }
 
 static Eterm lcnt_build_result_term(Eterm **hpp, Uint *szp, erts_lcnt_time_t *duration,
-                                    lcnt_lock_info_vector_t *current_locks,
-                                    lcnt_lock_info_vector_t *deleted_locks, Eterm res) {
-    Eterm dts, dtns, tdt, adur, tdur, aloc, lloc = NIL, tloc;
+                                    lcnt_sample_vector_t *current_locks,
+                                    lcnt_sample_vector_t *deleted_locks, Eterm res) {
+    const char *str_duration = "duration";
+    const char *str_locks = "locks";
 
+    Eterm dts, dtns, tdt, adur, tdur, aloc, lloc = NIL, tloc;
     size_t i;
 
-    char *str_duration = "duration";
-    char *str_locks    = "locks";
-
-    /* term:
-     * [{'duration', {seconds, nanoseconds}}, {'locks', locks()}]
-     */
+    /* term: [{'duration', {seconds, nanoseconds}}, {'locks', locks()}] */
 
     /* duration tuple */ 
     dts  = bld_unstable_uint64(hpp, szp, duration->s);
@@ -4628,15 +4633,14 @@ static Eterm lcnt_build_result_term(Eterm **hpp, Uint *szp, erts_lcnt_time_t *du
     tdur = erts_bld_tuple(hpp, szp, 2, adur, tdt);
    
     /* lock tuple */
-    
     aloc = erts_atom_put((byte *)str_locks, strlen(str_locks), ERTS_ATOM_ENC_LATIN1, 1);
 
     for(i = 0; i < current_locks->size; i++) {
-        lloc = lcnt_build_lock_term(hpp, szp, current_locks->elements[i], lloc);
+        lloc = lcnt_build_lock_term(hpp, szp, &current_locks->elements[i], lloc);
     }
 
     for(i = 0; i < deleted_locks->size; i++) {
-        lloc = lcnt_build_lock_term(hpp, szp, deleted_locks->elements[i], lloc);
+        lloc = lcnt_build_lock_term(hpp, szp, &deleted_locks->elements[i], lloc);
     }
 
     tloc = erts_bld_tuple(hpp, szp, 2, aloc, lloc);
@@ -4647,6 +4651,26 @@ static Eterm lcnt_build_result_term(Eterm **hpp, Uint *szp, erts_lcnt_time_t *du
     return res;
 }
 
+static erts_lock_flags_t lcnt_atom_to_lock_category(Eterm atom) {
+    if(ERTS_IS_ATOM_STR("generic", atom)) {
+        return ERTS_LOCK_FLAGS_CATEGORY_GENERIC;
+    } else if(ERTS_IS_ATOM_STR("allocator", atom)) {
+        return ERTS_LOCK_FLAGS_CATEGORY_ALLOCATOR;
+    } else if(ERTS_IS_ATOM_STR("scheduler", atom)) {
+        return ERTS_LOCK_FLAGS_CATEGORY_SCHEDULER;
+    } else if(ERTS_IS_ATOM_STR("process", atom)) {
+        return ERTS_LOCK_FLAGS_CATEGORY_PROCESS;
+    } else if(ERTS_IS_ATOM_STR("db", atom)) {
+        return ERTS_LOCK_FLAGS_CATEGORY_DB;
+    } else if(ERTS_IS_ATOM_STR("io", atom)) {
+        return ERTS_LOCK_FLAGS_CATEGORY_IO;
+    } else if(ERTS_IS_ATOM_STR("debug", atom)) {
+        return ERTS_LOCK_FLAGS_CATEGORY_DEBUG;
+    }
+
+    return 0;
+}
+
 #endif
 
 BIF_RETTYPE erts_debug_lock_counters_1(BIF_ALIST_1)
@@ -4662,7 +4686,7 @@ BIF_RETTYPE erts_debug_lock_counters_1(BIF_ALIST_1)
     if (BIF_ARG_1 == am_enabled) {
        BIF_RET(am_true);
     } else if (BIF_ARG_1 == am_info) {
-        lcnt_lock_info_vector_t current_locks, deleted_locks;
+        lcnt_sample_vector_t current_locks, deleted_locks;
         erts_lcnt_data_t data;
 
         Eterm *term_heap_start, *term_heap_end;
@@ -4671,8 +4695,8 @@ BIF_RETTYPE erts_debug_lock_counters_1(BIF_ALIST_1)
 
         data = erts_lcnt_get_data();
 
-        current_locks = lcnt_build_lock_info_vector(data.current_locks);
-        deleted_locks = lcnt_build_lock_info_vector(data.deleted_locks);
+        current_locks = lcnt_build_sample_vector(data.current_locks);
+        deleted_locks = lcnt_build_sample_vector(data.deleted_locks);
 
         lcnt_build_result_term(NULL, &term_heap_size, &data.duration,
             &current_locks, &deleted_locks, NIL);
@@ -4685,8 +4709,8 @@ BIF_RETTYPE erts_debug_lock_counters_1(BIF_ALIST_1)
 
         HRelease(BIF_P, term_heap_start + term_heap_size, term_heap_end);
 
-        lcnt_destroy_lock_info_vector(&current_locks);
-        lcnt_destroy_lock_info_vector(&deleted_locks);
+        lcnt_destroy_sample_vector(&current_locks);
+        lcnt_destroy_sample_vector(&deleted_locks);
 
         BIF_RET(result);
     } else if (BIF_ARG_1 == am_clear) {
@@ -4696,46 +4720,39 @@ BIF_RETTYPE erts_debug_lock_counters_1(BIF_ALIST_1)
     } else if (is_tuple(BIF_ARG_1)) {
         Eterm* ptr = tuple_val(BIF_ARG_1);
 
-        if ((arityval(ptr[0]) == 2) && (ptr[2] == am_false || ptr[2] == am_true)) {
-           Eterm res;
-
-            int lock_opt = 0, enable = (ptr[2] == am_true) ? 1 : 0;
-            if (ERTS_IS_ATOM_STR("copy_save", ptr[1])) {
-                lock_opt = ERTS_LCNT_OPT_COPYSAVE;
-            } else if (ERTS_IS_ATOM_STR("process_locks", ptr[1])) {
-                lock_opt = ERTS_LCNT_OPT_PROCLOCK;
-            } else if (ERTS_IS_ATOM_STR("port_locks", ptr[1])) {
-                lock_opt = ERTS_LCNT_OPT_PORTLOCK;
-            } else if (ERTS_IS_ATOM_STR("location", ptr[1])) {
-                lock_opt = ERTS_LCNT_OPT_LOCATION;
-            } else {
+        if(arityval(ptr[0]) != 2) {
+            BIF_ERROR(BIF_P, BADARG);
+        } else if(ERTS_IS_ATOM_STR("mask", ptr[1])) {
+            erts_lock_flags_t category_mask = 0;
+            Eterm categories = ptr[2];
+
+            if(!(is_list(categories) || is_nil(categories))) {
                 BIF_ERROR(BIF_P, BADARG);
             }
 
-            if (enable) {
-                res = erts_lcnt_set_rt_opt(lock_opt) ? am_true : am_false;
-            } else {
-                res = erts_lcnt_clear_rt_opt(lock_opt) ? am_true : am_false;
-            }
+            while(is_list(categories)) {
+                Eterm *cell = list_val(categories);
+                erts_lock_flags_t category;
 
-#ifdef ERTS_SMP
-            /* FIXME: make this non-blocking. */
-            erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
-            erts_smp_thr_progress_block();
-#endif
+                category = lcnt_atom_to_lock_category(CAR(cell));
+
+                if(!category) {
+                    /* Return {error, bad_category, Category}? Or leave that to
+                     * the lcnt module? */
+                    BIF_ERROR(BIF_P, BADARG);
+                }
 
-            if (res != ptr[2] && lock_opt == ERTS_LCNT_OPT_PORTLOCK) {
-                erts_lcnt_enable_io_lock_count(enable);
-            } else if (res != ptr[2] && lock_opt == ERTS_LCNT_OPT_PROCLOCK) {
-                erts_lcnt_enable_proc_lock_count(enable);
+                category_mask |= category;
+                categories = CDR(cell);
             }
 
-#ifdef ERTS_SMP
-            erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
-            erts_smp_thr_progress_unblock();
-#endif
+            erts_lcnt_set_category_mask(category_mask);
+
+            BIF_RET(am_ok);
+        } else if(ERTS_IS_ATOM_STR("copy_save", ptr[1]) &&
+            (ptr[2] == am_true || ptr[2] == am_false)) {
 
-            BIF_RET(res);
+            erts_lcnt_set_preserve_info(ptr[2] == am_true);
         }
     }
 
diff --git a/erts/emulator/beam/erl_bif_unique.c b/erts/emulator/beam/erl_bif_unique.c
index fc6fb5f868..2f8adc87d5 100644
--- a/erts/emulator/beam/erl_bif_unique.c
+++ b/erts/emulator/beam/erl_bif_unique.c
@@ -392,7 +392,8 @@ init_magic_ref_tables(void)
     erts_snprintf(&tblp->name[0], sizeof(tblp->name),
 		  "magic_ref_table_0");
     hash_init(0, &tblp->hash, &tblp->name[0], 1, hash_funcs);
-    erts_rwmtx_init(&tblp->rwmtx, "magic_ref_table");
+    erts_rwmtx_init(&tblp->rwmtx, "magic_ref_table", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
 
     hash_funcs.hash = nsched_mreft_hash;
     hash_funcs.cmp = nsched_mreft_cmp;
@@ -402,7 +403,8 @@ init_magic_ref_tables(void)
 	erts_snprintf(&tblp->name[0], sizeof(tblp->name),
 		      "magic_ref_table_%d", i);
 	hash_init(0, &tblp->hash, &tblp->name[0], 1, hash_funcs);
-	erts_rwmtx_init(&tblp->rwmtx, "magic_ref_table");
+	erts_rwmtx_init(&tblp->rwmtx, "magic_ref_table", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
     }
 }
 
diff --git a/erts/emulator/beam/erl_cpu_topology.c b/erts/emulator/beam/erl_cpu_topology.c
index 4347f9f2b7..9f3a96fa1e 100644
--- a/erts/emulator/beam/erl_cpu_topology.c
+++ b/erts/emulator/beam/erl_cpu_topology.c
@@ -1706,7 +1706,8 @@ erts_init_cpu_topology(void)
 {
     int ix;
 
-    erts_smp_rwmtx_init(&cpuinfo_rwmtx, "cpu_info");
+    erts_smp_rwmtx_init(&cpuinfo_rwmtx, "cpu_info", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
     erts_smp_rwmtx_rwlock(&cpuinfo_rwmtx);
 
     scheduler2cpu_map = erts_alloc(ERTS_ALC_T_CPUDATA,
diff --git a/erts/emulator/beam/erl_db.c b/erts/emulator/beam/erl_db.c
index 17e0f2aeec..b83134c79c 100644
--- a/erts/emulator/beam/erl_db.c
+++ b/erts/emulator/beam/erl_db.c
@@ -575,9 +575,7 @@ delete_owned_table(Process *p, DbTable *tb)
     table_dec_refc(tb, 1);
 }
 
-
-static ERTS_INLINE void db_init_lock(DbTable* tb, int use_frequent_read_lock,
-				     char *rwname, char* fixname)
+static ERTS_INLINE void db_init_lock(DbTable* tb, int use_frequent_read_lock)
 {
 #ifdef ERTS_SMP
     erts_smp_rwmtx_opt_t rwmtx_opt = ERTS_SMP_RWMTX_OPT_DEFAULT_INITER;
@@ -587,9 +585,10 @@ static ERTS_INLINE void db_init_lock(DbTable* tb, int use_frequent_read_lock,
 	rwmtx_opt.main_spincount = erts_ets_rwmtx_spin_count;
 #endif
 #ifdef ERTS_SMP
-    erts_smp_rwmtx_init_opt_x(&tb->common.rwlock, &rwmtx_opt,
-			      rwname, tb->common.the_name);
-    erts_smp_mtx_init_x(&tb->common.fixlock, fixname, tb->common.the_name);
+    erts_smp_rwmtx_init_opt(&tb->common.rwlock, &rwmtx_opt, "db_tab",
+        tb->common.the_name, ERTS_LOCK_FLAGS_CATEGORY_DB);
+    erts_smp_mtx_init(&tb->common.fixlock, "db_tab_fix",
+        tb->common.the_name, ERTS_LOCK_FLAGS_CATEGORY_DB);
     tb->common.is_thread_safe = !(tb->common.status & DB_FINE_LOCKED);
 #endif
 }
@@ -1753,8 +1752,7 @@ BIF_RETTYPE ets_new_2(BIF_ALIST_2)
     /* Note, 'type' is *read only* from now on... */
 #endif
     erts_smp_refc_init(&tb->common.fix_count, 0);
-    db_init_lock(tb, status & (DB_FINE_LOCKED|DB_FREQ_READ),
-		 "db_tab", "db_tab_fix");
+    db_init_lock(tb, status & (DB_FINE_LOCKED|DB_FREQ_READ));
     tb->common.keypos = keypos;
     tb->common.owner = BIF_P->common.id;
     set_heir(BIF_P, tb, heir, heir_data);
@@ -3391,8 +3389,9 @@ void init_db(ErtsDbSpinCount db_spin_count)
 	rwmtx_opt.main_spincount = erts_ets_rwmtx_spin_count;
 
     for (i=0; i<META_NAME_TAB_LOCK_CNT; i++) {
-	erts_smp_rwmtx_init_opt_x(&meta_name_tab_rwlocks[i].lck, &rwmtx_opt,
-				  "meta_name_tab", make_small(i));
+        erts_smp_rwmtx_init_opt(&meta_name_tab_rwlocks[i].lck, &rwmtx_opt,
+            "meta_name_tab", make_small(i),
+            ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_DB);
     }
 #endif
 
@@ -4334,3 +4333,47 @@ erts_ets_colliding_names(Process* p, Eterm name, Uint cnt)
     return list;
 }
 
+#ifdef ERTS_ENABLE_LOCK_COUNT
+
+void erts_lcnt_enable_db_lock_count(DbTable *tb, int enable) {
+    if(enable) {
+        erts_lcnt_install_new_lock_info(&tb->common.rwlock.lcnt, "db_tab",
+            tb->common.the_name, ERTS_LOCK_TYPE_RWMUTEX | ERTS_LOCK_FLAGS_CATEGORY_DB);
+        erts_lcnt_install_new_lock_info(&tb->common.fixlock.lcnt, "db_tab_fix",
+            tb->common.the_name, ERTS_LOCK_TYPE_MUTEX | ERTS_LOCK_FLAGS_CATEGORY_DB);
+    } else {
+        erts_lcnt_uninstall(&tb->common.rwlock.lcnt);
+        erts_lcnt_uninstall(&tb->common.fixlock.lcnt);
+    }
+
+    if(IS_HASH_TABLE(tb->common.status)) {
+        erts_lcnt_enable_db_hash_lock_count(&tb->hash, enable);
+    }
+}
+
+static void lcnt_update_db_locks_per_sched(void *enable) {
+    ErtsSchedulerData *esdp;
+    DbTable *head;
+
+    esdp = erts_get_scheduler_data();
+    head = esdp->ets_tables.clist;
+
+    if(head) {
+        DbTable *iterator = head;
+
+        do {
+            if(is_table_alive(iterator)) {
+                erts_lcnt_enable_db_lock_count(iterator, !!enable);
+            }
+
+            iterator = iterator->common.all.next;
+        } while (iterator != head);
+    }
+}
+
+void erts_lcnt_update_db_locks(int enable) {
+    erts_schedule_multi_misc_aux_work(0, erts_no_schedulers,
+        &lcnt_update_db_locks_per_sched, (void*)(UWord)enable);
+}
+
+#endif /* ERTS_ENABLE_LOCK_COUNT */
\ No newline at end of file
diff --git a/erts/emulator/beam/erl_db.h b/erts/emulator/beam/erl_db.h
index 4ff9f224e8..d83126b3a2 100644
--- a/erts/emulator/beam/erl_db.h
+++ b/erts/emulator/beam/erl_db.h
@@ -129,6 +129,11 @@ extern erts_smp_atomic_t erts_ets_misc_mem_size;
 Eterm erts_ets_colliding_names(Process*, Eterm name, Uint cnt);
 Uint erts_db_get_max_tabs(void);
 
+#ifdef ERTS_ENABLE_LOCK_COUNT
+void erts_lcnt_enable_db_lock_count(DbTable *tb, int enable);
+void erts_lcnt_update_db_locks(int enable);
+#endif
+
 #endif /* ERL_DB_H__ */
 
 #if defined(ERTS_WANT_DB_INTERNAL__) && !defined(ERTS_HAVE_DB_INTERNAL__)
diff --git a/erts/emulator/beam/erl_db_hash.c b/erts/emulator/beam/erl_db_hash.c
index 08a0f0e83b..ae9322dfd3 100644
--- a/erts/emulator/beam/erl_db_hash.c
+++ b/erts/emulator/beam/erl_db_hash.c
@@ -675,8 +675,8 @@ int db_create_hash(Process *p, DbTable *tbl)
 							      (DbTable *) tb,
 							      sizeof(DbTableHashFineLocks));	    	    
 	for (i=0; i<DB_HASH_LOCK_CNT; ++i) {
-	    erts_smp_rwmtx_init_opt_x(&tb->locks->lck_vec[i].lck, &rwmtx_opt,
-				      "db_hash_slot", make_small(i));
+            erts_smp_rwmtx_init_opt(&tb->locks->lck_vec[i].lck, &rwmtx_opt,
+                "db_hash_slot", tb->common.the_name, ERTS_LOCK_FLAGS_CATEGORY_DB);
 	}
 	/* This important property is needed to guarantee the two buckets
     	 * involved in a grow/shrink operation it protected by the same lock:
@@ -3206,3 +3206,23 @@ Eterm erts_ets_hash_sizeof_ext_segtab(void)
     return make_small(((SIZEOF_EXT_SEGTAB(0)-1) / sizeof(UWord)) + 1);
 }
 
+#ifdef ERTS_ENABLE_LOCK_COUNT
+void erts_lcnt_enable_db_hash_lock_count(DbTableHash *tb, int enable) {
+    int i;
+
+    if(tb->locks == NULL) {
+        return;
+    }
+
+    for(i = 0; i < DB_HASH_LOCK_CNT; i++) {
+        erts_lcnt_ref_t *ref = &tb->locks->lck_vec[i].lck.lcnt;
+
+        if(enable) {
+            erts_lcnt_install_new_lock_info(ref, "db_hash_slot", tb->common.the_name,
+                ERTS_LOCK_TYPE_RWMUTEX | ERTS_LOCK_FLAGS_CATEGORY_DB);
+        } else {
+            erts_lcnt_uninstall(ref);
+        }
+    }
+}
+#endif /* ERTS_ENABLE_LOCK_COUNT */
diff --git a/erts/emulator/beam/erl_db_hash.h b/erts/emulator/beam/erl_db_hash.h
index f491c85d95..523ed7860e 100644
--- a/erts/emulator/beam/erl_db_hash.h
+++ b/erts/emulator/beam/erl_db_hash.h
@@ -103,4 +103,8 @@ typedef struct {
 void db_calc_stats_hash(DbTableHash* tb, DbHashStats*);
 Eterm erts_ets_hash_sizeof_ext_segtab(void);
 
+#ifdef ERTS_ENABLE_LOCK_COUNT
+void erts_lcnt_enable_db_hash_lock_count(DbTableHash *tb, int enable);
+#endif
+
 #endif /* _DB_HASH_H */
diff --git a/erts/emulator/beam/erl_drv_thread.c b/erts/emulator/beam/erl_drv_thread.c
index 3b68abe5d7..49bbab55a8 100644
--- a/erts/emulator/beam/erl_drv_thread.c
+++ b/erts/emulator/beam/erl_drv_thread.c
@@ -146,7 +146,8 @@ void erl_drv_thr_init(void)
 			       sizeof(char *)*ERL_DRV_TSD_KEYS_INC);
     for (i = 0; i < ERL_DRV_TSD_KEYS_INC; i++)
 	used_tsd_keys[i] = NULL;
-    erts_mtx_init(&tsd_mtx, "drv_tsd");
+    erts_mtx_init(&tsd_mtx, "drv_tsd", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_IO);
 }
 
 /*
@@ -176,8 +177,8 @@ erl_drv_mutex_create(char *name)
 	    dmtx->name = no_name;
 	}
 #ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_init_ref(&dmtx->lcnt);
-    erts_lcnt_install_new_lock_info(&dmtx->lcnt, dmtx->name, ERTS_LCNT_LT_MUTEX);
+    erts_lcnt_init_ref_x(&dmtx->lcnt, dmtx->name, NIL,
+        ERTS_LOCK_TYPE_MUTEX | ERTS_LOCK_FLAGS_CATEGORY_IO);
 #endif
     }
     return dmtx;
@@ -369,8 +370,8 @@ erl_drv_rwlock_create(char *name)
 	    drwlck->name = no_name;
 	}
 #ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_init_ref(&drwlck->lcnt);
-    erts_lcnt_install_new_lock_info(&drwlck->lcnt, drwlck->name, ERTS_LCNT_LT_RWMUTEX);
+    erts_lcnt_init_ref_x(&drwlck->lcnt, drwlck->name, NIL,
+        ERTS_LOCK_TYPE_RWMUTEX | ERTS_LOCK_FLAGS_CATEGORY_IO);
 #endif
     }
     return drwlck;
@@ -413,7 +414,7 @@ erl_drv_rwlock_tryrlock(ErlDrvRWLock *drwlck)
 	fatal_error(EINVAL, "erl_drv_rwlock_tryrlock()");
     res = ethr_rwmutex_tryrlock(&drwlck->rwmtx);
 #ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_trylock_opt(&drwlck->lcnt, res, ERTS_LCNT_LO_READ);
+    erts_lcnt_trylock_opt(&drwlck->lcnt, res, ERTS_LOCK_OPTION_READ);
 #endif
     return res;
 #else
@@ -428,7 +429,7 @@ erl_drv_rwlock_rlock(ErlDrvRWLock *drwlck)
     if (!drwlck)
 	fatal_error(EINVAL, "erl_drv_rwlock_rlock()");
 #ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_lock_opt(&drwlck->lcnt, ERTS_LCNT_LO_READ);
+    erts_lcnt_lock_opt(&drwlck->lcnt, ERTS_LOCK_OPTION_READ);
 #endif
     ethr_rwmutex_rlock(&drwlck->rwmtx);
 #ifdef ERTS_ENABLE_LOCK_COUNT
@@ -444,7 +445,7 @@ erl_drv_rwlock_runlock(ErlDrvRWLock *drwlck)
     if (!drwlck)
 	fatal_error(EINVAL, "erl_drv_rwlock_runlock()");
 #ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_unlock_opt(&drwlck->lcnt, ERTS_LCNT_LO_READ);
+    erts_lcnt_unlock_opt(&drwlck->lcnt, ERTS_LOCK_OPTION_READ);
 #endif
     ethr_rwmutex_runlock(&drwlck->rwmtx);
 #endif
@@ -459,7 +460,7 @@ erl_drv_rwlock_tryrwlock(ErlDrvRWLock *drwlck)
 	fatal_error(EINVAL, "erl_drv_rwlock_tryrwlock()");
     res = ethr_rwmutex_tryrwlock(&drwlck->rwmtx);
 #ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_trylock_opt(&drwlck->lcnt, res, ERTS_LCNT_LO_READ_WRITE);
+    erts_lcnt_trylock_opt(&drwlck->lcnt, res, ERTS_LOCK_OPTION_RDWR);
 #endif
     return res;
 #else
@@ -474,7 +475,7 @@ erl_drv_rwlock_rwlock(ErlDrvRWLock *drwlck)
     if (!drwlck)
 	fatal_error(EINVAL, "erl_drv_rwlock_rwlock()");
 #ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_lock_opt(&drwlck->lcnt, ERTS_LCNT_LO_READ_WRITE);
+    erts_lcnt_lock_opt(&drwlck->lcnt, ERTS_LOCK_OPTION_RDWR);
 #endif
     ethr_rwmutex_rwlock(&drwlck->rwmtx);
 #ifdef ERTS_ENABLE_LOCK_COUNT
@@ -490,7 +491,7 @@ erl_drv_rwlock_rwunlock(ErlDrvRWLock *drwlck)
     if (!drwlck)
 	fatal_error(EINVAL, "erl_drv_rwlock_rwunlock()");
 #ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_unlock_opt(&drwlck->lcnt, ERTS_LCNT_LO_READ_WRITE);
+    erts_lcnt_unlock_opt(&drwlck->lcnt, ERTS_LOCK_OPTION_RDWR);
 #endif
     ethr_rwmutex_rwunlock(&drwlck->rwmtx);
 #endif
diff --git a/erts/emulator/beam/erl_fun.c b/erts/emulator/beam/erl_fun.c
index d18016c42e..535f677bb3 100644
--- a/erts/emulator/beam/erl_fun.c
+++ b/erts/emulator/beam/erl_fun.c
@@ -63,7 +63,8 @@ erts_init_fun_table(void)
     rwmtx_opt.type = ERTS_SMP_RWMTX_TYPE_FREQUENT_READ;
     rwmtx_opt.lived = ERTS_SMP_RWMTX_LONG_LIVED;
 
-    erts_smp_rwmtx_init_opt(&erts_fun_table_lock, &rwmtx_opt, "fun_tab");
+    erts_smp_rwmtx_init_opt(&erts_fun_table_lock, &rwmtx_opt, "fun_tab", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
 
     f.hash = (H_FUN) fun_hash;
     f.cmp  = (HCMP_FUN) fun_cmp;
diff --git a/erts/emulator/beam/erl_gc.c b/erts/emulator/beam/erl_gc.c
index 2ff49c97b3..23c5b56067 100644
--- a/erts/emulator/beam/erl_gc.c
+++ b/erts/emulator/beam/erl_gc.c
@@ -274,7 +274,8 @@ erts_init_gc(void)
     }
 
 #ifdef ERTS_DIRTY_SCHEDULERS
-    erts_smp_mtx_init(&dirty_gc.mtx, "dirty_gc_info");
+    erts_smp_mtx_init(&dirty_gc.mtx, "dirty_gc_info", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
     init_gc_info(&dirty_gc.info);
 #endif
 
diff --git a/erts/emulator/beam/erl_init.c b/erts/emulator/beam/erl_init.c
index ac99f043e6..aaecde4d78 100644
--- a/erts/emulator/beam/erl_init.c
+++ b/erts/emulator/beam/erl_init.c
@@ -2355,8 +2355,12 @@ erl_start(int argc, char **argv)
 
 #ifdef ERTS_SMP
     erts_start_schedulers();
-    /* Let system specific code decide what to do with the main thread... */
 
+#ifdef ERTS_ENABLE_LOCK_COUNT
+    erts_lcnt_post_startup();
+#endif
+
+    /* Let system specific code decide what to do with the main thread... */
     erts_sys_main_thread(); /* May or may not return! */
 #else
     {
@@ -2371,6 +2375,11 @@ erl_start(int argc, char **argv)
 	erts_sched_init_time_sup(esdp);
         erts_ets_sched_spec_data_init(esdp);
         erts_aux_work_timeout_late_init(esdp);
+
+#ifdef ERTS_ENABLE_LOCK_COUNT
+        erts_lcnt_post_startup();
+#endif
+
 	process_main(esdp->x_reg_array, esdp->f_reg_array);
     }
 #endif
diff --git a/erts/emulator/beam/erl_instrument.c b/erts/emulator/beam/erl_instrument.c
index 4d4defd8b5..634509f880 100644
--- a/erts/emulator/beam/erl_instrument.c
+++ b/erts/emulator/beam/erl_instrument.c
@@ -1200,7 +1200,8 @@ erts_instr_init(int stat, int map_stat)
 
     stats = erts_alloc(ERTS_ALC_T_INSTR_INFO, sizeof(struct stats_));
 
-    erts_mtx_init(&instr_mutex, "instr");
+    erts_mtx_init(&instr_mutex, "instr", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_DEBUG);
 
     mem_anchor = NULL;
 
@@ -1223,7 +1224,8 @@ erts_instr_init(int stat, int map_stat)
 
     if (map_stat) {
 
-	erts_mtx_init(&instr_x_mutex, "instr_x");
+	erts_mtx_init(&instr_x_mutex, "instr_x", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_DEBUG);
 
 	erts_instr_memory_map = 1;
 	erts_instr_stat = 1;
diff --git a/erts/emulator/beam/erl_lock_check.c b/erts/emulator/beam/erl_lock_check.c
index f270d8baef..85ee703c99 100644
--- a/erts/emulator/beam/erl_lock_check.c
+++ b/erts/emulator/beam/erl_lock_check.c
@@ -104,7 +104,6 @@ static erts_lc_lock_order_t erts_lock_order[] = {
     {	"db_tab",				"address"		},
     {	"proc_status",				"pid"			},
     {	"proc_trace",				"pid"			},
-    {   "ports_snapshot",                       NULL                    },
     {	"db_tab_fix",				"address"		},
     {	"db_hash_slot",				"address"		},
     {	"node_table",				NULL			},
@@ -161,6 +160,9 @@ static erts_lc_lock_order_t erts_lock_order[] = {
     {	"mtrace_op",				NULL			},
     {	"instr_x",				NULL			},
     {	"instr",				NULL			},
+#ifdef ERTS_SMP
+    {	"pollsets_lock",			NULL			},
+#endif
     {	"alcu_allocator",			"index"			},
     {	"mseg",					NULL			},
 #ifdef ERTS_SMP
@@ -173,7 +175,6 @@ static erts_lc_lock_order_t erts_lock_order[] = {
     {	"get_time",				NULL			},
     {	"get_corrected_time",			NULL			},
     {	"breakpoints",				NULL			},
-    {	"pollsets_lock",			NULL			},
     {	"pix_lock",				"address"		},
     {	"run_queues_lists",			NULL			},
     {	"sched_stat",				NULL			},
diff --git a/erts/emulator/beam/erl_lock_count.c b/erts/emulator/beam/erl_lock_count.c
index 2cf59aa367..d2e8f47d59 100644
--- a/erts/emulator/beam/erl_lock_count.c
+++ b/erts/emulator/beam/erl_lock_count.c
@@ -26,19 +26,26 @@
 
 #include "sys.h"
 
+#include "global.h"
+
 #include "erl_lock_count.h"
 #include "erl_thr_progress.h"
 
-#define LCNT_MAX_CARRIER_ENTRIES 255
-
-/* - Exported global - */
+#include "erl_node_tables.h"
+#include "erl_alloc_util.h"
+#include "erl_check_io.h"
+#include "erl_poll.h"
+#include "erl_db.h"
 
-Uint16 erts_lcnt_rt_options = ERTS_LCNT_OPT_PROCLOCK | ERTS_LCNT_OPT_LOCATION;
+#define LCNT_MAX_CARRIER_ENTRIES 255
 
 /* - Locals that are shared with the header implementation - */
 
-int lcnt_initialization_completed__ = 0;
+#ifdef DEBUG
+int lcnt_initialization_completed__;
+#endif
 
+erts_lock_flags_t lcnt_category_mask__;
 ethr_tsd_key lcnt_thr_data_key__;
 
 const int lcnt_log2_tab64__[64] = {
@@ -53,11 +60,25 @@ const int lcnt_log2_tab64__[64] = {
 
 /* - Local variables - */
 
+typedef struct lcnt_static_lock_ref_ {
+    erts_lcnt_ref_t *reference;
+
+    erts_lock_flags_t flags;
+    const char *name;
+    Eterm id;
+
+    struct lcnt_static_lock_ref_ *next;
+} lcnt_static_lock_ref_t;
+
+static ethr_atomic_t lcnt_static_lock_registry;
+
 static erts_lcnt_lock_info_list_t lcnt_current_lock_list;
 static erts_lcnt_lock_info_list_t lcnt_deleted_lock_list;
 
 static erts_lcnt_time_t lcnt_timer_start;
 
+static int lcnt_preserve_info;
+
 /* local functions */
 
 static void lcnt_clear_stats(erts_lcnt_lock_info_t *info) {
@@ -97,37 +118,6 @@ static lcnt_thread_data_t__ *lcnt_thread_data_alloc(void) {
     return eltd;
 }
 
-/* debug */
-
-#if 0
-static char* lock_opt(Uint16 flag) {
-    if ((flag & ERTS_LCNT_LO_WRITE) && (flag & ERTS_LCNT_LO_READ)) return "rw";
-    if  (flag & ERTS_LCNT_LO_READ )                                return "r ";
-    if  (flag & ERTS_LCNT_LO_WRITE)                                return " w";
-    return "--";
-}
-
-static void print_lock_x(erts_lcnt_lock_info_t *info, Uint16 flag, char *action) {
-    ethr_sint_t w_state, r_state;
-    char *type;
-
-    if (strcmp(info->name, "run_queue") != 0) return;
-    type = erts_lcnt_lock_type(info->flag);
-    r_state = ethr_atomic_read(&info->r_state);
-    w_state = ethr_atomic_read(&info->w_state);
-
-    if (info->flag & flag) {
-        erts_fprintf(stderr,"%10s [%24s] [r/w state %4ld/%4ld] %2s id %T\r\n",
-                action,
-                info->name,
-                r_state,
-                w_state,
-                type,
-                info->id);
-    }
-}
-#endif
-
 /* - List operations -
  *
  * Info entries are kept in a doubly linked list where each entry is locked
@@ -271,12 +261,7 @@ void lcnt_thr_progress_unmanaged_continue__(int handle) {
     return erts_thr_progress_unmanaged_continue(handle);
 }
 
-static void lcnt_deallocate_carrier_malloc(erts_lcnt_lock_info_carrier_t *carrier) {
-    ASSERT(ethr_atomic_read(&carrier->ref_count) == 0);
-    free(carrier);
-}
-
-static void lcnt_deallocate_carrier_erts(erts_lcnt_lock_info_carrier_t *carrier) {
+void lcnt_deallocate_carrier__(erts_lcnt_lock_info_carrier_t *carrier) {
     ASSERT(ethr_atomic_read(&carrier->ref_count) == 0);
     erts_free(ERTS_ALC_T_LCNT_CARRIER, (void*)carrier);
 }
@@ -323,7 +308,7 @@ static void lcnt_info_deallocate(erts_lcnt_lock_info_t *info) {
 static void lcnt_info_dispose(erts_lcnt_lock_info_t *info) {
     ASSERT(ethr_atomic_read(&info->ref_count) == 0);
 
-    if(erts_lcnt_rt_options & ERTS_LCNT_OPT_COPYSAVE) {
+    if(lcnt_preserve_info) {
         ethr_atomic_set(&info->ref_count, 1);
 
         /* Move straight to deallocation the next time around. */
@@ -336,10 +321,6 @@ static void lcnt_info_dispose(erts_lcnt_lock_info_t *info) {
 }
 
 static void lcnt_lock_info_init_helper(erts_lcnt_lock_info_t *info) {
-#ifdef DEBUG
-    ethr_atomic_init(&info->flowstate, 0);
-#endif
-
     ethr_atomic_init(&info->ref_count, 1);
     ethr_atomic32_init(&info->lock, 0);
 
@@ -356,22 +337,16 @@ erts_lcnt_lock_info_carrier_t *erts_lcnt_create_lock_info_carrier(int entry_coun
     size_t carrier_size, i;
 
     ASSERT(entry_count > 0 && entry_count <= LCNT_MAX_CARRIER_ENTRIES);
+    ASSERT(lcnt_initialization_completed__);
 
     carrier_size = sizeof(erts_lcnt_lock_info_carrier_t) +
                    sizeof(erts_lcnt_lock_info_t) * entry_count;
 
-    if(lcnt_initialization_completed__) {
-        result = (erts_lcnt_lock_info_carrier_t*)erts_alloc(ERTS_ALC_T_LCNT_CARRIER, carrier_size);
-        result->deallocate = &lcnt_deallocate_carrier_erts;
-    } else {
-        result = (erts_lcnt_lock_info_carrier_t*)malloc(carrier_size);
-        result->deallocate = &lcnt_deallocate_carrier_malloc;
-    }
+    result = (erts_lcnt_lock_info_carrier_t*)erts_alloc(ERTS_ALC_T_LCNT_CARRIER, carrier_size);
+    result->entry_count = entry_count;
 
     ethr_atomic_init(&result->ref_count, entry_count);
 
-    result->entry_count = entry_count;
-
     for(i = 0; i < entry_count; i++) {
         erts_lcnt_lock_info_t *info = &result->entries[i];
 
@@ -386,6 +361,24 @@ erts_lcnt_lock_info_carrier_t *erts_lcnt_create_lock_info_carrier(int entry_coun
 void erts_lcnt_install(erts_lcnt_ref_t *ref, erts_lcnt_lock_info_carrier_t *carrier) {
     ethr_sint_t swapped_carrier;
 
+#ifdef DEBUG
+    int i;
+
+    /* Verify that all locks share the same categories/static property; all
+     * other flags are fair game. */
+    for(i = 1; i < carrier->entry_count; i++) {
+        const erts_lock_flags_t SIGNIFICANT_DIFF_MASK =
+            ERTS_LOCK_FLAGS_MASK_CATEGORY | ERTS_LOCK_FLAGS_PROPERTY_STATIC;
+
+        erts_lcnt_lock_info_t *previous, *current;
+
+        previous = &carrier->entries[i - 1];
+        current = &carrier->entries[i];
+
+        ASSERT(!((previous->flags ^ current->flags) & SIGNIFICANT_DIFF_MASK));
+    }
+#endif
+
     swapped_carrier = ethr_atomic_cmpxchg_mb(ref, (ethr_sint_t)carrier, (ethr_sint_t)NULL);
 
     if(swapped_carrier != (ethr_sint_t)NULL) {
@@ -394,7 +387,7 @@ void erts_lcnt_install(erts_lcnt_ref_t *ref, erts_lcnt_lock_info_carrier_t *carr
         ethr_atomic_set(&carrier->ref_count, 0);
 #endif
 
-        carrier->deallocate(carrier);
+        lcnt_deallocate_carrier__(carrier);
     } else {
         lcnt_insert_list_carrier(&lcnt_current_lock_list, carrier);
     }
@@ -411,6 +404,61 @@ void erts_lcnt_uninstall(erts_lcnt_ref_t *ref) {
     }
 }
 
+/* - Static lock registry -
+ *
+ * Since static locks can be trusted to never disappear, we can track them
+ * pretty cheaply and won't need to bother writing an "erts_lcnt_update_xx"
+ * variant. */
+
+static void lcnt_init_static_lock_registry(void) {
+    ethr_atomic_init(&lcnt_static_lock_registry, (ethr_sint_t)NULL);
+}
+
+static void lcnt_update_static_locks(void) {
+    lcnt_static_lock_ref_t *iterator =
+        (lcnt_static_lock_ref_t*)ethr_atomic_read(&lcnt_static_lock_registry);
+
+    while(iterator != NULL) {
+        if(!erts_lcnt_check_enabled(iterator->flags)) {
+            erts_lcnt_uninstall(iterator->reference);
+        } else if(!erts_lcnt_check_ref_installed(iterator->reference)) {
+            erts_lcnt_lock_info_carrier_t *carrier = erts_lcnt_create_lock_info_carrier(1);
+
+            erts_lcnt_init_lock_info_idx(carrier, 0, iterator->name, iterator->id, iterator->flags);
+
+            erts_lcnt_install(iterator->reference, carrier);
+        }
+
+        iterator = iterator->next;
+    }
+}
+
+void lcnt_register_static_lock__(erts_lcnt_ref_t *reference, const char *name, Eterm id,
+                                 erts_lock_flags_t flags) {
+    lcnt_static_lock_ref_t *lock = malloc(sizeof(lcnt_static_lock_ref_t));
+    int retry_insertion;
+
+    ASSERT(flags & ERTS_LOCK_FLAGS_PROPERTY_STATIC);
+
+    lock->reference = reference;
+    lock->flags = flags;
+    lock->name = name;
+    lock->id = id;
+
+    do {
+        ethr_sint_t swapped_head;
+
+        lock->next = (lcnt_static_lock_ref_t*)ethr_atomic_read(&lcnt_static_lock_registry);
+
+        swapped_head = ethr_atomic_cmpxchg_acqb(
+            &lcnt_static_lock_registry,
+            (ethr_sint_t)lock,
+            (ethr_sint_t)lock->next);
+
+        retry_insertion = (swapped_head != (ethr_sint_t)lock->next);
+    } while(retry_insertion);
+}
+
 /* - Initialization - */
 
 void erts_lcnt_pre_thr_init() {
@@ -422,6 +470,8 @@ void erts_lcnt_pre_thr_init() {
 
     lcnt_init_list(&lcnt_current_lock_list);
     lcnt_init_list(&lcnt_deleted_lock_list);
+
+    lcnt_init_static_lock_registry();
 }
 
 void erts_lcnt_post_thr_init() {
@@ -438,8 +488,16 @@ void erts_lcnt_late_init() {
     erts_lcnt_clear_counters();
     erts_thr_install_exit_handler(erts_lcnt_thread_exit_handler);
 
+#ifdef DEBUG
     /* It's safe to use erts_alloc and thread progress past this point. */
     lcnt_initialization_completed__ = 1;
+#endif
+}
+
+void erts_lcnt_post_startup(void) {
+    /* Default to capturing everything to match the behavior of the old lock
+     * counter build. */
+    erts_lcnt_set_category_mask(ERTS_LOCK_FLAGS_MASK_CATEGORY);
 }
 
 void erts_lcnt_thread_setup() {
@@ -492,18 +550,74 @@ void erts_lcnt_release_lock_info(erts_lcnt_lock_info_t *info) {
     }
 }
 
-Uint16 erts_lcnt_set_rt_opt(Uint16 opt) {
-    Uint16 prev;
-    prev = (erts_lcnt_rt_options & opt);
-    erts_lcnt_rt_options |= opt;
-    return prev;
+erts_lock_flags_t erts_lcnt_get_category_mask() {
+    return lcnt_category_mask__;
 }
 
-Uint16 erts_lcnt_clear_rt_opt(Uint16 opt) {
-    Uint16 prev;
-    prev = (erts_lcnt_rt_options & opt);
-    erts_lcnt_rt_options &= ~opt;
-    return prev;
+#ifdef ERTS_ENABLE_KERNEL_POLL
+/* erl_poll/erl_check_io only exports one of these variants at a time, and we
+ * may need to use either one depending on emulator startup flags. */
+void erts_lcnt_update_pollset_locks_nkp(int);
+void erts_lcnt_update_pollset_locks_kp(int);
+
+void erts_lcnt_update_cio_locks_nkp(int);
+void erts_lcnt_update_cio_locks_kp(int);
+#endif
+
+void erts_lcnt_set_category_mask(erts_lock_flags_t mask) {
+    erts_lock_flags_t changed_categories;
+
+    ASSERT(!(mask & ~ERTS_LOCK_FLAGS_MASK_CATEGORY));
+    ASSERT(lcnt_initialization_completed__);
+
+    changed_categories = (lcnt_category_mask__ ^ mask);
+    lcnt_category_mask__ = mask;
+
+    if(changed_categories) {
+        lcnt_update_static_locks();
+    }
+
+    if(changed_categories & ERTS_LOCK_FLAGS_CATEGORY_DISTRIBUTION) {
+        erts_lcnt_update_distribution_locks(mask & ERTS_LOCK_FLAGS_CATEGORY_DISTRIBUTION);
+    }
+
+    if(changed_categories & ERTS_LOCK_FLAGS_CATEGORY_ALLOCATOR) {
+        erts_lcnt_update_allocator_locks(mask & ERTS_LOCK_FLAGS_CATEGORY_ALLOCATOR);
+    }
+
+    if(changed_categories & ERTS_LOCK_FLAGS_CATEGORY_PROCESS) {
+        erts_lcnt_update_process_locks(mask & ERTS_LOCK_FLAGS_CATEGORY_PROCESS);
+    }
+
+    if(changed_categories & ERTS_LOCK_FLAGS_CATEGORY_IO) {
+#ifdef ERTS_ENABLE_KERNEL_POLL
+        if(erts_use_kernel_poll) {
+            erts_lcnt_update_pollset_locks_kp(mask & ERTS_LOCK_FLAGS_CATEGORY_IO);
+            erts_lcnt_update_cio_locks_kp(mask & ERTS_LOCK_FLAGS_CATEGORY_IO);
+        } else {
+            erts_lcnt_update_pollset_locks_nkp(mask & ERTS_LOCK_FLAGS_CATEGORY_IO);
+            erts_lcnt_update_cio_locks_nkp(mask & ERTS_LOCK_FLAGS_CATEGORY_IO);
+        }
+#else
+        erts_lcnt_update_pollset_locks(mask & ERTS_LOCK_FLAGS_CATEGORY_IO);
+        erts_lcnt_update_cio_locks(mask & ERTS_LOCK_FLAGS_CATEGORY_IO);
+#endif
+
+        erts_lcnt_update_driver_locks(mask & ERTS_LOCK_FLAGS_CATEGORY_IO);
+        erts_lcnt_update_port_locks(mask & ERTS_LOCK_FLAGS_CATEGORY_IO);
+    }
+
+    if(changed_categories & ERTS_LOCK_FLAGS_CATEGORY_DB) {
+        erts_lcnt_update_db_locks(mask & ERTS_LOCK_FLAGS_CATEGORY_DB);
+    }
+}
+
+void erts_lcnt_set_preserve_info(int enable) {
+    lcnt_preserve_info = enable;
+}
+
+int erts_lcnt_get_preserve_info() {
+    return lcnt_preserve_info;
 }
 
 void erts_lcnt_clear_counters(void) {
@@ -538,17 +652,6 @@ erts_lcnt_data_t erts_lcnt_get_data(void) {
     return result;
 }
 
-const char *erts_lcnt_lock_type(Uint16 type) {
-    switch(type & ERTS_LCNT_LT_ALL) {
-        case ERTS_LCNT_LT_SPINLOCK:   return "spinlock";
-        case ERTS_LCNT_LT_RWSPINLOCK: return "rw_spinlock";
-        case ERTS_LCNT_LT_MUTEX:      return "mutex";
-        case ERTS_LCNT_LT_RWMUTEX:    return "rw_mutex";
-        case ERTS_LCNT_LT_PROCLOCK:   return "proclock";
-        default:                      return "";
-    }
-}
-
 int erts_lcnt_iterate_list(erts_lcnt_lock_info_list_t *list, erts_lcnt_lock_info_t **iterator) {
     erts_lcnt_lock_info_t *current, *next;
 
diff --git a/erts/emulator/beam/erl_lock_count.h b/erts/emulator/beam/erl_lock_count.h
index c89dfcba47..3181dbcad4 100644
--- a/erts/emulator/beam/erl_lock_count.h
+++ b/erts/emulator/beam/erl_lock_count.h
@@ -43,17 +43,7 @@
  *
  * Each instance of a lock is the unique lock, i.e. set and id in that set.
  * For each lock there is a set of statistics with where and what impact
- * the lock aqusition had.
- *
- * Runtime options:
- * - location, reserved and not used.
- * - proclock, disable proclock counting. Used when performance might be an
- *   issue. Accessible from erts_debug:lock_counters({process_locks, bool()}).
- *   Default: off.
- * - copysave, enable saving of destroyed locks (and thereby its statistics).
- *   If memory constraints is an issue this need to be disabled.
- *   Accessible from erts_debug:lock_counters({copy_save, bool()}).
- *   Default: off.
+ * the lock acquisition had.
  */
 
 #ifndef ERTS_LOCK_COUNT_H__
@@ -67,11 +57,12 @@
 
 #include "sys.h"
 #include "ethread.h"
+
 #include "erl_term.h"
+#include "erl_lock_flags.h"
 
-#define ERTS_LCNT_MAX_LOCK_LOCATIONS  (10)
+#define ERTS_LCNT_MAX_LOCK_LOCATIONS  (5)
 
-/* histogram */
 #define ERTS_LCNT_HISTOGRAM_MAX_NS    (((unsigned long)1LL << 28) - 1)
 #if 0 || defined(ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT)
 #define ERTS_LCNT_HISTOGRAM_SLOT_SIZE (30)
@@ -81,34 +72,6 @@
 #define ERTS_LCNT_HISTOGRAM_RSHIFT    (10)
 #endif
 
-#define ERTS_LCNT_LT_SPINLOCK   (((Uint16) 1) << 0)
-#define ERTS_LCNT_LT_RWSPINLOCK (((Uint16) 1) << 1)
-#define ERTS_LCNT_LT_MUTEX      (((Uint16) 1) << 2)
-#define ERTS_LCNT_LT_RWMUTEX    (((Uint16) 1) << 3)
-#define ERTS_LCNT_LT_PROCLOCK   (((Uint16) 1) << 4)
-#define ERTS_LCNT_LT_ALLOC      (((Uint16) 1) << 5)
-
-#define ERTS_LCNT_LO_READ       (((Uint16) 1) << 6)
-#define ERTS_LCNT_LO_WRITE      (((Uint16) 1) << 7)
-
-#define ERTS_LCNT_LT_DISABLE    (((Uint16) 1) << 8)
-
-#define ERTS_LCNT_LO_READ_WRITE ( ERTS_LCNT_LO_READ  \
-                                | ERTS_LCNT_LO_WRITE )
-
-#define ERTS_LCNT_LT_ALL        ( ERTS_LCNT_LT_SPINLOCK   \
-                                | ERTS_LCNT_LT_RWSPINLOCK \
-                                | ERTS_LCNT_LT_MUTEX      \
-                                | ERTS_LCNT_LT_RWMUTEX    \
-                                | ERTS_LCNT_LT_PROCLOCK   )
-
-/* Runtime options */
-
-#define ERTS_LCNT_OPT_LOCATION (((Uint16) 1) << 1)
-#define ERTS_LCNT_OPT_PROCLOCK (((Uint16) 1) << 2)
-#define ERTS_LCNT_OPT_PORTLOCK (((Uint16) 1) << 3)
-#define ERTS_LCNT_OPT_COPYSAVE (((Uint16) 1) << 4)
-
 typedef struct {
     unsigned long s;
     unsigned long ns;
@@ -139,9 +102,10 @@ typedef struct {
 } erts_lcnt_lock_stats_t;
 
 typedef struct lcnt_lock_info_t_ {
-    const char *name; /**< Lock name */
-    Uint16 flag;      /**< Lock type */
-    Eterm id;         /**< Id if possible, must be an immediate */
+    erts_lock_flags_t flags;
+    const char *name;
+    /** @brief Id if possible, must be an immediate */
+    Eterm id;
 
     /* The first entry is reserved as a fallback for when location information
      * is missing, and when the lock is used in more than (MAX_LOCK_LOCATIONS
@@ -158,15 +122,6 @@ typedef struct lcnt_lock_info_t_ {
     /** @brief Read state. 0 = not taken, > 0 -> writes will wait */
     ethr_atomic_t r_state;
 
-#ifdef LCNT_DEBUG_LOCK_FLOW
-    /** @brief Tracks lock/unlock operations. This will explode if the lock is
-     * held at the time lock counting is installed.
-     *
-     * Avoid enabling existing locks at runtime while running in this
-     * configuration. */
-    ethr_atomic_t flowstate;
-#endif
-
     struct lcnt_lock_info_t_ *prev;
     struct lcnt_lock_info_t_ *next;
 
@@ -200,7 +155,10 @@ typedef ethr_atomic_t erts_lcnt_ref_t;
 
 /* -- Globals -------------------------------------------------------------- */
 
-extern Uint16 erts_lcnt_rt_options;
+/** @brief Checks whether counting is enabled for any of the given
+ * categories. */
+#define erts_lcnt_check_enabled(flags) \
+    (lcnt_category_mask__ & flags)
 
 /* -- Lock operations ------------------------------------------------------
  *
@@ -259,12 +217,6 @@ void erts_lcnt_trylock_opt(erts_lcnt_ref_t *ref, int result, Uint16 option);
  *
  * Refer to \c erts_lcnt_lock for example usage. */
 
-ERTS_GLB_FORCE_INLINE
-int erts_lcnt_open_ref(erts_lcnt_ref_t *ref, int *handle, erts_lcnt_lock_info_carrier_t **result);
-
-ERTS_GLB_FORCE_INLINE
-void erts_lcnt_close_ref(int handle, erts_lcnt_lock_info_carrier_t *carrier);
-
 ERTS_GLB_INLINE
 void erts_lcnt_lock_idx(erts_lcnt_lock_info_carrier_t *carrier, int index);
 ERTS_GLB_INLINE
@@ -290,22 +242,43 @@ void erts_lcnt_trylock_opt_idx(erts_lcnt_lock_info_carrier_t *carrier, int index
 
 /* -- Reference operations ------------------------------------------------- */
 
-erts_lcnt_lock_info_carrier_t *erts_lcnt_create_lock_info_carrier(int count);
-
-/** @brief Fills in the name and lock type of the given index. */
-#define erts_lcnt_init_lock_info_idx(carrier, index, name, flag) \
-    erts_lcnt_init_lock_info_x_idx(carrier, index, name, flag, NIL)
+/** @brief Registers a lock counter reference; this must be called prior to
+ * using any other functions in this module. */
+ERTS_GLB_INLINE
+void erts_lcnt_init_ref(erts_lcnt_ref_t *ref);
 
-/** @copydoc erts_lcnt_install_new_lock_info
+/** @brief As \c erts_lcnt_init_ref, but also enables lock counting right
+ * away if appropriate to reduce noise.
  * @param id An immediate erlang term with whatever extra data you want to
  * identify this lock with. */
 ERTS_GLB_INLINE
-void erts_lcnt_init_lock_info_x_idx(erts_lcnt_lock_info_carrier_t *carrier, int index,
-    const char *name, Uint16 flag, Eterm id);
+void erts_lcnt_init_ref_x(erts_lcnt_ref_t *ref, const char *name,
+    Eterm id, erts_lock_flags_t flags);
 
-/** @brief Initializes a lock counter reference; this must be called prior to
- * using any other functions in this module. */
-#define erts_lcnt_init_ref(ref) ethr_atomic_init(ref, (ethr_sint_t)NULL);
+/** @brief Checks whether counting is enabled on the given reference. */
+ERTS_GLB_FORCE_INLINE
+int erts_lcnt_check_ref_installed(erts_lcnt_ref_t *ref);
+
+/** @brief Convenience macro to re/enable counting on an already initialized
+ * reference. Don't forget to specify the lock type in \c flags! */
+#define erts_lcnt_install_new_lock_info(ref, name, id, flags) \
+    if(!erts_lcnt_check_ref_installed(ref)) { \
+        erts_lcnt_lock_info_carrier_t *__carrier; \
+        __carrier = erts_lcnt_create_lock_info_carrier(1);\
+        erts_lcnt_init_lock_info_idx(__carrier, 0, name, id, flags); \
+        erts_lcnt_install(ref, __carrier);\
+    } while(0)
+
+erts_lcnt_lock_info_carrier_t *erts_lcnt_create_lock_info_carrier(int count);
+
+/* @brief Initializes the lock info at the given index.
+ * @param id An immediate erlang term with whatever extra data you want to
+ * identify this lock with.
+ * @param flags The flags the lock itself was initialized with. Keep in mind
+ * that all locks in a carrier must share the same category/static property. */
+ERTS_GLB_INLINE
+void erts_lcnt_init_lock_info_idx(erts_lcnt_lock_info_carrier_t *carrier, int index,
+    const char *name, Eterm id, erts_lock_flags_t flags);
 
 /** @brief Atomically installs the given lock counters. Nops (and releases the
  * provided carrier) if something was already installed. */
@@ -315,21 +288,11 @@ void erts_lcnt_install(erts_lcnt_ref_t *ref, erts_lcnt_lock_info_carrier_t *carr
  * nothing was installed. */
 void erts_lcnt_uninstall(erts_lcnt_ref_t *ref);
 
-/** @brief Convenience macro to install a single lock counter of the given
- * name and type. */
-#define erts_lcnt_install_new_lock_info(reference, name, flag) \
-    erts_lcnt_install_new_lock_info_x(reference, name, flag, NIL)
+ERTS_GLB_FORCE_INLINE
+int erts_lcnt_open_ref(erts_lcnt_ref_t *ref, int *handle, erts_lcnt_lock_info_carrier_t **result);
 
-/** @copydoc erts_lcnt_install_new_lock_info
- * @param id An immediate erlang term with whatever extra data you want to
- * identify this lock with. */
-#define erts_lcnt_install_new_lock_info_x(reference, name, flag, id) \
-    do { \
-        erts_lcnt_lock_info_carrier_t *__carrier; \
-        __carrier = erts_lcnt_create_lock_info_carrier(1); \
-        erts_lcnt_init_lock_info_x_idx(__carrier, 0, name, flag, id); \
-        erts_lcnt_install(reference, __carrier); \
-    } while(0)
+ERTS_GLB_FORCE_INLINE
+void erts_lcnt_close_ref(int handle, erts_lcnt_lock_info_carrier_t *carrier);
 
 /* -- Module initialization ------------------------------------------------ */
 
@@ -337,6 +300,11 @@ void erts_lcnt_pre_thr_init(void);
 void erts_lcnt_post_thr_init(void);
 void erts_lcnt_late_init(void);
 
+/* @brief Called after everything in the system has been initialized, including
+ * the schedulers. This is mainly a backwards compatibility shim for matching
+ * the old lcnt behavior where all lock counting was enabled by default. */
+void erts_lcnt_post_startup(void);
+
 void erts_lcnt_thread_setup(void);
 void erts_lcnt_thread_exit_handler(void);
 
@@ -357,7 +325,7 @@ void erts_lcnt_thread_exit_handler(void);
 int erts_lcnt_iterate_list(erts_lcnt_lock_info_list_t *list, erts_lcnt_lock_info_t **iterator);
 
 /** @brief Clears the counter state of all locks, and releases all locks
- * preserved through ERTS_LCNT_OPT_COPYSAVE (if any). */
+ * preserved through erts_lcnt_set_preserve_info (if any). */
 void erts_lcnt_clear_counters(void);
 
 /** @brief Retrieves the global lock counter state.
@@ -369,10 +337,24 @@ erts_lcnt_data_t erts_lcnt_get_data(void);
 void erts_lcnt_retain_lock_info(erts_lcnt_lock_info_t *info);
 void erts_lcnt_release_lock_info(erts_lcnt_lock_info_t *info);
 
-Uint16 erts_lcnt_set_rt_opt(Uint16 opt);
-Uint16 erts_lcnt_clear_rt_opt(Uint16 opt);
+/** @brief Sets whether to preserve the info of destroyed/uninstalled locks.
+ *
+ * This option makes no distinction whether the lock was destroyed or if lock
+ * counting was simply disabled, so erts_lcnt_set_category_mask must not be
+ * used while this option is active. */
+void erts_lcnt_set_preserve_info(int enable);
 
-const char *erts_lcnt_lock_type(Uint16 type);
+int erts_lcnt_get_preserve_info(void);
+
+/** @brief Updates the category mask, enabling or disabling counting on the
+ * affected locks as necessary.
+ *
+ * This is not guaranteed to find all existing locks; only those that are
+ * flagged as static locks and those reachable through other means can be
+ * altered. */
+void erts_lcnt_set_category_mask(erts_lock_flags_t mask);
+
+erts_lock_flags_t erts_lcnt_get_category_mask(void);
 
 /* -- Inline implementation ------------------------------------------------ */
 
@@ -390,8 +372,6 @@ typedef struct { Uint64 _[4]; } LcntThrPrgrLaterOp;
 struct lcnt_lock_info_carrier_ {
     ethr_atomic_t ref_count;
 
-    void (*deallocate)(struct lcnt_lock_info_carrier_ *);
-
     LcntThrPrgrLaterOp release_entries;
 
     unsigned char entry_count;
@@ -404,14 +384,19 @@ typedef struct {
     int lock_in_conflict;   /* bool */
 } lcnt_thread_data_t__;
 
+extern const int lcnt_log2_tab64__[];
+
 extern ethr_tsd_key lcnt_thr_data_key__;
+extern erts_lock_flags_t lcnt_category_mask__;
 
-/** @brief Some operations (eg erts_alloc or erts_thr_progress_unmanaged_delay)
- * are unsafe in the early stages of initialization, so we're using this flag
- * to know when we can move over to normal operation. */
+#ifdef DEBUG
 extern int lcnt_initialization_completed__;
+#endif
 
-extern const int lcnt_log2_tab64__[];
+void lcnt_register_static_lock__(erts_lcnt_ref_t *reference, const char *name, Eterm id,
+    erts_lock_flags_t flags);
+
+void lcnt_deallocate_carrier__(erts_lcnt_lock_info_carrier_t *carrier);
 
 ERTS_GLB_INLINE
 int lcnt_log2__(Uint64 v);
@@ -557,29 +542,27 @@ void lcnt_dec_lock_state__(ethr_atomic_t *l_state) {
 
 ERTS_GLB_INLINE
 erts_lcnt_lock_stats_t *lcnt_get_lock_stats__(erts_lcnt_lock_info_t *info, char *file, unsigned int line) {
-    ASSERT(info->location_count >= 1 && info->location_count <= ERTS_LCNT_MAX_LOCK_LOCATIONS);
+    unsigned int i;
 
-    if(erts_lcnt_rt_options & ERTS_LCNT_OPT_LOCATION) {
-        unsigned int i;
+    ASSERT(info->location_count >= 1 && info->location_count <= ERTS_LCNT_MAX_LOCK_LOCATIONS);
 
-        for(i = 0; i < info->location_count; i++) {
-            erts_lcnt_lock_stats_t *stats = &info->location_stats[i];
+    for(i = 0; i < info->location_count; i++) {
+        erts_lcnt_lock_stats_t *stats = &info->location_stats[i];
 
-            if(stats->file == file && stats->line == line) {
-                return stats;
-            }
+        if(stats->file == file && stats->line == line) {
+            return stats;
         }
+    }
 
-        if(info->location_count < ERTS_LCNT_MAX_LOCK_LOCATIONS) {
-            erts_lcnt_lock_stats_t *stats = &info->location_stats[info->location_count];
+    if(info->location_count < ERTS_LCNT_MAX_LOCK_LOCATIONS) {
+        erts_lcnt_lock_stats_t *stats = &info->location_stats[info->location_count];
 
-            stats->file = file;
-            stats->line = line;
+        stats->file = file;
+        stats->line = line;
 
-            info->location_count++;
+        info->location_count++;
 
-            return stats;
-        }
+        return stats;
     }
 
     return &info->location_stats[0];
@@ -596,10 +579,12 @@ lcnt_thread_data_t__ *lcnt_get_thread_data__(void) {
 
 ERTS_GLB_FORCE_INLINE
 int erts_lcnt_open_ref(erts_lcnt_ref_t *ref, int *handle, erts_lcnt_lock_info_carrier_t **result) {
-    if(!*ethr_atomic_addr(ref) || !lcnt_initialization_completed__) {
+    if(ERTS_LIKELY(!erts_lcnt_check_ref_installed(ref))) {
         return 0;
     }
 
+    ASSERT(lcnt_initialization_completed__);
+
     (*handle) = lcnt_thr_progress_unmanaged_delay__();
     (*result) = (erts_lcnt_lock_info_carrier_t*)ethr_atomic_read(ref);
 
@@ -624,6 +609,30 @@ void erts_lcnt_close_ref(int handle, erts_lcnt_lock_info_carrier_t *carrier) {
     }
 }
 
+ERTS_GLB_INLINE
+void erts_lcnt_init_ref(erts_lcnt_ref_t *ref) {
+    ethr_atomic_init(ref, (ethr_sint_t)NULL);
+}
+
+ERTS_GLB_INLINE
+void erts_lcnt_init_ref_x(erts_lcnt_ref_t *ref, const char *name,
+                          Eterm id, erts_lock_flags_t flags) {
+    erts_lcnt_init_ref(ref);
+
+    if(flags & ERTS_LOCK_FLAGS_PROPERTY_STATIC) {
+        lcnt_register_static_lock__(ref, name, id, flags);
+    }
+
+    if(erts_lcnt_check_enabled(flags)) {
+        erts_lcnt_install_new_lock_info(ref, name, id, flags);
+    }
+}
+
+ERTS_GLB_FORCE_INLINE
+int erts_lcnt_check_ref_installed(erts_lcnt_ref_t *ref) {
+    return (!!*ethr_atomic_addr(ref));
+}
+
 ERTS_GLB_FORCE_INLINE
 void erts_lcnt_lock(erts_lcnt_ref_t *ref) {
     erts_lcnt_lock_info_carrier_t *carrier;
@@ -734,7 +743,7 @@ void erts_lcnt_trylock_opt(erts_lcnt_ref_t *ref, int result, Uint16 option) {
 
 ERTS_GLB_INLINE
 void erts_lcnt_lock_idx(erts_lcnt_lock_info_carrier_t *carrier, int index) {
-    erts_lcnt_lock_opt_idx(carrier, index, ERTS_LCNT_LO_WRITE);
+    erts_lcnt_lock_opt_idx(carrier, index, ERTS_LOCK_OPTION_WRITE);
 }
 
 ERTS_GLB_INLINE
@@ -745,9 +754,9 @@ void erts_lcnt_lock_opt_idx(erts_lcnt_lock_info_carrier_t *carrier, int index, U
 
     ASSERT(index < carrier->entry_count);
 
-    ASSERT((option & ERTS_LCNT_LO_READ) || (option & ERTS_LCNT_LO_WRITE));
+    ASSERT((option & ERTS_LOCK_OPTION_READ) || (option & ERTS_LOCK_OPTION_WRITE));
 
-    if(option & ERTS_LCNT_LO_WRITE) {
+    if(option & ERTS_LOCK_OPTION_WRITE) {
         ethr_sint_t w_state, r_state;
 
         w_state = ethr_atomic_inc_read(&info->w_state) - 1;
@@ -762,7 +771,8 @@ void erts_lcnt_lock_opt_idx(erts_lcnt_lock_info_carrier_t *carrier, int index, U
         eltd->lock_in_conflict = (w_state > 0);
     }
 
-    if(option & ERTS_LCNT_LO_READ) {
+    if(option & ERTS_LOCK_OPTION_READ) {
+        ASSERT(info->flags & ERTS_LOCK_FLAGS_PROPERTY_READ_WRITE);
         ethr_atomic_inc(&info->r_state);
     }
 
@@ -792,12 +802,6 @@ void erts_lcnt_lock_post_x_idx(erts_lcnt_lock_info_carrier_t *carrier, int index
 
     ASSERT(index < carrier->entry_count);
 
-#ifdef LCNT_DEBUG_LOCK_FLOW
-    if(!(info->flag & (ERTS_LCNT_LT_RWMUTEX | ERTS_LCNT_LT_RWSPINLOCK))) {
-        ASSERT(ethr_atomic_inc_read(&info->flowstate) == 1);
-    }
-#endif
-
     /* If the lock was in conflict, update the time spent waiting. */
     stats = lcnt_get_lock_stats__(info, file, line);
     if(eltd->timer_set) {
@@ -819,15 +823,9 @@ void erts_lcnt_lock_post_x_idx(erts_lcnt_lock_info_carrier_t *carrier, int index
 
 ERTS_GLB_INLINE
 void erts_lcnt_unlock_idx(erts_lcnt_lock_info_carrier_t *carrier, int index) {
-#ifdef LCNT_DEBUG_LOCK_FLOW
-    erts_lcnt_lock_info_t *info = &carrier->entries[index];
-
-    ASSERT(ethr_atomic_dec_read(&info->flowstate) == 0);
-#endif
-
     ASSERT(index < carrier->entry_count);
 
-    erts_lcnt_unlock_opt_idx(carrier, index, ERTS_LCNT_LO_WRITE);
+    erts_lcnt_unlock_opt_idx(carrier, index, ERTS_LOCK_OPTION_WRITE);
 }
 
 ERTS_GLB_INLINE
@@ -836,13 +834,14 @@ void erts_lcnt_unlock_opt_idx(erts_lcnt_lock_info_carrier_t *carrier, int index,
 
     ASSERT(index < carrier->entry_count);
 
-    ASSERT((option & ERTS_LCNT_LO_READ) || (option & ERTS_LCNT_LO_WRITE));
+    ASSERT((option & ERTS_LOCK_OPTION_READ) || (option & ERTS_LOCK_OPTION_WRITE));
 
-    if(option & ERTS_LCNT_LO_WRITE) {
+    if(option & ERTS_LOCK_OPTION_WRITE) {
         lcnt_dec_lock_state__(&info->w_state);
     }
 
-    if(option & ERTS_LCNT_LO_READ) {
+    if(option & ERTS_LOCK_OPTION_READ) {
+        ASSERT(info->flags & ERTS_LOCK_FLAGS_PROPERTY_READ_WRITE);
         lcnt_dec_lock_state__(&info->r_state);
     }
 }
@@ -858,15 +857,9 @@ void erts_lcnt_lock_unacquire_idx(erts_lcnt_lock_info_carrier_t *carrier, int in
 
 ERTS_GLB_INLINE
 void erts_lcnt_trylock_idx(erts_lcnt_lock_info_carrier_t *carrier, int index, int result) {
-#ifdef LCNT_DEBUG_LOCK_FLOW
-    erts_lcnt_lock_info_t *info = &carrier->entries[index];
-
-    ASSERT(result == EBUSY || ethr_atomic_inc_read(&info->flowstate) == 1);
-#endif
-
     ASSERT(index < carrier->entry_count);
 
-    erts_lcnt_trylock_opt_idx(carrier, index, result, ERTS_LCNT_LO_WRITE);
+    erts_lcnt_trylock_opt_idx(carrier, index, result, ERTS_LOCK_OPTION_WRITE);
 }
 
 ERTS_GLB_INLINE
@@ -875,14 +868,15 @@ void erts_lcnt_trylock_opt_idx(erts_lcnt_lock_info_carrier_t *carrier, int index
 
     ASSERT(index < carrier->entry_count);
 
-    ASSERT((option & ERTS_LCNT_LO_READ) || (option & ERTS_LCNT_LO_WRITE));
+    ASSERT((option & ERTS_LOCK_OPTION_READ) || (option & ERTS_LOCK_OPTION_WRITE));
 
     if(result != EBUSY) {
-        if(option & ERTS_LCNT_LO_WRITE) {
+        if(option & ERTS_LOCK_OPTION_WRITE) {
             ethr_atomic_inc(&info->w_state);
         }
 
-        if(option & ERTS_LCNT_LO_READ) {
+        if(option & ERTS_LOCK_OPTION_READ) {
+            ASSERT(info->flags & ERTS_LOCK_FLAGS_PROPERTY_READ_WRITE);
             ethr_atomic_inc(&info->r_state);
         }
 
@@ -894,13 +888,16 @@ void erts_lcnt_trylock_opt_idx(erts_lcnt_lock_info_carrier_t *carrier, int index
 }
 
 ERTS_GLB_INLINE
-void erts_lcnt_init_lock_info_x_idx(erts_lcnt_lock_info_carrier_t *carrier, int index,
-                                    const char *name, Uint16 flag, Eterm id) {
+void erts_lcnt_init_lock_info_idx(erts_lcnt_lock_info_carrier_t *carrier, int index,
+                                  const char *name, Eterm id, erts_lock_flags_t flags) {
     erts_lcnt_lock_info_t *info = &carrier->entries[index];
 
     ASSERT(is_immed(id));
 
-    info->flag = flag;
+    ASSERT(flags & ERTS_LOCK_FLAGS_MASK_TYPE);
+    ASSERT(flags & ERTS_LOCK_FLAGS_MASK_CATEGORY);
+
+    info->flags = flags;
     info->name = name;
     info->id = id;
 }
@@ -921,7 +918,7 @@ void lcnt_release_carrier__(erts_lcnt_lock_info_carrier_t *carrier) {
     ASSERT(count >= 0);
 
     if(count == 0) {
-        carrier->deallocate(carrier);
+        lcnt_deallocate_carrier__(carrier);
     }
 }
 
diff --git a/erts/emulator/beam/erl_msacc.c b/erts/emulator/beam/erl_msacc.c
index 2d70f0d874..6c477be615 100644
--- a/erts/emulator/beam/erl_msacc.c
+++ b/erts/emulator/beam/erl_msacc.c
@@ -76,7 +76,8 @@ void erts_msacc_early_init(void) {
 #ifndef ERTS_MSACC_ALWAYS_ON
     erts_msacc_enabled = 0;
 #endif
-    erts_rwmtx_init(&msacc_mutex,"msacc_list_mutex");
+    erts_rwmtx_init(&msacc_mutex, "msacc_list_mutex", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_DEBUG);
 #ifdef USE_THREADS
     erts_tsd_key_create(&erts_msacc_key,"erts_msacc_key");
 #else
@@ -109,7 +110,8 @@ void erts_msacc_init_thread(char *type, int id, int managed) {
 #ifdef USE_THREADS
     erts_rwmtx_rwlock(&msacc_mutex);
     if (!managed) {
-        erts_mtx_init(&msacc->mtx,"msacc_unmanaged_mutex");
+        erts_mtx_init(&msacc->mtx, "msacc_unmanaged_mutex", NIL,
+            ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_DEBUG);
         msacc->next = msacc_unmanaged;
         msacc_unmanaged = msacc;
         msacc_unmanaged_count++;
diff --git a/erts/emulator/beam/erl_mtrace.c b/erts/emulator/beam/erl_mtrace.c
index 19bb7d5b31..f2a660f085 100644
--- a/erts/emulator/beam/erl_mtrace.c
+++ b/erts/emulator/beam/erl_mtrace.c
@@ -583,8 +583,10 @@ void erts_mtrace_init(char *receiver, char *nodename)
 	byte ip_addr[4];
 	Uint16 port;
 
-	erts_mtx_init(&mtrace_buf_mutex, "mtrace_buf");
-	erts_mtx_init(&mtrace_op_mutex, "mtrace_op");
+        erts_mtx_init(&mtrace_buf_mutex, "mtrace_buf", NIL,
+            ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_DEBUG);
+        erts_mtx_init(&mtrace_op_mutex, "mtrace_op", NIL,
+            ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_DEBUG);
 
 	socket_desc = erts_sock_open();
 	if (socket_desc == ERTS_SOCK_INVALID_SOCKET) {
diff --git a/erts/emulator/beam/erl_nif.c b/erts/emulator/beam/erl_nif.c
index ea835d1b64..399626de74 100644
--- a/erts/emulator/beam/erl_nif.c
+++ b/erts/emulator/beam/erl_nif.c
@@ -2398,7 +2398,8 @@ void* enif_alloc_resource(ErlNifResourceType* type, size_t data_sz)
     erts_refc_inc(&resource->type->refc, 2);
     if (type->down) {
         resource->monitors = (ErtsResourceMonitors*) (resource->data + monitors_offs);
-        erts_smp_mtx_init(&resource->monitors->lock, "resource_monitors");
+        erts_smp_mtx_init(&resource->monitors->lock, "resource_monitors", NIL,
+            ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
         resource->monitors->root = NULL;
         resource->monitors->pending_failed_fire = 0;
         resource->monitors->is_dying = 0;
diff --git a/erts/emulator/beam/erl_node_tables.c b/erts/emulator/beam/erl_node_tables.c
index 3c5945d48d..deadf435e9 100644
--- a/erts/emulator/beam/erl_node_tables.c
+++ b/erts/emulator/beam/erl_node_tables.c
@@ -85,21 +85,20 @@ dist_table_cmp(void *dep1, void *dep2)
 static void*
 dist_table_alloc(void *dep_tmpl)
 {
-    Eterm chnl_nr;
     Eterm sysname;
     DistEntry *dep;
     erts_smp_rwmtx_opt_t rwmtx_opt = ERTS_SMP_RWMTX_OPT_DEFAULT_INITER;
     rwmtx_opt.type = ERTS_SMP_RWMTX_TYPE_FREQUENT_READ;
 
     sysname = ((DistEntry *) dep_tmpl)->sysname;
-    chnl_nr = make_small((Uint) atom_val(sysname));
     dep = (DistEntry *) erts_alloc(ERTS_ALC_T_DIST_ENTRY, sizeof(DistEntry));
 
     dist_entries++;
 
     dep->prev				= NULL;
     erts_smp_refc_init(&dep->refc, -1);
-    erts_smp_rwmtx_init_opt_x(&dep->rwmtx, &rwmtx_opt, "dist_entry", chnl_nr);
+    erts_smp_rwmtx_init_opt(&dep->rwmtx, &rwmtx_opt, "dist_entry", sysname,
+        ERTS_LOCK_FLAGS_CATEGORY_DISTRIBUTION);
     dep->sysname			= sysname;
     dep->cid				= NIL;
     dep->connection_id			= 0;
@@ -107,12 +106,14 @@ dist_table_alloc(void *dep_tmpl)
     dep->flags				= 0;
     dep->version			= 0;
 
-    erts_smp_mtx_init_x(&dep->lnk_mtx, "dist_entry_links", chnl_nr);
+    erts_smp_mtx_init(&dep->lnk_mtx, "dist_entry_links", sysname,
+        ERTS_LOCK_FLAGS_CATEGORY_DISTRIBUTION);
     dep->node_links			= NULL;
     dep->nlinks				= NULL;
     dep->monitors			= NULL;
 
-    erts_smp_mtx_init_x(&dep->qlock, "dist_entry_out_queue", chnl_nr);
+    erts_smp_mtx_init(&dep->qlock, "dist_entry_out_queue", sysname,
+        ERTS_LOCK_FLAGS_CATEGORY_DISTRIBUTION);
     dep->qflgs				= 0;
     dep->qsize				= 0;
     dep->out_queue.first		= NULL;
@@ -760,8 +761,10 @@ void erts_init_node_tables(int dd_sec)
     rwmtx_opt.type = ERTS_SMP_RWMTX_TYPE_FREQUENT_READ;
     rwmtx_opt.lived = ERTS_SMP_RWMTX_LONG_LIVED;
 
-    erts_smp_rwmtx_init_opt(&erts_node_table_rwmtx, &rwmtx_opt, "node_table");
-    erts_smp_rwmtx_init_opt(&erts_dist_table_rwmtx, &rwmtx_opt, "dist_table");
+    erts_smp_rwmtx_init_opt(&erts_node_table_rwmtx, &rwmtx_opt, "node_table", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_DISTRIBUTION);
+    erts_smp_rwmtx_init_opt(&erts_dist_table_rwmtx, &rwmtx_opt, "dist_table", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_DISTRIBUTION);
 
     f.hash       = (H_FUN)		dist_table_hash;
     f.cmp        = (HCMP_FUN)		dist_table_cmp;
@@ -818,6 +821,33 @@ int erts_lc_is_de_rlocked(DistEntry *dep)
 #endif
 #endif
 
+#ifdef ERTS_ENABLE_LOCK_COUNT
+
+static void erts_lcnt_enable_dist_lock_count(void *dep_raw, void *enable) {
+    DistEntry *dep = (DistEntry*)dep_raw;
+
+    if(enable) {
+        erts_lcnt_install_new_lock_info(&dep->rwmtx.lcnt, "dist_entry", dep->sysname, 
+            ERTS_LOCK_TYPE_RWMUTEX | ERTS_LOCK_FLAGS_CATEGORY_DISTRIBUTION);
+        erts_lcnt_install_new_lock_info(&dep->lnk_mtx.lcnt, "dist_entry_links", dep->sysname,
+            ERTS_LOCK_TYPE_MUTEX | ERTS_LOCK_FLAGS_CATEGORY_DISTRIBUTION);
+        erts_lcnt_install_new_lock_info(&dep->qlock.lcnt, "dist_entry_out_queue", dep->sysname,
+            ERTS_LOCK_TYPE_MUTEX | ERTS_LOCK_FLAGS_CATEGORY_DISTRIBUTION);
+    } else {
+        erts_lcnt_uninstall(&dep->rwmtx.lcnt);
+        erts_lcnt_uninstall(&dep->lnk_mtx.lcnt);
+        erts_lcnt_uninstall(&dep->qlock.lcnt);
+    }
+}
+
+void erts_lcnt_update_distribution_locks(int enable) {
+    erts_smp_rwmtx_rlock(&erts_dist_table_rwmtx);
+    hash_foreach(&erts_dist_table, erts_lcnt_enable_dist_lock_count,
+        (void*)(UWord)enable);
+    erts_smp_rwmtx_runlock(&erts_dist_table_rwmtx);
+}
+#endif
+
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
  * The following is only supposed to be used for testing, and debugging.     *
  *                                                                           *
diff --git a/erts/emulator/beam/erl_node_tables.h b/erts/emulator/beam/erl_node_tables.h
index 489da1ba17..91bcb4fce1 100644
--- a/erts/emulator/beam/erl_node_tables.h
+++ b/erts/emulator/beam/erl_node_tables.h
@@ -195,6 +195,10 @@ int erts_lc_is_de_rwlocked(DistEntry *);
 int erts_lc_is_de_rlocked(DistEntry *);
 #endif
 
+#ifdef ERTS_ENABLE_LOCK_COUNT
+void erts_lcnt_update_distribution_locks(int enable);
+#endif
+
 ERTS_GLB_INLINE void erts_deref_dist_entry(DistEntry *dep);
 ERTS_GLB_INLINE void erts_deref_node_entry(ErlNode *np);
 ERTS_GLB_INLINE void erts_smp_de_rlock(DistEntry *dep);
diff --git a/erts/emulator/beam/erl_port_task.h b/erts/emulator/beam/erl_port_task.h
index ab536c6f27..4e2e168320 100644
--- a/erts/emulator/beam/erl_port_task.h
+++ b/erts/emulator/beam/erl_port_task.h
@@ -188,13 +188,7 @@ erts_port_task_init_sched(ErtsPortTaskSched *ptsp, Eterm instr_id)
     ptsp->taskq.in.last = NULL;
     erts_smp_atomic32_init_nob(&ptsp->flags, 0);
 #ifdef ERTS_SMP
-#ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_mtx_init_x_opt(&ptsp->mtx, lock_str, instr_id,
-			((erts_lcnt_rt_options & ERTS_LCNT_OPT_PORTLOCK)
-			 ? 0 : ERTS_LCNT_LT_DISABLE));
-#else
-    erts_mtx_init_x(&ptsp->mtx, lock_str, instr_id);
-#endif
+    erts_mtx_init(&ptsp->mtx, lock_str, instr_id, ERTS_LOCK_FLAGS_CATEGORY_IO);
 #endif
 }
 
diff --git a/erts/emulator/beam/erl_process.c b/erts/emulator/beam/erl_process.c
index da27c7e7c6..f18537bcf1 100644
--- a/erts/emulator/beam/erl_process.c
+++ b/erts/emulator/beam/erl_process.c
@@ -789,7 +789,9 @@ erts_late_init_process(void)
 {
     int ix;
 
-    erts_smp_spinlock_init(&erts_sched_stat.lock, "sched_stat");
+    erts_smp_spinlock_init(&erts_sched_stat.lock, "sched_stat", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_SCHEDULER);
+
     for (ix = 0; ix < ERTS_NO_PRIO_LEVELS; ix++) {
 	Eterm atom;
 	char *atom_str;
@@ -1958,12 +1960,13 @@ erts_schedule_multi_misc_aux_work(int ignore_self,
     int id, self = 0;
 
     if (ignore_self) {
-	ErtsSchedulerData *esdp = erts_get_scheduler_data();
-#ifdef ERTS_DIRTY_SCHEDULERS
-	ASSERT(!ERTS_SCHEDULER_IS_DIRTY(esdp));
-#endif
-	if (esdp)
-	    self = (int) esdp->no;
+        ErtsSchedulerData *esdp = erts_get_scheduler_data();
+
+        /* ignore_self is meaningless on dirty schedulers since aux work can
+         * only run on normal schedulers, and their ids do not translate. */
+        if(esdp && !ERTS_SCHEDULER_IS_DIRTY(esdp)) {
+            self = (int)esdp->no;
+        }
     }
 
     ASSERT(0 < max_sched && max_sched <= erts_no_schedulers);
@@ -6183,13 +6186,17 @@ erts_init_scheduling(int no_schedulers, int no_schedulers_online
 	 * id if the esdp->no <-> ix+1 mapping change.
 	 */
 
-	erts_smp_mtx_init_x(&rq->mtx, "run_queue", make_small(ix + 1));
+	erts_smp_mtx_init(&rq->mtx, "run_queue", make_small(ix + 1),
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_SCHEDULER);
 	erts_smp_cnd_init(&rq->cnd);
 
 #ifdef ERTS_DIRTY_SCHEDULERS
 #ifdef ERTS_SMP
-	if (ERTS_RUNQ_IX_IS_DIRTY(ix))
-	    erts_smp_spinlock_init(&rq->sleepers.lock, "dirty_run_queue_sleep_list");
+        if (ERTS_RUNQ_IX_IS_DIRTY(ix)) {
+            erts_smp_spinlock_init(&rq->sleepers.lock, "dirty_run_queue_sleep_list",
+                make_small(ix + 1),
+                ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_SCHEDULER);
+        }
 	rq->sleepers.list = NULL;
 #endif
 #endif
@@ -6382,7 +6389,8 @@ erts_init_scheduling(int no_schedulers, int no_schedulers_online
 
     init_no_runqs(no_schedulers_online, no_schedulers_online);
     balance_info.last_active_runqs = no_schedulers;
-    erts_smp_mtx_init(&balance_info.update_mtx, "migration_info_update");
+    erts_smp_mtx_init(&balance_info.update_mtx, "migration_info_update", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_SCHEDULER);
     balance_info.forced_check_balance = 0;
     balance_info.halftime = 1;
     balance_info.full_reds_history_index = 0;
@@ -7439,7 +7447,8 @@ sched_set_suspended_sleeptype(ErtsSchedulerSleepInfo *ssi)
 static void
 init_scheduler_suspend(void)
 {
-    erts_smp_mtx_init(&schdlr_sspnd.mtx, "schdlr_sspnd");
+    erts_smp_mtx_init(&schdlr_sspnd.mtx, "schdlr_sspnd", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_SCHEDULER);
     schdlr_sspnd.online.normal = 1;
     schdlr_sspnd.curr_online.normal = 1;
     schdlr_sspnd.active.normal = 1;
diff --git a/erts/emulator/beam/erl_process_lock.c b/erts/emulator/beam/erl_process_lock.c
index 59577bf422..23c7414901 100644
--- a/erts/emulator/beam/erl_process_lock.c
+++ b/erts/emulator/beam/erl_process_lock.c
@@ -112,21 +112,13 @@ static struct {
 
 erts_pix_lock_t erts_pix_locks[ERTS_NO_OF_PIX_LOCKS];
 
-#ifdef ERTS_ENABLE_LOCK_COUNT
-static void lcnt_enable_proc_lock_count(Process *proc, int enable);
-#endif
-
 void
 erts_init_proc_lock(int cpus)
 {
     int i;
     for (i = 0; i < ERTS_NO_OF_PIX_LOCKS; i++) {
-#ifdef ERTS_ENABLE_LOCK_COUNT
-	erts_mtx_init_x(&erts_pix_locks[i].u.mtx,
-			"pix_lock", make_small(i));
-#else
-	erts_mtx_init(&erts_pix_locks[i].u.mtx, "pix_lock");
-#endif
+        erts_mtx_init(&erts_pix_locks[i].u.mtx, "pix_lock", make_small(i),
+            ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_PROCESS);
     }
 #if ERTS_PROC_LOCK_OWN_IMPL
     erts_thr_install_exit_handler(cleanup_tse);
@@ -1062,32 +1054,38 @@ erts_proc_lock_init(Process *p)
 #endif
 #elif ERTS_PROC_LOCK_RAW_MUTEX_IMPL
 
-    erts_mtx_init_x(&p->lock.main, "proc_main", p->common.id);
+    erts_mtx_init(&p->lock.main, "proc_main", p->common.id,
+        ERTS_LOCK_FLAGS_CATEGORY_PROCESS);
     ethr_mutex_lock(&p->lock.main.mtx);
 #ifdef ERTS_ENABLE_LOCK_CHECK
     erts_lc_trylock(1, &p->lock.main.lc);
 #endif
-    erts_mtx_init_x(&p->lock.link, "proc_link", p->common.id);
+    erts_mtx_init(&p->lock.link, "proc_link", p->common.id,
+        ERTS_LOCK_FLAGS_CATEGORY_PROCESS);
     ethr_mutex_lock(&p->lock.link.mtx);
 #ifdef ERTS_ENABLE_LOCK_CHECK
     erts_lc_trylock(1, &p->lock.link.lc);
 #endif
-    erts_mtx_init_x(&p->lock.msgq, "proc_msgq", p->common.id);
+    erts_mtx_init(&p->lock.msgq, "proc_msgq", p->common.id,
+        ERTS_LOCK_FLAGS_CATEGORY_PROCESS);
     ethr_mutex_lock(&p->lock.msgq.mtx);
 #ifdef ERTS_ENABLE_LOCK_CHECK
     erts_lc_trylock(1, &p->lock.msgq.lc);
 #endif
-    erts_mtx_init_x(&p->lock.btm, "proc_btm", p->common.id);
+    erts_mtx_init(&p->lock.btm, "proc_btm", p->common.id,
+        ERTS_LOCK_FLAGS_CATEGORY_PROCESS);
     ethr_mutex_lock(&p->lock.btm.mtx);
 #ifdef ERTS_ENABLE_LOCK_CHECK
     erts_lc_trylock(1, &p->lock.btm.lc);
 #endif
-    erts_mtx_init_x(&p->lock.status, "proc_status", p->common.id);
+    erts_mtx_init(&p->lock.status, "proc_status", p->common.id,
+        ERTS_LOCK_FLAGS_CATEGORY_PROCESS);
     ethr_mutex_lock(&p->lock.status.mtx);
 #ifdef ERTS_ENABLE_LOCK_CHECK
     erts_lc_trylock(1, &p->lock.status.lc);
 #endif
-    erts_mtx_init_x(&p->lock.trace, "proc_trace", p->common.id);
+    erts_mtx_init(&p->lock.trace, "proc_trace", p->common.id,
+        ERTS_LOCK_FLAGS_CATEGORY_PROCESS);
     ethr_mutex_lock(&p->lock.trace.mtx);
 #ifdef ERTS_ENABLE_LOCK_CHECK
     erts_lc_trylock(1, &p->lock.trace.lc);
@@ -1124,21 +1122,11 @@ erts_proc_lock_fin(Process *p)
 
 #if ERTS_PROC_LOCK_OWN_IMPL && defined(ERTS_ENABLE_LOCK_COUNT)
 
-void erts_lcnt_enable_proc_lock_count(int enable) {
-    int ix, max = erts_ptab_max(&erts_proc);
-    Process *proc = NULL;
-    for(ix = 0; ix < max; ++ix) {
-        if((proc = erts_pix2proc(ix)) != NULL) {
-            lcnt_enable_proc_lock_count(proc, enable);
-        }
-    } /* for all processes */
-}
-
 void erts_lcnt_proc_lock_init(Process *p) {
     erts_lcnt_init_ref(&p->lock.lcnt_carrier);
 
-    if (erts_lcnt_rt_options & ERTS_LCNT_OPT_PROCLOCK) {
-        lcnt_enable_proc_lock_count(p, 1);
+    if(erts_lcnt_check_enabled(ERTS_LOCK_FLAGS_CATEGORY_PROCESS)) {
+        erts_lcnt_enable_proc_lock_count(p, 1);
     }
 } /* logic reversed */
 
@@ -1146,30 +1134,55 @@ void erts_lcnt_proc_lock_destroy(Process *p) {
     erts_lcnt_uninstall(&p->lock.lcnt_carrier);
 }
 
-static void lcnt_enable_proc_lock_count(Process *proc, int enable) {
-    if (enable) {
+void erts_lcnt_enable_proc_lock_count(Process *proc, int enable) {
+    if(proc->common.id == ERTS_INVALID_PID) {
+        /* Locks without an id are more trouble than they're worth; there's no
+         * way to look them up and we can't track them with _STATIC since it's
+         * too early to tell whether we're a system process (proc->static_flags
+         * hasn't been not set yet). */
+    } else if(!enable) {
+        erts_lcnt_proc_lock_destroy(proc);
+    } else if(!erts_lcnt_check_ref_installed(&proc->lock.lcnt_carrier)) {
         erts_lcnt_lock_info_carrier_t *carrier;
-        Eterm pid;
 
         carrier = erts_lcnt_create_lock_info_carrier(ERTS_LCNT_PROCLOCK_COUNT);
-        pid = (proc->common.id != ERTS_INVALID_PID) ? proc->common.id : NIL;
-
-        erts_lcnt_init_lock_info_x_idx(carrier, ERTS_LCNT_PROCLOCK_IDX_MAIN,
-            "proc_main", ERTS_LCNT_LT_PROCLOCK, pid);
-        erts_lcnt_init_lock_info_x_idx(carrier, ERTS_LCNT_PROCLOCK_IDX_LINK,
-            "proc_link", ERTS_LCNT_LT_PROCLOCK, pid);
-        erts_lcnt_init_lock_info_x_idx(carrier, ERTS_LCNT_PROCLOCK_IDX_MSGQ,
-            "proc_msgq", ERTS_LCNT_LT_PROCLOCK, pid);
-        erts_lcnt_init_lock_info_x_idx(carrier, ERTS_LCNT_PROCLOCK_IDX_BTM,
-            "proc_btm", ERTS_LCNT_LT_PROCLOCK, pid);
-        erts_lcnt_init_lock_info_x_idx(carrier, ERTS_LCNT_PROCLOCK_IDX_STATUS,
-            "proc_status",ERTS_LCNT_LT_PROCLOCK, pid);
-        erts_lcnt_init_lock_info_x_idx(carrier, ERTS_LCNT_PROCLOCK_IDX_TRACE,
-            "proc_trace", ERTS_LCNT_LT_PROCLOCK, pid);
+
+        erts_lcnt_init_lock_info_idx(carrier, ERTS_LCNT_PROCLOCK_IDX_MAIN,
+            "proc_main", proc->common.id, ERTS_LOCK_TYPE_PROCLOCK);
+        erts_lcnt_init_lock_info_idx(carrier, ERTS_LCNT_PROCLOCK_IDX_LINK,
+            "proc_link", proc->common.id, ERTS_LOCK_TYPE_PROCLOCK);
+        erts_lcnt_init_lock_info_idx(carrier, ERTS_LCNT_PROCLOCK_IDX_MSGQ,
+            "proc_msgq", proc->common.id, ERTS_LOCK_TYPE_PROCLOCK);
+        erts_lcnt_init_lock_info_idx(carrier, ERTS_LCNT_PROCLOCK_IDX_BTM,
+            "proc_btm", proc->common.id, ERTS_LOCK_TYPE_PROCLOCK);
+        erts_lcnt_init_lock_info_idx(carrier, ERTS_LCNT_PROCLOCK_IDX_STATUS,
+            "proc_status",proc->common.id, ERTS_LOCK_TYPE_PROCLOCK);
+        erts_lcnt_init_lock_info_idx(carrier, ERTS_LCNT_PROCLOCK_IDX_TRACE,
+            "proc_trace", proc->common.id, ERTS_LOCK_TYPE_PROCLOCK);
 
         erts_lcnt_install(&proc->lock.lcnt_carrier, carrier);
-    } else {
-        erts_lcnt_proc_lock_destroy(proc);
+    }
+}
+
+void erts_lcnt_update_process_locks(int enable) {
+    int i, max;
+
+    max = erts_ptab_max(&erts_proc);
+
+    for(i = 0; i < max; i++) {
+        int delay_handle;
+        Process *proc;
+
+        delay_handle = erts_thr_progress_unmanaged_delay();
+        proc = erts_pix2proc(i);
+
+        if(proc != NULL) {
+            erts_lcnt_enable_proc_lock_count(proc, enable);
+        }
+
+        if(delay_handle != ERTS_THR_PRGR_DHANDLE_MANAGED) {
+            erts_thr_progress_unmanaged_continue(delay_handle);
+        }
     }
 }
 
diff --git a/erts/emulator/beam/erl_process_lock.h b/erts/emulator/beam/erl_process_lock.h
index b4a5ef3f28..023ba4d4ae 100644
--- a/erts/emulator/beam/erl_process_lock.h
+++ b/erts/emulator/beam/erl_process_lock.h
@@ -263,7 +263,8 @@ void erts_lcnt_proc_unlock(erts_proc_lock_t *lock, ErtsProcLocks locks);
 ERTS_GLB_INLINE
 void erts_lcnt_proc_trylock(erts_proc_lock_t *lock, ErtsProcLocks locks, int res);
 
-void erts_lcnt_enable_proc_lock_count(int enable);
+void erts_lcnt_enable_proc_lock_count(Process *proc, int enable);
+void erts_lcnt_update_process_locks(int enable);
 
 #if ERTS_GLB_INLINE_INCL_FUNC_DEF
 
diff --git a/erts/emulator/beam/erl_ptab.c b/erts/emulator/beam/erl_ptab.c
index c3d59cb3a8..b3bcb3af3f 100644
--- a/erts/emulator/beam/erl_ptab.c
+++ b/erts/emulator/beam/erl_ptab.c
@@ -372,7 +372,8 @@ erts_ptab_init_table(ErtsPTab *ptab,
     rwmtx_opts.type = ERTS_SMP_RWMTX_TYPE_EXTREMELY_FREQUENT_READ;
     rwmtx_opts.lived = ERTS_SMP_RWMTX_LONG_LIVED;
 
-    erts_smp_rwmtx_init_opt(&ptab->list.data.rwmtx, &rwmtx_opts, name);
+    erts_smp_rwmtx_init_opt(&ptab->list.data.rwmtx, &rwmtx_opts, name, NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
     erts_smp_atomic32_init_nob(&ptab->vola.tile.count, 0);
     last_data_init_nob(ptab, ~((Uint64) 0));
 
diff --git a/erts/emulator/beam/erl_smp.h b/erts/emulator/beam/erl_smp.h
index 55ba943bdd..3502de5135 100644
--- a/erts/emulator/beam/erl_smp.h
+++ b/erts/emulator/beam/erl_smp.h
@@ -128,14 +128,14 @@ ERTS_GLB_INLINE int erts_smp_equal_tids(erts_smp_tid_t x, erts_smp_tid_t y);
 #define ERTS_SMP_HAVE_REC_MTX_INIT 1
 ERTS_GLB_INLINE void erts_smp_rec_mtx_init(erts_smp_mtx_t *mtx);
 #endif
-ERTS_GLB_INLINE void erts_smp_mtx_init_x(erts_smp_mtx_t *mtx,
-					 char *name,
-					 Eterm extra);
-ERTS_GLB_INLINE void erts_smp_mtx_init_locked_x(erts_smp_mtx_t *mtx,
-						char *name,
-						Eterm extra);
-ERTS_GLB_INLINE void erts_smp_mtx_init(erts_smp_mtx_t *mtx, char *name);
-ERTS_GLB_INLINE void erts_smp_mtx_init_locked(erts_smp_mtx_t *mtx, char *name);
+ERTS_GLB_INLINE void erts_smp_mtx_init(erts_smp_mtx_t *mtx,
+                                       char *name,
+                                       Eterm extra,
+                                       erts_lock_flags_t flags);
+ERTS_GLB_INLINE void erts_smp_mtx_init_locked(erts_smp_mtx_t *mtx,
+                                               char *name,
+                                               Eterm extra,
+                                               erts_lock_flags_t flags);
 ERTS_GLB_INLINE void erts_smp_mtx_destroy(erts_smp_mtx_t *mtx);
 #ifdef ERTS_ENABLE_LOCK_POSITION
 ERTS_GLB_INLINE int erts_smp_mtx_trylock_x(erts_smp_mtx_t *mtx, char *file, unsigned int line);
@@ -153,18 +153,15 @@ ERTS_GLB_INLINE void erts_smp_cnd_wait(erts_smp_cnd_t *cnd,
 ERTS_GLB_INLINE void erts_smp_cnd_signal(erts_smp_cnd_t *cnd);
 ERTS_GLB_INLINE void erts_smp_cnd_broadcast(erts_smp_cnd_t *cnd);
 ERTS_GLB_INLINE void erts_smp_rwmtx_set_reader_group(int no);
-ERTS_GLB_INLINE void erts_smp_rwmtx_init_opt_x(erts_smp_rwmtx_t *rwmtx,
-					       erts_smp_rwmtx_opt_t *opt,
-					       char *name,
-					       Eterm extra);
-ERTS_GLB_INLINE void erts_smp_rwmtx_init_x(erts_smp_rwmtx_t *rwmtx,
-					   char *name,
-					   Eterm extra);
 ERTS_GLB_INLINE void erts_smp_rwmtx_init_opt(erts_smp_rwmtx_t *rwmtx,
-					     erts_smp_rwmtx_opt_t *opt,
-					     char *name);
+                                             erts_smp_rwmtx_opt_t *opt,
+                                             char *name,
+                                             Eterm extra,
+                                             erts_lock_flags_t flags);
 ERTS_GLB_INLINE void erts_smp_rwmtx_init(erts_smp_rwmtx_t *rwmtx,
-					 char *name);
+                                         char *name,
+                                         Eterm extra,
+                                         erts_lock_flags_t flags);
 ERTS_GLB_INLINE void erts_smp_rwmtx_destroy(erts_smp_rwmtx_t *rwmtx);
 #ifdef ERTS_ENABLE_LOCK_POSITION
 ERTS_GLB_INLINE int erts_smp_rwmtx_tryrlock_x(erts_smp_rwmtx_t *rwmtx, char *file, unsigned int line);
@@ -181,11 +178,10 @@ ERTS_GLB_INLINE void erts_smp_rwmtx_runlock(erts_smp_rwmtx_t *rwmtx);
 ERTS_GLB_INLINE void erts_smp_rwmtx_rwunlock(erts_smp_rwmtx_t *rwmtx);
 ERTS_GLB_INLINE int erts_smp_lc_rwmtx_is_rlocked(erts_smp_rwmtx_t *mtx);
 ERTS_GLB_INLINE int erts_smp_lc_rwmtx_is_rwlocked(erts_smp_rwmtx_t *mtx);
-ERTS_GLB_INLINE void erts_smp_spinlock_init_x(erts_smp_spinlock_t *lock,
-					      char *name,
-					      Eterm extra);
 ERTS_GLB_INLINE void erts_smp_spinlock_init(erts_smp_spinlock_t *lock,
-					    char *name);
+                                            char *name,
+                                            Eterm extra,
+                                            erts_lock_flags_t flags);
 ERTS_GLB_INLINE void erts_smp_spinlock_destroy(erts_smp_spinlock_t *lock);
 ERTS_GLB_INLINE void erts_smp_spin_unlock(erts_smp_spinlock_t *lock);
 #ifdef ERTS_ENABLE_LOCK_POSITION
@@ -194,11 +190,10 @@ ERTS_GLB_INLINE void erts_smp_spin_lock_x(erts_smp_spinlock_t *lock, char *file,
 ERTS_GLB_INLINE void erts_smp_spin_lock(erts_smp_spinlock_t *lock);
 #endif
 ERTS_GLB_INLINE int erts_smp_lc_spinlock_is_locked(erts_smp_spinlock_t *lock);
-ERTS_GLB_INLINE void erts_smp_rwlock_init_x(erts_smp_rwlock_t *lock,
-					    char *name,
-					    Eterm extra);
 ERTS_GLB_INLINE void erts_smp_rwlock_init(erts_smp_rwlock_t *lock,
-					  char *name);
+                                          char *name,
+                                          Eterm extra,
+                                          erts_lock_flags_t flags);
 ERTS_GLB_INLINE void erts_smp_rwlock_destroy(erts_smp_rwlock_t *lock);
 ERTS_GLB_INLINE void erts_smp_read_unlock(erts_smp_rwlock_t *lock);
 #ifdef ERTS_ENABLE_LOCK_POSITION
@@ -1062,34 +1057,18 @@ erts_smp_rec_mtx_init(erts_smp_mtx_t *mtx)
 #endif
 
 ERTS_GLB_INLINE void
-erts_smp_mtx_init_x(erts_smp_mtx_t *mtx, char *name, Eterm extra)
+erts_smp_mtx_init(erts_smp_mtx_t *mtx, char *name, Eterm extra, erts_lock_flags_t flags)
 {
 #ifdef ERTS_SMP
-    erts_mtx_init_x(mtx, name, extra);
+    erts_mtx_init(mtx, name, extra, flags);
 #endif
 }
 
 ERTS_GLB_INLINE void
-erts_smp_mtx_init_locked_x(erts_smp_mtx_t *mtx, char *name, Eterm extra)
+erts_smp_mtx_init_locked(erts_smp_mtx_t *mtx, char *name, Eterm extra, erts_lock_flags_t flags)
 {
 #ifdef ERTS_SMP
-    erts_mtx_init_locked_x_opt(mtx, name, extra, 0);
-#endif
-}
-
-ERTS_GLB_INLINE void
-erts_smp_mtx_init(erts_smp_mtx_t *mtx, char *name)
-{
-#ifdef ERTS_SMP
-    erts_mtx_init(mtx, name);
-#endif
-}
-
-ERTS_GLB_INLINE void
-erts_smp_mtx_init_locked(erts_smp_mtx_t *mtx, char *name)
-{
-#ifdef ERTS_SMP
-    erts_mtx_init_locked(mtx, name);
+    erts_mtx_init_locked(mtx, name, extra, flags);
 #endif
 }
 
@@ -1211,39 +1190,25 @@ erts_smp_rwmtx_set_reader_group(int no)
 }
 
 ERTS_GLB_INLINE void
-erts_smp_rwmtx_init_opt_x(erts_smp_rwmtx_t *rwmtx,
-			  erts_smp_rwmtx_opt_t *opt,
-			  char *name,
-			  Eterm extra)
-{
-#ifdef ERTS_SMP
-    erts_rwmtx_init_opt_x(rwmtx, opt, name, extra);
-#endif
-}
-
-ERTS_GLB_INLINE void
-erts_smp_rwmtx_init_x(erts_smp_rwmtx_t *rwmtx, char *name, Eterm extra)
+erts_smp_rwmtx_init(erts_smp_rwmtx_t *rwmtx,
+                    char *name,
+                    Eterm extra,
+                    erts_lock_flags_t flags)
 {
 #ifdef ERTS_SMP
-    erts_rwmtx_init_x(rwmtx, name, extra);
+    erts_smp_rwmtx_init_opt(rwmtx, NULL, name, extra, flags);
 #endif
 }
 
 ERTS_GLB_INLINE void
 erts_smp_rwmtx_init_opt(erts_smp_rwmtx_t *rwmtx,
-			erts_smp_rwmtx_opt_t *opt,
-			char *name)
-{
-#ifdef ERTS_SMP
-    erts_rwmtx_init_opt(rwmtx, opt, name);
-#endif
-}
-
-ERTS_GLB_INLINE void
-erts_smp_rwmtx_init(erts_smp_rwmtx_t *rwmtx, char *name)
+                        erts_smp_rwmtx_opt_t *opt,
+                        char *name,
+                        Eterm extra,
+                        erts_lock_flags_t flags)
 {
 #ifdef ERTS_SMP
-    erts_rwmtx_init(rwmtx, name);
+    erts_rwmtx_init_opt(rwmtx, opt, name, extra, flags);
 #endif
 }
 
@@ -1379,20 +1344,10 @@ erts_smp_lc_rwmtx_is_rwlocked(erts_smp_rwmtx_t *mtx)
 }
 
 ERTS_GLB_INLINE void
-erts_smp_spinlock_init_x(erts_smp_spinlock_t *lock, char *name, Eterm extra)
-{
-#ifdef ERTS_SMP
-    erts_spinlock_init_x(lock, name, extra);
-#else
-    (void)lock;
-#endif
-}
-
-ERTS_GLB_INLINE void
-erts_smp_spinlock_init(erts_smp_spinlock_t *lock, char *name)
+erts_smp_spinlock_init(erts_smp_spinlock_t *lock, char *name, Eterm extra, erts_lock_flags_t flags)
 {
 #ifdef ERTS_SMP
-    erts_spinlock_init(lock, name);
+    erts_spinlock_init(lock, name, extra, flags);
 #else
     (void)lock;
 #endif
@@ -1445,20 +1400,10 @@ erts_smp_lc_spinlock_is_locked(erts_smp_spinlock_t *lock)
 }
 
 ERTS_GLB_INLINE void
-erts_smp_rwlock_init_x(erts_smp_rwlock_t *lock, char *name, Eterm extra)
-{
-#ifdef ERTS_SMP
-    erts_rwlock_init_x(lock, name, extra);
-#else
-    (void)lock;
-#endif
-}
-
-ERTS_GLB_INLINE void
-erts_smp_rwlock_init(erts_smp_rwlock_t *lock, char *name)
+erts_smp_rwlock_init(erts_smp_rwlock_t *lock, char *name, Eterm extra, erts_lock_flags_t flags)
 {
 #ifdef ERTS_SMP
-    erts_rwlock_init(lock, name);
+    erts_rwlock_init(lock, name, extra, flags);
 #else
     (void)lock;
 #endif
diff --git a/erts/emulator/beam/erl_threads.h b/erts/emulator/beam/erl_threads.h
index f7b53f5ef3..3b13defdc6 100644
--- a/erts/emulator/beam/erl_threads.h
+++ b/erts/emulator/beam/erl_threads.h
@@ -259,13 +259,16 @@
 
 #include "sys.h"
 
+#include "erl_lock_flags.h"
+#include "erl_term.h"
+
 #ifdef USE_THREADS
 
 #define ETHR_TRY_INLINE_FUNCS
 #include "ethread.h"
+
 #include "erl_lock_check.h"
 #include "erl_lock_count.h"
-#include "erl_term.h"
 
 #if defined(__GLIBC__) && (__GLIBC__ << 16) + __GLIBC_MINOR__ < (2 << 16) + 4
 /*
@@ -309,7 +312,9 @@ typedef struct {
 #ifdef ERTS_ENABLE_LOCK_COUNT
     erts_lcnt_ref_t lcnt;
 #endif
-
+#ifdef DEBUG
+    erts_lock_flags_t flags;
+#endif
 } erts_mtx_t;
 typedef ethr_cond erts_cnd_t;
 
@@ -322,6 +327,9 @@ typedef struct {
 #ifdef ERTS_ENABLE_LOCK_COUNT
     erts_lcnt_ref_t lcnt;
 #endif
+#ifdef DEBUG
+    erts_lock_flags_t flags;
+#endif
 } erts_rwmtx_t;
 
 #define ERTS_MTX_OPT_DEFAULT_INITER ETHR_MUTEX_OPT_DEFAULT_INITER
@@ -367,6 +375,9 @@ typedef struct {
 #ifdef ERTS_ENABLE_LOCK_COUNT
     erts_lcnt_ref_t lcnt;
 #endif
+#ifdef DEBUG
+    erts_lock_flags_t flags;
+#endif
 } erts_spinlock_t;
 
 /* rwlock */
@@ -378,6 +389,9 @@ typedef struct {
 #ifdef ERTS_ENABLE_LOCK_COUNT
     erts_lcnt_ref_t lcnt;
 #endif
+#ifdef DEBUG
+    erts_lock_flags_t flags;
+#endif
 } erts_rwlock_t;
 
 __decl_noreturn void  __noreturn erts_thr_fatal_error(int, char *); 
@@ -479,11 +493,14 @@ ERTS_GLB_INLINE void erts_thr_install_exit_handler(void (*exit_handler)(void));
 ERTS_GLB_INLINE erts_tid_t erts_thr_self(void);
 ERTS_GLB_INLINE int erts_thr_getname(erts_tid_t tid, char *buf, size_t len);
 ERTS_GLB_INLINE int erts_equal_tids(erts_tid_t x, erts_tid_t y);
-ERTS_GLB_INLINE void erts_mtx_init_x(erts_mtx_t *mtx, char *name, Eterm extra);
-ERTS_GLB_INLINE void erts_mtx_init_x_opt(erts_mtx_t *mtx, char *name, Eterm extra, Uint16 opt);
-ERTS_GLB_INLINE void erts_mtx_init_locked_x_opt(erts_mtx_t *mtx, char *name, Eterm extra, Uint16 opt);
-ERTS_GLB_INLINE void erts_mtx_init(erts_mtx_t *mtx, char *name);
-ERTS_GLB_INLINE void erts_mtx_init_locked(erts_mtx_t *mtx, char *name);
+ERTS_GLB_INLINE void erts_mtx_init(erts_mtx_t *mtx,
+                                   char *name,
+                                   Eterm extra,
+                                   erts_lock_flags_t flags);
+ERTS_GLB_INLINE void erts_mtx_init_locked(erts_mtx_t *mtx,
+                                          char *name,
+                                          Eterm extra,
+                                          erts_lock_flags_t flags);
 ERTS_GLB_INLINE void erts_mtx_destroy(erts_mtx_t *mtx);
 #ifdef ERTS_ENABLE_LOCK_POSITION
 ERTS_GLB_INLINE int erts_mtx_trylock_x(erts_mtx_t *mtx, char *file,
@@ -502,18 +519,15 @@ ERTS_GLB_INLINE void erts_cnd_wait(erts_cnd_t *cnd, erts_mtx_t *mtx);
 ERTS_GLB_INLINE void erts_cnd_signal(erts_cnd_t *cnd);
 ERTS_GLB_INLINE void erts_cnd_broadcast(erts_cnd_t *cnd);
 ERTS_GLB_INLINE void erts_rwmtx_set_reader_group(int no);
-ERTS_GLB_INLINE void erts_rwmtx_init_opt_x(erts_rwmtx_t *rwmtx,
-					   erts_rwmtx_opt_t *opt,
-					   char *name,
-					   Eterm extra);
-ERTS_GLB_INLINE void erts_rwmtx_init_x(erts_rwmtx_t *rwmtx,
-				       char *name,
-				       Eterm extra);
 ERTS_GLB_INLINE void erts_rwmtx_init_opt(erts_rwmtx_t *rwmtx,
-					 erts_rwmtx_opt_t *opt,
-					 char *name);
+                                         erts_rwmtx_opt_t *opt,
+                                         char *name,
+                                         Eterm extra,
+                                         erts_lock_flags_t flags);
 ERTS_GLB_INLINE void erts_rwmtx_init(erts_rwmtx_t *rwmtx,
-					 char *name);
+                                     char *name,
+                                     Eterm extra,
+                                     erts_lock_flags_t flags);
 ERTS_GLB_INLINE void erts_rwmtx_destroy(erts_rwmtx_t *rwmtx);
 #ifdef ERTS_ENABLE_LOCK_POSITION
 ERTS_GLB_INLINE int erts_rwmtx_tryrlock_x(erts_rwmtx_t *rwmtx, char *file, unsigned int line);
@@ -603,16 +617,10 @@ ERTS_GLB_INLINE erts_aint64_t erts_no_atomic64_cmpxchg(erts_no_atomic64_t *xchgp
 ERTS_GLB_INLINE erts_aint64_t erts_no_atomic64_read_bset(erts_no_atomic64_t *var,
 							 erts_aint64_t mask,
 							 erts_aint64_t set);
-
-ERTS_GLB_INLINE void erts_spinlock_init_x_opt(erts_spinlock_t *lock,
-					      char *name,
-					      Eterm extra,
-					      Uint16 opt);
-ERTS_GLB_INLINE void erts_spinlock_init_x(erts_spinlock_t *lock,
-					  char *name,
-					  Eterm extra);
 ERTS_GLB_INLINE void erts_spinlock_init(erts_spinlock_t *lock,
-					char *name);
+                                        char *name,
+                                        Eterm extra,
+                                        erts_lock_flags_t flags);
 ERTS_GLB_INLINE void erts_spinlock_destroy(erts_spinlock_t *lock);
 ERTS_GLB_INLINE void erts_spin_unlock(erts_spinlock_t *lock);
 #ifdef ERTS_ENABLE_LOCK_POSITION
@@ -621,11 +629,10 @@ ERTS_GLB_INLINE void erts_spin_lock_x(erts_spinlock_t *lock, char *file, unsigne
 ERTS_GLB_INLINE void erts_spin_lock(erts_spinlock_t *lock);
 #endif
 ERTS_GLB_INLINE int erts_lc_spinlock_is_locked(erts_spinlock_t *lock);
-ERTS_GLB_INLINE void erts_rwlock_init_x(erts_rwlock_t *lock,
-					char *name,
-					Eterm extra);
 ERTS_GLB_INLINE void erts_rwlock_init(erts_rwlock_t *lock,
-				      char *name);
+                                      char *name,
+                                      Eterm extra,
+                                      erts_lock_flags_t flags);
 ERTS_GLB_INLINE void erts_rwlock_destroy(erts_rwlock_t *lock);
 ERTS_GLB_INLINE void erts_read_unlock(erts_rwlock_t *lock);
 #ifdef ERTS_ENABLE_LOCK_POSITION
@@ -2159,106 +2166,41 @@ erts_equal_tids(erts_tid_t x, erts_tid_t y)
 }
 
 ERTS_GLB_INLINE void
-erts_mtx_init_x(erts_mtx_t *mtx, char *name, Eterm extra)
-{
-#ifdef USE_THREADS
-    int res = ethr_mutex_init(&mtx->mtx);
-    if (res)
-	erts_thr_fatal_error(res, "initialize mutex");
-#ifdef ERTS_ENABLE_LOCK_CHECK
-    erts_lc_init_lock_x(&mtx->lc, name, ERTS_LC_FLG_LT_MUTEX, extra);
-#endif
-#ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_init_ref(&mtx->lcnt);
-    erts_lcnt_install_new_lock_info_x(&mtx->lcnt, name, ERTS_LCNT_LT_MUTEX, extra);
-#endif
-#endif
-}
-
-ERTS_GLB_INLINE void
-erts_mtx_init_x_opt(erts_mtx_t *mtx, char *name, Eterm extra, Uint16 opt)
+erts_mtx_init(erts_mtx_t *mtx, char *name, Eterm extra, erts_lock_flags_t flags)
 {
 #ifdef USE_THREADS
     int res = ethr_mutex_init(&mtx->mtx);
-    if (res)
-	erts_thr_fatal_error(res, "initialize mutex");
-#ifdef ERTS_ENABLE_LOCK_CHECK
-    erts_lc_init_lock_x(&mtx->lc, name, ERTS_LC_FLG_LT_MUTEX, extra);
-#endif
-#ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_init_ref(&mtx->lcnt);
-    if(!(opt & ERTS_LCNT_LT_DISABLE)) { // Incorrect, but preserves the old interface.
-        erts_lcnt_install_new_lock_info_x(&mtx->lcnt, name, ERTS_LCNT_LT_MUTEX | opt, extra);
+    if (res) {
+        erts_thr_fatal_error(res, "initialize mutex");
     }
-#endif
-#endif
-}
 
+    flags |= ERTS_LOCK_TYPE_MUTEX;
+#ifdef DEBUG
+    mtx->flags = flags;
+#endif
 
-ERTS_GLB_INLINE void
-erts_mtx_init_locked_x_opt(erts_mtx_t *mtx, char *name, Eterm extra, Uint16 opt)
-{
-#ifdef USE_THREADS
-    int res = ethr_mutex_init(&mtx->mtx);
-    if (res)
-	erts_thr_fatal_error(res, "initialize mutex");
 #ifdef ERTS_ENABLE_LOCK_CHECK
     erts_lc_init_lock_x(&mtx->lc, name, ERTS_LC_FLG_LT_MUTEX, extra);
 #endif
 #ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_init_ref(&mtx->lcnt);
-    if(!(opt & ERTS_LCNT_LT_DISABLE)) { // Incorrect, but preserves the old interface.
-        erts_lcnt_install_new_lock_info_x(&mtx->lcnt, name, ERTS_LCNT_LT_MUTEX, extra);
-    }
-#endif
-    ethr_mutex_lock(&mtx->mtx);
-#ifdef ERTS_ENABLE_LOCK_CHECK
-    erts_lc_trylock(1, &mtx->lc);
-#endif
-#ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_trylock(&mtx->lcnt, 1);
-#endif
+    erts_lcnt_init_ref_x(&mtx->lcnt, name, extra, flags);
 #endif
+#endif /* USE_THREADS */
 }
 
 ERTS_GLB_INLINE void
-erts_mtx_init(erts_mtx_t *mtx, char *name)
+erts_mtx_init_locked(erts_mtx_t *mtx, char *name, Eterm extra, erts_lock_flags_t flags)
 {
 #ifdef USE_THREADS
-    int res = ethr_mutex_init(&mtx->mtx);
-    if (res)
-	erts_thr_fatal_error(res, "initialize mutex");
-#ifdef ERTS_ENABLE_LOCK_CHECK
-    erts_lc_init_lock(&mtx->lc, name, ERTS_LC_FLG_LT_MUTEX);
-#endif
-#ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_init_ref(&mtx->lcnt);
-    erts_lcnt_install_new_lock_info(&mtx->lcnt, name, ERTS_LCNT_LT_MUTEX);
-#endif
-#endif
-}
+    erts_mtx_init(mtx, name, extra, flags);
 
-ERTS_GLB_INLINE void
-erts_mtx_init_locked(erts_mtx_t *mtx, char *name)
-{
-#ifdef USE_THREADS
-    int res = ethr_mutex_init(&mtx->mtx);
-    if (res)
-	erts_thr_fatal_error(res, "initialize mutex");
-#ifdef ERTS_ENABLE_LOCK_CHECK
-    erts_lc_init_lock(&mtx->lc, name, ERTS_LC_FLG_LT_MUTEX);
-#endif
-#ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_init_ref(&mtx->lcnt);
-    erts_lcnt_install_new_lock_info(&mtx->lcnt, name, ERTS_LCNT_LT_MUTEX);
-#endif
     ethr_mutex_lock(&mtx->mtx);
-#ifdef ERTS_ENABLE_LOCK_CHECK
-    erts_lc_trylock(1, &mtx->lc);
-#endif
-#ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_trylock(&mtx->lcnt, 1);
-#endif
+    #ifdef ERTS_ENABLE_LOCK_CHECK
+        erts_lc_trylock(1, &mtx->lc);
+    #endif
+    #ifdef ERTS_ENABLE_LOCK_COUNT
+        erts_lcnt_trylock(&mtx->lcnt, 1);
+    #endif
 #endif
 }
 
@@ -2267,6 +2209,9 @@ erts_mtx_destroy(erts_mtx_t *mtx)
 {
 #ifdef USE_THREADS
     int res;
+
+    ASSERT(!(mtx->flags & ERTS_LOCK_FLAGS_PROPERTY_STATIC));
+
 #ifdef ERTS_ENABLE_LOCK_CHECK
     erts_lc_destroy_lock(&mtx->lc);
 #endif
@@ -2477,59 +2422,32 @@ erts_rwmtx_set_reader_group(int no)
 }
 
 ERTS_GLB_INLINE void
-erts_rwmtx_init_opt_x(erts_rwmtx_t *rwmtx,
-		      erts_rwmtx_opt_t *opt,
-		      char *name,
-		      Eterm extra)
-{
+erts_rwmtx_init_opt(erts_rwmtx_t *rwmtx, erts_rwmtx_opt_t *opt,
+                    char *name, Eterm extra, erts_lock_flags_t flags) {
 #ifdef USE_THREADS
     int res = ethr_rwmutex_init_opt(&rwmtx->rwmtx, opt);
-    if (res != 0)
-	erts_thr_fatal_error(res, "initialize rwmutex");
-#ifdef ERTS_ENABLE_LOCK_CHECK
-    erts_lc_init_lock_x(&rwmtx->lc, name, ERTS_LC_FLG_LT_RWMUTEX, extra);
-#endif
-#ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_init_ref(&rwmtx->lcnt);
-    if (name && name[0] == '\0')
-        erts_lcnt_install_new_lock_info_x(&rwmtx->lcnt, NULL, ERTS_LCNT_LT_RWMUTEX, extra);
-    else
-        erts_lcnt_install_new_lock_info_x(&rwmtx->lcnt, name, ERTS_LCNT_LT_RWMUTEX, extra);
-#endif
-#endif
-}
+    if (res != 0) {
+        erts_thr_fatal_error(res, "initialize rwmutex");
+    }
 
-ERTS_GLB_INLINE void
-erts_rwmtx_init_x(erts_rwmtx_t *rwmtx,
-		  char *name,
-		  Eterm extra)
-{
-    erts_rwmtx_init_opt_x(rwmtx, NULL, name, extra);
-}
+    flags |= ERTS_LOCK_TYPE_RWMUTEX;
+#ifdef DEBUG
+    rwmtx->flags = flags;
+#endif
 
-ERTS_GLB_INLINE void
-erts_rwmtx_init_opt(erts_rwmtx_t *rwmtx,
-		    erts_rwmtx_opt_t *opt,
-		    char *name)
-{
-#ifdef USE_THREADS
-    int res = ethr_rwmutex_init_opt(&rwmtx->rwmtx, opt);
-    if (res != 0)
-	erts_thr_fatal_error(res, "initialize rwmutex");
 #ifdef ERTS_ENABLE_LOCK_CHECK
-    erts_lc_init_lock(&rwmtx->lc, name, ERTS_LC_FLG_LT_RWMUTEX);
+    erts_lc_init_lock_x(&rwmtx->lc, name, ERTS_LC_FLG_LT_RWMUTEX, extra);
 #endif
 #ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_init_ref(&rwmtx->lcnt);
-    erts_lcnt_install_new_lock_info(&rwmtx->lcnt, name, ERTS_LCNT_LT_RWMUTEX);
-#endif
+    erts_lcnt_init_ref_x(&rwmtx->lcnt, name, extra, flags);
 #endif
+#endif /* USE_THREADS */
 }
 
 ERTS_GLB_INLINE void
-erts_rwmtx_init(erts_rwmtx_t *rwmtx, char *name)
-{
-    erts_rwmtx_init_opt(rwmtx, NULL, name);
+erts_rwmtx_init(erts_rwmtx_t *rwmtx, char *name, Eterm extra,
+                erts_lock_flags_t flags) {
+    erts_rwmtx_init_opt(rwmtx, NULL, name, extra, flags);
 }
 
 ERTS_GLB_INLINE void
@@ -2537,6 +2455,9 @@ erts_rwmtx_destroy(erts_rwmtx_t *rwmtx)
 {
 #ifdef USE_THREADS
     int res;
+
+    ASSERT(!(rwmtx->flags & ERTS_LOCK_FLAGS_PROPERTY_STATIC));
+
 #ifdef ERTS_ENABLE_LOCK_CHECK
     erts_lc_destroy_lock(&rwmtx->lc);
 #endif
@@ -2584,7 +2505,7 @@ erts_rwmtx_tryrlock(erts_rwmtx_t *rwmtx)
 #endif
 #endif
 #ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_trylock_opt(&rwmtx->lcnt, res, ERTS_LCNT_LO_READ);
+    erts_lcnt_trylock_opt(&rwmtx->lcnt, res, ERTS_LOCK_OPTION_READ);
 #endif
     
     return res;
@@ -2609,7 +2530,7 @@ erts_rwmtx_rlock(erts_rwmtx_t *rwmtx)
 #endif
 #endif
 #ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_lock_opt(&rwmtx->lcnt, ERTS_LCNT_LO_READ);
+    erts_lcnt_lock_opt(&rwmtx->lcnt, ERTS_LOCK_OPTION_READ);
 #endif
     ethr_rwmutex_rlock(&rwmtx->rwmtx);
 #ifdef ERTS_ENABLE_LOCK_COUNT
@@ -2626,7 +2547,7 @@ erts_rwmtx_runlock(erts_rwmtx_t *rwmtx)
     erts_lc_unlock_flg(&rwmtx->lc, ERTS_LC_FLG_LO_READ);
 #endif
 #ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_unlock_opt(&rwmtx->lcnt, ERTS_LCNT_LO_READ);
+    erts_lcnt_unlock_opt(&rwmtx->lcnt, ERTS_LOCK_OPTION_READ);
 #endif
     ethr_rwmutex_runlock(&rwmtx->rwmtx);
 #endif
@@ -2659,7 +2580,7 @@ erts_rwmtx_tryrwlock(erts_rwmtx_t *rwmtx)
 #endif
 #endif
 #ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_trylock_opt(&rwmtx->lcnt, res, ERTS_LCNT_LO_READ_WRITE);
+    erts_lcnt_trylock_opt(&rwmtx->lcnt, res, ERTS_LOCK_OPTION_RDWR);
 #endif
     
     return res;
@@ -2684,7 +2605,7 @@ erts_rwmtx_rwlock(erts_rwmtx_t *rwmtx)
 #endif
 #endif
 #ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_lock_opt(&rwmtx->lcnt, ERTS_LCNT_LO_READ_WRITE);
+    erts_lcnt_lock_opt(&rwmtx->lcnt, ERTS_LOCK_OPTION_RDWR);
 #endif
     ethr_rwmutex_rwlock(&rwmtx->rwmtx);
 #ifdef ERTS_ENABLE_LOCK_COUNT
@@ -2701,7 +2622,7 @@ erts_rwmtx_rwunlock(erts_rwmtx_t *rwmtx)
     erts_lc_unlock_flg(&rwmtx->lc, ERTS_LC_FLG_LO_READ_WRITE);
 #endif
 #ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_unlock_opt(&rwmtx->lcnt, ERTS_LCNT_LO_READ_WRITE);
+    erts_lcnt_unlock_opt(&rwmtx->lcnt, ERTS_LOCK_OPTION_RDWR);
 #endif
     ethr_rwmutex_rwunlock(&rwmtx->rwmtx);
 #endif
@@ -3086,62 +3007,26 @@ erts_no_atomic64_read_bset(erts_no_atomic64_t *var,
 /* spinlock */
 
 ERTS_GLB_INLINE void
-erts_spinlock_init_x(erts_spinlock_t *lock, char *name, Eterm extra)
+erts_spinlock_init(erts_spinlock_t *lock, char *name, Eterm extra, erts_lock_flags_t flags)
 {
 #ifdef USE_THREADS
     int res = ethr_spinlock_init(&lock->slck);
-    if (res)
-	erts_thr_fatal_error(res, "init spinlock");
-#ifdef ERTS_ENABLE_LOCK_CHECK
-    erts_lc_init_lock_x(&lock->lc, name, ERTS_LC_FLG_LT_SPINLOCK, extra);
-#endif
-#ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_init_ref(&lock->lcnt);
-    erts_lcnt_install_new_lock_info_x(&lock->lcnt, name, ERTS_LCNT_LT_SPINLOCK, extra);
-#endif
-#else
-    (void)lock;
-#endif
-}
+    if (res) {
+        erts_thr_fatal_error(res, "init spinlock");
+    }
 
-ERTS_GLB_INLINE void
-erts_spinlock_init_x_opt(erts_spinlock_t *lock, char *name, Eterm extra,
-			 Uint16 opt)
-{
-#ifdef USE_THREADS
-    int res = ethr_spinlock_init(&lock->slck);
-    if (res)
-	erts_thr_fatal_error(res, "init spinlock");
-#ifdef ERTS_ENABLE_LOCK_CHECK
-    erts_lc_init_lock_x(&lock->lc, name, ERTS_LC_FLG_LT_SPINLOCK, extra);
-#endif
-#ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_init_ref(&lock->lcnt);
-    erts_lcnt_install_new_lock_info_x(&lock->lcnt, name, ERTS_LCNT_LT_SPINLOCK | opt, extra);
+    flags |= ERTS_LOCK_TYPE_SPINLOCK;
+#ifdef DEBUG
+    lock->flags = flags;
 #endif
-#else
-    (void)lock;
-#endif
-}
 
-
-ERTS_GLB_INLINE void
-erts_spinlock_init(erts_spinlock_t *lock, char *name)
-{
-#ifdef USE_THREADS
-    int res = ethr_spinlock_init(&lock->slck);
-    if (res)
-	erts_thr_fatal_error(res, "init spinlock");
 #ifdef ERTS_ENABLE_LOCK_CHECK
-    erts_lc_init_lock(&lock->lc, name, ERTS_LC_FLG_LT_SPINLOCK);
+    erts_lc_init_lock_x(&lock->lc, name, ERTS_LC_FLG_LT_SPINLOCK, extra);
 #endif
 #ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_init_ref(&lock->lcnt);
-    erts_lcnt_install_new_lock_info(&lock->lcnt, name, ERTS_LCNT_LT_SPINLOCK);
-#endif
-#else
-    (void)lock;
+    erts_lcnt_init_ref_x(&lock->lcnt, name, extra, flags);
 #endif
+#endif /* USE_THREADS */
 }
 
 ERTS_GLB_INLINE void
@@ -3149,6 +3034,9 @@ erts_spinlock_destroy(erts_spinlock_t *lock)
 {
 #ifdef USE_THREADS
     int res;
+
+    ASSERT(!(lock->flags & ERTS_LOCK_FLAGS_PROPERTY_STATIC));
+
 #ifdef ERTS_ENABLE_LOCK_CHECK
     erts_lc_destroy_lock(&lock->lc);
 #endif
@@ -3232,41 +3120,26 @@ erts_lc_spinlock_is_locked(erts_spinlock_t *lock)
 /* rwspinlock */
 
 ERTS_GLB_INLINE void
-erts_rwlock_init_x(erts_rwlock_t *lock, char *name, Eterm extra)
+erts_rwlock_init(erts_rwlock_t *lock, char *name, Eterm extra, erts_lock_flags_t flags)
 {
 #ifdef USE_THREADS
     int res = ethr_rwlock_init(&lock->rwlck);
-    if (res)
-	erts_thr_fatal_error(res, "init rwlock");
-#ifdef ERTS_ENABLE_LOCK_CHECK
-    erts_lc_init_lock_x(&lock->lc, name, ERTS_LC_FLG_LT_RWSPINLOCK, extra);
-#endif
-#ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_init_ref(&lock->lcnt);
-    erts_lcnt_install_new_lock_info_x(&lock->lcnt, name, ERTS_LCNT_LT_RWSPINLOCK, extra);
-#endif
-#else
-    (void)lock;
+    if (res) {
+        erts_thr_fatal_error(res, "init rwlock");
+    }
+
+    flags |= ERTS_LOCK_TYPE_RWSPINLOCK;
+#ifdef DEBUG
+    lock->flags = flags;
 #endif
-}
 
-ERTS_GLB_INLINE void
-erts_rwlock_init(erts_rwlock_t *lock, char *name)
-{
-#ifdef USE_THREADS
-    int res = ethr_rwlock_init(&lock->rwlck);
-    if (res)
-	erts_thr_fatal_error(res, "init rwlock");
 #ifdef ERTS_ENABLE_LOCK_CHECK
-    erts_lc_init_lock(&lock->lc, name, ERTS_LC_FLG_LT_RWSPINLOCK);
+    erts_lc_init_lock_x(&lock->lc, name, ERTS_LC_FLG_LT_RWSPINLOCK, extra);
 #endif
 #ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_init_ref(&lock->lcnt);
-    erts_lcnt_install_new_lock_info(&lock->lcnt, name, ERTS_LCNT_LT_RWSPINLOCK);
-#endif
-#else
-    (void)lock;
+    erts_lcnt_init_ref_x(&lock->lcnt, name, extra, flags);
 #endif
+#endif /* USE_THREADS */
 }
 
 ERTS_GLB_INLINE void
@@ -3274,6 +3147,9 @@ erts_rwlock_destroy(erts_rwlock_t *lock)
 {
 #ifdef USE_THREADS
     int res;
+
+    ASSERT(!(lock->flags & ERTS_LOCK_FLAGS_PROPERTY_STATIC));
+
 #ifdef ERTS_ENABLE_LOCK_CHECK
     erts_lc_destroy_lock(&lock->lc);
 #endif
@@ -3305,7 +3181,7 @@ erts_read_unlock(erts_rwlock_t *lock)
     erts_lc_unlock_flg(&lock->lc, ERTS_LC_FLG_LO_READ);
 #endif
 #ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_unlock_opt(&lock->lcnt, ERTS_LCNT_LO_READ);
+    erts_lcnt_unlock_opt(&lock->lcnt, ERTS_LOCK_OPTION_READ);
 #endif
     ethr_read_unlock(&lock->rwlck);
 #else
@@ -3329,7 +3205,7 @@ erts_read_lock(erts_rwlock_t *lock)
 #endif
 #endif
 #ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_lock_opt(&lock->lcnt, ERTS_LCNT_LO_READ);
+    erts_lcnt_lock_opt(&lock->lcnt, ERTS_LOCK_OPTION_READ);
 #endif
     ethr_read_lock(&lock->rwlck);
 #ifdef ERTS_ENABLE_LOCK_COUNT
@@ -3348,7 +3224,7 @@ erts_write_unlock(erts_rwlock_t *lock)
     erts_lc_unlock_flg(&lock->lc, ERTS_LC_FLG_LO_READ_WRITE);
 #endif
 #ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_unlock_opt(&lock->lcnt, ERTS_LCNT_LO_READ_WRITE);
+    erts_lcnt_unlock_opt(&lock->lcnt, ERTS_LOCK_OPTION_RDWR);
 #endif
     ethr_write_unlock(&lock->rwlck);
 #else
@@ -3372,7 +3248,7 @@ erts_write_lock(erts_rwlock_t *lock)
 #endif
 #endif
 #ifdef ERTS_ENABLE_LOCK_COUNT
-    erts_lcnt_lock_opt(&lock->lcnt, ERTS_LCNT_LO_READ_WRITE);
+    erts_lcnt_lock_opt(&lock->lcnt, ERTS_LOCK_OPTION_RDWR);
 #endif
     ethr_write_lock(&lock->rwlck);
 #ifdef ERTS_ENABLE_LOCK_COUNT
diff --git a/erts/emulator/beam/erl_time_sup.c b/erts/emulator/beam/erl_time_sup.c
index 3084a8db75..6ddf97b463 100644
--- a/erts/emulator/beam/erl_time_sup.c
+++ b/erts/emulator/beam/erl_time_sup.c
@@ -954,8 +954,10 @@ erts_init_time_sup(int time_correction, ErtsTimeWarpMode time_warp_mode)
 
     ASSERT(ERTS_MONOTONIC_TIME_MIN < ERTS_MONOTONIC_TIME_MAX);
 
-    erts_smp_mtx_init(&erts_timeofday_mtx, "timeofday");
-    erts_smp_mtx_init(&erts_get_time_mtx, "get_time");
+    erts_smp_mtx_init(&erts_timeofday_mtx, "timeofday", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
+    erts_smp_mtx_init(&erts_get_time_mtx, "get_time", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
 
     time_sup.r.o.correction = time_correction;
     time_sup.r.o.warp_mode = time_warp_mode;
@@ -1120,8 +1122,9 @@ erts_init_time_sup(int time_correction, ErtsTimeWarpMode time_warp_mode)
 	rwmtx_opts.type = ERTS_SMP_RWMTX_TYPE_EXTREMELY_FREQUENT_READ;
 	rwmtx_opts.lived = ERTS_SMP_RWMTX_LONG_LIVED;
 
-	erts_smp_rwmtx_init_opt(&time_sup.inf.c.parmon.rwmtx,
-				&rwmtx_opts, "get_corrected_time");
+        erts_smp_rwmtx_init_opt(&time_sup.inf.c.parmon.rwmtx, &rwmtx_opts,
+            "get_corrected_time", NIL,
+            ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
 
 	cdatap = &time_sup.inf.c.parmon.cdata;
     
diff --git a/erts/emulator/beam/erl_trace.c b/erts/emulator/beam/erl_trace.c
index 4b06c55770..db7d0ac449 100644
--- a/erts/emulator/beam/erl_trace.c
+++ b/erts/emulator/beam/erl_trace.c
@@ -336,7 +336,8 @@ void erts_init_trace(void) {
     rwmtx_opts.type = ERTS_SMP_RWMTX_TYPE_EXTREMELY_FREQUENT_READ;
     rwmtx_opts.lived = ERTS_SMP_RWMTX_LONG_LIVED;
 
-    erts_smp_rwmtx_init_opt(&sys_trace_rwmtx, &rwmtx_opts, "sys_tracers");
+    erts_smp_rwmtx_init_opt(&sys_trace_rwmtx, &rwmtx_opts, "sys_tracers", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_DEBUG);
 
 #ifdef HAVE_ERTS_NOW_CPU
     erts_cpu_timestamp = 0;
@@ -2625,7 +2626,8 @@ init_sys_msg_dispatcher(void)
     sys_message_queue = NULL;
     sys_message_queue_end = NULL;
     erts_smp_cnd_init(&smq_cnd);
-    erts_smp_mtx_init(&smq_mtx, "sys_msg_q");
+    erts_smp_mtx_init(&smq_mtx, "sys_msg_q", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_DEBUG);
     erts_smp_thr_create(&sys_msg_dispatcher_tid,
 			sys_msg_dispatcher_func,
 			NULL,
@@ -3185,7 +3187,9 @@ static void init_tracer_nif()
     erts_smp_rwmtx_opt_t rwmtx_opt = ERTS_SMP_RWMTX_OPT_DEFAULT_INITER;
     rwmtx_opt.type = ERTS_SMP_RWMTX_TYPE_EXTREMELY_FREQUENT_READ;
     rwmtx_opt.lived = ERTS_SMP_RWMTX_LONG_LIVED;
-    erts_smp_rwmtx_init_opt(&tracer_mtx, &rwmtx_opt, "tracer_mtx");
+
+    erts_smp_rwmtx_init_opt(&tracer_mtx, &rwmtx_opt, "tracer_mtx", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_DEBUG);
 
     erts_tracer_nif_clear();
 
diff --git a/erts/emulator/beam/export.c b/erts/emulator/beam/export.c
index 57f5ba5436..828c833ffc 100644
--- a/erts/emulator/beam/export.c
+++ b/erts/emulator/beam/export.c
@@ -182,7 +182,8 @@ init_export_table(void)
     HashFunctions f;
     int i;
 
-    erts_smp_mtx_init(&export_staging_lock, "export_tab");
+    erts_smp_mtx_init(&export_staging_lock, "export_tab", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
     erts_smp_atomic_init_nob(&total_entries_bytes, 0);
 
     f.hash = (H_FUN) export_hash;
diff --git a/erts/emulator/beam/global.h b/erts/emulator/beam/global.h
index fc95535ec3..2105ee7a6c 100644
--- a/erts/emulator/beam/global.h
+++ b/erts/emulator/beam/global.h
@@ -1183,7 +1183,8 @@ void erts_ref_to_driver_monitor(Eterm ref, ErlDrvMonitor *mon);
 Eterm erts_driver_monitor_to_ref(Eterm* hp, const ErlDrvMonitor *mon);
 
 #if defined(ERTS_SMP) && defined(ERTS_ENABLE_LOCK_COUNT)
-void erts_lcnt_enable_io_lock_count(int enable);
+void erts_lcnt_update_driver_locks(int enable);
+void erts_lcnt_update_port_locks(int enable);
 #endif
 
 /* driver_tab.c */
diff --git a/erts/emulator/beam/io.c b/erts/emulator/beam/io.c
index 11cb2dfddf..135beab6e1 100644
--- a/erts/emulator/beam/io.c
+++ b/erts/emulator/beam/io.c
@@ -258,14 +258,7 @@ static ERTS_INLINE void port_init_instr(Port *prt
 #ifdef ERTS_SMP
     ASSERT(prt->drv_ptr && prt->lock);
     if (!prt->drv_ptr->lock) {
-	char *lock_str = "port_lock";
-#ifdef ERTS_ENABLE_LOCK_COUNT
-	Uint16 opt = ((erts_lcnt_rt_options & ERTS_LCNT_OPT_PORTLOCK)
-			    ? 0 : ERTS_LCNT_LT_DISABLE);
-#else
-	Uint16 opt = 0;
-#endif
-	erts_mtx_init_locked_x_opt(prt->lock, lock_str, id, opt);
+        erts_mtx_init_locked(prt->lock, "port_lock", id, ERTS_LOCK_FLAGS_CATEGORY_IO);
     }
 #endif
     erts_port_task_init_sched(&prt->sched, id);
@@ -3419,9 +3412,8 @@ void erts_init_io(int port_tab_size,
     else if (port_tab_size < ERTS_MIN_PORTS)
 	port_tab_size = ERTS_MIN_PORTS;
 
-    erts_smp_rwmtx_init_opt(&erts_driver_list_lock,
-			    &drv_list_rwmtx_opts,
-			    "driver_list");
+    erts_smp_rwmtx_init_opt(&erts_driver_list_lock, &drv_list_rwmtx_opts, "driver_list", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_IO);
     driver_list = NULL;
     erts_smp_tsd_key_create(&driver_list_lock_status_key,
 			    "erts_driver_list_lock_status_key");
@@ -3458,62 +3450,94 @@ void erts_init_io(int port_tab_size,
 }
 
 #if defined(ERTS_ENABLE_LOCK_COUNT) && defined(ERTS_SMP)
-static ERTS_INLINE void lcnt_enable_drv_lock_count(erts_driver_t *dp, int enable)
+static void lcnt_enable_driver_lock_count(erts_driver_t *dp, int enable)
 {
     if (dp->lock) {
-	if (enable) {
-			Eterm name_as_atom = erts_atom_put((byte*)dp->name, sys_strlen(dp->name),
-											   ERTS_ATOM_ENC_LATIN1, 1);
-			erts_lcnt_install_new_lock_info_x(&dp->lock->lcnt,
-				"driver_lock", ERTS_LCNT_LT_MUTEX, name_as_atom);
-		} else {
-			erts_lcnt_uninstall(&dp->lock->lcnt);
-		}
-	}
+        if (enable) {
+            Eterm name_as_atom = erts_atom_put((byte*)dp->name, sys_strlen(dp->name),
+                                                ERTS_ATOM_ENC_LATIN1, 1);
+
+            erts_lcnt_install_new_lock_info(&dp->lock->lcnt, "driver_lock", name_as_atom,
+                ERTS_LOCK_TYPE_MUTEX | ERTS_LOCK_FLAGS_CATEGORY_IO);
+        } else {
+            erts_lcnt_uninstall(&dp->lock->lcnt);
+        }
+    }
 }
 
-static ERTS_INLINE void lcnt_enable_port_lock_count(Port *prt, int enable)
+static void lcnt_enable_port_lock_count(Port *prt, int enable)
 {
     erts_aint32_t state = erts_atomic32_read_nob(&prt->state);
 
     if(enable) {
-		erts_lcnt_install_new_lock_info_x(&prt->sched.mtx.lcnt,
-			"port_sched_lock", ERTS_LCNT_LT_MUTEX,prt->common.id);
+        ErlDrvPDL pdl = prt->port_data_lock;
 
-		if (state & ERTS_PORT_SFLG_PORT_SPECIFIC_LOCK) {
-			erts_lcnt_install_new_lock_info_x(&prt->lock->lcnt,
-				"port_lock", ERTS_LCNT_LT_MUTEX, prt->common.id);
-		}
+        erts_lcnt_install_new_lock_info(&prt->sched.mtx.lcnt, "port_sched_lock",
+            prt->common.id, ERTS_LOCK_TYPE_MUTEX | ERTS_LOCK_FLAGS_CATEGORY_IO);
+
+        if(pdl) {
+            erts_lcnt_install_new_lock_info(&pdl->mtx.lcnt, "port_data_lock",
+                prt->common.id, ERTS_LOCK_TYPE_MUTEX | ERTS_LOCK_FLAGS_CATEGORY_IO);
+        }
+
+        if(state & ERTS_PORT_SFLG_PORT_SPECIFIC_LOCK) {
+            erts_lcnt_install_new_lock_info(&prt->lock->lcnt, "port_lock",
+                prt->common.id, ERTS_LOCK_TYPE_MUTEX | ERTS_LOCK_FLAGS_CATEGORY_IO);
+        }
     } else {
-		erts_lcnt_uninstall(&prt->sched.mtx.lcnt);
-		if (state & ERTS_PORT_SFLG_PORT_SPECIFIC_LOCK) {
-			erts_lcnt_uninstall(&prt->lock->lcnt);
-		}
-    }
-}
+        erts_lcnt_uninstall(&prt->sched.mtx.lcnt);
 
-void erts_lcnt_enable_io_lock_count(int enable) {
-    erts_driver_t *dp;
-    int ix, max = erts_ptab_max(&erts_port);
-    Port *prt;
+        if(prt->port_data_lock) {
+            erts_lcnt_uninstall(&prt->port_data_lock->mtx.lcnt);
+        }
 
-    for (ix = 0; ix < max; ix++) {
-	if ((prt = erts_pix2port(ix)) != NULL) {
-	    lcnt_enable_port_lock_count(prt, enable);
+        if(state & ERTS_PORT_SFLG_PORT_SPECIFIC_LOCK) {
+            erts_lcnt_uninstall(&prt->lock->lcnt);
         }
-    } /* for all ports */
+    }
+}
 
-    lcnt_enable_drv_lock_count(&vanilla_driver, enable);
-    lcnt_enable_drv_lock_count(&spawn_driver, enable);
+void erts_lcnt_update_driver_locks(int enable) {
+    erts_driver_t *driver;
+
+    lcnt_enable_driver_lock_count(&vanilla_driver, enable);
+    lcnt_enable_driver_lock_count(&spawn_driver, enable);
 #ifndef __WIN32__
-    lcnt_enable_drv_lock_count(&forker_driver, enable);
+    lcnt_enable_driver_lock_count(&forker_driver, enable);
 #endif
-    lcnt_enable_drv_lock_count(&fd_driver, enable);
-    /* enable lock counting in all drivers */
-    for (dp = driver_list; dp; dp = dp->next) {
-	lcnt_enable_drv_lock_count(dp, enable);
+    lcnt_enable_driver_lock_count(&fd_driver, enable);
+
+    erts_rwmtx_rlock(&erts_driver_list_lock);
+
+    for (driver = driver_list; driver; driver = driver->next) {
+        lcnt_enable_driver_lock_count(driver, enable);
+    }
+
+    erts_rwmtx_runlock(&erts_driver_list_lock);
+}
+
+void erts_lcnt_update_port_locks(int enable) {
+    int i, max;
+
+    max = erts_ptab_max(&erts_port);
+
+    for(i = 0; i < max; i++) {
+        int delay_handle;
+        Port *port;
+
+        delay_handle = erts_thr_progress_unmanaged_delay();
+        port = erts_pix2port(i);
+
+        if(port != NULL) {
+            lcnt_enable_port_lock_count(port, enable);
+        }
+
+        if(delay_handle != ERTS_THR_PRGR_DHANDLE_MANAGED) {
+            erts_thr_progress_unmanaged_continue(delay_handle);
+        }
     }
-} /* enable/disable lock counting of ports */
+}
+
 #endif /* defined(ERTS_ENABLE_LOCK_COUNT) && defined(ERTS_SMP) */
 /*
  * Buffering of data when using line oriented I/O on ports
@@ -7088,7 +7112,7 @@ driver_pdl_create(ErlDrvPort dp)
 	return NULL;
     pdl = erts_alloc(ERTS_ALC_T_PORT_DATA_LOCK,
 		     sizeof(struct erl_drv_port_data_lock));
-    erts_mtx_init_x(&pdl->mtx, "port_data_lock", pp->common.id);
+    erts_mtx_init(&pdl->mtx, "port_data_lock", pp->common.id, ERTS_LOCK_FLAGS_CATEGORY_IO);
     pdl_init_refc(pdl);
     erts_port_inc_refc(pp);
     pdl->prt = pp;
@@ -8255,22 +8279,16 @@ init_driver(erts_driver_t *drv, ErlDrvEntry *de, DE_Handle *handle)
     drv->flags = de->driver_flags;
     drv->handle = handle;
 #ifdef ERTS_SMP
-    if (drv->flags & ERL_DRV_FLAG_USE_PORT_LOCKING)
-	drv->lock = NULL;
-    else {
-	drv->lock = erts_alloc(ERTS_ALC_T_DRIVER_LOCK,
-			       sizeof(erts_mtx_t));
-	erts_mtx_init_x(drv->lock,
-			"driver_lock",
-#if defined(ERTS_ENABLE_LOCK_CHECK) || defined(ERTS_ENABLE_LOCK_COUNT)
-                        erts_atom_put((byte *) drv->name,
-				       sys_strlen(drv->name),
-                                       ERTS_ATOM_ENC_LATIN1,
-                                       1)
-#else
-			NIL
-#endif
-	    );
+    if (drv->flags & ERL_DRV_FLAG_USE_PORT_LOCKING) {
+        drv->lock = NULL;
+    } else {
+        Eterm driver_id = erts_atom_put((byte *) drv->name,
+                                        sys_strlen(drv->name),
+                                        ERTS_ATOM_ENC_LATIN1, 1);
+
+        drv->lock = erts_alloc(ERTS_ALC_T_DRIVER_LOCK, sizeof(erts_mtx_t));
+
+        erts_mtx_init(drv->lock, "driver_lock", driver_id, ERTS_LOCK_FLAGS_CATEGORY_IO);
     }
 #endif
     drv->entry = de;
diff --git a/erts/emulator/beam/module.c b/erts/emulator/beam/module.c
index 8ab6c713d6..7987cb2eb5 100644
--- a/erts/emulator/beam/module.c
+++ b/erts/emulator/beam/module.c
@@ -120,7 +120,8 @@ void init_module_table(void)
     }
 
     for (i=0; i<ERTS_NUM_CODE_IX; i++) {
-	erts_smp_rwmtx_init_x(&the_old_code_rwlocks[i], "old_code", make_small(i));
+        erts_smp_rwmtx_init(&the_old_code_rwlocks[i], "old_code", make_small(i),
+            ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
     }
     erts_smp_atomic_init_nob(&tot_module_bytes, 0);
 }
diff --git a/erts/emulator/beam/register.c b/erts/emulator/beam/register.c
index 7f60710124..bf3267cff1 100644
--- a/erts/emulator/beam/register.c
+++ b/erts/emulator/beam/register.c
@@ -145,7 +145,8 @@ void init_register_table(void)
     rwmtx_opt.type = ERTS_SMP_RWMTX_TYPE_FREQUENT_READ;
     rwmtx_opt.lived = ERTS_SMP_RWMTX_LONG_LIVED;
 
-    erts_smp_rwmtx_init_opt(&regtab_rwmtx, &rwmtx_opt, "reg_tab");
+    erts_smp_rwmtx_init_opt(&regtab_rwmtx, &rwmtx_opt, "reg_tab", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
 
     f.hash = (H_FUN) reg_hash;
     f.cmp  = (HCMP_FUN) reg_cmp;
diff --git a/erts/emulator/beam/safe_hash.c b/erts/emulator/beam/safe_hash.c
index 30b26a7296..527c9efeca 100644
--- a/erts/emulator/beam/safe_hash.c
+++ b/erts/emulator/beam/safe_hash.c
@@ -155,7 +155,8 @@ int safe_hash_table_sz(SafeHash *h)
 ** Init a pre allocated or static hash structure
 ** and allocate buckets. NOT SAFE
 */
-SafeHash* safe_hash_init(ErtsAlcType_t type, SafeHash* h, char* name, int size, SafeHashFunctions fun)
+SafeHash* safe_hash_init(ErtsAlcType_t type, SafeHash* h, char* name, erts_lock_flags_t flags,
+    int size, SafeHashFunctions fun)
 {
     int i, bytes;
 
@@ -170,7 +171,8 @@ SafeHash* safe_hash_init(ErtsAlcType_t type, SafeHash* h, char* name, int size,
     erts_smp_atomic_init_nob(&h->is_rehashing, 0);
     erts_smp_atomic_init_nob(&h->nitems, 0);
     for (i=0; i<SAFE_HASH_LOCK_CNT; i++) {
-	erts_smp_mtx_init(&h->lock_vec[i].mtx,"safe_hash");
+        erts_smp_mtx_init(&h->lock_vec[i].mtx, "safe_hash", NIL,
+            flags);
     }
     return h;
 }
@@ -273,5 +275,22 @@ void safe_hash_for_each(SafeHash* h, void (*func)(void *, void *), void *func_ar
     }
 }
 
+#ifdef ERTS_ENABLE_LOCK_COUNT
+void erts_lcnt_enable_hash_lock_count(SafeHash *h, erts_lock_flags_t flags, int enable) {
+    int i;
+
+    for(i = 0; i < SAFE_HASH_LOCK_CNT; i++) {
+        erts_smp_mtx_t *lock = &h->lock_vec[i].mtx;
+
+        if(enable) {
+            erts_lcnt_install_new_lock_info(&lock->lcnt, "safe_hash", NIL,
+                ERTS_LOCK_TYPE_MUTEX | flags);
+        } else {
+            erts_lcnt_uninstall(&lock->lcnt);
+        }
+    }
+}
+#endif /* ERTS_ENABLE_LOCK_COUNT */
+
 #endif /* !ERTS_SYS_CONTINOUS_FD_NUMBERS */
 
diff --git a/erts/emulator/beam/safe_hash.h b/erts/emulator/beam/safe_hash.h
index 285103cb17..dde48a6de8 100644
--- a/erts/emulator/beam/safe_hash.h
+++ b/erts/emulator/beam/safe_hash.h
@@ -28,6 +28,7 @@
 
 #include "sys.h"
 #include "erl_alloc.h"
+#include "erl_lock_flags.h"
 
 typedef unsigned long SafeHashValue;
 
@@ -85,7 +86,7 @@ typedef struct
     /* A: Lockless atomics */
 } SafeHash;
 
-SafeHash* safe_hash_init(ErtsAlcType_t, SafeHash*, char*, int, SafeHashFunctions);
+SafeHash* safe_hash_init(ErtsAlcType_t, SafeHash*, char*, erts_lock_flags_t, int, SafeHashFunctions);
 
 void  safe_hash_get_info(SafeHashInfo*, SafeHash*);
 int   safe_hash_table_sz(SafeHash *);
@@ -96,5 +97,9 @@ void* safe_hash_erase(SafeHash*, void*);
 
 void  safe_hash_for_each(SafeHash*, void (*func)(void *, void *), void *);
 
+#ifdef ERTS_ENABLE_LOCK_COUNT
+void erts_lcnt_enable_hash_lock_count(SafeHash*, erts_lock_flags_t, int);
+#endif
+
 #endif /* __SAFE_HASH_H__ */
 
diff --git a/erts/emulator/drivers/common/efile_drv.c b/erts/emulator/drivers/common/efile_drv.c
index 1538191d67..3a7b3bb50c 100644
--- a/erts/emulator/drivers/common/efile_drv.c
+++ b/erts/emulator/drivers/common/efile_drv.c
@@ -742,7 +742,8 @@ file_init(void)
     efile_init();
 
 #ifdef  USE_VM_PROBES
-    erts_mtx_init(&dt_driver_mutex, "efile_drv dtrace mutex");
+    erts_mtx_init(&dt_driver_mutex, "efile_drv dtrace mutex", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_IO);
     pthread_key_create(&dt_driver_key, NULL);
 #endif  /* USE_VM_PROBES */
 
diff --git a/erts/emulator/hipe/hipe_bif0.c b/erts/emulator/hipe/hipe_bif0.c
index 0225f17613..94bc563fda 100644
--- a/erts/emulator/hipe/hipe_bif0.c
+++ b/erts/emulator/hipe/hipe_bif0.c
@@ -1129,7 +1129,8 @@ struct hipe_ref {
 
 static inline void hipe_mfa_info_table_init_lock(void)
 {
-    erts_smp_rwmtx_init(&hipe_mfa_info_table.lock, "hipe_mfait_lock");
+    erts_smp_rwmtx_init(&hipe_mfa_info_table.lock, "hipe_mfait_lock", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
 }
 
 static inline void hipe_mfa_info_table_rlock(void)
diff --git a/erts/emulator/sys/common/erl_check_io.c b/erts/emulator/sys/common/erl_check_io.c
index ad580e7d52..799f67fc45 100644
--- a/erts/emulator/sys/common/erl_check_io.c
+++ b/erts/emulator/sys/common/erl_check_io.c
@@ -2564,24 +2564,22 @@ ERTS_CIO_EXPORT(erts_init_check_io)(void)
 #ifdef ERTS_SMP
     init_removed_fd_alloc();
     pollset.removed_list = NULL;
-    erts_smp_spinlock_init(&pollset.removed_list_lock,
-			   "pollset_rm_list");
+    erts_smp_spinlock_init(&pollset.removed_list_lock, "pollset_rm_list", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_IO);
     {
-	int i;
-	for (i=0; i<DRV_EV_STATE_LOCK_CNT; i++) {
-#ifdef ERTS_ENABLE_LOCK_COUNT
-	    erts_smp_mtx_init_x(&drv_ev_state_locks[i].lck, "drv_ev_state", make_small(i));
-#else
-	    erts_smp_mtx_init(&drv_ev_state_locks[i].lck, "drv_ev_state");
-#endif
-	}
+        int i;
+        for (i=0; i<DRV_EV_STATE_LOCK_CNT; i++) {
+            erts_smp_mtx_init(&drv_ev_state_locks[i].lck, "drv_ev_state", make_small(i),
+                ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_IO);
+        }
     }
 #endif
 #ifdef ERTS_SYS_CONTINOUS_FD_NUMBERS
     max_fds = ERTS_CIO_POLL_MAX_FDS();
     erts_smp_atomic_init_nob(&drv_ev_state_len, 0);
     drv_ev_state = NULL;
-    erts_smp_mtx_init(&drv_ev_state_grow_lock, "drv_ev_state_grow");
+    erts_smp_mtx_init(&drv_ev_state_grow_lock, "drv_ev_state_grow", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_IO);
 #else
     {
 	SafeHashFunctions hf;
@@ -2591,10 +2589,11 @@ ERTS_CIO_EXPORT(erts_init_check_io)(void)
 	hf.free = &drv_ev_state_free;
 	num_state_prealloc = 0;
 	state_prealloc_first = NULL;
-	erts_smp_spinlock_init(&state_prealloc_lock,"state_prealloc");
+	erts_smp_spinlock_init(&state_prealloc_lock,"state_prealloc", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_IO);
 
-	safe_hash_init(ERTS_ALC_T_DRV_EV_STATE, &drv_ev_state_tab, "drv_ev_state_tab", 
-		       DRV_EV_STATE_HTAB_SIZE, hf);
+	safe_hash_init(ERTS_ALC_T_DRV_EV_STATE, &drv_ev_state_tab, "drv_ev_state_tab",
+            ERTS_LOCK_FLAGS_CATEGORY_IO, DRV_EV_STATE_HTAB_SIZE, hf);
     }
 #endif
 }
@@ -3130,3 +3129,12 @@ ERTS_CIO_EXPORT(erts_check_io_debug)(ErtsCheckIoDebugInfo *ciodip)
     return counters.num_errors;
 }
 
+#ifdef ERTS_ENABLE_LOCK_COUNT
+void ERTS_CIO_EXPORT(erts_lcnt_update_cio_locks)(int enable) {
+#ifndef ERTS_SYS_CONTINOUS_FD_NUMBERS
+    erts_lcnt_enable_hash_lock_count(&drv_ev_state_tab, ERTS_LOCK_FLAGS_CATEGORY_IO, enable);
+#else
+    (void)enable;
+#endif
+}
+#endif /* ERTS_ENABLE_LOCK_COUNT */
diff --git a/erts/emulator/sys/common/erl_check_io.h b/erts/emulator/sys/common/erl_check_io.h
index ee4abeece9..2d3bb98afa 100644
--- a/erts/emulator/sys/common/erl_check_io.h
+++ b/erts/emulator/sys/common/erl_check_io.h
@@ -59,6 +59,11 @@ void erts_init_check_io_nkp(void);
 int erts_check_io_debug_kp(ErtsCheckIoDebugInfo *);
 int erts_check_io_debug_nkp(ErtsCheckIoDebugInfo *);
 
+#ifdef ERTS_ENABLE_LOCK_COUNT
+void erts_lcnt_update_cio_locks_kp(int enable);
+void erts_lcnt_update_cio_locks_nkp(int enable);
+#endif
+
 #else /* !ERTS_ENABLE_KERNEL_POLL */
 
 Uint erts_check_io_size(void);
@@ -72,6 +77,10 @@ void erts_check_io_interrupt_timed(int, ErtsMonotonicTime);
 void erts_check_io(int);
 void erts_init_check_io(void);
 
+#ifdef ERTS_ENABLE_LOCK_COUNT
+void erts_lcnt_update_cio_locks(int enable);
+#endif
+
 #endif
 
 extern erts_smp_atomic_t erts_check_io_time;
diff --git a/erts/emulator/sys/common/erl_mmap.c b/erts/emulator/sys/common/erl_mmap.c
index bb930ff03b..214ed01c82 100644
--- a/erts/emulator/sys/common/erl_mmap.c
+++ b/erts/emulator/sys/common/erl_mmap.c
@@ -2212,9 +2212,11 @@ erts_mmap_init(ErtsMemMapper* mm, ErtsMMapInit *init, int executable)
 	erts_exit(1, "erts_mmap: Failed to open /dev/zero\n");
 #endif
 
-    erts_smp_mtx_init(&mm->mtx, "erts_mmap");
+    erts_smp_mtx_init(&mm->mtx, "erts_mmap", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
     if (is_first_call) {
-        erts_mtx_init(&am.init_mutex, "mmap_init_atoms");
+        erts_mtx_init(&am.init_mutex, "mmap_init_atoms", NIL,
+            ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
     }
 
 #ifdef ERTS_HAVE_OS_PHYSICAL_MEMORY_RESERVATION
@@ -2816,7 +2818,8 @@ static void hard_dbg_mseg_init(void)
 {
     ErtsFreeSegDesc_fake* p;
 
-    erts_mtx_init(&hard_dbg_mseg_mtx, "hard_dbg_mseg");
+    erts_mtx_init(&hard_dbg_mseg_mtx, "hard_dbg_mseg", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_DEBUG);
     hard_dbg_mseg_tree.root = NULL;
     hard_dbg_mseg_tree.order = ADDR_ORDER;
 
diff --git a/erts/emulator/sys/common/erl_mseg.c b/erts/emulator/sys/common/erl_mseg.c
index b8f0bb7150..d69a79dc2a 100644
--- a/erts/emulator/sys/common/erl_mseg.c
+++ b/erts/emulator/sys/common/erl_mseg.c
@@ -1420,7 +1420,8 @@ erts_mseg_init(ErtsMsegInit_t *init)
 
     atoms_initialized = 0;
 
-    erts_mtx_init(&init_atoms_mutex, "mseg_init_atoms");
+    erts_mtx_init(&init_atoms_mutex, "mseg_init_atoms", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
 
 #ifdef ERTS_HAVE_EXEC_MMAPPER
     /* Initialize erts_exec_mapper *FIRST*, to increase probability
@@ -1449,7 +1450,8 @@ erts_mseg_init(ErtsMsegInit_t *init)
 	    ma->is_thread_safe = 0;
 	else {
 	    ma->is_thread_safe = 1;
-	    erts_mtx_init(&ma->mtx, "mseg");
+            erts_mtx_init(&ma->mtx, "mseg", make_small(i),
+                ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_ALLOCATOR);
 	}
 
 	ma->is_cache_check_scheduled = 0;
diff --git a/erts/emulator/sys/common/erl_poll.c b/erts/emulator/sys/common/erl_poll.c
index 5e7ae8953a..52a8b6a53f 100644
--- a/erts/emulator/sys/common/erl_poll.c
+++ b/erts/emulator/sys/common/erl_poll.c
@@ -336,7 +336,7 @@ static void fatal_error_async_signal_safe(char *error_str);
 
 static int max_fds = -1;
 static ErtsPollSet pollsets;
-static erts_smp_spinlock_t pollsets_lock;
+static erts_smp_mtx_t pollsets_lock;
 
 #if ERTS_POLL_USE_POLL
 
@@ -2583,7 +2583,8 @@ ERTS_POLL_EXPORT(erts_poll_max_fds)(void)
 void
 ERTS_POLL_EXPORT(erts_poll_init)(void)
 {
-    erts_smp_spinlock_init(&pollsets_lock, "pollsets_lock");
+    erts_smp_mtx_init(&pollsets_lock, "pollsets_lock", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_IO);
     pollsets = NULL;
 
     errno = 0;
@@ -2689,7 +2690,7 @@ ERTS_POLL_EXPORT(erts_poll_create_pollset)(void)
 #endif
 #ifdef ERTS_SMP
     erts_atomic32_init_nob(&ps->polled, 0);
-    erts_smp_mtx_init(&ps->mtx, "pollset");
+    erts_smp_mtx_init(&ps->mtx, "pollset", NIL, ERTS_LOCK_FLAGS_CATEGORY_IO);
 #endif
 #if defined(USE_THREADS) || ERTS_POLL_ASYNC_INTERRUPT_SUPPORT
     erts_atomic32_init_nob(&ps->wakeup_state, (erts_aint32_t) 0);
@@ -2731,10 +2732,10 @@ ERTS_POLL_EXPORT(erts_poll_create_pollset)(void)
 #endif
     erts_smp_atomic_set_nob(&ps->no_of_user_fds, 0); /* Don't count wakeup pipe and fallback fd */
 
-    erts_smp_spin_lock(&pollsets_lock);
+    erts_smp_mtx_lock(&pollsets_lock);
     ps->next = pollsets;
     pollsets = ps;
-    erts_smp_spin_unlock(&pollsets_lock);
+    erts_smp_mtx_unlock(&pollsets_lock);
 
     return ps;
 }
@@ -2795,7 +2796,7 @@ ERTS_POLL_EXPORT(erts_poll_destroy_pollset)(ErtsPollSet ps)
         close(ps->timer_fd);
 #endif
 
-    erts_smp_spin_lock(&pollsets_lock);
+    erts_smp_mtx_lock(&pollsets_lock);
     if (ps == pollsets)
 	pollsets = pollsets->next;
     else {
@@ -2805,7 +2806,7 @@ ERTS_POLL_EXPORT(erts_poll_destroy_pollset)(ErtsPollSet ps)
 	ASSERT(ps == prev_ps->next);
 	prev_ps->next = ps->next;
     }
-    erts_smp_spin_unlock(&pollsets_lock);
+    erts_smp_mtx_unlock(&pollsets_lock);
 
     erts_free(ERTS_ALC_T_POLLSET, (void *) ps);
 }
@@ -3148,3 +3149,26 @@ print_misc_debug_info(void)
 }
     
 #endif
+
+#ifdef ERTS_ENABLE_LOCK_COUNT
+static void erts_lcnt_enable_pollset_lock_count(ErtsPollSet pollset, int enable) {
+    if(enable) {
+        erts_lcnt_install_new_lock_info(&pollset->mtx.lcnt, "pollset_rm", NIL,
+            ERTS_LOCK_TYPE_MUTEX | ERTS_LOCK_FLAGS_CATEGORY_IO);
+    } else {
+        erts_lcnt_uninstall(&pollset->mtx.lcnt);
+    }
+}
+
+void ERTS_POLL_EXPORT(erts_lcnt_update_pollset_locks)(int enable) {
+    ErtsPollSet iterator;
+
+    erts_smp_mtx_lock(&pollsets_lock);
+
+    for(iterator = pollsets; iterator != NULL; iterator = iterator->next) {
+        erts_lcnt_enable_pollset_lock_count(iterator, enable);
+    }
+
+    erts_smp_mtx_unlock(&pollsets_lock);
+}
+#endif
diff --git a/erts/emulator/sys/common/erl_poll.h b/erts/emulator/sys/common/erl_poll.h
index c16122610d..b3b4d79984 100644
--- a/erts/emulator/sys/common/erl_poll.h
+++ b/erts/emulator/sys/common/erl_poll.h
@@ -260,4 +260,8 @@ void		ERTS_POLL_EXPORT(erts_poll_get_selected_events)(ErtsPollSet,
 
 int erts_poll_new_table_len(int old_len, int need_len);
 
+#ifdef ERTS_ENABLE_LOCK_COUNT
+void ERTS_POLL_EXPORT(erts_lcnt_update_pollset_locks)(int enable);
+#endif
+
 #endif /* #ifndef ERL_POLL_H__ */
diff --git a/erts/emulator/sys/unix/sys.c b/erts/emulator/sys/unix/sys.c
index e86258b5e0..de4ec61c47 100644
--- a/erts/emulator/sys/unix/sys.c
+++ b/erts/emulator/sys/unix/sys.c
@@ -1550,7 +1550,8 @@ erl_sys_args(int* argc, char** argv)
 {
     int i, j;
 
-    erts_smp_rwmtx_init(&environ_rwmtx, "environ");
+    erts_smp_rwmtx_init(&environ_rwmtx, "environ", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
 
     i = 1;
 
diff --git a/erts/emulator/sys/unix/sys_time.c b/erts/emulator/sys/unix/sys_time.c
index 4f26639703..102ef7bebf 100644
--- a/erts/emulator/sys/unix/sys_time.c
+++ b/erts/emulator/sys/unix/sys_time.c
@@ -304,8 +304,8 @@ sys_init_time(ErtsSysInitTimeResult *init_resp)
 	    erts_sys_time_data__.r.o.os_times =
 		clock_gettime_times_verified;
 #endif
-	    erts_smp_mtx_init(&internal_state.w.f.mtx,
-			      "os_monotonic_time");
+            erts_smp_mtx_init(&internal_state.w.f.mtx, "os_monotonic_time", NIL,
+                ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_IO);
 	    internal_state.w.f.last_delivered
 		= clock_gettime_monotonic();
 	    init_resp->os_monotonic_time_info.locked_use = 1;
diff --git a/erts/emulator/sys/win32/erl_poll.c b/erts/emulator/sys/win32/erl_poll.c
index b10fc1e430..8743f83a50 100644
--- a/erts/emulator/sys/win32/erl_poll.c
+++ b/erts/emulator/sys/win32/erl_poll.c
@@ -142,7 +142,8 @@ static erts_mtx_t save_ops_mtx;
 
 static void poll_debug_init(void)
 {
-    erts_mtx_init(&save_ops_mtx, "save_ops_lock");
+    erts_mtx_init(&save_ops_mtx, "save_ops_lock", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_DEBUG);
 }
 
 void poll_debug_set_active_fd(ErtsSysFdType fd)
@@ -677,7 +678,7 @@ static void new_waiter(ErtsPollSet ps)
     w->active_events = 1;
     w->highwater = 1;
     w->total_events = 1;
-    erts_mtx_init(&w->mtx, "pollwaiter");
+    erts_mtx_init(&w->mtx, "pollwaiter", NIL, ERTS_LOCK_FLAGS_CATEGORY_IO);
 
 
     /*
@@ -1359,7 +1360,7 @@ ErtsPollSet erts_poll_create_pollset(void)
 
     erts_atomic32_init_nob(&ps->wakeup_state, ERTS_POLL_NOT_WOKEN);
 #ifdef ERTS_SMP
-    erts_smp_mtx_init(&ps->mtx, "pollset");
+    erts_smp_mtx_init(&ps->mtx, "pollset", NIL, ERTS_LOCK_FLAGS_CATEGORY_IO);
 #endif
     init_timeout_time(ps);
 
@@ -1411,7 +1412,8 @@ void  erts_poll_init(void)
     HARDTRACEF(("In erts_poll_init"));
     erts_sys_break_event = CreateManualEvent(FALSE);
 
-    erts_mtx_init(&break_waiter_lock,"break_waiter_lock");
+    erts_mtx_init(&break_waiter_lock, "break_waiter_lock", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_IO);
     break_happened_event = CreateManualEvent(FALSE);
     erts_atomic32_init_nob(&break_waiter_state, 0); 
 
diff --git a/erts/emulator/sys/win32/sys_env.c b/erts/emulator/sys/win32/sys_env.c
index 21ef71ad9a..8fcee1cbb6 100644
--- a/erts/emulator/sys/win32/sys_env.c
+++ b/erts/emulator/sys/win32/sys_env.c
@@ -37,7 +37,8 @@ static erts_smp_rwmtx_t environ_rwmtx;
 void

 erts_sys_env_init(void)

 {

-    erts_smp_rwmtx_init(&environ_rwmtx, "environ");

+    erts_smp_rwmtx_init(&environ_rwmtx, "environ", NIL,

+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);

 }

 

 int

diff --git a/erts/emulator/sys/win32/sys_time.c b/erts/emulator/sys/win32/sys_time.c
index e8c67b3928..88131aaa6a 100644
--- a/erts/emulator/sys/win32/sys_time.c
+++ b/erts/emulator/sys/win32/sys_time.c
@@ -300,8 +300,8 @@ sys_init_time(ErtsSysInitTimeResult *init_resp)
     module = GetModuleHandle(kernel_dll_name);
     if (!module) {
     get_tick_count:
-	erts_smp_mtx_init(&internal_state.w.f.mtime_mtx,
-			  "os_monotonic_time");
+        erts_smp_mtx_init(&internal_state.w.f.mtime_mtx, "os_monotonic_time", NIL,
+            ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
 	internal_state.w.f.wrap = 0;
 	internal_state.w.f.last_tick_count = 0;
 
diff --git a/erts/etc/common/Makefile.in b/erts/etc/common/Makefile.in
index 583426460e..4bcbb288b3 100644
--- a/erts/etc/common/Makefile.in
+++ b/erts/etc/common/Makefile.in
@@ -57,7 +57,7 @@ ERTS_INCL = -I$(ERL_TOP)/erts/include \
 CC        = @CC@
 WFLAGS    = @WFLAGS@
 CFLAGS    = @CFLAGS@ @DEFS@ $(TYPE_FLAGS) @WFLAGS@ -I$(SYSDIR) -I$(EMUDIR) \
-            $(ERTS_INCL) -DOTP_SYSTEM_VERSION=\"$(SYSTEM_VSN)\"
+            -I$(COMSYSDIR) $(ERTS_INCL) -DOTP_SYSTEM_VERSION=\"$(SYSTEM_VSN)\"
 LD        = @LD@
 LIBS      = @LIBS@
 LDFLAGS   = @LDFLAGS@
@@ -77,6 +77,7 @@ endif
 BINDIR    = $(ERL_TOP)/bin/$(TARGET)
 OBJDIR    = $(ERL_TOP)/erts/obj$(TYPEMARKER)/$(TARGET)
 EMUDIR    = $(ERL_TOP)/erts/emulator/beam
+COMSYSDIR = $(ERL_TOP)/erts/emulator/sys/common
 EMUOSDIR  = $(ERL_TOP)/erts/emulator/@ERLANG_OSTYPE@
 SYSDIR    = $(ERL_TOP)/erts/emulator/sys/@ERLANG_OSTYPE@
 DRVDIR    = $(ERL_TOP)/erts/emulator/drivers/@ERLANG_OSTYPE@