Merge branch 'egil/erts/tracing-support-lttng/OTP-13532'

* egil/erts/tracing-support-lttng/OTP-13532: (28 commits)
  runtime_tools: User's guide to LTTng and dyntrace
  runtime_tools: Fix Dtrace build
  erts: Fix gc messages in tracer_SUITE
  erts: Fix gc messages in sensitive_SUITE
  erts: Fix gc messages in trace_port_SUITE
  tools: Update fprof tests
  tools: Update fprof with new gc traces
  runtime_tools: Update dyntrace_lttng_SUITE tests
  runtime_tools: Add 'return_to' for call tracing
  erts: Fix return_to trace callback
  erts: Update erl_tracer documentation
  erts: Fix erl_tracer documentation typos
  Update preloaded erl_tracer.beam
  erts: Update erl_tracer type specs
  runtime_tools: Add lttng dyntrace tests
  runtime_tools: Extend 'trace' and 'enabled' tracer callbacks
  erts: Extend 'enabled' and 'trace' tracer callbacks
  runtime_tools: Extend 'enabled' tracer callbacks
  erts: Extend 'enabled' tracer callbacks
  runtime_tools: Update lttng garbage collection trace
  ...

23 files changed, 2374 insertions, 156 deletions

diff --git a/erts/doc/src/erl_tracer.xml b/erts/doc/src/erl_tracer.xml
index 1e8e78b25f..2075b962d8 100644
--- a/erts/doc/src/erl_tracer.xml
+++ b/erts/doc/src/erl_tracer.xml
@@ -54,6 +54,14 @@
   </description>
 
   <datatypes>
+      <datatype> <name name="trace_tag_send" /> </datatype>
+      <datatype> <name name="trace_tag_receive" /> </datatype>
+      <datatype> <name name="trace_tag_call" /> </datatype>
+      <datatype> <name name="trace_tag_procs" /> </datatype>
+      <datatype> <name name="trace_tag_ports" /> </datatype>
+      <datatype> <name name="trace_tag_running_procs" /> </datatype>
+      <datatype> <name name="trace_tag_running_ports" /> </datatype>
+      <datatype> <name name="trace_tag_gc" /> </datatype>
     <datatype>
       <name name="trace_tag" />
       <desc>
@@ -105,6 +113,29 @@
     <title>CALLBACK FUNCTIONS</title>
     <p>The following functions
       should be exported from a <c>erl_tracer</c> callback module.</p>
+   <taglist>
+       <tag><seealso marker="#enabled"><c>Module:enabled/3</c></seealso></tag>
+       <item>Mandatory</item>
+       <tag><seealso marker="#trace"><c>Module:trace/6</c></seealso></tag>
+       <item>Mandatory</item>
+       <tag><seealso marker="#enabled_procs"><c>Module:enabled_procs/3</c></seealso></tag>
+       <item>Optional</item>
+       <tag><seealso marker="#trace_procs"><c>Module:trace_procs/6</c></seealso></tag>
+       <item>Optional</item>
+       <tag><seealso marker="#enabled_ports"><c>Module:enabled_ports/3</c></seealso></tag>
+       <item>Optional</item>
+       <tag><seealso marker="#trace_ports"><c>Module:trace_ports/6</c></seealso></tag>
+       <item>Optional</item>
+       <tag><seealso marker="#enabled_running_ports"><c>Module:enabled_running_ports/3</c></seealso></tag>
+       <item>Optional</item>
+       <tag><seealso marker="#trace_running_ports"><c>Module:trace_running_ports/6</c></seealso></tag>
+       <item>Optional</item>
+       <tag><seealso marker="#enabled_running_procs"><c>Module:enabled_running_procs/3</c></seealso></tag>
+       <item>Optional</item>
+       <tag><seealso marker="#trace_running_procs"><c>Module:trace_running_procs/6</c></seealso></tag>
+       <item>Optional</item>
+   </taglist>
+
   </section>
   <marker id="enabled"></marker>
   <funcs>
@@ -114,11 +145,11 @@
       <type>
         <v>TraceTag = <seealso marker="#type-trace_tag">trace_tag()</seealso> | trace_status</v>
         <v>TracerState = term()</v>
-        <v>Tracee = <seealso marker="#type-trace_tag">tracee()</seealso></v>
+        <v>Tracee = <seealso marker="#type-tracee">tracee()</seealso></v>
         <v>Result =  trace | discard | remove</v>
       </type>
       <desc>
-        <p>This callback will be called whenever a trace point is triggered. It
+        <p>This callback will be called whenever a tracepoint is triggered. It
         allows the tracer to decide whether a trace should be generated or not.
         This check is made as early as possible in order to limit the amount of
         overhead associated with tracing. If <c>trace</c> is returned the
@@ -132,7 +163,7 @@
         to check if the tracer should still be active. It is called in multiple
         scenarios, but most significantly it is used when tracing is started
         using this tracer.</p>
-        <p>This function may be called multiple times per trace point, so it
+        <p>This function may be called multiple times per tracepoint, so it
         is important that it is both fast and side effect free.</p>
       </desc>
     </func>
@@ -143,17 +174,17 @@
       <type>
         <v>TraceTag = <seealso marker="#type-trace_tag">trace_tag()</seealso></v>
         <v>TracerState = term()</v>
-        <v>Tracee = <seealso marker="#type-trace_tag">tracee()</seealso></v>
+        <v>Tracee = <seealso marker="#type-tracee">tracee()</seealso></v>
         <v>FirstTraceTerm = term()</v>
         <v>SecondTraceTerm = term() | undefined</v>
         <v>Opts = <seealso marker="#type-trace_opts">trace_opts()</seealso></v>
         <v>Result =  ok</v>
       </type>
       <desc>
-        <p>This callback will be called when a trace point is triggered and
+        <p>This callback will be called when a tracepoint is triggered and
         the <seealso marker="#enabled">Module:enabled/3</seealso>
         callback returned <c>trace</c>. In it any side effects needed by
-        the tracer should be done. The trace point payload is located in
+        the tracer should be done. The tracepoint payload is located in
         the <c>FirstTraceTerm</c> and <c>SecondTraceTerm</c>. The content
         of the TraceTerms depends on which <c>TraceTag</c> has been triggered.
         The <c>FirstTraceTerm</c> and <c>SecondTraceTerm</c> correspond to the
@@ -181,6 +212,319 @@
         see the <seealso marker="kernel:seq_trace">seq_trace</seealso> manual.</p>
       </desc>
     </func>
+
+    <marker id="enabled_procs"></marker>
+    <func>
+        <name>Module:enabled_procs(TraceTag, TracerState, Tracee) -> Result</name>
+        <fsummary>Check if a trace event should be generated.</fsummary>
+        <type>
+            <v>TraceTag = <seealso marker="#type-trace_tag_procs">trace_tag_procs()</seealso></v>
+            <v>TracerState = term()</v>
+            <v>Tracee = <seealso marker="#type-tracee">tracee()</seealso></v>
+            <v>Result = trace | discard | remove</v>
+        </type>
+        <desc>
+            <p>This callback will be called whenever a tracepoint with trace flag
+                <seealso marker="erlang#trace-3"><c>procs</c></seealso>
+                is triggered.</p>
+            <p>If <c>enabled_procs/3</c> is not defined <c>enabled/3</c> will be called instead.</p>
+        </desc>
+    </func>
+
+    <marker id="trace_procs"></marker>
+    <func>
+        <name>Module:trace_procs(TraceTag, TracerState, Tracee, FirstTraceTerm, SecondTraceTerm, Opts) -> Result</name>
+        <fsummary>Check if a trace event should be generated.</fsummary>
+        <type>
+            <v>TraceTag = <seealso marker="#type-trace_tag_procs">trace_tag()</seealso></v>
+            <v>TracerState = term()</v>
+            <v>Tracee = <seealso marker="#type-tracee">tracee()</seealso></v>
+            <v>FirstTraceTerm = term()</v>
+            <v>SecondTraceTerm = term() | undefined</v>
+            <v>Opts = <seealso marker="#type-trace_opts">trace_opts()</seealso></v>
+            <v>Result = ok</v>
+        </type>
+        <desc>
+            <p>This callback will be called when a tracepoint is triggered and
+                the <seealso marker="#enabled_procs">Module:enabled_procs/3</seealso>
+                callback returned <c>trace</c>.</p>
+            <p>If <c>trace_procs/6</c> is not defined <c>trace/6</c> will be called instead.</p>
+        </desc>
+    </func>
+
+    <marker id="enabled_ports"></marker>
+    <func>
+        <name>Module:enabled_ports(TraceTag, TracerState, Tracee) -> Result</name>
+        <fsummary>Check if a trace event should be generated.</fsummary>
+        <type>
+            <v>TraceTag = <seealso marker="#type-trace_tag_ports">trace_tag_ports()</seealso></v>
+            <v>TracerState = term()</v>
+            <v>Tracee = <seealso marker="#type-tracee">tracee()</seealso></v>
+            <v>Result = trace | discard | remove</v>
+        </type>
+        <desc>
+            <p>This callback will be called whenever a tracepoint with trace flag
+                <seealso marker="erlang#trace-3"><c>ports</c></seealso>
+                is triggered.</p>
+            <p>If <c>enabled_ports/3</c> is not defined <c>enabled/3</c> will be called instead.</p>
+        </desc>
+    </func>
+
+    <marker id="trace_ports"></marker>
+    <func>
+        <name>Module:trace_ports(TraceTag, TracerState, Tracee, FirstTraceTerm, SecondTraceTerm, Opts) -> Result</name>
+        <fsummary>Check if a trace event should be generated.</fsummary>
+        <type>
+            <v>TraceTag = <seealso marker="#type-trace_tag_ports">trace_tag()</seealso></v>
+            <v>TracerState = term()</v>
+            <v>Tracee = <seealso marker="#type-tracee">tracee()</seealso></v>
+            <v>FirstTraceTerm = term()</v>
+            <v>SecondTraceTerm = term() | undefined</v>
+            <v>Opts = <seealso marker="#type-trace_opts">trace_opts()</seealso></v>
+            <v>Result = ok</v>
+        </type>
+        <desc>
+            <p>This callback will be called when a tracepoint is triggered and
+                the <seealso marker="#enabled_ports">Module:enabled_ports/3</seealso>
+                callback returned <c>trace</c>.</p>
+            <p>If <c>trace_ports/6</c> is not defined <c>trace/6</c> will be called instead.</p>
+        </desc>
+    </func>
+
+    <marker id="enabled_running_procs"></marker>
+    <func>
+        <name>Module:enabled_running_procs(TraceTag, TracerState, Tracee) -> Result</name>
+        <fsummary>Check if a trace event should be generated.</fsummary>
+        <type>
+            <v>TraceTag = <seealso marker="#type-trace_tag_running_procs">trace_tag_running_procs()</seealso></v>
+            <v>TracerState = term()</v>
+            <v>Tracee = <seealso marker="#type-tracee">tracee()</seealso></v>
+            <v>Result = trace | discard | remove</v>
+        </type>
+        <desc>
+            <p>This callback will be called whenever a tracepoint with trace flag
+                <seealso marker="erlang#trace-3"><c>running_procs | running</c></seealso>
+                is triggered.</p>
+            <p>If <c>enabled_running_procs/3</c> is not defined <c>enabled/3</c> will be called instead.</p>
+        </desc>
+    </func>
+
+    <marker id="trace_running_procs"></marker>
+    <func>
+        <name>Module:trace_running_procs(TraceTag, TracerState, Tracee, FirstTraceTerm, SecondTraceTerm, Opts) -> Result</name>
+        <fsummary>Check if a trace event should be generated.</fsummary>
+        <type>
+            <v>TraceTag = <seealso marker="#type-trace_tag_running_procs">trace_tag_running_procs()</seealso></v>
+            <v>TracerState = term()</v>
+            <v>Tracee = <seealso marker="#type-tracee">tracee()</seealso></v>
+            <v>FirstTraceTerm = term()</v>
+            <v>SecondTraceTerm = term() | undefined</v>
+            <v>Opts = <seealso marker="#type-trace_opts">trace_opts()</seealso></v>
+            <v>Result = ok</v>
+        </type>
+        <desc>
+            <p>This callback will be called when a tracepoint is triggered and
+                the <seealso marker="#enabled_running_procs">Module:enabled_running_procs/3</seealso>
+                callback returned <c>trace</c>.</p>
+            <p>If <c>trace_running_procs/6</c> is not defined <c>trace/6</c> will be called instead.</p>
+        </desc>
+    </func>
+
+    <marker id="enabled_running_ports"></marker>
+    <func>
+        <name>Module:enabled_running_ports(TraceTag, TracerState, Tracee) -> Result</name>
+        <fsummary>Check if a trace event should be generated.</fsummary>
+        <type>
+            <v>TraceTag = <seealso marker="#type-trace_tag_running_ports">trace_tag_running_ports()</seealso></v>
+            <v>TracerState = term()</v>
+            <v>Tracee = <seealso marker="#type-tracee">tracee()</seealso></v>
+            <v>Result = trace | discard | remove</v>
+        </type>
+        <desc>
+            <p>This callback will be called whenever a tracepoint with trace flag
+                <seealso marker="erlang#trace-3"><c>running_ports</c></seealso>
+                is triggered.</p>
+            <p>If <c>enabled_running_ports/3</c> is not defined <c>enabled/3</c> will be called instead.</p>
+        </desc>
+    </func>
+
+    <marker id="trace_running_ports"></marker>
+    <func>
+        <name>Module:trace_running_ports(TraceTag, TracerState, Tracee, FirstTraceTerm, SecondTraceTerm, Opts) -> Result</name>
+        <fsummary>Check if a trace event should be generated.</fsummary>
+        <type>
+            <v>TraceTag = <seealso marker="#type-trace_tag_running_ports">trace_tag_running_ports()</seealso></v>
+            <v>TracerState = term()</v>
+            <v>Tracee = <seealso marker="#type-tracee">tracee()</seealso></v>
+            <v>FirstTraceTerm = term()</v>
+            <v>SecondTraceTerm = term() | undefined</v>
+            <v>Opts = <seealso marker="#type-trace_opts">trace_opts()</seealso></v>
+            <v>Result = ok</v>
+        </type>
+        <desc>
+            <p>This callback will be called when a tracepoint is triggered and
+                the <seealso marker="#enabled_running_ports">Module:enabled_running_ports/3</seealso>
+                callback returned <c>trace</c>.</p>
+            <p>If <c>trace_running_ports/6</c> is not defined <c>trace/6</c> will be called instead.</p>
+        </desc>
+    </func>
+
+    <marker id="enabled_call"></marker>
+    <func>
+        <name>Module:enabled_call(TraceTag, TracerState, Tracee) -> Result</name>
+        <fsummary>Check if a trace event should be generated.</fsummary>
+        <type>
+            <v>TraceTag = <seealso marker="#type-trace_tag_call">trace_tag_call()</seealso></v>
+            <v>TracerState = term()</v>
+            <v>Tracee = <seealso marker="#type-tracee">tracee()</seealso></v>
+            <v>Result = trace | discard | remove</v>
+        </type>
+        <desc>
+            <p>This callback will be called whenever a tracepoint with trace flag
+                <seealso marker="erlang#trace-3"><c>call | return_to</c></seealso>
+                is triggered.</p>
+            <p>If <c>enabled_call/3</c> is not defined <c>enabled/3</c> will be called instead.</p>
+        </desc>
+    </func>
+
+    <marker id="trace_call"></marker>
+    <func>
+        <name>Module:trace_call(TraceTag, TracerState, Tracee, FirstTraceTerm, SecondTraceTerm, Opts) -> Result</name>
+        <fsummary>Check if a trace event should be generated.</fsummary>
+        <type>
+            <v>TraceTag = <seealso marker="#type-trace_tag_call">trace_tag_call()</seealso></v>
+            <v>TracerState = term()</v>
+            <v>Tracee = <seealso marker="#type-tracee">tracee()</seealso></v>
+            <v>FirstTraceTerm = term()</v>
+            <v>SecondTraceTerm = term() | undefined</v>
+            <v>Opts = <seealso marker="#type-trace_opts">trace_opts()</seealso></v>
+            <v>Result = ok</v>
+        </type>
+        <desc>
+            <p>This callback will be called when a tracepoint is triggered and
+                the <seealso marker="#enabled_call">Module:enabled_call/3</seealso>
+                callback returned <c>trace</c>.</p>
+            <p>If <c>trace_call/6</c> is not defined <c>trace/6</c> will be called instead.</p>
+        </desc>
+    </func>
+
+    <marker id="enabled_send"></marker>
+    <func>
+        <name>Module:enabled_send(TraceTag, TracerState, Tracee) -> Result</name>
+        <fsummary>Check if a trace event should be generated.</fsummary>
+        <type>
+            <v>TraceTag = <seealso marker="#type-trace_tag_send">trace_tag_send()</seealso></v>
+            <v>TracerState = term()</v>
+            <v>Tracee = <seealso marker="#type-tracee">tracee()</seealso></v>
+            <v>Result = trace | discard | remove</v>
+        </type>
+        <desc>
+            <p>This callback will be called whenever a tracepoint with trace flag
+                <seealso marker="erlang#trace-3"><c>send</c></seealso>
+                is triggered.</p>
+            <p>If <c>enabled_send/3</c> is not defined <c>enabled/3</c> will be called instead.</p>
+        </desc>
+    </func>
+
+    <marker id="trace_send"></marker>
+    <func>
+        <name>Module:trace_send(TraceTag, TracerState, Tracee, FirstTraceTerm, SecondTraceTerm, Opts) -> Result</name>
+        <fsummary>Check if a trace event should be generated.</fsummary>
+        <type>
+            <v>TraceTag = <seealso marker="#type-trace_tag_send">trace_tag_send()</seealso></v>
+            <v>TracerState = term()</v>
+            <v>Tracee = <seealso marker="#type-tracee">tracee()</seealso></v>
+            <v>FirstTraceTerm = term()</v>
+            <v>SecondTraceTerm = term() | undefined</v>
+            <v>Opts = <seealso marker="#type-trace_opts">trace_opts()</seealso></v>
+            <v>Result =  ok</v>
+        </type>
+        <desc>
+            <p>This callback will be called when a tracepoint is triggered and
+                the <seealso marker="#enabled_send">Module:enabled_send/3</seealso>
+                callback returned <c>trace</c>.</p>
+            <p>If <c>trace_send/6</c> is not defined <c>trace/6</c> will be called instead.</p>
+        </desc>
+    </func>
+
+    <marker id="enabled_receive"></marker>
+    <func>
+        <name>Module:enabled_receive(TraceTag, TracerState, Tracee) -> Result</name>
+        <fsummary>Check if a trace event should be generated.</fsummary>
+        <type>
+            <v>TraceTag = <seealso marker="#type-trace_tag_receive">trace_tag_receive()</seealso></v>
+            <v>TracerState = term()</v>
+            <v>Tracee = <seealso marker="#type-tracee">tracee()</seealso></v>
+            <v>Result = trace | discard | remove</v>
+        </type>
+        <desc>
+            <p>This callback will be called whenever a tracepoint with trace flag
+                <seealso marker="erlang#trace-3"><c>'receive'</c></seealso>
+                is triggered.</p>
+            <p>If <c>enabled_receive/3</c> is not defined <c>enabled/3</c> will be called instead.</p>
+        </desc>
+    </func>
+
+    <marker id="trace_receive"></marker>
+    <func>
+        <name>Module:trace_receive(TraceTag, TracerState, Tracee, FirstTraceTerm, SecondTraceTerm, Opts) -> Result</name>
+        <fsummary>Check if a trace event should be generated.</fsummary>
+        <type>
+            <v>TraceTag = <seealso marker="#type-trace_tag_receive">trace_tag_receive()</seealso></v>
+            <v>TracerState = term()</v>
+            <v>Tracee = <seealso marker="#type-tracee">tracee()</seealso></v>
+            <v>FirstTraceTerm = term()</v>
+            <v>SecondTraceTerm = term() | undefined</v>
+            <v>Opts = <seealso marker="#type-trace_opts">trace_opts()</seealso></v>
+            <v>Result =  ok</v>
+        </type>
+        <desc>
+            <p>This callback will be called when a tracepoint is triggered and
+                the <seealso marker="#enabled_receive">Module:enabled_receive/3</seealso>
+                callback returned <c>trace</c>.</p>
+            <p>If <c>trace_receive/6</c> is not defined <c>trace/6</c> will be called instead.</p>
+        </desc>
+    </func>
+
+    <marker id="enabled_garbage_collection"></marker>
+    <func>
+        <name>Module:enabled_garbage_collection(TraceTag, TracerState, Tracee) -> Result</name>
+        <fsummary>Check if a trace event should be generated.</fsummary>
+        <type>
+            <v>TraceTag = <seealso marker="#type-trace_tag_gc">trace_tag_gc()</seealso></v>
+            <v>TracerState = term()</v>
+            <v>Tracee = <seealso marker="#type-tracee">tracee()</seealso></v>
+            <v>Result = trace | discard | remove</v>
+        </type>
+        <desc>
+            <p>This callback will be called whenever a tracepoint with trace flag
+                <seealso marker="erlang#trace-3"><c>garbage_collection</c></seealso>
+                is triggered.</p>
+            <p>If <c>enabled_garbage_collection/3</c> is not defined <c>enabled/3</c> will be called instead.</p>
+        </desc>
+    </func>
+
+    <marker id="trace_garbage_collection"></marker>
+    <func>
+        <name>Module:trace_garbage_collection(TraceTag, TracerState, Tracee, FirstTraceTerm, SecondTraceTerm, Opts) -> Result</name>
+        <fsummary>Check if a trace event should be generated.</fsummary>
+        <type>
+            <v>TraceTag = <seealso marker="#type-trace_tag_gc">trace_tag_gc()</seealso></v>
+            <v>TracerState = term()</v>
+            <v>Tracee = <seealso marker="#type-tracee">tracee()</seealso></v>
+            <v>FirstTraceTerm = term()</v>
+            <v>SecondTraceTerm = term() | undefined</v>
+            <v>Opts = <seealso marker="#type-trace_opts">trace_opts()</seealso></v>
+            <v>Result =  ok</v>
+        </type>
+        <desc>
+            <p>This callback will be called when a tracepoint is triggered and
+                the <seealso marker="#enabled_garbage_collection">Module:enabled_garbage_collection/3</seealso>
+                callback returned <c>trace</c>.</p>
+            <p>If <c>trace_garbage_collection/6</c> is not defined <c>trace/6</c> will be called instead.</p>
+        </desc>
+    </func>
+
   </funcs>
   <section>
     <marker id="example"></marker>
@@ -282,7 +626,7 @@ static ERL_NIF_TERM enabled(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
     ErlNifPid to_pid;
     if (enif_get_local_pid(env, argv[1], &amp;to_pid))
         if (!enif_is_process_alive(env, &amp;to_pid))
-            /* tracer is dead so we should remove this trace point */
+            /* tracer is dead so we should remove this tracepoint */
             return enif_make_atom(env, "remove");
 
     /* Only generate trace for when tracer != tracee */
diff --git a/erts/emulator/beam/atom.names b/erts/emulator/beam/atom.names
index 8c51f788c0..3022c0a99a 100644
--- a/erts/emulator/beam/atom.names
+++ b/erts/emulator/beam/atom.names
@@ -273,6 +273,10 @@ atom garbage_collecting
 atom garbage_collection
 atom garbage_collection_info
 atom gc_end
+atom gc_major_end
+atom gc_major_start
+atom gc_minor_end
+atom gc_minor_start
 atom gc_start
 atom Ge='>='
 atom generational
diff --git a/erts/emulator/beam/erl_gc.c b/erts/emulator/beam/erl_gc.c
index 4698458521..df5d0f4918 100644
--- a/erts/emulator/beam/erl_gc.c
+++ b/erts/emulator/beam/erl_gc.c
@@ -593,10 +593,6 @@ garbage_collect(Process* p, ErlHeapFragment *live_hf_end,
 
     esdp = erts_get_scheduler_data();
 
-    if (IS_TRACED_FL(p, F_TRACE_GC)) {
-        trace_gc(p, am_gc_start);
-    }
-
     erts_smp_atomic32_read_bor_nob(&p->state, ERTS_PSFLG_GC);
     if (erts_system_monitor_long_gc != 0)
 	start_time = erts_get_monotonic_time(esdp);
@@ -619,18 +615,29 @@ garbage_collect(Process* p, ErlHeapFragment *live_hf_end,
      */
 
     if (GEN_GCS(p) < MAX_GEN_GCS(p) && !(FLAGS(p) & F_NEED_FULLSWEEP)) {
-	DTRACE2(gc_minor_start, pidbuf, need);
-	reds = minor_collection(p, live_hf_end, need, objv, nobj, &reclaimed_now);
-	DTRACE2(gc_minor_end, pidbuf, reclaimed_now);
-	if (reds < 0)
-	    goto do_major_collection;
-    }
-    else {
-    do_major_collection:
+        if (IS_TRACED_FL(p, F_TRACE_GC)) {
+            trace_gc(p, am_gc_minor_start, need);
+        }
+        DTRACE2(gc_minor_start, pidbuf, need);
+        reds = minor_collection(p, live_hf_end, need, objv, nobj, &reclaimed_now);
+        DTRACE2(gc_minor_end, pidbuf, reclaimed_now);
+        if (IS_TRACED_FL(p, F_TRACE_GC)) {
+            trace_gc(p, am_gc_minor_end, reclaimed_now);
+        }
+        if (reds < 0)
+            goto do_major_collection;
+    } else {
+do_major_collection:
         ERTS_MSACC_SET_STATE_CACHED_M_X(ERTS_MSACC_STATE_GC_FULL);
-	DTRACE2(gc_major_start, pidbuf, need);
-	reds = major_collection(p, live_hf_end, need, objv, nobj, &reclaimed_now);
-	DTRACE2(gc_major_end, pidbuf, reclaimed_now);
+        if (IS_TRACED_FL(p, F_TRACE_GC)) {
+            trace_gc(p, am_gc_major_start, need);
+        }
+        DTRACE2(gc_major_start, pidbuf, need);
+        reds = major_collection(p, live_hf_end, need, objv, nobj, &reclaimed_now);
+        DTRACE2(gc_major_end, pidbuf, reclaimed_now);
+        if (IS_TRACED_FL(p, F_TRACE_GC)) {
+            trace_gc(p, am_gc_major_end, reclaimed_now);
+        }
         ERTS_MSACC_SET_STATE_CACHED_M_X(ERTS_MSACC_STATE_GC);
     }
 
@@ -646,10 +653,6 @@ garbage_collect(Process* p, ErlHeapFragment *live_hf_end,
 
     erts_smp_atomic32_read_band_nob(&p->state, ~ERTS_PSFLG_GC);
 
-    if (IS_TRACED_FL(p, F_TRACE_GC)) {
-        trace_gc(p, am_gc_end);
-    }
-
     if (erts_system_monitor_long_gc != 0) {
 	ErtsMonotonicTime end_time;
 	Uint gc_time;
diff --git a/erts/emulator/beam/erl_nif.c b/erts/emulator/beam/erl_nif.c
index 24e72cc949..941f44b9ec 100644
--- a/erts/emulator/beam/erl_nif.c
+++ b/erts/emulator/beam/erl_nif.c
@@ -3157,7 +3157,7 @@ Eterm erts_nif_call_function(Process *p, Process *tracee,
     /* Verify that function is part of this module */
     int i;
     for (i = 0; i < mod->entry->num_of_funcs; i++)
-        if (fun == mod->entry->funcs+i)
+        if (fun == &(mod->entry->funcs[i]))
             break;
     ASSERT(i < mod->entry->num_of_funcs);
     if (p)
diff --git a/erts/emulator/beam/erl_trace.c b/erts/emulator/beam/erl_trace.c
index bd88769dfc..56899f574a 100644
--- a/erts/emulator/beam/erl_trace.c
+++ b/erts/emulator/beam/erl_trace.c
@@ -237,6 +237,7 @@ write_timestamp(ErtsTraceTimeStamp *tsp, Eterm **hpp)
     }
 }
 
+#ifdef ERTS_SMP
 #define PATCH_TS_SIZE(p) patch_ts_size(TFLGS_TS_TYPE(p))
 
 static ERTS_INLINE Uint
@@ -257,6 +258,7 @@ patch_ts_size(int ts_type)
 	return 0;
     }
 }
+#endif
 
 /*
  * Write a timestamp. The timestamp MUST be the last
@@ -359,25 +361,50 @@ void erts_init_trace(void) {
    *(OHPP) = &(*(BPP))->off_heap, \
    (*(BPP))->mem)
 
+enum ErtsTracerOpt {
+    TRACE_FUN_DEFAULT   = 0,
+    TRACE_FUN_ENABLED   = 1,
+    TRACE_FUN_T_SEND    = 2,
+    TRACE_FUN_T_RECEIVE = 3,
+    TRACE_FUN_T_CALL    = 4,
+    TRACE_FUN_T_SCHED_PROC = 5,
+    TRACE_FUN_T_SCHED_PORT = 6,
+    TRACE_FUN_T_GC      = 7,
+    TRACE_FUN_T_PROCS   = 8,
+    TRACE_FUN_T_PORTS   = 9,
+    TRACE_FUN_E_SEND    = 10,
+    TRACE_FUN_E_RECEIVE = 11,
+    TRACE_FUN_E_CALL    = 12,
+    TRACE_FUN_E_SCHED_PROC = 13,
+    TRACE_FUN_E_SCHED_PORT = 14,
+    TRACE_FUN_E_GC      = 15,
+    TRACE_FUN_E_PROCS   = 16,
+    TRACE_FUN_E_PORTS   = 17
+};
+
+#define NIF_TRACER_TYPES (18)
+
+
 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,
+                       enum ErtsTracerOpt topt,
                        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);
+                   Eterm t_p_id, ErtsTracerNif *tnif,
+                   enum ErtsTracerOpt topt,
+                   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);
+                    ErtsTracerNif **tnif_ref,
+                    enum ErtsTracerOpt topt,
+                    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);
-
-#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)
+is_tracer_enabled(Process* c_p, ErtsProcLocks c_p_locks,
+                  ErtsPTabElementCommon *t_p,
+                  ErtsTracerNif **tnif_ret,
+                  enum ErtsTracerOpt topt, Eterm tag);
 
 static Uint active_sched;
 
@@ -433,7 +460,7 @@ erts_set_system_seq_tracer(Process *c_p, ErtsProcLocks c_p_locks, ErtsTracer new
     if (!ERTS_TRACER_IS_NIL(new)) {
         Eterm nif_result = call_enabled_tracer(
             NULL, new, NULL,
-            am_trace_status, am_undefined);
+            TRACE_FUN_ENABLED, am_trace_status, am_undefined);
         switch (nif_result) {
         case am_trace: break;
         default:
@@ -465,7 +492,8 @@ erts_get_system_seq_tracer(void)
     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) {
+        call_enabled_tracer(NULL, st, NULL, TRACE_FUN_ENABLED,
+                            am_trace_status, am_undefined) == am_remove) {
         erts_set_system_seq_tracer(NULL, 0, erts_tracer_nil);
         st = erts_tracer_nil;
     }
@@ -484,10 +512,11 @@ get_default_tracing(Uint *flagsp, ErtsTracer *tracerp,
     if (ERTS_TRACER_IS_NIL(*default_tracer)) {
 	*default_trace_flags &= ~TRACEE_FLAGS;
     } else {
-        Eterm nif_result = call_enabled_tracer(
-            NULL, *default_tracer, NULL,
-            am_trace_status, am_undefined);
-        switch (nif_result) {
+        Eterm nif_res;
+        nif_res = call_enabled_tracer(NULL, *default_tracer,
+                                      NULL, TRACE_FUN_ENABLED,
+                                      am_trace_status, am_undefined);
+        switch (nif_res) {
         case am_trace: break;
         default: {
             ErtsTracer curr_default_tracer = *default_tracer;
@@ -737,7 +766,7 @@ trace_sched_aux(Process *p, ErtsProcLocks locks, Eterm what)
 	break;
     }
 
-    if (!is_tracer_proc_enabled(p, locks, &p->common, &tnif, what))
+    if (!is_tracer_enabled(p, locks, &p->common, &tnif, TRACE_FUN_E_SCHED_PROC, what))
         return;
 
     if (ERTS_PROC_IS_EXITING(p))
@@ -756,7 +785,7 @@ trace_sched_aux(Process *p, ErtsProcLocks locks, Eterm what)
 	hp += 4;
     }
 
-    send_to_tracer_nif(p, &p->common, p->common.id, tnif,
+    send_to_tracer_nif(p, &p->common, p->common.id, tnif, TRACE_FUN_T_SCHED_PROC,
                        what, tmp, THE_NON_VALUE);
 }
 
@@ -795,8 +824,10 @@ trace_send(Process *p, Eterm to, Eterm msg)
 	operation = am_send_to_non_existing_process;
     }
 
-    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);
+    if (is_tracer_enabled(p, ERTS_PROC_LOCK_MAIN, &p->common, &tnif,
+                TRACE_FUN_E_SEND, operation))
+        send_to_tracer_nif(p, &p->common, p->common.id, tnif, TRACE_FUN_T_SEND,
+                operation, msg, to);
 }
 
 /* Send {trace_ts, Pid, receive, Msg, Timestamp}
@@ -806,10 +837,11 @@ void
 trace_receive(Process *c_p, Eterm msg)
 {
     ErtsTracerNif *tnif = NULL;
-    if (is_tracer_proc_enabled(NULL, 0, &c_p->common,
-                               &tnif, am_receive))
+    if (is_tracer_enabled(NULL, 0, &c_p->common, &tnif,
+                TRACE_FUN_E_RECEIVE, am_receive))
         send_to_tracer_nif(NULL, &c_p->common, c_p->common.id,
-                           tnif, am_receive, msg, THE_NON_VALUE);
+                           tnif, TRACE_FUN_T_RECEIVE,
+                           am_receive, msg, THE_NON_VALUE);
 }
 
 int
@@ -819,8 +851,9 @@ seq_trace_update_send(Process *p)
     ASSERT((is_tuple(SEQ_TRACE_TOKEN(p)) || is_nil(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)
+         call_enabled_tracer(NULL, seq_tracer, NULL,
+                             TRACE_FUN_ENABLED, am_trace_status,
+                             p ? p->common.id : am_undefined) != am_trace)
 #ifdef USE_VM_PROBES
 	 || (SEQ_TRACE_TOKEN(p) == am_have_dt_utag)
 #endif
@@ -866,9 +899,10 @@ seq_trace_output_generic(Eterm token, Eterm msg, Uint type,
     ASSERT(is_tuple(token) || is_nil(token));
     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) {
+        call_enabled_tracer(NULL, seq_tracer,
+                            NULL, TRACE_FUN_ENABLED,
+                            am_trace_status,
+                            process ? process->common.id : am_undefined) != am_trace) {
 	return;
     }
 
@@ -897,14 +931,13 @@ seq_trace_output_generic(Eterm token, Eterm msg, Uint type,
         msg = TUPLE3(hp, am_EXIT, exitfrom, msg);
         hp += 4;
     }
-    mess = TUPLE5(hp, type_atom, lastcnt_serial, SEQ_TRACE_T_SENDER(token),
-                  receiver, msg);
+    mess = TUPLE5(hp, type_atom, lastcnt_serial, SEQ_TRACE_T_SENDER(token), receiver, msg);
     hp += 6;
 
     seq_tracer_flags |=  ERTS_SEQTFLGS2TFLGS(unsigned_val(SEQ_TRACE_T_FLAGS(token)));
 
     send_to_tracer_nif_raw(NULL, process, seq_tracer, seq_tracer_flags,
-                           label, NULL, am_seq_trace, mess,
+                           label, NULL, TRACE_FUN_DEFAULT, am_seq_trace, mess,
                            THE_NON_VALUE, am_true);
 
     UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
@@ -929,7 +962,8 @@ erts_trace_return_to(Process *p, BeamInstr *pc)
 	mfa = TUPLE3(hp, code_ptr[0], code_ptr[1], make_small(code_ptr[2]));
     }
 
-    SEND_TO_TRACER(p, am_return_to, mfa);
+    send_to_tracer_nif(p, &p->common, p->common.id, NULL, TRACE_FUN_T_CALL,
+                       am_return_to, mfa, THE_NON_VALUE);
 }
 
 
@@ -983,7 +1017,7 @@ erts_trace_return(Process* p, BeamInstr* fi, Eterm retval, ErtsTracer *tracer)
     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);
+                           NULL, TRACE_FUN_T_CALL, am_return_from, mfa, retval, am_true);
 }
 
 /* Send {trace_ts, Pid, exception_from, {Mod, Name, Arity}, {Class,Value}, 
@@ -1038,7 +1072,7 @@ erts_trace_exception(Process* p, BeamInstr mfa[3], Eterm class, Eterm value,
     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);
+                           NULL, TRACE_FUN_T_CALL, am_exception_from, mfa_tuple, cv, am_true);
 }
 
 /*
@@ -1088,7 +1122,8 @@ erts_call_trace(Process* p, BeamInstr mfa[3], Binary *match_spec,
 	 *     use process flags
 	 */
 	tracee_flags = &ERTS_TRACE_FLAGS(p);
-        if (!is_tracer_proc_enabled(p, ERTS_PROC_LOCK_MAIN, &p->common, &tnif, am_call)) {
+        if (!is_tracer_enabled(p, ERTS_PROC_LOCK_MAIN, &p->common, &tnif,
+                    TRACE_FUN_E_CALL, am_call)) {
             return 0;
         }
     } else {
@@ -1103,7 +1138,9 @@ erts_call_trace(Process* p, BeamInstr mfa[3], Binary *match_spec,
         }
 	meta_flags = F_TRACE_CALLS | F_NOW_TS;
 	tracee_flags = &meta_flags;
-        switch (call_enabled_tracer(p, *tracer, &tnif, am_call, p->common.id)) {
+        switch (call_enabled_tracer(p, *tracer,
+                                    &tnif, TRACE_FUN_T_CALL,
+                                    am_call, p->common.id)) {
         default:
         case am_remove: *tracer = erts_tracer_nil;
         case am_discard: return 0;
@@ -1227,7 +1264,7 @@ erts_call_trace(Process* p, BeamInstr mfa[3], Binary *match_spec,
      * 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);
+                           tnif, TRACE_FUN_T_CALL, am_call, mfa_tuple, THE_NON_VALUE, pam_result);
     erts_match_set_release_result(p);
 
     if (match_spec && tracer == &pre_ms_tracer)
@@ -1249,8 +1286,9 @@ trace_proc(Process *c_p, ErtsProcLocks c_p_locks,
            Process *t_p, Eterm what, Eterm data)
 {
     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,
+    if (is_tracer_enabled(c_p, c_p_locks, &t_p->common, &tnif,
+                TRACE_FUN_E_PROCS, what))
+        send_to_tracer_nif(c_p, &t_p->common, t_p->common.id, tnif, TRACE_FUN_T_PROCS,
                            what, data, THE_NON_VALUE);
 }
 
@@ -1267,16 +1305,17 @@ trace_proc_spawn(Process *p, Eterm what, Eterm pid,
 		 Eterm mod, Eterm func, Eterm args)
 {
     ErtsTracerNif *tnif = NULL;
-    if (is_tracer_proc_enabled(p, ERTS_PROC_LOCKS_ALL &
+    if (is_tracer_enabled(p, ERTS_PROC_LOCKS_ALL &
                                ~(ERTS_PROC_LOCK_STATUS|ERTS_PROC_LOCK_TRACE),
-                               &p->common, &tnif, what)) {
+                               &p->common, &tnif, TRACE_FUN_E_PROCS, what)) {
         Eterm mfa;
         Eterm* hp;
 
         hp = HAlloc(p, 4);
         mfa = TUPLE3(hp, mod, func, args);
         hp += 4;
-        send_to_tracer_nif(p, &p->common, p->common.id, tnif, what, pid, mfa);
+        send_to_tracer_nif(p, &p->common, p->common.id, tnif, TRACE_FUN_T_PROCS,
+                           what, pid, mfa);
     }
 }
 
@@ -1308,23 +1347,25 @@ void save_calls(Process *p, Export *e)
  * are all small (atomic) integers.
  */
 void
-trace_gc(Process *p, Eterm what)
+trace_gc(Process *p, Eterm what, Uint size)
 {
     ErtsTracerNif *tnif = NULL;
     Eterm* hp;
     Eterm msg = NIL;
-    Uint size = 0;
+    Uint sz = 0;
+    Eterm tup;
 
-    if (is_tracer_proc_enabled(
-            p, ERTS_PROC_LOCK_MAIN, &p->common, &tnif, what)) {
+    if (is_tracer_enabled(p, ERTS_PROC_LOCK_MAIN, &p->common, &tnif, TRACE_FUN_E_GC, what)) {
 
-        (void) erts_process_gc_info(p, &size, NULL);
-        hp = HAlloc(p, size);
+        (void) erts_process_gc_info(p, &sz, NULL);
+        hp = HAlloc(p, sz + 3 + 2);
 
         msg = erts_process_gc_info(p, NULL, &hp);
+	tup = TUPLE2(hp, am_wordsize, make_small(size)); hp += 3;
+        msg = CONS(hp, tup, msg); hp += 2;
 
-        send_to_tracer_nif(p, &p->common, p->common.id, tnif, what,
-                           msg, THE_NON_VALUE);
+        send_to_tracer_nif(p, &p->common, p->common.id, tnif, TRACE_FUN_T_GC,
+                what, msg, am_undefined);
     }
 }
 
@@ -1737,9 +1778,9 @@ void
 trace_port_open(Port *p, Eterm calling_pid, Eterm drv_name) {
     ErtsTracerNif *tnif = NULL;
     ERTS_SMP_CHK_NO_PROC_LOCKS;
-    if (is_tracer_proc_enabled(NULL, 0, &p->common, &tnif, am_open))
-        send_to_tracer_nif(NULL, &p->common, p->common.id, tnif, am_open,
-                           calling_pid, drv_name);
+    if (is_tracer_enabled(NULL, 0, &p->common, &tnif, TRACE_FUN_E_PORTS, am_open))
+        send_to_tracer_nif(NULL, &p->common, p->common.id, tnif, TRACE_FUN_T_PORTS,
+                am_open, calling_pid, drv_name);
 }
 
 /* Sends trace message:
@@ -1756,8 +1797,8 @@ trace_port(Port *t_p, Eterm what, Eterm data) {
     ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(t_p)
 		       || erts_thr_progress_is_blocking());
     ERTS_SMP_CHK_NO_PROC_LOCKS;
-    if (is_tracer_proc_enabled(NULL, 0, &t_p->common, &tnif, what))
-        send_to_tracer_nif(NULL, &t_p->common, t_p->common.id, tnif,
+    if (is_tracer_enabled(NULL, 0, &t_p->common, &tnif, TRACE_FUN_E_PORTS, what))
+        send_to_tracer_nif(NULL, &t_p->common, t_p->common.id, tnif, TRACE_FUN_T_PORTS,
                            what, data, THE_NON_VALUE);
 }
 
@@ -1802,7 +1843,7 @@ trace_port_receive(Port *t_p, Eterm caller, Eterm what, ...)
     ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(t_p)
 		       || erts_thr_progress_is_blocking());
     ERTS_SMP_CHK_NO_PROC_LOCKS;
-    if (is_tracer_proc_enabled(NULL, 0, &t_p->common, &tnif, am_receive)) {
+    if (is_tracer_enabled(NULL, 0, &t_p->common, &tnif, TRACE_FUN_E_RECEIVE, am_receive)) {
         /* We can use a stack heap here, as the nif is called in the
            context of a port */
 #define LOCAL_HEAP_SIZE (3 + 3 + heap_bin_size(ERL_ONHEAP_BIN_LIMIT) + 3)
@@ -1894,7 +1935,7 @@ trace_port_receive(Port *t_p, Eterm caller, Eterm what, ...)
         }
 
         data = TUPLE2(hp, caller, data);
-        send_to_tracer_nif(NULL, &t_p->common, t_p->common.id, tnif,
+        send_to_tracer_nif(NULL, &t_p->common, t_p->common.id, tnif, TRACE_FUN_T_RECEIVE,
                            am_receive, data, THE_NON_VALUE);
 
         if (bptr && erts_refc_dectest(&bptr->refc, 1) == 0)
@@ -1916,8 +1957,8 @@ trace_port_send(Port *t_p, Eterm receiver, Eterm msg, int exists)
     ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(t_p)
 		       || erts_thr_progress_is_blocking());
     ERTS_SMP_CHK_NO_PROC_LOCKS;
-    if (is_tracer_proc_enabled(NULL, 0, &t_p->common, &tnif, op))
-        send_to_tracer_nif(NULL, &t_p->common, t_p->common.id, tnif,
+    if (is_tracer_enabled(NULL, 0, &t_p->common, &tnif, TRACE_FUN_E_SEND, op))
+        send_to_tracer_nif(NULL, &t_p->common, t_p->common.id, tnif, TRACE_FUN_T_SEND,
                            op, msg, receiver);
 }
 
@@ -1927,7 +1968,7 @@ void trace_port_send_binary(Port *t_p, Eterm to, Eterm what, char *bin, Sint sz)
     ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(t_p)
 		       || erts_thr_progress_is_blocking());
     ERTS_SMP_CHK_NO_PROC_LOCKS;
-    if (is_tracer_proc_enabled(NULL, 0, &t_p->common, &tnif, am_send)) {
+    if (is_tracer_enabled(NULL, 0, &t_p->common, &tnif, TRACE_FUN_E_SEND, am_send)) {
         Eterm msg;
         Binary* bptr = NULL;
 #define LOCAL_HEAP_SIZE (3 + 3 + heap_bin_size(ERL_ONHEAP_BIN_LIMIT))
@@ -1946,7 +1987,7 @@ void trace_port_send_binary(Port *t_p, Eterm to, Eterm what, char *bin, Sint sz)
         msg = TUPLE2(hp, t_p->common.id, msg);
         hp += 3;
 
-        send_to_tracer_nif(NULL, &t_p->common, t_p->common.id, tnif,
+        send_to_tracer_nif(NULL, &t_p->common, t_p->common.id, tnif, TRACE_FUN_T_SEND,
                            am_send, msg, to);
         if (bptr && erts_refc_dectest(&bptr->refc, 1) == 0)
             erts_bin_free(bptr);
@@ -1975,9 +2016,10 @@ trace_sched_ports_where(Port *t_p, Eterm what, Eterm where) {
     ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(t_p)
 		       || erts_thr_progress_is_blocking());
     ERTS_SMP_CHK_NO_PROC_LOCKS;
-    if (is_tracer_proc_enabled(NULL, 0, &t_p->common, &tnif, what))
+    if (is_tracer_enabled(NULL, 0, &t_p->common, &tnif, TRACE_FUN_E_SCHED_PORT, what))
         send_to_tracer_nif(NULL, &t_p->common, t_p->common.id,
-                           tnif, what, where, THE_NON_VALUE);
+                           tnif, TRACE_FUN_T_SCHED_PORT,
+                           what, where, THE_NON_VALUE);
 }
 
 /* Port profiling */
@@ -2523,14 +2565,97 @@ init_sys_msg_dispatcher(void)
 
 #include "erl_nif.h"
 
+typedef struct {
+    char *name;
+    Uint arity;
+    ErlNifFunc *cb;
+} ErtsTracerType;
+
 struct ErtsTracerNif_ {
     HashBucket hb;
     Eterm module;
     struct erl_module_nif* nif_mod;
-    ErlNifFunc *enabled;
-    ErlNifFunc *trace;
+    ErtsTracerType tracers[NIF_TRACER_TYPES];
 };
 
+static void init_tracer_template(ErtsTracerNif *tnif) {
+
+    /* default tracer functions */
+    tnif->tracers[TRACE_FUN_DEFAULT].name  = "trace";
+    tnif->tracers[TRACE_FUN_DEFAULT].arity = 6;
+    tnif->tracers[TRACE_FUN_DEFAULT].cb    = NULL;
+
+    tnif->tracers[TRACE_FUN_ENABLED].name  = "enabled";
+    tnif->tracers[TRACE_FUN_ENABLED].arity = 3;
+    tnif->tracers[TRACE_FUN_ENABLED].cb    = NULL;
+
+    /* specific tracer functions */
+    tnif->tracers[TRACE_FUN_T_SEND].name  = "trace_send";
+    tnif->tracers[TRACE_FUN_T_SEND].arity = 6;
+    tnif->tracers[TRACE_FUN_T_SEND].cb    = NULL;
+
+    tnif->tracers[TRACE_FUN_T_RECEIVE].name  = "trace_receive";
+    tnif->tracers[TRACE_FUN_T_RECEIVE].arity = 6;
+    tnif->tracers[TRACE_FUN_T_RECEIVE].cb    = NULL;
+
+    tnif->tracers[TRACE_FUN_T_CALL].name  = "trace_call";
+    tnif->tracers[TRACE_FUN_T_CALL].arity = 6;
+    tnif->tracers[TRACE_FUN_T_CALL].cb    = NULL;
+
+    tnif->tracers[TRACE_FUN_T_SCHED_PROC].name  = "trace_running_procs";
+    tnif->tracers[TRACE_FUN_T_SCHED_PROC].arity = 6;
+    tnif->tracers[TRACE_FUN_T_SCHED_PROC].cb    = NULL;
+
+    tnif->tracers[TRACE_FUN_T_SCHED_PORT].name  = "trace_running_ports";
+    tnif->tracers[TRACE_FUN_T_SCHED_PORT].arity = 6;
+    tnif->tracers[TRACE_FUN_T_SCHED_PORT].cb    = NULL;
+
+    tnif->tracers[TRACE_FUN_T_GC].name  = "trace_garbage_collection";
+    tnif->tracers[TRACE_FUN_T_GC].arity = 6;
+    tnif->tracers[TRACE_FUN_T_GC].cb    = NULL;
+
+    tnif->tracers[TRACE_FUN_T_PROCS].name  = "trace_procs";
+    tnif->tracers[TRACE_FUN_T_PROCS].arity = 6;
+    tnif->tracers[TRACE_FUN_T_PROCS].cb    = NULL;
+
+    tnif->tracers[TRACE_FUN_T_PORTS].name  = "trace_ports";
+    tnif->tracers[TRACE_FUN_T_PORTS].arity = 6;
+    tnif->tracers[TRACE_FUN_T_PORTS].cb    = NULL;
+
+    /* specific enabled functions */
+    tnif->tracers[TRACE_FUN_E_SEND].name  = "enabled_send";
+    tnif->tracers[TRACE_FUN_E_SEND].arity = 3;
+    tnif->tracers[TRACE_FUN_E_SEND].cb    = NULL;
+
+    tnif->tracers[TRACE_FUN_E_RECEIVE].name  = "enabled_receive";
+    tnif->tracers[TRACE_FUN_E_RECEIVE].arity = 3;
+    tnif->tracers[TRACE_FUN_E_RECEIVE].cb    = NULL;
+
+    tnif->tracers[TRACE_FUN_E_CALL].name  = "enabled_call";
+    tnif->tracers[TRACE_FUN_E_CALL].arity = 3;
+    tnif->tracers[TRACE_FUN_E_CALL].cb    = NULL;
+
+    tnif->tracers[TRACE_FUN_E_SCHED_PROC].name  = "enabled_running_procs";
+    tnif->tracers[TRACE_FUN_E_SCHED_PROC].arity = 3;
+    tnif->tracers[TRACE_FUN_E_SCHED_PROC].cb    = NULL;
+
+    tnif->tracers[TRACE_FUN_E_SCHED_PORT].name  = "enabled_running_ports";
+    tnif->tracers[TRACE_FUN_E_SCHED_PORT].arity = 3;
+    tnif->tracers[TRACE_FUN_E_SCHED_PORT].cb    = NULL;
+
+    tnif->tracers[TRACE_FUN_E_GC].name  = "enabled_garbage_collection";
+    tnif->tracers[TRACE_FUN_E_GC].arity = 3;
+    tnif->tracers[TRACE_FUN_E_GC].cb    = NULL;
+
+    tnif->tracers[TRACE_FUN_E_PROCS].name  = "enabled_procs";
+    tnif->tracers[TRACE_FUN_E_PROCS].arity = 3;
+    tnif->tracers[TRACE_FUN_E_PROCS].cb    = NULL;
+
+    tnif->tracers[TRACE_FUN_E_PORTS].name  = "enabled_ports";
+    tnif->tracers[TRACE_FUN_E_PORTS].arity = 3;
+    tnif->tracers[TRACE_FUN_E_PORTS].cb    = NULL;
+}
+
 static Hash *tracer_hash = NULL;
 static erts_smp_rwmtx_t tracer_mtx;
 
@@ -2543,31 +2668,32 @@ load_tracer_nif(const ErtsTracer tracer)
     ErlNifFunc *funcs;
     int num_of_funcs;
     ErtsTracerNif tnif_tmpl, *tnif;
-    int i;
+    ErtsTracerType *tracers;
+    int i,j;
 
-    if (mod && mod->curr.nif != NULL) {
-        instance = &mod->curr;
-    } else {
+    if (!mod || !mod->curr.nif) {
         return NULL;
     }
 
-    tnif_tmpl.enabled = NULL;
-    tnif_tmpl.trace = NULL;
+    instance = &mod->curr;
+
+    init_tracer_template(&tnif_tmpl);
     tnif_tmpl.nif_mod = instance->nif;
     tnif_tmpl.module = ERTS_TRACER_MODULE(tracer);
+    tracers = tnif_tmpl.tracers;
 
     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;
+        for (j = 0; j < NIF_TRACER_TYPES; j++) {
+            if (strcmp(tracers[j].name, funcs[i].name) == 0 && tracers[j].arity == funcs[i].arity) {
+                tracers[j].cb = &(funcs[i]);
+                break;
+            }
         }
     }
 
-    if (tnif_tmpl.enabled == NULL ||
-        tnif_tmpl.trace   == NULL ) {
+    if (tracers[TRACE_FUN_DEFAULT].cb == NULL || tracers[TRACE_FUN_ENABLED].cb == NULL ) {
         return NULL;
     }
 
@@ -2660,17 +2786,18 @@ erts_tracer_to_term(Process *p, ErtsTracer tracer)
 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)
+                       Eterm t_p_id, ErtsTracerNif *tnif,
+                       enum ErtsTracerOpt topt,
+                       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 */)];
+        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;
+        topt = (tnif->tracers[topt].cb) ? topt : TRACE_FUN_DEFAULT;
+        ASSERT(topt < NIF_TRACER_TYPES);
 
         argv[0] = tag;
         argv[1] = ERTS_TRACER_STATE(tracer);
@@ -2681,8 +2808,7 @@ send_to_tracer_nif_raw(Process *c_p, Process *tracee,
 
         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->keys = TUPLE3(local_heap, am_match_spec_result, am_scheduler_id, am_timestamp);
 
         *map_values++ = pam_result;
         if (tracee_flags & F_TRACE_SCHED_NO)
@@ -2705,16 +2831,18 @@ send_to_tracer_nif_raw(Process *c_p, Process *tracee,
 
 #undef MAP_SIZE
         erts_nif_call_function(c_p, tracee ? tracee : c_p,
-                               tnif->nif_mod, tnif->trace, argc, argv);
+                               tnif->nif_mod,
+                               tnif->tracers[topt].cb,
+                               tnif->tracers[topt].arity,
+                               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)
+                   Eterm t_p_id, ErtsTracerNif *tnif, enum ErtsTracerOpt topt,
+                   Eterm tag, Eterm msg, Eterm extra)
 {
 #if defined(ERTS_SMP) && defined(ERTS_ENABLE_LOCK_CHECK)
     if (c_p) {
@@ -2733,29 +2861,35 @@ send_to_tracer_nif(Process *c_p, ErtsPTabElementCommon *t_p,
     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,
+                                  t_p_id, tnif, topt, 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_ret,
+                    enum ErtsTracerOpt topt,
+                    Eterm tag, Eterm t_p_id) {
     ErtsTracerNif *tnif = lookup_tracer_nif(tracer);
     if (tnif) {
         Eterm argv[] = {tag, ERTS_TRACER_STATE(tracer), t_p_id};
+        topt = (tnif->tracers[topt].cb) ? topt : TRACE_FUN_ENABLED;
+        ASSERT(topt < NIF_TRACER_TYPES);
+        ASSERT(tnif->tracers[topt].cb != NULL);
         if (tnif_ret) *tnif_ret = tnif;
-        return erts_nif_call_function(
-            c_p, NULL, tnif->nif_mod, tnif->enabled, 3, argv);
+        return erts_nif_call_function(c_p, NULL, tnif->nif_mod,
+                                      tnif->tracers[topt].cb,
+                                      tnif->tracers[topt].arity,
+                                      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)
-{
+is_tracer_enabled(Process* c_p, ErtsProcLocks c_p_locks,
+                  ErtsPTabElementCommon *t_p,
+                  ErtsTracerNif **tnif_ret,
+                  enum ErtsTracerOpt topt, Eterm tag) {
     Eterm nif_result;
 
 #if defined(ERTS_SMP) && defined(ERTS_ENABLE_LOCK_CHECK)
@@ -2773,7 +2907,7 @@ is_tracer_proc_enabled(Process* c_p, ErtsProcLocks c_p_locks,
     }
 #endif
 
-    nif_result = call_enabled_tracer(c_p, t_p->tracer, tnif_ret, tag, t_p->id);
+    nif_result = call_enabled_tracer(c_p, t_p->tracer, tnif_ret, topt, tag, t_p->id);
     switch (nif_result) {
     case am_discard: return 0;
     case am_trace: return 1;
@@ -2806,14 +2940,13 @@ is_tracer_proc_enabled(Process* c_p, ErtsProcLocks c_p_locks,
             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, Eterm type)
 {
-    return is_tracer_proc_enabled(c_p, c_p_locks, t_p, NULL, am_trace_status);
+    return is_tracer_enabled(c_p, c_p_locks, t_p, NULL, TRACE_FUN_ENABLED, am_trace_status);
 }
 
 int erts_is_tracer_enabled(Process *c_p, const ErtsTracer tracer)
@@ -2821,7 +2954,7 @@ 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,
+                                               TRACE_FUN_ENABLED, am_trace_status,
                                                c_p->common.id);
         switch (nif_result) {
         case am_discard:
diff --git a/erts/emulator/beam/erl_trace.h b/erts/emulator/beam/erl_trace.h
index 177fd373a6..9a007e62ec 100644
--- a/erts/emulator/beam/erl_trace.h
+++ b/erts/emulator/beam/erl_trace.h
@@ -103,7 +103,7 @@ void trace_sched(Process*, ErtsProcLocks, Eterm);
 void trace_proc(Process*, ErtsProcLocks, Process*, Eterm, Eterm);
 void trace_proc_spawn(Process*, Eterm what, Eterm pid, Eterm mod, Eterm func, Eterm args);
 void save_calls(Process *p, Export *);
-void trace_gc(Process *p, Eterm what);
+void trace_gc(Process *p, Eterm what, Uint size);
 /* port tracing */
 void trace_virtual_sched(Process*, ErtsProcLocks, Eterm);
 void trace_sched_ports(Port *pp, Eterm);
diff --git a/erts/emulator/nifs/common/erl_tracer_nif.c b/erts/emulator/nifs/common/erl_tracer_nif.c
index a1e0e581a4..1bb6b940c4 100644
--- a/erts/emulator/nifs/common/erl_tracer_nif.c
+++ b/erts/emulator/nifs/common/erl_tracer_nif.c
@@ -72,6 +72,12 @@ ERL_NIF_INIT(erl_tracer, nif_funcs, load, NULL, upgrade, unload)
     ATOM_DECL(trace);                              \
     ATOM_DECL(trace_ts);                           \
     ATOM_DECL(true);                               \
+    ATOM_DECL(gc_start);                           \
+    ATOM_DECL(gc_end);                             \
+    ATOM_DECL(gc_minor_start);                     \
+    ATOM_DECL(gc_minor_end);                       \
+    ATOM_DECL(gc_major_start);                     \
+    ATOM_DECL(gc_major_end);                       \
     ATOM_DECL(undefined);
 
 #define ATOM_DECL(A) static ERL_NIF_TERM atom_##A
diff --git a/erts/emulator/test/sensitive_SUITE.erl b/erts/emulator/test/sensitive_SUITE.erl
index b7ff4c109c..c3e303bbd1 100644
--- a/erts/emulator/test/sensitive_SUITE.erl
+++ b/erts/emulator/test/sensitive_SUITE.erl
@@ -311,7 +311,7 @@ gc_trace(Config) when is_list(Config) ->
 
     wait_trace(Self),
     {messages,Messages} = process_info(Tracer, messages),    
-    [{trace,Self,gc_start,_},{trace,Self,gc_end,_}] = Messages,
+    [{trace,Self,gc_major_start,_},{trace,Self,gc_major_end,_}] = Messages,
 
     unlink(Tracer), exit(Tracer, kill),
     ok.
diff --git a/erts/emulator/test/trace_port_SUITE.erl b/erts/emulator/test/trace_port_SUITE.erl
index 1068c1d22d..a66563d15b 100644
--- a/erts/emulator/test/trace_port_SUITE.erl
+++ b/erts/emulator/test/trace_port_SUITE.erl
@@ -236,13 +236,13 @@ gc(Config) when is_list(Config) ->
 
     trace_info(Garber, flags),
     Garber ! hi,
-    expect({trace,Garber,gc_start,info}),
-    expect({trace,Garber,gc_end,info}),
+    expect({trace,Garber,gc_major_start,info}),
+    expect({trace,Garber,gc_major_end,info}),
 
     trac(Garber, true, [garbage_collection,timestamp]),
     Garber ! hi,
-    expect({trace_ts,Garber,gc_start,info,ts}),
-    expect({trace_ts,Garber,gc_end,info,ts}),
+    expect({trace_ts,Garber,gc_major_start,info,ts}),
+    expect({trace_ts,Garber,gc_major_end,info,ts}),
 
     ok.
 
diff --git a/erts/emulator/test/tracer_SUITE.erl b/erts/emulator/test/tracer_SUITE.erl
index 812e834562..de44d6656a 100644
--- a/erts/emulator/test/tracer_SUITE.erl
+++ b/erts/emulator/test/tracer_SUITE.erl
@@ -468,12 +468,12 @@ gc_start(_Config) ->
         fun(Pid, State, EOpts) ->
                 receive
                     Msg ->
-                        {Pid, gc_start, State, Pid, _, undefined, Opts} = Msg,
+                        {Pid, gc_major_start, State, Pid, _, undefined, Opts} = Msg,
                         check_opts(EOpts, Opts)
                 end
              end,
 
-    test(gc_start, garbage_collection, Tc, Expect, true).
+    test(gc_major_start, garbage_collection, Tc, Expect, true).
 
 gc_end(_Config) ->
 
@@ -488,12 +488,12 @@ gc_end(_Config) ->
         fun(Pid, State, EOpts) ->
                 receive
                     Msg ->
-                        {Pid, gc_end, State, Pid, _, undefined, Opts} = Msg,
+                        {Pid, gc_major_end, State, Pid, _, undefined, Opts} = Msg,
                         check_opts(EOpts, Opts)
                 end
              end,
 
-    test(gc_end, garbage_collection, Tc, Expect, true).
+    test(gc_major_end, garbage_collection, Tc, Expect, true).
 
 test(Event, Tc, Expect) ->
     test(Event, Tc, Expect, true).
diff --git a/erts/preloaded/ebin/erl_tracer.beam b/erts/preloaded/ebin/erl_tracer.beam
index ffe5d5631c..b8f3f6d8c2 100644
--- a/erts/preloaded/ebin/erl_tracer.beam
+++ b/erts/preloaded/ebin/erl_tracer.beam
diff --git a/erts/preloaded/src/erl_tracer.erl b/erts/preloaded/src/erl_tracer.erl
index 2177e48f60..de1e9ca01e 100644
--- a/erts/preloaded/src/erl_tracer.erl
+++ b/erts/preloaded/src/erl_tracer.erl
@@ -3,12 +3,29 @@
 -export([enabled/3, trace/6, on_load/0]).
 
 -type tracee() :: port() | pid() | undefined.
--type trace_tag() :: send | send_to_non_existing_process | 'receive' |
-                     call | return_to | return_from | exception_from |
-                     spawn | spawned | exit | link | unlink | getting_linked |
-                     getting_unlinked | register | unregister | in | out |
-                     in_exiting | out_exiting | out_exited |
-                     open | closed | gc_start | gc_end.
+
+-type trace_tag_running_ports() :: in | out | in_exiting | out_exiting | out_exited.
+-type trace_tag_running_procs() :: in | out | in_exiting | out_exiting | out_exited.
+-type trace_tag_send() :: send | send_to_non_existing_process.
+-type trace_tag_receive() :: 'receive'.
+-type trace_tag_call() :: call | return_to | return_from | exception_from.
+-type trace_tag_procs() :: spawn | spawned | exit | link | unlink
+                         | getting_linked | getting_unlinked
+                         | register | unregister.
+-type trace_tag_ports() :: open | closed  | link | unlink
+                         | getting_linked | getting_unlinked.
+-type trace_tag_gc() :: gc_minor_start | gc_minor_end
+                      | gc_major_start | gc_major_end.
+
+-type trace_tag() :: trace_tag_send()
+                   | trace_tag_receive()
+                   | trace_tag_call()
+                   | trace_tag_procs()
+                   | trace_tag_ports()
+                   | trace_tag_running_procs()
+                   | trace_tag_running_ports()
+                   | trace_tag_gc().
+
 -type trace_opts() :: #{ match_spec_result => true | term(),
                          scheduler_id => undefined | non_neg_integer(),
                          timestamp => undefined | timestamp | cpu_timestamp |
diff --git a/lib/runtime_tools/c_src/Makefile.in b/lib/runtime_tools/c_src/Makefile.in
index 70b48daf97..4530a83aee 100644
--- a/lib/runtime_tools/c_src/Makefile.in
+++ b/lib/runtime_tools/c_src/Makefile.in
@@ -91,7 +91,7 @@ $(OBJDIR):
 $(LIBDIR):
 	-@mkdir -p $(LIBDIR)
 
-$(OBJDIR)/%$(TYPEMARKER).o: %.c
+$(OBJDIR)/%$(TYPEMARKER).o: %.c dyntrace_lttng.h
 	$(V_CC) -c -o $@ $(ALL_CFLAGS) $<
 
 $(LIBDIR)/%$(TYPEMARKER).@DED_EXT@: $(OBJDIR)/%$(TYPEMARKER).o
diff --git a/lib/runtime_tools/c_src/dyntrace.c b/lib/runtime_tools/c_src/dyntrace.c
index 0ef8eaf4d3..0178d95efb 100644
--- a/lib/runtime_tools/c_src/dyntrace.c
+++ b/lib/runtime_tools/c_src/dyntrace.c
@@ -29,7 +29,13 @@
 #include "sys.h"
 #include "dtrace-wrapper.h"
 #if defined(USE_DYNAMIC_TRACE) && (defined(USE_DTRACE) || defined(USE_SYSTEMTAP))
-#define HAVE_USE_DTRACE 1
+#  define HAVE_USE_DTRACE 1
+#endif
+#if defined(USE_LTTNG)
+#  define HAVE_USE_LTTNG 1
+#  define TRACEPOINT_DEFINE
+#  define TRACEPOINT_CREATE_PROBES
+#  include "dyntrace_lttng.h"
 #endif
 
 void dtrace_nifenv_str(ErlNifEnv *env, char *process_buf);
@@ -60,11 +66,56 @@ static ERL_NIF_TERM user_trace_s1(ErlNifEnv* env, int argc, const ERL_NIF_TERM a
 static ERL_NIF_TERM user_trace_i4s4(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
 static ERL_NIF_TERM user_trace_n(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
 
+static ERL_NIF_TERM enabled(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM trace(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
+
+#ifdef HAVE_USE_LTTNG
+static ERL_NIF_TERM trace_procs(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM trace_ports(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM trace_running_procs(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM trace_running_ports(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM trace_call(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM trace_send(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM trace_receive(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM trace_garbage_collection(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
+
+static ERL_NIF_TERM enabled_procs(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM enabled_ports(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM enabled_running_procs(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM enabled_running_ports(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM enabled_call(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM enabled_send(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM enabled_receive(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM enabled_garbage_collection(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
+#endif
+
+
 static ErlNifFunc nif_funcs[] = {
     {"available", 0, available},
     {"user_trace_s1", 1, user_trace_s1},
     {"user_trace_i4s4", 9, user_trace_i4s4},
-    {"user_trace_n", 10, user_trace_n}
+    {"user_trace_n", 10, user_trace_n},
+#ifdef HAVE_USE_LTTNG
+    {"trace_procs", 6, trace_procs},
+    {"trace_ports", 6, trace_ports},
+    {"trace_running_procs", 6, trace_running_procs},
+    {"trace_running_ports", 6, trace_running_ports},
+    {"trace_call", 6, trace_call},
+    {"trace_send", 6, trace_send},
+    {"trace_receive", 6, trace_receive},
+    {"trace_garbage_collection", 6, trace_garbage_collection},
+    {"enabled_procs", 3, enabled_procs},
+    {"enabled_ports", 3, enabled_ports},
+    {"enabled_running_procs", 3, enabled_running_procs},
+    {"enabled_running_ports", 3, enabled_running_ports},
+    {"enabled_call", 3, enabled_call},
+    {"enabled_send", 3, enabled_send},
+    {"enabled_receive", 3, enabled_receive},
+    {"enabled_garbage_collection", 3, enabled_garbage_collection},
+#endif
+    {"enabled", 3, enabled},
+    {"trace", 5, trace},
+    {"trace", 6, trace}
 };
 
 ERL_NIF_INIT(dyntrace, nif_funcs, load, NULL, NULL, NULL)
@@ -76,6 +127,61 @@ static ERL_NIF_TERM atom_not_available;
 static ERL_NIF_TERM atom_badarg;
 static ERL_NIF_TERM atom_ok;
 
+static ERL_NIF_TERM atom_trace;
+static ERL_NIF_TERM atom_seq_trace;
+static ERL_NIF_TERM atom_remove;
+static ERL_NIF_TERM atom_discard;
+
+#ifdef HAVE_USE_LTTNG
+
+/* gc atoms */
+
+static ERL_NIF_TERM atom_gc_minor_start;
+static ERL_NIF_TERM atom_gc_minor_end;
+static ERL_NIF_TERM atom_gc_major_start;
+static ERL_NIF_TERM atom_gc_major_end;
+
+static ERL_NIF_TERM atom_old_heap_block_size; /* for debug */
+static ERL_NIF_TERM atom_heap_block_size;     /* for debug */
+
+/* process 'procs' */
+
+static ERL_NIF_TERM atom_spawn;
+static ERL_NIF_TERM atom_exit;
+static ERL_NIF_TERM atom_register;
+static ERL_NIF_TERM atom_unregister;
+static ERL_NIF_TERM atom_link;
+static ERL_NIF_TERM atom_unlink;
+static ERL_NIF_TERM atom_getting_linked;
+static ERL_NIF_TERM atom_getting_unlinked;
+
+/* process 'running' and 'exiting' */
+
+static ERL_NIF_TERM atom_in;
+static ERL_NIF_TERM atom_out;
+static ERL_NIF_TERM atom_in_exiting;
+static ERL_NIF_TERM atom_out_exiting;
+static ERL_NIF_TERM atom_out_exited;
+
+/* process messages 'send' and 'receive' */
+
+static ERL_NIF_TERM atom_send;
+static ERL_NIF_TERM atom_receive;
+static ERL_NIF_TERM atom_send_to_non_existing_process;
+
+/* ports 'ports' */
+
+static ERL_NIF_TERM atom_open;
+static ERL_NIF_TERM atom_closed;
+
+/* 'call' */
+
+static ERL_NIF_TERM atom_call;
+static ERL_NIF_TERM atom_return_from;
+static ERL_NIF_TERM atom_return_to;
+static ERL_NIF_TERM atom_exception_from;
+#endif
+
 static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info)
 {
     atom_true = enif_make_atom(env,"true");
@@ -85,6 +191,61 @@ static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info)
     atom_badarg = enif_make_atom(env,"badarg");
     atom_ok = enif_make_atom(env,"ok");
 
+    atom_trace = enif_make_atom(env,"trace");
+    atom_seq_trace = enif_make_atom(env,"seq_trace");
+    atom_remove = enif_make_atom(env,"remove");
+    atom_discard = enif_make_atom(env,"discard");
+
+#ifdef HAVE_USE_LTTNG
+
+    /* gc */
+
+    atom_gc_minor_start = enif_make_atom(env,"gc_minor_start");
+    atom_gc_minor_end   = enif_make_atom(env,"gc_minor_end");
+    atom_gc_major_start = enif_make_atom(env,"gc_major_start");
+    atom_gc_major_end   = enif_make_atom(env,"gc_major_end");
+
+    atom_old_heap_block_size = enif_make_atom(env,"old_heap_block_size"); 
+    atom_heap_block_size     = enif_make_atom(env,"heap_block_size");
+
+    /* process 'proc' */
+
+    atom_spawn = enif_make_atom(env,"spawn");
+    atom_exit = enif_make_atom(env,"exit");
+    atom_register = enif_make_atom(env,"register");
+    atom_unregister = enif_make_atom(env,"unregister");
+    atom_link = enif_make_atom(env,"link");
+    atom_unlink = enif_make_atom(env,"unlink");
+    atom_getting_unlinked = enif_make_atom(env,"getting_unlinked");
+    atom_getting_linked = enif_make_atom(env,"getting_linked");
+
+    /* process 'running' and 'exiting' */
+
+    atom_in = enif_make_atom(env,"in");
+    atom_out = enif_make_atom(env,"out");
+    atom_in_exiting = enif_make_atom(env,"in_exiting");
+    atom_out_exiting = enif_make_atom(env,"out_exiting");
+    atom_out_exited = enif_make_atom(env,"out_exited");
+
+    /* process messages 'send' and 'receive' */
+
+    atom_send = enif_make_atom(env,"send");
+    atom_receive = enif_make_atom(env,"receive");
+    atom_send_to_non_existing_process = enif_make_atom(env,"send_to_non_existing_process");
+
+    /* ports 'ports' */
+
+    atom_open = enif_make_atom(env,"open");
+    atom_closed = enif_make_atom(env,"closed");
+
+    /* 'call' */
+
+    atom_call = enif_make_atom(env,"call");
+    atom_return_from = enif_make_atom(env,"return_from");
+    atom_return_to = enif_make_atom(env,"return_to");
+    atom_exception_from = enif_make_atom(env,"exception_from");
+#endif
+
     return 0;
 }
 
@@ -123,3 +284,442 @@ static ERL_NIF_TERM user_trace_n(ErlNifEnv* env, int argc, const ERL_NIF_TERM ar
     return atom_error;
 #endif
 }
+
+static ERL_NIF_TERM enabled(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
+{
+#ifdef HAVE_USE_LTTNG
+    ASSERT(argc == 3);
+    return atom_trace;
+#endif
+    return atom_remove;
+}
+
+static ERL_NIF_TERM trace(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    return atom_ok;
+}
+
+#ifdef HAVE_USE_LTTNG
+static ERL_NIF_TERM enabled_garbage_collection(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
+{
+    ASSERT(argc == 3);
+
+    if (argv[0] == atom_gc_minor_start && LTTNG_ENABLED(gc_minor_start)) {
+        return atom_trace;
+    } else if (argv[0] == atom_gc_minor_end && LTTNG_ENABLED(gc_minor_end)) {
+        return atom_trace;
+    } else if (argv[0] == atom_gc_major_start && LTTNG_ENABLED(gc_major_start)) {
+        return atom_trace;
+    } else if (argv[0] == atom_gc_major_end && LTTNG_ENABLED(gc_major_end)) {
+        return atom_trace;
+    }
+
+    return atom_discard;
+}
+
+static ERL_NIF_TERM trace_garbage_collection(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    lttng_decl_procbuf(pid);
+    ERL_NIF_TERM gci, tup;
+    const ERL_NIF_TERM *vals;
+    int arity;
+    unsigned long ohbsz, nhbsz, size;
+
+    ASSERT(argc == 6);
+
+    /* Assume gc info order does not change */
+    gci = argv[3];
+
+    /* get reclaimed or need */
+    enif_get_list_cell(env, gci, &tup, &gci);
+    enif_get_tuple(env, tup, &arity, &vals);
+    ASSERT(arity == 2);
+    enif_get_ulong(env, vals[1], &size);
+
+    /* get old heap block size */
+    enif_get_list_cell(env, gci, &tup, &gci);
+    enif_get_tuple(env, tup, &arity, &vals);
+    ASSERT(arity == 2);
+    ASSERT(vals[0] == atom_old_heap_block_size);
+    enif_get_ulong(env, vals[1], &ohbsz);
+
+    /* get new heap block size */
+    enif_get_list_cell(env, gci, &tup, &gci);
+    enif_get_tuple(env, tup, &arity, &vals);
+    ASSERT(arity == 2);
+    ASSERT(vals[0] == atom_heap_block_size);
+    enif_get_ulong(env, vals[1], &nhbsz);
+
+    lttng_pid_to_str(argv[2], pid);
+
+    if (argv[0] == atom_gc_minor_start) {
+        LTTNG4(gc_minor_start, pid, size, nhbsz, ohbsz);
+    } else if (argv[0] == atom_gc_minor_end) {
+        LTTNG4(gc_minor_end, pid, size, nhbsz, ohbsz);
+    } else if (argv[0] == atom_gc_major_start) {
+        LTTNG4(gc_major_start, pid, size, nhbsz, ohbsz);
+    } else if (argv[0] == atom_gc_major_end) {
+        LTTNG4(gc_major_end, pid, size, nhbsz, ohbsz);
+    }
+    return atom_ok;
+}
+
+static ERL_NIF_TERM enabled_call(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
+{
+    ASSERT(argc == 3);
+
+    if (argv[0] == atom_call && LTTNG_ENABLED(function_call))
+        return atom_trace;
+    else if (argv[0] == atom_return_from && LTTNG_ENABLED(function_return))
+        return atom_trace;
+    else if (argv[0] == atom_exception_from && LTTNG_ENABLED(function_exception))
+        return atom_trace;
+
+    return atom_discard;
+}
+
+static ERL_NIF_TERM trace_call(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    lttng_decl_procbuf(pid);
+    unsigned int len;
+    char undef[] = "undefined";
+
+    lttng_pid_to_str(argv[2], pid);
+
+    if (argv[0] == atom_call) {
+        const ERL_NIF_TERM* tuple;
+        int arity;
+        lttng_decl_mfabuf(mfa);
+
+        if (enif_get_tuple(env, argv[3], &arity, &tuple)) {
+            if (enif_is_list(env, tuple[2])) {
+                enif_get_list_length(env, tuple[2], &len);
+            } else {
+                enif_get_uint(env, tuple[2], &len);
+            }
+            lttng_mfa_to_str(tuple[0], tuple[1], len, mfa);
+            LTTNG3(function_call, pid, mfa, 0);
+        } else {
+            LTTNG3(function_call, pid, undef, 0);
+        }
+    } else if (argv[0] == atom_return_from) {
+        const ERL_NIF_TERM* tuple;
+        int arity;
+        lttng_decl_mfabuf(mfa);
+
+        if (enif_get_tuple(env, argv[3], &arity, &tuple)) {
+            enif_get_uint(env, tuple[2], &len);
+            lttng_mfa_to_str(tuple[0], tuple[1], len, mfa);
+            LTTNG3(function_return, pid, mfa, 0);
+        } else {
+            LTTNG3(function_return, pid, undef, 0);
+        }
+    } else if (argv[0] == atom_return_to) {
+        const ERL_NIF_TERM* tuple;
+        int arity;
+        lttng_decl_mfabuf(mfa);
+
+        if (enif_get_tuple(env, argv[3], &arity, &tuple)) {
+            enif_get_uint(env, tuple[2], &len);
+            lttng_mfa_to_str(tuple[0], tuple[1], len, mfa);
+            LTTNG3(function_return, pid, mfa, 0);
+        } else {
+            LTTNG3(function_return, pid, undef, 0);
+        }
+    } else if (argv[0] == atom_exception_from) {
+        const ERL_NIF_TERM* tuple;
+        int arity;
+        lttng_decl_mfabuf(mfa);
+        char class[LTTNG_BUFFER_SZ];
+
+        enif_get_tuple(env, argv[4], &arity, &tuple);
+        erts_snprintf(class, LTTNG_BUFFER_SZ, "%T", tuple[0]);
+
+        if (enif_get_tuple(env, argv[3], &arity, &tuple)) {
+            enif_get_uint(env, tuple[2], &len);
+            lttng_mfa_to_str(tuple[0], tuple[1], len, mfa);
+            LTTNG3(function_exception, pid, mfa, class);
+        } else {
+            LTTNG3(function_exception, pid, undef, class);
+        }
+    }
+    return atom_ok;
+}
+
+static ERL_NIF_TERM enabled_send(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
+{
+    ASSERT(argc == 3);
+    if (LTTNG_ENABLED(message_send))
+        return atom_trace;
+
+    return atom_discard;
+}
+
+static ERL_NIF_TERM trace_send(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    lttng_decl_procbuf(pid);
+    lttng_pid_to_str(argv[2], pid);
+
+    if (argv[0] == atom_send) {
+        lttng_decl_procbuf(to);
+        char msg[LTTNG_BUFFER_SZ];
+
+        lttng_pid_to_str(argv[4], to);
+        erts_snprintf(msg, LTTNG_BUFFER_SZ, "%T", argv[3]);
+
+        LTTNG3(message_send, pid, to, msg);
+    } else if (argv[0] == atom_send_to_non_existing_process) {
+        lttng_decl_procbuf(to);
+        char msg[LTTNG_BUFFER_SZ];
+
+        lttng_pid_to_str(argv[4], to);
+        erts_snprintf(msg, LTTNG_BUFFER_SZ, "%T", argv[3]);
+        /* mark it as non existing ? */
+
+        LTTNG3(message_send, pid, to, msg);
+    }
+    return atom_ok;
+}
+
+static ERL_NIF_TERM enabled_receive(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
+{
+    if (LTTNG_ENABLED(message_receive))
+        return atom_trace;
+
+    return atom_discard;
+}
+
+static ERL_NIF_TERM trace_receive(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    if (argv[0] == atom_receive) {
+        lttng_decl_procbuf(pid);
+        char msg[LTTNG_BUFFER_SZ];
+
+        lttng_pid_to_str(argv[2], pid);
+        erts_snprintf(msg, LTTNG_BUFFER_SZ, "%T", argv[3]);
+
+        LTTNG2(message_receive, pid, msg);
+    }
+    return atom_ok;
+}
+
+static ERL_NIF_TERM enabled_procs(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
+{
+    ASSERT(argc == 3);
+
+    if (argv[0] == atom_spawn && LTTNG_ENABLED(process_spawn)) {
+        return atom_trace;
+    } else if (argv[0] == atom_register && LTTNG_ENABLED(process_register)) {
+        return atom_trace;
+    } else if (argv[0] == atom_unregister && LTTNG_ENABLED(process_register)) {
+        return atom_trace;
+    } else if (argv[0] == atom_link && LTTNG_ENABLED(process_link)) {
+        return atom_trace;
+    } else if (argv[0] == atom_unlink && LTTNG_ENABLED(process_link)) {
+        return atom_trace;
+    } else if (argv[0] == atom_getting_linked && LTTNG_ENABLED(process_link)) {
+        return atom_trace;
+    } else if (argv[0] == atom_getting_unlinked && LTTNG_ENABLED(process_link)) {
+        return atom_trace;
+    } else if (argv[0] == atom_exit && LTTNG_ENABLED(process_exit)) {
+        return atom_trace;
+    }
+
+    return atom_discard;
+}
+
+static ERL_NIF_TERM trace_procs(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    lttng_decl_procbuf(pid);
+    lttng_decl_procbuf(to);
+
+    lttng_pid_to_str(argv[2], pid);
+
+    /* spawn */
+    if (argv[0] == atom_spawn) {
+        char undef[] = "undefined";
+        const ERL_NIF_TERM* tuple;
+        int arity;
+        unsigned int len;
+        lttng_decl_mfabuf(mfa);
+
+        lttng_pid_to_str(argv[3], to);
+
+        if (enif_get_tuple(env, argv[4], &arity, &tuple)) {
+            if (enif_is_list(env, tuple[2])) {
+                enif_get_list_length(env, tuple[2], &len);
+            } else {
+                enif_get_uint(env, tuple[2], &len);
+            }
+            lttng_mfa_to_str(tuple[0], tuple[1], len, mfa);
+            LTTNG3(process_spawn, to, pid, mfa);
+        } else {
+            LTTNG3(process_spawn, to, pid, undef);
+        }
+
+    /* register */
+    } else if (argv[0] == atom_register) {
+        char name[LTTNG_BUFFER_SZ];
+        erts_snprintf(name, LTTNG_BUFFER_SZ, "%T", argv[3]);
+        LTTNG3(process_register, pid, name, "register");
+    } else if (argv[0] == atom_unregister) {
+        char name[LTTNG_BUFFER_SZ];
+        erts_snprintf(name, LTTNG_BUFFER_SZ, "%T", argv[3]);
+        LTTNG3(process_register, pid, name, "unregister");
+    /* link */
+    } else if (argv[0] == atom_link) {
+        lttng_pid_to_str(argv[3], to);
+        LTTNG3(process_link, pid, to, "link");
+    } else if (argv[0] == atom_unlink) {
+        lttng_pid_to_str(argv[3], to);
+        LTTNG3(process_link, pid, to, "unlink");
+    } else if (argv[0] == atom_getting_linked) {
+        lttng_pid_to_str(argv[3], to);
+        LTTNG3(process_link, to, pid, "link");
+    } else if (argv[0] == atom_getting_unlinked) {
+        lttng_pid_to_str(argv[3], to);
+        LTTNG3(process_link, to, pid, "unlink");
+    /* exit */
+    } else if (argv[0] == atom_exit) {
+        char reason[LTTNG_BUFFER_SZ];
+        erts_snprintf(reason, LTTNG_BUFFER_SZ, "%T", argv[3]);
+        LTTNG2(process_exit, pid, reason);
+    }
+    return atom_ok;
+}
+
+static ERL_NIF_TERM enabled_ports(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
+{
+    ASSERT(argc == 3);
+
+    if (argv[0] == atom_open && LTTNG_ENABLED(port_open)) {
+        return atom_trace;
+    } else if (argv[0] == atom_link && LTTNG_ENABLED(port_link)) {
+        return atom_trace;
+    } else if (argv[0] == atom_unlink && LTTNG_ENABLED(port_link)) {
+        return atom_trace;
+    } else if (argv[0] == atom_getting_linked && LTTNG_ENABLED(port_link)) {
+        return atom_trace;
+    } else if (argv[0] == atom_getting_unlinked && LTTNG_ENABLED(port_link)) {
+        return atom_trace;
+    } else if (argv[0] == atom_closed && LTTNG_ENABLED(port_exit)) {
+        return atom_trace;
+    }
+
+    return atom_discard;
+}
+
+static ERL_NIF_TERM trace_ports(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    lttng_decl_portbuf(port);
+    lttng_decl_procbuf(to);
+
+    lttng_portid_to_str(argv[2], port);
+
+    /* open and closed */
+    if (argv[0] == atom_open) {
+        char driver[LTTNG_BUFFER_SZ];
+        lttng_decl_procbuf(pid);
+        lttng_pid_to_str(argv[3], pid);
+
+        erts_snprintf(driver, LTTNG_BUFFER_SZ, "%T", argv[4]);
+        LTTNG3(port_open, pid, driver, port);
+    } else if (argv[0] == atom_closed) {
+        char reason[LTTNG_BUFFER_SZ];
+        erts_snprintf(reason, LTTNG_BUFFER_SZ, "%T", argv[3]);
+
+        LTTNG2(port_exit, port, reason);
+    /* link */
+    } else if (argv[0] == atom_link) {
+        lttng_pid_to_str(argv[3], to);
+        LTTNG3(port_link, port, to, "link");
+    } else if (argv[0] == atom_unlink) {
+        lttng_pid_to_str(argv[3], to);
+        LTTNG3(port_link, port, to, "unlink");
+    } else if (argv[0] == atom_getting_linked) {
+        lttng_pid_to_str(argv[3], to);
+        LTTNG3(port_link, to, port, "link");
+    } else if (argv[0] == atom_getting_unlinked) {
+        lttng_pid_to_str(argv[3], to);
+        LTTNG3(port_link, to, port, "unlink");
+    }
+    return atom_ok;
+}
+
+static ERL_NIF_TERM enabled_running_procs(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
+{
+    ASSERT(argc == 3);
+
+    if (LTTNG_ENABLED(process_scheduled))
+        return atom_trace;
+ 
+    return atom_discard;
+}
+
+static ERL_NIF_TERM trace_running_procs(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    lttng_decl_procbuf(pid);
+    const ERL_NIF_TERM* tuple;
+    char *mfastr = "undefined";
+    int arity;
+    lttng_decl_mfabuf(mfa);
+
+    lttng_pid_to_str(argv[2], pid);
+
+    if (enif_get_tuple(env, argv[3], &arity, &tuple)) {
+        int val;
+        enif_get_int(env, tuple[2], &val);
+        lttng_mfa_to_str(tuple[0], tuple[1], val, mfa);
+        mfastr = mfa;
+    }
+    /* running processes */
+    if (argv[0] == atom_in) {
+        LTTNG3(process_scheduled, pid, mfastr, "in");
+    } else if (argv[0] == atom_out) {
+        LTTNG3(process_scheduled, pid, mfastr, "out");
+    /* exiting */
+    } else if (argv[0] == atom_in_exiting) {
+        LTTNG3(process_scheduled, pid, mfastr, "in_exiting");
+    } else if (argv[0] == atom_out_exiting) {
+        LTTNG3(process_scheduled, pid, mfastr, "out_exiting");
+    } else if (argv[0] == atom_out_exited) {
+        LTTNG3(process_scheduled, pid, mfastr, "out_exited");
+    }
+
+    return atom_ok;
+}
+
+static ERL_NIF_TERM enabled_running_ports(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
+{
+    ASSERT(argc == 3);
+
+    if (LTTNG_ENABLED(port_scheduled))
+        return atom_trace;
+
+    return atom_discard;
+}
+
+static ERL_NIF_TERM trace_running_ports(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    lttng_decl_procbuf(pid);
+    lttng_decl_mfabuf(where);
+
+    lttng_portid_to_str(argv[2], pid);
+    erts_snprintf(where, LTTNG_BUFFER_SZ, "%T", argv[3]);
+
+    /* running  ports */
+    if (argv[0] == atom_in) {
+        LTTNG3(port_scheduled, pid, where, "in");
+    } else if (argv[0] == atom_out) {
+        LTTNG3(port_scheduled, pid, where, "out");
+        /* exiting */
+    } else if (argv[0] == atom_in_exiting) {
+        LTTNG3(port_scheduled, pid, where, "in_exiting");
+    } else if (argv[0] == atom_out_exiting) {
+        LTTNG3(port_scheduled, pid, where, "out_exiting");
+    } else if (argv[0] == atom_out_exited) {
+        LTTNG3(port_scheduled, pid, where, "out_exited");
+    }
+    return atom_ok;
+}
+#endif
diff --git a/lib/runtime_tools/c_src/dyntrace_lttng.h b/lib/runtime_tools/c_src/dyntrace_lttng.h
new file mode 100644
index 0000000000..3550a1cab5
--- /dev/null
+++ b/lib/runtime_tools/c_src/dyntrace_lttng.h
@@ -0,0 +1,367 @@
+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson AB 2016. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * %CopyrightEnd%
+ */
+
+#undef TRACEPOINT_PROVIDER
+#define TRACEPOINT_PROVIDER com_ericsson_dyntrace
+
+#if !defined(DYNTRACE_LTTNG_H) || defined(TRACEPOINT_HEADER_MULTI_READ)
+#define DYNTRACE_LTTNG_H
+
+#include <lttng/tracepoint.h>
+
+#define LTTNG1(Name, Arg1) \
+    tracepoint(com_ericsson_dyntrace, Name, (Arg1))
+
+#define LTTNG2(Name, Arg1, Arg2) \
+    tracepoint(com_ericsson_dyntrace, Name, (Arg1), (Arg2))
+
+#define LTTNG3(Name, Arg1, Arg2, Arg3) \
+    tracepoint(com_ericsson_dyntrace, Name, (Arg1), (Arg2), (Arg3))
+
+#define LTTNG4(Name, Arg1, Arg2, Arg3, Arg4) \
+    tracepoint(com_ericsson_dyntrace, Name, (Arg1), (Arg2), (Arg3), (Arg4))
+
+#define LTTNG5(Name, Arg1, Arg2, Arg3, Arg4, Arg5) \
+    tracepoint(com_ericsson_dyntrace, Name, (Arg1), (Arg2), (Arg3), (Arg4), (Arg5))
+
+#define LTTNG_ENABLED(Name) \
+    tracepoint_enabled(com_ericsson_dyntrace, Name)
+
+#define LTTNG_BUFFER_SZ      (256)
+#define LTTNG_PROC_BUFFER_SZ (16)
+#define LTTNG_PORT_BUFFER_SZ (20)
+#define LTTNG_MFA_BUFFER_SZ  (256)
+
+#define lttng_decl_procbuf(Name) \
+    char Name[LTTNG_PROC_BUFFER_SZ]
+
+#define lttng_decl_portbuf(Name) \
+    char Name[LTTNG_PORT_BUFFER_SZ]
+
+#define lttng_decl_mfabuf(Name) \
+    char Name[LTTNG_MFA_BUFFER_SZ]
+
+#define lttng_pid_to_str(pid, name) \
+    erts_snprintf(name, LTTNG_PROC_BUFFER_SZ, "%T", (pid))
+
+#define lttng_portid_to_str(pid, name) \
+    erts_snprintf(name, LTTNG_PORT_BUFFER_SZ, "%T", (pid))
+
+#define lttng_proc_to_str(p, name) \
+    lttng_pid_to_str(((p) ? (p)->common.id : ERTS_INVALID_PID), name)
+
+#define lttng_port_to_str(p, name) \
+    lttng_portid_to_str(((p) ? (p)->common.id : ERTS_INVALID_PORT), name)
+
+#define lttng_mfa_to_str(m,f,a, Name) \
+    erts_snprintf(Name, LTTNG_MFA_BUFFER_SZ, "%T:%T/%lu", (Eterm)(m), (Eterm)(f), (Uint)(a))
+
+/* Process scheduling */
+
+TRACEPOINT_EVENT(
+    com_ericsson_dyntrace,
+    process_spawn,
+    TP_ARGS(
+        char*, p,
+        char*, parent,
+        char*, mfa
+    ),
+    TP_FIELDS(
+        ctf_string(pid, p)
+        ctf_string(parent, parent)
+        ctf_string(entry, mfa)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_dyntrace,
+    process_link,
+    TP_ARGS(
+        char*, from,
+        char*, to,
+        char*, type
+    ),
+    TP_FIELDS(
+        ctf_string(from, from)
+        ctf_string(to, to)
+        ctf_string(type, type)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_dyntrace,
+    process_exit,
+    TP_ARGS(
+        char*, p,
+        char*, reason
+    ),
+    TP_FIELDS(
+        ctf_string(pid, p)
+        ctf_string(reason, reason)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_dyntrace,
+    process_register,
+    TP_ARGS(
+        char*, pid,
+        char*, name,
+        char*, type
+    ),
+    TP_FIELDS(
+        ctf_string(pid, pid)
+        ctf_string(name, name)
+        ctf_string(type, type)
+    )
+)
+
+/* Scheduled */
+
+TRACEPOINT_EVENT(
+    com_ericsson_dyntrace,
+    process_scheduled,
+    TP_ARGS(
+        char*, p,
+        char*, mfa,
+        char*, type
+    ),
+    TP_FIELDS(
+        ctf_string(pid, p)
+        ctf_string(entry, mfa)
+        ctf_string(type, type)
+    )
+)
+
+/* Ports */
+
+
+TRACEPOINT_EVENT(
+    com_ericsson_dyntrace,
+    port_open,
+    TP_ARGS(
+        char*, pid,
+        char*, driver,
+        char*, port
+    ),
+    TP_FIELDS(
+        ctf_string(pid, pid)
+        ctf_string(driver, driver)
+        ctf_string(port, port)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_dyntrace,
+    port_exit,
+    TP_ARGS(
+        char*, port,
+        char*, reason
+    ),
+    TP_FIELDS(
+        ctf_string(port, port)
+        ctf_string(reason, reason)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_dyntrace,
+    port_link,
+    TP_ARGS(
+        char*, from,
+        char*, to,
+        char*, type
+    ),
+    TP_FIELDS(
+        ctf_string(from, from)
+        ctf_string(to, to)
+        ctf_string(type, type)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_dyntrace,
+    port_scheduled,
+    TP_ARGS(
+        char*, p,
+        char*, op,
+        char*, type
+    ),
+    TP_FIELDS(
+        ctf_string(pid, p)
+        ctf_string(entry, op)
+        ctf_string(type, type)
+    )
+)
+
+/* Call tracing */
+
+TRACEPOINT_EVENT(
+    com_ericsson_dyntrace,
+    function_call,
+    TP_ARGS(
+        char*, pid,
+        char*, mfa,
+        unsigned int, depth
+    ),
+    TP_FIELDS(
+        ctf_string(pid, pid)
+        ctf_string(entry, mfa)
+        ctf_integer(unsigned int, depth, depth)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_dyntrace,
+    function_return,
+    TP_ARGS(
+        char*, pid,
+        char*, mfa,
+        unsigned int, depth
+    ),
+    TP_FIELDS(
+        ctf_string(pid, pid)
+        ctf_string(entry, mfa)
+        ctf_integer(unsigned int, depth, depth)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_dyntrace,
+    function_exception,
+    TP_ARGS(
+        char*, pid,
+        char*, mfa,
+        char*, type
+    ),
+    TP_FIELDS(
+        ctf_string(pid, pid)
+        ctf_string(entry, mfa)
+        ctf_string(class, type)
+    )
+)
+
+/* Process messages */
+
+TRACEPOINT_EVENT(
+    com_ericsson_dyntrace,
+    message_send,
+    TP_ARGS(
+        char*, sender,
+        char*, receiver,
+        char*, msg
+    ),
+    TP_FIELDS(
+        ctf_string(from, sender)
+        ctf_string(to, receiver)
+        ctf_string(message, msg)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_dyntrace,
+    message_receive,
+    TP_ARGS(
+        char*, receiver,
+        char*, msg
+    ),
+    TP_FIELDS(
+        ctf_string(to, receiver)
+        ctf_string(message, msg)
+    )
+)
+
+/* Process Memory */
+
+TRACEPOINT_EVENT(
+    com_ericsson_dyntrace,
+    gc_minor_start,
+    TP_ARGS(
+        char*, p,
+        unsigned long, need,
+        unsigned long, nh,
+        unsigned long, oh
+    ),
+    TP_FIELDS(
+        ctf_string(pid, p)
+        ctf_integer(unsigned long, need, need)
+        ctf_integer(unsigned long, heap, nh)
+        ctf_integer(unsigned long, old_heap, oh)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_dyntrace,
+    gc_minor_end,
+    TP_ARGS(
+        char*, p,
+        unsigned long, reclaimed,
+        unsigned long, nh,
+        unsigned long, oh
+    ),
+    TP_FIELDS(
+        ctf_string(pid, p)
+        ctf_integer(unsigned long, reclaimed, reclaimed)
+        ctf_integer(unsigned long, heap, nh)
+        ctf_integer(unsigned long, old_heap, oh)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_dyntrace,
+    gc_major_start,
+    TP_ARGS(
+        char*, p,
+        unsigned long, need,
+        unsigned long, nh,
+        unsigned long, oh
+    ),
+    TP_FIELDS(
+        ctf_string(pid, p)
+        ctf_integer(unsigned long, need, need)
+        ctf_integer(unsigned long, heap, nh)
+        ctf_integer(unsigned long, old_heap, oh)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_dyntrace,
+    gc_major_end,
+    TP_ARGS(
+        char*, p,
+        unsigned long, reclaimed,
+        unsigned long, nh,
+        unsigned long, oh
+    ),
+    TP_FIELDS(
+        ctf_string(pid, p)
+        ctf_integer(unsigned long, reclaimed, reclaimed)
+        ctf_integer(unsigned long, heap, nh)
+        ctf_integer(unsigned long, old_heap, oh)
+    )
+)
+
+#endif /* DYNTRACE_LTTNG_H */
+
+#undef TRACEPOINT_INCLUDE
+#define TRACEPOINT_INCLUDE "./dyntrace_lttng.h"
+
+/* This part must be outside protection */
+#include <lttng/tracepoint-event.h>
diff --git a/lib/runtime_tools/doc/src/LTTng.xml b/lib/runtime_tools/doc/src/LTTng.xml
new file mode 100644
index 0000000000..eab1848e88
--- /dev/null
+++ b/lib/runtime_tools/doc/src/LTTng.xml
@@ -0,0 +1,245 @@
+<?xml version="1.0" encoding="utf8" ?>
+<!DOCTYPE chapter SYSTEM "chapter.dtd">
+<chapter>
+    <header>
+        <copyright>
+            <year>2016</year><year>2016</year>
+            <holder>Ericsson AB. All Rights Reserved.</holder>
+        </copyright>
+        <legalnotice>
+            Licensed under the Apache License, Version 2.0 (the "License");
+            you may not use this file except in compliance with the License.
+            You may obtain a copy of the License at
+
+            http://www.apache.org/licenses/LICENSE-2.0
+
+            Unless required by applicable law or agreed to in writing, software
+            distributed under the License is distributed on an "AS IS" BASIS,
+            WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+            See the License for the specific language governing permissions and
+            limitations under the License.
+        </legalnotice>
+
+        <title>LTTng and Erlang/OTP</title>
+        <prepared></prepared>
+        <responsible></responsible>
+        <docno></docno>
+        <approved></approved>
+        <checked></checked>
+        <date>2016-04-27</date>
+        <rev></rev>
+        <file>LTTng.xml</file>
+    </header>
+
+    <section>
+        <title>Introduction</title>
+        <p>The Linux Trace Toolkit: next generation is an open source system software package
+            for correlated tracing of the Linux kernel, user applications and libraries. </p>
+        <p>For more information, please visit <url href="http://lttng.org">http://lttng.org</url></p>
+    </section>
+
+    <section>
+        <title>Building Erlang/OTP with LTTng support</title>
+        <p>
+            Configure and build Erlang with LTTng support:
+        </p>
+        <p>For LTTng to work properly with Erlang/OTP you need
+            the following packages installed:</p>
+
+      <list type="bulleted">
+          <item><p>LTTng-tools: a command line interface to control tracing sessions.</p></item>
+          <item><p>LTTng-UST: user space tracing library.</p></item>
+      </list>
+
+      <p>On Ubuntu this can be installed via <c>aptitude</c>:</p>
+
+      <code type="none">$ sudo aptitude install lttng-tools liblttng-ust-dev</code>
+      <p>See <url href="http://lttng.org/docs/#doc-installing-lttng">Installing LTTng</url>
+          for more information on how to install LTTng on your system.</p>
+
+      <p>After LTTng is properly installed on the system Erlang/OTP can be built with LTTng support.</p>
+ 
+
+<code type="none">$ ./configure --with-dynamic-trace=lttng
+$ make </code>
+    </section>
+
+    <section>
+        <title>Dyntrace Tracepoints</title>
+        <p>All tracepoints are in the domain of <c>com_ericsson_dyntrace</c></p>
+        <p>All Erlang types are the string equivalent in LTTng.</p>
+
+        <p><em>process_spawn</em></p>
+        <list type="bulleted">
+            <item><c>pid : string</c> :: Process ID. Ex. <c>"&lt;0.131.0&gt;"</c></item>
+            <item><c>parent : string</c> :: Process ID. Ex. <c>"&lt;0.131.0&gt;"</c></item>
+            <item><c>entry : string</c> :: Code Location. Ex. <c>"lists:sort/1"</c></item>
+        </list>
+        <p>Example:</p>
+        <p><code type="none">process_spawn: { cpu_id = 3 }, { pid = "&lt;0.131.0&gt;", parent = "&lt;0.130.0&gt;", entry = "erlang:apply/2" }</code></p>
+
+        <p><em>process_link</em></p>
+        <list type="bulleted">
+            <item><c>to : string</c> :: Process ID or Port ID. Ex. <c>"&lt;0.131.0&gt;"</c></item>
+            <item><c>from : string</c> :: Process ID or Port ID. Ex. <c>"&lt;0.131.0&gt;"</c></item>
+            <item><c>type : string</c> :: <c>"link" | "unlink"</c></item>
+        </list>
+        <p>Example:</p>
+        <p><code type="none">process_link: { cpu_id = 3 }, { from = "&lt;0.130.0&gt;", to = "&lt;0.131.0&gt;", type = "link" }</code></p>
+
+
+        <p><em>process_exit</em></p>
+        <list type="bulleted">
+            <item><c>pid : string</c> :: Process ID. Ex. <c>"&lt;0.131.0&gt;"</c></item>
+            <item><c>reason : string</c> :: Exit reason. Ex. <c>"normal"</c></item>
+        </list>
+        <p>Example:</p>
+        <p><code type="none">process_exit: { cpu_id = 3 }, { pid = "&lt;0.130.0&gt;", reason = "normal" }</code></p>
+
+        <p><em>process_register</em></p>
+        <list type="bulleted">
+            <item><c>pid : string</c> :: Process ID. Ex. <c>"&lt;0.131.0&gt;"</c></item>
+            <item><c>name : string</c> :: Registered name. Ex. <c>"error_logger"</c></item>
+            <item><c>type : string</c> :: <c>"register" | "unregister"</c></item>
+        </list>
+        <p>Example:</p>
+        <p><code type="none">process_register: { cpu_id = 0 }, { pid = "&lt;0.128.0&gt;", name = "dyntrace_lttng_SUITE" type = "register" }</code></p>
+
+        <p><em>process_scheduled</em></p>
+        <list type="bulleted">
+            <item><c>pid : string</c> :: Process ID. Ex. <c>"&lt;0.131.0&gt;"</c></item>
+            <item><c>entry : string</c> :: Code Location. Ex. <c>"lists:sort/1"</c></item>
+            <item><c>type : string</c> :: <c>"in" | "out" | "in_exiting" | "out_exiting" | "out_exited"</c></item>
+        </list>
+
+        <p>Example:</p>
+        <p><code type="none">process_scheduled: { cpu_id = 0 }, { pid = "&lt;0.136.0&gt;", entry = "erlang:apply/2", type = "in" }</code></p>
+
+
+        <p><em>port_open</em></p>
+        <list type="bulleted">
+            <item><c>pid : string</c> :: Process ID. Ex. <c>"&lt;0.131.0&gt;"</c></item>
+            <item><c>driver : string</c> :: Driver name. Ex. <c>"efile"</c></item>
+            <item><c>port : string</c> :: Port ID. Ex. <c>"#Port&lt;0.1031&gt;"</c></item>
+        </list>
+
+        <p>Example:</p>
+        <p><code type="none">port_open: { cpu_id = 5 }, { pid = "&lt;0.131.0&gt;", driver = "'/bin/sh -s unix:cmd'", port = "#Port&lt;0.1887&gt;" }</code></p>
+
+        <p><em>port_exit</em></p>
+        <list type="bulleted">
+            <item><c>port : string</c> :: Port ID. Ex. <c>"#Port&lt;0.1031&gt;"</c></item>
+            <item><c>reason : string</c> :: Exit reason. Ex. <c>"normal"</c></item>
+        </list>
+        <p>Example:</p>
+        <p><code type="none">port_exit: { cpu_id = 5 }, { port = "#Port&lt;0.1887&gt;", reason = "normal" }</code></p>
+
+        <p><em>port_link</em></p>
+        <list type="bulleted">
+            <item><c>to : string</c> :: Process ID. Ex. <c>"&lt;0.131.0&gt;"</c></item>
+            <item><c>from : string</c> :: Process ID. Ex. <c>"&lt;0.131.0&gt;"</c></item>
+            <item><c>type : string</c> :: <c>"link" | "unlink"</c></item>
+        </list>
+        <p>Example:</p>
+        <p><code type="none">port_link: { cpu_id = 5 }, { from = "#Port&lt;0.1887&gt;", to = "&lt;0.131.0&gt;", type = "unlink" }</code></p>
+
+        <p><em>port_scheduled</em></p>
+        <list type="bulleted">
+            <item><c>port : string</c> :: Port ID. Ex. <c>"#Port&lt;0.1031&gt;"</c></item>
+            <item><c>entry : string</c> :: Callback. Ex. <c>"open"</c></item>
+            <item><c>type : string</c> :: <c>"in" | "out" | "in_exiting" | "out_exiting" | "out_exited"</c></item>
+        </list>
+
+        <p>Example:</p>
+        <p><code type="none">port_scheduled: { cpu_id = 5 }, { pid = "#Port&lt;0.1905&gt;", entry = "close", type = "out" }</code></p>
+
+        <p><em>function_call</em></p>
+        <list type="bulleted">
+            <item><c>pid : string</c> :: Process ID. Ex. <c>"&lt;0.131.0&gt;"</c></item>
+            <item><c>entry : string</c> :: Code Location. Ex. <c>"lists:sort/1"</c></item>
+            <item><c>depth : integer</c> :: Stack depth. Ex. <c>0</c></item>
+        </list>
+        <p>Example:</p>
+        <p><code type="none">function_call: { cpu_id = 5 }, { pid = "&lt;0.145.0&gt;", entry = "dyntrace_lttng_SUITE:'-t_call/1-fun-1-'/0", depth = 0 }</code></p>
+
+        <p><em>function_return</em></p>
+        <list type="bulleted">
+            <item><c>pid : string</c> :: Process ID. Ex. <c>"&lt;0.131.0&gt;"</c></item>
+            <item><c>entry : string</c> :: Code Location. Ex. <c>"lists:sort/1"</c></item>
+            <item><c>depth : integer</c> :: Stack depth. Ex. <c>0</c></item>
+        </list>
+        <p>Example:</p>
+        <p><code type="none">function_return: { cpu_id = 5 }, { pid = "&lt;0.145.0&gt;", entry = "dyntrace_lttng_SUITE:waiter/0", depth = 0 }</code></p>
+
+        <p><em>function_exception</em></p>
+        <list type="bulleted">
+            <item><c>pid : string</c> :: Process ID. Ex. <c>"&lt;0.131.0&gt;"</c></item>
+            <item><c>entry : string</c> :: Code Location. Ex. <c>"lists:sort/1"</c></item>
+            <item><c>class : string</c> :: Error reason. Ex. <c>"error"</c></item>
+        </list>
+        <p>Example:</p>
+        <p><code type="none">function_exception: { cpu_id = 5 }, { pid = "&lt;0.144.0&gt;", entry = "t:call_exc/1", class = "error" }</code></p>
+
+        <p><em>message_send</em></p>
+        <list type="bulleted">
+            <item><c>from : string</c> :: Process ID or Port ID. Ex. <c>"&lt;0.131.0&gt;"</c></item>
+            <item><c>to : string</c> :: Process ID or Port ID. Ex. <c>"&lt;0.131.0&gt;"</c></item>
+            <item><c>message : string</c> :: Message sent. Ex. <c>"{&lt;0.162.0&gt;,ok}"</c></item>
+        </list>
+        <p>Example:</p>
+        <p><code type="none">message_send: { cpu_id = 3 }, { from = "#Port&lt;0.1938&gt;", to = "&lt;0.160.0&gt;", message = "{#Port&lt;0.1938&gt;,eof}" }</code></p>
+
+        <p><em>message_receive</em></p>
+        <list type="bulleted">
+            <item><c>to : string</c> :: Process ID or Port ID. Ex. <c>"&lt;0.131.0&gt;"</c></item>
+            <item><c>message : string</c> :: Message received. Ex. <c>"{&lt;0.162.0&gt;,ok}"</c></item>
+        </list>
+        <p>Example:</p>
+        <p><code type="none">message_receive: { cpu_id = 7 }, { to = "&lt;0.167.0&gt;", message = "{&lt;0.165.0&gt;,ok}" }</code></p>
+
+        <p><em>gc_minor_start</em></p>
+        <list type="bulleted">
+            <item><c>pid : string</c> :: Process ID. Ex. <c>"&lt;0.131.0&gt;"</c></item>
+            <item><c>need : integer</c> :: Heap need. Ex. <c>2</c></item>
+            <item><c>heap : integer</c> :: Young heap word size. Ex. <c>233</c></item>
+            <item><c>old_heap : integer</c> :: Old heap word size. Ex. <c>233</c></item>
+        </list>
+        <p>Example:</p>
+        <p><code type="none">gc_minor_start: { cpu_id = 0 }, { pid = "&lt;0.172.0&gt;", need = 0, heap = 610, old_heap = 0 }</code></p>
+
+        <p><em>gc_minor_end</em></p>
+        <list type="bulleted">
+            <item><c>pid : string</c> :: Process ID. Ex. <c>"&lt;0.131.0&gt;"</c></item>
+            <item><c>reclaimed : integer</c> :: Heap reclaimed. Ex. <c>2</c></item>
+            <item><c>heap : integer</c> :: Young heap word size. Ex. <c>233</c></item>
+            <item><c>old_heap : integer</c> :: Old heap word size. Ex. <c>233</c></item>
+        </list>
+        <p>Example:</p>
+        <p><code type="none">gc_minor_end: { cpu_id = 0 }, { pid = "&lt;0.172.0&gt;", reclaimed = 120, heap = 1598, old_heap = 1598 }</code></p>
+
+        <p><em>gc_major_start</em></p>
+        <list type="bulleted">
+            <item><c>pid : string</c> :: Process ID. Ex. <c>"&lt;0.131.0&gt;"</c></item>
+            <item><c>need : integer</c> :: Heap need. Ex. <c>2</c></item>
+            <item><c>heap : integer</c> :: Young heap word size. Ex. <c>233</c></item>
+            <item><c>old_heap : integer</c> :: Old heap word size. Ex. <c>233</c></item>
+        </list>
+        <p>Example:</p>
+        <p><code type="none">gc_major_start: { cpu_id = 0 }, { pid = "&lt;0.172.0&gt;", need = 8, heap = 2586, old_heap = 1598 }</code></p>
+
+        <p><em>gc_major_end</em></p>
+        <list type="bulleted">
+            <item><c>pid : string</c> :: Process ID. Ex. <c>"&lt;0.131.0&gt;"</c></item>
+            <item><c>reclaimed : integer</c> :: Heap reclaimed. Ex. <c>2</c></item>
+            <item><c>heap : integer</c> :: Young heap word size. Ex. <c>233</c></item>
+            <item><c>old_heap : integer</c> :: Old heap word size. Ex. <c>233</c></item>
+        </list>
+        <p>Example:</p>
+        <p><code type="none">gc_major_end: { cpu_id = 0 }, { pid = "&lt;0.172.0&gt;", reclaimed = 240, heap = 4185, old_heap = 0 }</code></p>
+
+    </section>
+
+    <section>
+        <title>Examples</title>
+    </section>
+</chapter>
diff --git a/lib/runtime_tools/doc/src/Makefile b/lib/runtime_tools/doc/src/Makefile
index 0a590ff9ec..5ce40bb995 100644
--- a/lib/runtime_tools/doc/src/Makefile
+++ b/lib/runtime_tools/doc/src/Makefile
@@ -45,7 +45,7 @@ XML_REF3_FILES = dbg.xml dyntrace.xml erts_alloc_config.xml system_information.x
 XML_REF6_FILES = runtime_tools_app.xml
 
 XML_PART_FILES = part_notes.xml part_notes_history.xml part.xml
-XML_CHAPTER_FILES = notes.xml notes_history.xml
+XML_CHAPTER_FILES = notes.xml notes_history.xml LTTng.xml
 
 GENERATED_XML_FILES = DTRACE.xml SYSTEMTAP.xml
 
diff --git a/lib/runtime_tools/doc/src/part.xml b/lib/runtime_tools/doc/src/part.xml
index 14e8b71c83..34acf69fc8 100644
--- a/lib/runtime_tools/doc/src/part.xml
+++ b/lib/runtime_tools/doc/src/part.xml
@@ -34,6 +34,7 @@
       <p><em>Runtime Tools</em></p>
   </description>
 
+  <xi:include href="LTTng.xml"/>
   <xi:include href="DTRACE.xml"/>
   <xi:include href="SYSTEMTAP.xml"/>
 </part>
diff --git a/lib/runtime_tools/src/dyntrace.erl b/lib/runtime_tools/src/dyntrace.erl
index f7dbef6929..28e6d67d96 100644
--- a/lib/runtime_tools/src/dyntrace.erl
+++ b/lib/runtime_tools/src/dyntrace.erl
@@ -41,6 +41,28 @@
          pn/1, pn/2, pn/3, pn/4, pn/5, pn/6, pn/7, pn/8, pn/9]).
 -export([put_tag/1, get_tag/0, get_tag_data/0, spread_tag/1, restore_tag/1]).
 
+-export([trace/5,
+         trace/6,
+         trace_procs/6,
+         trace_ports/6,
+         trace_running_procs/6,
+         trace_running_ports/6,
+         trace_call/6,
+         trace_send/6,
+         trace_receive/6,
+         trace_garbage_collection/6]).
+
+-export([enabled_procs/3,
+         enabled_ports/3,
+         enabled_running_procs/3,
+         enabled_running_ports/3,
+         enabled_call/3,
+         enabled_send/3,
+         enabled_receive/3,
+         enabled_garbage_collection/3,
+         enabled/3]).
+
+
 -export([user_trace_i4s4/9]). % Know what you're doing!
 -on_load(on_load/0).
 
@@ -125,6 +147,63 @@ user_trace_i4s4(_, _, _, _, _, _, _, _, _) ->
 user_trace_n(_, _, _, _, _, _, _, _, _, _) ->
     erlang:nif_error(nif_not_loaded).
 
+trace(_TracerState, _Label, _SeqTraceInfo, _, _Opts) ->
+    erlang:nif_error(nif_not_loaded).
+
+trace(_TraceTag, _TracerState, _Tracee, _FirstTraceTerm, _SecondTraceTerm, _Opts) ->
+    erlang:nif_error(nif_not_loaded).
+
+trace_procs(_TraceTag, _TracerState, _Tracee, _FirstTraceTerm, _SecondTraceTerm, _Opts) ->
+    erlang:nif_error(nif_not_loaded).
+
+trace_ports(_TraceTag, _TracerState, _Tracee, _FirstTraceTerm, _SecondTraceTerm, _Opts) ->
+    erlang:nif_error(nif_not_loaded).
+
+trace_running_procs(_TraceTag, _TracerState, _Tracee, _FirstTraceTerm, _SecondTraceTerm, _Opts) ->
+    erlang:nif_error(nif_not_loaded).
+
+trace_running_ports(_TraceTag, _TracerState, _Tracee, _FirstTraceTerm, _SecondTraceTerm, _Opts) ->
+    erlang:nif_error(nif_not_loaded).
+
+trace_call(_TraceTag, _TracerState, _Tracee, _FirstTraceTerm, _SecondTraceTerm, _Opts) ->
+    erlang:nif_error(nif_not_loaded).
+
+trace_send(_TraceTag, _TracerState, _Tracee, _FirstTraceTerm, _SecondTraceTerm, _Opts) ->
+    erlang:nif_error(nif_not_loaded).
+
+trace_receive(_TraceTag, _TracerState, _Tracee, _FirstTraceTerm, _SecondTraceTerm, _Opts) ->
+    erlang:nif_error(nif_not_loaded).
+
+trace_garbage_collection(_TraceTag, _TracerState, _Tracee, _FirstTraceTerm, _SecondTraceTerm, _Opts) ->
+    erlang:nif_error(nif_not_loaded).
+
+enabled(_TraceTag, _TracerState, _Tracee) ->
+    erlang:nif_error(nif_not_loaded).
+
+enabled_procs(_TraceTag, _TracerState, _Tracee) ->
+    erlang:nif_error(nif_not_loaded).
+
+enabled_ports(_TraceTag, _TracerState, _Tracee) ->
+    erlang:nif_error(nif_not_loaded).
+
+enabled_running_procs(_TraceTag, _TracerState, _Tracee) ->
+    erlang:nif_error(nif_not_loaded).
+
+enabled_running_ports(_TraceTag, _TracerState, _Tracee) ->
+    erlang:nif_error(nif_not_loaded).
+
+enabled_call(_TraceTag, _TracerState, _Tracee) ->
+    erlang:nif_error(nif_not_loaded).
+
+enabled_send(_TraceTag, _TracerState, _Tracee) ->
+    erlang:nif_error(nif_not_loaded).
+
+enabled_receive(_TraceTag, _TracerState, _Tracee) ->
+    erlang:nif_error(nif_not_loaded).
+
+enabled_garbage_collection(_TraceTag, _TracerState, _Tracee) ->
+    erlang:nif_error(nif_not_loaded).
+
 %%%
 %%% Erlang support functions
 %%%
diff --git a/lib/runtime_tools/test/Makefile b/lib/runtime_tools/test/Makefile
index 432a361468..61377ea09e 100644
--- a/lib/runtime_tools/test/Makefile
+++ b/lib/runtime_tools/test/Makefile
@@ -4,6 +4,7 @@ include $(ERL_TOP)/make/$(TARGET)/otp.mk
 
 MODULES =  \
 	dyntrace_SUITE \
+	dyntrace_lttng_SUITE \
 	runtime_tools_SUITE \
 	system_information_SUITE \
 	dbg_SUITE \
diff --git a/lib/runtime_tools/test/dyntrace_lttng_SUITE.erl b/lib/runtime_tools/test/dyntrace_lttng_SUITE.erl
new file mode 100644
index 0000000000..e6c147b003
--- /dev/null
+++ b/lib/runtime_tools/test/dyntrace_lttng_SUITE.erl
@@ -0,0 +1,377 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2012-2016. All Rights Reserved.
+%%
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
+%%
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
+%%
+%% %CopyrightEnd%
+%%
+-module(dyntrace_lttng_SUITE).
+-include_lib("common_test/include/ct.hrl").
+
+-export([all/0, suite/0]).
+-export([init_per_suite/1, end_per_suite/1]).
+-export([init_per_testcase/2, end_per_testcase/2]).
+
+%% Test cases
+-export([t_lttng_list/1,
+         t_procs/1,
+         t_ports/1,
+         t_running_process/1,
+         t_running_port/1,
+         t_call/1,
+         t_call_return_to/1,
+         t_call_silent/1,
+         t_send/1,
+         t_receive/1,
+         t_garbage_collection/1,
+         t_all/1]).
+
+suite() ->
+    [{ct_hooks,[ts_install_cth]},
+     {timetrap, {seconds, 10}}].
+
+all() ->
+    [t_lttng_list,
+     t_procs,
+     t_ports,
+     t_running_process,
+     t_running_port,
+     t_call,
+     t_call_return_to,
+     t_call_silent,
+     t_send,
+     t_receive,
+     t_garbage_collection,
+     t_all].
+
+
+init_per_suite(Config) ->
+    case erlang:system_info(dynamic_trace) of
+        lttng ->
+            ensure_lttng_stopped("--all"),
+            Config;
+        _ ->
+            {skip, "No LTTng configured on system."}
+    end.
+
+end_per_suite(_Config) ->
+    ensure_lttng_stopped("--all"),
+    ok.
+
+init_per_testcase(Case, Config) ->
+    %% ensure loaded
+    _ = dyntrace:module_info(),
+    Name = atom_to_list(Case),
+    ok = ensure_lttng_started(Name, Config),
+    [{session, Name}|Config].
+
+end_per_testcase(Case, _Config) ->
+    Name = atom_to_list(Case),
+    ok = ensure_lttng_stopped(Name),
+    ok.
+
+%% tracepoints
+%%
+%%  com_ericsson_dyntrace:gc_major_end
+%%  com_ericsson_dyntrace:gc_major_start
+%%  com_ericsson_dyntrace:gc_minor_end
+%%  com_ericsson_dyntrace:gc_minor_start
+%%  com_ericsson_dyntrace:message_receive
+%%  com_ericsson_dyntrace:message_send
+%%  -com_ericsson_dyntrace:message_queued
+%%  com_ericsson_dyntrace:function_exception
+%%  com_ericsson_dyntrace:function_return
+%%  com_ericsson_dyntrace:function_call
+%%  com_ericsson_dyntrace:port_link
+%%  com_ericsson_dyntrace:port_exit
+%%  com_ericsson_dyntrace:port_open
+%%  com_ericsson_dyntrace:port_scheduled
+%%  com_ericsson_dyntrace:process_scheduled
+%%  com_ericsson_dyntrace:process_register
+%%  com_ericsson_dyntrace:process_exit
+%%  com_ericsson_dyntrace:process_link
+%%  com_ericsson_dyntrace:process_spawn
+%%
+%% Testcases
+%%
+
+t_lttng_list(_Config) ->
+    {ok, _} = cmd("lttng list -u"),
+    ok.
+
+t_procs(Config) when is_list(Config) ->
+    ok = lttng_start_event("com_ericsson_dyntrace:process_*", Config),
+    _ = erlang:trace(new, true, [{tracer, dyntrace, []},procs]),
+
+    Pid = spawn_link(fun() -> waiter() end),
+    Pid ! {self(), ok},
+    ok = receive {Pid,ok} -> ok end,
+    timer:sleep(1000),
+
+    _ = erlang:trace(all, false, [procs]),
+    Res = lttng_stop_and_view(Config),
+    ok = check_tracepoint("com_ericsson_dyntrace:process_spawn", Res),
+    ok = check_tracepoint("com_ericsson_dyntrace:process_link", Res),
+    ok = check_tracepoint("com_ericsson_dyntrace:process_exit", Res),
+    ok = check_tracepoint("com_ericsson_dyntrace:process_register", Res),
+    ok.
+
+t_ports(Config) when is_list(Config) ->
+    ok = lttng_start_event("com_ericsson_dyntrace:port_*", Config),
+    _ = erlang:trace(new, true, [{tracer, dyntrace, []},ports]),
+
+    _ = os:cmd("ls"),
+
+    _ = erlang:trace(all, false, [{tracer, dyntrace, []},ports]),
+    Res = lttng_stop_and_view(Config),
+    ok = check_tracepoint("com_ericsson_dyntrace:port_open", Res),
+    ok = check_tracepoint("com_ericsson_dyntrace:port_link", Res),
+    ok = check_tracepoint("com_ericsson_dyntrace:port_exit", Res),
+    ok.
+
+t_running_process(Config) when is_list(Config) ->
+    ok = lttng_start_event("com_ericsson_dyntrace:process_scheduled", Config),
+    _ = erlang:trace(new, true, [{tracer, dyntrace, []},running]),
+
+    Pid = spawn_link(fun() -> waiter() end),
+    Pid ! {self(), ok},
+    ok = receive {Pid,ok} -> ok end,
+    timer:sleep(1000),
+
+    _ = erlang:trace(all, false, [running]),
+    Res = lttng_stop_and_view(Config),
+    ok = check_tracepoint("com_ericsson_dyntrace:process_scheduled", Res),
+    ok.
+
+t_running_port(Config) when is_list(Config) ->
+    ok = lttng_start_event("com_ericsson_dyntrace:port_scheduled", Config),
+    _ = erlang:trace(new, true, [{tracer, dyntrace, []},running_ports]),
+
+    _ = os:cmd("ls"),
+    _ = os:cmd("ls"),
+
+    _ = erlang:trace(all, false, [running_ports]),
+    Res = lttng_stop_and_view(Config),
+    ok = check_tracepoint("com_ericsson_dyntrace:port_scheduled", Res),
+    ok.
+
+
+t_call(Config) when is_list(Config) ->
+    ok = lttng_start_event("com_ericsson_dyntrace:function_*", Config),
+    _ = erlang:trace(new, true, [{tracer, dyntrace, []}, call]),
+    _ = erlang:trace_pattern({?MODULE, '_', '_'}, [{'_',[],[{exception_trace}]}], [local]),
+
+    DontLink = spawn(fun() -> foo_clause_exception(nope) end),
+    Pid = spawn_link(fun() -> waiter() end),
+    Pid ! {self(), ok},
+    ok = receive {Pid,ok} -> ok end,
+    
+    timer:sleep(10),
+    undefined = erlang:process_info(DontLink),
+
+    _ = erlang:trace_pattern({?MODULE, '_', '_'}, false, [local]),
+    _ = erlang:trace(all, false, [call]),
+    Res = lttng_stop_and_view(Config),
+    ok = check_tracepoint("com_ericsson_dyntrace:function_call", Res),
+    ok = check_tracepoint("com_ericsson_dyntrace:function_return", Res),
+    ok = check_tracepoint("com_ericsson_dyntrace:function_exception", Res),
+    ok.
+
+t_send(Config) when is_list(Config) ->
+    ok = lttng_start_event("com_ericsson_dyntrace:message_send", Config),
+    _ = erlang:trace(new, true, [{tracer, dyntrace, []},send]),
+
+    Pid = spawn_link(fun() -> waiter() end),
+    Pid ! {self(), ok},
+    ok = receive {Pid,ok} -> ok end,
+    _ = os:cmd("ls"),
+    timer:sleep(10),
+
+    _ = erlang:trace(all, false, [send]),
+    Res = lttng_stop_and_view(Config),
+    ok = check_tracepoint("com_ericsson_dyntrace:message_send", Res),
+    ok.
+
+t_call_return_to(Config) when is_list(Config) ->
+    ok = lttng_start_event("com_ericsson_dyntrace:function_*", Config),
+    _ = erlang:trace(new, true, [{tracer, dyntrace, []}, call, return_to]),
+    _ = erlang:trace_pattern({lists, '_', '_'}, true, [local]),
+    _ = erlang:trace_pattern({?MODULE, '_', '_'}, true, [local]),
+
+    Pid = spawn_link(fun() -> gcfier(10) end),
+    Pid ! {self(), ok},
+    ok = receive {Pid,ok} -> ok end,
+    timer:sleep(10),
+
+    _ = erlang:trace_pattern({?MODULE, '_', '_'}, false, [local]),
+    _ = erlang:trace_pattern({lists, '_', '_'}, false, [local]),
+    _ = erlang:trace(all, false, [call,return_to]),
+    Res = lttng_stop_and_view(Config),
+    ok = check_tracepoint("com_ericsson_dyntrace:function_call", Res),
+    ok.
+
+t_call_silent(Config) when is_list(Config) ->
+    ok = lttng_start_event("com_ericsson_dyntrace:function_*", Config),
+    _ = erlang:trace(new, true, [{tracer, dyntrace, []}, call, silent]),
+    _ = erlang:trace_pattern({?MODULE, '_', '_'}, [{'_',[],[{exception_trace}]}], [local]),
+
+    DontLink = spawn(fun() -> foo_clause_exception(nope) end),
+    Pid = spawn_link(fun() -> waiter() end),
+    Pid ! {self(), ok},
+    ok = receive {Pid,ok} -> ok end,
+
+    timer:sleep(10),
+    undefined = erlang:process_info(DontLink),
+
+    _ = erlang:trace_pattern({?MODULE, '_', '_'}, false, [local]),
+    _ = erlang:trace(all, false, [call]),
+    Res = lttng_stop_and_view(Config),
+    notfound = check_tracepoint("com_ericsson_dyntrace:function_call", Res),
+    notfound = check_tracepoint("com_ericsson_dyntrace:function_return", Res),
+    notfound = check_tracepoint("com_ericsson_dyntrace:function_exception", Res),
+    ok.
+
+
+t_receive(Config) when is_list(Config) ->
+    ok = lttng_start_event("com_ericsson_dyntrace:message_receive", Config),
+    _ = erlang:trace(new, true, [{tracer, dyntrace, []},'receive']),
+
+    Pid = spawn_link(fun() -> waiter() end),
+    Pid ! {self(), ok},
+    ok = receive {Pid,ok} -> ok end,
+    timer:sleep(10),
+    _ = erlang:trace(all, false, ['receive']),
+    Res = lttng_stop_and_view(Config),
+    ok = check_tracepoint("com_ericsson_dyntrace:message_receive", Res),
+    ok.
+
+t_garbage_collection(Config) when is_list(Config) ->
+    ok = lttng_start_event("com_ericsson_dyntrace:gc_*", Config),
+    _ = erlang:trace(new, true, [{tracer, dyntrace, []},garbage_collection]),
+
+    Pid = spawn_link(fun() -> gcfier() end),
+    Pid ! {self(), ok},
+    ok = receive {Pid,ok} -> ok end,
+    timer:sleep(10),
+    _ = erlang:trace(all, false, [garbage_collection]),
+    Res = lttng_stop_and_view(Config),
+    ok = check_tracepoint("com_ericsson_dyntrace:gc_major_start", Res),
+    ok = check_tracepoint("com_ericsson_dyntrace:gc_major_end", Res),
+    ok = check_tracepoint("com_ericsson_dyntrace:gc_minor_start", Res),
+    ok = check_tracepoint("com_ericsson_dyntrace:gc_minor_end", Res),
+    ok.
+
+t_all(Config) when is_list(Config) ->
+    ok = lttng_start_event("com_ericsson_dyntrace:*", Config),
+    _ = erlang:trace(new, true, [{tracer, dyntrace, []},all]),
+
+    Pid1 = spawn_link(fun() -> waiter() end),
+    Pid1 ! {self(), ok},
+    ok = receive {Pid1,ok} -> ok end,
+
+    Pid2 = spawn_link(fun() -> gcfier() end),
+    Pid2 ! {self(), ok},
+    ok = receive {Pid2,ok} -> ok end,
+    _ = os:cmd("ls"),
+    _ = os:cmd("ls"),
+    timer:sleep(10),
+
+    _ = erlang:trace(all, false, [all]),
+    Res = lttng_stop_and_view(Config),
+
+    ok = check_tracepoint("com_ericsson_dyntrace:process_spawn", Res),
+    ok = check_tracepoint("com_ericsson_dyntrace:process_link", Res),
+    ok = check_tracepoint("com_ericsson_dyntrace:process_exit", Res),
+    ok = check_tracepoint("com_ericsson_dyntrace:process_register", Res),
+    ok = check_tracepoint("com_ericsson_dyntrace:port_open", Res),
+    ok = check_tracepoint("com_ericsson_dyntrace:port_link", Res),
+    ok = check_tracepoint("com_ericsson_dyntrace:port_exit", Res),
+    ok = check_tracepoint("com_ericsson_dyntrace:process_scheduled", Res),
+    ok = check_tracepoint("com_ericsson_dyntrace:port_scheduled", Res),
+    ok = check_tracepoint("com_ericsson_dyntrace:message_send", Res),
+    ok = check_tracepoint("com_ericsson_dyntrace:message_receive", Res),
+    ok = check_tracepoint("com_ericsson_dyntrace:gc_major_start", Res),
+    ok = check_tracepoint("com_ericsson_dyntrace:gc_major_end", Res),
+    ok = check_tracepoint("com_ericsson_dyntrace:gc_minor_start", Res),
+    ok = check_tracepoint("com_ericsson_dyntrace:gc_minor_end", Res),
+    ok.
+
+
+%% aux
+
+gcfier() ->
+    gcfier(10000).
+gcfier(N) ->
+    receive
+        {Pid, ok} ->
+            _ = lists:reverse(lists:seq(1,N)),
+            true = erlang:garbage_collect(),
+            Pid ! {self(), ok}
+    end.
+
+
+waiter() ->
+    true = register(?MODULE, self()),
+    receive
+        {Pid, ok} ->
+            Child = spawn(fun() -> receive ok -> ok end end),
+            link(Child),
+            unlink(Child),
+            _ = lists:seq(1,1000),
+            Child ! ok,
+            true = unregister(?MODULE),
+            Pid ! {self(),ok}
+    end.
+
+foo_clause_exception({1,2}) -> badness.
+
+%% lttng
+lttng_stop_and_view(Config) ->
+    Path = proplists:get_value(priv_dir, Config),
+    Name = proplists:get_value(session, Config),
+    {ok,_} = cmd("lttng stop " ++ Name),
+    {ok,Res} = cmd("lttng view " ++ Name ++ " --trace-path=" ++ Path),
+    Res.
+
+check_tracepoint(TP, Data) ->
+    case re:run(Data, TP, [global]) of
+        {match, _} -> ok;
+        _ -> notfound
+    end.
+
+lttng_start_event(Event, Config) ->
+    Name = proplists:get_value(session, Config),
+    {ok, _} = cmd("lttng enable-event -u " ++ Event ++ " --session=" ++ Name),
+    {ok, _} = cmd("lttng start " ++ Name),
+    ok.
+
+ensure_lttng_started(Name, Config) ->
+    Out = case proplists:get_value(priv_dir, Config) of
+              undefined -> [];
+              Path -> "--output="++Path++" "
+          end,
+    {ok,_} = cmd("lttng create " ++ Out ++ Name),
+    ok.
+
+ensure_lttng_stopped(Name) ->
+    {ok,_} = cmd("lttng stop"),
+    {ok,_} = cmd("lttng destroy " ++ Name),
+    ok.
+
+cmd(Cmd) ->
+    io:format("<< ~ts~n", [Cmd]),
+    Res = os:cmd(Cmd),
+    io:format(">> ~ts~n", [Res]),
+    {ok,Res}.
diff --git a/lib/tools/src/fprof.erl b/lib/tools/src/fprof.erl
index f9da748fef..b21eedc625 100644
--- a/lib/tools/src/fprof.erl
+++ b/lib/tools/src/fprof.erl
@@ -1629,15 +1629,24 @@ trace_handler({trace_ts, Pid, in, {_M, _F, Args} = MFArgs, TS} = Trace,
     TS;
 %%
 %% gc_start
-trace_handler({trace_ts, Pid, gc_start, _Func, TS} = Trace,
-	      Table, _, Dump) ->
+trace_handler({trace_ts, Pid, gc_minor_start, _Func, TS} = Trace, Table, _, Dump) ->
+    dump_stack(Dump, get(Pid), Trace),
+    trace_gc_start(Table, Pid, TS),
+    TS;
+
+trace_handler({trace_ts, Pid, gc_major_start, _Func, TS} = Trace, Table, _, Dump) ->
     dump_stack(Dump, get(Pid), Trace),
     trace_gc_start(Table, Pid, TS),
     TS;
+
 %%
 %% gc_end
-trace_handler({trace_ts, Pid, gc_end, _Func, TS} = Trace,
-	      Table, _, Dump) ->
+trace_handler({trace_ts, Pid, gc_minor_end, _Func, TS} = Trace, Table, _, Dump) ->
+    dump_stack(Dump, get(Pid), Trace),
+    trace_gc_end(Table, Pid, TS),
+    TS;
+
+trace_handler({trace_ts, Pid, gc_major_end, _Func, TS} = Trace, Table, _, Dump) ->
     dump_stack(Dump, get(Pid), Trace),
     trace_gc_end(Table, Pid, TS),
     TS;
diff --git a/lib/tools/test/fprof_SUITE.erl b/lib/tools/test/fprof_SUITE.erl
index e18d384b52..affb45b7a6 100644
--- a/lib/tools/test/fprof_SUITE.erl
+++ b/lib/tools/test/fprof_SUITE.erl
@@ -949,8 +949,8 @@ handle_trace({trace_ts,Pid,return_to,MFA,TS},P) ->
     end,
     put({Pid,last_ts},TS),
     P;
-handle_trace({trace_ts,Pid,gc_start,_,TS},P) ->
-    ?dbg("~p",[{{gc_start,Pid},get(Pid)}]),
+handle_trace({trace_ts,Pid,gc_minor_start,_,TS},P) ->
+    ?dbg("~p",[{{gc_minor_start,Pid},get(Pid)}]),
     case get(Pid) of
         [suspend|_] = Stack ->
             T = ts_sub(TS,get({Pid,last_ts})),
@@ -970,8 +970,40 @@ handle_trace({trace_ts,Pid,gc_start,_,TS},P) ->
     end,
     put({Pid,last_ts},TS),
     P;
-handle_trace({trace_ts,Pid,gc_end,_,TS},P) ->
-    ?dbg("~p",[{{gc_end,Pid},get(Pid)}]),
+handle_trace({trace_ts,Pid,gc_major_start,_,TS},P) ->
+    ?dbg("~p",[{{gc_minor_start,Pid},get(Pid)}]),
+    case get(Pid) of
+        [suspend|_] = Stack ->
+            T = ts_sub(TS,get({Pid,last_ts})),
+            insert(Pid,garbage_collect),
+            update_acc(Pid,Stack,T),
+            put(Pid,[garbage_collect|Stack]);
+        [CallingMFA|_] = Stack ->
+            T = ts_sub(TS,get({Pid,last_ts})),
+            insert(Pid,garbage_collect),
+            update_own(Pid,CallingMFA,T),
+            update_acc(Pid,Stack,T),
+            put(Pid,[garbage_collect|Stack]);
+        undefined ->
+            put(first_ts,TS),
+            put(Pid,[garbage_collect]),
+            insert(Pid,garbage_collect)
+    end,
+    put({Pid,last_ts},TS),
+    P;
+handle_trace({trace_ts,Pid,gc_minor_end,_,TS},P) ->
+    ?dbg("~p",[{{gc_minor_end,Pid},get(Pid)}]),
+    T = ts_sub(TS,get({Pid,last_ts})),
+    case get(Pid) of
+        [garbage_collect|RestOfStack] = Stack ->
+            update_own(Pid,garbage_collect,T),
+            update_acc(Pid,Stack,T),
+            put(Pid,RestOfStack)
+    end,
+    put({Pid,last_ts},TS),
+    P;
+handle_trace({trace_ts,Pid,gc_major_end,_,TS},P) ->
+    ?dbg("~p",[{{gc_major_end,Pid},get(Pid)}]),
     T = ts_sub(TS,get({Pid,last_ts})),
     case get(Pid) of
         [garbage_collect|RestOfStack] = Stack ->