Don't go to single-scheduler mode when managing breakpoints

Calls to erlang:set_trace_pattern/3 will no longer block all
other schedulers.

We will still go to single-scheduler mode when new code is loaded
for a module that is traced, or when loading code when there is a
default trace pattern set. That is not impossible to fix, but that
requires much closer cooperation between tracing BIFs and the loader
BIFs.

1 files changed, 0 insertions, 179 deletions

diff --git a/erts/emulator/beam/erl_trace.c b/erts/emulator/beam/erl_trace.c
index c64c9d8eee..d04a91f18c 100644
--- a/erts/emulator/beam/erl_trace.c
+++ b/erts/emulator/beam/erl_trace.c
@@ -2134,185 +2134,6 @@ void save_calls(Process *p, Export *e)
     }
 }
 
-/* 
- * Entry point called by the trace wrap functions in erl_bif_wrap.c
- *
- * The trace wrap functions are themselves called through the export
- * entries instead of the original BIF functions.
- */
-Eterm
-erts_bif_trace(int bif_index, Process* p, Eterm* args, BeamInstr* I)
-{
-    Eterm result;
-    int meta = !!(erts_bif_trace_flags[bif_index] & BIF_TRACE_AS_META);
-
-    ERTS_SMP_CHK_HAVE_ONLY_MAIN_PROC_LOCK(p);
-
-    if (!ARE_TRACE_FLAGS_ON(p, F_TRACE_CALLS) && (! meta)) {
-	/* Warning! This is an Optimization. 
-	 *
-	 * If neither meta trace is active nor process trace flags then 
-	 * no tracing will occur. Doing the whole else branch will 
-	 * also do nothing, only slower.
-	 */
-	Eterm (*func)(Process*, Eterm*, BeamInstr*) = bif_table[bif_index].f;
-	result = func(p, args, I);
-    } else {
-	Eterm (*func)(Process*, Eterm*, BeamInstr*);
-	Export* ep = bif_export[bif_index];
-	Uint32 flags = 0, flags_meta = 0;
-	int global = !!(erts_bif_trace_flags[bif_index] & BIF_TRACE_AS_GLOBAL);
-	int local  = !!(erts_bif_trace_flags[bif_index] & BIF_TRACE_AS_LOCAL);
-	int time   = !!(erts_bif_trace_flags[bif_index] & BIF_TRACE_AS_CALL_TIME);
-	Eterm meta_tracer_pid = NIL;
-	int applying = (I == &(ep->code[3])); /* Yup, the apply code for a bif
-					       * is actually in the 
-					       * export entry */
-	BeamInstr *cp = p->cp;
-	
-	/* 
-	 * Make continuation pointer OK, it is not during direct BIF calls,
-	 * but it is correct during apply of bif.
-	 */
-	if (!applying) { 
-	    p->cp = I;
-	}
-	if (global || local) {
-	    flags = erts_call_trace(p, ep->code, ep->match_prog_set, args, 
-				       local, &p->tracer_proc);
-	}
-	if (meta) {
-	    flags_meta = erts_bif_mtrace(p, ep->code+3, args, local, 
-					 &meta_tracer_pid);
-	}
-	if (time) {
-	    BpDataTime *bdt;
-	    BeamInstr *pc = (BeamInstr *)ep->code+3;
-
-	    bdt = erts_get_active_time_break(pc);
-	    if (bdt) {
-		erts_trace_time_call(p, pc, bdt);
-	    }
-	}
-	/* Restore original continuation pointer (if changed). */
-	p->cp = cp;
-	
-	func = bif_table[bif_index].f;
-
-	result = func(p, args, I);
-	
-	if (applying && (flags & MATCH_SET_RETURN_TO_TRACE)) {
-	    BeamInstr i_return_trace      = beam_return_trace[0];
-	    BeamInstr i_return_to_trace   = beam_return_to_trace[0];
-	    BeamInstr i_return_time_trace = beam_return_time_trace[0];
-	    Eterm *cpp;
-	    /* Maybe advance cp to skip trace stack frames */
-	    for (cpp = p->stop;  ;  cp = cp_val(*cpp++)) {
-		if (*cp == i_return_trace) {
-		    /* Skip stack frame variables */
-		    while (is_not_CP(*cpp)) cpp++;
-		    cpp += 2; /* Skip return_trace parameters */
-		} else if (*cp == i_return_time_trace) {
-		    /* Skip stack frame variables */
-		    while (is_not_CP(*cpp)) cpp++;
-		    cpp += 1; /* Skip return_time_trace parameters */
-		} else if (*cp == i_return_to_trace) {
-		    /* A return_to trace message is going to be generated
-		     * by normal means, so we do not have to.
-		     */
-		    cp = NULL;
-		    break;
-		} else break;
-	    }
-	}
-	
-	/* Try to get these in the order 
-	 * they usually appear in normal code... */
-	if (is_non_value(result)) {
-	    Uint reason = p->freason;
-	    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;
-		    ASSERT(is_tuple(value));
-		    tp = tuple_val(value);
-		    value = tp[1];
-		}
-		if ((reason & EXF_THROWN) && (p->catches <= 0)) {
-		    value = TUPLE2(nocatch, am_nocatch, value);
-		    reason = EXC_ERROR;
-		}
-		/* Note: expand_error_value() could theoretically 
-		 * allocate on the heap, but not for any error
-		 * returned by a BIF, and it would do no harm,
-		 * just be annoying.
-		 */
-		value = expand_error_value(p, reason, value);
-		class = exception_tag[GET_EXC_CLASS(reason)];
-		
-		if (flags_meta & MATCH_SET_EXCEPTION_TRACE) {
-		    erts_trace_exception(p, ep->code, class, value,
-					 &meta_tracer_pid);
-		}
-		if (flags & MATCH_SET_EXCEPTION_TRACE) {
-		    erts_trace_exception(p, ep->code, class, value,
-					 &p->tracer_proc);
-		}
-		if ((flags & MATCH_SET_RETURN_TO_TRACE) && p->catches > 0) {
-		    /* can only happen if(local)*/
-		    Eterm *ptr = p->stop;
-		    ASSERT(is_CP(*ptr));
-		    ASSERT(ptr <= STACK_START(p));
-		    /* Search the nearest stack frame for a catch */
-		    while (++ptr < STACK_START(p)) {
-			if (is_CP(*ptr)) break;
-			if (is_catch(*ptr)) {
-			    if (applying) {
-				/* Apply of BIF, cp is in calling function */
-				if (cp) erts_trace_return_to(p, cp);
-			    } else {
-				/* Direct bif call, I points into 
-				 * calling function */
-				erts_trace_return_to(p, I);
-			    }
-			}
-		    }
-		}
-		UnUseTmpHeapNoproc(3);
-		if ((flags_meta|flags) & MATCH_SET_EXCEPTION_TRACE) {
-		    erts_smp_proc_lock(p, ERTS_PROC_LOCKS_ALL_MINOR);
-		    p->trace_flags |= F_EXCEPTION_TRACE;
-		    erts_smp_proc_unlock(p, ERTS_PROC_LOCKS_ALL_MINOR);
-		}
-	    }
-	} else {
-	    if (flags_meta & MATCH_SET_RX_TRACE) {
-		erts_trace_return(p, ep->code, result, &meta_tracer_pid);
-	    }
-	    /* MATCH_SET_RETURN_TO_TRACE cannot occur if(meta) */
-	    if (flags & MATCH_SET_RX_TRACE) {
-		erts_trace_return(p, ep->code, result, &p->tracer_proc);
-	    }
-	    if (flags & MATCH_SET_RETURN_TO_TRACE) { 
-		/* can only happen if(local)*/
-		if (applying) {
-		    /* Apply of BIF, cp is in calling function */
-		    if (cp) erts_trace_return_to(p, cp);
-		} else {
-		    /* Direct bif call, I points into calling function */
-		    erts_trace_return_to(p, I);
-		}
-	    }
-	}
-    }
-    ERTS_SMP_CHK_HAVE_ONLY_MAIN_PROC_LOCK(p);
-    return result;
-}
-
 /* Sends trace message:
  *    {trace_ts, Pid, What, Msg, Timestamp}
  * or {trace, Pid, What, Msg}