%% %% %CopyrightBegin% %% %% Copyright Ericsson AB 1998-2011. 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(seq_trace_SUITE). -export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, init_per_group/2,end_per_group/2, init_per_testcase/2,end_per_testcase/2]). -export([token_set_get/1, tracer_set_get/1, print/1, send/1, distributed_send/1, recv/1, distributed_recv/1, trace_exit/1, distributed_exit/1, call/1, port/1, match_set_seq_token/1, gc_seq_token/1]). % internal exports -export([simple_tracer/2, one_time_receiver/0, one_time_receiver/1, start_tracer/0, stop_tracer/1, do_match_set_seq_token/1, do_gc_seq_token/1, countdown_start/2]). %-define(line_trace, 1). -include_lib("common_test/include/ct.hrl"). -define(TIMESTAMP_MODES, [no_timestamp, timestamp, monotonic_timestamp, strict_monotonic_timestamp]). suite() -> [{ct_hooks,[ts_install_cth]}, {timetrap,{minutes,1}}]. all() -> [token_set_get, tracer_set_get, print, send, distributed_send, recv, distributed_recv, trace_exit, distributed_exit, call, port, match_set_seq_token, gc_seq_token]. groups() -> []. init_per_suite(Config) -> Config. end_per_suite(_Config) -> ok. init_per_group(_GroupName, Config) -> Config. end_per_group(_GroupName, Config) -> Config. init_per_testcase(_Case, Config) -> Config. end_per_testcase(_Case, _Config) -> ok. %% Verifies that the set_token and get_token functions work as expected token_set_get(doc) -> []; token_set_get(suite) -> []; token_set_get(Config) when is_list(Config) -> do_token_set_get(timestamp), do_token_set_get(monotonic_timestamp), do_token_set_get(strict_monotonic_timestamp). do_token_set_get(TsType) -> io:format("Testing ~p~n", [TsType]), Flags = case TsType of timestamp -> 15; strict_monotonic_timestamp -> 23; monotonic_timestamp -> 39 end, ?line Self = self(), ?line seq_trace:reset_trace(), %% Test that initial seq_trace is disabled ?line [] = seq_trace:get_token(), %% Test setting and reading the different fields ?line 0 = seq_trace:set_token(label,17), ?line {label,17} = seq_trace:get_token(label), ?line false = seq_trace:set_token(print,true), ?line {print,true} = seq_trace:get_token(print), ?line false = seq_trace:set_token(send,true), ?line {send,true} = seq_trace:get_token(send), ?line false = seq_trace:set_token('receive',true), ?line {'receive',true} = seq_trace:get_token('receive'), ?line false = seq_trace:set_token(TsType,true), ?line {TsType,true} = seq_trace:get_token(TsType), %% Check the whole token ?line {Flags,17,0,Self,0} = seq_trace:get_token(), % all flags are set %% Test setting and reading the 'serial' field ?line {0,0} = seq_trace:set_token(serial,{3,5}), ?line {serial,{3,5}} = seq_trace:get_token(serial), %% Check the whole token, test that a whole token can be set and get ?line {Flags,17,5,Self,3} = seq_trace:get_token(), ?line seq_trace:set_token({Flags,19,7,Self,5}), ?line {Flags,19,7,Self,5} = seq_trace:get_token(), %% Check that receive timeout does not reset token ?line receive after 0 -> ok end, ?line {Flags,19,7,Self,5} = seq_trace:get_token(), %% Check that token can be unset ?line {Flags,19,7,Self,5} = seq_trace:set_token([]), ?line [] = seq_trace:get_token(), %% Check that Previous serial counter survived unset token ?line 0 = seq_trace:set_token(label, 17), ?line {0,17,0,Self,5} = seq_trace:get_token(), %% Check that reset_trace resets the token and clears %% the Previous serial counter ?line seq_trace:reset_trace(), ?line [] = seq_trace:get_token(), ?line 0 = seq_trace:set_token(label, 19), ?line {0,19,0,Self,0} = seq_trace:get_token(), %% Cleanup ?line seq_trace:reset_trace(), ok. tracer_set_get(doc) -> []; tracer_set_get(suite) -> []; tracer_set_get(Config) when is_list(Config) -> ?line Self = self(), ?line seq_trace:set_system_tracer(self()), ?line Self = seq_trace:get_system_tracer(), ?line Self = seq_trace:set_system_tracer(false), ?line false = seq_trace:get_system_tracer(), %% Set the system tracer to a port. ?line Port = load_tracer(Config), ?line seq_trace:set_system_tracer(Port), ?line Port = seq_trace:get_system_tracer(), ?line Port = seq_trace:set_system_tracer(false), ?line false = seq_trace:get_system_tracer(), ok. print(doc) -> []; print(suite) -> []; print(Config) when is_list(Config) -> lists:foreach(fun do_print/1, ?TIMESTAMP_MODES). do_print(TsType) -> ?line start_tracer(), ?line set_token_flags([print, TsType]), ?line seq_trace:print(0,print1), ?line seq_trace:print(1,print2), ?line seq_trace:print(print3), ?line seq_trace:reset_trace(), ?line [{0,{print,_,_,[],print1}, Ts0}, {0,{print,_,_,[],print3}, Ts1}] = stop_tracer(2), check_ts(TsType, Ts0), check_ts(TsType, Ts1). send(doc) -> []; send(suite) -> []; send(Config) when is_list(Config) -> lists:foreach(fun do_send/1, ?TIMESTAMP_MODES). do_send(TsType) -> ?line seq_trace:reset_trace(), ?line start_tracer(), ?line Receiver = spawn(?MODULE,one_time_receiver,[]), ?line set_token_flags([send, TsType]), ?line Receiver ! send, ?line Self = self(), ?line seq_trace:reset_trace(), ?line [{0,{send,_,Self,Receiver,send}, Ts}] = stop_tracer(1), check_ts(TsType, Ts). distributed_send(doc) -> []; distributed_send(suite) -> []; distributed_send(Config) when is_list(Config) -> lists:foreach(fun do_distributed_send/1, ?TIMESTAMP_MODES). do_distributed_send(TsType) -> ?line {ok,Node} = start_node(seq_trace_other,[]), ?line {_,Dir} = code:is_loaded(?MODULE), ?line Mdir = filename:dirname(Dir), ?line true = rpc:call(Node,code,add_patha,[Mdir]), ?line seq_trace:reset_trace(), ?line start_tracer(), ?line Receiver = spawn(Node,?MODULE,one_time_receiver,[]), ?line set_token_flags([send,TsType]), ?line Receiver ! send, ?line Self = self(), ?line seq_trace:reset_trace(), ?line stop_node(Node), ?line [{0,{send,_,Self,Receiver,send}, Ts}] = stop_tracer(1), check_ts(TsType, Ts). recv(doc) -> []; recv(suite) -> []; recv(Config) when is_list(Config) -> lists:foreach(fun do_recv/1, ?TIMESTAMP_MODES). do_recv(TsType) -> ?line seq_trace:reset_trace(), ?line start_tracer(), ?line Receiver = spawn(?MODULE,one_time_receiver,[]), ?line set_token_flags(['receive',TsType]), ?line Receiver ! 'receive', %% let the other process receive the message: ?line receive after 1 -> ok end, ?line Self = self(), ?line seq_trace:reset_trace(), ?line [{0,{'receive',_,Self,Receiver,'receive'}, Ts}] = stop_tracer(1), check_ts(TsType, Ts). distributed_recv(doc) -> []; distributed_recv(suite) -> []; distributed_recv(Config) when is_list(Config) -> lists:foreach(fun do_distributed_recv/1, ?TIMESTAMP_MODES). do_distributed_recv(TsType) -> ?line {ok,Node} = start_node(seq_trace_other,[]), ?line {_,Dir} = code:is_loaded(?MODULE), ?line Mdir = filename:dirname(Dir), ?line true = rpc:call(Node,code,add_patha,[Mdir]), ?line seq_trace:reset_trace(), ?line rpc:call(Node,?MODULE,start_tracer,[]), ?line Receiver = spawn(Node,?MODULE,one_time_receiver,[]), ?line set_token_flags(['receive',TsType]), ?line Receiver ! 'receive', %% let the other process receive the message: ?line receive after 1 -> ok end, ?line Self = self(), ?line seq_trace:reset_trace(), ?line Result = rpc:call(Node,?MODULE,stop_tracer,[1]), ?line stop_node(Node), ?line ok = io:format("~p~n",[Result]), ?line [{0,{'receive',_,Self,Receiver,'receive'}, Ts}] = Result, check_ts(TsType, Ts). trace_exit(doc) -> []; trace_exit(suite) -> []; trace_exit(Config) when is_list(Config) -> lists:foreach(fun do_trace_exit/1, ?TIMESTAMP_MODES). do_trace_exit(TsType) -> ?line seq_trace:reset_trace(), ?line start_tracer(), ?line Receiver = spawn_link(?MODULE, one_time_receiver, [exit]), ?line process_flag(trap_exit, true), ?line set_token_flags([send, TsType]), ?line Receiver ! {before, exit}, %% let the other process receive the message: ?line receive {'EXIT', Receiver, {exit, {before, exit}}} -> seq_trace:set_token([]); Other -> seq_trace:set_token([]), ct:fail({received, Other}) end, ?line Self = self(), ?line Result = stop_tracer(2), ?line seq_trace:reset_trace(), ?line ok = io:format("~p~n", [Result]), ?line [{0, {send, {0,1}, Self, Receiver, {before, exit}}, Ts0}, {0, {send, {1,2}, Receiver, Self, {'EXIT', Receiver, {exit, {before, exit}}}}, Ts1}] = Result, check_ts(TsType, Ts0), check_ts(TsType, Ts1). distributed_exit(doc) -> []; distributed_exit(suite) -> []; distributed_exit(Config) when is_list(Config) -> lists:foreach(fun do_distributed_exit/1, ?TIMESTAMP_MODES). do_distributed_exit(TsType) -> ?line {ok, Node} = start_node(seq_trace_other, []), ?line {_, Dir} = code:is_loaded(?MODULE), ?line Mdir = filename:dirname(Dir), ?line true = rpc:call(Node, code, add_patha, [Mdir]), ?line seq_trace:reset_trace(), ?line rpc:call(Node, ?MODULE, start_tracer,[]), ?line Receiver = spawn_link(Node, ?MODULE, one_time_receiver, [exit]), ?line process_flag(trap_exit, true), ?line set_token_flags([send, TsType]), ?line Receiver ! {before, exit}, %% let the other process receive the message: ?line receive {'EXIT', Receiver, {exit, {before, exit}}} -> seq_trace:set_token([]); Other -> seq_trace:set_token([]), ct:fail({received, Other}) end, ?line Self = self(), ?line Result = rpc:call(Node, ?MODULE, stop_tracer, [1]), ?line seq_trace:reset_trace(), ?line stop_node(Node), ?line ok = io:format("~p~n", [Result]), ?line [{0, {send, {1, 2}, Receiver, Self, {'EXIT', Receiver, {exit, {before, exit}}}}, Ts}] = Result, check_ts(TsType, Ts). call(doc) -> "Tests special forms {is_seq_trace} and {get_seq_token} " "in trace match specs."; call(suite) -> []; call(Config) when is_list(Config) -> ?line Self = self(), ?line seq_trace:reset_trace(), ?line TrA = transparent_tracer(), ?line 1 = erlang:trace(Self, true, [call, set_on_spawn, {tracer, TrA(pid)}]), ?line 1 = erlang:trace_pattern({?MODULE, call_tracee_1, 1}, [{'_', [], [{message, {{{self}, {get_seq_token}}}}]}], [local]), ?line 1 = erlang:trace_pattern({?MODULE, call_tracee_2, 1}, [{'_', [{is_seq_trace}], [{message, {{{self}, {get_seq_token}}}}]}], [local]), ?line RefA = make_ref(), ?line Pid2A = spawn_link( fun() -> receive {_, msg, RefA} -> ok end, RefA = call_tracee_2(RefA), Self ! {self(), msg, RefA} end), ?line Pid1A = spawn_link( fun() -> receive {_, msg, RefA} -> ok end, RefA = call_tracee_1(RefA), Pid2A ! {self(), msg, RefA} end), ?line Pid1A ! {Self, msg, RefA}, %% The message is passed Self -> Pid1B -> Pid2B -> Self. %% Traced functions are called in Pid1B and Pid2B. ?line receive {Pid2A, msg, RefA} -> ok end, %% Only call_tracee1 will be traced since the guard for %% call_tracee2 requires a sequential trace. The trace %% token is undefined. ?line Token2A = [], ?line {ok, [{trace, Pid1A, call, {?MODULE, call_tracee_1, [RefA]}, {Pid1A, Token2A}}]} = TrA({stop, 1}), ?line seq_trace:reset_trace(), ?line TrB = transparent_tracer(), ?line 1 = erlang:trace(Self, true, [call, set_on_spawn, {tracer, TrB(pid)}]), ?line Label = 17, ?line seq_trace:set_token(label, Label), % Token enters here!! ?line RefB = make_ref(), ?line Pid2B = spawn_link( fun() -> receive {_, msg, RefB} -> ok end, RefB = call_tracee_2(RefB), Self ! {self(), msg, RefB} end), ?line Pid1B = spawn_link( fun() -> receive {_, msg, RefB} -> ok end, RefB = call_tracee_1(RefB), Pid2B ! {self(), msg, RefB} end), ?line Pid1B ! {Self, msg, RefB}, %% The message is passed Self -> Pid1B -> Pid2B -> Self, and the %% seq_trace token follows invisibly. Traced functions are %% called in Pid1B and Pid2B. Seq_trace flags == 0 so no %% seq_trace messages are generated. ?line receive {Pid2B, msg, RefB} -> ok end, %% The values of these counters {.., 1, _, 0}, {.., 2, _, 1} %% depend on that seq_trace has been reset just before this test. ?line Token1B = {0, Label, 1, Self, 0}, ?line Token2B = {0, Label, 2, Pid1B, 1}, ?line {ok, [{trace, Pid1B, call, {?MODULE, call_tracee_1, [RefB]}, {Pid1B, Token1B}}, {trace, Pid2B, call, {?MODULE, call_tracee_2, [RefB]}, {Pid2B, Token2B}}]} = TrB({stop,2}), ?line seq_trace:reset_trace(), ok. port(doc) -> "Send trace messages to a port."; port(suite) -> []; port(Config) when is_list(Config) -> lists:foreach(fun (TsType) -> do_port(TsType, Config) end, ?TIMESTAMP_MODES). do_port(TsType, Config) -> io:format("Testing ~p~n",[TsType]), ?line Port = load_tracer(Config), ?line seq_trace:set_system_tracer(Port), ?line set_token_flags([print, TsType]), ?line Small = [small,term], ?line seq_trace:print(0, Small), ?line case get_port_message(Port) of {seq_trace,0,{print,_,_,[],Small}} when TsType == no_timestamp -> ok; {seq_trace,0,{print,_,_,[],Small},Ts0} when TsType /= no_timestamp -> check_ts(TsType, Ts0), ok; Other -> ?line seq_trace:reset_trace(), ct:fail({unexpected,Other}) end, %% OTP-4218 Messages from ports should not affect seq trace token. %% %% Check if trace token still is active on this process after %% the get_port_message/1 above that receives from a port. ?line OtherSmall = [other | Small], ?line seq_trace:print(0, OtherSmall), ?line seq_trace:reset_trace(), ?line case get_port_message(Port) of {seq_trace,0,{print,_,_,[],OtherSmall}} when TsType == no_timestamp -> ok; {seq_trace,0,{print,_,_,[],OtherSmall}, Ts1} when TsType /= no_timestamp -> check_ts(TsType, Ts1), ok; Other1 -> ct:fail({unexpected,Other1}) end, ?line seq_trace:set_token(print, true), ?line Huge = huge_data(), ?line seq_trace:print(0, Huge), ?line seq_trace:reset_trace(), ?line case get_port_message(Port) of {seq_trace,0,{print,_,_,[],Huge}} -> ok; Other2 -> ct:fail({unexpected,Other2}) end, unlink(Port), exit(Port,kill), ok. get_port_message(Port) -> receive {Port,{data,Bin}} when is_binary(Bin) -> binary_to_term(Bin); Other -> ct:fail({unexpected,Other}) after 5000 -> ct:fail(timeout) end. match_set_seq_token(suite) -> []; match_set_seq_token(doc) -> ["Tests that match spec function set_seq_token does not " "corrupt the heap"]; match_set_seq_token(Config) when is_list(Config) -> ?line Parent = self(), %% OTP-4222 Match spec 'set_seq_token' corrupts heap %% %% This test crashes the emulator if the bug in question is present, %% it is therefore done in a slave node. %% %% All the timeout stuff is here to get decent accuracy of the error %% return value, instead of just 'timeout'. % ?line {ok, Sandbox} = start_node(seq_trace_other, []), ?line true = rpc:call(Sandbox, code, add_patha, [filename:dirname(code:which(?MODULE))]), ?line Lbl = 4711, %% Do the possibly crashing test ?line P1 = spawn( fun () -> Parent ! {self(), rpc:call(Sandbox, ?MODULE, do_match_set_seq_token, [Lbl])} end), %% Probe the node with a simple rpc request, to see if it is alive. ?line P2 = spawn( fun () -> receive after 4000 -> ok end, Parent ! {self(), rpc:call(Sandbox, erlang, abs, [-1])} end), %% If the test node hangs completely, this timer expires. ?line R3 = erlang:start_timer(8000, self(), void), %% ?line {ok, Log} = receive {P1, Result} -> exit(P2, done), erlang:cancel_timer(R3), Result; {P2, 1} -> exit(P1, timeout), erlang:cancel_timer(R3), {error, "Test process hung"}; {timeout, R3, _} -> exit(P1, timeout), exit(P2, timeout), {error, "Test node hung"} end, ?line ok = check_match_set_seq_token_log(Lbl, Log), %% ?line stop_node(Sandbox), ok. %% OTP-4222 Match spec 'set_seq_token' corrupts heap %% %% The crashing test goes as follows: %% %% One trigger function calls match spec function {set_seq_token, _, _}, %% which when faulty corrupts the heap. It is assured that the process %% in question has a big heap and recently garbage collected so there %% will be room on the heap, which is necessary for the crash to happen. %% %% Then two processes bounces a few messages between each other, and if %% the heap is crashed the emulator crashes, or the triggering process's %% loop data gets corrupted so the loop never ends. do_match_set_seq_token(Label) -> seq_trace:reset_trace(), Tr = transparent_tracer(), TrPid = Tr(pid), erlang:trace_pattern({?MODULE, '_', '_'}, [{'_', [{is_seq_trace}], [{message, {get_seq_token}}]}], [local]), erlang:trace_pattern({?MODULE, countdown, 2}, [{'_', [], [{set_seq_token, label, Label}, {message, {get_seq_token}}]}], [local]), erlang:trace(new, true, [call, {tracer, TrPid}]), Ref = make_ref(), Bounce = spawn(fun () -> bounce(Ref) end), Mref = erlang:monitor(process, Bounce), _Countdown = erlang:spawn_opt(?MODULE, countdown_start, [Bounce, Ref], [{min_heap_size, 4192}]), receive {'DOWN', Mref, _, _, normal} -> Result = Tr({stop, 0}), seq_trace:reset_trace(), erlang:trace(new, false, [call]), Result; {'DOWN', Mref, _, _, Reason} -> Tr({stop, 0}), seq_trace:reset_trace(), erlang:trace(new, false, [call]), {error, Reason} end. check_match_set_seq_token_log( Label, [{trace,C,call,{?MODULE,countdown,[B,Ref]}, {0,Label,0,C,0}}, {trace,C,call,{?MODULE,countdown,[B,Ref,3]},{0,Label,0,C,0}}, {trace,B,call,{?MODULE,bounce, [Ref]}, {0,Label,2,B,1}}, {trace,C,call,{?MODULE,countdown,[B,Ref,2]},{0,Label,2,B,1}}, {trace,B,call,{?MODULE,bounce, [Ref]}, {0,Label,4,B,3}}, {trace,C,call,{?MODULE,countdown,[B,Ref,1]},{0,Label,4,B,3}}, {trace,B,call,{?MODULE,bounce, [Ref]}, {0,Label,6,B,5}}, {trace,C,call,{?MODULE,countdown,[B,Ref,0]},{0,Label,6,B,5}} ]) -> ok; check_match_set_seq_token_log(_Label, Log) -> {error, Log}. countdown_start(Bounce, Ref) -> %% This gc and the increased heap size of this process ensures that %% the match spec executed for countdown/2 has got heap space for %% the trace token, so the heap gets trashed according to OTP-4222. erlang:garbage_collect(), countdown(Bounce, Ref). countdown(Bounce, Ref) -> countdown(Bounce, Ref, 3). countdown(Bounce, Ref, 0) -> Bounce ! Ref; countdown(Bounce, Ref, Cnt) -> Tag = make_ref(), Bounce ! {Ref, self(), {Tag, Cnt}}, receive {Tag, Cnt} -> countdown(Bounce, Ref, Cnt-1) end. bounce(Ref) -> receive Ref -> ok; {Ref, Dest, Msg} -> Dest ! Msg, bounce(Ref) end. gc_seq_token(suite) -> []; gc_seq_token(doc) -> ["Tests that a seq_trace token on a message in the inqueue ", "can be garbage collected."]; gc_seq_token(Config) when is_list(Config) -> ?line Parent = self(), %% OTP-4555 Seq trace token causes free mem read in gc %% %% This test crashes the emulator if the bug in question is present, %% it is therefore done in a slave node. %% %% All the timeout stuff is here to get decent accuracy of the error %% return value, instead of just 'timeout'. % ?line {ok, Sandbox} = start_node(seq_trace_other, []), ?line true = rpc:call(Sandbox, code, add_patha, [filename:dirname(code:which(?MODULE))]), ?line Label = 4711, %% Do the possibly crashing test ?line P1 = spawn( fun () -> Parent ! {self(), rpc:call(Sandbox, ?MODULE, do_gc_seq_token, [Label])} end), %% Probe the node with a simple rpc request, to see if it is alive. ?line P2 = spawn( fun () -> receive after 4000 -> ok end, Parent ! {self(), rpc:call(Sandbox, erlang, abs, [-1])} end), %% If the test node hangs completely, this timer expires. ?line R3 = erlang:start_timer(8000, self(), void), %% ?line ok = receive {P1, Result} -> exit(P2, done), erlang:cancel_timer(R3), Result; {P2, 1} -> exit(P1, timeout), erlang:cancel_timer(R3), {error, "Test process hung"}; {timeout, R3, _} -> exit(P1, timeout), exit(P2, timeout), {error, "Test node hung"} end, %% ?line stop_node(Sandbox), ok. do_gc_seq_token(Label) -> Parent = self(), Comment = {"OTP-4555 Seq trace token causes free mem read in gc\n" "\n" "The crashing test goes as follows:\n" "\n" "Put a message with seq_trace token in the inqueue,\n" "Grow the process heap big enough to become mmap'ed\n" "and force a garbage collection using large terms\n" "to get a test_heap instruction with a big size value.\n" "Then try to trick the heap into shrinking.\n" "\n" "All this to make the GC move the heap between memory blocks.\n"}, seq_trace:reset_trace(), Child = spawn_link( fun() -> receive {Parent, no_seq_trace_token} -> ok end, do_grow(Comment, 256*1024, []), do_shrink(10), receive {Parent, seq_trace_token} -> ok end, Parent ! {self(), {token, seq_trace:get_token(label)}} end), seq_trace:set_token(label, Label), Child ! {Parent, seq_trace_token}, seq_trace:set_token([]), Child ! {Parent, no_seq_trace_token}, receive {Child, {token, {label, Label}}} -> ok; {Child, {token, Other}} -> {error, Other} end. do_grow(_, 0, Acc) -> Acc; do_grow(E, N, Acc) -> do_grow(E, N-1, [E | Acc]). do_shrink(0) -> ok; do_shrink(N) -> erlang:garbage_collect(), do_shrink(N-1). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% Internal help functions %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% Call trace targets call_tracee_1(X) -> X. call_tracee_2(X) -> X. transparent_tracer() -> Ref = make_ref(), Loop = fun(Fun, Log, LN) -> receive {stop, MinLN, Ref, From} when LN >= MinLN -> From ! {log, Ref, lists:reverse(Log)}; Entry when is_tuple(Entry) == false; element(1, Entry) /= stop -> Fun(Fun, [Entry | Log], LN+1) end end, Self = self(), Pid = spawn(fun() -> seq_trace:set_system_tracer(self()), Self ! {started, Ref}, Loop(Loop, [], 0) end), receive {started, Ref} -> ok end, fun(pid) -> Pid; ({stop, N}) when is_integer(N), N >= 0 -> Mref = erlang:monitor(process, Pid), receive {'DOWN', Mref, _, _, _} -> {error, not_started} after 0 -> DeliverRef = erlang:trace_delivered(all), receive {trace_delivered,_,DeliverRef} -> ok end, Pid ! {stop, N, Ref, self()}, receive {'DOWN', Mref, _, _, _} -> ok end, receive {log, Ref, Log} -> {ok, Log} end end end. one_time_receiver() -> receive _Term -> ok end. one_time_receiver(exit) -> receive Term -> exit({exit, Term}) end. simple_tracer(Data, DN) -> receive {seq_trace,Label,Info,Ts} -> simple_tracer([{Label,Info,Ts}|Data], DN+1); {seq_trace,Label,Info} -> simple_tracer([{Label,Info, no_timestamp}|Data], DN+1); {stop,N,From} when DN >= N -> From ! {tracerlog,lists:reverse(Data)} end. stop_tracer(N) when is_integer(N) -> case catch (seq_trace_SUITE_tracer ! {stop,N,self()}) of {'EXIT', _} -> {error, not_started}; _ -> receive {tracerlog,Data} -> Data after 1000 -> {error,timeout} end end. start_tracer() -> stop_tracer(0), Pid = spawn(?MODULE,simple_tracer,[[], 0]), register(seq_trace_SUITE_tracer,Pid), seq_trace:set_system_tracer(Pid), Pid. set_token_flags([]) -> ok; set_token_flags([no_timestamp|Flags]) -> seq_trace:set_token(timestamp, false), seq_trace:set_token(monotonic_timestamp, false), seq_trace:set_token(strict_monotonic_timestamp, false), set_token_flags(Flags); set_token_flags([Flag|Flags]) -> seq_trace:set_token(Flag, true), set_token_flags(Flags). check_ts(no_timestamp, Ts) -> try no_timestamp = Ts catch _ : _ -> ct:fail({unexpected_timestamp, Ts}) end, ok; check_ts(timestamp, Ts) -> try {Ms,S,Us} = Ts, true = is_integer(Ms), true = is_integer(S), true = is_integer(Us) catch _ : _ -> ct:fail({unexpected_timestamp, Ts}) end, ok; check_ts(monotonic_timestamp, Ts) -> try true = is_integer(Ts) catch _ : _ -> ct:fail({unexpected_timestamp, Ts}) end, ok; check_ts(strict_monotonic_timestamp, Ts) -> try {MT, UMI} = Ts, true = is_integer(MT), true = is_integer(UMI) catch _ : _ -> ct:fail({unexpected_timestamp, Ts}) end, ok. start_node(Name, Param) -> test_server:start_node(Name, slave, [{args, Param}]). stop_node(Node) -> test_server:stop_node(Node). load_tracer(Config) -> Path = proplists:get_value(data_dir, Config), ok = erl_ddll:load_driver(Path, echo_drv), open_port({spawn,echo_drv}, [eof,binary]). huge_data() -> huge_data(16384). huge_data(0) -> []; huge_data(N) when N rem 2 == 0 -> P = huge_data(N div 2), [P|P]; huge_data(N) -> P = huge_data(N div 2), [16#1234566,P|P].