From 48201abc7961b44be9e5cf0feb74d18a399d6099 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang-solutions.com>
Date: Thu, 1 Aug 2013 15:50:46 +0200
Subject: erts: Make source file info available in lc

---
 erts/emulator/beam/beam_bp.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'erts/emulator/beam/beam_bp.c')

diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index 68907a771a..49a34ab4ad 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -46,7 +46,8 @@
 
 #if defined(ERTS_ENABLE_LOCK_CHECK) && defined(ERTS_SMP)
 #  define ERTS_SMP_REQ_PROC_MAIN_LOCK(P) \
-      if ((P)) erts_proc_lc_require_lock((P), ERTS_PROC_LOCK_MAIN)
+      if ((P)) erts_proc_lc_require_lock((P), ERTS_PROC_LOCK_MAIN,\
+					 __FILE__, __LINE__)
 #  define ERTS_SMP_UNREQ_PROC_MAIN_LOCK(P) \
       if ((P)) erts_proc_lc_unrequire_lock((P), ERTS_PROC_LOCK_MAIN)
 #else
-- 
cgit v1.2.3


From 9327904dcbf2708823c05baa7532783fb0214792 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Fri, 7 Mar 2014 10:41:32 +0100
Subject: Teach the call_time trace to notice when the trace dies (non-SMP
 system)

The call_time trace is a special kind of tracing that requires
a tracer process just like ordinary call trace, but it never
actually sends anything to the tracer. It merely use the existence
of a trace process (and call trace flags) as an indication that
call_time tracing is active for the process.

If the tracer dies in a non-SMP run-time system, processes with
call_time tracing would not notice that the tracer had
died. Furthermore, if the set_on_spawn flag was active, the dead
tracer could be propagaged to newly spawned processes.

Before accumulating trace information in a non-SMP system, always
validate the tracer process. (In an SMP system, a reference to a
dead tracer will be cleared away each time a process is scheduled.)

While we could put all of the new code beam_bp.c, we have chosen to
make a function call from beam_bp.c to a function in erl_trace.c for
clarity's sake and to ease further maintenance. In the future, we
might want to handle tracing in more similar ways in the SMP and
non-SMP system.
---
 erts/emulator/beam/beam_bp.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'erts/emulator/beam/beam_bp.c')

diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index 49a34ab4ad..4e711c89e0 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -642,7 +642,7 @@ erts_generic_breakpoint(Process* c_p, BeamInstr* I, Eterm* reg)
 	erts_smp_atomic_inc_nob(&bp->count->acount);
     }
 
-    if (bp_flags & ERTS_BPF_TIME_TRACE_ACTIVE) {
+    if (bp_flags & ERTS_BPF_TIME_TRACE_ACTIVE && erts_is_tracer_proc_valid(c_p)) {
 	Eterm w;
 	erts_trace_time_call(c_p, I, bp->time);
 	w = (BeamInstr) *c_p->cp;
@@ -730,7 +730,8 @@ erts_bif_trace(int bif_index, Process* p, Eterm* args, BeamInstr* I)
 	}
     }
     if (bp_flags & ERTS_BPF_TIME_TRACE_ACTIVE &&
-	IS_TRACED_FL(p, F_TRACE_CALLS)) {
+	IS_TRACED_FL(p, F_TRACE_CALLS) &&
+	erts_is_tracer_proc_valid(p)) {
 	BeamInstr *pc = (BeamInstr *)ep->code+3;
 	erts_trace_time_call(p, pc, bp->time);
     }
-- 
cgit v1.2.3


From 738c34d4bb8f1a3811acd00af8c6c12107f8315b Mon Sep 17 00:00:00 2001
From: Bruce Yinhe <bruce@erlang.org>
Date: Thu, 18 Jun 2015 11:31:02 +0200
Subject: Change license text to APLv2

---
 erts/emulator/beam/beam_bp.c | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

(limited to 'erts/emulator/beam/beam_bp.c')

diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index 4e711c89e0..016d0aaa32 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -3,16 +3,17 @@
  *
  * Copyright Ericsson AB 2000-2013. All Rights Reserved.
  *
- * The contents of this file are subject to the Erlang Public License,
- * Version 1.1, (the "License"); you may not use this file except in
- * compliance with the License. You should have received a copy of the
- * Erlang Public License along with this software. If not, it can be
- * retrieved online at http://www.erlang.org/.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
  *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
- * the License for the specific language governing rights and limitations
- * under the License.
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  *
  * %CopyrightEnd%
  */
-- 
cgit v1.2.3


From b9caedf093d0ccf268562656e28cdda6a02631cb Mon Sep 17 00:00:00 2001
From: Sverker Eriksson <sverker@erlang.org>
Date: Fri, 2 Oct 2015 19:05:57 +0200
Subject: erts: Refactor header of loaded beam code

to use a real C struct instead of array.
---
 erts/emulator/beam/beam_bp.c | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

(limited to 'erts/emulator/beam/beam_bp.c')

diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index 016d0aaa32..2a8663d7ee 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -152,8 +152,8 @@ erts_bp_match_functions(BpFunctions* f, Eterm mfa[3], int specified)
     num_modules = 0;
     for (current = 0; current < max_modules; current++) {
 	modp = module_code(current, code_ix);
-	if (modp->curr.code) {
-	    max_funcs += modp->curr.code[MI_NUM_FUNCTIONS];
+	if (modp->curr.code_hdr) {
+	    max_funcs += modp->curr.code_hdr->num_functions;
 	    module[num_modules++] = modp;
 	}
     }
@@ -161,9 +161,9 @@ erts_bp_match_functions(BpFunctions* f, Eterm mfa[3], int specified)
     f->matching = (BpFunction *) Alloc(max_funcs*sizeof(BpFunction));
     i = 0;
     for (current = 0; current < num_modules; current++) {
-	BeamInstr** code_base = (BeamInstr **) module[current]->curr.code;
+	BeamCodeHeader* code_hdr = module[current]->curr.code_hdr;
 	BeamInstr* code;
-	Uint num_functions = (Uint)(UWord) code_base[MI_NUM_FUNCTIONS];
+	Uint num_functions = (Uint)(UWord) code_hdr->num_functions;
 	Uint fi;
 
 	if (specified > 0) {
@@ -177,7 +177,7 @@ erts_bp_match_functions(BpFunctions* f, Eterm mfa[3], int specified)
 	    BeamInstr* pc;
 	    int wi;
 
-	    code = code_base[MI_FUNCTIONS+fi];
+	    code = code_hdr->functions[fi];
 	    ASSERT(code[0] == (BeamInstr) BeamOp(op_i_func_info_IaaI));
 	    pc = code+5;
 	    if (erts_is_native_break(pc)) {
@@ -547,21 +547,21 @@ erts_clear_all_breaks(BpFunctions* f)
 
 int 
 erts_clear_module_break(Module *modp) {
-    BeamInstr** code_base;
+    BeamCodeHeader* code_hdr;
     Uint n;
     Uint i;
 
     ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
     ASSERT(modp);
-    code_base = (BeamInstr **) modp->curr.code;
-    if (code_base == NULL) {
+    code_hdr = modp->curr.code_hdr;
+    if (!code_hdr) {
 	return 0;
     }
-    n = (Uint)(UWord) code_base[MI_NUM_FUNCTIONS];
+    n = (Uint)(UWord) code_hdr->num_functions;
     for (i = 0; i < n; ++i) {
 	BeamInstr* pc;
 
-	pc = code_base[MI_FUNCTIONS+i] + 5;
+	pc = code_hdr->functions[i] + 5;
 	if (erts_is_native_break(pc)) {
 	    continue;
 	}
@@ -573,7 +573,7 @@ erts_clear_module_break(Module *modp) {
     for (i = 0; i < n; ++i) {
 	BeamInstr* pc;
 
-	pc = code_base[MI_FUNCTIONS+i] + 5;
+	pc = code_hdr->functions[i] + 5;
 	if (erts_is_native_break(pc)) {
 	    continue;
 	}
@@ -1204,17 +1204,17 @@ int erts_is_time_break(Process *p, BeamInstr *pc, Eterm *retval) {
 BeamInstr *
 erts_find_local_func(Eterm mfa[3]) {
     Module *modp;
-    BeamInstr** code_base;
+    BeamCodeHeader* code_hdr;
     BeamInstr* code_ptr;
     Uint i,n;
 
     if ((modp = erts_get_module(mfa[0], erts_active_code_ix())) == NULL)
 	return NULL;
-    if ((code_base = (BeamInstr **) modp->curr.code) == NULL)
+    if ((code_hdr = modp->curr.code_hdr) == NULL)
 	return NULL;
-    n = (BeamInstr) code_base[MI_NUM_FUNCTIONS];
+    n = (BeamInstr) code_hdr->num_functions;
     for (i = 0; i < n; ++i) {
-	code_ptr = code_base[MI_FUNCTIONS+i];
+	code_ptr = code_hdr->functions[i];
 	ASSERT(((BeamInstr) BeamOp(op_i_func_info_IaaI)) == code_ptr[0]);
 	ASSERT(mfa[0] == ((Eterm) code_ptr[2]) ||
 	       is_nil((Eterm) code_ptr[2]));
-- 
cgit v1.2.3


From 77f0f265f860130102acc1db31d99f8dd9e690c5 Mon Sep 17 00:00:00 2001
From: Rickard Green <rickard@erlang.org>
Date: Tue, 22 Dec 2015 18:32:10 +0100
Subject: Use monotonic time for call_time trace

---
 erts/emulator/beam/beam_bp.c | 99 ++++++++++++++------------------------------
 1 file changed, 30 insertions(+), 69 deletions(-)

(limited to 'erts/emulator/beam/beam_bp.c')

diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index 016d0aaa32..9860968687 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -75,6 +75,16 @@ extern BeamInstr beam_return_time_trace[1]; /* OpCode(i_return_time_trace) */
 erts_smp_atomic32_t erts_active_bp_index;
 erts_smp_atomic32_t erts_staging_bp_index;
 
+/*
+ * Inlined helpers
+ */
+
+static ERTS_INLINE ErtsMonotonicTime
+get_mtime(Process *c_p)
+{
+    return erts_get_monotonic_time(ERTS_PROC_GET_SCHDATA(c_p));
+}
+
 /* *************************************************************************
 ** Local prototypes
 */
@@ -97,9 +107,6 @@ static int clear_function_break(BeamInstr *pc, Uint break_flags);
 
 static BpDataTime* get_time_break(BeamInstr *pc);
 static GenericBpData* check_break(BeamInstr *pc, Uint break_flags);
-static void bp_time_diff(bp_data_time_item_t *item,
-			 process_breakpoint_time_t *pbt,
-			 Uint ms, Uint s, Uint us);
 
 static void bp_meta_unref(BpMetaPid* bmp);
 static void bp_count_unref(BpCount* bcp);
@@ -110,13 +117,8 @@ static void uninstall_breakpoint(BeamInstr* pc);
 /* bp_hash */
 #define BP_TIME_ADD(pi0, pi1)                       \
     do {                                            \
-	Uint r;                                     \
 	(pi0)->count   += (pi1)->count;             \
-	(pi0)->s_time  += (pi1)->s_time;            \
-	(pi0)->us_time += (pi1)->us_time;           \
-	r = (pi0)->us_time / 1000000;               \
-	(pi0)->s_time  += r;                        \
-	(pi0)->us_time  = (pi0)->us_time % 1000000; \
+	(pi0)->time    += (pi1)->time;              \
     } while(0)
 
 static void bp_hash_init(bp_time_hash_t *hash, Uint n);
@@ -948,7 +950,7 @@ do_call_trace(Process* c_p, BeamInstr* I, Eterm* reg,
 void
 erts_trace_time_call(Process* c_p, BeamInstr* I, BpDataTime* bdt)
 {
-    Uint ms,s,us;
+    ErtsMonotonicTime time;
     process_breakpoint_time_t *pbt = NULL;
     bp_data_time_item_t sitem, *item = NULL;
     bp_time_hash_t *h = NULL;
@@ -961,7 +963,7 @@ erts_trace_time_call(Process* c_p, BeamInstr* I, BpDataTime* bdt)
      * from the process psd  */
 
     pbt = ERTS_PROC_GET_CALL_TIME(c_p);
-    get_sys_now(&ms, &s, &us);
+    time = get_mtime(c_p);
 
     /* get pbt
      * timestamp = t0
@@ -976,7 +978,7 @@ erts_trace_time_call(Process* c_p, BeamInstr* I, BpDataTime* bdt)
     } else {
 	ASSERT(pbt->pc);
 	/* add time to previous code */
-	bp_time_diff(&sitem, pbt, ms, s, us);
+	sitem.time = time - pbt->time;
 	sitem.pid = c_p->common.id;
 	sitem.count = 0;
 
@@ -1002,8 +1004,7 @@ erts_trace_time_call(Process* c_p, BeamInstr* I, BpDataTime* bdt)
     /* Add count to this code */
     sitem.pid     = c_p->common.id;
     sitem.count   = 1;
-    sitem.s_time  = 0;
-    sitem.us_time = 0;
+    sitem.time    = 0;
 
     /* this breakpoint */
     ASSERT(bdt);
@@ -1020,15 +1021,13 @@ erts_trace_time_call(Process* c_p, BeamInstr* I, BpDataTime* bdt)
     }
 
     pbt->pc = I;
-    pbt->ms = ms;
-    pbt->s  = s;
-    pbt->us = us;
+    pbt->time = time;
 }
 
 void
 erts_trace_time_return(Process *p, BeamInstr *pc)
 {
-    Uint ms,s,us;
+    ErtsMonotonicTime time;
     process_breakpoint_time_t *pbt = NULL;
     bp_data_time_item_t sitem, *item = NULL;
     bp_time_hash_t *h = NULL;
@@ -1041,7 +1040,7 @@ erts_trace_time_return(Process *p, BeamInstr *pc)
      * from the process psd  */
 
     pbt = ERTS_PROC_GET_CALL_TIME(p);
-    get_sys_now(&ms,&s,&us);
+    time = get_mtime(p);
 
     /* get pbt
      * lookup bdt from code
@@ -1057,7 +1056,7 @@ erts_trace_time_return(Process *p, BeamInstr *pc)
 	 */
 	ASSERT(pbt->pc);
 
-	bp_time_diff(&sitem, pbt, ms, s, us);
+	sitem.time = time - pbt->time;
 	sitem.pid   = p->common.id;
 	sitem.count = 0;
 
@@ -1080,9 +1079,7 @@ erts_trace_time_return(Process *p, BeamInstr *pc)
 	}
 
 	pbt->pc = pc;
-	pbt->ms = ms;
-	pbt->s  = s;
-	pbt->us = us;
+	pbt->time = time;
     }
 }
 
@@ -1183,10 +1180,14 @@ int erts_is_time_break(Process *p, BeamInstr *pc, Eterm *retval) {
 		for(ix = 0; ix < hash.n; ix++) {
 		    item = &(hash.item[ix]);
 		    if (item->pid != NIL) {
+			ErtsMonotonicTime sec, usec;
+			usec = ERTS_MONOTONIC_TO_USEC(item->time);
+			sec = usec / 1000000;
+			usec = usec - sec*1000000;
 			t = TUPLE4(hp, item->pid,
 				make_small(item->count),
-				make_small(item->s_time),
-				make_small(item->us_time));
+				   make_small((Uint) sec),
+				   make_small((Uint) usec));
 			hp += 5;
 			*retval = CONS(hp, t, *retval); hp += 2;
 		    }
@@ -1266,8 +1267,7 @@ static void bp_hash_rehash(bp_time_hash_t *hash, Uint n) {
 	    }
 	    item[hval].pid     = hash->item[ix].pid;
 	    item[hval].count   = hash->item[ix].count;
-	    item[hval].s_time  = hash->item[ix].s_time;
-	    item[hval].us_time = hash->item[ix].us_time;
+	    item[hval].time    = hash->item[ix].time;
 	}
     }
 
@@ -1315,8 +1315,7 @@ static ERTS_INLINE bp_data_time_item_t * bp_hash_put(bp_time_hash_t *hash, bp_da
     item = &(hash->item[hval]);
 
     item->pid     = sitem->pid;
-    item->s_time  = sitem->s_time;
-    item->us_time = sitem->us_time;
+    item->time    = sitem->time;
     item->count   = sitem->count;
     hash->used++;
 
@@ -1330,41 +1329,7 @@ static void bp_hash_delete(bp_time_hash_t *hash) {
     hash->item = NULL;
 }
 
-static void bp_time_diff(bp_data_time_item_t *item, /* out */
-	process_breakpoint_time_t *pbt,             /* in  */
-	Uint ms, Uint s, Uint us) {
-    int ds,dus;
-#ifdef DEBUG
-    int dms;
-
-
-    dms = ms - pbt->ms;
-#endif
-    ds  = s  - pbt->s;
-    dus = us - pbt->us;
-
-    /* get_sys_now may return zero difftime,
-     * this is ok.
-     */
-
-#ifdef DEBUG
-    ASSERT(dms >= 0 || ds >= 0 || dus >= 0);
-#endif
-
-    if (dus < 0) {
-	dus += 1000000;
-	ds  -= 1;
-    }
-    if (ds < 0) {
-	ds += 1000000;
-    }
-
-    item->s_time  = ds;
-    item->us_time = dus;
-}
-
 void erts_schedule_time_break(Process *p, Uint schedule) {
-    Uint ms, s, us;
     process_breakpoint_time_t *pbt = NULL;
     bp_data_time_item_t sitem, *item = NULL;
     bp_time_hash_t *h = NULL;
@@ -1387,8 +1352,7 @@ void erts_schedule_time_break(Process *p, Uint schedule) {
 
 	    pbdt = get_time_break(pbt->pc);
 	    if (pbdt) {
-		get_sys_now(&ms,&s,&us);
-		bp_time_diff(&sitem, pbt, ms, s, us);
+		sitem.time = get_mtime(p) - pbt->time;
 		sitem.pid   = p->common.id;
 		sitem.count = 0;
 
@@ -1410,10 +1374,7 @@ void erts_schedule_time_break(Process *p, Uint schedule) {
 	     * timestamp it and remove the previous
 	     * timestamp in the psd.
 	     */
-	    get_sys_now(&ms,&s,&us);
-	    pbt->ms = ms;
-	    pbt->s  = s;
-	    pbt->us = us;
+	    pbt->time = get_mtime(p);
 	    break;
 	default :
 	    ASSERT(0);
-- 
cgit v1.2.3


From 0bf37ca78b6200f8b82b20234f0b882154a094ff Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn-Egil=20Dahlberg?= <egil@erlang.org>
Date: Fri, 18 Dec 2015 15:26:35 +0100
Subject: Silence compiler

---
 erts/emulator/beam/beam_bp.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'erts/emulator/beam/beam_bp.c')

diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index 2a23da4f25..5d471d168b 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -864,7 +864,7 @@ do_call_trace(Process* c_p, BeamInstr* I, Eterm* reg,
     Eterm* cpp;
     int return_to_trace = 0;
     BeamInstr w;
-    BeamInstr *cp_save;
+    BeamInstr *cp_save = c_p->cp;
     Uint32 flags;
     Uint need = 0;
     Eterm* E = c_p->stop;
-- 
cgit v1.2.3


From 6664eed554974336909d3ffe03f20349cc4c38fd Mon Sep 17 00:00:00 2001
From: Henrik Nord <henrik@erlang.org>
Date: Tue, 15 Mar 2016 15:19:56 +0100
Subject: update copyright-year

---
 erts/emulator/beam/beam_bp.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'erts/emulator/beam/beam_bp.c')

diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index 5d471d168b..86e1fdc2fb 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -1,7 +1,7 @@
 /*
  * %CopyrightBegin%
  *
- * Copyright Ericsson AB 2000-2013. All Rights Reserved.
+ * Copyright Ericsson AB 2000-2016. 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.
-- 
cgit v1.2.3


From ab884c3fdda00479d636de82d68ffbd8628c5c20 Mon Sep 17 00:00:00 2001
From: Rickard Green <rickard@erlang.org>
Date: Thu, 24 Mar 2016 16:20:51 +0100
Subject: Improve process/port specific data management

---
 erts/emulator/beam/beam_bp.c | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

(limited to 'erts/emulator/beam/beam_bp.c')

diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index 5d471d168b..74c9d3ee53 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -974,7 +974,7 @@ erts_trace_time_call(Process* c_p, BeamInstr* I, BpDataTime* bdt)
     if (pbt == 0) {
 	/* First call of process to instrumented function */
 	pbt = Alloc(sizeof(process_breakpoint_time_t));
-	(void) ERTS_PROC_SET_CALL_TIME(c_p, ERTS_PROC_LOCK_MAIN, pbt);
+	(void) ERTS_PROC_SET_CALL_TIME(c_p, pbt);
     } else {
 	ASSERT(pbt->pc);
 	/* add time to previous code */
@@ -1598,9 +1598,7 @@ bp_time_unref(BpDataTime* bdt)
 			h_p = erts_pid2proc(NULL, 0, item->pid,
 					    ERTS_PROC_LOCK_MAIN);
 			if (h_p) {
-			    pbt = ERTS_PROC_SET_CALL_TIME(h_p,
-							  ERTS_PROC_LOCK_MAIN,
-							  NULL);
+			    pbt = ERTS_PROC_SET_CALL_TIME(h_p, NULL);
 			    if (pbt) {
 				Free(pbt);
 			    }
-- 
cgit v1.2.3


From 37092dab15448ef6a078800e3ff0cc41880ea765 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas.larsson@erlang-solutions.com>
Date: Thu, 10 Dec 2015 11:10:46 +0100
Subject: erts: Implement tracer modules

Add the possibility to use modules as trace data receivers. The functions
in the module have to be nifs as otherwise complex trace probes will be
very hard to handle (complex means trace probes for ports for example).

This commit changes the way that the ptab->tracer field works from always
being an immediate, to now be NIL if no tracer is present or else be
the tuple {TracerModule, TracerState} where TracerModule is an atom that
is later used to lookup the appropriate tracer callbacks to call and
TracerState is just passed to the tracer callback. The default process and
port tracers have been rewritten to use the new API.

This commit also changes the order which trace messages are delivered to the
potential tracer process. Any enif_send done in a tracer module may be delayed
indefinitely because of lock order issues. If a message is delayed any other
trace message send from that process is also delayed so that order is preserved
for each traced entity. This means that for some trace events (i.e. send/receive)
the events may come in an unintuitive order (receive before send) to the
trace receiver. Timestamps are taken when the trace message is generated so
trace messages from differented processes may arrive with the timestamp
out of order.

Both the erlang:trace and seq_trace:set_system_tracer accept the new tracer
module tracers and also the backwards compatible arguments.

OTP-10267
---
 erts/emulator/beam/beam_bp.c | 169 ++++++++++++++++++++++++-------------------
 1 file changed, 94 insertions(+), 75 deletions(-)

(limited to 'erts/emulator/beam/beam_bp.c')

diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index 0a13454951..2ee98ed7b5 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -92,15 +92,15 @@ get_mtime(Process *c_p)
 /*
 ** Helpers
 */
-static Eterm do_call_trace(Process* c_p, BeamInstr* I, Eterm* reg,
-			   int local, Binary* ms, Eterm tracer_pid);
+static ErtsTracer do_call_trace(Process* c_p, BeamInstr* I, Eterm* reg,
+                                int local, Binary* ms, ErtsTracer tracer);
 static void set_break(BpFunctions* f, Binary *match_spec, Uint break_flags,
-		      enum erts_break_op count_op, Eterm tracer_pid);
+		      enum erts_break_op count_op, ErtsTracer tracer);
 static void set_function_break(BeamInstr *pc,
 			       Binary *match_spec,
 			       Uint break_flags,
 			       enum erts_break_op count_op,
-			       Eterm tracer_pid);
+			       ErtsTracer tracer);
 
 static void clear_break(BpFunctions* f, Uint break_flags);
 static int clear_function_break(BeamInstr *pc, Uint break_flags);
@@ -108,7 +108,7 @@ static int clear_function_break(BeamInstr *pc, Uint break_flags);
 static BpDataTime* get_time_break(BeamInstr *pc);
 static GenericBpData* check_break(BeamInstr *pc, Uint break_flags);
 
-static void bp_meta_unref(BpMetaPid* bmp);
+static void bp_meta_unref(BpMetaTracer* bmt);
 static void bp_count_unref(BpCount* bcp);
 static void bp_time_unref(BpDataTime* bdt);
 static void consolidate_bp_data(Module* modp, BeamInstr* pc, int local);
@@ -302,7 +302,7 @@ consolidate_bp_data(Module* modp, BeamInstr* pc, int local)
 	MatchSetUnref(dst->local_ms);
     }
     if (flags & ERTS_BPF_META_TRACE) {
-	bp_meta_unref(dst->meta_pid);
+	bp_meta_unref(dst->meta_tracer);
 	MatchSetUnref(dst->meta_ms);
     }
     if (flags & ERTS_BPF_COUNT) {
@@ -343,8 +343,8 @@ consolidate_bp_data(Module* modp, BeamInstr* pc, int local)
 	MatchSetRef(dst->local_ms);
     }
     if (flags & ERTS_BPF_META_TRACE) {
-	dst->meta_pid = src->meta_pid;
-	erts_refc_inc(&dst->meta_pid->refc, 1);
+	dst->meta_tracer = src->meta_tracer;
+	erts_refc_inc(&dst->meta_tracer->refc, 1);
 	dst->meta_ms = src->meta_ms;
 	MatchSetRef(dst->meta_ms);
     }
@@ -436,13 +436,13 @@ uninstall_breakpoint(BeamInstr* pc)
 void
 erts_set_trace_break(BpFunctions* f, Binary *match_spec)
 {
-    set_break(f, match_spec, ERTS_BPF_LOCAL_TRACE, 0, am_true);
+    set_break(f, match_spec, ERTS_BPF_LOCAL_TRACE, 0, erts_tracer_true);
 }
 
 void
-erts_set_mtrace_break(BpFunctions* f, Binary *match_spec, Eterm tracer_pid)
+erts_set_mtrace_break(BpFunctions* f, Binary *match_spec, ErtsTracer tracer)
 {
-    set_break(f, match_spec, ERTS_BPF_META_TRACE, 0, tracer_pid);
+    set_break(f, match_spec, ERTS_BPF_META_TRACE, 0, tracer);
 }
 
 void
@@ -450,13 +450,13 @@ erts_set_call_trace_bif(BeamInstr *pc, Binary *match_spec, int local)
 {
     Uint flags = local ? ERTS_BPF_LOCAL_TRACE : ERTS_BPF_GLOBAL_TRACE;
 
-    set_function_break(pc, match_spec, flags, 0, NIL);
+    set_function_break(pc, match_spec, flags, 0, erts_tracer_nil);
 }
 
 void
-erts_set_mtrace_bif(BeamInstr *pc, Binary *match_spec, Eterm tracer_pid)
+erts_set_mtrace_bif(BeamInstr *pc, Binary *match_spec, ErtsTracer tracer)
 {
-    set_function_break(pc, match_spec, ERTS_BPF_META_TRACE, 0, tracer_pid);
+    set_function_break(pc, match_spec, ERTS_BPF_META_TRACE, 0, tracer);
 }
 
 void
@@ -464,7 +464,7 @@ erts_set_time_trace_bif(BeamInstr *pc, enum erts_break_op count_op)
 {
     set_function_break(pc, NULL,
 		       ERTS_BPF_TIME_TRACE|ERTS_BPF_TIME_TRACE_ACTIVE,
-		       count_op, NIL);
+		       count_op, erts_tracer_nil);
 }
 
 void
@@ -474,21 +474,21 @@ erts_clear_time_trace_bif(BeamInstr *pc) {
 
 void
 erts_set_debug_break(BpFunctions* f) {
-    set_break(f, NULL, ERTS_BPF_DEBUG, 0, NIL);
+    set_break(f, NULL, ERTS_BPF_DEBUG, 0, erts_tracer_nil);
 }
 
 void
 erts_set_count_break(BpFunctions* f, enum erts_break_op count_op)
 {
     set_break(f, 0, ERTS_BPF_COUNT|ERTS_BPF_COUNT_ACTIVE,
-	      count_op, NIL);
+	      count_op, erts_tracer_nil);
 }
 
 void
 erts_set_time_break(BpFunctions* f, enum erts_break_op count_op)
 {
     set_break(f, 0, ERTS_BPF_TIME_TRACE|ERTS_BPF_TIME_TRACE_ACTIVE,
-	      count_op, NIL);
+	      count_op, erts_tracer_nil);
 }
 
 void
@@ -625,19 +625,26 @@ erts_generic_breakpoint(Process* c_p, BeamInstr* I, Eterm* reg)
 
     if (bp_flags & ERTS_BPF_LOCAL_TRACE) {
 	ASSERT((bp_flags & ERTS_BPF_GLOBAL_TRACE) == 0);
-	(void) do_call_trace(c_p, I, reg, 1, bp->local_ms, am_true);
+	(void) do_call_trace(c_p, I, reg, 1, bp->local_ms, erts_tracer_true);
     } else if (bp_flags & ERTS_BPF_GLOBAL_TRACE) {
-	(void) do_call_trace(c_p, I, reg, 0, bp->local_ms, am_true);
+	(void) do_call_trace(c_p, I, reg, 0, bp->local_ms, erts_tracer_true);
     }
 
     if (bp_flags & ERTS_BPF_META_TRACE) {
-	Eterm old_pid;
-	Eterm new_pid;
-
-	old_pid = (Eterm) erts_smp_atomic_read_nob(&bp->meta_pid->pid);
-	new_pid = do_call_trace(c_p, I, reg, 1, bp->meta_ms, old_pid);
-	if (new_pid != old_pid) {
-	    erts_smp_atomic_set_nob(&bp->meta_pid->pid, new_pid);
+	ErtsTracer old_tracer, new_tracer;
+
+	old_tracer = erts_smp_atomic_read_nob(&bp->meta_tracer->tracer);
+
+	new_tracer = do_call_trace(c_p, I, reg, 1, bp->meta_ms, old_tracer);
+	if (!ERTS_TRACER_COMPARE(new_tracer, old_tracer)) {
+            if (old_tracer == erts_smp_atomic_cmpxchg_acqb(
+                    &bp->meta_tracer->tracer,
+                    (erts_aint_t)new_tracer,
+                    (erts_aint_t)old_tracer)) {
+                ERTS_TRACER_CLEAR(&old_tracer);
+            } else {
+                ERTS_TRACER_CLEAR(&new_tracer);
+            }
 	}
     }
 
@@ -645,7 +652,8 @@ erts_generic_breakpoint(Process* c_p, BeamInstr* I, Eterm* reg)
 	erts_smp_atomic_inc_nob(&bp->count->acount);
     }
 
-    if (bp_flags & ERTS_BPF_TIME_TRACE_ACTIVE && erts_is_tracer_proc_valid(c_p)) {
+    if (bp_flags & ERTS_BPF_TIME_TRACE_ACTIVE
+        && ERTS_TRACER_PROC_IS_ENABLED(c_p)) {
 	Eterm w;
 	erts_trace_time_call(c_p, I, bp->time);
 	w = (BeamInstr) *c_p->cp;
@@ -690,7 +698,7 @@ erts_bif_trace(int bif_index, Process* p, Eterm* args, BeamInstr* I)
     Eterm (*func)(Process*, Eterm*, BeamInstr*);
     Export* ep = bif_export[bif_index];
     Uint32 flags = 0, flags_meta = 0;
-    Eterm meta_tracer_pid = NIL;
+    ErtsTracer meta_tracer = erts_tracer_nil;
     int applying = (I == &(ep->code[3])); /* Yup, the apply code for a bif
 					   * is actually in the
 					   * export entry */
@@ -718,23 +726,32 @@ erts_bif_trace(int bif_index, Process* p, Eterm* args, BeamInstr* I)
 	IS_TRACED_FL(p, F_TRACE_CALLS)) {
 	int local = !!(bp_flags & ERTS_BPF_LOCAL_TRACE);
 	flags = erts_call_trace(p, ep->code, bp->local_ms, args,
-				local, &ERTS_TRACER_PROC(p));
+				local, &ERTS_TRACER(p));
     }
     if (bp_flags & ERTS_BPF_META_TRACE) {
-	Eterm tpid1, tpid2;
+	ErtsTracer old_tracer;
 
-	tpid1 = tpid2 =
-	    (Eterm) erts_smp_atomic_read_nob(&bp->meta_pid->pid);
+        meta_tracer = erts_smp_atomic_read_nob(&bp->meta_tracer->tracer);
+        old_tracer = meta_tracer;
 	flags_meta = erts_call_trace(p, ep->code, bp->meta_ms, args,
-				     0, &tpid2);
-	meta_tracer_pid = tpid2;
-	if (tpid1 != tpid2) {
-	    erts_smp_atomic_set_nob(&bp->meta_pid->pid, tpid2);
+				     0, &meta_tracer);
+
+	if (!ERTS_TRACER_COMPARE(old_tracer, meta_tracer)) {
+            ErtsTracer new_tracer = erts_tracer_nil;
+            erts_tracer_update(&new_tracer, meta_tracer);
+	    if (old_tracer == erts_smp_atomic_cmpxchg_acqb(
+                    &bp->meta_tracer->tracer,
+                    (erts_aint_t)new_tracer,
+                    (erts_aint_t)old_tracer)) {
+                ERTS_TRACER_CLEAR(&old_tracer);
+            } else {
+                ERTS_TRACER_CLEAR(&new_tracer);
+            }
 	}
     }
     if (bp_flags & ERTS_BPF_TIME_TRACE_ACTIVE &&
 	IS_TRACED_FL(p, F_TRACE_CALLS) &&
-	erts_is_tracer_proc_valid(p)) {
+	ERTS_TRACER_PROC_IS_ENABLED(p)) {
 	BeamInstr *pc = (BeamInstr *)ep->code+3;
 	erts_trace_time_call(p, pc, bp->time);
     }
@@ -778,8 +795,6 @@ erts_bif_trace(int bif_index, Process* p, Eterm* args, BeamInstr* I)
 	if (reason != TRAP) {
 	    Eterm class;
 	    Eterm value = p->fvalue;
-	    DeclareTmpHeapNoproc(nocatch,3);
-	    UseTmpHeapNoproc(3);
 	    /* Expand error value like in handle_error() */
 	    if (reason & EXF_ARGLIST) {
 		Eterm *tp;
@@ -788,7 +803,8 @@ erts_bif_trace(int bif_index, Process* p, Eterm* args, BeamInstr* I)
 		value = tp[1];
 	    }
 	    if ((reason & EXF_THROWN) && (p->catches <= 0)) {
-		value = TUPLE2(nocatch, am_nocatch, value);
+                Eterm *hp = HAlloc(p, 3);
+		value = TUPLE2(hp, am_nocatch, value);
 		reason = EXC_ERROR;
 	    }
 	    /* Note: expand_error_value() could theoretically
@@ -801,11 +817,11 @@ erts_bif_trace(int bif_index, Process* p, Eterm* args, BeamInstr* I)
 
 	    if (flags_meta & MATCH_SET_EXCEPTION_TRACE) {
 		erts_trace_exception(p, ep->code, class, value,
-				     &meta_tracer_pid);
+				     &meta_tracer);
 	    }
 	    if (flags & MATCH_SET_EXCEPTION_TRACE) {
 		erts_trace_exception(p, ep->code, class, value,
-				     &ERTS_TRACER_PROC(p));
+				     &ERTS_TRACER(p));
 	    }
 	    if ((flags & MATCH_SET_RETURN_TO_TRACE) && p->catches > 0) {
 		/* can only happen if(local)*/
@@ -827,7 +843,6 @@ erts_bif_trace(int bif_index, Process* p, Eterm* args, BeamInstr* I)
 		    }
 		}
 	    }
-	    UnUseTmpHeapNoproc(3);
 	    if ((flags_meta|flags) & MATCH_SET_EXCEPTION_TRACE) {
 		erts_smp_proc_lock(p, ERTS_PROC_LOCKS_ALL_MINOR);
 		ERTS_TRACE_FLAGS(p) |= F_EXCEPTION_TRACE;
@@ -836,11 +851,11 @@ erts_bif_trace(int bif_index, Process* p, Eterm* args, BeamInstr* I)
 	}
     } else {
 	if (flags_meta & MATCH_SET_RX_TRACE) {
-	    erts_trace_return(p, ep->code, result, &meta_tracer_pid);
+	    erts_trace_return(p, ep->code, result, &meta_tracer);
 	}
 	/* MATCH_SET_RETURN_TO_TRACE cannot occur if(meta) */
 	if (flags & MATCH_SET_RX_TRACE) {
-	    erts_trace_return(p, ep->code, result, &ERTS_TRACER_PROC(p));
+	    erts_trace_return(p, ep->code, result, &ERTS_TRACER(p));
 	}
 	if (flags & MATCH_SET_RETURN_TO_TRACE) {
 	    /* can only happen if(local)*/
@@ -857,9 +872,9 @@ erts_bif_trace(int bif_index, Process* p, Eterm* args, BeamInstr* I)
     return result;
 }
 
-static Eterm
+static ErtsTracer
 do_call_trace(Process* c_p, BeamInstr* I, Eterm* reg,
-	      int local, Binary* ms, Eterm tracer_pid)
+	      int local, Binary* ms, ErtsTracer tracer)
 {
     Eterm* cpp;
     int return_to_trace = 0;
@@ -899,7 +914,7 @@ do_call_trace(Process* c_p, BeamInstr* I, Eterm* reg,
 	ASSERT(is_CP(*cpp));
     }
     ERTS_SMP_UNREQ_PROC_MAIN_LOCK(c_p);
-    flags = erts_call_trace(c_p, I-3, ms, reg, local, &tracer_pid);
+    flags = erts_call_trace(c_p, I-3, ms, reg, local, &tracer);
     ERTS_SMP_REQ_PROC_MAIN_LOCK(c_p);
     if (cpp) {
 	c_p->cp = cp_save;
@@ -910,7 +925,7 @@ do_call_trace(Process* c_p, BeamInstr* I, Eterm* reg,
 	need += 1;
     }
     if (flags & MATCH_SET_RX_TRACE) {
-	need += 3;
+	need += 3 + size_object(tracer);
     }
     if (need) {
 	ASSERT(c_p->htop <= E && E <= c_p->hend);
@@ -926,14 +941,15 @@ do_call_trace(Process* c_p, BeamInstr* I, Eterm* reg,
 	E[0] = make_cp(c_p->cp);
 	c_p->cp = beam_return_to_trace;
     }
-    if (flags & MATCH_SET_RX_TRACE) {
+    if (flags & MATCH_SET_RX_TRACE)
+    {
 	E -= 3;
+        c_p->stop = E;
 	ASSERT(c_p->htop <= E && E <= c_p->hend);
 	ASSERT(is_CP((Eterm) (UWord) (I - 3)));
-	ASSERT(am_true == tracer_pid ||
-	       is_internal_pid(tracer_pid) || is_internal_port(tracer_pid));
+	ASSERT(IS_TRACER_VALID(tracer));
 	E[2] = make_cp(c_p->cp);
-	E[1] = tracer_pid;
+        E[1] = copy_object(tracer, c_p);
 	E[0] = make_cp(I - 3); /* We ARE at the beginning of an
 				  instruction,
 				  the funcinfo is above i. */
@@ -942,9 +958,9 @@ do_call_trace(Process* c_p, BeamInstr* I, Eterm* reg,
 	erts_smp_proc_lock(c_p, ERTS_PROC_LOCKS_ALL_MINOR);
 	ERTS_TRACE_FLAGS(c_p) |= F_EXCEPTION_TRACE;
 	erts_smp_proc_unlock(c_p, ERTS_PROC_LOCKS_ALL_MINOR);
-    }
-    c_p->stop = E;
-    return tracer_pid;
+    } else
+        c_p->stop = E;
+    return tracer;
 }
 
 void
@@ -1098,9 +1114,9 @@ erts_is_trace_break(BeamInstr *pc, Binary **match_spec_ret, int local)
     return 0;
 }
 
-int 
+int
 erts_is_mtrace_break(BeamInstr *pc, Binary **match_spec_ret,
-		     Eterm *tracer_pid_ret)
+		     ErtsTracer *tracer_ret)
 {
     GenericBpData* bp = check_break(pc, ERTS_BPF_META_TRACE);
     
@@ -1108,9 +1124,8 @@ erts_is_mtrace_break(BeamInstr *pc, Binary **match_spec_ret,
 	if (match_spec_ret) {
 	    *match_spec_ret = bp->meta_ms;
 	}
-	if (tracer_pid_ret) {
-	    *tracer_pid_ret =
-		(Eterm) erts_smp_atomic_read_nob(&bp->meta_pid->pid);
+	if (tracer_ret) {
+            *tracer_ret = erts_smp_atomic_read_nob(&bp->meta_tracer->tracer);
 	}
 	return 1;
     }
@@ -1391,7 +1406,7 @@ void erts_schedule_time_break(Process *p, Uint schedule) {
 
 static void
 set_break(BpFunctions* f, Binary *match_spec, Uint break_flags,
-	  enum erts_break_op count_op, Eterm tracer_pid)
+	  enum erts_break_op count_op, ErtsTracer tracer)
 {
     Uint i;
     Uint n;
@@ -1400,13 +1415,13 @@ set_break(BpFunctions* f, Binary *match_spec, Uint break_flags,
     for (i = 0; i < n; i++) {
 	BeamInstr* pc = f->matching[i].pc;
 	set_function_break(pc, match_spec, break_flags,
-			   count_op, tracer_pid);
+			   count_op, tracer);
     }
 }
 
 static void
 set_function_break(BeamInstr *pc, Binary *match_spec, Uint break_flags,
-		   enum erts_break_op count_op, Eterm tracer_pid)
+		   enum erts_break_op count_op, ErtsTracer tracer)
 {
     GenericBp* g;
     GenericBpData* bp;
@@ -1439,7 +1454,7 @@ set_function_break(BeamInstr *pc, Binary *match_spec, Uint break_flags,
 	MatchSetUnref(bp->local_ms);
     } else if (common & ERTS_BPF_META_TRACE) {
 	MatchSetUnref(bp->meta_ms);
-	bp_meta_unref(bp->meta_pid);
+	bp_meta_unref(bp->meta_tracer);
     } else if (common & ERTS_BPF_COUNT) {
 	if (count_op == erts_break_stop) {
 	    bp->flags &= ~ERTS_BPF_COUNT_ACTIVE;
@@ -1474,13 +1489,15 @@ set_function_break(BeamInstr *pc, Binary *match_spec, Uint break_flags,
 	MatchSetRef(match_spec);
 	bp->local_ms = match_spec;
     } else if (break_flags & ERTS_BPF_META_TRACE) {
-	BpMetaPid* bmp;
+	BpMetaTracer* bmt;
+        ErtsTracer meta_tracer = erts_tracer_nil;
 	MatchSetRef(match_spec);
 	bp->meta_ms = match_spec;
-	bmp = Alloc(sizeof(BpMetaPid));
-	erts_refc_init(&bmp->refc, 1);
-	erts_smp_atomic_init_nob(&bmp->pid, tracer_pid);
-	bp->meta_pid = bmp;
+	bmt = Alloc(sizeof(BpMetaTracer));
+	erts_refc_init(&bmt->refc, 1);
+        erts_tracer_update(&meta_tracer, tracer); /* copy tracer */
+	erts_smp_atomic_init_nob(&bmt->tracer, (erts_aint_t)meta_tracer);
+	bp->meta_tracer = bmt;
     } else if (break_flags & ERTS_BPF_COUNT) {
 	BpCount* bcp;
 
@@ -1544,7 +1561,7 @@ clear_function_break(BeamInstr *pc, Uint break_flags)
     }
     if (common & ERTS_BPF_META_TRACE) {
 	MatchSetUnref(bp->meta_ms);
-	bp_meta_unref(bp->meta_pid);
+	bp_meta_unref(bp->meta_tracer);
     }
     if (common & ERTS_BPF_COUNT) {
 	ASSERT((bp->flags & ERTS_BPF_COUNT_ACTIVE) == 0);
@@ -1560,10 +1577,12 @@ clear_function_break(BeamInstr *pc, Uint break_flags)
 }
 
 static void
-bp_meta_unref(BpMetaPid* bmp)
+bp_meta_unref(BpMetaTracer* bmt)
 {
-    if (erts_refc_dectest(&bmp->refc, 0) <= 0) {
-	Free(bmp);
+    if (erts_refc_dectest(&bmt->refc, 0) <= 0) {
+        ErtsTracer trc = erts_smp_atomic_read_nob(&bmt->tracer);
+        ERTS_TRACER_CLEAR(&trc);
+	Free(bmt);
     }
 }
 
-- 
cgit v1.2.3


From af2a4c5a40c62da775caa92df5164fbee08b9245 Mon Sep 17 00:00:00 2001
From: Sverker Eriksson <sverker@erlang.org>
Date: Tue, 2 Feb 2016 17:30:51 +0100
Subject: erts: Rename constants in enum erts_break_op

with uppercase for constants
and why not call them 'RESTART' and 'PAUSE' as the API.
---
 erts/emulator/beam/beam_bp.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'erts/emulator/beam/beam_bp.c')

diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index 2ee98ed7b5..c4b9259d64 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -1432,7 +1432,7 @@ set_function_break(BeamInstr *pc, Binary *match_spec, Uint break_flags,
     g = (GenericBp *) pc[-4];
     if (g == 0) {
 	int i;
-	if (count_op == erts_break_reset || count_op == erts_break_stop) {
+	if (count_op == ERTS_BREAK_RESTART || count_op == ERTS_BREAK_PAUSE) {
 	    /* Do not insert a new breakpoint */
 	    return;
 	}
@@ -1456,7 +1456,7 @@ set_function_break(BeamInstr *pc, Binary *match_spec, Uint break_flags,
 	MatchSetUnref(bp->meta_ms);
 	bp_meta_unref(bp->meta_tracer);
     } else if (common & ERTS_BPF_COUNT) {
-	if (count_op == erts_break_stop) {
+	if (count_op == ERTS_BREAK_PAUSE) {
 	    bp->flags &= ~ERTS_BPF_COUNT_ACTIVE;
 	} else {
 	    bp->flags |= ERTS_BPF_COUNT_ACTIVE;
@@ -1468,7 +1468,7 @@ set_function_break(BeamInstr *pc, Binary *match_spec, Uint break_flags,
 	BpDataTime* bdt = bp->time;
 	Uint i = 0;
 
-	if (count_op == erts_break_stop) {
+	if (count_op == ERTS_BREAK_PAUSE) {
 	    bp->flags &= ~ERTS_BPF_TIME_TRACE_ACTIVE;
 	} else {
 	    bp->flags |= ERTS_BPF_TIME_TRACE_ACTIVE;
-- 
cgit v1.2.3


From 4a4475dea3ab0daf29f9a49ce845fa062387362a Mon Sep 17 00:00:00 2001
From: Sverker Eriksson <sverker@erlang.org>
Date: Thu, 3 Mar 2016 19:34:50 +0100
Subject: erts: Add match spec for send trace

---
 erts/emulator/beam/beam_bp.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'erts/emulator/beam/beam_bp.c')

diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index c4b9259d64..1e30e8d8d1 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -248,7 +248,10 @@ erts_bp_match_export(BpFunctions* f, Eterm mfa[3], int specified)
 void
 erts_bp_free_matched_functions(BpFunctions* f)
 {
-    Free(f->matching);
+    if (f->matching) {
+	Free(f->matching);
+    }
+    else ASSERT(f->matched == 0);
 }
 
 void
-- 
cgit v1.2.3


From 8cbf3bd3b9d552423812df4acc7a40d9a23fdeae Mon Sep 17 00:00:00 2001
From: Rickard Green <rickard@erlang.org>
Date: Mon, 2 May 2016 16:02:02 +0200
Subject: Add better support for communication with a process executing dirty
 NIF

- Termination of a process...
- Modify trace flags of process...
- Process info on process...
- Register/unregister of name on process...
- Set group leader on process...

...  while it is executing a dirty NIF.
---
 erts/emulator/beam/beam_bp.c | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

(limited to 'erts/emulator/beam/beam_bp.c')

diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index 1e30e8d8d1..308e5ce205 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -82,7 +82,7 @@ erts_smp_atomic32_t erts_staging_bp_index;
 static ERTS_INLINE ErtsMonotonicTime
 get_mtime(Process *c_p)
 {
-    return erts_get_monotonic_time(ERTS_PROC_GET_SCHDATA(c_p));
+    return erts_get_monotonic_time(erts_proc_sched_data(c_p));
 }
 
 /* *************************************************************************
@@ -976,7 +976,8 @@ erts_trace_time_call(Process* c_p, BeamInstr* I, BpDataTime* bdt)
     BpDataTime *pbdt = NULL;
 
     ASSERT(c_p);
-    ASSERT(erts_smp_atomic32_read_acqb(&c_p->state) & ERTS_PSFLG_RUNNING);
+    ASSERT(erts_smp_atomic32_read_acqb(&c_p->state) & (ERTS_PSFLG_RUNNING
+						       | ERTS_PSFLG_DIRTY_RUNNING));
 
     /* get previous timestamp and breakpoint
      * from the process psd  */
@@ -1053,7 +1054,8 @@ erts_trace_time_return(Process *p, BeamInstr *pc)
     BpDataTime *pbdt = NULL;
 
     ASSERT(p);
-    ASSERT(erts_smp_atomic32_read_acqb(&p->state) & ERTS_PSFLG_RUNNING);
+    ASSERT(erts_smp_atomic32_read_acqb(&p->state) & (ERTS_PSFLG_RUNNING
+						     | ERTS_PSFLG_DIRTY_RUNNING));
 
     /* get previous timestamp and breakpoint
      * from the process psd  */
-- 
cgit v1.2.3


From 3471d44a6a5ed5ab038c4cdc76b350119fe745e2 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang.org>
Date: Wed, 11 May 2016 11:16:16 +0200
Subject: erts: Only allow remove from trace_status callback

Make it so that it is only possible to remove a tracer via
returning remove from an erl_tracer. This limition is put in
place in order to avoid a lot of lock checking and taking
in various places, especially in regards to trace events
happening on dirty schedulers.
---
 erts/emulator/beam/beam_bp.c | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

(limited to 'erts/emulator/beam/beam_bp.c')

diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index 308e5ce205..8489897d3a 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -655,8 +655,7 @@ erts_generic_breakpoint(Process* c_p, BeamInstr* I, Eterm* reg)
 	erts_smp_atomic_inc_nob(&bp->count->acount);
     }
 
-    if (bp_flags & ERTS_BPF_TIME_TRACE_ACTIVE
-        && ERTS_TRACER_PROC_IS_ENABLED(c_p)) {
+    if (bp_flags & ERTS_BPF_TIME_TRACE_ACTIVE) {
 	Eterm w;
 	erts_trace_time_call(c_p, I, bp->time);
 	w = (BeamInstr) *c_p->cp;
@@ -753,8 +752,7 @@ erts_bif_trace(int bif_index, Process* p, Eterm* args, BeamInstr* I)
 	}
     }
     if (bp_flags & ERTS_BPF_TIME_TRACE_ACTIVE &&
-	IS_TRACED_FL(p, F_TRACE_CALLS) &&
-	ERTS_TRACER_PROC_IS_ENABLED(p)) {
+	IS_TRACED_FL(p, F_TRACE_CALLS)) {
 	BeamInstr *pc = (BeamInstr *)ep->code+3;
 	erts_trace_time_call(p, pc, bp->time);
     }
-- 
cgit v1.2.3