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

1 files changed, 845 insertions, 1685 deletions

diff --git a/erts/emulator/beam/erl_trace.c b/erts/emulator/beam/erl_trace.c
index 1654ea58d9..1e6ae8c82e 100644
--- a/erts/emulator/beam/erl_trace.c
+++ b/erts/emulator/beam/erl_trace.c
@@ -39,6 +39,7 @@
 #include "erl_bits.h"
 #include "erl_thr_progress.h"
 #include "erl_bif_unique.h"
+#include "erl_map.h"
 
 #if 0
 #define DEBUG_PRINTOUTS
@@ -46,17 +47,13 @@
 #undef DEBUG_PRINTOUTS
 #endif
 
-extern BeamInstr beam_return_to_trace[1];   /* OpCode(i_return_to_trace) */
-extern BeamInstr beam_return_trace[1];      /* OpCode(i_return_trace) */
-extern BeamInstr beam_return_time_trace[1]; /* OpCode(i_return_time_trace) */
-
 /* Pseudo export entries. Never filled in with data, only used to
    yield unique pointers of the correct type. */
 Export exp_send, exp_receive, exp_timeout;
 
-static Eterm system_seq_tracer;
+static ErtsTracer system_seq_tracer;
 static Uint default_trace_flags;
-static Eterm default_tracer;
+static ErtsTracer default_tracer;
 
 static Eterm system_monitor;
 static Eterm system_profile;
@@ -70,11 +67,8 @@ static erts_smp_rwmtx_t sys_trace_rwmtx;
 
 enum ErtsSysMsgType {
     SYS_MSG_TYPE_UNDEFINED,
-    SYS_MSG_TYPE_TRACE,
-    SYS_MSG_TYPE_SEQTRACE,
     SYS_MSG_TYPE_SYSMON,
     SYS_MSG_TYPE_ERRLGR,
-    SYS_MSG_TYPE_PROC_MSG,
     SYS_MSG_TYPE_SYSPROF
 };
 
@@ -298,43 +292,6 @@ write_ts(int ts_type, Eterm *hp, ErlHeapFragment *bp, Process *tracer)
     return res;
 }
 
-/*
- * Patch a timestamp into a tuple. The tuple MUST be the last thing
- * built on the heap before the call, and the timestamp MUST be
- * the last thing after the call. This since patch_ts() might adjust
- * the size of the used area.
- */
-
-#define PATCH_TS__(Type, Tuple, Hp, Bp, Tracer)			\
-    do {							\
-	int ts_type__ = (Type);					\
-	if (ts_type__)						\
-	    patch_ts(ts_type__, (Tuple), (Hp), (Bp), (Tracer));	\
-    } while (0)
-
-#ifdef ERTS_SMP
-#define PATCH_TS(Type, Tuple, Hp, Bp, Tracer) \
-    PATCH_TS__((Type), (Tuple), (Hp), (Bp), NULL)
-#else
-#define PATCH_TS(Type, Tuple, Hp, Bp, Tracer) \
-    PATCH_TS__((Type), (Tuple), (Hp), (Bp), (Tracer))
-#endif
-
-static ERTS_INLINE void
-patch_ts(int ts_type, Eterm tuple, Eterm* hp, ErlHeapFragment *bp, Process *tracer)
-{
-    Eterm *tptr = tuple_val(tuple);
-    int arity = arityval(*tptr);
-
-    ASSERT(ts_type);
-    ASSERT((tptr+arity+1) == hp);
-
-    tptr[0] = make_arityval(arity+1);
-    tptr[1] = am_trace_ts;
-
-    *hp = write_ts(ts_type, hp+1, bp, tracer);
-}
-
 #ifdef ERTS_SMP
 static void enqueue_sys_msg_unlocked(enum ErtsSysMsgType type,
 				     Eterm from,
@@ -349,6 +306,14 @@ static void enqueue_sys_msg(enum ErtsSysMsgType type,
 static void init_sys_msg_dispatcher(void);
 #endif
 
+static void init_tracer_nif(void);
+static int tracer_cmp_fun(void*, void*);
+static HashValue tracer_hash_fun(void*);
+static void *tracer_alloc_fun(void*);
+static void tracer_free_fun(void*);
+
+typedef struct ErtsTracerNif_ ErtsTracerNif;
+
 void erts_init_trace(void) {
     erts_smp_rwmtx_opt_t rwmtx_opts = ERTS_SMP_RWMTX_OPT_DEFAULT_INITER;
     rwmtx_opts.type = ERTS_SMP_RWMTX_TYPE_EXTREMELY_FREQUENT_READ;
@@ -363,79 +328,38 @@ void erts_init_trace(void) {
     erts_system_monitor_clear(NULL);
     erts_system_profile_clear(NULL);
     default_trace_flags = F_INITIAL_TRACE_FLAGS;
-    default_tracer = NIL;
-    system_seq_tracer = am_false;
+    default_tracer = erts_tracer_nil;
+    system_seq_tracer = erts_tracer_nil;
 #ifdef ERTS_SMP
     init_sys_msg_dispatcher();
 #endif
+    init_tracer_nif();
 }
 
-static Eterm system_seq_tracer;
-
 #define ERTS_ALLOC_SYSMSG_HEAP(SZ, BPP, OHPP, UNUSED) \
   (*(BPP) = new_message_buffer((SZ)), \
    *(OHPP) = &(*(BPP))->off_heap, \
    (*(BPP))->mem)
 
-#ifdef ERTS_SMP
-#define ERTS_ENQ_TRACE_MSG(FPID, TPID, MSG, BP) \
-do { \
-    ERTS_LC_ASSERT(erts_smp_lc_mtx_is_locked(&smq_mtx)); \
-    enqueue_sys_msg_unlocked(SYS_MSG_TYPE_TRACE, (FPID), (TPID), (MSG), (BP)); \
-} while(0)
-#else
-#define ERTS_ENQ_TRACE_MSG(FPID, TPROC, MSG, BP)		\
-    do {							\
-	ErtsMessage *mp__ = erts_alloc_message(0, NULL);		\
-	mp__->data.heap_frag = (BP);				\
-	erts_queue_message((TPROC), NULL, mp__, (MSG), NIL);	\
-    } while (0)
-#endif
-
-/*
- * NOTE that the ERTS_GET_TRACER_REF() returns from the function  (!!!)
- * using it, and resets the parameters used if the tracer is invalid, i.e.,
- * use it with extreme care!
- */
-#ifdef ERTS_SMP
-#define ERTS_NULL_TRACER_REF NIL
-#define ERTS_TRACER_REF_TYPE Eterm
- /* In the smp case, we never find the tracer invalid here (the sys
-    message dispatcher thread takes care of that). */
-#define ERTS_GET_TRACER_REF(RES, TPID, TRACEE_FLGS) \
-do { (RES) = (TPID); } while(0)
-int
-erts_is_tracer_proc_valid(Process* p)
-{
-    return 1;
-}
-#else
-#define ERTS_NULL_TRACER_REF NULL
-#define ERTS_TRACER_REF_TYPE Process *
-#define ERTS_GET_TRACER_REF(RES, TPID, TRACEE_FLGS) \
-do { \
-    (RES) = erts_proc_lookup((TPID)); \
-    if (!(RES) || !(ERTS_TRACE_FLAGS((RES)) & F_TRACER)) { \
-	(TPID) = NIL; \
-	(TRACEE_FLGS) &= ~TRACEE_FLAGS; \
-	return; \
-    } \
-} while (0)
-int
-erts_is_tracer_proc_valid(Process* p)
-{
-    Process* tracer;
+static ERTS_INLINE int
+send_to_tracer_nif_raw(Process *c_p, Process *tracee, const ErtsTracer tracer,
+                       Uint trace_flags, Eterm t_p_id, ErtsTracerNif *tnif,
+                       Eterm tag, Eterm msg, Eterm extra, Eterm pam_result);
+static ERTS_INLINE int
+send_to_tracer_nif(Process *c_p, ErtsPTabElementCommon *t_p,
+                   Eterm t_p_id, ErtsTracerNif *tnif, Eterm tag,
+                   Eterm msg, Eterm extra);
+static ERTS_INLINE Eterm
+call_enabled_tracer(Process *c_p, const ErtsTracer tracer,
+                    ErtsTracerNif **tnif_ref, Eterm tag, Eterm t_p_id);
+static int
+is_tracer_proc_enabled(Process* c_p, ErtsProcLocks c_p_locks,
+                       ErtsPTabElementCommon *t_p,
+                       ErtsTracerNif **tnif_ret, Eterm tag);
 
-    tracer = erts_proc_lookup(ERTS_TRACER_PROC(p));
-    if (tracer && ERTS_TRACE_FLAGS(tracer) & F_TRACER) {
-	return 1;
-    } else {
-	ERTS_TRACER_PROC(p) = NIL;
-	ERTS_TRACE_FLAGS(p) = ~TRACEE_FLAGS;
-	return 0;
-    }
-}
-#endif
+#define SEND_TO_TRACER(c_p, tag, msg)                                   \
+    send_to_tracer_nif(c_p, &(c_p)->common, (c_p)->common.id, NULL, tag, \
+                       msg, THE_NON_VALUE)
 
 static Uint active_sched;
 
@@ -450,19 +374,6 @@ static void
 exiting_reset(Eterm exiting)
 {
     erts_smp_rwmtx_rwlock(&sys_trace_rwmtx);
-    if (exiting == default_tracer) {
-	default_tracer = NIL;
-	default_trace_flags &= TRACEE_FLAGS;
-#ifdef DEBUG
-	default_trace_flags |= F_INITIAL_TRACE_FLAGS;
-#endif
-    }
-    if (exiting == system_seq_tracer) {
-#ifdef DEBUG_PRINTOUTS
-	erts_fprintf(stderr, "seq tracer %T exited\n", exiting);
-#endif
-	system_seq_tracer = am_false;
-    }
     if (exiting == system_monitor) {
 #ifdef ERTS_SMP
 	system_monitor = NIL;
@@ -487,11 +398,7 @@ erts_trace_check_exiting(Eterm exiting)
 {
     int reset = 0;
     erts_smp_rwmtx_rlock(&sys_trace_rwmtx);
-    if (exiting == default_tracer)
-	reset = 1;
-    else if (exiting == system_seq_tracer)
-	reset = 1;
-    else if (exiting == system_monitor)
+    if (exiting == system_monitor)
 	reset = 1;
     else if (exiting == system_profile)
 	reset = 1;
@@ -500,23 +407,26 @@ erts_trace_check_exiting(Eterm exiting)
 	exiting_reset(exiting);
 }
 
-static ERTS_INLINE int
-is_valid_tracer(Eterm tracer)
-{
-    return erts_proc_lookup(tracer) || erts_is_valid_tracer_port(tracer);
-}
-
-Eterm
-erts_set_system_seq_tracer(Process *c_p, ErtsProcLocks c_p_locks, Eterm new)
+ErtsTracer
+erts_set_system_seq_tracer(Process *c_p, ErtsProcLocks c_p_locks, ErtsTracer new)
 {
-    Eterm old;
-
-    if (new != am_false && !is_valid_tracer(new))
-	return THE_NON_VALUE;
+    ErtsTracer old;
+
+    if (!ERTS_TRACER_IS_NIL(new)) {
+        Eterm nif_result = call_enabled_tracer(
+            NULL, new, NULL,
+            am_trace_status, am_undefined);
+        switch (nif_result) {
+        case am_trace: break;
+        default:
+            return THE_NON_VALUE;
+        }
+    }
 
     erts_smp_rwmtx_rwlock(&sys_trace_rwmtx);
     old = system_seq_tracer;
-    system_seq_tracer = new;
+    system_seq_tracer = erts_tracer_nil;
+    erts_tracer_update(&system_seq_tracer, new);
 
 #ifdef DEBUG_PRINTOUTS
     erts_fprintf(stderr, "set seq tracer new=%T old=%T\n", new, old);
@@ -525,47 +435,56 @@ erts_set_system_seq_tracer(Process *c_p, ErtsProcLocks c_p_locks, Eterm new)
     return old;
 }
 
-Eterm
+ErtsTracer
 erts_get_system_seq_tracer(void)
 {
-    Eterm st;
+    ErtsTracer st;
     erts_smp_rwmtx_rlock(&sys_trace_rwmtx);
     st = system_seq_tracer;
 #ifdef DEBUG_PRINTOUTS
     erts_fprintf(stderr, "get seq tracer %T\n", st);
 #endif
     erts_smp_rwmtx_runlock(&sys_trace_rwmtx);
+
+    if (st != erts_tracer_nil &&
+        call_enabled_tracer(NULL, st, NULL, am_trace_status, am_undefined) == am_remove) {
+        erts_set_system_seq_tracer(NULL, 0, erts_tracer_nil);
+        st = erts_tracer_nil;
+    }
+
     return st;
 }
 
 static ERTS_INLINE void
-get_default_tracing(Uint *flagsp, Eterm *tracerp)
+get_default_tracing(Uint *flagsp, ErtsTracer *tracerp)
 {
     if (!(default_trace_flags & TRACEE_FLAGS))
-	default_tracer = NIL;
+	ERTS_TRACER_CLEAR(&default_tracer);
 
-    if (is_nil(default_tracer)) {
+    if (ERTS_TRACER_IS_NIL(default_tracer)) {
 	default_trace_flags &= ~TRACEE_FLAGS;
-    } else if (is_internal_pid(default_tracer)) {
-	if (!erts_proc_lookup(default_tracer)) {
-	reset_tracer:
-	    default_trace_flags &= ~TRACEE_FLAGS;
-	    default_tracer = NIL;
-	}
     } else {
-	ASSERT(is_internal_port(default_tracer));
-	if (!erts_is_valid_tracer_port(default_tracer))
-	    goto reset_tracer;
+        Eterm nif_result = call_enabled_tracer(
+            NULL, default_tracer, NULL,
+            am_trace_status, am_undefined);
+        switch (nif_result) {
+        case am_trace: break;
+        default:
+            default_trace_flags &= ~TRACEE_FLAGS;
+            ERTS_TRACER_CLEAR(&default_tracer);
+        }
     }
 
     if (flagsp)
 	*flagsp = default_trace_flags;
-    if (tracerp)
-	*tracerp = default_tracer;
+    if (tracerp) {
+	erts_tracer_update(tracerp,default_tracer);
+    }
 }
 
 void
-erts_change_default_tracing(int setflags, Uint *flagsp, Eterm *tracerp)
+erts_change_default_tracing(int setflags, Uint *flagsp,
+                            const ErtsTracer tracer)
 {
     erts_smp_rwmtx_rwlock(&sys_trace_rwmtx);
     if (flagsp) {
@@ -574,16 +493,18 @@ erts_change_default_tracing(int setflags, Uint *flagsp, Eterm *tracerp)
 	else
 	    default_trace_flags &= ~(*flagsp);
     }
-    if (tracerp)
-	default_tracer = *tracerp;
-    get_default_tracing(flagsp, tracerp);
+
+    erts_tracer_update(&default_tracer, tracer);
+
+    get_default_tracing(flagsp, NULL);
     erts_smp_rwmtx_rwunlock(&sys_trace_rwmtx);
 }
 
 void
-erts_get_default_tracing(Uint *flagsp, Eterm *tracerp)
+erts_get_default_tracing(Uint *flagsp, ErtsTracer *tracerp)
 {
     erts_smp_rwmtx_rlock(&sys_trace_rwmtx);
+    *tracerp = erts_tracer_nil; /* initialize */
     get_default_tracing(flagsp, tracerp);
     erts_smp_rwmtx_runlock(&sys_trace_rwmtx);
 }
@@ -622,29 +543,21 @@ erts_get_system_profile(void) {
     return profile;
 }
 
-#ifdef ERTS_SMP
-static void
-do_send_to_port(Eterm to,
-		Port* unused_port,
-		Eterm from,
-		enum ErtsSysMsgType type,
-		Eterm message)
-{
-    Uint sz = size_object(message);
-    ErlHeapFragment *bp = new_message_buffer(sz);
-    Uint *hp = bp->mem;
-    Eterm msg = copy_struct(message, sz, &hp, &bp->off_heap);
 
-    enqueue_sys_msg_unlocked(type, from, to, msg, bp);
-}
-
-#define WRITE_SYS_MSG_TO_PORT write_sys_msg_to_port
+#ifdef HAVE_ERTS_NOW_CPU
+#  define GET_NOW(m, s, u) \
+do { \
+    if (erts_cpu_timestamp) \
+	erts_get_now_cpu(m, s, u); \
+    else \
+	get_now(m, s, u); \
+} while (0)
 #else
-#define WRITE_SYS_MSG_TO_PORT do_send_to_port
+#  define GET_NOW(m, s, u) do {get_now(m, s, u);} while (0)
 #endif
 
 static void
-WRITE_SYS_MSG_TO_PORT(Eterm unused_to,
+write_sys_msg_to_port(Eterm unused_to,
 		      Port* trace_port,
 		      Eterm unused_from,
 		      enum ErtsSysMsgType unused_type,
@@ -671,150 +584,6 @@ WRITE_SYS_MSG_TO_PORT(Eterm unused_to,
     erts_free(ERTS_ALC_T_TMP, (void *) buffer);
 }
 
-
-#ifndef ERTS_SMP
-/* Send        {trace_ts, Pid, out, 0, Timestamp}
- * followed by {trace_ts, Pid, in, 0, NewTimestamp}
- *
- * 'NewTimestamp' through patch_ts().
- */
-static void 
-do_send_schedfix_to_port(Port *trace_port, Eterm pid, Eterm timestamp, int ts_type) {
-#define LOCAL_HEAP_SIZE (5+5+ERTS_TRACE_PATCH_TS_MAX_SIZE)
-    DeclareTmpHeapNoproc(local_heap,LOCAL_HEAP_SIZE);
-    Eterm message;
-    Eterm *hp;
-    Eterm mfarity;
-
-    UseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-    ASSERT(is_pid(pid));
-    ASSERT(is_tuple(timestamp));
-    ASSERT(*tuple_val(timestamp) == make_arityval(3));
-    
-    hp = local_heap;
-    mfarity = make_small(0);
-    message = TUPLE5(hp, am_trace_ts, pid, am_out, mfarity, timestamp);
-    /* Note, hp is deliberately NOT incremented since it will be reused */
-
-    do_send_to_port(trace_port->common.id,
-		    trace_port,
-		    pid,
-		    SYS_MSG_TYPE_UNDEFINED,
-		    message);
-
-
-    message = TUPLE5(hp, am_trace_ts, pid, am_in, mfarity,
-		     NIL /* Will be overwritten by timestamp */);
-    hp += 6;
-    hp[-1] = write_ts(ts_type, hp, NULL, NULL);
-
-    do_send_to_port(trace_port->common.id,
-		    trace_port,
-		    pid,
-		    SYS_MSG_TYPE_UNDEFINED,
-		    message);
-    UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-#undef LOCAL_HEAP_SIZE
-}
-#endif
-
-/* If (c_p != NULL), a fake schedule out/in message pair will be sent,
- * if the driver so requests. 
- * It is assumed that 'message' is not an 'out' message.
- *
- * 'c_p' is the currently executing process, "tracee" is the traced process
- * which 'message' concerns => if (*tracee_flags & F_TIMESTAMP_MASK), 
- * 'message' must contain a timestamp.
- */
-static void
-send_to_port(Process *c_p, Eterm message, 
-	     Eterm *tracer_pid, Uint *tracee_flags) {
-    Port* trace_port;
-#ifndef ERTS_SMP
-    int ts_type;
-#define LOCAL_HEAP_SIZE ERTS_TRACE_PATCH_TS_MAX_SIZE
-    Eterm ts;
-    DeclareTmpHeapNoproc(local_heap,LOCAL_HEAP_SIZE);
-#endif
-
-    ASSERT(is_internal_port(*tracer_pid));
-#ifdef ERTS_SMP
-    if (is_not_internal_port(*tracer_pid))
-	return;
-
-    trace_port = NULL;
-#else
-
-    trace_port = erts_id2port_sflgs(*tracer_pid,
-				    NULL,
-				    0,
-				    ERTS_PORT_SFLGS_INVALID_TRACER_LOOKUP);
-
-    if (!trace_port) {
-	*tracee_flags &= ~TRACEE_FLAGS;
-	*tracer_pid = NIL;
-	return;
-    }
-
-    /*
-     * Make a fake schedule only if the current process is traced
-     * with 'running' and 'timestamp'.
-     */
-
-    if ( c_p == NULL || 
-	 (! IS_TRACED_FL(c_p, F_TRACE_SCHED | F_TIMESTAMP_MASK))) { 
-#endif
-	do_send_to_port(*tracer_pid,
-			trace_port,
-			c_p ? c_p->common.id : NIL,
-			SYS_MSG_TYPE_TRACE,
-			message);
-#ifndef ERTS_SMP
-	erts_port_release(trace_port);
-	return;
-    }
-
-    /*
-     * Note that the process being traced for some type of trace messages
-     * (e.g. getting_linked) need not be the current process. That other
-     * process might not have timestamps enabled.
-     */
-    UseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-
-    /* A fake schedule might be needed.
-     * Create a dummy trace message with timestamp to be
-     * passed to do_send_schedfix_to_port().
-     */
-    ts_type = TFLGS_TS_TYPE(c_p);
-    ts = write_ts(ts_type, local_heap, NULL, NULL);
-
-    trace_port->control_flags &= ~PORT_CONTROL_FLAG_HEAVY;
-    do_send_to_port(*tracer_pid,
-		    trace_port,
-		    c_p ? c_p->common.id : NIL,
-		    SYS_MSG_TYPE_TRACE,
-		    message);
-
-    if (trace_port->control_flags & PORT_CONTROL_FLAG_HEAVY) {
-	/* The driver has just informed us that the last write took a 
-	 * non-neglectible amount of time.
-	 *
-	 * We need to fake some trace messages to compensate for the time the
-	 * current process had to sacrifice for the writing of the previous
-	 * trace message. We pretend that the process got scheduled out
-	 * just after writning the real trace message, and now gets scheduled
-	 * in again.
-	 */
-	do_send_schedfix_to_port(trace_port, c_p->common.id, ts, ts_type);
-    }
-
-    erts_port_release(trace_port);
-
-    UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-#undef LOCAL_HEAP_SIZE
-#endif
-}
-
 #ifndef ERTS_SMP
 /* Profile send
  * Checks if profiler is port or process
@@ -843,11 +612,11 @@ profile_send(Eterm from, Eterm message) {
 					   0,
 					   ERTS_PORT_SFLGS_INVALID_TRACER_LOOKUP);
 	if (profiler_port) {
-	    do_send_to_port(profiler,
-			    profiler_port,
-			    NIL, /* or current process->common.id */
-			    SYS_MSG_TYPE_SYSPROF,
-			    message);
+	    write_sys_msg_to_port(profiler,
+                                  profiler_port,
+                                  NIL, /* or current process->common.id */
+                                  SYS_MSG_TYPE_SYSPROF,
+                                  message);
 	    erts_port_release(profiler_port);
 	}
     	
@@ -867,154 +636,26 @@ profile_send(Eterm from, Eterm message) {
 	else
 	    msg = copy_struct(message, sz, &hp, &mp->hfrag.off_heap);
 
-        erts_queue_message(profile_p, NULL, mp, msg, NIL);
+        erts_queue_message(profile_p, NULL, mp, msg);
     }
 }
 
 #endif
 
-
-/* A fake schedule out/in message pair will be sent,
- * if the driver so requests.
- *
- * 'c_p' is the currently executing process, may be NULL.
- */
 static void
-seq_trace_send_to_port(Process *c_p,
-		       Eterm seq_tracer,
-		       Eterm message)
+trace_sched_aux(Process *p, ErtsProcLocks locks, Eterm what)
 {
-    Port* trace_port;
-#ifndef ERTS_SMP
-    int ts_type;
-    Eterm ts;
-#define LOCAL_HEAP_SIZE ERTS_TRACE_PATCH_TS_MAX_SIZE
-    DeclareTmpHeapNoproc(local_heap,LOCAL_HEAP_SIZE);
-    UseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-#endif
+    Eterm tmp, *hp;
+    int curr_func;
+    ErtsTracerNif *tnif = NULL;
 
-    ASSERT(is_internal_port(seq_tracer));
-#ifdef ERTS_SMP
-    if (is_not_internal_port(seq_tracer))
+    if (ERTS_TRACER_IS_NIL(ERTS_TRACER(p)))
 	return;
 
-    trace_port = NULL;
-#else
-    trace_port = erts_id2port_sflgs(seq_tracer,
-				    NULL,
-				    0,
-				    ERTS_PORT_SFLGS_INVALID_TRACER_LOOKUP);
-    if (!trace_port) {
-	system_seq_tracer = am_false;
-#ifndef ERTS_SMP
-	UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-#endif
-	return;
-    }
-
-    if (c_p == NULL
-	|| (! IS_TRACED_FL(c_p, F_TRACE_SCHED | F_TIMESTAMP_MASK))) {
-#endif
-	do_send_to_port(seq_tracer,
-			trace_port,
-			c_p ? c_p->common.id : NIL,
-			SYS_MSG_TYPE_SEQTRACE,
-			message);
-
-#ifndef ERTS_SMP
-	erts_port_release(trace_port);
-	UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-	return;
-    }
-    /* Make a fake schedule only if the current process is traced
-     * with 'running' and 'timestamp'.
-     */
-
-    /* A fake schedule might be needed.
-     * Create a dummy trace message with timestamp to be
-     * passed to do_send_schedfix_to_port().
-     */
-    ts_type = TFLGS_TS_TYPE(c_p);
-    ts = write_ts(ts_type, local_heap, NULL, NULL);
-
-    trace_port->control_flags &= ~PORT_CONTROL_FLAG_HEAVY;
-    do_send_to_port(seq_tracer,
-		    trace_port,
-		    c_p ? c_p->common.id : NIL,
-		    SYS_MSG_TYPE_SEQTRACE,
-		    message);
-
-    if (trace_port->control_flags & PORT_CONTROL_FLAG_HEAVY) {
-	/* The driver has just informed us that the last write took a 
-	 * non-neglectible amount of time.
-	 *
-	 * We need to fake some trace messages to compensate for the time the
-	 * current process had to sacrifice for the writing of the previous
-	 * trace message. We pretend that the process got scheduled out
-	 * just after writing the real trace message, and now gets scheduled
-	 * in again.
-	 */
-	do_send_schedfix_to_port(trace_port, c_p->common.id, ts, ts_type);
-    }
-
-    erts_port_release(trace_port);
-
-    UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-#undef LOCAL_HEAP_SIZE
-#endif
-}
-
-static ERTS_INLINE void
-send_to_tracer(Process *tracee,
-	       ERTS_TRACER_REF_TYPE tracer_ref,
-	       Eterm msg,
-	       Eterm **hpp,
-	       ErlHeapFragment *bp,
-	       int no_fake_sched)
-{
-    ERTS_SMP_LC_ASSERT(erts_proc_lc_my_proc_locks(tracee));
-
-    erts_smp_mtx_lock(&smq_mtx);
-
-    if (is_internal_pid(ERTS_TRACER_PROC(tracee))) {
-	PATCH_TS(TFLGS_TS_TYPE(tracee), msg, *hpp, bp, tracer_ref);
-	ERTS_ENQ_TRACE_MSG(tracee->common.id, tracer_ref, msg, bp);
-    }
-    else {
-	ASSERT(is_internal_port(ERTS_TRACER_PROC(tracee)));
-	PATCH_TS(TFLGS_TS_TYPE(tracee), msg, *hpp, NULL, NULL);
-	send_to_port(no_fake_sched ? NULL : tracee,
-		     msg,
-		     &ERTS_TRACER_PROC(tracee),
-		     &ERTS_TRACE_FLAGS(tracee));
-    }
-
-    erts_smp_mtx_unlock(&smq_mtx);
-
-}
-
-static void
-trace_sched_aux(Process *p, Eterm what, int never_fake_sched)
-{
-#define LOCAL_HEAP_SIZE (5+4+1+ERTS_TRACE_PATCH_TS_MAX_SIZE)
-    DeclareTmpHeap(local_heap,LOCAL_HEAP_SIZE,p);
-    Eterm tmp, mess, *hp;
-    ErlHeapFragment *bp = NULL;
-    ErlOffHeap *off_heap;
-    ERTS_TRACER_REF_TYPE tracer_ref = ERTS_NULL_TRACER_REF;
-    int sched_no, curr_func, to_port, no_fake_sched;
-
-    if (is_nil(ERTS_TRACER_PROC(p)))
-	return;
-
-    no_fake_sched = never_fake_sched;
-
     switch (what) {
     case am_out:
     case am_out_exiting:
     case am_out_exited:
-	no_fake_sched = 1;
-	break;
     case am_in:
     case am_in_exiting:
 	break;
@@ -1023,16 +664,8 @@ trace_sched_aux(Process *p, Eterm what, int never_fake_sched)
 	break;
     }
 
-    sched_no = IS_TRACED_FL(p, F_TRACE_SCHED_NO);
-    to_port = is_internal_port(ERTS_TRACER_PROC(p));
-
-    if (!to_port) {
-	ASSERT(is_internal_pid(ERTS_TRACER_PROC(p)));
-
-	ERTS_GET_TRACER_REF(tracer_ref,
-			    ERTS_TRACER_PROC(p),
-			    ERTS_TRACE_FLAGS(p));
-    }
+    if (!is_tracer_proc_enabled(p, locks, &p->common, &tnif, what))
+        return;
 
     if (ERTS_PROC_IS_EXITING(p))
 	curr_func = 0;
@@ -1042,44 +675,16 @@ trace_sched_aux(Process *p, Eterm what, int never_fake_sched)
 	curr_func = p->current != NULL;
     }
 
-    UseTmpHeap(LOCAL_HEAP_SIZE,p);
-
-    if (to_port)
-	hp = local_heap;
-    else {
-	Uint size = 5;
-	if (curr_func)
-	    size += 4;
-	if (sched_no)
-	    size += 1;
-	size += PATCH_TS_SIZE(p);
-	hp = ERTS_ALLOC_SYSMSG_HEAP(size, &bp, &off_heap, tracer_ref);
-    }
-
     if (!curr_func) {
 	tmp = make_small(0);
     } else {
+        hp = HAlloc(p, 4);
 	tmp = TUPLE3(hp,p->current[0],p->current[1],make_small(p->current[2]));
 	hp += 4;
     }
 
-    if (!sched_no) {
-	mess = TUPLE4(hp, am_trace, p->common.id, what, tmp);
-	hp += 5;
-    }
-    else {
-#ifdef ERTS_SMP
-	Eterm sched_id = make_small(p->scheduler_data->no);
-#else
-	Eterm sched_id = make_small(1);
-#endif
-	mess = TUPLE5(hp, am_trace, p->common.id, what, sched_id, tmp);
-	hp += 6;
-    }
-
-    send_to_tracer(p, tracer_ref, mess, &hp, bp, no_fake_sched);
-    UnUseTmpHeap(LOCAL_HEAP_SIZE,p);
-#undef LOCAL_HEAP_SIZE
+    send_to_tracer_nif(p, &p->common, p->common.id, tnif,
+                       what, tmp, THE_NON_VALUE);
 }
 
 /* Send {trace_ts, Pid, What, {Mod, Func, Arity}, Timestamp}
@@ -1089,9 +694,9 @@ trace_sched_aux(Process *p, Eterm what, int never_fake_sched)
  * 'out_exiting', or 'out_exited'.
  */
 void
-trace_sched(Process *p, Eterm what)
+trace_sched(Process *p, ErtsProcLocks locks, Eterm what)
 {
-    trace_sched_aux(p, what, 0);
+    trace_sched_aux(p, locks, what);
 }
 
 /* Send {trace_ts, Pid, Send, Msg, DestPid, Timestamp}
@@ -1102,17 +707,13 @@ trace_sched(Process *p, Eterm what)
 void
 trace_send(Process *p, Eterm to, Eterm msg)
 {
-    Eterm operation;
-    unsigned sz_msg;
-    unsigned sz_to;
-    Eterm* hp;
-    Eterm mess;
-    
+    Eterm operation = am_send;
+    ErtsTracerNif *tnif = NULL;
+
     if (!ARE_TRACE_FLAGS_ON(p, F_TRACE_SEND)) {
 	return;
     }
 
-    operation = am_send;
     if (is_internal_pid(to)) {
 	if (!erts_proc_lookup(to))
 	    goto send_to_non_existing_process;
@@ -1125,117 +726,36 @@ trace_send(Process *p, Eterm to, Eterm msg)
 	operation = am_atom_put(s, sys_strlen(s));
     }
 
-    if (is_internal_port(ERTS_TRACER_PROC(p))) {
-#define LOCAL_HEAP_SIZE (6 + ERTS_TRACE_PATCH_TS_MAX_SIZE)
-	DeclareTmpHeapNoproc(local_heap,LOCAL_HEAP_SIZE);
-	UseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-
-	hp = local_heap;
-	mess = TUPLE5(hp, am_trace, p->common.id, operation, msg, to);
-	hp += 6;
-	erts_smp_mtx_lock(&smq_mtx);
-	PATCH_TS(TFLGS_TS_TYPE(p), mess, hp, NULL, NULL);
-	send_to_port(p, mess, &ERTS_TRACER_PROC(p), &ERTS_TRACE_FLAGS(p));
-	UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-#undef LOCAL_HEAP_SIZE
-	erts_smp_mtx_unlock(&smq_mtx);
-    } else {
-	Uint need;
-	ErlHeapFragment *bp;
-	ErlOffHeap *off_heap;
-	ERTS_TRACER_REF_TYPE tracer_ref;
-
-	ASSERT(is_internal_pid(ERTS_TRACER_PROC(p)));
-
-	ERTS_GET_TRACER_REF(tracer_ref,
-			    ERTS_TRACER_PROC(p),
-			    ERTS_TRACE_FLAGS(p));
-
-	sz_msg = size_object(msg);
-	sz_to  = size_object(to);
-	need = sz_msg + sz_to + 6 + PATCH_TS_SIZE(p);
-	
-	hp = ERTS_ALLOC_SYSMSG_HEAP(need, &bp, &off_heap, tracer_ref);
-
-	to = copy_struct(to,
-			 sz_to,
-			 &hp,
-			 off_heap);
-	msg = copy_struct(msg,
-			  sz_msg,
-			  &hp,
-			  off_heap);
-	mess = TUPLE5(hp, am_trace, p->common.id, operation, msg, to);
-	hp += 6;
-
-	erts_smp_mtx_lock(&smq_mtx);
-
-	PATCH_TS(TFLGS_TS_TYPE(p), mess, hp, bp, tracer_ref);
-	ERTS_ENQ_TRACE_MSG(p->common.id, tracer_ref, mess, bp);
-	erts_smp_mtx_unlock(&smq_mtx);
-    }
+    if (is_tracer_proc_enabled(p, ERTS_PROC_LOCK_MAIN, &p->common, &tnif, operation))
+        send_to_tracer_nif(p, &p->common, p->common.id, tnif, operation, msg, to);
 }
 
 /* Send {trace_ts, Pid, receive, Msg, Timestamp}
  * or   {trace, Pid, receive, Msg}
  */
 void
-trace_receive(Process *rp, Eterm msg)
+trace_receive(Process *c_p, Eterm msg)
 {
-    Eterm mess;
-    size_t sz_msg;
-    Eterm* hp;
-
-    if (is_internal_port(ERTS_TRACER_PROC(rp))) {
-#define LOCAL_HEAP_SIZE (5+ERTS_TRACE_PATCH_TS_MAX_SIZE)
-	DeclareTmpHeapNoproc(local_heap,LOCAL_HEAP_SIZE);
-	UseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-
-	hp = local_heap;
-	mess = TUPLE4(hp, am_trace, rp->common.id, am_receive, msg);
-	hp += 5;
-	erts_smp_mtx_lock(&smq_mtx);
-	PATCH_TS(TFLGS_TS_TYPE(rp), mess, hp, NULL, NULL);
-	send_to_port(rp, mess, &ERTS_TRACER_PROC(rp), &ERTS_TRACE_FLAGS(rp));
-	UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-#undef LOCAL_HEAP_SIZE
-	erts_smp_mtx_unlock(&smq_mtx);
-    } else {
-	Uint hsz;
-	ErlHeapFragment *bp;
-	ErlOffHeap *off_heap;
-	ERTS_TRACER_REF_TYPE tracer_ref;
-
-	ASSERT(is_internal_pid(ERTS_TRACER_PROC(rp)));
-
-	ERTS_GET_TRACER_REF(tracer_ref,
-			    ERTS_TRACER_PROC(rp),
-			    ERTS_TRACE_FLAGS(rp));
-
-	sz_msg = size_object(msg);
-
-	hsz = sz_msg + 5 + PATCH_TS_SIZE(rp);
-
-	hp = ERTS_ALLOC_SYSMSG_HEAP(hsz, &bp, &off_heap, tracer_ref);
-
-	msg = copy_struct(msg, sz_msg, &hp, off_heap);
-	mess = TUPLE4(hp, am_trace, rp->common.id, am_receive, msg);
-	hp += 5;
-
-	erts_smp_mtx_lock(&smq_mtx);
-
-	PATCH_TS(TFLGS_TS_TYPE(rp), mess, hp, bp, tracer_ref);
-	ERTS_ENQ_TRACE_MSG(rp->common.id, tracer_ref, mess, bp);
-	erts_smp_mtx_unlock(&smq_mtx);
-    }
+    ErtsTracerNif *tnif = NULL;
+    if (is_tracer_proc_enabled(NULL, 0, &c_p->common,
+                               &tnif, am_receive))
+        send_to_tracer_nif(NULL, &c_p->common, c_p->common.id,
+                           tnif, am_receive, msg, THE_NON_VALUE);
 }
 
 int
 seq_trace_update_send(Process *p)
 {
-    Eterm seq_tracer = erts_get_system_seq_tracer();
+    ErtsTracer seq_tracer = erts_get_system_seq_tracer();
     ASSERT((is_tuple(SEQ_TRACE_TOKEN(p)) || is_nil(SEQ_TRACE_TOKEN(p))));
-    if ((p->common.id == seq_tracer) || have_no_seqtrace(SEQ_TRACE_TOKEN(p))) {
+    if (have_no_seqtrace(SEQ_TRACE_TOKEN(p)) ||
+        (seq_tracer != NIL &&
+         call_enabled_tracer( NULL, seq_tracer, NULL, am_trace_status,
+                              p ? p->common.id : am_undefined) != am_trace)
+#ifdef USE_VM_PROBES
+	 || (SEQ_TRACE_TOKEN(p) == am_have_dt_utag)
+#endif
+	 ) {
 	return 0;
     }
     SEQ_TRACE_TOKEN_SENDER(p) = p->common.id;
@@ -1263,20 +783,28 @@ seq_trace_output_generic(Eterm token, Eterm msg, Uint type,
 			 Eterm receiver, Process *process, Eterm exitfrom)
 {
     Eterm mess;
-    ErlHeapFragment* bp;
     Eterm* hp;
     Eterm label;
     Eterm lastcnt_serial;
     Eterm type_atom;
-    int sz_exit;
-    Eterm seq_tracer;
-    int ts_type;
+    ErtsTracer seq_tracer;
+    int seq_tracer_flags = 0;
+#define LOCAL_HEAP_SIZE (64)
+    DeclareTmpHeapNoproc(local_heap,LOCAL_HEAP_SIZE);
 
     seq_tracer = erts_get_system_seq_tracer();
 
     ASSERT(is_tuple(token) || is_nil(token));
-    if (SEQ_TRACE_T_SENDER(token) == seq_tracer || token == NIL ||
-	(process && ERTS_TRACE_FLAGS(process) & F_SENSITIVE)) {
+    if (token == NIL || (process && ERTS_TRACE_FLAGS(process) & F_SENSITIVE) ||
+        ERTS_TRACER_IS_NIL(seq_tracer) ||
+        call_enabled_tracer(
+            NULL, seq_tracer, NULL, am_trace_status,
+            process ? process->common.id : am_undefined) != am_trace) {
+	return;
+    }
+
+    if ((unsigned_val(SEQ_TRACE_T_FLAGS(token)) & type) == 0) {
+	/* No flags set, nothing to do */
 	return;
     }
 
@@ -1289,151 +817,29 @@ seq_trace_output_generic(Eterm token, Eterm msg, Uint type,
 	return;			/* To avoid warning */
     }
 
-    if ((unsigned_val(SEQ_TRACE_T_FLAGS(token)) & type) == 0) {
-	/* No flags set, nothing to do */
-	return;
-    }
+    UseTmpHeapNoproc(LOCAL_HEAP_SIZE);
 
-    if (seq_tracer == am_false) {
-	return;			/* no need to send anything */
+    hp = local_heap;
+    label = SEQ_TRACE_T_LABEL(token);
+    lastcnt_serial = TUPLE2(hp, SEQ_TRACE_T_LASTCNT(token),
+                            SEQ_TRACE_T_SERIAL(token));
+    hp += 3;
+    if (exitfrom != NIL) {
+        msg = TUPLE3(hp, am_EXIT, exitfrom, msg);
+        hp += 4;
     }
+    mess = TUPLE5(hp, type_atom, lastcnt_serial, SEQ_TRACE_T_SENDER(token),
+                  receiver, msg);
+    hp += 6;
 
-    ts_type = ERTS_SEQTFLGS2TSTYPE(unsigned_val(SEQ_TRACE_T_FLAGS(token)));
-
-    if (is_internal_port(seq_tracer)) {
-#define LOCAL_HEAP_SIZE (60 + ERTS_TRACE_PATCH_TS_MAX_SIZE)
-	DeclareTmpHeapNoproc(local_heap,LOCAL_HEAP_SIZE);
-	UseTmpHeapNoproc(LOCAL_HEAP_SIZE);
+    seq_tracer_flags |=  ERTS_SEQTFLGS2TFLGS(unsigned_val(SEQ_TRACE_T_FLAGS(token)));
 
-	hp = local_heap;
-	label = SEQ_TRACE_T_LABEL(token);
-	lastcnt_serial = TUPLE2(hp, SEQ_TRACE_T_LASTCNT(token),
-				SEQ_TRACE_T_SERIAL(token));
-	hp += 3;
-	if (exitfrom != NIL) {
-	    msg = TUPLE3(hp, am_EXIT, exitfrom, msg);
-	    hp += 4;
-	}
-	mess = TUPLE5(hp, type_atom, lastcnt_serial, SEQ_TRACE_T_SENDER(token),
-		      receiver, msg);
-	hp += 6;
+    send_to_tracer_nif_raw(NULL, process, seq_tracer, seq_tracer_flags,
+                           label, NULL, am_seq_trace, mess,
+                           THE_NON_VALUE, am_true);
 
-	erts_smp_mtx_lock(&smq_mtx);
-	if (!ts_type) {
-	    mess = TUPLE3(hp, am_seq_trace, label, mess);
-	    seq_trace_send_to_port(NULL, seq_tracer, mess);
-	} else {
-	    mess = TUPLE4(hp, am_seq_trace, label, mess,
-			  NIL /* Will be overwritten by timestamp */);
-	    hp += 5;
-	    hp[-1] = write_ts(ts_type, hp, NULL, NULL);
-	    seq_trace_send_to_port(process, seq_tracer, mess);
-	}
-	UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
+    UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
 #undef LOCAL_HEAP_SIZE
-	erts_smp_mtx_unlock(&smq_mtx);
-    } else {
-#ifndef ERTS_SMP
-	Process* tracer;
-#endif
-	Eterm sender_copy;
-	Eterm receiver_copy;
-	Eterm m2;
-	Uint sz_label, sz_lastcnt_serial, sz_msg, sz_ts, sz_sender,
-	    sz_exitfrom, sz_receiver;
-
-	ASSERT(is_internal_pid(seq_tracer));
-
-#ifndef ERTS_SMP
-
-	tracer = erts_proc_lookup(seq_tracer);
-	if (!tracer) {
-	    system_seq_tracer = am_false;
-	    return; /* no need to send anything */
-	}
-#endif
-	if (receiver == seq_tracer) {
-	    return; /* no need to send anything */
-	}
-
-	sz_label = size_object(SEQ_TRACE_T_LABEL(token));
-	sz_sender = size_object(SEQ_TRACE_T_SENDER(token));
-	sz_receiver = size_object(receiver);
-	sz_lastcnt_serial = 3; /* TUPLE2 */
-	sz_msg = size_object(msg);
-
-	sz_ts = patch_ts_size(ts_type);
-	if (exitfrom != NIL) {
-	    sz_exit = 4; /* create {'EXIT',exitfrom,msg} */
-	    sz_exitfrom = size_object(exitfrom);
-	}
-	else {
-	    sz_exit = 0;
-	    sz_exitfrom = 0;
-	}
-	bp = new_message_buffer(4 /* TUPLE3 */ + sz_ts + 6 /* TUPLE5 */ 
-				+ sz_lastcnt_serial + sz_label + sz_msg
-				+ sz_exit + sz_exitfrom
-				+ sz_sender + sz_receiver);
-	hp = bp->mem;
-	label = copy_struct(SEQ_TRACE_T_LABEL(token), sz_label, &hp, &bp->off_heap);
-	lastcnt_serial = TUPLE2(hp,SEQ_TRACE_T_LASTCNT(token),SEQ_TRACE_T_SERIAL(token));
-	hp += 3;
-	m2 = copy_struct(msg, sz_msg, &hp, &bp->off_heap);
-	if (sz_exit) {
-	    Eterm exitfrom_copy = copy_struct(exitfrom,
-					      sz_exitfrom,
-					      &hp,
-					      &bp->off_heap);
-	    m2 = TUPLE3(hp, am_EXIT, exitfrom_copy, m2);
-	    hp += 4;
-	}
-	sender_copy = copy_struct(SEQ_TRACE_T_SENDER(token),
-				  sz_sender,
-				  &hp,
-				  &bp->off_heap);
-	receiver_copy = copy_struct(receiver,
-				    sz_receiver,
-				    &hp,
-				    &bp->off_heap);
-	mess = TUPLE5(hp,
-		      type_atom,
-		      lastcnt_serial,
-		      sender_copy,
-		      receiver_copy,
-		      m2);
-	hp += 6;
-
-	erts_smp_mtx_lock(&smq_mtx);
-
-	if (!ts_type)
-	    mess = TUPLE3(hp, am_seq_trace, label, mess);
-	else {
-	    mess = TUPLE4(hp, am_seq_trace, label, mess,
-			  NIL /* Will be overwritten by timestamp */);
-	    hp += 5;
-	    /* Write timestamp in element 6 of the 'msg' tuple */
-	    hp[-1] = write_ts(ts_type, hp, bp,
-#ifndef ERTS_SMP
-			      tracer
-#else
-			      NULL
-#endif
-		);
-	}
-
-#ifdef ERTS_SMP
-	enqueue_sys_msg_unlocked(SYS_MSG_TYPE_SEQTRACE, NIL, NIL, mess, bp);
-	erts_smp_mtx_unlock(&smq_mtx);
-#else
-        /* trace_token must be NIL here */
-	{
-	    ErtsMessage *mp = erts_alloc_message(0, NULL);
-	    mp->data.heap_frag = bp;
-	    erts_queue_message(tracer, NULL, mp, mess, NIL);
-	}
-#endif
-    }
 }
 
 /* Send {trace_ts, Pid, return_to, {Mod, Func, Arity}, Timestamp}
@@ -1442,63 +848,19 @@ seq_trace_output_generic(Eterm token, Eterm msg, Uint type,
 void 
 erts_trace_return_to(Process *p, BeamInstr *pc)
 {
-#define LOCAL_HEAP_SIZE (4+5+ERTS_TRACE_PATCH_TS_MAX_SIZE)
-    Eterm* hp;
     Eterm mfa;
-    Eterm mess;
-    DeclareTmpHeapNoproc(local_heap,LOCAL_HEAP_SIZE);
 
     BeamInstr *code_ptr = find_function_from_pc(pc);
 
 
-    UseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-
-    hp = local_heap;
-
     if (!code_ptr) {
 	mfa = am_undefined;
     } else {
+        Eterm *hp = HAlloc(p, 4);
 	mfa = TUPLE3(hp, code_ptr[0], code_ptr[1], make_small(code_ptr[2]));
-	hp += 4;
     }
-	
-    mess = TUPLE4(hp, am_trace, p->common.id, am_return_to, mfa);
-    hp += 5;
-
-    erts_smp_mtx_lock(&smq_mtx);
-
-    PATCH_TS(TFLGS_TS_TYPE(p), mess, hp, NULL, NULL);
 
-    if (is_internal_port(ERTS_TRACER_PROC(p))) {
-	send_to_port(p, mess, &ERTS_TRACER_PROC(p), &ERTS_TRACE_FLAGS(p));
-    } else {
-	ErlHeapFragment *bp;
-	ErlOffHeap *off_heap;
-	ERTS_TRACER_REF_TYPE tracer_ref;
-	unsigned size;
-
-	/*
-	 * Find the tracer.
-	 */
-	ASSERT(is_internal_pid(ERTS_TRACER_PROC(p)));
-
-	ERTS_GET_TRACER_REF(tracer_ref,
-			    ERTS_TRACER_PROC(p),
-			    ERTS_TRACE_FLAGS(p));
-
-	size = size_object(mess);
-
-	hp = ERTS_ALLOC_SYSMSG_HEAP(size, &bp, &off_heap, tracer_ref);
-	
-	/*
-	 * Copy the trace message into the buffer and enqueue it.
-	 */
-	mess = copy_struct(mess, size, &hp, off_heap);
-	ERTS_ENQ_TRACE_MSG(p->common.id, tracer_ref, mess, bp);
-    }
-    UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-#undef LOCAL_HEAP_SIZE
-    erts_smp_mtx_unlock(&smq_mtx);
+    SEND_TO_TRACER(p, am_return_to, mfa);
 }
 
 
@@ -1506,114 +868,53 @@ erts_trace_return_to(Process *p, BeamInstr *pc)
  * or   {trace, Pid, return_from, {Mod, Name, Arity}, Retval}
  */
 void
-erts_trace_return(Process* p, BeamInstr* fi, Eterm retval, Eterm *tracer_pid)
+erts_trace_return(Process* p, BeamInstr* fi, Eterm retval, ErtsTracer *tracer)
 {
     Eterm* hp;
-    Eterm mfa;
-    Eterm mess;
-    Eterm mod, name;
+    Eterm mfa, mod, name;
     int arity;
     Uint meta_flags, *tracee_flags;
-    int ts_type;
-#ifdef ERTS_SMP
-    Eterm tracee;
-#endif
-    
-    ASSERT(tracer_pid);
-    if (*tracer_pid == am_true) {
+
+    ASSERT(tracer);
+    if (ERTS_TRACER_COMPARE(*tracer, erts_tracer_true)) {
 	/* Breakpoint trace enabled without specifying tracer =>
 	 *   use process tracer and flags
 	 */
-	tracer_pid = &ERTS_TRACER_PROC(p);
+	tracer = &ERTS_TRACER(p);
     }
-    if (is_nil(*tracer_pid)) {
+    if (ERTS_TRACER_IS_NIL(*tracer)) {
 	/* Trace disabled */
 	return;
     }
-    ASSERT(is_internal_pid(*tracer_pid) || is_internal_port(*tracer_pid));
-    if (*tracer_pid == p->common.id) {
-	/* Do not generate trace messages to oneself */
-	return;
-    }
-    if (tracer_pid == &ERTS_TRACER_PROC(p)) {
+    ASSERT(IS_TRACER_VALID(*tracer));
+    if (tracer == &ERTS_TRACER(p)) {
 	/* Tracer specified in process structure =>
 	 *   non-breakpoint trace =>
 	 *     use process flags
 	 */
 	tracee_flags = &ERTS_TRACE_FLAGS(p);
-#ifdef ERTS_SMP
-	tracee = p->common.id;
-#endif
+        if (! (*tracee_flags & F_TRACE_CALLS)) {
+            return;
+        }
     } else {
 	/* Tracer not specified in process structure =>
 	 *   tracer specified in breakpoint =>
 	 *     meta trace =>
 	 *       use fixed flag set instead of process flags
-	 */	    
+	 */
 	meta_flags = F_TRACE_CALLS | F_NOW_TS;
 	tracee_flags = &meta_flags;
-#ifdef ERTS_SMP
-	tracee = NIL;
-#endif
     }
-    if (! (*tracee_flags & F_TRACE_CALLS)) {
-	return;
-    }
-    
+
     mod = fi[0];
     name = fi[1];
     arity = fi[2];
-    
-    ts_type = ERTS_TFLGS2TSTYPE(*tracee_flags);
-
-    if (is_internal_port(*tracer_pid)) {
-#define LOCAL_HEAP_SIZE (4+6+ERTS_TRACE_PATCH_TS_MAX_SIZE)
-	DeclareTmpHeapNoproc(local_heap,LOCAL_HEAP_SIZE);
-	UseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-	hp = local_heap;
-	mfa = TUPLE3(hp, mod, name, make_small(arity));
-	hp += 4;
-	mess = TUPLE5(hp, am_trace, p->common.id, am_return_from, mfa, retval);
-	hp += 6;
-	erts_smp_mtx_lock(&smq_mtx);
-	PATCH_TS(ts_type, mess, hp, NULL, NULL);
-	send_to_port(p, mess, tracer_pid, tracee_flags);
-	UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-#undef LOCAL_HEAP_SIZE
-	erts_smp_mtx_unlock(&smq_mtx);
-    } else {
-	ErlHeapFragment *bp;
-	ErlOffHeap *off_heap;
-	ERTS_TRACER_REF_TYPE tracer_ref;
-	unsigned size;
-	unsigned retval_size;
-
-	ASSERT(is_internal_pid(*tracer_pid));
-
-	ERTS_GET_TRACER_REF(tracer_ref, *tracer_pid, *tracee_flags);
-
-	retval_size = size_object(retval);
-	size = 6 + 4 + retval_size + patch_ts_size(ts_type);
-
-	hp = ERTS_ALLOC_SYSMSG_HEAP(size, &bp, &off_heap, tracer_ref);
-
-	/*
-	 * Build the trace tuple and put it into receive queue of the tracer process.
-	 */
-	
-	mfa = TUPLE3(hp, mod, name, make_small(arity));
-	hp += 4;
-	retval = copy_struct(retval, retval_size, &hp, off_heap);
-	mess = TUPLE5(hp, am_trace, p->common.id, am_return_from, mfa, retval);
-	hp += 6;
-
-	erts_smp_mtx_lock(&smq_mtx);
-
-	PATCH_TS(ts_type, mess, hp, bp, tracer_ref);
 
-	ERTS_ENQ_TRACE_MSG(tracee, tracer_ref, mess, bp);
-	erts_smp_mtx_unlock(&smq_mtx);
-    }
+    hp = HAlloc(p, 4);
+    mfa = TUPLE3(hp, mod, name, make_small(arity));
+    hp += 4;
+    send_to_tracer_nif_raw(p, NULL, *tracer, *tracee_flags, p->common.id,
+                           NULL, am_return_from, mfa, retval, am_true);
 }
 
 /* Send {trace_ts, Pid, exception_from, {Mod, Name, Arity}, {Class,Value}, 
@@ -1625,116 +926,50 @@ erts_trace_return(Process* p, BeamInstr* fi, Eterm retval, Eterm *tracer_pid)
  */
 void
 erts_trace_exception(Process* p, BeamInstr mfa[3], Eterm class, Eterm value,
-		     Eterm *tracer_pid)
+		     ErtsTracer *tracer)
 {
     Eterm* hp;
-    Eterm mfa_tuple;
-    Eterm cv;
-    Eterm mess;
+    Eterm mfa_tuple, cv;
     Uint meta_flags, *tracee_flags;
-    int ts_type;
-#ifdef ERTS_SMP
-    Eterm tracee;
-#endif
-    
-    ASSERT(tracer_pid);
-    if (*tracer_pid == am_true) {
+
+    ASSERT(tracer);
+    if (ERTS_TRACER_COMPARE(*tracer, erts_tracer_true)) {
 	/* Breakpoint trace enabled without specifying tracer =>
 	 *   use process tracer and flags
 	 */
-	tracer_pid = &ERTS_TRACER_PROC(p);
+	tracer = &ERTS_TRACER(p);
     }
-    if (is_nil(*tracer_pid)) {
+    if (ERTS_TRACER_IS_NIL(*tracer)) {
 	/* Trace disabled */
 	return;
     }
-    ASSERT(is_internal_pid(*tracer_pid) || is_internal_port(*tracer_pid));
-    if (*tracer_pid == p->common.id) {
-	/* Do not generate trace messages to oneself */
-	return;
-    }
-    if (tracer_pid == &ERTS_TRACER_PROC(p)) {
+    ASSERT(IS_TRACER_VALID(*tracer));
+    if (tracer == &ERTS_TRACER(p)) {
 	/* Tracer specified in process structure =>
 	 *   non-breakpoint trace =>
 	 *     use process flags
 	 */
 	tracee_flags = &ERTS_TRACE_FLAGS(p);
-#ifdef ERTS_SMP
-	tracee = p->common.id;
-#endif
-	if (! (*tracee_flags & F_TRACE_CALLS)) {
-	    return;
-	}
+        if (! (*tracee_flags & F_TRACE_CALLS)) {
+            return;
+        }
     } else {
 	/* Tracer not specified in process structure =>
 	 *   tracer specified in breakpoint =>
 	 *     meta trace =>
 	 *       use fixed flag set instead of process flags
-	 */	    
+	 */
 	meta_flags = F_TRACE_CALLS | F_NOW_TS;
 	tracee_flags = &meta_flags;
-#ifdef ERTS_SMP
-	tracee = NIL;
-#endif
     }
-    
-    ts_type = ERTS_TFLGS2TSTYPE(*tracee_flags);
-
-    if (is_internal_port(*tracer_pid)) {
-#define LOCAL_HEAP_SIZE (4+3+6+ERTS_TRACE_PATCH_TS_MAX_SIZE)
-	DeclareTmpHeapNoproc(local_heap,LOCAL_HEAP_SIZE);
-	UseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-
-	hp = local_heap;
-	mfa_tuple = TUPLE3(hp, (Eterm) mfa[0], (Eterm) mfa[1], make_small((Eterm)mfa[2]));
-	hp += 4;
-	cv = TUPLE2(hp, class, value);
-	hp += 3;
-	mess = TUPLE5(hp, am_trace, p->common.id, am_exception_from, mfa_tuple, cv);
-	hp += 6;
-	ASSERT((hp - local_heap) <= LOCAL_HEAP_SIZE);
-	erts_smp_mtx_lock(&smq_mtx);
-	PATCH_TS(ts_type, mess, hp, NULL, NULL);
-	send_to_port(p, mess, tracer_pid, tracee_flags);
-	UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-#undef LOCAL_HEAP_SIZE
-	erts_smp_mtx_unlock(&smq_mtx);
-    } else {
-	ErlHeapFragment *bp;
-	ErlOffHeap *off_heap;
-	ERTS_TRACER_REF_TYPE tracer_ref;
-	unsigned size;
-	unsigned value_size;
-
-	ASSERT(is_internal_pid(*tracer_pid));
-
-	ERTS_GET_TRACER_REF(tracer_ref, *tracer_pid, *tracee_flags);
-	
-	value_size = size_object(value);
-	size = 6 + 4 + 3 + value_size + patch_ts_size(ts_type);
 
-	hp = ERTS_ALLOC_SYSMSG_HEAP(size, &bp, &off_heap, tracer_ref);
-
-	/*
-	 * Build the trace tuple and put it into receive queue of the tracer process.
-	 */
-	
-	mfa_tuple = TUPLE3(hp, (Eterm) mfa[0], (Eterm) mfa[1], make_small((Eterm) mfa[2]));
-	hp += 4;
-	value = copy_struct(value, value_size, &hp, off_heap);
-	cv = TUPLE2(hp, class, value);
-	hp += 3;
-	mess = TUPLE5(hp, am_trace, p->common.id, 
-		      am_exception_from, mfa_tuple, cv);
-	hp += 6;
-
-	erts_smp_mtx_lock(&smq_mtx);
-
-	PATCH_TS(ts_type, mess, hp, bp, tracer_ref);
-
-	ERTS_ENQ_TRACE_MSG(tracee, tracer_ref, mess, bp);
-	erts_smp_mtx_unlock(&smq_mtx);
-    }
+    hp = HAlloc(p, 7);;
+    mfa_tuple = TUPLE3(hp, (Eterm) mfa[0], (Eterm) mfa[1], make_small((Eterm)mfa[2]));
+    hp += 4;
+    cv = TUPLE2(hp, class, value);
+    hp += 3;
+    send_to_tracer_nif_raw(p, NULL, *tracer, *tracee_flags, p->common.id,
+                           NULL, am_exception_from, mfa_tuple, cv, am_true);
 }
 
 /*
@@ -1753,7 +988,7 @@ erts_trace_exception(Process* p, BeamInstr mfa[3], Eterm class, Eterm value,
  */
 Uint32
 erts_call_trace(Process* p, BeamInstr mfa[3], Binary *match_spec,
-		Eterm* args, int local, Eterm *tracer_pid)
+		Eterm* args, int local, ErtsTracer *tracer)
 {
     Eterm* hp;
     Eterm mfa_tuple;
@@ -1761,55 +996,50 @@ erts_call_trace(Process* p, BeamInstr mfa[3], Binary *match_spec,
     int i;
     Uint32 return_flags;
     Eterm pam_result = am_true;
-    Eterm mess;
     Uint meta_flags, *tracee_flags;
-    int ts_type;
-#ifdef ERTS_SMP
-    Eterm tracee;
-#endif
+    ErtsTracerNif *tnif = NULL;
     Eterm transformed_args[MAX_ARG];
-    DeclareTypedTmpHeap(ErlSubBin,sub_bin_heap,p);
+    ErtsTracer pre_ms_tracer = erts_tracer_nil;
 
-    ASSERT(tracer_pid);
-    if (*tracer_pid == am_true) {
-	/* Breakpoint trace enabled without specifying tracer =>
+    ASSERT(tracer);
+    if (ERTS_TRACER_COMPARE(*tracer, erts_tracer_true)) {
+        /* Breakpoint trace enabled without specifying tracer =>
 	 *   use process tracer and flags
 	 */
-	tracer_pid = &ERTS_TRACER_PROC(p);
-    } 
-    if (is_nil(*tracer_pid)) {
-	/* Trace disabled */
-	return 0;
+        tracer = &ERTS_TRACER(p);
     }
-    ASSERT(is_internal_pid(*tracer_pid) || is_internal_port(*tracer_pid));
-    if (*tracer_pid == p->common.id) {
-	/* Do not generate trace messages to oneself */
+    if (ERTS_TRACER_IS_NIL(*tracer)) {
+	/* Trace disabled */
 	return 0;
     }
-    if (tracer_pid == &ERTS_TRACER_PROC(p)) {
+    ASSERT(IS_TRACER_VALID(*tracer));
+    if (tracer == &ERTS_TRACER(p)) {
 	/* Tracer specified in process structure =>
 	 *   non-breakpoint trace =>
 	 *     use process flags
 	 */
 	tracee_flags = &ERTS_TRACE_FLAGS(p);
-#ifdef ERTS_SMP
-	tracee = p->common.id;
-#endif
+        if (!is_tracer_proc_enabled(p, ERTS_PROC_LOCK_MAIN, &p->common, &tnif, am_call)) {
+            return 0;
+        }
     } else {
 	/* Tracer not specified in process structure =>
 	 *   tracer specified in breakpoint =>
 	 *     meta trace =>
 	 *       use fixed flag set instead of process flags
-	 */	    
-	if (ERTS_TRACE_FLAGS(p) & F_SENSITIVE) {
-	    /* No trace messages for sensitive processes. */
-	    return 0;
-	}
+	 */
+        if (ERTS_TRACE_FLAGS(p) & F_SENSITIVE) {
+            /* No trace messages for sensitive processes. */
+            return 0;
+        }
 	meta_flags = F_TRACE_CALLS | F_NOW_TS;
 	tracee_flags = &meta_flags;
-#ifdef ERTS_SMP
-	tracee = NIL;
-#endif
+        switch (call_enabled_tracer(p, *tracer, &tnif, am_call, p->common.id)) {
+        default:
+        case am_remove: *tracer = erts_tracer_nil;
+        case am_discard: return 0;
+        case am_trace: break;
+        }
     }
 
     /*
@@ -1820,18 +1050,13 @@ erts_call_trace(Process* p, BeamInstr mfa[3], Binary *match_spec,
      * temporarily convert any match contexts to sub binaries.
      */
     arity = (Eterm) mfa[2];
-    UseTmpHeap(ERL_SUB_BIN_SIZE,p);
-#ifdef DEBUG
-    sub_bin_heap->thing_word = 0;
-#endif
     for (i = 0; i < arity; i++) {
 	Eterm arg = args[i];
 	if (is_boxed(arg) && header_is_bin_matchstate(*boxed_val(arg))) {
 	    ErlBinMatchState* ms = (ErlBinMatchState *) boxed_val(arg);
 	    ErlBinMatchBuffer* mb = &ms->mb;
 	    Uint bit_size;
-
-	    ASSERT(sub_bin_heap->thing_word == 0); /* At most one of match context */
+            ErlSubBin *sub_bin_heap = (ErlSubBin *)HAlloc(p, ERL_SUB_BIN_SIZE);
 
 	    bit_size = mb->size - mb->offset;
 	    sub_bin_heap->thing_word = HEADER_SUB_BIN;
@@ -1848,275 +1073,98 @@ erts_call_trace(Process* p, BeamInstr mfa[3], Binary *match_spec,
     }
     args = transformed_args;
 
-    ts_type = ERTS_TFLGS2TSTYPE(*tracee_flags);
-
-    if (is_internal_port(*tracer_pid)) {
-	Eterm local_heap[64+ERTS_TRACE_PATCH_TS_MAX_SIZE+MAX_ARG];
-	hp = local_heap;
+    /*
+     * If there is a PAM program, run it.  Return if it fails.
+     *
+     * Some precedence rules:
+     *
+     * - No proc flags, e.g 'silent' or 'return_to'
+     *   has any effect on meta trace.
+     * - The 'silent' process trace flag silences all call
+     *   related messages, e.g 'call', 'return_to' and 'return_from'.
+     * - The {message,_} PAM function does not affect {return_trace}.
+     * - The {message,false} PAM function shall give the same
+     *   'call' trace message as no PAM match.
+     * - The {message,true} PAM function shall give the same
+     *   'call' trace message as a nonexistent PAM program.
+     */
 
-	if (!erts_is_valid_tracer_port(*tracer_pid)) {
-#ifdef ERTS_SMP
-	    ASSERT(is_nil(tracee) || tracer_pid == &ERTS_TRACER_PROC(p));
-	    if (is_not_nil(tracee))
-		erts_smp_proc_lock(p, ERTS_PROC_LOCKS_ALL_MINOR);
-#endif
-	    *tracee_flags &= ~TRACEE_FLAGS;
-	    *tracer_pid = NIL;
-#ifdef ERTS_SMP
-	    if (is_not_nil(tracee))
-		erts_smp_proc_unlock(p, ERTS_PROC_LOCKS_ALL_MINOR);
-#endif
-	    UnUseTmpHeap(ERL_SUB_BIN_SIZE,p);
-	    return 0;
-	}
-	
-	/*
-	 * If there is a PAM program, run it.  Return if it fails.
-	 *
-	 * Some precedence rules:
-	 * 
-	 * - No proc flags, e.g 'silent' or 'return_to' 
-	 *   has any effect on meta trace.
-	 * - The 'silent' process trace flag silences all call 
-	 *   related messages, e.g 'call', 'return_to' and 'return_from'.
-	 * - The {message,_} PAM function does not affect {return_trace}.
-	 * - The {message,false} PAM function shall give the same
-	 *   'call' trace message as no PAM match.
-	 * - The {message,true} PAM function shall give the same
-	 *   'call' trace message as a nonexistent PAM program.
-	 */
-	
-	/* BEGIN this code should be the same for port and pid trace */
-	return_flags = 0;
-	if (match_spec) {
-	    pam_result = erts_match_set_run(p, match_spec, args, arity,
-					    ERTS_PAM_TMP_RESULT, &return_flags);
-	    if (is_non_value(pam_result)) {
-		erts_match_set_release_result(p);
-		UnUseTmpHeap(ERL_SUB_BIN_SIZE,p);
-		return 0;
-	    }
-	}
-	if (tracee_flags == &meta_flags) {
-	    /* Meta trace */
-	    if (pam_result == am_false) {
-		erts_match_set_release_result(p);
-		UnUseTmpHeap(ERL_SUB_BIN_SIZE,p);
-		return return_flags;
-	    }
-	} else {
-	    /* Non-meta trace */
-	    if (*tracee_flags & F_TRACE_SILENT) { 
-		erts_match_set_release_result(p);
-		UnUseTmpHeap(ERL_SUB_BIN_SIZE,p);
-		return 0;
-	    }
-	    if (pam_result == am_false) {
-		erts_match_set_release_result(p);
-		UnUseTmpHeap(ERL_SUB_BIN_SIZE,p);
-		return return_flags;
-	    }
-	    if (local && (*tracee_flags & F_TRACE_RETURN_TO)) {
-		return_flags |= MATCH_SET_RETURN_TO_TRACE;
-	    }
-	}
-	/* END this code should be the same for port and pid trace */
-	
-	/*
-	 * Build the the {M,F,A} tuple in the local heap. 
-	 * (A is arguments or arity.)
-	 */
-	
-	if (*tracee_flags & F_TRACE_ARITY_ONLY) {
-	    mfa_tuple = make_small(arity);
-	} else {
-	    mfa_tuple = NIL;
-	    for (i = arity-1; i >= 0; i--) {
-		mfa_tuple = CONS(hp, args[i], mfa_tuple);
-		hp += 2;
-	    }
-	}
-	mfa_tuple = TUPLE3(hp, (Eterm) mfa[0], (Eterm) mfa[1], mfa_tuple);
-	hp += 4;
-	
-	/*
-	 * Build the trace tuple and send it to the port.
-	 */
-	
-	mess = TUPLE4(hp, am_trace, p->common.id, am_call, mfa_tuple);
-	hp += 5;
-	if (pam_result != am_true) {
-	    hp[-5] = make_arityval(5);
-	    *hp++ = pam_result;
-	}
-	erts_smp_mtx_lock(&smq_mtx);
-	PATCH_TS(ts_type, mess, hp, NULL, NULL);
-	send_to_port(p, mess, tracer_pid, tracee_flags);
-	erts_smp_mtx_unlock(&smq_mtx);
-	erts_match_set_release_result(p);
-	UnUseTmpHeap(ERL_SUB_BIN_SIZE,p);
-	return *tracer_pid == NIL ? 0 : return_flags;
+    return_flags = 0;
+    if (match_spec) {
+        /* we have to make a copy of the tracer here as the match spec
+           may remove it, and we still want to generate a trace message */
+        erts_tracer_update(&pre_ms_tracer, *tracer);
+        tracer = &pre_ms_tracer;
+        pam_result = erts_match_set_run(p, match_spec, args, arity,
+                                        ERTS_PAM_TMP_RESULT, &return_flags);
+        if (is_non_value(pam_result)) {
+            erts_match_set_release_result(p);
+            UnUseTmpHeap(ERL_SUB_BIN_SIZE,p);
+            ERTS_TRACER_CLEAR(&pre_ms_tracer);
+            return 0;
+        }
+    }
 
+    if (tracee_flags == &meta_flags) {
+        /* Meta trace */
+        if (pam_result == am_false) {
+            erts_match_set_release_result(p);
+            UnUseTmpHeap(ERL_SUB_BIN_SIZE,p);
+            ERTS_TRACER_CLEAR(&pre_ms_tracer);
+            return return_flags;
+        }
     } else {
-	ErlHeapFragment *bp;
-	ErlOffHeap *off_heap;
-	Process *tracer;
-	ERTS_TRACER_REF_TYPE tracer_ref;
-#ifdef ERTS_SMP
-	Eterm tpid;
-#endif
-	unsigned size;
-	unsigned sizes[MAX_ARG];
-	unsigned pam_result_size = 0;
-	int invalid_tracer;
-
-	ASSERT(is_internal_pid(*tracer_pid));
-	
-	tracer = erts_pid2proc(p, ERTS_PROC_LOCK_MAIN,
-			       *tracer_pid, ERTS_PROC_LOCK_STATUS);
-	if (!tracer)
-	    invalid_tracer = 1;
-	else {
-	    invalid_tracer = !(ERTS_TRACE_FLAGS(tracer) & F_TRACER);
-	    erts_smp_proc_unlock(tracer, ERTS_PROC_LOCK_STATUS);
-	}
+        /* Non-meta trace */
+        if (*tracee_flags & F_TRACE_SILENT) {
+            erts_match_set_release_result(p);
+            UnUseTmpHeap(ERL_SUB_BIN_SIZE,p);
+            ERTS_TRACER_CLEAR(&pre_ms_tracer);
+            return 0;
+        }
+        if (pam_result == am_false) {
+            erts_match_set_release_result(p);
+            UnUseTmpHeap(ERL_SUB_BIN_SIZE,p);
+            ERTS_TRACER_CLEAR(&pre_ms_tracer);
+            return return_flags;
+        }
+        if (local && (*tracee_flags & F_TRACE_RETURN_TO)) {
+            return_flags |= MATCH_SET_RETURN_TO_TRACE;
+        }
+    }
 
-	if (invalid_tracer) {
-#ifdef ERTS_SMP
-	    ASSERT(is_nil(tracee)
-		   || tracer_pid == &ERTS_TRACER_PROC(p));
-	    if (is_not_nil(tracee))
-		erts_smp_proc_lock(p, ERTS_PROC_LOCKS_ALL_MINOR);
-#endif
-	    *tracee_flags &= ~TRACEE_FLAGS;
-	    *tracer_pid = NIL;
-#ifdef ERTS_SMP
-	    if (is_not_nil(tracee))
-		erts_smp_proc_unlock(p, ERTS_PROC_LOCKS_ALL_MINOR);
-#endif
-	    UnUseTmpHeap(ERL_SUB_BIN_SIZE,p);
-	    return 0;
-	}
+    ASSERT(!ERTS_TRACER_IS_NIL(*tracer));
 
-#ifdef ERTS_SMP
-	tpid = *tracer_pid; /* Need to save tracer pid,
-			       since *tracer_pid might
-			       be reset by erts_match_set_run() */
-	tracer_ref = tpid;
-#else
-	tracer_ref = tracer;
-#endif
-	
-	/*
-	 * If there is a PAM program, run it.  Return if it fails.
-	 *
-	 * See the rules above in the port trace code.
-	 */
-	
-	/* BEGIN this code should be the same for port and pid trace */
-	return_flags = 0;
-	if (match_spec) {
-	    pam_result = erts_match_set_run(p, match_spec, args, arity,
-					    ERTS_PAM_TMP_RESULT, &return_flags);
-	    if (is_non_value(pam_result)) {
-		erts_match_set_release_result(p);
-		UnUseTmpHeap(ERL_SUB_BIN_SIZE,p);
-		return 0;
-	    }
-	}
-	if (tracee_flags == &meta_flags) {
-	    /* Meta trace */
-	    if (pam_result == am_false) {
-		erts_match_set_release_result(p);
-		UnUseTmpHeap(ERL_SUB_BIN_SIZE,p);
-		return return_flags;
-	    }
-	} else {
-	    /* Non-meta trace */
-	    if (*tracee_flags & F_TRACE_SILENT) { 
-		erts_match_set_release_result(p);
-		UnUseTmpHeap(ERL_SUB_BIN_SIZE,p);
-		return 0;
-	    }
-	    if (pam_result == am_false) {
-		erts_match_set_release_result(p);
-		UnUseTmpHeap(ERL_SUB_BIN_SIZE,p);
-		return return_flags;
-	    }
-	    if (local && (*tracee_flags & F_TRACE_RETURN_TO)) {
-		return_flags |= MATCH_SET_RETURN_TO_TRACE;
-	    }
-	}
-	/* END this code should be the same for port and pid trace */
-	
-	/*
-	 * Calculate number of words needed on heap.
-	 */
-	
-	size = 4 + 5;		/* Trace tuple + MFA tuple. */
-	if (! (*tracee_flags & F_TRACE_ARITY_ONLY)) {
-	    size += 2*arity;
-	    for (i = arity-1; i >= 0; i--) {
-		sizes[i] = size_object(args[i]);
-		size += sizes[i];
-	    }
-	}
-	size += patch_ts_size(ts_type);
-	if (pam_result != am_true) {
-	    pam_result_size = size_object(pam_result);
-	    size += 1 + pam_result_size;
-	    /* One element in trace tuple + term size. */
-	}
-	
-	hp = ERTS_ALLOC_SYSMSG_HEAP(size, &bp, &off_heap, tracer_ref);
+    /*
+     * Build the the {M,F,A} tuple in the local heap.
+     * (A is arguments or arity.)
+     */
 
-	/*
-	 * Build the the {M,F,A} tuple in the message buffer. 
-	 * (A is arguments or arity.)
-	 */
-	
-	if (*tracee_flags & F_TRACE_ARITY_ONLY) {
-	    mfa_tuple = make_small(arity);
-	} else {
-	    mfa_tuple = NIL;
-	    for (i = arity-1; i >= 0; i--) {
-		Eterm term = copy_struct(args[i], sizes[i], &hp, off_heap);
-		mfa_tuple = CONS(hp, term, mfa_tuple);
-		hp += 2;
-	    }
-	}
-	mfa_tuple = TUPLE3(hp, (Eterm) mfa[0], (Eterm) mfa[1], mfa_tuple);
-	hp += 4;
-	
-	/*
-	 * Copy the PAM result (if any) onto the heap.
-	 */
-	
-	if (pam_result != am_true) {
-	    pam_result = copy_struct(pam_result, pam_result_size, &hp, off_heap);
-	}
 
-	erts_match_set_release_result(p);
+    if (*tracee_flags & F_TRACE_ARITY_ONLY) {
+        hp = HAlloc(p, 4);
+        mfa_tuple = make_small(arity);
+    } else {
+        hp = HAlloc(p, 4 + arity * 2);
+        mfa_tuple = NIL;
+        for (i = arity-1; i >= 0; i--) {
+            mfa_tuple = CONS(hp, args[i], mfa_tuple);
+            hp += 2;
+        }
+    }
+    mfa_tuple = TUPLE3(hp, (Eterm) mfa[0], (Eterm) mfa[1], mfa_tuple);
+    hp += 4;
 
-	/*
-	 * Build the trace tuple and enqueue it.
-	 */
-	
-	mess = TUPLE4(hp, am_trace, p->common.id, am_call, mfa_tuple);
-	hp += 5;
-	if (pam_result != am_true) {
-	    hp[-5] = make_arityval(5);
-	    *hp++ = pam_result;
-	}
+    /*
+     * Build the trace tuple and send it to the port.
+     */
+    send_to_tracer_nif_raw(p, NULL, *tracer, *tracee_flags, p->common.id,
+                           tnif, am_call, mfa_tuple, THE_NON_VALUE, pam_result);
+    erts_match_set_release_result(p);
 
-	erts_smp_mtx_lock(&smq_mtx);
+    if (match_spec && tracer == &pre_ms_tracer)
+        ERTS_TRACER_CLEAR(&pre_ms_tracer);
 
-	PATCH_TS(ts_type, mess, hp, bp, tracer_ref);
-	ERTS_ENQ_TRACE_MSG(tracee, tracer_ref, mess, bp);
-	erts_smp_mtx_unlock(&smq_mtx);
-	UnUseTmpHeap(ERL_SUB_BIN_SIZE,p);
-	return return_flags;
-    }
+    return return_flags;
 }
 
 /* Sends trace message:
@@ -2128,69 +1176,13 @@ erts_call_trace(Process* p, BeamInstr mfa[3], Binary *match_spec,
  * 't_p' is the traced process.
  */
 void
-trace_proc(Process *c_p, Process *t_p, Eterm what, Eterm data)
+trace_proc(Process *c_p, ErtsProcLocks c_p_locks,
+           Process *t_p, Eterm what, Eterm data)
 {
-    Eterm mess;
-    Eterm* hp;
-    int need;
-
-    ERTS_SMP_LC_ASSERT((erts_proc_lc_my_proc_locks(t_p) != 0)
-		       || erts_thr_progress_is_blocking());
-    if (is_internal_port(ERTS_TRACER_PROC(t_p))) {
-#define LOCAL_HEAP_SIZE (5+5)
-	DeclareTmpHeapNoproc(local_heap,LOCAL_HEAP_SIZE);
-	UseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-
-
-	hp = local_heap;
-	mess = TUPLE4(hp, am_trace, t_p->common.id, what, data);
-	hp += 5;
-	erts_smp_mtx_lock(&smq_mtx);
-	PATCH_TS(TFLGS_TS_TYPE(t_p), mess, hp, NULL, NULL);
-	send_to_port(
-#ifndef ERTS_SMP
-	    /* No fake schedule out and in again after an exit */
-	    what == am_exit ? NULL : c_p,
-#else
-	    /* Fake schedule out and in are never sent when smp enabled */
-	    c_p,
-#endif
-	    mess,
-	    &ERTS_TRACER_PROC(t_p),
-	    &ERTS_TRACE_FLAGS(t_p));
-	UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-#undef LOCAL_HEAP_SIZE
-	erts_smp_mtx_unlock(&smq_mtx);
-    } else {
-	Eterm tmp;
-	ErlHeapFragment *bp;
-	ErlOffHeap *off_heap;
-	ERTS_TRACER_REF_TYPE tracer_ref;
-	size_t sz_data;
-
-	ASSERT(is_internal_pid(ERTS_TRACER_PROC(t_p)));
-
-	ERTS_GET_TRACER_REF(tracer_ref,
-			    ERTS_TRACER_PROC(t_p),
-			    ERTS_TRACE_FLAGS(t_p));
-
-	sz_data = size_object(data);
-
-	need = sz_data + 5 + PATCH_TS_SIZE(t_p);
-
-	hp = ERTS_ALLOC_SYSMSG_HEAP(need, &bp, &off_heap, tracer_ref);
-
-	tmp = copy_struct(data, sz_data, &hp, off_heap);
-	mess = TUPLE4(hp, am_trace, t_p->common.id, what, tmp);
-	hp += 5;
-
-	erts_smp_mtx_lock(&smq_mtx);
-
-	PATCH_TS(TFLGS_TS_TYPE(t_p), mess, hp, bp, tracer_ref);
-
-	ERTS_ENQ_TRACE_MSG(t_p->common.id, tracer_ref, mess, bp);
-	erts_smp_mtx_unlock(&smq_mtx);
-    }
+    ErtsTracerNif *tnif = NULL;
+    if (is_tracer_proc_enabled(c_p, c_p_locks, &t_p->common, &tnif, what))
+        send_to_tracer_nif(c_p, &t_p->common, t_p->common.id, tnif,
+                           what, data, THE_NON_VALUE);
 }
 
 
@@ -2202,62 +1194,20 @@ trace_proc(Process *c_p, Process *t_p, Eterm what, Eterm data)
  * and 'args' may be a deep term.
  */
 void
-trace_proc_spawn(Process *p, Eterm pid, 
+trace_proc_spawn(Process *p, Eterm pid,
 		 Eterm mod, Eterm func, Eterm args)
 {
-    Eterm mfa;
-    Eterm mess;
-    Eterm* hp;
-
-    if (is_internal_port(ERTS_TRACER_PROC(p))) {
-#define LOCAL_HEAP_SIZE (4+6+5)
-	DeclareTmpHeapNoproc(local_heap,LOCAL_HEAP_SIZE);
-	UseTmpHeapNoproc(LOCAL_HEAP_SIZE);
+    ErtsTracerNif *tnif = NULL;
+    if (is_tracer_proc_enabled(p, ERTS_PROC_LOCKS_ALL &
+                               ~(ERTS_PROC_LOCK_STATUS|ERTS_PROC_LOCK_TRACE),
+                               &p->common, &tnif, am_spawn)) {
+        Eterm mfa;
+        Eterm* hp;
 
-	hp = local_heap;
-	mfa = TUPLE3(hp, mod, func, args);
-	hp += 4;
-	mess = TUPLE5(hp, am_trace, p->common.id, am_spawn, pid, mfa);
-	hp += 6;
-	erts_smp_mtx_lock(&smq_mtx);
-	PATCH_TS(TFLGS_TS_TYPE(p), mess, hp, NULL, NULL);
-	send_to_port(p, mess, &ERTS_TRACER_PROC(p), &ERTS_TRACE_FLAGS(p));
-	UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-#undef LOCAL_HEAP_SIZE
-	erts_smp_mtx_unlock(&smq_mtx);
-    } else {
-	Eterm tmp;
-	ErlHeapFragment *bp;
-	ErlOffHeap *off_heap;
-	ERTS_TRACER_REF_TYPE tracer_ref;
-	size_t sz_args, sz_pid;
-	Uint need;
-
-	ASSERT(is_internal_pid(ERTS_TRACER_PROC(p)));
-
-	ERTS_GET_TRACER_REF(tracer_ref,
-			    ERTS_TRACER_PROC(p),
-			    ERTS_TRACE_FLAGS(p));
-
-	sz_args = size_object(args);
-	sz_pid = size_object(pid);
-	need = sz_args + 4 + 6 + PATCH_TS_SIZE(p);
-
-	hp = ERTS_ALLOC_SYSMSG_HEAP(need, &bp, &off_heap, tracer_ref);
-
-	tmp = copy_struct(args, sz_args, &hp, off_heap);
-	mfa = TUPLE3(hp, mod, func, tmp);
-	hp += 4;
-	tmp = copy_struct(pid, sz_pid, &hp, off_heap);
-	mess = TUPLE5(hp, am_trace, p->common.id, am_spawn, tmp, mfa);
-	hp += 6;
-
-	erts_smp_mtx_lock(&smq_mtx);
-
-	PATCH_TS(TFLGS_TS_TYPE(p), mess, hp, bp, tracer_ref);
-
-	ERTS_ENQ_TRACE_MSG(p->common.id, tracer_ref, mess, bp);
-	erts_smp_mtx_unlock(&smq_mtx);
+        hp = HAlloc(p, 4);
+        mfa = TUPLE3(hp, mod, func, args);
+        hp += 4;
+        send_to_tracer_nif(p, &p->common, p->common.id, tnif, am_spawn, pid, mfa);
     }
 }
 
@@ -2291,66 +1241,22 @@ void save_calls(Process *p, Export *e)
 void
 trace_gc(Process *p, Eterm what)
 {
-    ErlHeapFragment *bp = NULL;
-    ErlOffHeap *off_heap;
-    ERTS_TRACER_REF_TYPE tracer_ref = ERTS_NULL_TRACER_REF;	/* Initialized
-								   to eliminate
-								   compiler
-								   warning */
+    ErtsTracerNif *tnif = NULL;
     Eterm* hp;
     Eterm msg = NIL;
-    Uint size;
-
-#define LOCAL_HEAP_SIZE						\
-    (ERTS_PROCESS_GC_INFO_MAX_SIZE) +                           \
-	5/*4-tuple */ + ERTS_TRACE_PATCH_TS_MAX_SIZE
-    DeclareTmpHeap(local_heap,LOCAL_HEAP_SIZE,p);
+    Uint size = 0;
 
-    UseTmpHeap(LOCAL_HEAP_SIZE,p);
+    if (is_tracer_proc_enabled(
+            p, ERTS_PROC_LOCK_MAIN, &p->common, &tnif, what)) {
 
-    if (is_internal_port(ERTS_TRACER_PROC(p))) {
-	hp = local_heap;
-#ifdef DEBUG
-	size = 0;
         (void) erts_process_gc_info(p, &size, NULL);
+        hp = HAlloc(p, size);
 
-	size += 5/*4-tuple*/ + PATCH_TS_SIZE(p);
-#endif
-    } else {
-	ASSERT(is_internal_pid(ERTS_TRACER_PROC(p)));
-
-	ERTS_GET_TRACER_REF(tracer_ref,
-			    ERTS_TRACER_PROC(p),
-			    ERTS_TRACE_FLAGS(p));
-
-	size = 0;
-        (void) erts_process_gc_info(p, &size, NULL);
+        msg = erts_process_gc_info(p, NULL, &hp);
 
-	size += 5/*4-tuple*/ + PATCH_TS_SIZE(p);
-
-	hp = ERTS_ALLOC_SYSMSG_HEAP(size, &bp, &off_heap, tracer_ref);
+        send_to_tracer_nif(p, &p->common, p->common.id, tnif, what,
+                           msg, THE_NON_VALUE);
     }
-
-    ASSERT(size <= LOCAL_HEAP_SIZE);
-
-    msg = erts_process_gc_info(p, NULL, &hp);
-
-    msg = TUPLE4(hp, am_trace, p->common.id, what, msg);
-    hp += 5;
-
-    erts_smp_mtx_lock(&smq_mtx);
-
-    if (is_internal_port(ERTS_TRACER_PROC(p))) {
-	PATCH_TS(TFLGS_TS_TYPE(p), msg, hp, NULL, NULL);
-	send_to_port(p, msg, &ERTS_TRACER_PROC(p), &ERTS_TRACE_FLAGS(p));
-    }
-    else {
-	PATCH_TS(TFLGS_TS_TYPE(p), msg, hp, bp, tracer_ref);
-	ERTS_ENQ_TRACE_MSG(p->common.id, tracer_ref, msg, bp);
-    }
-    erts_smp_mtx_unlock(&smq_mtx);
-    UnUseTmpHeap(LOCAL_HEAP_SIZE,p);
-#undef LOCAL_HEAP_SIZE
 }
 
 void 
@@ -2412,7 +1318,7 @@ monitor_long_schedule_proc(Process *p, BeamInstr *in_fp, BeamInstr *out_fp, Uint
     {
 	ErtsMessage *mp = erts_alloc_message(0, NULL);
 	mp->data.heap_frag = bp;
-	erts_queue_message(monitor_p, NULL, mp, msg, NIL);
+	erts_queue_message(monitor_p, NULL, mp, msg);
     }
 #endif
 }
@@ -2477,7 +1383,7 @@ monitor_long_schedule_port(Port *pp, ErtsPortTaskType type, Uint time)
     {
 	ErtsMessage *mp = erts_alloc_message(0, NULL);
 	mp->data.heap_frag = bp;
-	erts_queue_message(monitor_p, NULL, mp, msg, NIL);
+	erts_queue_message(monitor_p, NULL, mp, msg);
     }
 #endif
 }
@@ -2552,7 +1458,7 @@ monitor_long_gc(Process *p, Uint time) {
     {
 	ErtsMessage *mp = erts_alloc_message(0, NULL);
 	mp->data.heap_frag = bp;
-	erts_queue_message(monitor_p, NULL, mp, msg, NIL);
+	erts_queue_message(monitor_p, NULL, mp, msg);
     }
 #endif
 }
@@ -2627,7 +1533,7 @@ monitor_large_heap(Process *p) {
     {
 	ErtsMessage *mp = erts_alloc_message(0, NULL);
 	mp->data.heap_frag = bp;
-	erts_queue_message(monitor_p, NULL, mp, msg, NIL);
+	erts_queue_message(monitor_p, NULL, mp, msg);
     }
 #endif
 }
@@ -2659,7 +1565,7 @@ monitor_generic(Process *p, Eterm type, Eterm spec) {
     {
 	ErtsMessage *mp = erts_alloc_message(0, NULL);
 	mp->data.heap_frag = bp;
-	erts_queue_message(monitor_p, NULL, mp, msg, NIL);
+	erts_queue_message(monitor_p, NULL, mp, msg);
     }
 #endif
 
@@ -2756,71 +1662,13 @@ profile_scheduler_q(Eterm scheduler_id, Eterm state, Eterm no_schedulers, Uint M
 
 }
 
-
-/* Send {trace_ts, Pid, What, {Mod, Func, Arity}, Timestamp}
- * or   {trace, Pid, What, {Mod, Func, Arity}}
- *
- * where 'What' is supposed to be 'in' or 'out'.
- *
- * Virtual scheduling do not fake scheduling for ports.
- */
-
-
-void trace_virtual_sched(Process *p, Eterm what)
-{
-    trace_sched_aux(p, what, 1);
-}
-
 /* Port profiling */
 
 void
 trace_port_open(Port *p, Eterm calling_pid, Eterm drv_name) {
-    Eterm mess;
-    Eterm* hp;
-
-    if (is_internal_port(ERTS_TRACER_PROC(p))) {
-#define LOCAL_HEAP_SIZE (6+ERTS_TRACE_PATCH_TS_MAX_SIZE)
-	DeclareTmpHeapNoproc(local_heap,LOCAL_HEAP_SIZE);
-	UseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-
-	hp = local_heap;
-
-	mess = TUPLE5(hp, am_trace, calling_pid, am_open, p->common.id, drv_name);
-	hp += 6;
-	erts_smp_mtx_lock(&smq_mtx);
-	PATCH_TS(TFLGS_TS_TYPE(p), mess, hp, NULL, NULL);
-	/* No fake schedule */
-	send_to_port(NULL, mess, &ERTS_TRACER_PROC(p), &ERTS_TRACE_FLAGS(p));
-	UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-#undef LOCAL_HEAP_SIZE
-	erts_smp_mtx_unlock(&smq_mtx);
-    } else {
-	ErlHeapFragment *bp;
-	ErlOffHeap *off_heap;
-	size_t sz_data;
-	ERTS_TRACER_REF_TYPE tracer_ref;
-	
-	ASSERT(is_internal_pid(ERTS_TRACER_PROC(p)));
-
-	sz_data = 6 + PATCH_TS_SIZE(p);
-
-	ERTS_GET_TRACER_REF(tracer_ref,
-			    ERTS_TRACER_PROC(p),
-			    ERTS_TRACE_FLAGS(p));
-
-	hp = ERTS_ALLOC_SYSMSG_HEAP(sz_data, &bp, &off_heap, tracer_ref);
-
-	mess = TUPLE5(hp, am_trace, calling_pid, am_open, p->common.id, drv_name);
-	hp += 6;
-
-	erts_smp_mtx_lock(&smq_mtx);
-
-	PATCH_TS(TFLGS_TS_TYPE(p), mess, hp, bp, tracer_ref);
-
-	ERTS_ENQ_TRACE_MSG(p->common.id, tracer_ref, mess, bp);
-	erts_smp_mtx_unlock(&smq_mtx);
-    }
 
+    send_to_tracer_nif(NULL, &p->common, calling_pid, NULL, am_open,
+                       p->common.id, drv_name);
 }
 
 /* Sends trace message:
@@ -2832,53 +1680,11 @@ trace_port_open(Port *p, Eterm calling_pid, Eterm drv_name) {
  */
 void
 trace_port(Port *t_p, Eterm what, Eterm data) {
-    Eterm mess;
-    Eterm* hp;
 
     ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(t_p)
 		       || erts_thr_progress_is_blocking());
-
-    if (is_internal_port(ERTS_TRACER_PROC(t_p))) {
-#define LOCAL_HEAP_SIZE (5+ERTS_TRACE_PATCH_TS_MAX_SIZE)
-	DeclareTmpHeapNoproc(local_heap,LOCAL_HEAP_SIZE);
-	UseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-
-	hp = local_heap;
-	mess = TUPLE4(hp, am_trace, t_p->common.id, what, data);
-	hp += 5;
-	erts_smp_mtx_lock(&smq_mtx);
-	PATCH_TS(TFLGS_TS_TYPE(t_p), mess, hp, NULL, NULL);
-	/* No fake schedule */
-	send_to_port(NULL,mess,&ERTS_TRACER_PROC(t_p),&ERTS_TRACE_FLAGS(t_p));
-	UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-#undef LOCAL_HEAP_SIZE
-	erts_smp_mtx_unlock(&smq_mtx);
-    } else {
-	ErlHeapFragment *bp;
-	ErlOffHeap *off_heap;
-	size_t sz_data;
-	ERTS_TRACER_REF_TYPE tracer_ref;
-
-	ASSERT(is_internal_pid(ERTS_TRACER_PROC(t_p)));
-
-	sz_data = 5 + PATCH_TS_SIZE(t_p);
-
-	ERTS_GET_TRACER_REF(tracer_ref,
-			    ERTS_TRACER_PROC(t_p),
-			    ERTS_TRACE_FLAGS(t_p));
-
-	hp = ERTS_ALLOC_SYSMSG_HEAP(sz_data, &bp, &off_heap, tracer_ref);
-
-	mess = TUPLE4(hp, am_trace, t_p->common.id, what, data);
-	hp += 5;
-
-	erts_smp_mtx_lock(&smq_mtx);
-
-	PATCH_TS(TFLGS_TS_TYPE(t_p), mess, hp, bp, tracer_ref);
-
-	ERTS_ENQ_TRACE_MSG(t_p->common.id, tracer_ref, mess, bp);
-	erts_smp_mtx_unlock(&smq_mtx);
-    }
+    send_to_tracer_nif(NULL, &t_p->common, t_p->common.id, NULL,
+                       am_open, data, THE_NON_VALUE);
 }
 
 /* Send {trace_ts, Pid, What, {Mod, Func, Arity}, Timestamp}
@@ -2891,83 +1697,14 @@ trace_port(Port *t_p, Eterm what, Eterm data) {
 
 void
 trace_sched_ports(Port *p, Eterm what) {
-    trace_sched_ports_where(p,what, make_small(0));
+    trace_sched_ports_where(p, what, make_small(0));
 }
 
-void 
-trace_sched_ports_where(Port *p, Eterm what, Eterm where) {
-    Eterm mess;
-    Eterm* hp;
-    int ws = 5;	
-    Eterm sched_id = am_undefined;
-    
-    if (is_internal_port(ERTS_TRACER_PROC(p))) {
-#define LOCAL_HEAP_SIZE (6+ERTS_TRACE_PATCH_TS_MAX_SIZE)
-	DeclareTmpHeapNoproc(local_heap,LOCAL_HEAP_SIZE);
-	UseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-
-	hp = local_heap;
-	
-	if (IS_TRACED_FL(p, F_TRACE_SCHED_NO)) {
-#ifdef ERTS_SMP
-		ErtsSchedulerData *esd = erts_get_scheduler_data();
-		if (esd) sched_id = make_small(esd->no);
-		else sched_id = am_undefined;
-#else
-		sched_id = make_small(1);
-#endif
-		mess = TUPLE5(hp, am_trace, p->common.id, what, sched_id, where);
-		ws = 6;
-	} else {
-		mess = TUPLE4(hp, am_trace, p->common.id, what, where);
-		ws = 5;
-	}
-	hp += ws;
-	
-	erts_smp_mtx_lock(&smq_mtx);
-
-	PATCH_TS(TFLGS_TS_TYPE(p), mess, hp, NULL, NULL);
-	
-	/* No fake scheduling */
-	send_to_port(NULL, mess, &ERTS_TRACER_PROC(p), &ERTS_TRACE_FLAGS(p));
-	UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-#undef LOCAL_HEAP_SIZE
-	erts_smp_mtx_unlock(&smq_mtx);
-    } else  {
-	ErlHeapFragment *bp;
-    	ErlOffHeap *off_heap;
-	ERTS_TRACER_REF_TYPE tracer_ref;
-
-	ASSERT(is_internal_pid(ERTS_TRACER_PROC(p)));
-	
-	if (IS_TRACED_FL(p, F_TRACE_SCHED_NO)) ws = 6; /* Make place for scheduler id */
-
-	ERTS_GET_TRACER_REF(tracer_ref,
-			    ERTS_TRACER_PROC(p),
-			    ERTS_TRACE_FLAGS(p));
-
-	hp = ERTS_ALLOC_SYSMSG_HEAP(ws+PATCH_TS_SIZE(p), &bp, &off_heap, tracer_ref);
-
-	if (IS_TRACED_FL(p, F_TRACE_SCHED_NO)) {
-#ifdef ERTS_SMP
-		ErtsSchedulerData *esd = erts_get_scheduler_data();
-		if (esd) sched_id = make_small(esd->no);
-		else sched_id = am_undefined;
-#else
-		sched_id = make_small(1);
-#endif
-		mess = TUPLE5(hp, am_trace, p->common.id, what, sched_id, where);
-	} else {
-		mess = TUPLE4(hp, am_trace, p->common.id, what, where);
-	}
-	hp += ws;
-
-	erts_smp_mtx_lock(&smq_mtx);
+void
+trace_sched_ports_where(Port *t_p, Eterm what, Eterm where) {
 
-	PATCH_TS(TFLGS_TS_TYPE(p), mess, hp, bp, tracer_ref);
-	ERTS_ENQ_TRACE_MSG(p->common.id, tracer_ref, mess, bp);
-	erts_smp_mtx_unlock(&smq_mtx);
-    }
+    send_to_tracer_nif(NULL, &t_p->common, t_p->common.id,
+                       NULL, am_open, where, THE_NON_VALUE);
 }
 
 /* Port profiling */
@@ -3083,28 +1820,6 @@ profile_runnable_proc(Process *p, Eterm status){
 
 #ifdef ERTS_SMP
 
-void
-erts_check_my_tracer_proc(Process *p)
-{
-    if (is_internal_pid(ERTS_TRACER_PROC(p))) {
-	Process *tracer = erts_pid2proc(p,
-					ERTS_PROC_LOCK_MAIN,
-					ERTS_TRACER_PROC(p),
-					ERTS_PROC_LOCK_STATUS);
-	int invalid_tracer = (!tracer
-			      || !(ERTS_TRACE_FLAGS(tracer) & F_TRACER));
-	if (tracer)
-	    erts_smp_proc_unlock(tracer, ERTS_PROC_LOCK_STATUS);
-	if (invalid_tracer) {
-	    erts_smp_proc_lock(p, ERTS_PROC_LOCKS_ALL_MINOR);
-	    ERTS_TRACE_FLAGS(p) &= ~TRACEE_FLAGS;
-	    ERTS_TRACER_PROC(p) = NIL;
-	    erts_smp_proc_unlock(p, ERTS_PROC_LOCKS_ALL_MINOR);
-	}
-    }
-}
-
-
 typedef struct ErtsSysMsgQ_ ErtsSysMsgQ;
 struct  ErtsSysMsgQ_ {
     ErtsSysMsgQ *next;
@@ -3170,24 +1885,11 @@ erts_queue_error_logger_message(Eterm from, Eterm msg, ErlHeapFragment *bp)
     enqueue_sys_msg(SYS_MSG_TYPE_ERRLGR, from, am_error_logger, msg, bp);
 }
 
-void
-erts_send_sys_msg_proc(Eterm from, Eterm to, Eterm msg, ErlHeapFragment *bp)
-{
-    ASSERT(is_internal_pid(to));
-    enqueue_sys_msg(SYS_MSG_TYPE_PROC_MSG, from, to, msg, bp);
-}
-
 #ifdef DEBUG_PRINTOUTS
 static void
 print_msg_type(ErtsSysMsgQ *smqp)
 {
     switch (smqp->type) {
-    case SYS_MSG_TYPE_TRACE:
-	erts_fprintf(stderr, "TRACE ");
-	break;
-    case SYS_MSG_TYPE_SEQTRACE:
-	erts_fprintf(stderr, "SEQTRACE ");
-	break;
     case SYS_MSG_TYPE_SYSMON:
 	erts_fprintf(stderr, "SYSMON ");
 	break;
@@ -3197,9 +1899,6 @@ print_msg_type(ErtsSysMsgQ *smqp)
     case SYS_MSG_TYPE_ERRLGR:
 	erts_fprintf(stderr, "ERRLGR ");
 	break;
-    case SYS_MSG_TYPE_PROC_MSG:
-	erts_fprintf(stderr, "PROC_MSG ");
-	break;
     default:
 	erts_fprintf(stderr, "??? ");
 	break;
@@ -3211,17 +1910,6 @@ static void
 sys_msg_disp_failure(ErtsSysMsgQ *smqp, Eterm receiver)
 {
     switch (smqp->type) {
-    case SYS_MSG_TYPE_TRACE:
-	/* Invalid tracer_proc's are removed when processes
-	   are scheduled in. */
-	break;
-    case SYS_MSG_TYPE_SEQTRACE:
-	/* Reset seq_tracer if it hasn't changed */
-	erts_smp_rwmtx_rwlock(&sys_trace_rwmtx);
-	if (system_seq_tracer == receiver)
-	    system_seq_tracer = am_false;
-	erts_smp_rwmtx_rwunlock(&sys_trace_rwmtx);
-	break;
     case SYS_MSG_TYPE_SYSMON:
 	if (receiver == NIL
 	    && !erts_system_monitor_long_gc
@@ -3281,8 +1969,6 @@ sys_msg_disp_failure(ErtsSysMsgQ *smqp, Eterm receiver)
 		     no_elgger, tag, CAR(list_val(tp[3])));
 	break;
     }
-    case SYS_MSG_TYPE_PROC_MSG:
-	break;
     default:
 	ASSERT(0);
     }
@@ -3400,13 +2086,6 @@ sys_msg_dispatcher_func(void *unused)
 	    print_msg_type(smqp);
 #endif
 	    switch (smqp->type) {
-	    case SYS_MSG_TYPE_TRACE:
-	    case SYS_MSG_TYPE_PROC_MSG:
-		receiver = smqp->to;
-		break;
-	    case SYS_MSG_TYPE_SEQTRACE:
-		receiver = erts_get_system_seq_tracer();
-		break;
 	    case SYS_MSG_TYPE_SYSMON:
 		receiver = erts_get_system_monitor();
 		if (smqp->from == receiver) {
@@ -3441,16 +2120,8 @@ sys_msg_dispatcher_func(void *unused)
 
 	    if (is_internal_pid(receiver)) {
 		proc = erts_pid2proc(NULL, 0, receiver, proc_locks);
-		if (!proc
-		    || (smqp->type == SYS_MSG_TYPE_TRACE
-			&& !(ERTS_TRACE_FLAGS(proc) & F_TRACER))) {
+		if (!proc) {
 		    /* Bad tracer */
-#ifdef DEBUG_PRINTOUTS
-		    if (smqp->type == SYS_MSG_TYPE_TRACE && proc)
-			erts_fprintf(stderr,
-				     "<tracer alive but missing  "
-				     "F_TRACER flag> ");
-#endif
 		    goto failure;
 		}
 		else {
@@ -3458,7 +2129,7 @@ sys_msg_dispatcher_func(void *unused)
 		queue_proc_msg:
 		    mp = erts_alloc_message(0, NULL);
 		    mp->data.heap_frag = smqp->bp;
-		    erts_queue_message(proc,&proc_locks,mp,smqp->msg,NIL);
+		    erts_queue_message(proc,&proc_locks,mp,smqp->msg);
 #ifdef DEBUG_PRINTOUTS
 		    erts_fprintf(stderr, "delivered\n");
 #endif
@@ -3524,12 +2195,6 @@ erts_foreach_sys_msg_in_q(void (*func)(Eterm,
     for (sm = sys_message_queue; sm; sm = sm->next) {
 	Eterm to;
 	switch (sm->type) {
-	case SYS_MSG_TYPE_TRACE:
-	    to = sm->to;
-	    break;
-	case SYS_MSG_TYPE_SEQTRACE:
-	    to = erts_get_system_seq_tracer();
-	    break;
 	case SYS_MSG_TYPE_SYSMON:
 	    to = erts_get_system_monitor();
 	    break;
@@ -3567,3 +2232,498 @@ init_sys_msg_dispatcher(void)
 }
 
 #endif
+
+#include "erl_nif.h"
+
+struct ErtsTracerNif_ {
+    HashBucket hb;
+    Eterm module;
+    struct erl_module_nif* nif_mod;
+    ErlNifFunc *enabled;
+    ErlNifFunc *trace;
+};
+
+static Hash *tracer_hash = NULL;
+static erts_smp_rwmtx_t tracer_mtx;
+
+static ErtsTracerNif *
+load_tracer_nif(const ErtsTracer tracer)
+{
+    Module* mod = erts_get_module(ERTS_TRACER_MODULE(tracer),
+                                  erts_active_code_ix());
+    struct erl_module_instance *instance;
+    ErlNifFunc *funcs;
+    int num_of_funcs;
+    ErtsTracerNif tnif_tmpl, *tnif;
+    int i;
+
+    if (mod && mod->curr.nif != NULL) {
+        instance = &mod->curr;
+    } else {
+        return NULL;
+    }
+
+    tnif_tmpl.enabled = NULL;
+    tnif_tmpl.trace = NULL;
+    tnif_tmpl.nif_mod = instance->nif;
+    tnif_tmpl.module = ERTS_TRACER_MODULE(tracer);
+
+    num_of_funcs = erts_nif_get_funcs(instance->nif, &funcs);
+
+    for(i = 0; i < num_of_funcs; i++) {
+        if (strcmp("enabled",funcs[i].name) == 0 && funcs[i].arity == 3) {
+            tnif_tmpl.enabled = funcs + i;
+        } else if (strcmp("trace",funcs[i].name) == 0 && funcs[i].arity == 6) {
+            tnif_tmpl.trace = funcs + i;
+        }
+    }
+
+    if (tnif_tmpl.enabled == NULL ||
+        tnif_tmpl.trace   == NULL ) {
+        return NULL;
+    }
+
+    erts_smp_rwmtx_rwlock(&tracer_mtx);
+    tnif = hash_put(tracer_hash, &tnif_tmpl);
+    erts_smp_rwmtx_rwunlock(&tracer_mtx);
+
+    return tnif;
+}
+
+static ERTS_INLINE ErtsTracerNif *
+lookup_tracer_nif(const ErtsTracer tracer)
+{
+    ErtsTracerNif tnif_tmpl;
+    ErtsTracerNif *tnif;
+    tnif_tmpl.module = ERTS_TRACER_MODULE(tracer);
+    erts_smp_rwmtx_rlock(&tracer_mtx);
+    if ((tnif = hash_get(tracer_hash, &tnif_tmpl)) == NULL) {
+        erts_smp_rwmtx_runlock(&tracer_mtx);
+        tnif = load_tracer_nif(tracer);
+        ASSERT(!tnif || tnif->nif_mod);
+        return tnif;
+    }
+    erts_smp_rwmtx_runlock(&tracer_mtx);
+    ASSERT(tnif->nif_mod);
+    return tnif;
+}
+
+/* This function converts an Erlang tracer term to ErtsTracer.
+   It returns THE_NON_VALUE if an invalid tracer term was given.
+   Accepted input is:
+     pid() || port() || {prefix, pid()} || {prefix, port()} ||
+     {prefix, atom(), term()} || {atom(), term()}
+ */
+ErtsTracer
+erts_term_to_tracer(Eterm prefix, Eterm t)
+{
+    ErtsTracer tracer = erts_tracer_nil;
+    ASSERT(is_atom(prefix) || prefix == THE_NON_VALUE);
+    if (!is_nil(t)) {
+        Eterm module = am_erl_tracer, state = THE_NON_VALUE;
+        Eterm hp[2];
+        if (is_tuple(t)) {
+            Eterm *tp = tuple_val(t);
+            if (prefix != THE_NON_VALUE) {
+                if (arityval(tp[0]) == 2 && tp[1] == prefix)
+                    t = tp[2];
+                else if (arityval(tp[0]) == 3 && tp[1] == prefix && is_atom(tp[2])) {
+                    module = tp[2];
+                    state = tp[3];
+                }
+            } else {
+                if (arityval(tp[0]) == 2 && is_atom(tp[2])) {
+                    module = tp[1];
+                    state = tp[2];
+                }
+            }
+        }
+        if (state == THE_NON_VALUE && (is_internal_pid(t) || is_internal_port(t)))
+            state = t;
+        if (state == THE_NON_VALUE)
+            return THE_NON_VALUE;
+        erts_tracer_update(&tracer, CONS(hp, module, state));
+    }
+    if (!lookup_tracer_nif(tracer)) {
+        ASSERT(ERTS_TRACER_MODULE(tracer) != am_erl_tracer);
+        ERTS_TRACER_CLEAR(&tracer);
+        return THE_NON_VALUE;
+    }
+    return tracer;
+}
+
+Eterm
+erts_tracer_to_term(Process *p, ErtsTracer tracer)
+{
+    if (ERTS_TRACER_IS_NIL(tracer))
+        return am_false;
+    if (ERTS_TRACER_MODULE(tracer) == am_erl_tracer)
+        /* Have to manage these specifically in order to be
+           backwards compatible */
+        return ERTS_TRACER_STATE(tracer);
+    else {
+        Eterm *hp = HAlloc(p, 3);
+        return TUPLE2(hp, ERTS_TRACER_MODULE(tracer),
+                      copy_object(ERTS_TRACER_STATE(tracer), p));
+    }
+}
+
+
+static ERTS_INLINE int
+send_to_tracer_nif_raw(Process *c_p, Process *tracee,
+                       const ErtsTracer tracer, Uint tracee_flags,
+                       Eterm t_p_id, ErtsTracerNif *tnif, Eterm tag, Eterm msg,
+                       Eterm extra, Eterm pam_result)
+{
+    if (tnif || (tnif = lookup_tracer_nif(tracer)) != NULL) {
+#define MAP_SIZE 3
+        Eterm argv[6],
+            local_heap[3+MAP_SIZE /* values */+(MAP_SIZE+1 /* keys */)];
+        flatmap_t *map = (flatmap_t*)(local_heap+(MAP_SIZE+1));
+        Eterm *map_values = flatmap_get_values(map);
+
+        int argc = 6;
+
+        argv[0] = tag;
+        argv[1] = ERTS_TRACER_STATE(tracer);
+        argv[2] = t_p_id;
+        argv[3] = msg;
+        argv[4] = extra == THE_NON_VALUE ? am_undefined : extra;
+        argv[5] = make_flatmap(map);
+
+        map->thing_word = MAP_HEADER_FLATMAP;
+        map->size = MAP_SIZE;
+        map->keys = TUPLE3(local_heap, am_match_spec_result, am_scheduler_id,
+                           am_timestamp);
+
+        *map_values++ = pam_result;
+        if (tracee_flags & F_TRACE_SCHED_NO)
+            *map_values++ = make_small(erts_get_scheduler_id());
+        else
+            *map_values++ = am_undefined;
+        if (tracee_flags & F_NOW_TS)
+#ifdef HAVE_ERTS_NOW_CPU
+            if (erts_cpu_timestamp)
+                *map_values++ = am_cpu_timestamp;
+            else
+#endif
+                *map_values++ = am_timestamp;
+        else if (tracee_flags & F_STRICT_MON_TS)
+            *map_values++ = am_strict_monotonic;
+        else if (tracee_flags & F_MON_TS)
+            *map_values++ = am_monotonic;
+        else
+            *map_values++ = am_undefined;
+
+#undef MAP_SIZE
+        erts_nif_call_function(c_p, tracee ? tracee : c_p,
+                               tnif->nif_mod, tnif->trace, argc, argv);
+    }
+    return 1;
+}
+
+
+static ERTS_INLINE int
+send_to_tracer_nif(Process *c_p, ErtsPTabElementCommon *t_p,
+                   Eterm t_p_id, ErtsTracerNif *tnif, Eterm tag,
+                   Eterm msg, Eterm extra)
+{
+#if defined(ERTS_SMP) && defined(ERTS_ENABLE_LOCK_CHECK)
+    if (c_p) {
+        /* We have to hold the main lock of the currently executing process */
+        erts_proc_lc_chk_have_proc_locks(c_p, ERTS_PROC_LOCK_MAIN);
+    }
+    if (is_internal_pid(t_p->id)) {
+        /* We have to have at least one lock */
+        ERTS_SMP_LC_ASSERT(erts_proc_lc_my_proc_locks((Process*)t_p) & ERTS_PROC_LOCKS_ALL);
+    } else {
+        ASSERT(is_internal_port(t_p->id));
+        ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked((Port*)t_p));
+    }
+#endif
+
+    return send_to_tracer_nif_raw(c_p,
+                                  is_internal_pid(t_p->id) ? (Process*)t_p : NULL,
+                                  t_p->tracer, t_p->trace_flags,
+                                  t_p_id, tnif, tag, msg, extra,
+                                  am_true);
+}
+
+static ERTS_INLINE Eterm
+call_enabled_tracer(Process *c_p, const ErtsTracer tracer,
+                    ErtsTracerNif **tnif_ret, Eterm tag, Eterm t_p_id)
+{
+    ErtsTracerNif *tnif = lookup_tracer_nif(tracer);
+    if (tnif) {
+        Eterm argv[] = {tag, ERTS_TRACER_STATE(tracer), t_p_id};
+        if (tnif_ret) *tnif_ret = tnif;
+        return erts_nif_call_function(
+            c_p, NULL, tnif->nif_mod, tnif->enabled, 3, argv);
+    }
+    return am_remove;
+}
+
+static int
+is_tracer_proc_enabled(Process* c_p, ErtsProcLocks c_p_locks,
+                       ErtsPTabElementCommon *t_p,
+                       ErtsTracerNif **tnif_ret, Eterm tag)
+{
+    Eterm nif_result;
+
+#if defined(ERTS_SMP) && defined(ERTS_ENABLE_LOCK_CHECK)
+    if (c_p)
+        ERTS_SMP_LC_ASSERT(erts_proc_lc_my_proc_locks(c_p) == c_p_locks
+                           || erts_thr_progress_is_blocking());
+    if (is_internal_pid(t_p->id)) {
+        /* We have to have at least one lock */
+        ERTS_SMP_LC_ASSERT(erts_proc_lc_my_proc_locks((Process*)t_p) & ERTS_PROC_LOCKS_ALL
+                           || erts_thr_progress_is_blocking());
+    } else {
+        ASSERT(is_internal_port(t_p->id));
+        ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked((Port*)t_p)
+                           || erts_thr_progress_is_blocking());
+    }
+#endif
+
+    nif_result = call_enabled_tracer(c_p, t_p->tracer, tnif_ret, tag, t_p->id);
+    switch (nif_result) {
+    case am_discard: return 0;
+    case am_trace: return 1;
+    case THE_NON_VALUE:
+    case am_remove: break;
+    default:
+        /* only am_remove should be returned, but if
+           something else is returned we fall-through
+           and remove the tracer. */
+        ASSERT(0);
+    }
+
+    /* Only remove tracer on self() and ports */
+    if (is_internal_port(t_p->id) || (c_p && c_p->common.id == t_p->id)) {
+        ErtsProcLocks c_p_xlocks = 0;
+        if (is_internal_pid(t_p->id)) {
+            ERTS_SMP_LC_ASSERT(erts_proc_lc_my_proc_locks(c_p) & ERTS_PROC_LOCK_MAIN);
+            if (c_p_locks != ERTS_PROC_LOCKS_ALL) {
+                c_p_xlocks = ~c_p_locks & ERTS_PROC_LOCKS_ALL;
+                if (erts_smp_proc_trylock(c_p, c_p_xlocks) == EBUSY) {
+                    erts_smp_proc_unlock(c_p, c_p_locks & ~ERTS_PROC_LOCK_MAIN);
+                    erts_smp_proc_lock(c_p, ERTS_PROC_LOCKS_ALL_MINOR);
+                }
+            }
+        }
+        erts_tracer_replace(t_p, erts_tracer_nil);
+        t_p->trace_flags &= ~TRACEE_FLAGS;
+
+        if (c_p_xlocks)
+            erts_smp_proc_unlock(c_p, c_p_xlocks);
+    }
+
+
+    return 0;
+}
+
+int erts_is_tracer_proc_enabled(Process* c_p, ErtsProcLocks c_p_locks,
+                                ErtsPTabElementCommon *t_p)
+{
+    return is_tracer_proc_enabled(c_p, c_p_locks, t_p, NULL, am_trace_status);
+}
+
+int erts_is_tracer_enabled(Process *c_p, const ErtsTracer tracer)
+{
+    ErtsTracerNif *tnif = lookup_tracer_nif(tracer);
+    if (tnif) {
+        Eterm nif_result = call_enabled_tracer(c_p, tracer, &tnif,
+                                               am_trace_status,
+                                               c_p->common.id);
+        switch (nif_result) {
+        case am_discard:
+        case am_trace: return 1;
+        default:
+            break;
+        }
+    }
+    return 0;
+}
+
+void erts_tracer_replace(ErtsPTabElementCommon *t_p, const ErtsTracer tracer)
+{
+#if defined(ERTS_SMP) && defined(ERTS_ENABLE_LOCK_CHECK)
+    if (is_internal_pid(t_p->id) && !erts_thr_progress_is_blocking()) {
+        erts_proc_lc_chk_have_proc_locks((Process*)t_p, ERTS_PROC_LOCKS_ALL);
+    } else if (is_internal_port(t_p->id)) {
+        ERTS_LC_ASSERT(erts_lc_is_port_locked((Port*)t_p)
+                       || erts_thr_progress_is_blocking());
+    }
+#endif
+    if (ERTS_TRACER_COMPARE(t_p->tracer, tracer))
+        return;
+
+    erts_tracer_update(&t_p->tracer, tracer);
+}
+
+static void free_tracer(void *p)
+{
+    ErtsTracer tracer = (ErtsTracer)p;
+
+    if (is_immed(ERTS_TRACER_STATE(tracer))) {
+        erts_free(ERTS_ALC_T_HEAP_FRAG, ptr_val(tracer));
+    } else {
+        ErlHeapFragment *hf = (void*)((char*)(ptr_val(tracer)) - offsetof(ErlHeapFragment, mem));
+        free_message_buffer(hf);
+    }
+}
+
+/* un-define erts_tracer_update before implementation */
+#ifdef erts_tracer_update
+#undef erts_tracer_update
+#endif
+
+/*
+ * ErtsTracer is either NIL, 'true' or [Mod | State]
+ *
+ * - If State is immediate then the memory for
+ *   the cons cell is just two words + sizeof(ErtsThrPrgrLaterOp) large.
+ * - If State is a complex term then the cons cell
+ *   is allocated in an ErlHeapFragment where the cons
+ *   ptr points to the mem field. So in order to get the
+ *   ptr to the fragment you do this:
+ *   (char*)(ptr_val(tracer)) - offsetof(ErlHeapFragment, mem)
+ *   Normally you shouldn't have to care about this though
+ *   as erts_tracer_update takes care of it for you.
+ *
+ *   When ErtsTracer is stored in the stack as part of a
+ *   return trace, the cons cell is stored on the heap of
+ *   the process.
+ *
+ *   The cons cell is not always stored on the heap as:
+ *     1) for port/meta tracing there is no heap
+ *     2) we would need the main lock in order to
+ *        read the tracer which is undesirable.
+ *
+ * One way to optimize this (memory wise) is to keep an refc and only bump
+ * the refc when *tracer is NIL.
+ */
+void
+erts_tracer_update(ErtsTracer *tracer, const ErtsTracer new_tracer)
+{
+    ErlHeapFragment *hf;
+
+    if (is_not_nil(*tracer)) {
+        Uint offs = 2;
+        UWord size = 2 * sizeof(Eterm) + sizeof(ErtsThrPrgrLaterOp);
+        ASSERT(is_list(*tracer));
+        if (is_not_immed(ERTS_TRACER_STATE(*tracer))) {
+            hf = (void*)(((char*)(ptr_val(*tracer)) - offsetof(ErlHeapFragment, mem)));
+            offs = hf->used_size;
+            size = hf->alloc_size * sizeof(Eterm) + sizeof(ErlHeapFragment);
+            ASSERT(offs == size_object(*tracer));
+        }
+        /* We schedule the free:ing of the tracer until after a thread progress
+           has been made so that we know that no schedulers have any references
+           to it. Because we do this, it is possible to release all locks of a
+           process/port and still use the ErtsTracer of that port/process
+           without having to worry if it is free'd.
+        */
+        erts_schedule_thr_prgr_later_cleanup_op(
+            free_tracer, (void*)(*tracer),
+            (ErtsThrPrgrLaterOp*)(ptr_val(*tracer) + offs),
+            size);
+    }
+
+    if (is_nil(new_tracer)) {
+        *tracer = new_tracer;
+    } else if (is_immed(ERTS_TRACER_STATE(new_tracer))) {
+        /* If tracer state is an immediate we only allocate a 2 Eterm heap.
+           Not sure if it is worth it, we save 4 words (sizeof(ErlHeapFragment))
+           per tracer. */
+        Eterm *hp = erts_alloc(ERTS_ALC_T_HEAP_FRAG,
+                               2*sizeof(Eterm) + sizeof(ErtsThrPrgrLaterOp));
+        *tracer = CONS(hp, ERTS_TRACER_MODULE(new_tracer),
+                       ERTS_TRACER_STATE(new_tracer));
+    } else {
+        Eterm *hp, tracer_state = ERTS_TRACER_STATE(new_tracer),
+            tracer_module = ERTS_TRACER_MODULE(new_tracer);
+        Uint sz = size_object(tracer_state);
+        hf = new_message_buffer(sz + 2  /* cons cell */ + (sizeof(ErtsThrPrgrLaterOp)+sizeof(Eterm)-1)/sizeof(Eterm));
+        hp = hf->mem + 2;
+        hf->used_size -= (sizeof(ErtsThrPrgrLaterOp)+sizeof(Eterm)-1)/sizeof(Eterm);
+        *tracer = copy_struct(tracer_state, sz, &hp, &hf->off_heap);
+        *tracer = CONS(hf->mem, tracer_module, *tracer);
+        ASSERT((void*)(((char*)(ptr_val(*tracer)) - offsetof(ErlHeapFragment, mem))) == hf);
+    }
+}
+
+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_tracer_nif_clear();
+
+}
+
+int erts_tracer_nif_clear()
+{
+
+    erts_smp_rwmtx_rlock(&tracer_mtx);
+    if (!tracer_hash || tracer_hash->nobjs) {
+
+        HashFunctions hf;
+        hf.hash = tracer_hash_fun;
+        hf.cmp = tracer_cmp_fun;
+        hf.alloc = tracer_alloc_fun;
+        hf.free = tracer_free_fun;
+        hf.meta_alloc = (HMALLOC_FUN) erts_alloc;
+        hf.meta_free = (HMFREE_FUN) erts_free;
+        hf.meta_print = (HMPRINT_FUN) erts_print;
+
+        erts_smp_rwmtx_runlock(&tracer_mtx);
+        erts_smp_rwmtx_rwlock(&tracer_mtx);
+
+        if (tracer_hash)
+            hash_delete(tracer_hash);
+
+        tracer_hash = hash_new(ERTS_ALC_T_TRACER_NIF, "tracer_hash", 10, hf);
+
+        erts_smp_rwmtx_rwunlock(&tracer_mtx);
+        return 1;
+    }
+
+    erts_smp_rwmtx_runlock(&tracer_mtx);
+    return 0;
+}
+
+static int tracer_cmp_fun(void* a, void* b)
+{
+    return ((ErtsTracerNif*)a)->module != ((ErtsTracerNif*)b)->module;
+}
+
+static HashValue tracer_hash_fun(void* obj)
+{
+    return make_internal_hash(((ErtsTracerNif*)obj)->module);
+}
+
+static void *tracer_alloc_fun(void* tmpl)
+{
+    ErtsTracerNif *obj = erts_alloc(ERTS_ALC_T_TRACER_NIF,
+                                    sizeof(ErtsTracerNif) +
+                                    sizeof(ErtsThrPrgrLaterOp));
+    memcpy(obj, tmpl, sizeof(*obj));
+    return obj;
+}
+
+static void tracer_free_fun_cb(void* obj)
+{
+    erts_free(ERTS_ALC_T_TRACER_NIF, obj);
+}
+
+static void tracer_free_fun(void* obj)
+{
+    ErtsTracerNif *tnif = obj;
+    erts_schedule_thr_prgr_later_op(
+        tracer_free_fun_cb, obj,
+        (ErtsThrPrgrLaterOp*)(tnif + 1));
+
+}