The R13B03 release.OTP_R13B03

1 files changed, 461 insertions, 0 deletions

diff --git a/erts/emulator/test/sensitive_SUITE.erl b/erts/emulator/test/sensitive_SUITE.erl
new file mode 100644
index 0000000000..458275af81
--- /dev/null
+++ b/erts/emulator/test/sensitive_SUITE.erl
@@ -0,0 +1,461 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2007-2009. All Rights Reserved.
+%% 
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% %CopyrightEnd%
+%%
+
+-module(sensitive_SUITE).
+
+-include("test_server.hrl").
+
+-export([all/1,init_per_testcase/2,fin_per_testcase/2,
+	 stickiness/1,send_trace/1,recv_trace/1,proc_trace/1,call_trace/1,
+	 meta_trace/1,running_trace/1,gc_trace/1,seq_trace/1,
+	 t_process_info/1,t_process_display/1,save_calls/1]).
+
+-export([remote_process_display/0,an_exported_function/1]).
+
+-import(lists, [keysearch/3,foreach/2,sort/1]).
+
+init_per_testcase(Func, Config) when is_atom(Func), is_list(Config) ->
+    Dog = ?t:timetrap(?t:minutes(5)),
+    [{watchdog,Dog}|Config].
+
+fin_per_testcase(Func, Config) when is_atom(Func), is_list(Config) ->
+    Dog = ?config(watchdog, Config),
+    ?t:timetrap_cancel(Dog).
+
+all(suite) ->
+    [stickiness,send_trace,recv_trace,proc_trace,call_trace,
+     meta_trace,running_trace,gc_trace,seq_trace,
+     t_process_info,t_process_display,save_calls].
+    
+stickiness(Config) when is_list(Config) ->
+    ?line {Tracer,Mref} = spawn_monitor(fun() ->
+						receive after infinity -> ok end
+					end),
+    ?line false = process_flag(sensitive, true),
+    put(foo, bar),
+
+    Flags = sort([send,'receive',procs,call,running,garbage_collection,
+		  set_on_spawn,set_on_first_spawn,set_on_link,set_on_first_link]),
+    ?line foreach(fun(F) ->
+			  1 = erlang:trace(self(), true, [F,{tracer,Tracer}])
+		  end, Flags),
+    ?line foreach(fun(F) ->
+			  1 = erlang:trace(self(), false, [F,{tracer,Tracer}])
+		  end, Flags),
+    ?line 1 = erlang:trace(self(), true, [{tracer,Tracer}|Flags]),
+    ?line 1 = erlang:trace(self(), false, [{tracer,Tracer}|Flags]),
+
+    ?line {messages,[]} = process_info(Tracer, messages),
+    exit(Tracer, kill),
+    receive {'DOWN',Mref,_,_,_} -> ok end,
+    
+    case process_info(self(), dictionary) of
+	{dictionary,[]} -> ok;
+	{dictionary,_} -> ?line ?t:fail(sensitive_flag_cleared)
+    end,
+
+    NewTracer = spawn_link(fun() -> receive after infinity -> ok end end),
+    ?line 1 = erlang:trace(self(), true, [{tracer,NewTracer}|Flags]),
+    ?line Flags = sort(element(2, erlang:trace_info(self(), flags))),
+    ?line {tracer,NewTracer} = erlang:trace_info(self(), tracer),
+
+    %% Process still sensitive. Tracer should disappear when we clear
+    %% all trace flags.
+    ?line 1 = erlang:trace(self(), false, [{tracer,NewTracer}|Flags]),
+    ?line {tracer,[]} = erlang:trace_info(self(), tracer),
+
+    ?line unlink(NewTracer), exit(NewTracer, kill),
+    ok.
+
+send_trace(Config) when is_list(Config) ->
+    ?line {Dead,Mref} = spawn_monitor(fun() -> ok end),
+    receive {'DOWN',Mref,_,_,_} -> ok end,
+    ?line Tracer = spawn_link(fun() -> receive after infinity -> ok end end),
+    ?line Sink = spawn_link(fun() -> receive after infinity -> ok end end),
+    Self = self(),
+
+    ?line 1 = erlang:trace(self(), true, [send,{tracer,Tracer}]),
+    ?line Dead ! before,
+    ?line Sink ! before,
+    ?line false = process_flag(sensitive, true),
+    ?line Sink ! {blurf,lists:seq(1, 50)},
+    ?line true = process_flag(sensitive, true),
+    ?line Sink ! lists:seq(1, 100),
+    ?line Dead ! forget_me,
+    ?line true = process_flag(sensitive, false),
+    ?line Sink ! after1,
+    ?line false = process_flag(sensitive, false),
+    ?line Sink ! after2,
+    ?line Dead ! after2,
+    ?line wait_trace(Self),
+
+    ?line {messages,Messages} = process_info(Tracer, messages),
+    ?line [{trace,Self,send_to_non_existing_process,before,Dead},
+	   {trace,Self,send,before,Sink},
+	   {trace,Self,send,after1,Sink},
+	   {trace,Self,send,after2,Sink},
+	   {trace,Self,send_to_non_existing_process,after2,Dead}] = Messages,
+
+    ?line unlink(Tracer), exit(Tracer, kill),
+    ?line unlink(Sink), exit(Sink, kill),
+    ok.
+
+recv_trace(Config) when is_list(Config) ->
+    Parent = self(),
+    ?line Tracer = spawn_link(fun() -> receive after infinity -> ok end end),
+    ?line Sender = spawn_link(fun() -> recv_trace_sender(Parent) end),
+
+    ?line 1 = erlang:trace(self(), true, ['receive',{tracer,Tracer}]),
+
+    Sender ! 1,
+    receive a -> wait_trace(Sender) end,
+
+    ?line false = process_flag(sensitive, true),
+
+    Sender ! 2,
+    receive {b,[x,y,z]} -> wait_trace(Sender) end,
+    
+    ?line true = process_flag(sensitive, false),
+
+    Sender ! 3,
+    receive c -> wait_trace(Sender) end,
+    
+    ?line {messages,Messages} = process_info(Tracer, messages),
+    [{trace,Parent,'receive',a},
+     {trace,Parent,'receive',{trace_delivered,_,_}},
+     {trace,Parent,'receive',c},
+     {trace,Parent,'receive',{trace_delivered,_,_}}] = Messages,
+
+    ?line unlink(Tracer), exit(Tracer, kill),
+    ?line unlink(Sender), exit(Sender, kill),
+    ok.
+
+recv_trace_sender(Pid) ->
+    receive
+	1 -> Pid ! a;
+	2 -> Pid ! {b,[x,y,z]};
+	3 -> Pid ! c
+    end,
+    recv_trace_sender(Pid).
+
+proc_trace(Config) when is_list(Config) ->
+    Self = self(),
+    ?line Tracer = spawn_link(fun() -> receive after infinity -> ok end end),
+
+    ?line 1 = erlang:trace(self(), true, [procs,{tracer,Tracer}]),
+    ?line false = process_flag(sensitive, true),
+
+    spawn(fun() -> ok end),
+    ?line register(nisse, self()),
+    ?line unregister(nisse),
+    ?line link(Tracer),
+    ?line unlink(Tracer),
+    ?line Linker0 = spawn_link(fun() -> ok end),
+    Mref0 = erlang:monitor(process, Linker0),
+
+    ?line {_,Mref} = spawn_monitor(fun() -> link(Self), unlink(Self) end),
+
+    receive {'DOWN',Mref0,_,_,_} -> ok end,
+
+    receive {'DOWN',Mref,_,_,_} -> ok end,
+
+    ?line true = process_flag(sensitive, false),
+
+    Dead = spawn(fun() -> ok end),
+    ?line register(arne, self()),
+    ?line unregister(arne),
+    ?line {Linker,Mref2} = spawn_monitor(fun() -> link(Self), unlink(Self) end),
+    receive {'DOWN',Mref2,_,_,_} -> ok end,
+    ?line Last = spawn_link(fun() -> ok end),
+    receive after 10 -> ok end,
+    ?line wait_trace(all),
+    ?line {messages,Messages} = process_info(Tracer, messages),    
+    [{trace,Self,spawn,Dead,{erlang,apply,_}},
+     {trace,Self,register,arne},
+     {trace,Self,unregister,arne},
+     {trace,Self,spawn,Linker,_},
+     {trace,Self,getting_linked,Linker},
+     {trace,Self,getting_unlinked,Linker},
+     {trace,Self,spawn,Last,_},
+     {trace,Self,link,Last},
+     {trace,Self,getting_unlinked,Last}] = Messages,
+
+    ?line unlink(Tracer), exit(Tracer, kill),
+    ok.
+
+call_trace(Config) when is_list(Config) ->
+    Self = self(),
+    ?line Tracer = spawn_link(fun() -> receive after infinity -> ok end end),
+
+    ?line 1 = erlang:trace(self(), true, [call,{tracer,Tracer}]),
+    ?line 1 = erlang:trace_pattern({?MODULE,an_exported_function,1},
+				   true, [global]),
+    ?line 1 = erlang:trace_pattern({erlang,list_to_binary,1}, true, [global]),
+    ?line 1 = erlang:trace_pattern({erlang,binary_to_list,1}, true, [local]),
+    ?line Local = erlang:trace_pattern({?MODULE,'_','_'}, true, [local]),
+
+    ?line false = process_flag(sensitive, true),
+    ?line {ok,42} = a_local_function(42),
+    ?line 7 = an_exported_function(6),
+    ?line <<7,8,9,10>> = list_to_binary(id([7,8,9,10])),
+    ?line [42,43] = binary_to_list(id(<<42,43>>)),
+    ?line true = process_flag(sensitive, false),
+
+    ?line {ok,{a,b}} = a_local_function({a,b}),
+    ?line 1 = an_exported_function(0),
+    ?line <<1,2,3>> = list_to_binary(id([1,2,3])),
+    ?line [42,43,44] = binary_to_list(id(<<42,43,44>>)),
+
+    ?line wait_trace(Self),
+
+    ?line {messages,Messages} = process_info(Tracer, messages),    
+    ?line [{trace,Self,call,{?MODULE,a_local_function,[{a,b}]}},
+	   {trace,Self,call,{?MODULE,an_exported_function,[0]}},
+	   {trace,Self,call,{?MODULE,id,[_]}},
+	   {trace,Self,call,{erlang,list_to_binary,[[1,2,3]]}},
+	   {trace,Self,call,{sensitive_SUITE,id,[<<42,43,44>>]}},
+	   {trace,Self,call,{erlang,binary_to_list,[<<42,43,44>>]}},
+	   {trace,Self,call,{?MODULE,wait_trace,[Self]}}] = Messages,
+
+    ?line Local = erlang:trace_pattern({?MODULE,'_','_'}, false, [local]),
+    ?line erlang:trace_pattern({erlang,'_','_'}, false, [local]),
+    ?line erlang:trace_pattern({'_','_','_'}, false, [global]),
+
+    ?line unlink(Tracer), exit(Tracer, kill),
+    ok.
+
+meta_trace(Config) when is_list(Config) ->
+    Self = self(),
+    ?line Tracer = spawn_link(fun() -> receive after infinity -> ok end end),
+
+    ?line Local = erlang:trace_pattern({?MODULE,'_','_'}, true, [{meta,Tracer}]),
+    ?line 1 = erlang:trace_pattern({erlang,list_to_binary,1}, true, [{meta,Tracer}]),
+
+    ?line false = process_flag(sensitive, true),
+    ?line {ok,blurf} = a_local_function(blurf),
+    ?line 100 = an_exported_function(99),
+    ?line <<8,9,10>> = list_to_binary(id([8,9,10])),
+    ?line true = process_flag(sensitive, false),
+
+    ?line {ok,{x,y}} = a_local_function({x,y}),
+    ?line 1 = an_exported_function(0),
+    ?line <<10>> = list_to_binary(id([10])),
+    ?line wait_trace(Self),
+
+    ?line Local = erlang:trace_pattern({?MODULE,'_','_'}, false, [meta]),
+    ?line 1 = erlang:trace_pattern({erlang,list_to_binary,1}, false, [meta]),
+    ?line a_local_function(0),
+
+    ?line {messages,Messages} = process_info(Tracer, messages),    
+    ?line [{trace_ts,Self,call,{?MODULE,a_local_function,[{x,y}]},{_,_,_}},
+	   {trace_ts,Self,call,{?MODULE,an_exported_function,[0]},{_,_,_}},
+	   {trace_ts,Self,call,{?MODULE,id,[_]},{_,_,_}},
+	   {trace_ts,Self,call,{erlang,list_to_binary,[[10]]},{_,_,_}},
+	   {trace_ts,Self,call,{?MODULE,wait_trace,[Self]},{_,_,_}}] = Messages,
+
+    ?line unlink(Tracer), exit(Tracer, kill),
+    ok.
+
+a_local_function(A) ->
+    {ok,A}.
+
+an_exported_function(X) ->
+    X+1.
+
+running_trace(Config) when is_list(Config) ->
+    Self = self(),
+    ?line Tracer = spawn_link(fun() -> receive after infinity -> ok end end),
+
+    ?line false = process_flag(sensitive, true),
+    ?line 1 = erlang:trace(Self, true, [running,{tracer,Tracer}]),
+    erlang:yield(), erlang:yield(), erlang:yield(), erlang:yield(),
+    erlang:yield(), erlang:yield(), erlang:yield(), erlang:yield(),
+    ?line true = process_flag(sensitive, false),
+    erlang:yield(),
+    ?line 1 = erlang:trace(Self, false, [running,{tracer,Tracer}]),
+
+    ?line wait_trace(Self),
+    ?line {messages,Messages} = process_info(Tracer, messages),    
+    ?line [{trace,Self,out,{sensitive_SUITE,running_trace,1}},
+	   {trace,Self,in,{sensitive_SUITE,running_trace,1}}] = Messages,
+
+    ?line unlink(Tracer), exit(Tracer, kill),
+    ok.
+
+gc_trace(Config) when is_list(Config) ->
+    Self = self(),
+    ?line Tracer = spawn_link(fun() -> receive after infinity -> ok end end),
+
+    ?line false = process_flag(sensitive, true),
+    ?line 1 = erlang:trace(Self, true, [garbage_collection,{tracer,Tracer}]),
+    erlang:garbage_collect(), erlang:garbage_collect(),
+    erlang:garbage_collect(), erlang:garbage_collect(),
+    erlang:garbage_collect(), erlang:garbage_collect(),
+    erlang:garbage_collect(), erlang:garbage_collect(),
+    ?line true = process_flag(sensitive, false),
+    erlang:garbage_collect(),
+    ?line 1 = erlang:trace(Self, false, [garbage_collection,{tracer,Tracer}]),
+
+    ?line wait_trace(Self),
+    ?line {messages,Messages} = process_info(Tracer, messages),    
+    ?line [{trace,Self,gc_start,_},{trace,Self,gc_end,_}] = Messages,
+
+    ?line unlink(Tracer), exit(Tracer, kill),
+    ok.
+
+seq_trace(Config) when is_list(Config) ->
+    Self = self(),
+    ?line Tracer = spawn_link(fun() -> receive after infinity -> ok end end),
+    ?line seq_trace:set_system_tracer(Tracer),
+
+    ?line false = process_flag(sensitive, true),
+
+    ?line Echo = spawn_link(fun() ->
+				    receive
+					{Pid,Message} ->
+					    Pid ! {reply,Message}
+				    end
+			    end),
+    ?line Sender = spawn_link(fun() ->
+				      seq_trace:set_token(label, 42),
+				      seq_trace:set_token('receive', true),
+				      seq_trace:set_token(send, true),
+				      seq_trace:set_token(print, true),
+				      seq_trace:print(42, "trace started"),
+				      Self ! blurf
+			    end),
+    seq_trace:set_token(label, 17),
+    seq_trace:set_token('receive', true),
+    seq_trace:set_token(send, true),
+    seq_trace:set_token(print, true),
+    seq_trace:print(17, "trace started"),
+    Echo ! {Self,hello},
+    receive {reply,hello} -> ok end,
+    receive blurf -> ok end,
+
+    ?line wait_trace(all),
+
+    ?line {messages,Messages} = process_info(Tracer, messages),
+    ?line [{seq_trace,17,{'receive',{0,2},Self,Echo,{Self,hello}}},
+	   {seq_trace,17,{send,{2,3},Echo,Self,{reply,hello}}}] =
+	[M || {seq_trace,17,_}=M <- Messages],
+
+    ?line [{seq_trace,42,{print,{0,1},Sender,[],"trace started"}},
+	   {seq_trace,42,{send,{0,2},Sender,Self,blurf}}] =
+	[M || {seq_trace,42,_}=M <- Messages],
+    
+    ?line unlink(Tracer), exit(Tracer, kill),
+    ?line unlink(Echo), exit(Echo, kill),
+    ?line unlink(Sender), exit(Sender, kill),
+    ok.
+
+t_process_info(Config) when is_list(Config) ->
+    Parent = self(),
+    ?line Pid = spawn_link(fun() ->
+				   put(foo, bar),
+				   false = process_flag(sensitive, true),
+				   Parent ! go,
+				   receive
+				       revert ->
+					   true = process_flag(sensitive, false),
+					   Parent ! go_again,
+					   receive never -> ok end
+				   end end),
+    receive go -> ok end,
+
+    ?line put(foo, bar),
+    ?line self() ! Pid ! {i,am,a,message},
+
+    ?line false = process_flag(sensitive, true),
+    ?line t_process_info_suppressed(self()),
+    ?line t_process_info_suppressed(Pid),
+
+    ?line true = process_flag(sensitive, false),
+    Pid ! revert,
+    receive go_again -> ok end,
+
+    ?line t_process_info_normal(self()),
+    ?line t_process_info_normal(Pid),
+    ok.
+
+t_process_info_suppressed(Pid) ->
+    [] = my_process_info(Pid, dictionary),
+    <<>> = my_process_info(Pid, backtrace),
+    [] = my_process_info(Pid, messages).
+
+t_process_info_normal(Pid) ->
+    {value,{foo,bar}} = keysearch(foo, 1, my_process_info(Pid, dictionary)),
+    case process_info(Pid, backtrace) of
+	{backtrace,Bin} when size(Bin) > 20 -> ok
+    end,
+    [{i,am,a,message}] = my_process_info(Pid, messages).
+
+my_process_info(Pid, Tag) ->
+    {Tag,Value} = process_info(Pid, Tag),
+    All = process_info(Pid),
+    case keysearch(Tag, 1, All) of
+	false -> Value;
+	{value,{Tag,Value}} -> Value
+    end.
+
+t_process_display(Config) when is_list(Config) ->
+    ?line Dir = filename:dirname(code:which(?MODULE)),
+    ?line Cmd = atom_to_list(lib:progname()) ++ " -noinput -pa " ++ Dir ++
+	" -run " ++ ?MODULE_STRING ++ " remote_process_display",
+    ?line io:put_chars(Cmd),
+    ?line P = open_port({spawn,Cmd}, [in,stderr_to_stdout,eof]),
+    <<"done",_/binary>> = get_all(P),
+    ok.
+
+remote_process_display() ->
+    false = process_flag(sensitive, true),
+    erlang:process_display(self(), backtrace),
+    erlang:display(done),
+    receive after 10 -> ok end,
+    init:stop().
+
+get_all(P) ->
+    get_all(P, []).
+
+get_all(P, Acc) ->
+    receive
+	{P,{data,S}} ->
+	    get_all(P, [Acc|S]);
+	{P,eof} ->
+	    iolist_to_binary(Acc)
+    end.
+
+save_calls(Config) when is_list(Config) ->
+    process_flag(save_calls, 10),
+
+    false = process_flag(sensitive, true),
+    ?line {last_calls,LastCalls} = process_info(self(), last_calls),
+    ?line [{erlang,process_flag,2}] = LastCalls,
+    ?line [2,4,6] = lists:map(fun(E) -> 2*E end, [1,2,3]),
+    ?line {last_calls,LastCalls} = process_info(self(), last_calls),
+    ok.
+
+wait_trace(Pid) ->
+    Ref = erlang:trace_delivered(Pid),
+    receive
+	{trace_delivered,Pid,Ref} -> ok
+    end.
+    
+id(I) -> I.
+