1%% 2%% %CopyrightBegin% 3%% 4%% Copyright Ericsson AB 1997-2018. All Rights Reserved. 5%% 6%% Licensed under the Apache License, Version 2.0 (the "License"); 7%% you may not use this file except in compliance with the License. 8%% You may obtain a copy of the License at 9%% 10%% http://www.apache.org/licenses/LICENSE-2.0 11%% 12%% Unless required by applicable law or agreed to in writing, software 13%% distributed under the License is distributed on an "AS IS" BASIS, 14%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15%% See the License for the specific language governing permissions and 16%% limitations under the License. 17%% 18%% %CopyrightEnd% 19%% 20 21-module(trace_SUITE). 22 23%%% 24%%% Tests the trace BIF. 25%%% 26 27-export([all/0, suite/0, init_per_testcase/2, end_per_testcase/2, 28 link_receive_call_correlation/0, 29 receive_trace/1, link_receive_call_correlation/1, self_send/1, 30 timeout_trace/1, send_trace/1, 31 procs_trace/1, dist_procs_trace/1, procs_new_trace/1, 32 suspend/1, suspend_exit/1, suspender_exit/1, 33 suspend_system_limit/1, suspend_opts/1, suspend_waiting/1, 34 new_clear/1, existing_clear/1, tracer_die/1, 35 set_on_spawn/1, set_on_first_spawn/1, cpu_timestamp/1, 36 set_on_link/1, set_on_first_link/1, 37 system_monitor_args/1, more_system_monitor_args/1, 38 system_monitor_long_gc_1/1, system_monitor_long_gc_2/1, 39 system_monitor_large_heap_1/1, system_monitor_large_heap_2/1, 40 system_monitor_long_schedule/1, 41 bad_flag/1, trace_delivered/1, trap_exit_self_receive/1, 42 trace_info_badarg/1, erl_704/1]). 43 44-include_lib("common_test/include/ct.hrl"). 45 46%%% Internal exports 47-export([process/1]). 48 49suite() -> 50 [{ct_hooks,[ts_install_cth]}, 51 {timetrap, {minutes, 1}}]. 52 53all() -> 54 [cpu_timestamp, receive_trace, link_receive_call_correlation, 55 self_send, timeout_trace, 56 send_trace, procs_trace, dist_procs_trace, suspend, 57 suspend_exit, suspender_exit, 58 suspend_system_limit, suspend_opts, suspend_waiting, 59 new_clear, existing_clear, tracer_die, set_on_spawn, 60 set_on_first_spawn, set_on_link, set_on_first_link, 61 system_monitor_args, 62 more_system_monitor_args, system_monitor_long_gc_1, 63 system_monitor_long_gc_2, system_monitor_large_heap_1, 64 system_monitor_long_schedule, 65 system_monitor_large_heap_2, bad_flag, trace_delivered, 66 trap_exit_self_receive, trace_info_badarg, erl_704]. 67 68init_per_testcase(_Case, Config) -> 69 [{receiver,spawn(fun receiver/0)}|Config]. 70 71end_per_testcase(_Case, Config) -> 72 Receiver = proplists:get_value(receiver, Config), 73 unlink(Receiver), 74 exit(Receiver, die), 75 ok. 76 77%% No longer testing anything, just reporting whether cpu_timestamp 78%% is enabled or not. 79cpu_timestamp(Config) when is_list(Config) -> 80 %% Test whether cpu_timestamp is implemented on this platform. 81 Works = try erlang:trace(all, true, [cpu_timestamp]) of 82 _ -> 83 erlang:trace(all, false, [cpu_timestamp]), 84 true 85 catch 86 error:badarg -> false 87 end, 88 {comment,case Works of 89 false -> "cpu_timestamp is NOT implemented/does not work"; 90 true -> "cpu_timestamp works" 91 end}. 92 93 94%% Tests that trace(Pid, How, ['receive']) works. 95 96receive_trace(Config) when is_list(Config) -> 97 Receiver = proplists:get_value(receiver, Config), 98 99 %% Trace the process; make sure that we receive the trace messages. 100 1 = erlang:trace(Receiver, true, ['receive']), 101 Hello = {hello, world}, 102 Receiver ! Hello, 103 {trace, Receiver, 'receive', Hello} = receive_first_trace(), 104 Hello2 = {hello, again, world}, 105 Receiver ! Hello2, 106 {trace, Receiver, 'receive', Hello2} = receive_first_trace(), 107 receive_nothing(), 108 109 %% Test 'receive' with matchspec 110 F1 = fun ({Pat, IsMatching}) -> 111 set_trace_pattern('receive', Pat, []), 112 Receiver ! Hello, 113 case IsMatching of 114 true -> 115 {trace, Receiver, 'receive', Hello} = receive_first_trace(); 116 false -> 117 ok 118 end, 119 receive_nothing() 120 end, 121 From = self(), 122 Node = node(), 123 lists:foreach(F1, [{no, true}, 124 {[{[Node, undefined,"Unexpected"],[],[]}], false}, 125 {[{[Node, From,'_'],[],[]}], true}, 126 {[{[Node, '$1','_'],[{'=/=','$1',From}],[]}], false}, 127 {[{['$1', '_','_'],[{'=:=','$1',Node}],[]}], true}, 128 {false, false}, 129 {true, true}]), 130 131 %% Remote messages 132 OtherName = atom_to_list(?MODULE)++"_receive_trace", 133 {ok, OtherNode} = start_node(OtherName), 134 RemoteProc = spawn_link(OtherNode, ?MODULE, process, [self()]), 135 io:format("RemoteProc = ~p ~n", [RemoteProc]), 136 137 RemoteProc ! {send_please, Receiver, Hello}, 138 {trace, Receiver, 'receive', Hello} = receive_first_trace(), 139 RemoteProc ! {send_please, Receiver, 99}, 140 {trace, Receiver, 'receive', 99} = receive_first_trace(), 141 142 %% Remote with matchspec 143 F2 = fun (To, {Pat, IsMatching}) -> 144 set_trace_pattern('receive', Pat, []), 145 RemoteProc ! {send_please, To, Hello}, 146 case IsMatching of 147 true -> 148 {trace, Receiver, 'receive', Hello} = receive_first_trace(); 149 false -> 150 ok 151 end, 152 receive_nothing() 153 end, 154 F2(Receiver, {no, true}), 155 F2(Receiver, {[{[OtherNode, undefined,"Unexpected"],[],[]}], false}), 156 F2(Receiver, {[{[OtherNode, RemoteProc,'_'],[],[]}, 157 {[OtherNode, undefined,'_'],[],[]}], true}), 158 F2(Receiver, {[{[OtherNode, '$1','_'], 159 [{'orelse',{'=:=','$1',undefined},{'=/=',{node,'$1'},{node}}}], 160 []}], true}), 161 F2(Receiver, {[{['$1', '_','_'], [{'=:=','$1',OtherNode}], []}], true}), 162 F2(Receiver, {false, false}), 163 F2(Receiver, {true, true}), 164 165 %% Remote to named with matchspec 166 Name = trace_SUITE_receiver, 167 register(Name, Receiver), 168 NN = {Name, node()}, 169 F2(NN, {no, true}), 170 F2(NN, {[{[OtherNode, undefined,"Unexpected"],[],[]}], false}), 171 F2(NN, {[{[OtherNode, RemoteProc,'_'],[],[]}, 172 {[OtherNode, undefined,'_'],[],[]}], true}), 173 F2(NN, {[{[OtherNode, '$1','_'], 174 [{'orelse',{'=:=','$1',undefined},{'=/=',{node,'$1'},{node}}}], 175 []}], true}), 176 F2(NN, {[{['$1', '_','_'], [{'==','$1',OtherNode}], []}], true}), 177 F2(NN, {false, false}), 178 F2(NN, {true, true}), 179 180 unlink(RemoteProc), 181 true = stop_node(OtherNode), 182 183 %% Timeout 184 Receiver ! {set_timeout, 10}, 185 {trace, Receiver, 'receive', {set_timeout, 10}} = receive_first_trace(), 186 {trace, Receiver, 'receive', timeout} = receive_first_trace(), 187 erlang:trace_pattern('receive', [{[clock_service,undefined,timeout], [], []}], []), 188 Receiver ! {set_timeout, 7}, 189 {trace, Receiver, 'receive', timeout} = receive_first_trace(), 190 erlang:trace_pattern('receive', true, []), 191 192 %% Another process should not be able to trace Receiver. 193 process_flag(trap_exit, true), 194 Intruder = fun_spawn(fun() -> erlang:trace(Receiver, true, ['receive']) end), 195 {'EXIT', Intruder, {badarg, _}} = receive_first(), 196 197 %% Untrace the process; we should not receive anything. 198 1 = erlang:trace(Receiver, false, ['receive']), 199 Receiver ! {hello, there}, 200 Receiver ! any_garbage, 201 receive_nothing(), 202 203 %% Verify restrictions in matchspec for 'receive' 204 F3 = fun (Pat) -> {'EXIT', {badarg,_}} = (catch erlang:trace_pattern('receive', Pat, [])) end, 205 WC = ['_','_','_'], 206 F3([{WC,[],[{message, {process_dump}}]}]), 207 F3([{WC,[{is_seq_trace}],[]}]), 208 F3([{WC,[],[{set_seq_token,label,4711}]}]), 209 F3([{WC,[],[{get_seq_token}]}]), 210 F3([{WC,[],[{enable_trace,call}]}]), 211 F3([{WC,[],[{enable_trace,self(),call}]}]), 212 F3([{WC,[],[{disable_trace,call}]}]), 213 F3([{WC,[],[{disable_trace,self(),call}]}]), 214 F3([{WC,[],[{trace,[call],[]}]}]), 215 F3([{WC,[],[{trace,self(),[],[call]}]}]), 216 F3([{WC,[],[{caller}]}]), 217 F3([{WC,[],[{silent,true}]}]), 218 219 ok. 220 221%% Tests that receive of a message always happens before a call with 222%% that message and that links/unlinks are ordered together with the 223%% 'receive'. 224link_receive_call_correlation() -> 225 [{timetrap, {minutes, 5}}]. 226link_receive_call_correlation(Config) when is_list(Config) -> 227 Receiver = fun_spawn(fun F() -> 228 receive 229 stop -> ok; 230 M -> receive_msg(M), F() 231 end 232 end), 233 process_flag(trap_exit, true), 234 235 %% Trace the process; make sure that we receive the trace messages. 236 1 = erlang:trace(Receiver, true, ['receive', procs, call, timestamp, scheduler_id]), 237 1 = erlang:trace_pattern({?MODULE, receive_msg, '_'}, [], [local]), 238 239 Num = 100, 240 241 (fun F(0) -> []; 242 F(N) -> 243 if N rem 2 == 0 -> 244 link(Receiver); 245 true -> 246 unlink(Receiver) 247 end, 248 [Receiver ! N | F(N-1)] 249 end)(Num), 250 251 Receiver ! stop, 252 MonRef = erlang:monitor(process, Receiver), 253 receive {'DOWN', MonRef, _, _, _} -> ok end, 254 Ref = erlang:trace_delivered(Receiver), 255 receive {trace_delivered, _, Ref} -> ok end, 256 257 Msgs = (fun F() -> receive M -> [M | F()] after 1 -> [] end end)(), 258 259 case check_consistent(Receiver, Num, Num, Num, Msgs, false, undefined) of 260 ok -> 261 ok; 262 {error, Reason} -> 263 ct:log("~p", [Msgs]), 264 ct:fail({error, Reason}) 265 end. 266 267-define(schedid, , _). 268 269check_consistent(_Pid, Recv, Call, _LU, [Msg | _], _Received, _LinkedN) when Recv > Call -> 270 {error, Msg}; 271check_consistent(Pid, Recv, Call, LU, [Msg | Msgs], false, undefined) -> 272 273 case Msg of 274 {trace, Pid, 'receive', Recv ?schedid} -> 275 check_consistent(Pid,Recv - 1, Call, LU, Msgs, true, undefined); 276 {trace_ts, Pid, 'receive', Recv ?schedid, _} -> 277 check_consistent(Pid,Recv - 1, Call, LU, Msgs, true, undefined); 278 279 {trace, Pid, call, {?MODULE, receive_msg, [Call]} ?schedid} -> 280 check_consistent(Pid,Recv, Call - 1, LU, Msgs, false, undefined); 281 {trace_ts, Pid, call, {?MODULE, receive_msg, [Call]} ?schedid, _} -> 282 check_consistent(Pid,Recv, Call - 1, LU, Msgs, false, undefined); 283 284 {trace, Pid, _, _Self ?schedid} -> 285 check_consistent(Pid, Recv, Call, LU, Msgs, false, undefined); 286 {trace_ts, Pid, _, _Self ?schedid, _} -> 287 check_consistent(Pid, Recv, Call, LU, Msgs, false, undefined); 288 289 Msg -> 290 {error, Msg} 291 end; 292check_consistent(Pid, Recv, Call, LU, [Msg | Msgs], true, undefined) -> 293 294 case Msg of 295 {trace, Pid, call, {?MODULE, receive_msg, [Call]} ?schedid} -> 296 check_consistent(Pid,Recv, Call - 1, LU, Msgs, true, undefined); 297 {trace_ts, Pid, call, {?MODULE, receive_msg, [Call]} ?schedid, _} -> 298 check_consistent(Pid,Recv, Call - 1, LU, Msgs, true, undefined); 299 300 {trace, Pid, getting_linked, _Self ?schedid} -> 301 check_consistent(Pid, Recv, Call, LU - 1, Msgs, true, Recv rem 2); 302 {trace_ts, Pid, getting_linked, _Self ?schedid, _} -> 303 check_consistent(Pid, Recv, Call, LU - 1, Msgs, true, Recv rem 2); 304 305 {trace, Pid, getting_unlinked, _Self ?schedid} -> 306 check_consistent(Pid, Recv, Call, LU - 1, Msgs, true, (Recv+1) rem 2); 307 {trace_ts, Pid, getting_unlinked, _Self ?schedid, _} -> 308 check_consistent(Pid, Recv, Call, LU - 1, Msgs, true, (Recv+1) rem 2); 309 310 Msg -> 311 {error, Msg} 312 end; 313check_consistent(Pid, Recv, Call, LU, [Msg | Msgs], true, LinkedN) -> 314 UnlinkedN = (LinkedN + 1) rem 2, 315 316 case Msg of 317 {trace, Pid, 'receive', Recv ?schedid} when Recv == LU -> 318 check_consistent(Pid,Recv - 1, Call, LU, Msgs, true, LinkedN); 319 {trace_ts, Pid, 'receive', Recv ?schedid, _} when Recv == LU -> 320 check_consistent(Pid,Recv - 1, Call, LU, Msgs, true, LinkedN); 321 322 {trace, Pid, call, {?MODULE, receive_msg, [Call]} ?schedid} -> 323 check_consistent(Pid,Recv, Call - 1, LU, Msgs, true, LinkedN); 324 {trace_ts, Pid, call, {?MODULE, receive_msg, [Call]} ?schedid, _} -> 325 check_consistent(Pid,Recv, Call - 1, LU, Msgs, true, LinkedN); 326 327 %% We check that for each receive we have gotten a 328 %% getting_linked or getting_unlinked message. Also 329 %% if we receive a getting_linked, then the next 330 %% message we expect to receive is an even number 331 %% and odd number for getting_unlinked. 332 {trace, Pid, getting_linked, _Self ?schedid} 333 when Recv rem 2 == LinkedN -> 334 check_consistent(Pid, Recv, Call, LU - 1, Msgs, true, LinkedN); 335 {trace_ts, Pid, getting_linked, _Self ?schedid, _} 336 when Recv rem 2 == LinkedN -> 337 check_consistent(Pid, Recv, Call, LU - 1, Msgs, true, LinkedN); 338 339 {trace, Pid, getting_unlinked, _Self ?schedid} 340 when Recv rem 2 == UnlinkedN -> 341 check_consistent(Pid, Recv, Call, LU - 1, Msgs, true, LinkedN); 342 {trace_ts, Pid, getting_unlinked, _Self ?schedid, _} 343 when Recv rem 2 == UnlinkedN -> 344 check_consistent(Pid, Recv, Call, LU - 1, Msgs, true, LinkedN); 345 346 {trace,Pid,'receive',Ignore ?schedid} 347 when Ignore == stop; Ignore == timeout -> 348 check_consistent(Pid, Recv, Call, LU, Msgs, true, LinkedN); 349 {trace_ts,Pid,'receive',Ignore ?schedid,_} 350 when Ignore == stop; Ignore == timeout -> 351 check_consistent(Pid, Recv, Call, LU, Msgs, true, LinkedN); 352 353 {trace, Pid, exit, normal ?schedid} -> 354 check_consistent(Pid, Recv, Call, LU, Msgs, true, LinkedN); 355 {trace_ts, Pid, exit, normal ?schedid, _} -> 356 check_consistent(Pid, Recv, Call, LU, Msgs, true, LinkedN); 357 {'EXIT', Pid, normal} -> 358 check_consistent(Pid, Recv, Call, LU, Msgs, true, LinkedN); 359 Msg -> 360 {error, Msg} 361 end; 362check_consistent(_, 0, 0, 1, [], true, _) -> 363 ok; 364check_consistent(_, Recv, Call, LU, [], _, _) -> 365 {error,{Recv, Call, LU}}. 366 367receive_msg(M) -> 368 M. 369 370%% Test that traces are generated for messages sent 371%% and received to/from self(). 372self_send(Config) when is_list(Config) -> 373 Fun = 374 fun(Self, Parent) -> receive 375 go_ahead -> 376 self() ! from_myself, 377 Self(Self, Parent); 378 from_myself -> 379 Parent ! done 380 end 381 end, 382 Self = self(), 383 SelfSender = fun_spawn(Fun, [Fun, Self]), 384 erlang:trace(SelfSender, true, ['receive', 'send']), 385 SelfSender ! go_ahead, 386 receive {trace, SelfSender, 'receive', go_ahead} -> ok end, 387 receive {trace, SelfSender, 'receive', from_myself} -> ok end, 388 receive 389 {trace,SelfSender,send,from_myself,SelfSender} -> ok 390 end, 391 receive {trace,SelfSender,send,done,Self} -> ok end, 392 receive done -> ok end, 393 ok. 394 395%% Test that we can receive timeout traces. 396timeout_trace(Config) when is_list(Config) -> 397 Process = fun_spawn(fun process/0), 398 1 = erlang:trace(Process, true, ['receive']), 399 Process ! timeout_please, 400 {trace, Process, 'receive', timeout_please} = receive_first_trace(), 401 {trace, Process, 'receive', timeout} = receive_first_trace(), 402 receive_nothing(), 403 ok. 404 405%% Tests that trace(Pid, How, [send]) works. 406 407send_trace(Config) when is_list(Config) -> 408 process_flag(trap_exit, true), 409 Sender = fun_spawn(fun sender/0), 410 Receiver = proplists:get_value(receiver, Config), 411 412 %% Check that a message sent to another process is traced. 413 1 = erlang:trace(Sender, true, [send]), 414 F1 = fun (Pat) -> 415 set_trace_pattern(send, Pat, []), 416 Sender ! {send_please, Receiver, to_receiver}, 417 {trace, Sender, send, to_receiver, Receiver} = receive_first_trace(), 418 receive_nothing() 419 end, 420 lists:foreach(F1, [no, 421 [{[Receiver,to_receiver],[],[]}], 422 [{['_','_'],[],[]}], 423 [{['$1','_'],[{is_pid,'$1'}],[]}], 424 [{['_','$1'],[{is_atom,'$1'}],[]}], 425 true]), 426 427 %% Test {message, Msg} 428 F1m = fun ({Pat, Msg}) -> 429 set_trace_pattern(send, Pat, []), 430 Sender ! {send_please, Receiver, to_receiver}, 431 {trace, Sender, send, to_receiver, Receiver, Msg} = receive_first_trace(), 432 receive_nothing() 433 end, 434 lists:foreach(F1m, [{[{['_','_'],[],[{message, 4711}]}], 4711}, 435 {[{['_','_'],[],[{message, "4711"}]}], "4711"} 436 ]), 437 438 %% Test {message, {process_dump}} 439 set_trace_pattern(send, [{['_','_'],[],[{message, {process_dump}}]}], []), 440 Sender ! {send_please, Receiver, to_receiver}, 441 {trace, Sender, send, to_receiver, Receiver, ProcDump} = receive_first_trace(), 442 true = is_binary(ProcDump), 443 receive_nothing(), 444 445 %% Same test with false match spec 446 F2 = fun (Pat) -> 447 set_trace_pattern(send, Pat, []), 448 Sender ! {send_please, Receiver, to_receiver}, 449 receive_nothing() 450 end, 451 lists:foreach(F2, [[{[Sender,to_receiver],[],[]}], 452 [{[Receiver,nomatch],[],[]}], 453 [{['$1','_'],[{is_atom,'$1'}],[]}], 454 [{['_','$1'],[{is_pid,'$1'}],[]}], 455 false, 456 [{['_','_'],[],[{message,false}]}], 457 [{['_','_'],[],[{silent,true}]}]]), 458 erlang:trace_pattern(send, true, []), 459 erlang:trace(Sender, false, [silent]), 460 461 %% Check that a message sent to another registered process is traced. 462 register(?MODULE,Receiver), 463 F3 = fun (Pat) -> 464 set_trace_pattern(send, Pat, []), 465 Sender ! {send_please, ?MODULE, to_receiver}, 466 {trace, Sender, send, to_receiver, ?MODULE} = receive_first_trace(), 467 receive_nothing() 468 end, 469 lists:foreach(F3, [no, 470 [{[?MODULE,to_receiver],[],[]}], 471 [{['_','_'],[],[]}], 472 [{['$1','_'],[{is_atom,'$1'}],[]}], 473 [{['_','$1'],[{is_atom,'$1'}],[]}], 474 true]), 475 %% Again with false match spec 476 F4 = fun (Pat) -> 477 set_trace_pattern(send, Pat, []), 478 Sender ! {send_please, ?MODULE, to_receiver}, 479 receive_nothing() 480 end, 481 lists:foreach(F4, [[{[nomatch,to_receiver],[],[]}], 482 [{[?MODULE,nomatch],[],[]}], 483 [{['$1','_'],[{is_pid,'$1'}],[]}], 484 [{['_','$1'],[{is_pid,'$1'}],[]}], 485 [{['_','_'],[],[{message,false}]}], 486 [{['_','_'],[],[{silent,true}]}] 487 ]), 488 unregister(?MODULE), 489 erlang:trace_pattern(send, true, []), 490 erlang:trace(Sender, false, [silent]), 491 492 %% Check that a message sent to this process is traced. 493 F5 = fun (Pat) -> 494 set_trace_pattern(send, Pat, []), 495 Sender ! {send_please, self(), to_myself}, 496 receive to_myself -> ok end, 497 Self = self(), 498 {trace, Sender, send, to_myself, Self} = receive_first_trace(), 499 receive_nothing() 500 end, 501 lists:foreach(F5, [no, 502 [{[self(),to_myself],[],[]}], 503 [{['_','_'],[],[]}], 504 true]), 505 506 %% Check that a message sent to dead process is traced. 507 {Pid,Ref} = spawn_monitor(fun() -> ok end), 508 receive {'DOWN',Ref,_,_,_} -> ok end, 509 F6 = fun (Pat) -> 510 set_trace_pattern(send, Pat, []), 511 Sender ! {send_please, Pid, to_dead}, 512 {trace, Sender, send_to_non_existing_process, to_dead, Pid} = receive_first_trace(), 513 receive_nothing() 514 end, 515 lists:foreach(F6, [no, 516 [{[Pid,to_dead],[],[]}], 517 [{['_','_'],[],[]}], 518 true]), 519 520 %% Check that a message sent to unknown registrated process is traced. 521 BadargSender = fun_spawn(fun sender/0), 522 1 = erlang:trace(BadargSender, true, [send]), 523 unlink(BadargSender), 524 BadargSender ! {send_please, not_registered, to_unknown}, 525 {trace, BadargSender, send, to_unknown, not_registered} = receive_first_trace(), 526 receive_nothing(), 527 528 %% Another process should not be able to trace Sender. 529 Intruder = fun_spawn(fun() -> erlang:trace(Sender, true, [send]) end), 530 {'EXIT', Intruder, {badarg, _}} = receive_first(), 531 532 %% Untrace the sender process and make sure that we receive no more 533 %% trace messages. 534 1 = erlang:trace(Sender, false, [send]), 535 Sender ! {send_please, Receiver, to_receiver}, 536 Sender ! {send_please, self(), to_myself_again}, 537 receive to_myself_again -> ok end, 538 receive_nothing(), 539 540 {'EXIT',{badarg,_}} = (catch erlang:trace_pattern(send, true, [global])), 541 {'EXIT',{badarg,_}} = (catch erlang:trace_pattern(send, true, [local])), 542 {'EXIT',{badarg,_}} = (catch erlang:trace_pattern(send, true, [meta])), 543 {'EXIT',{badarg,_}} = (catch erlang:trace_pattern(send, true, [{meta,self()}])), 544 {'EXIT',{badarg,_}} = (catch erlang:trace_pattern(send, true, [call_count])), 545 {'EXIT',{badarg,_}} = (catch erlang:trace_pattern(send, true, [call_time])), 546 {'EXIT',{badarg,_}} = (catch erlang:trace_pattern(send, restart, [])), 547 {'EXIT',{badarg,_}} = (catch erlang:trace_pattern(send, pause, [])), 548 {'EXIT',{badarg,_}} = (catch erlang:trace_pattern(send, [{['_','_'],[],[{caller}]}], [])), 549 550 %% Done. 551 ok. 552 553set_trace_pattern(_, no, _) -> 0; 554set_trace_pattern(MFA, Pat, Flg) -> 555 R = erlang:trace_pattern(MFA, Pat, Flg), 556 {match_spec, Pat} = erlang:trace_info(MFA, match_spec), 557 R. 558 559%% Test trace(Pid, How, [procs]). 560procs_trace(Config) when is_list(Config) -> 561 Name = list_to_atom(atom_to_list(?MODULE)++"_procs_trace"), 562 Self = self(), 563 process_flag(trap_exit, true), 564 %% 565 Proc1 = spawn_link(?MODULE, process, [Self]), 566 io:format("Proc1 = ~p ~n", [Proc1]), 567 Proc2 = spawn(?MODULE, process, [Self]), 568 io:format("Proc2 = ~p ~n", [Proc2]), 569 %% 570 1 = erlang:trace(Proc1, true, [procs, set_on_first_spawn]), 571 MFA = {?MODULE, process, [Self]}, 572 %% 573 %% spawn, link 574 Proc1 ! {spawn_link_please, Self, MFA}, 575 Proc3 = receive {spawned, Proc1, P3} -> P3 end, 576 receive {trace, Proc3, spawned, Proc1, MFA} -> ok end, 577 receive {trace, Proc3, getting_linked, Proc1} -> ok end, 578 {trace, Proc1, spawn, Proc3, MFA} = receive_first_trace(), 579 io:format("Proc3 = ~p ~n", [Proc3]), 580 {trace, Proc1, link, Proc3} = receive_first_trace(), 581 receive_nothing(), 582 %% 583 %% getting_unlinked by exit() 584 Proc1 ! {trap_exit_please, true}, 585 Reason3 = make_ref(), 586 Proc1 ! {send_please, Proc3, {exit_please, Reason3}}, 587 receive {Proc1, {'EXIT', Proc3, Reason3}} -> ok end, 588 receive {trace, Proc3, exit, Reason3} -> ok end, 589 {trace, Proc1, getting_unlinked, Proc3} = receive_first_trace(), 590 Proc1 ! {trap_exit_please, false}, 591 receive_nothing(), 592 %% 593 %% link 594 Proc1 ! {link_please, Proc2}, 595 {trace, Proc1, link, Proc2} = receive_first_trace(), 596 receive_nothing(), 597 %% 598 %% unlink 599 Proc1 ! {unlink_please, Proc2}, 600 {trace, Proc1, unlink, Proc2} = receive_first_trace(), 601 receive_nothing(), 602 %% 603 %% getting_linked 604 Proc2 ! {link_please, Proc1}, 605 {trace, Proc1, getting_linked, Proc2} = receive_first_trace(), 606 receive_nothing(), 607 %% 608 %% getting_unlinked 609 Proc2 ! {unlink_please, Proc1}, 610 {trace, Proc1, getting_unlinked, Proc2} = receive_first_trace(), 611 receive_nothing(), 612 %% 613 %% register 614 true = register(Name, Proc1), 615 {trace, Proc1, register, Name} = receive_first_trace(), 616 receive_nothing(), 617 %% 618 %% unregister 619 true = unregister(Name), 620 {trace, Proc1, unregister, Name} = receive_first_trace(), 621 receive_nothing(), 622 %% 623 %% exit (with registered name, due to link) 624 Reason4 = make_ref(), 625 Proc1 ! {spawn_link_please, Self, MFA}, 626 Proc4 = receive {spawned, Proc1, P4} -> P4 end, 627 {trace, Proc1, spawn, Proc4, MFA} = receive_first_trace(), 628 io:format("Proc4 = ~p ~n", [Proc4]), 629 {trace, Proc1, link, Proc4} = receive_first_trace(), 630 Proc1 ! {register_please, Name, Proc1}, 631 {trace, Proc1, register, Name} = receive_first_trace(), 632 Proc4 ! {exit_please, Reason4}, 633 receive {'EXIT', Proc1, Reason4} -> ok end, 634 {trace, Proc1, exit, Reason4} = receive_first_trace(), 635 {trace, Proc1, unregister, Name} = receive_first_trace(), 636 receive_nothing(), 637 %% 638 %% exit (not linked to tracing process) 639 1 = erlang:trace(Proc2, true, [procs]), 640 Reason2 = make_ref(), 641 Proc2 ! {exit_please, Reason2}, 642 {trace, Proc2, exit, Reason2} = receive_first_trace(), 643 receive_nothing(), 644 ok. 645 646 647dist_procs_trace(Config) when is_list(Config) -> 648 ct:timetrap({seconds, 15}), 649 OtherName = atom_to_list(?MODULE)++"_dist_procs_trace", 650 {ok, OtherNode} = start_node(OtherName), 651 Self = self(), 652 process_flag(trap_exit, true), 653 %% 654 Proc1 = spawn_link(?MODULE, process, [Self]), 655 io:format("Proc1 = ~p ~n", [Proc1]), 656 Proc2 = spawn(OtherNode, ?MODULE, process, [Self]), 657 io:format("Proc2 = ~p ~n", [Proc2]), 658 %% 659 1 = erlang:trace(Proc1, true, [procs]), 660 MFA = {?MODULE, process, [Self]}, 661 %% 662 %% getting_unlinked by exit() 663 Proc1 ! {spawn_link_please, Self, OtherNode, MFA}, 664 Proc1 ! {trap_exit_please, true}, 665 Proc3 = receive {spawned, Proc1, P3} -> P3 end, 666 io:format("Proc3 = ~p ~n", [Proc3]), 667 {trace, Proc1, getting_linked, Proc3} = receive_first_trace(), 668 Reason3 = make_ref(), 669 Proc1 ! {send_please, Proc3, {exit_please, Reason3}}, 670 receive {Proc1, {'EXIT', Proc3, Reason3}} -> ok end, 671 {trace, Proc1, getting_unlinked, Proc3} = receive_first_trace(), 672 Proc1 ! {trap_exit_please, false}, 673 receive_nothing(), 674 %% 675 %% link 676 Proc1 ! {link_please, Proc2}, 677 {trace, Proc1, link, Proc2} = receive_first_trace(), 678 receive_nothing(), 679 %% 680 %% unlink 681 Proc1 ! {unlink_please, Proc2}, 682 {trace, Proc1, unlink, Proc2} = receive_first_trace(), 683 receive_nothing(), 684 %% 685 %% getting_linked 686 Proc2 ! {link_please, Proc1}, 687 {trace, Proc1, getting_linked, Proc2} = receive_first_trace(), 688 receive_nothing(), 689 %% 690 %% getting_unlinked 691 Proc2 ! {unlink_please, Proc1}, 692 {trace, Proc1, getting_unlinked, Proc2} = receive_first_trace(), 693 receive_nothing(), 694 695 %% 696 %% exit (with registered name, due to link) 697 Name = list_to_atom(OtherName), 698 Reason2 = make_ref(), 699 Proc1 ! {link_please, Proc2}, 700 {trace, Proc1, link, Proc2} = receive_first_trace(), 701 Proc1 ! {register_please, Name, Proc1}, 702 {trace, Proc1, register, Name} = receive_first_trace(), 703 Proc2 ! {exit_please, Reason2}, 704 receive {'EXIT', Proc1, Reason2} -> ok end, 705 {trace, Proc1, exit, Reason2} = receive_first_trace(), 706 {trace, Proc1, unregister, Name} = receive_first_trace(), 707 receive_nothing(), 708 %% 709 %% Done. 710 true = stop_node(OtherNode), 711 ok. 712 713%% Test trace(new, How, [procs]). 714procs_new_trace(Config) when is_list(Config) -> 715 Self = self(), 716 process_flag(trap_exit, true), 717 %% 718 Proc1 = spawn_link(?MODULE, process, [Self]), 719 io:format("Proc1 = ~p ~n", [Proc1]), 720 %% 721 0 = erlang:trace(new, true, [procs]), 722 723 MFA = {?MODULE, process, [Self]}, 724 %% 725 %% spawn, link 726 Proc1 ! {spawn_link_please, Self, MFA}, 727 Proc3 = receive {spawned, Proc1, P3} -> P3 end, 728 receive {trace, Proc3, spawned, Proc1, MFA} -> ok end, 729 receive {trace, Proc3, getting_linked, Proc1} -> ok end, 730 io:format("Proc3 = ~p ~n", [Proc3]), 731 receive_nothing(), 732 %% 733 %% 734 %% exit (not linked to tracing process) 735 Reason1 = make_ref(), 736 Proc1 ! {exit_please, Reason1}, 737 receive {'EXIT', Proc1, Reason1} -> ok end, 738 {trace, Proc3, exit, Reason1} = receive_first_trace(), 739 receive_nothing(), 740 ok. 741 742 743 744%% Tests trace(Pid, How, [set_on_spawn]). 745 746set_on_spawn(Config) when is_list(Config) -> 747 Listener = fun_spawn(fun process/0), 748 749 %% Create and trace a process with the set_on_spawn flag. 750 %% Make sure it is traced. 751 Father_SOS = fun_spawn(fun process/0), 752 1 = erlang:trace(Father_SOS, true, [send, set_on_spawn]), 753 true = is_send_traced(Father_SOS, Listener, sos_father), 754 755 %% Have the process spawn of two children and test that they 756 %% are traced. 757 [Child1, Child2] = spawn_children(Father_SOS, 2), 758 true = is_send_traced(Child1, Listener, child1), 759 true = is_send_traced(Child2, Listener, child2), 760 761 %% Second generation. 762 [Child11, Child12] = spawn_children(Child1, 2), 763 true = is_send_traced(Child11, Listener, child11), 764 true = is_send_traced(Child12, Listener, child12), 765 ok. 766 767%% Tests trace(Pid, How, [set_on_first_spawn]). 768 769set_on_first_spawn(Config) when is_list(Config) -> 770 ct:timetrap({seconds, 10}), 771 Listener = fun_spawn(fun process/0), 772 773 %% Create and trace a process with the set_on_first_spawn flag. 774 %% Make sure it is traced. 775 Parent = fun_spawn(fun process/0), 776 1 = erlang:trace(Parent, true, [send, set_on_first_spawn]), 777 is_send_traced(Parent, Listener, sos_father), 778 779 %% Have the process spawn off three children and test that the 780 %% first is traced. 781 [Child1, Child2, Child3] = spawn_children(Parent, 3), 782 true = is_send_traced(Child1, Listener, child1), 783 false = is_send_traced(Child2, Listener, child2), 784 false = is_send_traced(Child3, Listener, child3), 785 receive_nothing(), 786 ok. 787 788%% Tests trace(Pid, How, [set_on_link]). 789 790set_on_link(_Config) -> 791 Listener = fun_spawn(fun process/0), 792 793 %% Create and trace a process with the set_on_link flag. 794 %% Make sure it is traced. 795 Father_SOL = fun_spawn(fun process/0), 796 1 = erlang:trace(Father_SOL, true, [send, set_on_link]), 797 true = is_send_traced(Father_SOL, Listener, sol_father), 798 799 %% Have the process spawn of two children and test that they 800 %% are traced. 801 [Child1, Child2] = spawn_children(Father_SOL, 2), 802 true = is_send_traced(Child1, Listener, child1), 803 true = is_send_traced(Child2, Listener, child2), 804 805 %% Second generation. 806 [Child11, Child12] = spawn_children(Child1, 2), 807 true = is_send_traced(Child11, Listener, child11), 808 true = is_send_traced(Child12, Listener, child12), 809 ok. 810 811%% Tests trace(Pid, How, [set_on_first_spawn]). 812 813set_on_first_link(_Config) -> 814 ct:timetrap({seconds, 10}), 815 Listener = fun_spawn(fun process/0), 816 817 %% Create and trace a process with the set_on_first_spawn flag. 818 %% Make sure it is traced. 819 Parent = fun_spawn(fun process/0), 820 1 = erlang:trace(Parent, true, [send, set_on_first_link]), 821 is_send_traced(Parent, Listener, sol_father), 822 823 %% Have the process spawn off three children and test that the 824 %% first is traced. 825 [Child1, Child2, Child3] = spawn_children(Parent, 3), 826 true = is_send_traced(Child1, Listener, child1), 827 false = is_send_traced(Child2, Listener, child2), 828 false = is_send_traced(Child3, Listener, child3), 829 receive_nothing(), 830 ok. 831 832 833 834%% Tests arguments to erlang:system_monitor/0,1,2 835system_monitor_args(Config) when is_list(Config) -> 836 Self = self(), 837 %% 838 OldMonitor = erlang:system_monitor(undefined), 839 undefined = erlang:system_monitor(Self, [{long_gc,0}]), 840 MinT = case erlang:system_monitor() of 841 {Self,[{long_gc,T}]} when is_integer(T), T > 0 -> T; 842 Other1 -> test_server:fault(Other1) 843 end, 844 {Self,[{long_gc,MinT}]} = erlang:system_monitor(), 845 {Self,[{long_gc,MinT}]} = 846 erlang:system_monitor({Self,[{large_heap,0}]}), 847 MinN = case erlang:system_monitor() of 848 {Self,[{large_heap,N}]} when is_integer(N), N > 0 -> N; 849 Other2 -> test_server:fault(Other2) 850 end, 851 {Self,[{large_heap,MinN}]} = erlang:system_monitor(), 852 {Self,[{large_heap,MinN}]} = 853 erlang:system_monitor(Self, [busy_port]), 854 {Self,[busy_port]} = erlang:system_monitor(), 855 {Self,[busy_port]} = 856 erlang:system_monitor({Self,[busy_dist_port]}), 857 {Self,[busy_dist_port]} = erlang:system_monitor(), 858 All = lists:sort([busy_port,busy_dist_port, 859 {long_gc,1},{large_heap,65535}]), 860 {Self,[busy_dist_port]} = erlang:system_monitor(Self, All), 861 {Self,A1} = erlang:system_monitor(), 862 All = lists:sort(A1), 863 {Self,A1} = erlang:system_monitor(Self, []), 864 Pid = spawn(fun () -> receive {Self,die} -> exit(die) end end), 865 Mref = erlang:monitor(process, Pid), 866 undefined = erlang:system_monitor(Pid, All), 867 {Pid,A2} = erlang:system_monitor(), 868 All = lists:sort(A2), 869 Pid ! {Self,die}, 870 receive {'DOWN',Mref,_,_,_} -> ok end, 871 undefined = erlang:system_monitor(OldMonitor), 872 erlang:yield(), 873 OldMonitor = erlang:system_monitor(), 874 %% 875 {'EXIT',{badarg,_}} = (catch erlang:system_monitor(atom)), 876 {'EXIT',{badarg,_}} = (catch erlang:system_monitor({})), 877 {'EXIT',{badarg,_}} = (catch erlang:system_monitor({1})), 878 {'EXIT',{badarg,_}} = (catch erlang:system_monitor({1,2,3})), 879 {'EXIT',{badarg,_}} = 880 (catch erlang:system_monitor({Self,atom})), 881 {'EXIT',{badarg,_}} = 882 (catch erlang:system_monitor(atom, atom)), 883 {'EXIT',{badarg,_}} = 884 (catch erlang:system_monitor({Self,[busy_port|busy_dist_port]})), 885 {'EXIT',{badarg,_}} = 886 (catch erlang:system_monitor(Self, [{long_gc,-1}])), 887 {'EXIT',{badarg,_}} = 888 (catch erlang:system_monitor({Self,[{long_gc,atom}]})), 889 {'EXIT',{badarg,_}} = 890 (catch erlang:system_monitor(Self,[{large_heap,-1}])), 891 {'EXIT',{badarg,_}} = 892 (catch erlang:system_monitor({Self,[{large_heap,atom}]})), 893 ok. 894 895 896%% Tests arguments to erlang:system_monitor/0,1,2 897more_system_monitor_args(Config) when is_list(Config) -> 898 try_l(64000), 899 try_l(16#7ffffff), 900 try_l(16#3fffffff), 901 try_l(16#7fffffff), 902 try_l(16#ffffffff), 903 ok. 904 905try_l(Val) -> 906 Self = self(), 907 Arbitrary1 = 77777, 908 Arbitrary2 = 88888, 909 910 erlang:system_monitor(undefined), 911 912 undefined = erlang:system_monitor(Self, [{long_gc,Val},{large_heap,Arbitrary1}]), 913 914 {Self,Comb0} = erlang:system_monitor(Self, [{long_gc,Arbitrary2},{large_heap,Val}]), 915 [{large_heap,Arbitrary1},{long_gc,Val}] = lists:sort(Comb0), 916 917 {Self,Comb1} = erlang:system_monitor(undefined), 918 [{large_heap,Val},{long_gc,Arbitrary2}] = lists:sort(Comb1). 919 920monitor_sys(Parent) -> 921 receive 922 {monitor,Pid,long_schedule,Data} when is_pid(Pid) -> 923 io:format("Long schedule of ~w: ~w~n",[Pid,Data]), 924 Parent ! {Pid,Data}, 925 monitor_sys(Parent); 926 {monitor,Port,long_schedule,Data} when is_port(Port) -> 927 {name,Name} = erlang:port_info(Port,name), 928 io:format("Long schedule of ~w (~p): ~w~n",[Port,Name,Data]), 929 Parent ! {Port,Data}, 930 monitor_sys(Parent); 931 Other -> 932 erlang:display(Other) 933 end. 934 935start_monitor() -> 936 Parent = self(), 937 Mpid = spawn_link(fun() -> monitor_sys(Parent) end), 938 erlang:system_monitor(Mpid,[{long_schedule,100}]), 939 erlang:yield(), % Need to be rescheduled for the trace to take 940 ok. 941 942%% Tests erlang:system_monitor(Pid, [{long_schedule,Time}]) 943system_monitor_long_schedule(Config) when is_list(Config) -> 944 Path = proplists:get_value(data_dir, Config), 945 erl_ddll:start(), 946 case (catch load_driver(Path, slow_drv)) of 947 ok -> 948 do_system_monitor_long_schedule(); 949 _Error -> 950 {skip, "Unable to load slow_drv (windows or no usleep()?)"} 951 end. 952do_system_monitor_long_schedule() -> 953 start_monitor(), 954 Port = open_port({spawn_driver,slow_drv}, []), 955 "ok" = erlang:port_control(Port,0,[]), 956 Self = self(), 957 receive 958 {Self,L} when is_list(L) -> 959 ok 960 after 1000 -> 961 ct:fail(no_trace_of_pid) 962 end, 963 "ok" = erlang:port_control(Port,1,[]), 964 "ok" = erlang:port_control(Port,2,[]), 965 receive 966 {Port,LL} when is_list(LL) -> 967 ok 968 after 1000 -> 969 ct:fail(no_trace_of_port) 970 end, 971 port_close(Port), 972 erlang:system_monitor(undefined), 973 ok. 974 975 976-define(LONG_GC_SLEEP, 670). 977 978%% Tests erlang:system_monitor(Pid, [{long_gc,Time}]) 979system_monitor_long_gc_1(Config) when is_list(Config) -> 980 erts_debug:set_internal_state(available_internal_state, true), 981 try 982 case erts_debug:get_internal_state(force_heap_frags) of 983 true -> 984 {skip,"emulator with FORCE_HEAP_FRAGS defined"}; 985 false -> 986 %% Add ?LONG_GC_SLEEP ms to all gc 987 erts_debug:set_internal_state(test_long_gc_sleep, 988 ?LONG_GC_SLEEP), 989 LoadFun = fun () -> 990 garbage_collect(), 991 self() 992 end, 993 long_gc(LoadFun, false) 994 end 995 after 996 erts_debug:set_internal_state(test_long_gc_sleep, 0), 997 erts_debug:set_internal_state(available_internal_state, false) 998 end. 999 1000%% Tests erlang:system_monitor(Pid, [{long_gc,Time}]) 1001system_monitor_long_gc_2(Config) when is_list(Config) -> 1002 erts_debug:set_internal_state(available_internal_state, true), 1003 try 1004 case erts_debug:get_internal_state(force_heap_frags) of 1005 true -> 1006 {skip,"emulator with FORCE_HEAP_FRAGS defined"}; 1007 false -> 1008 %% Add ?LONG_GC_SLEEP ms to all gc 1009 erts_debug:set_internal_state(test_long_gc_sleep, 1010 ?LONG_GC_SLEEP), 1011 Parent = self(), 1012 LoadFun = 1013 fun () -> 1014 Ref = make_ref(), 1015 Pid = 1016 spawn_link( 1017 fun () -> 1018 garbage_collect(), 1019 Parent ! {Ref, self()} 1020 end), 1021 receive {Ref, Pid} -> Pid end 1022 end, 1023 long_gc(LoadFun, true), 1024 long_gc(LoadFun, true), 1025 long_gc(LoadFun, true) 1026 end 1027 after 1028 erts_debug:set_internal_state(test_long_gc_sleep, 0), 1029 erts_debug:set_internal_state(available_internal_state, false) 1030 end. 1031 1032long_gc(LoadFun, ExpectMonMsg) -> 1033 Self = self(), 1034 Time = 1, 1035 OldMonitor = erlang:system_monitor(Self, [{long_gc,Time}]), 1036 Pid = LoadFun(), 1037 Ref = erlang:trace_delivered(Pid), 1038 receive {trace_delivered, Pid, Ref} -> ok end, 1039 {Self,[{long_gc,Time}]} = erlang:system_monitor(OldMonitor), 1040 case {long_gc_check(Pid, Time, undefined), ExpectMonMsg} of 1041 {ok, true} when Pid =/= Self -> 1042 ok; 1043 {ok, false} -> 1044 ct:fail(unexpected_system_monitor_message_received); 1045 {undefined, false} -> 1046 ok; 1047 {undefined, true} -> 1048 ct:fail(no_system_monitor_message_received) 1049 end. 1050 1051long_gc_check(Pid, Time, Result) -> 1052 receive 1053 {monitor,Pid,long_gc,L} = Monitor -> 1054 case lists:foldl( 1055 fun (_, error) -> 1056 error; 1057 ({timeout,T}, N) when is_integer(T), 1058 Time =< T, T =< 10*?LONG_GC_SLEEP -> 1059 %% OTP-7622. The time T must be within reasonable limits 1060 %% for the test to pass. 1061 N-1; 1062 ({heap_size,_}, N) -> 1063 N-1; 1064 ({old_heap_size,_}, N) -> 1065 N-1; 1066 ({stack_size,_}, N) -> 1067 N-1; 1068 ({mbuf_size,_}, N) -> 1069 N-1; 1070 ({heap_block_size,_}, N) -> 1071 N-1; 1072 ({old_heap_block_size,_}, N) -> 1073 N-1; 1074 (_, _) -> 1075 error 1076 end, 7, L) of 1077 0 -> 1078 long_gc_check(Pid, Time, ok); 1079 error -> 1080 {error,Monitor} 1081 end; 1082 {monitor,_,long_gc,_} -> 1083 long_gc_check(Pid, Time, Result); 1084 Other -> 1085 {error,Other} 1086 after 0 -> 1087 Result 1088 end. 1089 1090%% Tests erlang:system_monitor(Pid, [{large_heap,Size}]) 1091system_monitor_large_heap_1(Config) when is_list(Config) -> 1092 LoadFun = 1093 fun (Size) -> 1094 List = seq(1,2*Size), 1095 garbage_collect(), 1096 true = lists:prefix([1], List), 1097 self() 1098 end, 1099 large_heap(LoadFun, false). 1100 1101%% Tests erlang:system_monitor(Pid, [{large_heap,Size}]) 1102system_monitor_large_heap_2(Config) when is_list(Config) -> 1103 Parent = self(), 1104 LoadFun = 1105 fun (Size) -> 1106 Ref = make_ref(), 1107 Pid = 1108 spawn_opt(fun () -> 1109 garbage_collect(), 1110 Parent ! {Ref, self()} 1111 end, 1112 [link, {min_heap_size, 2*Size}]), 1113 receive {Ref, Pid} -> Pid end 1114 end, 1115 large_heap(LoadFun, true). 1116 1117large_heap(LoadFun, ExpectMonMsg) -> 1118 ct:timetrap({seconds, 20}), 1119 %% 1120 Size = 65535, 1121 Self = self(), 1122 NewMonitor = {Self,[{large_heap,Size}]}, 1123 OldMonitor = erlang:system_monitor(NewMonitor), 1124 Pid = LoadFun(Size), 1125 Ref = erlang:trace_delivered(Pid), 1126 receive {trace_delivered, Pid, Ref} -> ok end, 1127 {Self,[{large_heap,Size}]} = erlang:system_monitor(OldMonitor), 1128 case {large_heap_check(Pid, Size, undefined), ExpectMonMsg} of 1129 {ok, true} when Pid =/= Self -> 1130 ok; 1131 {ok, false} -> 1132 ct:fail(unexpected_system_monitor_message_received); 1133 {undefined, false} -> 1134 ok; 1135 {undefined, true} -> 1136 ct:fail(no_system_monitor_message_received) 1137 end, 1138 ok. 1139 1140large_heap_check(Pid, Size, Result) -> 1141 receive 1142 {monitor,Pid,large_heap,L} = Monitor -> 1143 case lists:foldl( 1144 fun (_, error) -> 1145 error; 1146 ({heap_size,_}, N) -> 1147 N-1; 1148 ({old_heap_size,_}, N) -> 1149 N-1; 1150 ({stack_size,_}, N) -> 1151 N-1; 1152 ({mbuf_size,_}, N) -> 1153 N-1; 1154 ({heap_block_size,_}, N) -> 1155 N-1; 1156 ({old_heap_block_size,_}, N) -> 1157 N-1; 1158 (_, _) -> 1159 error 1160 end, 6, L) of 1161 0 -> 1162 large_heap_check(Pid, Size, ok); 1163 error -> 1164 {error,Monitor} 1165 end; 1166 {monitor,_,large_heap,_} -> 1167 large_heap_check(Pid, Size, Result); 1168 Other -> 1169 {error,Other} 1170 after 0 -> 1171 Result 1172 end. 1173 1174seq(N, M) -> 1175 seq(N, M, []). 1176 1177seq(M, M, R) -> 1178 lists:reverse(R); 1179seq(N, M, R) -> 1180 seq(N+1, M, [N|R]). 1181 1182 1183is_send_traced(Pid, Listener, Msg) -> 1184 Pid ! {send_please, Listener, Msg}, 1185 receive 1186 Any -> 1187 {trace, Pid, send, Msg, Listener} = Any, 1188 true 1189 after 1000 -> 1190 false 1191 end. 1192 1193%% This procedure assumes that the Parent process is send traced. 1194 1195spawn_children(Parent, Number) -> 1196 spawn_children(Parent, Number, []). 1197 1198spawn_children(_Parent, 0, Result) -> 1199 lists:reverse(Result); 1200spawn_children(Parent, Number, Result) -> 1201 Self = self(), 1202 Parent ! {spawn_please, Self, fun process/0}, 1203 Child = 1204 receive 1205 {trace, Parent, send, {spawned, Pid}, Self} -> Pid 1206 end, 1207 receive 1208 {spawned, Child} -> 1209 spawn_children(Parent, Number-1, [Child|Result]) 1210 end. 1211 1212%% Test erlang:suspend/1 and erlang:resume/1. 1213suspend(Config) when is_list(Config) -> 1214 ct:timetrap({minutes,2}), 1215 Worker = fun_spawn(fun worker/0), 1216 %% Suspend a process and test that it is suspended. 1217 ok = do_suspend(Worker, 10000), 1218 ok. 1219 1220do_suspend(_Pid, 0) -> 1221 ok; 1222do_suspend(Pid, N) -> 1223 %% Suspend a process and test that it is suspended. 1224 true = erlang:suspend_process(Pid), 1225 {status, suspended} = process_info(Pid, status), 1226 1227 %% Unsuspend the process and make sure it starts working. 1228 true = erlang:resume_process(Pid), 1229 case process_info(Pid, status) of 1230 {status, runnable} -> ok; 1231 {status, running} -> ok; 1232 {status, garbage_collecting} -> ok; 1233 ST -> ct:fail(ST) 1234 end, 1235 erlang:yield(), 1236 do_suspend(Pid, N-1). 1237 1238suspend_exit(Config) when is_list(Config) -> 1239 ct:timetrap({minutes, 2}), 1240 rand:seed(exsplus, {4711,17,4711}), 1241 do_suspend_exit(5000), 1242 ok. 1243 1244do_suspend_exit(0) -> 1245 ok; 1246do_suspend_exit(N) -> 1247 Work = rand:uniform(50), 1248 Parent = self(), 1249 {Suspendee, Mon2} 1250 = spawn_monitor(fun () -> 1251 suspend_exit_work(Work), 1252 exit(normal) 1253 end), 1254 {Suspender, Mon1} 1255 = spawn_monitor( 1256 fun () -> 1257 suspend_exit_work(Work div 2), 1258 Parent ! {doing_suspend, self()}, 1259 case catch erlang:suspend_process(Suspendee) of 1260 {'EXIT', _} -> 1261 ok; 1262 true -> 1263 erlang:resume_process(Suspendee) 1264 end 1265 end), 1266 receive 1267 {doing_suspend, Suspender} -> 1268 case N rem 2 of 1269 0 -> exit(Suspender, bang); 1270 1 -> ok 1271 end 1272 end, 1273 receive {'DOWN', Mon1, process, Suspender, _} -> ok end, 1274 receive {'DOWN', Mon2, process, Suspendee, _} -> ok end, 1275 do_suspend_exit(N-1). 1276 1277 1278 1279 1280suspend_exit_work(0) -> 1281 ok; 1282suspend_exit_work(N) -> 1283 process_info(self()), 1284 suspend_exit_work(N-1). 1285 1286-define(CHK_SUSPENDED(P,B), chk_suspended(P, B, ?LINE)). 1287 1288chk_suspended(P, Bool, Line) -> 1289 {Bool, Line} = {({status, suspended} == process_info(P, status)), Line}. 1290 1291suspender_exit(Config) when is_list(Config) -> 1292 ct:timetrap({minutes, 3}), 1293 P1 = spawn_link(fun () -> receive after infinity -> ok end end), 1294 {'EXIT', _} = (catch erlang:resume_process(P1)), 1295 {P2, M2} = spawn_monitor( 1296 fun () -> 1297 ?CHK_SUSPENDED(P1, false), 1298 erlang:suspend_process(P1), 1299 ?CHK_SUSPENDED(P1, true), 1300 erlang:suspend_process(P1), 1301 erlang:suspend_process(P1), 1302 erlang:suspend_process(P1), 1303 ?CHK_SUSPENDED(P1, true), 1304 erlang:resume_process(P1), 1305 erlang:resume_process(P1), 1306 erlang:resume_process(P1), 1307 ?CHK_SUSPENDED(P1, true), 1308 erlang:resume_process(P1), 1309 ?CHK_SUSPENDED(P1, false), 1310 erlang:suspend_process(P1), 1311 erlang:suspend_process(P1), 1312 erlang:suspend_process(P1), 1313 ?CHK_SUSPENDED(P1, true), 1314 exit(bang) 1315 end), 1316 receive 1317 {'DOWN', M2,process,P2,R2} -> 1318 bang = R2, 1319 ?CHK_SUSPENDED(P1, false) 1320 end, 1321 Parent = self(), 1322 {P3, M3} = spawn_monitor( 1323 fun () -> 1324 erlang:suspend_process(P1), 1325 ?CHK_SUSPENDED(P1, true), 1326 Parent ! self(), 1327 receive after infinity -> ok end 1328 end), 1329 {P4, M4} = spawn_monitor( 1330 fun () -> 1331 erlang:suspend_process(P1), 1332 ?CHK_SUSPENDED(P1, true), 1333 Parent ! self(), 1334 receive after infinity -> ok end 1335 end), 1336 {P5, M5} = spawn_monitor( 1337 fun () -> 1338 erlang:suspend_process(P1), 1339 ?CHK_SUSPENDED(P1, true), 1340 Parent ! self(), 1341 receive after infinity -> ok end 1342 end), 1343 {P6, M6} = spawn_monitor( 1344 fun () -> 1345 erlang:suspend_process(P1), 1346 ?CHK_SUSPENDED(P1, true), 1347 Parent ! self(), 1348 receive after infinity -> ok end 1349 end), 1350 {P7, M7} = spawn_monitor( 1351 fun () -> 1352 erlang:suspend_process(P1), 1353 ?CHK_SUSPENDED(P1, true), 1354 Parent ! self(), 1355 receive after infinity -> ok end 1356 end), 1357 receive P3 -> ok end, 1358 receive P4 -> ok end, 1359 receive P5 -> ok end, 1360 receive P6 -> ok end, 1361 receive P7 -> ok end, 1362 ?CHK_SUSPENDED(P1, true), 1363 exit(P3, bang), 1364 receive 1365 {'DOWN',M3,process,P3,R3} -> 1366 bang = R3, 1367 ?CHK_SUSPENDED(P1, true) 1368 end, 1369 exit(P4, bang), 1370 receive 1371 {'DOWN',M4,process,P4,R4} -> 1372 bang = R4, 1373 ?CHK_SUSPENDED(P1, true) 1374 end, 1375 exit(P5, bang), 1376 receive 1377 {'DOWN',M5,process,P5,R5} -> 1378 bang = R5, 1379 ?CHK_SUSPENDED(P1, true) 1380 end, 1381 exit(P6, bang), 1382 receive 1383 {'DOWN',M6,process,P6,R6} -> 1384 bang = R6, 1385 ?CHK_SUSPENDED(P1, true) 1386 end, 1387 exit(P7, bang), 1388 receive 1389 {'DOWN',M7,process,P7,R7} -> 1390 bang = R7, 1391 ?CHK_SUSPENDED(P1, false) 1392 end, 1393 unlink(P1), 1394 exit(P1, bong), 1395 ok. 1396 1397suspend_system_limit(Config) when is_list(Config) -> 1398 case os:getenv("ERL_EXTREME_TESTING") of 1399 "true" -> 1400 ct:timetrap({minutes, 3*60}), 1401 P = spawn_link(fun () -> receive after infinity -> ok end end), 1402 suspend_until_system_limit(P), 1403 unlink(P), 1404 exit(P, bye), 1405 ok; 1406 _ -> 1407 {skip, "Takes too long time for normal testing"} 1408 end. 1409 1410suspend_until_system_limit(P) -> 1411 suspend_until_system_limit(P, 0, 0). 1412 1413suspend_until_system_limit(P, N, M) -> 1414 NewM = case M of 1415 1 -> 1416 ?CHK_SUSPENDED(P, true), 2; 1417 1000000 -> 1418 erlang:display(N), 1; 1419 _ -> 1420 M+1 1421 end, 1422 case catch erlang:suspend_process(P) of 1423 true -> 1424 suspend_until_system_limit(P, N+1, NewM); 1425 {'EXIT', R} when R == system_limit; 1426 element(1, R) == system_limit -> 1427 io:format("system limit at ~p~n", [N]), 1428 resume_from_system_limit(P, N, 0); 1429 Error -> 1430 ct:fail(Error) 1431 end. 1432 1433resume_from_system_limit(P, 0, _) -> 1434 ?CHK_SUSPENDED(P, false), 1435 {'EXIT', _} = (catch erlang:resume_process(P)), 1436 ok; 1437resume_from_system_limit(P, N, M) -> 1438 NewM = case M of 1439 1 -> 1440 ?CHK_SUSPENDED(P, true), 2; 1441 1000000 -> 1442 erlang:display(N), 1; 1443 _ -> 1444 M+1 1445 end, 1446 erlang:resume_process(P), 1447 resume_from_system_limit(P, N-1, NewM). 1448 1449-record(susp_info, {async = 0, 1450 dbl_async = 0, 1451 synced = 0, 1452 async_once = 0}). 1453 1454suspend_opts(Config) when is_list(Config) -> 1455 ct:timetrap({minutes, 3}), 1456 Self = self(), 1457 wait_for_empty_runq(10), 1458 Tok = spawn_link(fun () -> 1459 Self ! self(), 1460 tok_trace_loop(Self, 0, 1000000000) 1461 end), 1462 TC = 1000, 1463 receive Tok -> ok end, 1464 SF = fun (N, #susp_info {async = A, 1465 dbl_async = AA, 1466 synced = S, 1467 async_once = AO} = Acc) -> 1468 Tag = {make_ref(), self()}, 1469 erlang:suspend_process(Tok, [{asynchronous, Tag}]), 1470 Res = case {suspend_count(Tok), N rem 4} of 1471 {0, 2} -> 1472 erlang:suspend_process(Tok, 1473 [asynchronous]), 1474 case suspend_count(Tok) of 1475 2 -> 1476 erlang:resume_process(Tok), 1477 Acc#susp_info{async = A+1}; 1478 0 -> 1479 erlang:resume_process(Tok), 1480 Acc#susp_info{async = A+1, 1481 dbl_async = AA+1} 1482 end; 1483 {0, 1} -> 1484 erlang:suspend_process(Tok, 1485 [asynchronous, 1486 unless_suspending]), 1487 case suspend_count(Tok) of 1488 1 -> 1489 Acc#susp_info{async = A+1}; 1490 0 -> 1491 Acc#susp_info{async = A+1, 1492 async_once = AO+1} 1493 end; 1494 {0, 0} -> 1495 erlang:suspend_process(Tok, 1496 [unless_suspending]), 1497 1 = suspend_count(Tok), 1498 Acc#susp_info{async = A+1, 1499 synced = S+1}; 1500 {0, _} -> 1501 Acc#susp_info{async = A+1}; 1502 _ -> 1503 Acc 1504 end, 1505 receive 1506 {Tag, Result} -> 1507 suspended = Result, 1508 erlang:resume_process(Tok) 1509 end, 1510 erlang:yield(), 1511 Res 1512 end, 1513 SI = repeat_acc(SF, TC, #susp_info{}), 1514 erlang:suspend_process(Tok, [asynchronous]), 1515 %% Verify that it eventually suspends 1516 WaitTime0 = 10, 1517 WaitTime1 = case {erlang:system_info(debug_compiled), 1518 erlang:system_info(lock_checking)} of 1519 {false, false} -> 1520 WaitTime0; 1521 {false, true} -> 1522 WaitTime0*5; 1523 _ -> 1524 WaitTime0*10 1525 end, 1526 WaitTime = case {erlang:system_info(schedulers_online), 1527 erlang:system_info(logical_processors)} of 1528 {Schdlrs, CPUs} when is_integer(CPUs), 1529 Schdlrs =< CPUs -> 1530 WaitTime1; 1531 _ -> 1532 WaitTime1*10 1533 end, 1534 receive after WaitTime -> ok end, 1535 1 = suspend_count(Tok), 1536 erlang:suspend_process(Tok, [asynchronous]), 1537 2 = suspend_count(Tok), 1538 erlang:suspend_process(Tok, [asynchronous]), 1539 3 = suspend_count(Tok), 1540 erlang:suspend_process(Tok), 1541 4 = suspend_count(Tok), 1542 erlang:suspend_process(Tok), 1543 5 = suspend_count(Tok), 1544 erlang:suspend_process(Tok, [unless_suspending]), 1545 5 = suspend_count(Tok), 1546 erlang:suspend_process(Tok, [unless_suspending, 1547 asynchronous]), 1548 5 = suspend_count(Tok), 1549 erlang:resume_process(Tok), 1550 erlang:resume_process(Tok), 1551 erlang:resume_process(Tok), 1552 erlang:resume_process(Tok), 1553 1 = suspend_count(Tok), 1554 io:format("Main suspends: ~p~n" 1555 "Main async: ~p~n" 1556 "Double async: ~p~n" 1557 "Async once: ~p~n" 1558 "Synced: ~p~n", 1559 [TC, 1560 SI#susp_info.async, 1561 SI#susp_info.dbl_async, 1562 SI#susp_info.async_once, 1563 SI#susp_info.synced]), 1564 case erlang:system_info(schedulers_online) of 1565 1 -> 1566 ok; 1567 _ -> 1568 true = SI#susp_info.async =/= 0 1569 end, 1570 unlink(Tok), 1571 exit(Tok, bang), 1572 ok. 1573 1574suspend_count(Suspendee) -> 1575 suspend_count(self(), Suspendee). 1576 1577suspend_count(Suspender, Suspendee) -> 1578 {suspending, SList} = process_info(Suspender, suspending), 1579 1580 case lists:keysearch(Suspendee, 1, SList) of 1581 {value, {_Suspendee, 0, 0}} -> 1582 ct:fail({bad_suspendee_list, SList}); 1583 {value, {Suspendee, Count, 0}} when is_integer(Count), Count > 0 -> 1584 {status, suspended} = process_info(Suspendee, status), 1585 Count; 1586 {value, {Suspendee, 0, Outstanding}} when is_integer(Outstanding), 1587 Outstanding > 0 -> 1588 0; 1589 false -> 1590 0; 1591 Error -> 1592 ct:fail({bad_suspendee_list, Error, SList}) 1593 end. 1594 1595repeat_acc(Fun, N, Acc) -> 1596 repeat_acc(Fun, 0, N, Acc). 1597 1598repeat_acc(_Fun, N, N, Acc) -> 1599 Acc; 1600repeat_acc(Fun, N, M, Acc) -> 1601 repeat_acc(Fun, N+1, M, Fun(N, Acc)). 1602 1603%% Tests that waiting process can be suspended 1604%% (bug in R2D and earlier; see OTP-1488). 1605 1606%% Test that a waiting process can be suspended. 1607suspend_waiting(Config) when is_list(Config) -> 1608 Process = fun_spawn(fun process/0), 1609 receive after 1 -> ok end, 1610 true = erlang:suspend_process(Process), 1611 {status, suspended} = process_info(Process, status), 1612 ok. 1613 1614 1615%% Test that erlang:trace(new, true, ...) is cleared when tracer dies. 1616new_clear(Config) when is_list(Config) -> 1617 Tracer = proplists:get_value(receiver, Config), 1618 1619 0 = erlang:trace(new, true, [send, {tracer, Tracer}]), 1620 {flags, [send]} = erlang:trace_info(new, flags), 1621 {tracer, Tracer} = erlang:trace_info(new, tracer), 1622 Mref = erlang:monitor(process, Tracer), 1623 true = exit(Tracer, done), 1624 receive 1625 {'DOWN',Mref,_,_,_} -> ok 1626 end, 1627 {flags, []} = erlang:trace_info(new, flags), 1628 {tracer, []} = erlang:trace_info(new, tracer), 1629 ok. 1630 1631 1632 1633%% Test that erlang:trace(all, false, ...) works without tracer. 1634existing_clear(Config) when is_list(Config) -> 1635 Self = self(), 1636 1637 Tracer = proplists:get_value(receiver, Config), 1638 N = erlang:trace(existing, true, [send, {tracer, Tracer}]), 1639 {flags, [send]} = erlang:trace_info(Self, flags), 1640 {tracer, Tracer} = erlang:trace_info(Self, tracer), 1641 M = erlang:trace(all, false, [all]), 1642 io:format("Started trace on ~p processes and stopped on ~p~n", 1643 [N, M]), 1644 {flags, []} = erlang:trace_info(Self, flags), 1645 {tracer, []} = erlang:trace_info(Self, tracer), 1646 M = N, % Used to be N + 1, but from 19.0 the tracer is also traced 1647 1648 ok. 1649 1650%% Test that erlang:trace/3 can be called on processes where the 1651%% tracer has died. OTP-13928 1652tracer_die(Config) when is_list(Config) -> 1653 Proc = spawn_link(fun receiver/0), 1654 1655 Tracer = spawn_link(fun receiver/0), 1656 timer:sleep(1), 1657 N = erlang:trace(existing, true, [send, {tracer, Tracer}]), 1658 {flags, [send]} = erlang:trace_info(Proc, flags), 1659 {tracer, Tracer} = erlang:trace_info(Proc, tracer), 1660 unlink(Tracer), 1661 exit(Tracer, die), 1662 1663 Tracer2 = spawn_link(fun receiver/0), 1664 timer:sleep(1), 1665 N = erlang:trace(existing, true, [send, {tracer, Tracer2}]), 1666 {flags, [send]} = erlang:trace_info(Proc, flags), 1667 {tracer, Tracer2} = erlang:trace_info(Proc, tracer), 1668 unlink(Tracer2), 1669 exit(Tracer2, die), 1670 1671 Tracer3 = spawn_link(fun receiver/0), 1672 timer:sleep(1), 1673 1 = erlang:trace(Proc, true, [send, {tracer, Tracer3}]), 1674 {flags, [send]} = erlang:trace_info(Proc, flags), 1675 {tracer, Tracer3} = erlang:trace_info(Proc, tracer), 1676 unlink(Tracer3), 1677 exit(Tracer3, die), 1678 1679 ok. 1680 1681%% Test that an invalid flag cause badarg 1682bad_flag(Config) when is_list(Config) -> 1683 %% A bad flag could deadlock the SMP emulator in erts-5.5 1684 {'EXIT', {badarg, _}} = (catch erlang:trace(new, 1685 true, 1686 [not_a_valid_flag])), 1687 ok. 1688 1689%% Test erlang:trace_delivered/1 1690trace_delivered(Config) when is_list(Config) -> 1691 ct:timetrap({minutes, 1}), 1692 TokLoops = 10000, 1693 Go = make_ref(), 1694 Parent = self(), 1695 Tok = spawn(fun () -> 1696 receive Go -> gone end, 1697 tok_trace_loop(Parent, 0, TokLoops) 1698 end), 1699 1 = erlang:trace(Tok, true, [procs]), 1700 Mon = erlang:monitor(process, Tok), 1701 NoOfTraceMessages = 4*TokLoops + 1, 1702 io:format("Expect a total of ~p trace messages~n", 1703 [NoOfTraceMessages]), 1704 Tok ! Go, 1705 NoOfTraceMessages = drop_trace_until_down(Tok, Mon), 1706 receive 1707 Msg -> 1708 ct:fail({unexpected_message, Msg}) 1709 after 1000 -> 1710 ok 1711 end. 1712 1713%% This testcase checks that receive trace works on exit signal messages 1714%% when the sender of the exit signal is the process itself. 1715trap_exit_self_receive(Config) -> 1716 Parent = self(), 1717 Proc = spawn_link(fun() -> process(Parent) end), 1718 1719 1 = erlang:trace(Proc, true, ['receive']), 1720 Proc ! {trap_exit_please, true}, 1721 {trace, Proc, 'receive', {trap_exit_please, true}} = receive_first_trace(), 1722 1723 %% Make the process call exit(self(), signal) 1724 Reason1 = make_ref(), 1725 Proc ! {exit_signal_please, Reason1}, 1726 {trace, Proc, 'receive', {exit_signal_please, Reason1}} = receive_first_trace(), 1727 {trace, Proc, 'receive', {'EXIT', Proc, Reason1}} = receive_first_trace(), 1728 receive {Proc, {'EXIT', Proc, Reason1}} -> ok end, 1729 receive_nothing(), 1730 1731 unlink(Proc), 1732 Reason2 = make_ref(), 1733 Proc ! {exit_please, Reason2}, 1734 {trace, Proc, 'receive', {exit_please, Reason2}} = receive_first_trace(), 1735 receive_nothing(), 1736 ok. 1737 1738trace_info_badarg(Config) when is_list(Config) -> 1739 catch erlang:trace_info({a,b,c},d), 1740 ok. 1741 1742%% An incoming suspend monitor down wasn't handled 1743%% correct when the local monitor half had been 1744%% removed with an emulator crash as result. 1745erl_704(Config) -> 1746 erl_704_test(100). 1747 1748erl_704_test(0) -> 1749 ok; 1750erl_704_test(N) -> 1751 P = spawn(fun () -> receive infinity -> ok end end), 1752 erlang:suspend_process(P), 1753 exit(P, kill), 1754 (catch erlang:resume_process(P)), 1755 erl_704_test(N-1). 1756 1757drop_trace_until_down(Proc, Mon) -> 1758 drop_trace_until_down(Proc, Mon, false, 0, 0). 1759 1760drop_trace_until_down(Proc, Mon, TDRef, N, D) -> 1761 case receive Msg -> Msg end of 1762 {trace_delivered, Proc, TDRef} -> 1763 io:format("~p trace messages on 'DOWN'~n", [D]), 1764 io:format("Got a total of ~p trace messages~n", [N]), 1765 N; 1766 {'DOWN', Mon, process, Proc, _} -> 1767 Ref = erlang:trace_delivered(Proc), 1768 drop_trace_until_down(Proc, Mon, Ref, N, N); 1769 Trace when is_tuple(Trace), 1770 element(1, Trace) == trace, 1771 element(2, Trace) == Proc -> 1772 drop_trace_until_down(Proc, Mon, TDRef, N+1, D) 1773 end. 1774 1775tok_trace_loop(_, N, N) -> 1776 ok; 1777tok_trace_loop(Parent, N, M) -> 1778 Name = 'A really stupid name which I will unregister at once', 1779 link(Parent), 1780 register(Name, self()), 1781 unregister(Name), 1782 unlink(Parent), 1783 tok_trace_loop(Parent, N+1, M). 1784 1785%% Waits for and returns the first message in the message queue. 1786 1787receive_first() -> 1788 receive 1789 Any -> Any 1790 end. 1791 1792%% Waits for and returns the first message in the message queue. 1793 1794receive_first_trace() -> 1795 receive 1796 Any when element(1,Any) =:= trace; element(1,Any) =:= trace_ts -> Any 1797 end. 1798 1799%% Ensures that there is no message in the message queue. 1800 1801receive_nothing() -> 1802 receive 1803 Any -> 1804 ct:fail({unexpected_message, Any}) 1805 after 100 -> 1806 ok 1807 end. 1808 1809 1810%%% Models for various kinds of processes. 1811 1812process(Dest) -> 1813 receive 1814 {send_please, To, What} -> 1815 To ! What, 1816 process(Dest); 1817 {spawn_link_please, ReplyTo, {M, F, A}} -> 1818 Pid = spawn_link(M, F, A), 1819 ReplyTo ! {spawned, self(), Pid}, 1820 process(Dest); 1821 {spawn_link_please, ReplyTo, Node, {M, F, A}} -> 1822 Pid = spawn_link(Node, M, F, A), 1823 ReplyTo ! {spawned, self(), Pid}, 1824 process(Dest); 1825 {link_please, Pid} -> 1826 link(Pid), 1827 process(Dest); 1828 {unlink_please, Pid} -> 1829 unlink(Pid), 1830 process(Dest); 1831 {register_please, Name, Pid} -> 1832 register(Name, Pid), 1833 process(Dest); 1834 {unregister_please, Name} -> 1835 unregister(Name), 1836 process(Dest); 1837 {exit_please, Reason} -> 1838 exit(Reason); 1839 {exit_signal_please, Reason} -> 1840 exit(self(), Reason), 1841 process(Dest); 1842 {trap_exit_please, State} -> 1843 process_flag(trap_exit, State), 1844 process(Dest); 1845 Other -> 1846 Dest ! {self(), Other}, 1847 process(Dest) 1848 after 3000 -> 1849 exit(timeout) 1850 end. 1851 1852 1853%% A smart process template. 1854 1855process() -> 1856 receive 1857 {spawn_please, ReplyTo, Fun} -> 1858 Pid = fun_spawn(Fun), 1859 ReplyTo ! {spawned, Pid}, 1860 process(); 1861 {send_please, To, What} -> 1862 To ! What, 1863 process(); 1864 timeout_please -> 1865 receive after 1 -> process() end; 1866 _Other -> 1867 process() 1868 end. 1869 1870 1871%% Sends messages when ordered to. 1872 1873sender() -> 1874 receive 1875 {send_please, To, What} -> 1876 To ! What, 1877 sender() 1878 end. 1879 1880 1881%% Just consumes messages from its message queue. 1882 1883receiver() -> 1884 receiver(infinity). 1885 1886receiver(Timeout) -> 1887 receiver(receive 1888 {set_timeout, NewTimeout} -> NewTimeout; 1889 _Any -> Timeout 1890 after Timeout -> infinity %% reset 1891 end). 1892 1893%% Works as long as it receives CPU time. Will always be RUNNABLE. 1894 1895worker() -> 1896 worker(0). 1897 1898worker(Number) -> 1899 worker(Number+1). 1900 1901fun_spawn(Fun) -> 1902 spawn_link(erlang, apply, [Fun, []]). 1903 1904fun_spawn(Fun, Args) -> 1905 spawn_link(erlang, apply, [Fun, Args]). 1906 1907 1908start_node(Name) -> 1909 Pa = filename:dirname(code:which(?MODULE)), 1910 Cookie = atom_to_list(erlang:get_cookie()), 1911 test_server:start_node(Name, slave, 1912 [{args, "-setcookie " ++ Cookie ++" -pa " ++ Pa}]). 1913 1914stop_node(Node) -> 1915 test_server:stop_node(Node). 1916 1917 1918wait_for_empty_runq(DeadLine) -> 1919 case statistics(run_queue) of 1920 0 -> true; 1921 RQLen -> 1922 erlang:display("Waiting for empty run queue"), 1923 MSDL = DeadLine*1000, 1924 wait_for_empty_runq(MSDL, MSDL, RQLen) 1925 end. 1926 1927wait_for_empty_runq(DeadLine, Left, RQLen) when Left =< 0 -> 1928 issue_non_empty_runq_warning(DeadLine, RQLen), 1929 false; 1930wait_for_empty_runq(DeadLine, Left, _RQLen) -> 1931 Wait = 10, 1932 UntilDeadLine = Left - Wait, 1933 receive after Wait -> ok end, 1934 case statistics(run_queue) of 1935 0 -> 1936 erlang:display("Waited for " 1937 ++ integer_to_list(DeadLine 1938 - UntilDeadLine) 1939 ++ " ms for empty run queue."), 1940 true; 1941 NewRQLen -> 1942 wait_for_empty_runq(DeadLine, 1943 UntilDeadLine, 1944 NewRQLen) 1945 end. 1946 1947issue_non_empty_runq_warning(DeadLine, RQLen) -> 1948 PIs = lists:foldl( 1949 fun (P, Acc) -> 1950 case process_info(P, 1951 [status, 1952 initial_call, 1953 current_function, 1954 registered_name, 1955 reductions, 1956 message_queue_len]) of 1957 [{status, Runnable} | _] = PI when Runnable /= waiting, 1958 Runnable /= suspended -> 1959 [[{pid, P} | PI] | Acc]; 1960 _ -> 1961 Acc 1962 end 1963 end, 1964 [], 1965 processes()), 1966 io:format("WARNING: Unexpected runnable processes in system (waited ~p sec).~n" 1967 " Run queue length: ~p~n" 1968 " Self: ~p~n" 1969 " Processes info: ~p~n", 1970 [DeadLine div 1000, RQLen, self(), PIs]), 1971 receive after 1000 -> ok end. 1972 1973load_driver(Dir, Driver) -> 1974 case erl_ddll:load_driver(Dir, Driver) of 1975 ok -> ok; 1976 {error, Error} = Res -> 1977 io:format("~s\n", [erl_ddll:format_error(Error)]), 1978 Res 1979 end. 1980