Merge branch 'lukas/erts/tracing/misc_fixes/OTP-13503'

* lukas/erts/tracing/misc_fixes/OTP-13503:
  erts: Add test for new procs trace with spawn_link
  kernel: Remove seq_trace event order dep in tc
  erts: Add tests for set on link tracing
  erts: Expand trace tests for refc binaries
  erts: Remove erl_tracer with invalid state
  erts: Remove some dead code
  erts: Fix broken doc link to erl_tracer

Conflicts:
	erts/emulator/beam/erl_trace.c

9 files changed, 120 insertions, 105 deletions

diff --git a/erts/doc/src/erlang.xml b/erts/doc/src/erlang.xml
index 423ccdf98f..1daa582584 100644
--- a/erts/doc/src/erlang.xml
+++ b/erts/doc/src/erlang.xml
@@ -8637,8 +8637,8 @@ timestamp() ->
             <p>Specifies that a tracer module should be called
             instead of sending a trace message. The tracer module
             can then ignore or change the trace message. For more details
-            on how to write a tracer module see <seealso marker="erl_tracer">
-            erl_tracer</seealso>
+            on how to write a tracer module see
+            <seealso marker="erts:erl_tracer"><c>erl_tracer</c></seealso>
           </p>
           </item>
         </taglist>
@@ -8989,7 +8989,7 @@ timestamp() ->
           <c>erlang:trace_delivered(<anno>Tracee</anno>)</c> resides on.
           The special <c><anno>Tracee</anno></c> atom <c>all</c>
           denotes all processes that currently are traced in the node.</p>
-        <p>When used together with an <seealso marker="#erl_tracer">
+        <p>When used together with an <seealso marker="erts:erl_tracer">
           Tracer Module</seealso> any message sent in the trace callback
           is guaranteed to have reached it's recipient before the
           <c>trace_delivered</c> message is sent.</p>
diff --git a/erts/emulator/beam/beam_bp.h b/erts/emulator/beam/beam_bp.h
index bb171be8a6..08641b86d6 100644
--- a/erts/emulator/beam/beam_bp.h
+++ b/erts/emulator/beam/beam_bp.h
@@ -173,19 +173,7 @@ void erts_clear_time_trace_bif(BeamInstr *pc);
 
 BeamInstr *erts_find_local_func(Eterm mfa[3]);
 
-ERTS_GLB_INLINE Uint erts_bp_sched2ix(void);
-
 #if ERTS_GLB_INLINE_INCL_FUNC_DEF
-ERTS_GLB_INLINE Uint erts_bp_sched2ix(void)
-{
-#ifdef ERTS_SMP
-    ErtsSchedulerData *esdp;
-    esdp = erts_get_scheduler_data();
-    return esdp->no - 1;
-#else
-    return 0;
-#endif
-}
 
 extern erts_smp_atomic32_t erts_active_bp_index;
 extern erts_smp_atomic32_t erts_staging_bp_index;
diff --git a/erts/emulator/beam/erl_trace.c b/erts/emulator/beam/erl_trace.c
index 56899f574a..128696270b 100644
--- a/erts/emulator/beam/erl_trace.c
+++ b/erts/emulator/beam/erl_trace.c
@@ -658,6 +658,7 @@ do { \
 #  define GET_NOW(m, s, u) do {get_now(m, s, u);} while (0)
 #endif
 
+
 static void
 write_sys_msg_to_port(Eterm unused_to,
 		      Port* trace_port,
@@ -1737,41 +1738,6 @@ profile_scheduler(Eterm scheduler_id, Eterm state) {
 
 }
 
-void
-profile_scheduler_q(Eterm scheduler_id, Eterm state, Eterm no_schedulers, Uint Ms, Uint s, Uint us) {
-    Eterm *hp, msg, timestamp;
-    
-#ifndef ERTS_SMP	
-#define LOCAL_HEAP_SIZE (4 + 7)
-    DeclareTmpHeapNoproc(local_heap,LOCAL_HEAP_SIZE);
-    UseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-
-    hp = local_heap;
-#else    
-    ErlHeapFragment *bp;
-    Uint hsz;
-
-    hsz = 4 + 7;
-	
-    bp = new_message_buffer(hsz);
-    hp = bp->mem;
-#endif
-
-    erts_smp_mtx_lock(&smq_mtx);
-
-    timestamp = TUPLE3(hp, make_small(Ms), make_small(s), make_small(us)); hp += 4;
-    msg = TUPLE6(hp, am_profile, am_scheduler, scheduler_id, state, no_schedulers, timestamp); hp += 7;
-#ifndef ERTS_SMP
-    profile_send(NIL, msg);
-    UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
-#undef LOCAL_HEAP_SIZE
-#else
-    enqueue_sys_msg_unlocked(SYS_MSG_TYPE_SYSPROF, NIL, NIL, msg, bp);
-#endif
-    erts_smp_mtx_unlock(&smq_mtx);
-
-}
-
 /* Port profiling */
 
 void
@@ -1935,7 +1901,10 @@ 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, TRACE_FUN_T_RECEIVE,
+        hp += 3;
+        ASSERT(hp <= (local_heap + LOCAL_HEAP_SIZE) || orig_hp);
+        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)
diff --git a/erts/emulator/beam/utils.c b/erts/emulator/beam/utils.c
index b280995488..68006e7ef3 100644
--- a/erts/emulator/beam/utils.c
+++ b/erts/emulator/beam/utils.c
@@ -71,41 +71,6 @@
 #define HAVE_MALLOPT 0
 #endif
 
-/* profile_scheduler mini message queue */
-
-typedef struct {
-    Uint scheduler_id;
-    Uint no_schedulers;
-    Uint Ms;
-    Uint s;
-    Uint us;
-    Eterm state;
-} profile_sched_msg;
-
-typedef struct {
-    profile_sched_msg msg[2];
-    Uint n;
-} profile_sched_msg_q;
-
-#ifdef ERTS_SMP
-
-#if 0 /* Unused */
-static void 
-dispatch_profile_msg_q(profile_sched_msg_q *psmq)
-{
-    int i = 0;
-    profile_sched_msg *msg = NULL;
-    ASSERT(psmq != NULL);
-    for (i = 0; i < psmq->n; i++) {
-        msg = &(psmq->msg[i]);
-	profile_scheduler_q(make_small(msg->scheduler_id), msg->state, am_undefined, msg->Ms, msg->s, msg->us);
-    }
-}
-#endif
-
-#endif
-
-
 Eterm*
 erts_heap_alloc(Process* p, Uint need, Uint xtra)
 {
diff --git a/erts/emulator/nifs/common/erl_tracer_nif.c b/erts/emulator/nifs/common/erl_tracer_nif.c
index 1bb6b940c4..b0c937592a 100644
--- a/erts/emulator/nifs/common/erl_tracer_nif.c
+++ b/erts/emulator/nifs/common/erl_tracer_nif.c
@@ -130,6 +130,9 @@ static ERL_NIF_TERM enabled(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
         if (!enif_is_port_alive(env, &to_port))
             /* tracer is dead so we should remove this trace point */
             return atom_remove;
+    } else {
+        /* The state was not a pid or a port */
+        return atom_remove;
     }
 
     /* Only generate trace for when tracer != tracee */
diff --git a/erts/emulator/test/match_spec_SUITE.erl b/erts/emulator/test/match_spec_SUITE.erl
index ea973276db..6733237b20 100644
--- a/erts/emulator/test/match_spec_SUITE.erl
+++ b/erts/emulator/test/match_spec_SUITE.erl
@@ -597,16 +597,15 @@ ms_trace3(Config) when is_list(Config) ->
       end),
     ok.
 
-ms_trace_dead(doc) ->
-    ["Test that a dead tracer is removed using ms"];
-ms_trace_dead(suite) -> [];
-ms_trace_dead(Config) when is_list(Config) ->
+%% Test that a dead tracer is removed using ms
+ms_trace_dead(_Config) ->
     Self = self(),
     TFun = fun F() -> receive M -> Self ! M, F() end end,
     {Tracer, MRef} = spawn_monitor(TFun),
     MetaTracer = spawn_link(TFun),
     erlang:trace_pattern({?MODULE, f1, '_'},
-                         [{'_',[],[{trace,[],
+                         [{'_',[],[{message, false},
+                                   {trace,[],
                                     [call,{const,{tracer,Tracer}}]}]}],
                          [{meta, MetaTracer}]),
     erlang:trace_pattern({?MODULE, f2, '_'}, []),
@@ -623,8 +622,6 @@ ms_trace_dead(Config) when is_list(Config) ->
     ?MODULE:f2(3,4),
     TRef = erlang:trace_delivered(all),
     receive {trace_delivered, _, TRef} -> ok end,
-    receive {trace_ts, Self, call, {?MODULE, f1, _}, _} -> ok end,
-    receive {trace_ts, Self, call, {?MODULE, f1, _}, _} -> ok end,
     receive M -> ct:fail({unexpected, M}) after 10 -> ok end.
 
 %% Test that destructive operations in test bif does not really happen
diff --git a/erts/emulator/test/port_trace_SUITE.erl b/erts/emulator/test/port_trace_SUITE.erl
index 41e8a316c4..bfdea0761b 100644
--- a/erts/emulator/test/port_trace_SUITE.erl
+++ b/erts/emulator/test/port_trace_SUITE.erl
@@ -240,19 +240,23 @@ command(Config) ->
     Prt ! {S, {command, <<?ECHO_DRV_NOOP:8>>}},
     [{trace, Prt, 'receive', {S, {command, <<?ECHO_DRV_NOOP:8>>}}}] = flush(),
 
+    OutputMsg = <<?ECHO_DRV_NOOP:8,0:(8*512)>>,
+    Prt ! {S, {command, OutputMsg}},
+    [{trace, Prt, 'receive', {S, {command, OutputMsg}}}] = flush(),
+
     close(Prt, Flags),
 
     os:putenv("OUTPUTV","true"),
     reload_drv(Config),
 
     Prt2 = erlang:open_port({spawn, echo_drv}, [binary]),
-    Msg = [<<0:8>>,<<0:(8*512)>>,<<0:(8*256)>>,<<0:8>>],
+    OutputvMsg = [<<0:8>>,<<0:(8*512)>>,<<0:(8*256)>>,<<0:8>>],
 
-    erlang:port_command(Prt2, Msg),
-    [{trace, Prt2, 'receive', {S, {command, Msg}}}] = flush(),
+    erlang:port_command(Prt2, OutputvMsg),
+    [{trace, Prt2, 'receive', {S, {command, OutputvMsg}}}] = flush(),
 
-    Prt2 ! {S, {command, Msg}},
-    [{trace, Prt2, 'receive', {S, {command, Msg}}}] = flush(),
+    Prt2 ! {S, {command, OutputvMsg}},
+    [{trace, Prt2, 'receive', {S, {command, OutputvMsg}}}] = flush(),
 
     close(Prt2, Flags),
 
@@ -274,6 +278,12 @@ control(_Config) ->
     [{trace, Prt, 'receive', {S, {control, {(1 bsl 32) - 1, <<?ECHO_DRV_NOOP:8, 0:8>>}}}},
      {trace, Prt, send, {Prt, {control, <<0:8>>}}, S}] = flush(),
 
+    Msg = <<?ECHO_DRV_NOOP:8, 0:(8*512)>>,
+    Pat = lists:duplicate(512, 0),
+    Pat = erlang:port_control(Prt, 1, Msg),
+    [{trace, Prt, 'receive', {S, {control, {1, Msg}}}},
+     {trace, Prt, send, {Prt, {control, <<0:(8*512)>>}}, S}] = flush(),
+
     close(Prt, Flags),
 
     ok.
@@ -331,12 +341,16 @@ call(_Config) ->
     Flags = [send,'receive'],
     {Prt, S} = trace_and_open(Flags,[binary]),
 
-    Msg = {hello, world, make_ref()},
-    BinMsg = term_to_binary(Msg),
+    Test = fun(Msg) ->
+                   BinMsg = term_to_binary(Msg),
+
+                   Msg = erlang:port_call(Prt, 0, Msg),
+                   [{trace, Prt, 'receive', {S, {call, {0, BinMsg}}}},
+                    {trace, Prt, send, {Prt, {call, BinMsg}}, S}] = flush()
+           end,
 
-    Msg = erlang:port_call(Prt, 0, Msg),
-    [{trace, Prt, 'receive', {S, {call, {0, BinMsg}}}},
-     {trace, Prt, send, {Prt, {call, BinMsg}}, S}] = flush(),
+    Test({hello, world, make_ref()}),
+    Test({hello, world, lists:seq(1,1000)}),
 
     close(Prt, Flags),
 
diff --git a/erts/emulator/test/port_trace_SUITE_data/echo_drv.c b/erts/emulator/test/port_trace_SUITE_data/echo_drv.c
index b5728bc170..b5ae9389b4 100644
--- a/erts/emulator/test/port_trace_SUITE_data/echo_drv.c
+++ b/erts/emulator/test/port_trace_SUITE_data/echo_drv.c
@@ -217,6 +217,8 @@ static ErlDrvSSizeT echo_drv_control(ErlDrvData drv_data,
 				     char *buf, ErlDrvSizeT len,
 				     char **rbuf, ErlDrvSizeT rlen)
 {
+    if ((len - 1) > rlen)
+        *rbuf = driver_alloc(len - 1);
     memcpy(*rbuf, buf+1, len-1);
     return len-1;
 }
@@ -232,6 +234,8 @@ static ErlDrvSSizeT echo_drv_call(ErlDrvData drv_data,
                                   char **rbuf, ErlDrvSizeT rlen,
                                   unsigned int *flags)
 {
+    if ((len - command) > rlen)
+        *rbuf = driver_alloc(len - command);
     memcpy(*rbuf, buf+command, len-command);
     return len-command;
 }
diff --git a/erts/emulator/test/trace_SUITE.erl b/erts/emulator/test/trace_SUITE.erl
index b7f312635e..29e043dd5c 100644
--- a/erts/emulator/test/trace_SUITE.erl
+++ b/erts/emulator/test/trace_SUITE.erl
@@ -27,11 +27,12 @@
 -export([all/0, suite/0, link_receive_call_correlation/0,
          receive_trace/1, link_receive_call_correlation/1, self_send/1,
 	 timeout_trace/1, send_trace/1,
-	 procs_trace/1, dist_procs_trace/1,
+	 procs_trace/1, dist_procs_trace/1, procs_new_trace/1,
 	 suspend/1, mutual_suspend/1, suspend_exit/1, suspender_exit/1,
 	 suspend_system_limit/1, suspend_opts/1, suspend_waiting/1,
 	 new_clear/1, existing_clear/1,
 	 set_on_spawn/1, set_on_first_spawn/1, cpu_timestamp/1,
+	 set_on_link/1, set_on_first_link/1,
 	 system_monitor_args/1, more_system_monitor_args/1,
 	 system_monitor_long_gc_1/1, system_monitor_long_gc_2/1, 
 	 system_monitor_large_heap_1/1, system_monitor_large_heap_2/1,
@@ -54,7 +55,8 @@ all() ->
      mutual_suspend, suspend_exit, suspender_exit,
      suspend_system_limit, suspend_opts, suspend_waiting,
      new_clear, existing_clear, set_on_spawn,
-     set_on_first_spawn, system_monitor_args,
+     set_on_first_spawn, set_on_link, set_on_first_link,
+     system_monitor_args,
      more_system_monitor_args, system_monitor_long_gc_1,
      system_monitor_long_gc_2, system_monitor_large_heap_1,
      system_monitor_long_schedule,
@@ -454,6 +456,34 @@ dist_procs_trace(Config) when is_list(Config) ->
     true = stop_node(OtherNode),
     ok.
 
+%% Test trace(new, How, [procs]).
+procs_new_trace(Config) when is_list(Config) ->
+    Self = self(),
+    process_flag(trap_exit, true),
+    %%
+    Proc1 = spawn_link(?MODULE, process, [Self]),
+    io:format("Proc1 = ~p ~n", [Proc1]),
+    %%
+    0 = erlang:trace(new, true, [procs]),
+
+    MFA = {?MODULE, process, [Self]},
+    %%
+    %% spawn, link
+    Proc1 ! {spawn_link_please, Self, MFA},
+    Proc3 = receive {spawned, Proc1, P3} -> P3 end,
+    receive {trace, Proc3, spawned, Proc1, MFA} -> ok end,
+    receive {trace, Proc3, getting_linked, Proc1} -> ok end,
+    io:format("Proc3 = ~p ~n", [Proc3]),
+    receive_nothing(),
+    %%
+    %%
+    %% exit (not linked to tracing process)
+    Reason1 = make_ref(),
+    Proc1 ! {exit_please, Reason1},
+    receive {'EXIT', Proc1, Reason1} -> ok end,
+    {trace, Proc3, exit, Reason1} = receive_first_trace(),
+    receive_nothing(),
+    ok.
 
 
 
@@ -501,6 +531,51 @@ set_on_first_spawn(Config) when is_list(Config) ->
     receive_nothing(),
     ok.
 
+%% Tests trace(Pid, How, [set_on_link]).
+
+set_on_link(Config) ->
+    Listener = fun_spawn(fun process/0),
+
+    %% Create and trace a process with the set_on_link flag.
+    %% Make sure it is traced.
+    Father_SOL = fun_spawn(fun process/0),
+    1 = erlang:trace(Father_SOL, true, [send, set_on_link]),
+    true = is_send_traced(Father_SOL, Listener, sol_father),
+
+    %% Have the process spawn of two children and test that they
+    %% are traced.
+    [Child1, Child2] = spawn_children(Father_SOL, 2),
+    true = is_send_traced(Child1, Listener, child1),
+    true = is_send_traced(Child2, Listener, child2),
+
+    %% Second generation.
+    [Child11, Child12] = spawn_children(Child1, 2),
+    true = is_send_traced(Child11, Listener, child11),
+    true = is_send_traced(Child12, Listener, child12),
+    ok.
+
+%% Tests trace(Pid, How, [set_on_first_spawn]).
+
+set_on_first_link(Config) ->
+    ct:timetrap({seconds, 10}),
+    Listener = fun_spawn(fun process/0),
+
+    %% Create and trace a process with the set_on_first_spawn flag.
+    %% Make sure it is traced.
+    Parent = fun_spawn(fun process/0),
+    1 = erlang:trace(Parent, true, [send, set_on_first_link]),
+    is_send_traced(Parent, Listener, sol_father),
+
+    %% Have the process spawn off three children and test that the
+    %% first is traced.
+    [Child1, Child2, Child3] = spawn_children(Parent, 3),
+    true = is_send_traced(Child1, Listener, child1),
+    false = is_send_traced(Child2, Listener, child2),
+    false = is_send_traced(Child3, Listener, child3),
+    receive_nothing(),
+    ok.
+
+
 
 %% Tests arguments to erlang:system_monitor/0,1,2
 system_monitor_args(Config) when is_list(Config) ->