1 files changed, 251 insertions, 149 deletions

diff --git a/erts/emulator/beam/erl_process_lock.c b/erts/emulator/beam/erl_process_lock.c
index 0bee2c848c..ff124d5ba7 100644
--- a/erts/emulator/beam/erl_process_lock.c
+++ b/erts/emulator/beam/erl_process_lock.c
@@ -1,7 +1,7 @@
 /*
  * %CopyrightBegin%
  *
- * Copyright Ericsson AB 2007-2012. All Rights Reserved.
+ * Copyright Ericsson AB 2007-2017. All Rights Reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -106,26 +106,19 @@ static struct {
     Sint16 proc_lock_msgq;
     Sint16 proc_lock_btm;
     Sint16 proc_lock_status;
+    Sint16 proc_lock_trace;
 } lc_id;
 #endif
 
 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), 1);
-#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);
@@ -152,6 +145,7 @@ erts_init_proc_lock(int cpus)
     lc_id.proc_lock_msgq	= erts_lc_get_lock_order_id("proc_msgq");
     lc_id.proc_lock_btm		= erts_lc_get_lock_order_id("proc_btm");
     lc_id.proc_lock_status	= erts_lc_get_lock_order_id("proc_status");
+    lc_id.proc_lock_trace	= erts_lc_get_lock_order_id("proc_trace");
 #endif
 }
 
@@ -942,7 +936,7 @@ erts_pid2proc_opt(Process *c_p,
 			erts_proc_inc_refc(proc);
 
 #if ERTS_PROC_LOCK_OWN_IMPL && defined(ERTS_ENABLE_LOCK_COUNT)
-		    erts_lcnt_proc_lock_unaquire(&proc->lock, lcnt_locks);
+		    erts_lcnt_proc_lock_unacquire(&proc->lock, lcnt_locks);
 #endif
 
 		    managed = dhndl == ERTS_THR_PRGR_DHANDLE_MANAGED;
@@ -1004,6 +998,41 @@ erts_pid2proc_opt(Process *c_p,
     return proc;
 }
 
+static ERTS_INLINE
+Process *proc_lookup_inc_refc(Eterm pid, int allow_exit)
+{
+    Process *proc;
+#ifdef ERTS_SMP
+    ErtsThrPrgrDelayHandle dhndl;
+
+    dhndl = erts_thr_progress_unmanaged_delay();
+#endif
+
+    proc = erts_proc_lookup_raw(pid);
+    if (proc) {
+        if (!allow_exit && ERTS_PROC_IS_EXITING(proc))
+            proc = NULL;
+        else
+            erts_proc_inc_refc(proc);
+    }
+
+#ifdef ERTS_SMP
+    erts_thr_progress_unmanaged_continue(dhndl);
+#endif
+
+    return proc;
+}
+
+Process *erts_proc_lookup_inc_refc(Eterm pid)
+{
+    return proc_lookup_inc_refc(pid, 0);
+}
+
+Process *erts_proc_lookup_raw_inc_refc(Eterm pid)
+{
+    return proc_lookup_inc_refc(pid, 1);
+}
+
 void
 erts_proc_lock_init(Process *p)
 {
@@ -1025,38 +1054,42 @@ erts_proc_lock_init(Process *p)
 #endif
 #elif ERTS_PROC_LOCK_RAW_MUTEX_IMPL
 
-#ifdef ERTS_ENABLE_LOCK_COUNT
-    int do_lock_count = 1;
-#else
-    int do_lock_count = 0;
-#endif
-
-    erts_mtx_init_x(&p->lock.main, "proc_main", p->common.id, do_lock_count);
+    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, do_lock_count);
+    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, do_lock_count);
+    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, do_lock_count);
+    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,
-		    do_lock_count);
+    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(&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);
+#endif
 #endif
 #ifdef ERTS_PROC_LOCK_DEBUG
     for (i = 0; i <= ERTS_PROC_LOCK_MAX_BIT; i++)
@@ -1078,6 +1111,7 @@ erts_proc_lock_fin(Process *p)
     erts_mtx_destroy(&p->lock.msgq);
     erts_mtx_destroy(&p->lock.btm);
     erts_mtx_destroy(&p->lock.status);
+    erts_mtx_destroy(&p->lock.trace);
 #endif
 #if defined(ERTS_ENABLE_LOCK_COUNT) && defined(ERTS_SMP)
     erts_lcnt_proc_lock_destroy(p);
@@ -1088,107 +1122,70 @@ 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) {
-    if (!(erts_lcnt_rt_options & ERTS_LCNT_OPT_PROCLOCK)) {
-        erts_lcnt_init_lock_empty(&(p->lock.lcnt_main));
-        erts_lcnt_init_lock_empty(&(p->lock.lcnt_msgq));
-        erts_lcnt_init_lock_empty(&(p->lock.lcnt_btm));
-        erts_lcnt_init_lock_empty(&(p->lock.lcnt_link));
-        erts_lcnt_init_lock_empty(&(p->lock.lcnt_status));
-    } else { /* now the common case */
-        Eterm pid = (p->common.id != ERTS_INVALID_PID) ? p->common.id : NIL;
-        erts_lcnt_init_lock_x(&(p->lock.lcnt_main),  "proc_main",  ERTS_LCNT_LT_PROCLOCK, pid);
-        erts_lcnt_init_lock_x(&(p->lock.lcnt_msgq),  "proc_msgq",  ERTS_LCNT_LT_PROCLOCK, pid);
-        erts_lcnt_init_lock_x(&(p->lock.lcnt_btm),   "proc_btm",   ERTS_LCNT_LT_PROCLOCK, pid);
-        erts_lcnt_init_lock_x(&(p->lock.lcnt_link),  "proc_link",  ERTS_LCNT_LT_PROCLOCK, pid);
-        erts_lcnt_init_lock_x(&(p->lock.lcnt_status),"proc_status",ERTS_LCNT_LT_PROCLOCK, pid);
-    } /* the lock names should really be aligned to four characters */
+    erts_lcnt_init_ref(&p->lock.lcnt_carrier);
+
+    if(erts_lcnt_check_enabled(ERTS_LOCK_FLAGS_CATEGORY_PROCESS)) {
+        erts_lcnt_enable_proc_lock_count(p, 1);
+    }
 } /* logic reversed */
 
 void erts_lcnt_proc_lock_destroy(Process *p) {
-    erts_lcnt_destroy_lock(&(p->lock.lcnt_main));
-    erts_lcnt_destroy_lock(&(p->lock.lcnt_msgq));
-    erts_lcnt_destroy_lock(&(p->lock.lcnt_btm));
-    erts_lcnt_destroy_lock(&(p->lock.lcnt_link));
-    erts_lcnt_destroy_lock(&(p->lock.lcnt_status));
+    erts_lcnt_uninstall(&p->lock.lcnt_carrier);
 }
 
-static void lcnt_enable_proc_lock_count(Process *proc, int enable) {
-    if (enable) {
-        if (!ERTS_LCNT_LOCK_TYPE(&(proc->lock.lcnt_main))) {
-            erts_lcnt_proc_lock_init(proc);
-        }
-    }
-    else {
-        if (ERTS_LCNT_LOCK_TYPE(&(proc->lock.lcnt_main))) {
-            erts_lcnt_proc_lock_destroy(proc);
-        }
+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;
+
+        carrier = erts_lcnt_create_lock_info_carrier(ERTS_LCNT_PROCLOCK_COUNT);
+
+        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);
     }
 }
 
-void erts_lcnt_proc_lock(erts_proc_lock_t *lock, ErtsProcLocks locks) {
-    if (!(erts_lcnt_rt_options & ERTS_LCNT_OPT_PROCLOCK)) return;
-    if (locks & ERTS_PROC_LOCK_MAIN) { erts_lcnt_lock(&(lock->lcnt_main)); }
-    if (locks & ERTS_PROC_LOCK_MSGQ) { erts_lcnt_lock(&(lock->lcnt_msgq)); }
-    if (locks & ERTS_PROC_LOCK_BTM) { erts_lcnt_lock(&(lock->lcnt_btm)); }
-    if (locks & ERTS_PROC_LOCK_LINK) { erts_lcnt_lock(&(lock->lcnt_link)); }
-    if (locks & ERTS_PROC_LOCK_STATUS) { erts_lcnt_lock(&(lock->lcnt_status)); }
-}
+void erts_lcnt_update_process_locks(int enable) {
+    int i, max;
 
-void erts_lcnt_proc_lock_post_x(erts_proc_lock_t *lock, ErtsProcLocks locks,
-                                char *file, unsigned int line) {
-    if (!(erts_lcnt_rt_options & ERTS_LCNT_OPT_PROCLOCK)) return;
-    if (locks & ERTS_PROC_LOCK_MAIN) {
-	erts_lcnt_lock_post_x(&(lock->lcnt_main), file, line);
-    }
-    if (locks & ERTS_PROC_LOCK_MSGQ) {
-        erts_lcnt_lock_post_x(&(lock->lcnt_msgq), file, line);
-    }
-    if (locks & ERTS_PROC_LOCK_BTM) {
-        erts_lcnt_lock_post_x(&(lock->lcnt_btm), file, line);
-    }
-    if (locks & ERTS_PROC_LOCK_LINK) {
-	erts_lcnt_lock_post_x(&(lock->lcnt_link), file, line);
-    }
-    if (locks & ERTS_PROC_LOCK_STATUS) {
-	erts_lcnt_lock_post_x(&(lock->lcnt_status), file, line);
-    }
-}
+    max = erts_ptab_max(&erts_proc);
 
-void erts_lcnt_proc_lock_unaquire(erts_proc_lock_t *lock, ErtsProcLocks locks) {
-    if (!(erts_lcnt_rt_options & ERTS_LCNT_OPT_PROCLOCK)) return;
-    if (locks & ERTS_PROC_LOCK_MAIN) { erts_lcnt_lock_unaquire(&(lock->lcnt_main)); }
-    if (locks & ERTS_PROC_LOCK_MSGQ) { erts_lcnt_lock_unaquire(&(lock->lcnt_msgq)); }
-    if (locks & ERTS_PROC_LOCK_BTM) { erts_lcnt_lock_unaquire(&(lock->lcnt_btm)); }
-    if (locks & ERTS_PROC_LOCK_LINK) { erts_lcnt_lock_unaquire(&(lock->lcnt_link)); }
-    if (locks & ERTS_PROC_LOCK_STATUS) { erts_lcnt_lock_unaquire(&(lock->lcnt_status)); }
-}
+    for(i = 0; i < max; i++) {
+        int delay_handle;
+        Process *proc;
+
+        delay_handle = erts_thr_progress_unmanaged_delay();
+        proc = erts_pix2proc(i);
 
-void erts_lcnt_proc_unlock(erts_proc_lock_t *lock, ErtsProcLocks locks) {
-    if (!(erts_lcnt_rt_options & ERTS_LCNT_OPT_PROCLOCK)) return;
-    if (locks & ERTS_PROC_LOCK_MAIN) { erts_lcnt_unlock(&(lock->lcnt_main)); }
-    if (locks & ERTS_PROC_LOCK_MSGQ) { erts_lcnt_unlock(&(lock->lcnt_msgq)); }
-    if (locks & ERTS_PROC_LOCK_BTM) { erts_lcnt_unlock(&(lock->lcnt_btm)); }
-    if (locks & ERTS_PROC_LOCK_LINK) { erts_lcnt_unlock(&(lock->lcnt_link)); }
-    if (locks & ERTS_PROC_LOCK_STATUS) { erts_lcnt_unlock(&(lock->lcnt_status)); }
+        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);
+        }
+    }
 }
-void erts_lcnt_proc_trylock(erts_proc_lock_t *lock, ErtsProcLocks locks, int res) {
-    if (!(erts_lcnt_rt_options & ERTS_LCNT_OPT_PROCLOCK)) return;
-    if (locks & ERTS_PROC_LOCK_MAIN) { erts_lcnt_trylock(&(lock->lcnt_main), res); }
-    if (locks & ERTS_PROC_LOCK_MSGQ) { erts_lcnt_trylock(&(lock->lcnt_msgq), res); }
-    if (locks & ERTS_PROC_LOCK_BTM) { erts_lcnt_trylock(&(lock->lcnt_btm), res); }
-    if (locks & ERTS_PROC_LOCK_LINK) { erts_lcnt_trylock(&(lock->lcnt_link), res); }
-    if (locks & ERTS_PROC_LOCK_STATUS) { erts_lcnt_trylock(&(lock->lcnt_status), res); }
-} /* reversed logic */
+
 #endif /* ERTS_ENABLE_LOCK_COUNT */
 
 
@@ -1203,7 +1200,7 @@ erts_proc_lc_lock(Process *p, ErtsProcLocks locks, char *file, unsigned int line
 {
     erts_lc_lock_t lck = ERTS_LC_LOCK_INIT(-1,
 					   p->common.id,
-					   ERTS_LC_FLG_LT_PROCLOCK);
+					   ERTS_LOCK_TYPE_PROCLOCK);
     if (locks & ERTS_PROC_LOCK_MAIN) {
 	lck.id = lc_id.proc_lock_main;
 	erts_lc_lock_x(&lck,file,line);
@@ -1224,6 +1221,10 @@ erts_proc_lc_lock(Process *p, ErtsProcLocks locks, char *file, unsigned int line
 	lck.id = lc_id.proc_lock_status;
 	erts_lc_lock_x(&lck,file,line);
     }
+    if (locks & ERTS_PROC_LOCK_TRACE) {
+	lck.id = lc_id.proc_lock_trace;
+	erts_lc_lock_x(&lck,file,line);
+    }
 }
 
 void
@@ -1232,7 +1233,7 @@ erts_proc_lc_trylock(Process *p, ErtsProcLocks locks, int locked,
 {
     erts_lc_lock_t lck = ERTS_LC_LOCK_INIT(-1,
 					   p->common.id,
-					   ERTS_LC_FLG_LT_PROCLOCK);
+					   ERTS_LOCK_TYPE_PROCLOCK);
     if (locks & ERTS_PROC_LOCK_MAIN) {
 	lck.id = lc_id.proc_lock_main;
 	erts_lc_trylock_x(locked, &lck, file, line);
@@ -1253,6 +1254,10 @@ erts_proc_lc_trylock(Process *p, ErtsProcLocks locks, int locked,
 	lck.id = lc_id.proc_lock_status;
 	erts_lc_trylock_x(locked, &lck, file, line);
     }
+    if (locks & ERTS_PROC_LOCK_TRACE) {
+	lck.id = lc_id.proc_lock_trace;
+	erts_lc_trylock_x(locked, &lck, file, line);
+    }
 }
 
 void
@@ -1260,7 +1265,11 @@ erts_proc_lc_unlock(Process *p, ErtsProcLocks locks)
 {
     erts_lc_lock_t lck = ERTS_LC_LOCK_INIT(-1,
 					   p->common.id,
-					   ERTS_LC_FLG_LT_PROCLOCK);
+					   ERTS_LOCK_TYPE_PROCLOCK);
+    if (locks & ERTS_PROC_LOCK_TRACE) {
+	lck.id = lc_id.proc_lock_trace;
+	erts_lc_unlock(&lck);
+    }
     if (locks & ERTS_PROC_LOCK_STATUS) {
 	lck.id = lc_id.proc_lock_status;
 	erts_lc_unlock(&lck);
@@ -1291,7 +1300,11 @@ erts_proc_lc_might_unlock(Process *p, ErtsProcLocks locks)
 #if ERTS_PROC_LOCK_OWN_IMPL
     erts_lc_lock_t lck = ERTS_LC_LOCK_INIT(-1,
 					   p->common.id,
-					   ERTS_LC_FLG_LT_PROCLOCK);
+					   ERTS_LOCK_TYPE_PROCLOCK);
+    if (locks & ERTS_PROC_LOCK_TRACE) {
+	lck.id = lc_id.proc_lock_trace;
+	erts_lc_might_unlock(&lck);
+    }
     if (locks & ERTS_PROC_LOCK_STATUS) {
 	lck.id = lc_id.proc_lock_status;
 	erts_lc_might_unlock(&lck);
@@ -1323,6 +1336,8 @@ erts_proc_lc_might_unlock(Process *p, ErtsProcLocks locks)
 	erts_lc_might_unlock(&p->lock.btm.lc);
     if (locks & ERTS_PROC_LOCK_STATUS)
 	erts_lc_might_unlock(&p->lock.status.lc);
+    if (locks & ERTS_PROC_LOCK_TRACE)
+	erts_lc_might_unlock(&p->lock.trace.lc);
 #endif
 }
 
@@ -1333,7 +1348,7 @@ erts_proc_lc_require_lock(Process *p, ErtsProcLocks locks, char *file,
 #if ERTS_PROC_LOCK_OWN_IMPL
     erts_lc_lock_t lck = ERTS_LC_LOCK_INIT(-1,
 					   p->common.id,
-					   ERTS_LC_FLG_LT_PROCLOCK);
+					   ERTS_LOCK_TYPE_PROCLOCK);
     if (locks & ERTS_PROC_LOCK_MAIN) {
 	lck.id = lc_id.proc_lock_main;
 	erts_lc_require_lock(&lck, file, line);
@@ -1354,6 +1369,10 @@ erts_proc_lc_require_lock(Process *p, ErtsProcLocks locks, char *file,
 	lck.id = lc_id.proc_lock_status;
 	erts_lc_require_lock(&lck, file, line);
     }
+    if (locks & ERTS_PROC_LOCK_TRACE) {
+	lck.id = lc_id.proc_lock_trace;
+	erts_lc_require_lock(&lck, file, line);
+    }
 #elif ERTS_PROC_LOCK_RAW_MUTEX_IMPL
     if (locks & ERTS_PROC_LOCK_MAIN)
 	erts_lc_require_lock(&p->lock.main.lc, file, line);
@@ -1365,6 +1384,8 @@ erts_proc_lc_require_lock(Process *p, ErtsProcLocks locks, char *file,
 	erts_lc_require_lock(&p->lock.btm.lc, file, line);
     if (locks & ERTS_PROC_LOCK_STATUS)
 	erts_lc_require_lock(&p->lock.status.lc, file, line);
+    if (locks & ERTS_PROC_LOCK_TRACE)
+	erts_lc_require_lock(&p->lock.trace.lc, file, line);
 #endif
 }
 
@@ -1374,7 +1395,11 @@ erts_proc_lc_unrequire_lock(Process *p, ErtsProcLocks locks)
 #if ERTS_PROC_LOCK_OWN_IMPL
     erts_lc_lock_t lck = ERTS_LC_LOCK_INIT(-1,
 					   p->common.id,
-					   ERTS_LC_FLG_LT_PROCLOCK);
+					   ERTS_LOCK_TYPE_PROCLOCK);
+    if (locks & ERTS_PROC_LOCK_TRACE) {
+	lck.id = lc_id.proc_lock_trace;
+	erts_lc_unrequire_lock(&lck);
+    }
     if (locks & ERTS_PROC_LOCK_STATUS) {
 	lck.id = lc_id.proc_lock_status;
 	erts_lc_unrequire_lock(&lck);
@@ -1406,6 +1431,8 @@ erts_proc_lc_unrequire_lock(Process *p, ErtsProcLocks locks)
 	erts_lc_unrequire_lock(&p->lock.btm.lc);
     if (locks & ERTS_PROC_LOCK_STATUS)
 	erts_lc_unrequire_lock(&p->lock.status.lc);
+    if (locks & ERTS_PROC_LOCK_TRACE)
+	erts_lc_unrequire_lock(&p->lock.trace.lc);
 #endif
 }
 
@@ -1417,7 +1444,7 @@ erts_proc_lc_trylock_force_busy(Process *p, ErtsProcLocks locks)
     if (locks & ERTS_PROC_LOCKS_ALL) {
 	erts_lc_lock_t lck = ERTS_LC_LOCK_INIT(-1,
 					       p->common.id,
-					       ERTS_LC_FLG_LT_PROCLOCK);
+					       ERTS_LOCK_TYPE_PROCLOCK);
 
 	if (locks & ERTS_PROC_LOCK_MAIN)
 	    lck.id = lc_id.proc_lock_main;
@@ -1429,6 +1456,8 @@ erts_proc_lc_trylock_force_busy(Process *p, ErtsProcLocks locks)
 	    lck.id = lc_id.proc_lock_btm;
 	else if (locks & ERTS_PROC_LOCK_STATUS)
 	    lck.id = lc_id.proc_lock_status;
+	else if (locks & ERTS_PROC_LOCK_TRACE)
+	    lck.id = lc_id.proc_lock_trace;
 	else
 	    erts_lc_fail("Unknown proc lock found");
 
@@ -1441,29 +1470,75 @@ erts_proc_lc_trylock_force_busy(Process *p, ErtsProcLocks locks)
 
 void erts_proc_lc_chk_only_proc_main(Process *p)
 {
-#if ERTS_PROC_LOCK_OWN_IMPL
-    erts_lc_lock_t proc_main = ERTS_LC_LOCK_INIT(lc_id.proc_lock_main,
-						 p->common.id,
-						 ERTS_LC_FLG_LT_PROCLOCK);
-    erts_lc_check_exact(&proc_main, 1);
-#elif ERTS_PROC_LOCK_RAW_MUTEX_IMPL
-    erts_lc_check_exact(&p->lock.main.lc, 1);
-#endif
+    erts_proc_lc_chk_only_proc(p, ERTS_PROC_LOCK_MAIN);
 }
 
 #if ERTS_PROC_LOCK_OWN_IMPL
 #define ERTS_PROC_LC_EMPTY_LOCK_INIT \
-  ERTS_LC_LOCK_INIT(-1, THE_NON_VALUE, ERTS_LC_FLG_LT_PROCLOCK)
+  ERTS_LC_LOCK_INIT(-1, THE_NON_VALUE, ERTS_LOCK_TYPE_PROCLOCK)
 #endif /* ERTS_PROC_LOCK_OWN_IMPL */
 
+void erts_proc_lc_chk_only_proc(Process *p, ErtsProcLocks locks)
+{
+    int have_locks_len = 0;
+#if ERTS_PROC_LOCK_OWN_IMPL
+    erts_lc_lock_t have_locks[6] = {ERTS_PROC_LC_EMPTY_LOCK_INIT,
+				    ERTS_PROC_LC_EMPTY_LOCK_INIT,
+				    ERTS_PROC_LC_EMPTY_LOCK_INIT,
+				    ERTS_PROC_LC_EMPTY_LOCK_INIT,
+				    ERTS_PROC_LC_EMPTY_LOCK_INIT,
+                                    ERTS_PROC_LC_EMPTY_LOCK_INIT};
+    if (locks & ERTS_PROC_LOCK_MAIN) {
+	have_locks[have_locks_len].id = lc_id.proc_lock_main;
+	have_locks[have_locks_len++].extra = p->common.id;
+    }
+    if (locks & ERTS_PROC_LOCK_LINK) {
+	have_locks[have_locks_len].id = lc_id.proc_lock_link;
+	have_locks[have_locks_len++].extra = p->common.id;
+    }
+    if (locks & ERTS_PROC_LOCK_MSGQ) {
+	have_locks[have_locks_len].id = lc_id.proc_lock_msgq;
+	have_locks[have_locks_len++].extra = p->common.id;
+    }
+    if (locks & ERTS_PROC_LOCK_BTM) {
+	have_locks[have_locks_len].id = lc_id.proc_lock_btm;
+	have_locks[have_locks_len++].extra = p->common.id;
+    }
+    if (locks & ERTS_PROC_LOCK_STATUS) {
+	have_locks[have_locks_len].id = lc_id.proc_lock_status;
+	have_locks[have_locks_len++].extra = p->common.id;
+    }
+    if (locks & ERTS_PROC_LOCK_TRACE) {
+	have_locks[have_locks_len].id = lc_id.proc_lock_trace;
+	have_locks[have_locks_len++].extra = p->common.id;
+    }
+#elif ERTS_PROC_LOCK_RAW_MUTEX_IMPL
+    erts_lc_lock_t have_locks[6];
+    if (locks & ERTS_PROC_LOCK_MAIN)
+	have_locks[have_locks_len++] = p->lock.main.lc;
+    if (locks & ERTS_PROC_LOCK_LINK)
+	have_locks[have_locks_len++] = p->lock.link.lc;
+    if (locks & ERTS_PROC_LOCK_MSGQ)
+	have_locks[have_locks_len++] = p->lock.msgq.lc;
+    if (locks & ERTS_PROC_LOCK_BTM)
+	have_locks[have_locks_len++] = p->lock.btm.lc;
+    if (locks & ERTS_PROC_LOCK_STATUS)
+	have_locks[have_locks_len++] = p->lock.status.lc;
+    if (locks & ERTS_PROC_LOCK_TRACE)
+	have_locks[have_locks_len++] = p->lock.trace.lc;
+#endif
+    erts_lc_check_exact(have_locks, have_locks_len);
+}
+
 void
 erts_proc_lc_chk_have_proc_locks(Process *p, ErtsProcLocks locks)
 {
     int have_locks_len = 0;
 #if ERTS_PROC_LOCK_OWN_IMPL
-    erts_lc_lock_t have_locks[5] = {ERTS_PROC_LC_EMPTY_LOCK_INIT,
+    erts_lc_lock_t have_locks[6] = {ERTS_PROC_LC_EMPTY_LOCK_INIT,
 				    ERTS_PROC_LC_EMPTY_LOCK_INIT,
 				    ERTS_PROC_LC_EMPTY_LOCK_INIT,
+                                    ERTS_PROC_LC_EMPTY_LOCK_INIT,
 				    ERTS_PROC_LC_EMPTY_LOCK_INIT,
 				    ERTS_PROC_LC_EMPTY_LOCK_INIT};
     if (locks & ERTS_PROC_LOCK_MAIN) {
@@ -1486,8 +1561,12 @@ erts_proc_lc_chk_have_proc_locks(Process *p, ErtsProcLocks locks)
 	have_locks[have_locks_len].id = lc_id.proc_lock_status;
 	have_locks[have_locks_len++].extra = p->common.id;
     }
+    if (locks & ERTS_PROC_LOCK_TRACE) {
+	have_locks[have_locks_len].id = lc_id.proc_lock_trace;
+	have_locks[have_locks_len++].extra = p->common.id;
+    }
 #elif ERTS_PROC_LOCK_RAW_MUTEX_IMPL
-    erts_lc_lock_t have_locks[5];
+    erts_lc_lock_t have_locks[6];
     if (locks & ERTS_PROC_LOCK_MAIN)
 	have_locks[have_locks_len++] = p->lock.main.lc;
     if (locks & ERTS_PROC_LOCK_LINK)
@@ -1498,6 +1577,8 @@ erts_proc_lc_chk_have_proc_locks(Process *p, ErtsProcLocks locks)
 	have_locks[have_locks_len++] = p->lock.btm.lc;
     if (locks & ERTS_PROC_LOCK_STATUS)
 	have_locks[have_locks_len++] = p->lock.status.lc;
+    if (locks & ERTS_PROC_LOCK_TRACE)
+	have_locks[have_locks_len++] = p->lock.trace.lc;
 #endif
     erts_lc_check(have_locks, have_locks_len, NULL, 0);
 }
@@ -1508,12 +1589,14 @@ erts_proc_lc_chk_proc_locks(Process *p, ErtsProcLocks locks)
     int have_locks_len = 0;
     int have_not_locks_len = 0;
 #if ERTS_PROC_LOCK_OWN_IMPL
-    erts_lc_lock_t have_locks[5] = {ERTS_PROC_LC_EMPTY_LOCK_INIT,
+    erts_lc_lock_t have_locks[6] = {ERTS_PROC_LC_EMPTY_LOCK_INIT,
 				    ERTS_PROC_LC_EMPTY_LOCK_INIT,
+                                    ERTS_PROC_LC_EMPTY_LOCK_INIT,
 				    ERTS_PROC_LC_EMPTY_LOCK_INIT,
 				    ERTS_PROC_LC_EMPTY_LOCK_INIT};
-    erts_lc_lock_t have_not_locks[5] = {ERTS_PROC_LC_EMPTY_LOCK_INIT,
+    erts_lc_lock_t have_not_locks[6] = {ERTS_PROC_LC_EMPTY_LOCK_INIT,
 					ERTS_PROC_LC_EMPTY_LOCK_INIT,
+                                        ERTS_PROC_LC_EMPTY_LOCK_INIT,
 					ERTS_PROC_LC_EMPTY_LOCK_INIT,
 					ERTS_PROC_LC_EMPTY_LOCK_INIT};
 
@@ -1557,9 +1640,17 @@ erts_proc_lc_chk_proc_locks(Process *p, ErtsProcLocks locks)
 	have_not_locks[have_not_locks_len].id = lc_id.proc_lock_status;
 	have_not_locks[have_not_locks_len++].extra = p->common.id;
     }
+    if (locks & ERTS_PROC_LOCK_TRACE) {
+	have_locks[have_locks_len].id = lc_id.proc_lock_trace;
+	have_locks[have_locks_len++].extra = p->common.id;
+    }
+    else {
+	have_not_locks[have_not_locks_len].id = lc_id.proc_lock_trace;
+	have_not_locks[have_not_locks_len++].extra = p->common.id;
+    }
 #elif ERTS_PROC_LOCK_RAW_MUTEX_IMPL
-    erts_lc_lock_t have_locks[5];
-    erts_lc_lock_t have_not_locks[5];
+    erts_lc_lock_t have_locks[6];
+    erts_lc_lock_t have_not_locks[6];
 
     if (locks & ERTS_PROC_LOCK_MAIN)
 	have_locks[have_locks_len++] = p->lock.main.lc;
@@ -1581,6 +1672,10 @@ erts_proc_lc_chk_proc_locks(Process *p, ErtsProcLocks locks)
 	have_locks[have_locks_len++] = p->lock.status.lc;
     else
 	have_not_locks[have_not_locks_len++] = p->lock.status.lc;
+    if (locks & ERTS_PROC_LOCK_TRACE)
+	have_locks[have_locks_len++] = p->lock.trace.lc;
+    else
+	have_not_locks[have_not_locks_len++] = p->lock.trace.lc;
 #endif
 
     erts_lc_check(have_locks, have_locks_len,
@@ -1590,33 +1685,37 @@ erts_proc_lc_chk_proc_locks(Process *p, ErtsProcLocks locks)
 ErtsProcLocks
 erts_proc_lc_my_proc_locks(Process *p)
 {
-    int resv[5];
+    int resv[6];
     ErtsProcLocks res = 0;
 #if ERTS_PROC_LOCK_OWN_IMPL
-    erts_lc_lock_t locks[5] = {ERTS_LC_LOCK_INIT(lc_id.proc_lock_main,
+    erts_lc_lock_t locks[6] = {ERTS_LC_LOCK_INIT(lc_id.proc_lock_main,
 						 p->common.id,
-						 ERTS_LC_FLG_LT_PROCLOCK),
+						 ERTS_LOCK_TYPE_PROCLOCK),
 			       ERTS_LC_LOCK_INIT(lc_id.proc_lock_link,
 						 p->common.id,
-						 ERTS_LC_FLG_LT_PROCLOCK),
+						 ERTS_LOCK_TYPE_PROCLOCK),
 			       ERTS_LC_LOCK_INIT(lc_id.proc_lock_msgq,
 						 p->common.id,
-						 ERTS_LC_FLG_LT_PROCLOCK),
+						 ERTS_LOCK_TYPE_PROCLOCK),
 			       ERTS_LC_LOCK_INIT(lc_id.proc_lock_btm,
 						 p->common.id,
-						 ERTS_LC_FLG_LT_PROCLOCK),
+						 ERTS_LOCK_TYPE_PROCLOCK),
 			       ERTS_LC_LOCK_INIT(lc_id.proc_lock_status,
 						 p->common.id,
-						 ERTS_LC_FLG_LT_PROCLOCK)};
+						 ERTS_LOCK_TYPE_PROCLOCK),
+			       ERTS_LC_LOCK_INIT(lc_id.proc_lock_trace,
+						 p->common.id,
+						 ERTS_LOCK_TYPE_PROCLOCK)};
 #elif ERTS_PROC_LOCK_RAW_MUTEX_IMPL
-    erts_lc_lock_t locks[5] = {p->lock.main.lc,
+    erts_lc_lock_t locks[6] = {p->lock.main.lc,
 			       p->lock.link.lc,
 			       p->lock.msgq.lc,
 			       p->lock.btm.lc,
-			       p->lock.status.lc};
+			       p->lock.status.lc,
+			       p->lock.trace.lc};
 #endif
 
-    erts_lc_have_locks(resv, locks, 5);
+    erts_lc_have_locks(resv, locks, 6);
     if (resv[0])
 	res |= ERTS_PROC_LOCK_MAIN;
     if (resv[1])
@@ -1627,6 +1726,8 @@ erts_proc_lc_my_proc_locks(Process *p)
 	res |= ERTS_PROC_LOCK_BTM;
     if (resv[4])
 	res |= ERTS_PROC_LOCK_STATUS;
+    if (resv[5])
+	res |= ERTS_PROC_LOCK_TRACE;
 
     return res;
 }
@@ -1634,14 +1735,15 @@ erts_proc_lc_my_proc_locks(Process *p)
 void
 erts_proc_lc_chk_no_proc_locks(char *file, int line)
 {
-    int resv[5];
-    int ids[5] = {lc_id.proc_lock_main,
+    int resv[6];
+    int ids[6] = {lc_id.proc_lock_main,
 		  lc_id.proc_lock_link,
 		  lc_id.proc_lock_msgq,
 		  lc_id.proc_lock_btm,
-		  lc_id.proc_lock_status};
-    erts_lc_have_lock_ids(resv, ids, 5);
-    if (!ERTS_IS_CRASH_DUMPING && (resv[0] || resv[1] || resv[2] || resv[3] || resv[4])) {
+		  lc_id.proc_lock_status,
+		  lc_id.proc_lock_trace};
+    erts_lc_have_lock_ids(resv, ids, 6);
+    if (!ERTS_IS_CRASH_DUMPING && (resv[0] || resv[1] || resv[2] || resv[3] || resv[4] || resv[5])) {
 	erts_lc_fail("%s:%d: Thread has process locks locked when expected "
 		     "not to have any process locks locked",
 		     file, line);