diff options
Diffstat (limited to 'lib/runtime_tools/src/inviso_rt.erl')
| -rw-r--r-- | lib/runtime_tools/src/inviso_rt.erl | 2895 |
1 files changed, 2895 insertions, 0 deletions
diff --git a/lib/runtime_tools/src/inviso_rt.erl b/lib/runtime_tools/src/inviso_rt.erl new file mode 100644 index 0000000000..dfab70b42e --- /dev/null +++ b/lib/runtime_tools/src/inviso_rt.erl @@ -0,0 +1,2895 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2005-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% +%% +%% Description: +%% The runtime component of the trace tool Inviso. +%% +%% Authors: +%% Ann-Marie L�f, [email protected] +%% Lennart �hman, [email protected] +%% ----------------------------------------------------------------------------- + +-module(inviso_rt). + + +%% ----------------------------------------------------------------------------- +%% interface for supervisor +%% ----------------------------------------------------------------------------- +-export([start_link_man/3,start_link_auto/1]). + +%% API for controll component. +-export([start/4,stop/1, + init_tracing/2,stop_tracing_parallel/1, + try_to_adopt/3,confirm_connection/2,get_node_info/1, + suspend/2,call_suspend/2,cancel_suspension/1,change_options/2, + clear/2,clear_all_tp/1, + flush/1, + trace_patterns_parallel/3, + trace_flags_parallel/3,trace_flags_parallel/2,trace_flags_parallel/1, + meta_tracer_call_parallel/2, + get_status/1,get_tracerdata/1,list_logs/1,list_logs/2,fetch_log/2,fetch_log/3, + delete_log/1,delete_log/2, + state/1]). +%% ----------------------------------------------------------------------------- + +%% API mostly for autostart scripts, instead of corresponding control component +%% apis not available doing local function calls. +-export([init_tracing/1,tp/4,tp/5,tp/1,tpg/4,tpg/5,tpg/1, + tpl/4,tpl/5,tpl/1, + ctp/1,ctp/3,ctpg/1,ctpg/3,ctpl/1,ctpl/3, + init_tpm/4,init_tpm/7, + tpm/4,tpm/5,tpm/8,tpm_tracer/4,tpm_tracer/5,tpm_tracer/8, + tpm_ms/5,tpm_ms_tracer/5, + ctpm_ms/4, + local_register/0,global_register/0, + ctpm/3,remove_local_register/0,remove_global_register/0, + tf/2,tf/1,ctf/2,ctf/1]). +%% ----------------------------------------------------------------------------- + +%% Internal exports. +-export([init/4,auto_init/2,fetch_init/4]). +%% ----------------------------------------------------------------------------- + +%% ----------------------------------------------------------------------------- +%% Constants. +%% ----------------------------------------------------------------------------- + +-define(DEFAULT_OVERLOAD_FUNC,default_overload_func). +-define(NO_LOADCHECK,no_loadcheck). + +-define(RT_SUP,runtime_tools_sup). % Refers to the registered name. +-define(CTRL,inviso_c). % Refers to the registered name. +%% ----------------------------------------------------------------------------- + +%% ----------------------------------------------------------------------------- +%% Record definition. +%% ----------------------------------------------------------------------------- + +%% #rt +%% All record fields must be bound to listed values when leaving init or +%% auto_init. +%% dependency: Timeout accepting being without control component. +%% overload : Controlls which module to call, if any, when time for a check. +%% timer_ref: Used when timing delayed shutdown due to lost control component. +-record(rt,{state = new, % new | idle | tracing + status = running, % running | {suspended, Reason} + next_loadcheck = now(), % now | "No Loadcheck" + parent, % pid() + tracerdata, % undefined|{fun(),term()}|{file,Param}|{ip,Param} + tracer_port, % port() | undefined + handler, % {fun(), term()} | undefined + auto_starter, % pid() | undefined; proc starting interpreters. + meta_tracer, % undefined | pid() + fetchers=[], % [pid(),...] processes transfering logfiles. +% spies = [], + dependency={infinity,node()}, % {TOut,Node} | TOut; TOut=int()|infinity + overload=no_loadcheck, % ?NO_LOADCHECK|{LoadMF,Interval,InitMFA,RemoveMFA} + overload_data=void, % Datastructure given to LoadMF and RemoveMFA. + timer_ref, % undefined | reference() + ctrl, % undefined | pid() + ctrl_ref, % undefined | reference() + vsn, % list() + tag % term() + }). +%% ----------------------------------------------------------------------------- + + +%% ============================================================================== +%% Start API +%% ============================================================================== + +%% Note that the runtime component may be started in many different ways. +%% It can be autostarted by the runtime_tools_sup during initial start-up of the +%% system. It is actually most likely that it will be started that way. However +%% if there are no autostart trace-cases to run, the inviso_rt runtime component +%% will terminate. It will then however remain as a child of the runtime_tools_sup +%% supervisor. This means that if the runtime component is started again, manually, +%% by the control component, some actions must be taken. +%% For instance is it very likely that the child already exists. But since it +%% must be started with different arguments when started manually, the child-spec +%% must be changed. +%% +%% The runtime component is not a proper gen_server, to allow full control of +%% what happens. It however mimcs gen_server behaviour to be managed by the +%% runtime_tools_sup supervisor. + + +%% start_link_auto(AutoModArgs)={ok,Pid} +%% +%% This function is entered into the child-spec when planning on doing autostart +%% of the runtime component. The autostart is controlled by the so called +%% inviso_autostart_mod. It is an application environment parameter of the +%% runtime_tools application. If it exists, it shall point out a module name. +%% If it does not exist, the default 'inviso_autostart' module will be tried. +%% Note that these start_link functions do not implement proper otp-behaviour. +%% For instance they return {ok,Pid} immediately making the init-phase of the +%% runtime component process empty. +%% +%% The inviso_autostart_mod shall export one function: +%% autostart(AutoModArgs) -> {MFA,Options,Tag}, where +%% AutoModArgs=term(), comes from the application start parameters in the +%% runtime_tools application resource file. +%% MFA={Mod,Func,Args} | term(). +%% If it is MFA it will cause a trace initiator process to start spawning +%% on spawn_link(Mod,Func,Args). The trace initiator may for instance +%% initiate the wanted tracing. +start_link_auto(AutoModArgs) -> + {ok,spawn_link(?MODULE,auto_init,[AutoModArgs,self()])}. +%% ------------------------------------------------------------------------------ + +%% This function is entered into the child-specification of the runtime_tools_sup +%% if the runtime component shall be started manually via the control component. +start_link_man(Ctrl,Options,Tag) -> + {ok,spawn_link(?MODULE,init,[Ctrl,Options,Tag,self()])}. +%% ------------------------------------------------------------------------------ + +%% start(Node,Options,Tag,Condition)=tbd +%% Node=The node where the runtime component shall be started. +%% Options=[Opt]; List of options to the runtime component. +%% Opt={dependency,Val}|{dependency,{Val,Node}} +%% Val=int()|infinity +%% If the runtime component may run on its own or not. Val=0 means a runtime +%% component which will terminate immediately without its control component. +%% Note that if the runtime component is started manually, the Node part +%% is never used. The runtime is supposed to be dependent of the Ctrl mentioned +%% in the start_link_man parameters. +%% Opt={overload,OverLoad} | overload +%% The latter means no loadcheck. Necessary if changing the options. +%% Overload=Iterval (int() in milliseconds) | +%% {LoadMF,Interval}|{LoadMF,Interval,InitMFA,RemoveMFA} +%% LoadMF={Mod,Func}|function() +%% InitMFA,RemoveMFA={Mod,Func,ArgList} where +%% apply(InitM,InitF,InitArgs) -> {ok,DataStruct}|'void'. +%% apply(RemoveM,RemoveF,[DataStruct|Args]) -> don't care +%% LoadMF is called each time loadcheck is performed. +%% Mod:Func(DataStruct)->ok|{suspend,Reason} +%% If just Interval is used, it means using a default overload check. +%% Tag=term(), used to identify an incarnation of a runtime component so that +%% a control component reconnecting will know if it was its own incarnation +%% still alive, or some elses. +%% Condition='if_ref'|term(). Controls if we want to adopt the runtime component. +%% If 'if_ref' is stated it means that we only want to adopt a runtime component +%% with the suggested Tag. +%% +%% This is the API used by the control component when tries to start a runtime +%% component. Note that it will try to adopt an already running, if possible. +%% Adoptions are only possible if the runtime component at hand is running +%% without control component. +start(Node, Options, Tag, Condition) when Node == node() -> + ChildSpec = {?MODULE, {?MODULE, start_link_man, [self(), Options, Tag]}, + temporary, 5000, worker, [?MODULE]}, + case catch supervisor:start_child(?RT_SUP, ChildSpec) of + {ok, Pid} when is_pid(Pid) -> + {node_info, _Node, Pid, VSN, State, Status, _Tag} = + get_node_info(Pid), + {node_info, Node, Pid, VSN, State, Status, new}; + {error, already_present} -> + supervisor:delete_child(?RT_SUP, ?MODULE), + start(Node, Options, Tag, Condition); + {error, {already_started, Pid}} -> + try_to_adopt(Pid, Tag, Condition); + {error,Reason} -> + {error,Reason}; + {'EXIT',Reason} -> + {error,Reason} + end; +start(Node, Options, Tag, Condition) -> + case rt_version(Node) of + {error,Error} -> + {error,Error}; + _VSN -> + ChildSpec = {?MODULE, {?MODULE, start_link_man, + [self(), Options, Tag]}, + temporary, 5000, worker, [?MODULE]}, + case catch rpc:call(Node, supervisor, start_child, + [?RT_SUP, ChildSpec]) of + {ok, Pid} when is_pid(Pid) -> + {node_info, _Node, Pid, + VSN, State, Status, _Tag} = get_node_info(Pid), + {node_info, Node, Pid, VSN, State, Status, new}; + {error, already_present} -> + rpc:call(Node, supervisor, delete_child, + [?RT_SUP, ?MODULE]), + start(Node, Options, Tag, Condition); + {error, {already_started, Pid}} -> + try_to_adopt(Pid, Tag, Condition); + {error,Reason} -> % Could not start child. + {error,Reason}; + {badrpc,nodedown} -> + {error,nodedown}; + {badrpc,Reason} -> + {error,{badrpc,Reason}}; + {'EXIT',Reason} -> + {error,Reason} + end + end. + +rt_version(Node) -> + case catch rpc:call(Node,application,loaded_applications,[]) of + List when is_list(List) -> + case lists:keysearch(runtime_tools,1,List) of + {value,{_,_,VSN}} -> + VSN; + false -> + {error,not_loaded} + end; + {badrpc,nodedown} -> + {error,nodedown}; + {'EXIT',Reason} -> + {error,Reason} + end. +%% ------------------------------------------------------------------------------ + +%% stop(Node)=ok|{error,Reason} +%% Stops the runtim component on node Node. Note that this is mearly calling the +%% supervisor API to shutdown the inviso_rt child belonging to the runtime_tools_sup. +stop(Node) when Node==node() -> + supervisor:terminate_child(?RT_SUP,?MODULE), + supervisor:delete_child(?RT_SUP,?MODULE), + ok; +stop(Node) -> + case catch rpc:call(Node,supervisor,terminate_child,[?RT_SUP,?MODULE]) of + ok -> + stop_delete_child(Node); + {error,_} -> % No child running. + stop_delete_child(Node); % Make sure we remove it also. + {badrpc,Reason} -> + {error,{badrpc,Reason}}; + {'EXIT',Reason} -> + {error,Reason} + end. + +stop_delete_child(Node) -> + case catch rpc:call(Node,supervisor,delete_child,[?RT_SUP,?MODULE]) of + ok -> + ok; + {error,_} -> % No child running. + ok; + {badrpc,Reason} -> + {error,{badrpc,Reason}}; + {'EXIT',Reason} -> + {error,Reason} + end. +%% ------------------------------------------------------------------------------ + + +%% ============================================================================== +%% API for the control component. +%% ============================================================================== + +%% init_tracing(TracerData) -> +%% TracerData = LogTD | [{trace,LogTD},{ti,TiTD}] +%% LogTD = {HandlerFun, Data} | collector | +%% {relayer, pid()} | {ip, IPPortParameters} | +%% {file, FilePortParameters} +%% TiTD = {file,FileName} | {file,FileName,{InitPublLD,RemovePublLD,CleanPublLD}} +%% | {relay,Node} | {relay,Node,{InitPublLD,RemovePublLD,CleanPublLD}} +%% HandlerFun=fun(TraceMsg,Data)->NewData +%% IPPortParameters = Portno | {Portno, Qsiz} +%% Qsiz = +%% FilePortParameters = {Filename, wrap, Tail, {time, WrapTime}, WrapCnt} | +%% {FileName, wrap, Tail, WrapSize, WrapCnt} | +%% {FileName, wrap, Tail, WrapSize} | +%% {FileName, wrap, Tail} | FileName +%% Defines a tracer: +%% {HandlerFun, Data} - will be used as handler inside the runtime component for +%% every incomming trace message. +%% relayer - the runtime component will relay all comming trace messages to +%% the runtime component Pid. +%% collector - the runtime component is used as tracer or collector of relayed +%% trace messages using the default handler writing them to io. +%% ip | file - will start a tracer port using PortParameters +init_tracing(Pid,TracerData) -> + call(Pid,{init_tracing,TracerData}). +%% ------------------------------------------------------------------------------ + +%% stop_tracing(RTpids)=[{Node,NodeResult},...] +%% RTpids=[RTinfo,...] +%% RTinfo={RTpid,Node} | {{error,Reason},Node} +%% NodeResult={ok,State} | {error,Reason} +%% Sends a request to stop tracing to all nodes in RTpids, in parallel. Stop +%% tracing means that all trace flags are removed and the nodes go to idle +%% state. +stop_tracing_parallel(RTpids) -> + call_parallel(lists:map(fun({Pid,Node})->{Pid,Node,stop_tracing}; + (Error)->Error + end, + RTpids)). +%% ------------------------------------------------------------------------------ + +%% try_to_adopt(Pid,NewTag,Condition)= +%% {node_info,node(),self(),VSN,State,Status,{tag,PreviousTag}}|{error,Reason} +%% NewTag=term(), the identification tag we want the runtime component to use +%% from now on if adoption was successful. +%% Condition='if_ref', only adopt if current tag is NewTag. +%% PreviousTag= the tag the runtime component had before it accepted the +%% adoption. +%% This function shall only be used by a control component wishing to adopt this +%% runtime component. +try_to_adopt(Pid, Tag, Condition) -> + call(Pid,{try_to_adopt,Tag,Condition}). +%% ------------------------------------------------------------------------------ + +%% confirm_connection(Pid,Tag)= {node_info,node(),self(),VSN,State,Status,Tag}| +%% {error,refused}. +%% Must only be used by a control component having been contacted by the runtime +%% component Pid. It confirms to the runtime component that the control component +%% has accepted the connect request. +confirm_connection(Pid,Tag) -> + call(Pid,{confirm_connection,Tag}). +%% ------------------------------------------------------------------------------ + +%% get_node_info(Pid)={node_info,Node,Pid,VSN,State,Status,Tag}. +get_node_info(Pid) -> + call(Pid,get_node_info). +%% ------------------------------------------------------------------------------ + +%% suspend(NodeOrPid,Reason)=ok +%% call_suspend(NodeOrPid,Reason)=ok +%% Makes the runtime component and all of its helpers suspend. suspend/2 is +%% assynchronous. +suspend(NodeOrPid,Reason) -> + cast(NodeOrPid,{suspend,Reason}). + +call_suspend(NodeOrPid,Reason) -> + call(NodeOrPid,{suspend,Reason}). +%% ------------------------------------------------------------------------------ + +%% cancel_suspension(Pid)=ok +%% Function moving the runtime component to status running. Regardless of its +%% current status. +cancel_suspension(Pid) -> + call(Pid,cancel_suspension). +%% ------------------------------------------------------------------------------ + +%% change_options(Pid,Options)=ok +%% Options=list(); see the start_link_XXX functions. +%% Changes options according to Options list. +%% Changing the control component we shall be depending on has no effect. The +%% dependency value in self can however be changed, and takes effect immediately. +change_options(Pid,Options) -> + call(Pid,{change_options,Options}). +%% ------------------------------------------------------------------------------ + +%% clear_all_tp(Pid)=ok +%% Function removing all, both local and global trace-patterns from the node. +clear_all_tp(Pid) -> + call(Pid,clear_all_tp). +%% ------------------------------------------------------------------------------ + +%% clear(Pid,Options)={ok,{new,Status}} +%% Options=[Opt,...] +%% Opt=keep_trace_patterns | keep_log_files +%% Resets the runtime component to state 'new' by stopping all ongoing tracing, +%% closing and removing all associated logfiles. The Options can be used to +%% prevent the runtime component from being totally erased. +clear(Pid,Options) -> + call(Pid,{clear,Options}). +%% ------------------------------------------------------------------------------ + +%% flush(Pid)=ok | {error,Reason} +%% Sends the flush command to the trace-port, if we are using a trace-port and +%% are tracing. +flush(Pid) -> + call(Pid,flush). +%% ------------------------------------------------------------------------------ + +%% trace_patterns_parallel(RTpids,Args,Flags)=[{Node,Answer},...] +%% RTpids=[{RTpid,Node},...] or [{Error,Node},...] +%% Args=[Arg,...] +%% Arg={Mod,Func,Arity,MS}|{Mod,Func,Arity,MS,Opts} +%% Mod=atom()|reg_exp()|{Dir,reg_exp()} +%% Dir=reg_exp() +%% Answer=[Answer,...] +%% Answer=int()|{error,Reason} +%% API function for the control component sending trace-patterns to a list of +%% runtime components. Returns a [{Node,Answer},...] list in the same order. +trace_patterns_parallel(RTpids,Args,Flags) -> % Same args and flags for all. + call_parallel(lists:map(fun({Pid,Node})when is_pid(Pid)->{Pid,Node,{tp,Args,Flags}}; + (Error)-> Error + end, + RTpids)). +%% ------------------------------------------------------------------------------ + +%% trace_flags_parallel(RTpids,Args,How)= +%% trace_flags_parallel(RTpidsArgs,How)= +%% trace_flags_parallel(RTpidsArgsHow)=[{Node,Reply},...] +%% RTpids=[RTpidEntry,...] +%% RTpidEntry={RTpid,Node}|{Error,Node} +%% Error=term(), any term you wish to have as reply in Answer assoc. to Node. +%% Args=[{Process,Flags},...] +%% Process=pid()|registeredname()|'all'|'new'|'existing' +%% Flags=List of the allowed process trace flags. +%% RTpidsArgs=[RTpidArgEntry,...] +%% RTpidArgEntry={RTpid,Node,Args}|{Error,Node} +%% RTpidsArgsHow=[RTpidArgsHowEntry,...] +%% RTpidArgsHowEntry={RTpid,Node,Args,How}|{Error,Node} +%% How=true|false +%% Reply={ok,Answers} +%% Answers=[Answer,...], one for each Args and in the same order. +%% Answer=int()|{error,Reason} +%% API function used by the control component to send flags to a list of runtime +%% components. Returns a list of [{Node,Answer},... ] in the same order. +trace_flags_parallel(RTpids,Args,How) -> % Same args for every node! + call_parallel(lists:map(fun({Pid,Node})when is_pid(Pid)->{Pid,Node,{tf,Args,How}}; + (Error)-> Error + end, + RTpids)). + +trace_flags_parallel(RTpidArgs,How) -> % Different args but same how. + call_parallel(lists:map(fun({Pid,Node,Args})when is_pid(Pid)-> + {Pid,Node,{tf,Args,How}}; + (Error)-> + Error + end, + RTpidArgs)). + +trace_flags_parallel(RTpidArgsHow) -> % Both different args and hows. + call_parallel(lists:map(fun({Pid,Node,Args,How})when is_pid(Pid)-> + {Pid,Node,{tf,Args,How}}; + (Error)-> + Error + end, + RTpidArgsHow)). +%% ------------------------------------------------------------------------------ + +%% meta_pattern(RTpids,Args)=[{Node,Answer},...] +%% RTpids=[{RTpid,Node},...] or [{Error,Node},...] +%% Args={FunctionName,ArgList} +%% FunctionName=atom() +%% ArgList=list(), list of the arguments to FunctionName. +%% Answer=[Answer,...] +%% Answer=int()|{error,Reason} +%% Makes a call to the meta-tracer through its runtime component. Returns a list +%% a answers in the same order as RTpids. Note that if "someone" has discovered +%% that there is an error with a particular node, the error answer can be placed +%% in the RTpids list from the start. +meta_tracer_call_parallel(RTpids,Args) -> % Same args for all nodes. + call_parallel(lists:map(fun({Pid,Node})when is_pid(Pid)-> + {Pid,Node,{meta_tracer_call,Args}}; + (Error)-> + Error + end, + RTpids)). +%% ------------------------------------------------------------------------------ + +%% get_status(Pid)={ok,{State,Status}} +%% State=new|tracing|idle +%% Status=running|{suspended,Reason} +get_status(Pid) -> + call(Pid,get_status). +%% ------------------------------------------------------------------------------ + +%% get_tracerdata(Pid)={ok,TracerData} | {ok,no_tracerdata} | {error,Reason} +%% TracerData=see init_tracing +%% Fetches the current tracerdata from the runtime component. +get_tracerdata(Pid) -> + call(Pid,get_tracerdata). +%% ------------------------------------------------------------------------------ + +%% list_log(Pid)={ok,no_log}|{ok,LogCollection}|{error,Reason} +%% list_log(Pid,TracerData)= +%% LogCollection=[LogTypes,...] +%% LogTypes={trace_log,Dir,Files}|{ti_log,Dir,Files} +%% Dir=string() +%% Files=[FileNameWithoutDir,...] +%% Lists all files associated with the current tracerdata. Or finds out which +%% files there are stored in this node given a tracerdata. +list_logs(Pid) -> + call(Pid,list_logs). +list_logs(Pid,TD) -> + call(Pid,{list_logs,TD}). +%% ------------------------------------------------------------------------------ + +%% fetch_log(Pid,CollectPid)={ok,FetcherPid}|{complete,no_log}|{error,Reason} +%% fetch_log(Pid,CollectPid,Spec)= +%% CollectPid=pid(), the process which will be given the transfered logs. +%% Spec=TracerData|LogCollection +%% Transferes a number of files using ditributed Erlang to CollectPid. This +%% function is supposed to be used internally by a control component. It returns +%% when the transfer is initiated and does not mean it is done or successful. +fetch_log(Pid,CollectPid) -> + call(Pid,{fetch_log,CollectPid}). +fetch_log(Pid,CollectPid,Spec) -> + call(Pid,{fetch_log,CollectPid,Spec}). +%% ------------------------------------------------------------------------------ + +%% delete_log(Pid,TracerDataOrLogList)={ok,Results}|{error,Reason} +%% TracerDataOrLogList=[FileNameWithPath,...]|LogCollection|TracerData +%% Results=[LogType,...] +%% LogType={trace_log,FileSpecs}|{ti_log,FilesSpecs} +%% FilesSpecs=[FileSpec,...] +%% FileSpec={ok,FileName}|{error,{Posix,FileName}} +%% Filename=string(), the filename without dir-path. +delete_log(Pid) -> + call(Pid,delete_logs). +delete_log(Pid,TracerDataOrLogList) -> + call(Pid,{delete_logs,TracerDataOrLogList}). +%% ------------------------------------------------------------------------------ + +%% state(NodeOrPid)=LoopData +%% Returns the loopdata of the runtime component. Only meant for debugging. +state(NodeOrPid) -> + call(NodeOrPid,state). +%% ------------------------------------------------------------------------------ + + +%% ============================================================================== +%% API for local calls made from the same node. E.g autostart. +%% ============================================================================== + +%% init_tracing(TracerData)= +%% See init_tracing/2. +init_tracing(TracerData) -> + call_regname(?MODULE,{init_tracing,TracerData}). +%% ------------------------------------------------------------------------------ + + +%% Meaning that these function does most often not have to be called by a +%% control component because there are more efficient ones above. + +%% tp(Module,Function,Arity,MatchSpec) -> +%% tp(Module,Function,Arity,MatchSpec,Opts) -> +%% tp(PatternList) -> +%% Module = '_'|atom()|ModRegExp|{DirRegExp,ModRegExp} +%% Function == atom() | '_' +%% Arity = integer() | '_' +%% MatchSpec = true | false | [] | matchspec() see ERTS User's guide for a +%% description of match specifications. +%% Opts=list(); 'only_loaded' +%% PatternList = [Pattern], +%% Pattern = {Module,Function,Arity,MatchSpec,Opts}, +%% Set trace pattern (global). +tp(Module,Function,Arity,MatchSpec) -> + tp(Module,Function,Arity,MatchSpec,[]). +tp(Module,Function,Arity,MatchSpec,Opts) -> + call_regname(?MODULE,{tp,[{Module,Function,Arity,MatchSpec,Opts}],[global]}). +tp(PatternList) -> + call_regname(?MODULE,{tp,PatternList,[global]}). +%% ------------------------------------------------------------------------------ + +tpg(Mod,Func,Arity,MatchSpec) -> + tp(Mod,Func,Arity,MatchSpec). +tpg(Mod,Func,Arity,MatchSpec,Opts) -> + tp(Mod,Func,Arity,MatchSpec,Opts). +tpg(PatternList) -> + tp(PatternList). +%% ------------------------------------------------------------------------------ + +%% tpl(Module,Function,Arity,MatchSpec) -> +%% tpl(Module,Function,Arity,MatchSpec,Opts) -> +%% tpl(PatternList) -> +%% Module = Function == atom() | '_' | RegExpMod | {RegExpDir,RegExpMod} +%% Arity = integer() | '_' +%% MatchSpec = true | false | [] | matchspec() see ERTS User's guide for a +%% Opts=list(); 'only_loaded' +%% description of match specifications. +%% PatternList = [Pattern], +%% Pattern = {Module, Function, Arity, MatchSpec}, +%% Set trace pattern (local). +tpl(Module,Function,Arity,MatchSpec) -> + call_regname(?MODULE,{tp,[{Module,Function,Arity,MatchSpec,[]}],[local]}). +tpl(Module,Function,Arity,MatchSpec,Opts) -> + call_regname(?MODULE,{tp,[{Module,Function,Arity,MatchSpec,Opts}],[local]}). +tpl(PatternList) -> + call_regname(?MODULE,{tp,PatternList,[local]}). +%% ------------------------------------------------------------------------------ + +%% ctp(Module,Function,Arity) -> +%% ctp(PatternList)= +%% Module = atom()|'_'|RegExpMod|{RegExpDir,RegExpMod} +%% Function == atom() | '_' +%% Arity = integer() | '_' +%% PatternList=[{Mod,Func,Arity},...] +%% Clear trace pattern (global). +%% Note that it is possible to clear patterns using regexps. But we can for +%% natural reasons only clear patterns for loaded modules. Further more there +%% seems to be a fault in the emulator (<=R10B) crashing if we remove patterns +%% for deleted modules. Therefore we use the only_loaded option. +ctp(Module,Function,Arity) -> + call_regname(?MODULE,{tp,[{Module,Function,Arity,false,[only_loaded]}],[global]}). +ctp(PatternList) -> + call_regname(?MODULE, + {tp, + lists:map(fun({M,F,A})->{M,F,A,false,[only_loaded]} end,PatternList), + [global]}). +%% ------------------------------------------------------------------------------ + +ctpg(Mod,Func,Arity) -> + ctp(Mod,Func,Arity). +ctpg(PatternList) -> + ctp(PatternList). +%% ------------------------------------------------------------------------------ + +%% ctpl(Module,Function,Arity) -> +%% Module = atom()|'_'|RegExpMod|{RegExpDir,RegExpMod} +%% Function == atom() | '_' +%% Arity = integer() | '_' +%% PatternList=[{Mod,Func,Arity},...] +%% Clear trace pattern (local). +ctpl(Module,Function,Arity) -> + call_regname(?MODULE,{tp,[{Module,Function,Arity,false,[only_loaded]}],[local]}). +ctpl(PatternList) -> + call_regname(?MODULE, + {tp, + lists:map(fun({M,F,A})->{M,F,A,false,[only_loaded]} end,PatternList), + [local]}). +%% ------------------------------------------------------------------------------ + +init_tpm(Mod,Func,Arity,CallFunc) -> + call_regname(?MODULE,{meta_tracer_call,{init_tpm,[Mod,Func,Arity,CallFunc]}}). + +init_tpm(Mod,Func,Arity,InitFunc,CallFunc,ReturnFunc,RemoveFunc) -> + call_regname(?MODULE, + {meta_tracer_call, + {init_tpm, + [Mod,Func,Arity,InitFunc,CallFunc,ReturnFunc,RemoveFunc]}}). +%% ------------------------------------------------------------------------------ + +tpm(Mod,Func,Arity,MS) -> + call_regname(?MODULE,{meta_tracer_call,{tpm,[Mod,Func,Arity,MS]}}). +tpm(Mod,Func,Arity,MS,CallFunc) -> + call_regname(?MODULE,{meta_tracer_call,{tpm,[Mod,Func,Arity,MS,CallFunc]}}). +tpm(Mod,Func,Arity,MS,InitFunc,CallFunc,ReturnFunc,RemoveFunc) -> + call_regname(?MODULE, + {meta_tracer_call, + {tpm, + [Mod,Func,Arity,MS,InitFunc,CallFunc,ReturnFunc,RemoveFunc]}}). +%% ------------------------------------------------------------------------------ + +tpm_tracer(Mod,Func,Arity,MS) -> + call_regname(?MODULE,{meta_tracer_call,{tpm_tracer,[Mod,Func,Arity,MS]}}). +tpm_tracer(Mod,Func,Arity,MS,CallFunc) -> + call_regname(?MODULE,{meta_tracer_call,{tpm_tracer,[Mod,Func,Arity,MS,CallFunc]}}). +tpm_tracer(Mod,Func,Arity,MS,InitFunc,CallFunc,ReturnFunc,RemoveFunc) -> + call_regname(?MODULE, + {meta_tracer_call, + {tpm_tracer, + [Mod,Func,Arity,MS,InitFunc,CallFunc,ReturnFunc,RemoveFunc]}}). +%% ------------------------------------------------------------------------------ + +tpm_ms(Mod,Func,Arity,MSname,MS) -> + call_regname(?MODULE,{meta_tracer_call,{tpm_ms,[Mod,Func,Arity,MSname,MS]}}). +%% ------------------------------------------------------------------------------ + +tpm_ms_tracer(Mod,Func,Arity,MSname,MS) -> + call_regname(?MODULE,{meta_tracer_call,{tpm_ms_tracer,[Mod,Func,Arity,MSname,MS]}}). +%% ------------------------------------------------------------------------------ + +ctpm_ms(Mod,Func,Arity,MSname) -> + call_regname(?MODULE,{meta_tracer_call,{ctpm_ms,[Mod,Func,Arity,MSname]}}). +%% ------------------------------------------------------------------------------ + +local_register() -> + call_regname(?MODULE,{meta_tracer_call,{local_register,[]}}). +%% ------------------------------------------------------------------------------ + +global_register() -> + call_regname(?MODULE,{meta_tracer_call,{global_register,[]}}). +%% ------------------------------------------------------------------------------ + +ctpm(Mod,Func,Arity) -> + call_regname(?MODULE,{meta_tracer_call,{ctpm,[Mod,Func,Arity]}}). +%% ------------------------------------------------------------------------------ + +remove_local_register() -> + call_regname(?MODULE,{meta_tracer_call,{remove_local_register,[]}}). +%% ------------------------------------------------------------------------------ + +remove_global_register() -> + call_regname(?MODULE,{meta_tracer_call,{remove_global_register,[]}}). +%% ------------------------------------------------------------------------------ + +%% tf(PidSpec, FlagList) -> +%% tf(TraceConfList) -> +%% TraceConfList = [{PidSpec, FlagList}], +%% FlagList = [Flags], +%% PidSpec = all | new | existing | pid() | registeredname() +%% Flags = all | send | 'receive' | procs | call | silent | return_to | +%% running | garbage_collection | timestamp | cpu_timestamp | arity | +%% set_on_spawn | set_on_first_spawn | set_on_link | set_on_first_link +%% Set trace flags. +tf(PidSpec, FlagList) -> + call_regname(?MODULE,{tf,[{PidSpec,FlagList}],true}). + +tf(TraceConfList) -> + call_regname(?MODULE,{tf,TraceConfList,true}). +%% ------------------------------------------------------------------------------ + +%% ctf(PidSpec, FlagList) -> +%% ctf(TraceConfList) -> +%% TraceConfList = [{PidSpec, FlagList}], +%% FlagList = [Flags], +%% PidSpec = all | new | existing | pid() | registeredname() +%% Flags = all | send | 'receive' | procs | call | silent | return_to | +%% running | garbage_collection | timestamp | cpu_timestamp | arity | +%% set_on_spawn | set_on_first_spawn | set_on_link | set_on_first_link +%% Clear trace flags. +ctf(PidSpec, FlagList) -> + call_regname(?MODULE,{tf,[{PidSpec,FlagList}],false}). + +ctf(TraceConfList) -> + call_regname(?MODULE,{tf_as,TraceConfList,false}). +%% ------------------------------------------------------------------------------ + + +%% ------------------------------------------------------------------------------ +%% Client side functions. +%% ------------------------------------------------------------------------------ + +%% Call function managing the client to server communication. This function may +%% be run by a client on a different node. +%% Note that we must use two different functions for calling a named process and +%% calling the runtime component at a specified node. +call(Pid,Request) when is_pid(Pid) -> + call_2(Pid,Request); +call(Node,Request) when Node==node() -> % To our node! + call_2(?MODULE,Request); +call(Node,Request) when is_atom(Node) -> + call_2({?MODULE,Node},Request); +call(To,_Request) -> + {error,{badarg,To}}. + +call_regname(Name,Request) when is_atom(Name) -> % To a registered name. + call_2(Name,Request). + +call_2(To,Request) -> + MRef=erlang:monitor(process,To), % Use a monitor to avoid waiting for ever. + Ref=make_ref(), + case catch To ! {Request,self(),Ref} of % Can be a remote pid. + {'EXIT',_} -> % If we use registered name. + erlang:demonitor(MRef), % Maybe not necessary!? + receive + {'DOWN',MRef,_Type,_Obj,_Info} -> + true + after + 0 -> + true + end, + {error,not_started}; + _ -> % At least no obvious error. + receive + {Msg,Ref} -> + erlang:demonitor(MRef), + Msg; + {'DOWN',MRef,_Type,_Obj,Info} -> % The runtime component disapeared. + {error,{no_response,Info}} + end + end. +%% ----------------------------------------------------------------------------- + +%% Multicall function taking a list of [{Pid,Node,Request},...] and sends +%% a request to every Pid. This function then also allows you to send multiple +%% requests to the same Pid since it will sit and wait for all replies. +%% Note that RTspec may also be an [{{error,Reason},Node},...]. That tuple will +%% then be used as reply in the reply list. +%% Returns [{Node,Reply},...] for every element in RTspec, in the same order. +call_parallel(RTspec) -> + Ref=make_ref(), + {Nr,Pending}=call_parallel_2(RTspec,Ref,0,[]), + Replies=call_parallel_3(Ref,Pending,Nr,[],[]), + call_parallel_build_reply(RTspec,1,Replies). + +call_parallel_2([{Pid,Node,Request}|Rest],Ref,Nr,Pending) when is_pid(Pid) -> + Pid ! {Request,self(),{Ref,Nr+1}}, + MRef=erlang:monitor(process,Pid), % So we won't wait for ever for it. + call_parallel_2(Rest,Ref,Nr+1,[{Nr+1,Node,MRef}|Pending]); +call_parallel_2([{{error,_Reason},_Node}|Rest],Ref,Nr,Pending) -> + call_parallel_2(Rest,Ref,Nr,Pending); % Just skip it. This is no process. +call_parallel_2([_Faulty|Rest],Ref,Nr,Pending) -> % Should not happend. + call_parallel_2(Rest,Ref,Nr,Pending); % But we choose to skip it instead of crash. +call_parallel_2([],_,Nr,Pending) -> + {Nr,Pending}. + +%% Help function collecting reply-messages sent from the runtime components. We +%% count down until we got a reply for every pending request. Or if we get a DOWN +%% message indicating that the runtime component is no longer present. Note that +%% we can by accident read away DOWN messages not belonging to this procedure. +%% They are collected to be reissued after we are done. +call_parallel_3(_Ref,_Pending,0,Replies,DownMsgs) -> % All expected received. + lists:foreach(fun({MRef,Pid,Info}) -> self() ! {'DOWN',MRef,process,Pid,Info} end, + DownMsgs), % Reissue the down messages! + Replies; +call_parallel_3(Ref,Pending,NrOfPending,Replies,DownMsgs) -> + receive + {Reply,{Ref,Nr}} -> + case lists:keysearch(Nr,1,Pending) of + {value,{_Nr,Node,MRef}} -> + erlang:demonitor(MRef), + call_parallel_3(Ref,Pending,NrOfPending-1, + [{Nr,Node,Reply}|Replies],DownMsgs); + false -> % Really strange! + call_parallel_3(Ref,Pending,NrOfPending,Replies,DownMsgs) + end; + {'DOWN',MRef,process,Pid,Info} -> % Probably process we monitor terminated. + case lists:keysearch(MRef,3,Pending) of + {value,{Nr,Node,_}} -> % Yes it was one of our processes. + call_parallel_3(Ref,Pending,NrOfPending-1, + [{Nr,Node,{error,no_reponse}}|Replies],DownMsgs); + false -> % We picked up a DOWN msg by misstake. + call_parallel_3(Ref,Pending,NrOfPending,Replies, + [{MRef,Pid,Info}|DownMsgs]) + end + end. + +%% Help function which build up the [{Node,Reply},...] list in the same order as RTspec. +call_parallel_build_reply([],_,_) -> + []; +call_parallel_build_reply([{Pid,Node,_Request}|Rest],Nr,Replies) when is_pid(Pid) -> + {value,{_Nr,_Node,Reply}}=lists:keysearch(Nr,1,Replies), + [{Node,Reply}|call_parallel_build_reply(Rest,Nr+1,Replies)]; +call_parallel_build_reply([{{error,Reason},Node}|Rest],Nr,Replies) -> + [{Node,{error,Reason}}|call_parallel_build_reply(Rest,Nr,Replies)]; +call_parallel_build_reply([_Faulty|Rest],Nr,Replies) -> + call_parallel_build_reply(Rest,Nr,Replies). +%% ------------------------------------------------------------------------------ + +cast(Pid,Request) when is_pid(Pid) -> + cast2(Pid,Request); +cast(Node,Request) when Node==node() -> + catch cast2(?MODULE,Request), + ok; +cast(Node,Request) when is_atom(Node) -> + catch cast2({?MODULE,Node},Request), + ok; +cast(BadAddress,_Request) -> + {error,{badarg,BadAddress}}. + +cast2(To,Request) -> + To ! {Request,void,void}. % Mimics the call protocol. +%% ------------------------------------------------------------------------------ + + +%% ============================================================================== +%% Implementation of the runtime component (server side). +%% ============================================================================== + +%% Since the runtime component is not implemented using gen_sever we are "free" +%% to use what ever functionnames we like. + +%% Initial function on which the runtime component is spawned on if started by +%% a controlcomponent. +init(Ctrl, Options, Tag, Parent) when is_list(Options) -> + %% started from controller + process_flag(trap_exit,true), + register(?MODULE,self()), % Will crash if rt is already running + do_clear_trace_patterns(), % Remove potential old patterns left. + LD1=read_option_list(Options, + #rt{state=new, + parent=Parent, + ctrl=Ctrl, + vsn=get_application_vsn(), + tag=Tag}), + OverloadData=initialize_overload(LD1), + CtrlRef=erlang:monitor(process,Ctrl), % Monitor our control component. + loop1(LD1#rt{ctrl_ref=CtrlRef,overload_data=OverloadData}). +%% ---------------------------------------------------------------------------- + +%% Initial function on which the runtime component is spawned on if started +%% by the runtime_tools supervisor. It is here it is determined if we shall +%% autostart. +auto_init(AutoModArgs,Parent) -> + %% autostart + process_flag(trap_exit, true), + register(?MODULE, self()), % Will crash if a rt is already running + AutoMod=get_autostart_module(), % Determine which module to use! + case catch AutoMod:autostart(AutoModArgs) of + {MFA,Options,Tag} -> + do_clear_trace_patterns(), % Remove previously left patterns. + LD1=read_option_list(Options,#rt{state=new, + parent=Parent, + vsn=get_application_vsn(), + tag=Tag}), + case auto_init_connect_control(LD1) of + {ok,LD2} -> % Either connected or running_alone. + OverloadData=initialize_overload(LD2), + case auto_init_check_mfa(MFA) of + {ok,{M,F,A}} -> % We shall start somekind of tracing! + P=spawn_link(M,F,A), % It lives its own life, only link! + loop1(LD2#rt{auto_starter=P,overload_data=OverloadData}); + false -> + loop1(LD2#rt{overload_data=OverloadData}) + end; + stop -> % Not allowed to run alone! + true % Simply terminate. + end; + _ -> % Non existent or faulty autostart mod! + true % Terminate normally. + end. + +auto_init_connect_control(LD1) -> + case auto_init_connect_find_pid(LD1#rt.dependency) of + Pid when is_pid(Pid) -> % There is a control component. + CtrlRef=erlang:monitor(process,Pid), + Pid ! {connect,node(),self(),LD1#rt.vsn,LD1#rt.tag}, + {ok,LD1#rt{ctrl_ref=CtrlRef,ctrl=Pid}}; + _ -> % There is no control component. + do_down_message(LD1) % Will return 'stop' or a LoopData. + end. + +%% Help function which finds the pid of the control component. +auto_init_connect_find_pid({_TimeOut,Node}) when Node==node() -> + whereis(?CTRL); +auto_init_connect_find_pid({_TimeOut,Node}) when is_atom(Node) -> + rpc:call(Node,erlang,whereis,[?CTRL]); +auto_init_connect_find_pid(_) -> % Node is not a proper node. + undefined. % Act as could not find control comp. + +%% Help function checking that the parameter is reasonable to be used as +%% spawn_link argument. +auto_init_check_mfa({M,F,A}) when is_atom(M),is_atom(F),is_list(A) -> + {ok,{M,F,A}}; +auto_init_check_mfa(_) -> + false. + +%% Help function to init_auto which finds out which module to call for +%% guidance on how to proceed. Returns an atom. +get_autostart_module() -> + case application:get_env(inviso_autostart_mod) of + {ok,Mod} when is_atom(Mod) -> + Mod; + _ -> + inviso_autostart % The default autostart module. + end. +%% ---------------------------------------------------------------------------- + + +%% This is the preloop function which performs loadcheck if necessary. Note +%% that it calculates the timeout used in the after in the real loop. There is +%% further no use doing overload checks if we are not tracing or already +%% suspended. There is yet one more situation, we do not want to perform +%% overload checks if the interval is set to infinity. This can be the case if +%% we are using an external source pushing overload information instead. +loop1(LD=#rt{overload=Overload}) -> + if + Overload/=?NO_LOADCHECK,element(2,Overload)/=infinity -> + Now=now(), + if + LD#rt.status==running, + LD#rt.state==tracing, + Now>LD#rt.next_loadcheck -> % Do loadcheck only then! + {NewLD,TimeOut}=do_check_overload(LD,{timeout,LD#rt.overload_data}), + loop(NewLD,TimeOut); + LD#rt.status==running,LD#rt.state==tracing -> + Timeout=calc_diff_to_now(Now,LD#rt.next_loadcheck), + loop(LD,Timeout); + true -> % Do not spend CPU on this! :-) + loop(LD,infinity) + end; + true -> % Either no check or infinity. + loop(LD,infinity) + end. + +loop(LoopData,Timeout) -> + receive + Msg when element(1,Msg)==trace_ts; + element(1,Msg)==trace; + element(1,Msg)==drop; + element(1,Msg)==seq_trace -> + case LoopData#rt.handler of + {HandlerFun,Data} -> + NewData=HandlerFun(Msg,Data), + loop1(LoopData#rt{handler={HandlerFun,NewData}}); + _ -> + loop1(LoopData) + end; + {{tp,Args,Flags},From,Ref} -> + if + LoopData#rt.status==running -> % Not when suspended. + Reply=do_set_trace_patterns(Args,Flags), + if + LoopData#rt.state==new -> % No longer new when tp set. + reply_and_loop({ok,Reply},From,Ref,LoopData#rt{state=idle}); + true -> + reply_and_loop({ok,Reply},From,Ref,LoopData) + end; + true -> % We are suspended! + reply_and_loop({error,suspended},From,Ref,LoopData) + end; + {{tf,Args,How},From,MRef} -> + Reply= + case How of + true -> + if + LoopData#rt.status==running -> + case {LoopData#rt.tracer_port,LoopData#rt.handler} of + {Port,_} when is_port(Port) -> + do_set_trace_flags(Port,Args,How); + {_,{Handler,_D}} when is_function(Handler) -> + do_set_trace_flags(self(),Args,How); + _ -> + {error,no_tracer} + end; + true -> % Can't turn *on* flags if suspended. + {error, suspended} + end; + false -> % No tracer needed when turning off. + do_set_trace_flags(void,Args,How) + end, + reply_and_loop(Reply,From,MRef,LoopData); + {{meta_tracer_call,Args},From,MRef} -> + if + LoopData#rt.status==running -> + case LoopData#rt.meta_tracer of + MPid when is_pid(MPid) -> + Reply=do_meta_pattern(MPid,Args), + reply_and_loop(Reply,From,MRef,LoopData); + _ -> + reply_and_loop({error,no_metatracer},From,MRef,LoopData) + end; + true -> + reply_and_loop({error,suspended},From,MRef,LoopData) + end; + {clear_all_tp,From,MRef} -> + do_clear_trace_patterns(), + reply_and_loop(ok,From,MRef,LoopData); + {{init_tracing,TracerData},From,MRef} -> + {NewLoopData,Reply}= + if + LoopData#rt.status==running -> + if + LoopData#rt.state==tracing -> + {LoopData,{error,already_initiated}}; + true -> % Otherwise, try to init-tracing! + case translate_td(TracerData) of + {ok,LogTD,MetaTD} -> + do_init_tracing(LoopData,TracerData,LogTD,MetaTD); + Error -> + {LoopData,Error} + end + end; + true -> % Can't init tracing if not running. + {LoopData,{error,suspended}} + end, + reply_and_loop(Reply,From,MRef,NewLoopData); + {stop_tracing,From,MRef} -> + case LoopData#rt.state of + tracing -> % Only case we need to do anything. + reply_and_loop({ok,idle},From,MRef,do_stop_tracing(LoopData)); + idle -> % Already idle! + reply_and_loop({ok,idle},From,MRef,LoopData); + new -> % Have actually never traced! + reply_and_loop({ok,new},From,MRef,LoopData) + end; + {{suspend,Reason},From,MRef} -> + if + LoopData#rt.status==running -> + NewLD=do_suspend(LoopData,Reason), + reply_and_loop(ok,From,MRef,NewLD); + true -> % No need suspend if not running! + reply_and_loop(ok,From,MRef,LoopData) + end; + {cancel_suspension,From,MRef} -> + NewLoopData=LoopData#rt{status=running,next_loadcheck=now()}, + send_event(state_change,NewLoopData), + reply_and_loop(ok,From,MRef,NewLoopData); + {{clear,Options},From,MRef} -> + NewLoopData=do_clear(LoopData,Options), + reply_and_loop({ok,{new,NewLoopData#rt.status}},From,MRef,NewLoopData); + {flush,From,MRef} -> + case LoopData#rt.state of + tracing -> % Can only flush if we are tracing. + if + is_port(LoopData#rt.tracer_port) -> + trace_port_control(LoopData#rt.tracer_port,flush), + reply_and_loop(ok,From,MRef,LoopData); + true -> % Not necessary but lets pretend. + reply_and_loop(ok,From,MRef,LoopData) + end; + State -> + reply_and_loop({error,{not_tracing,State}},From,MRef,LoopData) + end; + {list_logs,From,MRef} -> + TracerData=LoopData#rt.tracerdata, % Current tracerdata. + if + TracerData/=undefined -> % There is tracerdata! + reply_and_loop(do_list_logs(TracerData),From,MRef,LoopData); + true -> % Have no current tracerdata! + reply_and_loop({error,no_tracerdata},From,MRef,LoopData) + end; + {{list_logs,TracerData},From,MRef} -> + reply_and_loop(do_list_logs(TracerData),From,MRef,LoopData); + {{fetch_log,CollectPid},From,MRef} -> % Fetch according to current tracerdata. + TracerData=LoopData#rt.tracerdata, % Current tracerdata. + if + TracerData/=undefined -> % There is tracerdata! + {Reply,NewLD}=do_fetch_log(LoopData,CollectPid,TracerData), + reply_and_loop(Reply,From,MRef,NewLD); + true -> % No tracerdata! + reply_and_loop({error,no_tracerdata},From,MRef,LoopData) + end; + {{fetch_log,CollectPid,Spec},From,MRef} -> % Either list of files or tracerdata. + {Reply,NewLD}=do_fetch_log(LoopData,CollectPid,Spec), + reply_and_loop(Reply,From,MRef,NewLD); + {delete_logs,From,MRef} -> + if + LoopData#rt.state==tracing -> % Can't remove then! + reply_and_loop({error,tracing},From,MRef,LoopData); + true -> + TracerData=LoopData#rt.tracerdata, + reply_and_loop(do_delete_logs(TracerData),From,MRef,LoopData) + end; + {{delete_logs,TracerDataOrLogList},From,MRef} -> + if + LoopData#rt.state==tracing -> % Can't remove then! + reply_and_loop({error,tracing},From,MRef,LoopData); + true -> + reply_and_loop(do_delete_logs(TracerDataOrLogList),From,MRef,LoopData) + end; + {get_node_info,From,MRef} -> + Reply=collect_node_info(LoopData), + reply_and_loop(Reply,From,MRef,LoopData); + {{try_to_adopt,Tag,Condition},From,MRef} -> + if + LoopData#rt.ctrl_ref==undefined -> % We have no control component. + {Reply,NewLoopData}=do_try_to_adopt(Tag,Condition,LoopData,From), + reply_and_loop(Reply,From,MRef,NewLoopData); + true -> % We already have a control component. + reply_and_loop({error,refused},From,MRef,LoopData) + end; + {{confirm_connection,_Tag},From,MRef} -> + if + LoopData#rt.ctrl==From -> % It must be from this process! + Reply=collect_node_info(LoopData), + reply_and_loop(Reply,From,MRef,LoopData); + true -> % Strange, some one is joking? + reply_and_loop({error,refused},From,MRef,LoopData) + end; + {{change_options,Options},From,MRef} -> + case do_change_options(Options,LoopData) of + stop -> % Can't run alone with these options! + terminate_overload(LoopData), + From ! {ok,MRef}; % Don't care if From not a proper pid! + NewLoopData when is_record(NewLoopData,rt) -> + reply_and_loop(ok,From,MRef,NewLoopData) + end; + {get_status,From,MRef} -> + Reply={ok,{LoopData#rt.state,LoopData#rt.status}}, + reply_and_loop(Reply,From,MRef,LoopData); + {get_tracerdata,From,MRef} -> + case LoopData#rt.tracerdata of + undefined -> + reply_and_loop({ok,no_tracerdata},From,MRef,LoopData); + TracerData -> + reply_and_loop({ok,TracerData},From,MRef,LoopData) + end; + {state,From,MRef} -> % For debugging purposes. + reply_and_loop(LoopData,From,MRef,LoopData); + + {'DOWN',CtrlRef,process,_,_} when CtrlRef==LoopData#rt.ctrl_ref -> + case do_down_message(LoopData) of + stop -> % inviso_c gone and we must stop! + terminate_overload(LoopData), + exit(running_alone); + {ok,NewLoopData} -> + loop1(NewLoopData) + end; + {'EXIT',Pid,Reason} -> + case act_on_exit(Pid,Reason,LoopData) of + exit -> + terminate_overload(LoopData), + exit(Reason); + NewLoopData when is_record(NewLoopData,rt) -> + loop1(NewLoopData); + {NewLoopData,NewTimeOut} when is_record(NewLoopData,rt) -> + loop(NewLoopData,NewTimeOut) + end; + Other -> % Check if it concerns overload. + if + LoopData#rt.overload/=?NO_LOADCHECK, + LoopData#rt.status==running, + LoopData#rt.state==tracing -> + {NewLD,NewTimeOut}= + do_check_overload(LoopData, + {msg,{Other,LoopData#rt.overload_data}}), + loop(NewLD,NewTimeOut); + true -> + NewTimeOut=calc_diff_to_now(now(),LoopData#rt.next_loadcheck), + loop(LoopData,NewTimeOut) + end + after + Timeout -> + loop1(LoopData) + end. + +reply_and_loop(Reply,To,MRef,LoopData) when is_pid(To) -> + To ! {Reply,MRef}, + loop1(LoopData); +reply_and_loop(_,_,_,LoopData) -> % Used together with incoming casts. + loop1(LoopData). +%% ----------------------------------------------------------------------------- + + +%% ============================================================================= +%% File transfer process implementation. +%% ============================================================================= + +%% Files that are to to be transfered from the runtime component to the control +%% component are done so by reading them as binaries and sending them with +%% normal message passing (over distributed Erlang). +%% Reading the files are done in a process separate to the runtime component, +%% to both make the code more simple. But also to free up the runtime component. +%% +%% This help process must be capable of recognizing the fact that the runtime +%% component has been suspended, and then of course also discontinue any file +%% transfere. +fetch_init(Parent,Files,CollectPid,ChunkSize) -> + process_flag(trap_exit,true), % We must clean-up. + process_flag(priority,low), % Lets be careful. + case fetch_open_file(Files,CollectPid) of + {ok,FileName,FD,RestFiles} -> + MRef=erlang:monitor(process,CollectPid), + fetch_loop(Parent,RestFiles,CollectPid,ChunkSize,FileName,FD,MRef); + done -> + fetch_end(CollectPid); + error -> + fetch_incomplete(CollectPid) + end. + +fetch_loop(Parent,Files,CollectPid,ChunkSize,FName,FD,MRef) -> + receive + {suspend,Parent} -> % The runtime component is suspended. + file:close(FD), % We must clean-up. + fetch_incomplete(CollectPid); + {'DOWN',MRef,process,_,_} -> % The CollectPid terminated! + file:close(FD); % Close file and terminate. + {'EXIT',Parent,_Reason} -> % The runtime component terminated. + file:close(FD), + fetch_incomplete(CollectPid); + _ -> + fetch_loop(Parent,Files,CollectPid,ChunkSize,FName,FD,MRef) + after + 0 -> % If non of the above, get to work! + case file:read(FD,ChunkSize) of + {ok,Bin} -> + fetch_send_chunk(CollectPid,Bin), + case fetch_wait_for_chunk_ack(CollectPid,MRef) of + ok -> % Collector ready to receive next chunk. + fetch_loop(Parent,Files,CollectPid,ChunkSize,FName,FD,MRef); + cancel -> % Send no more files! + file:close(FD), % Close file, send incomplete, terminate! + fetch_incomplete(CollectPid); + 'DOWN' -> % Collector has terminate, stop! + file:close(FD) % Close file and terminate. + end; + eof -> % Ok, go on with the next file. + file:close(FD), + fetch_send_eof(CollectPid), + case fetch_open_file(Files,CollectPid) of + {ok,NewFName,NewFD,RestFiles} -> + fetch_loop(Parent,RestFiles,CollectPid, + ChunkSize,NewFName,NewFD,MRef); + done -> + fetch_end(CollectPid); + error -> + fetch_incomplete(CollectPid) + end; + {error,Reason} -> % Do not continue. + file:close(FD), + fetch_send_readerror(CollectPid,FName,Reason), + fetch_incomplete(CollectPid) + end + end. +%% ----------------------------------------------------------------------------- + +%% Help function which opens the next file to be transferred. It also communicates +%% the opening of the file to the collector process. +%% We know here that it will be a list of three-tuples. But there is no guarantee +%% that Dir or FileName are proper strings. +%% Returns {ok,FileName,FileDescriptor,RemainingFiles} or 'done'. +fetch_open_file([{FType,Dir,FileName}|RestFiles],CollectPid) -> + case catch file:open(filename:join(Dir,FileName),[read,raw,binary]) of + {ok,FD} -> + CollectPid ! {node(),open,{FType,FileName}}, + {ok,FileName,FD,RestFiles}; + {error,_Reason} -> + CollectPid ! {node(),open_failure,{FType,FileName}}, + error; + {'EXIT',_Reason} -> % Faulty Dir or FileName. + CollectPid ! {node(),open_failure,{FType,FileName}}, + error + end; +fetch_open_file([],_CollectPid) -> + done. +%% ----------------------------------------------------------------------------- + +%% A group of help functions sending information to the collector process. +%% Returns nothing significant. +fetch_send_chunk(CollectPid,Bin) -> + CollectPid ! {node(),payload,Bin,self()}. +%% ----------------------------------------------------------------------------- + +fetch_send_eof(CollectPid) -> + CollectPid ! {node(),end_of_file}. +%% ----------------------------------------------------------------------------- + +fetch_end(CollectPid) -> + CollectPid ! {node(),end_of_transmission}. +%% ----------------------------------------------------------------------------- + +fetch_send_readerror(CollectPid,FName,Reason) -> + CollectPid ! {node(),{error,{file_read,{Reason,FName}}}}. +%% ----------------------------------------------------------------------------- + +fetch_incomplete(CollectPid) -> + CollectPid ! {node(),incomplete}. +%% ----------------------------------------------------------------------------- + +%% Help function waiting for the collector to respond that it is ready to receive +%% the next chunk. This is in order to exercise flow control protecting the +%% collector to get swamped if the node where the collector runs is busy. +fetch_wait_for_chunk_ack(CollectPid,MRef) -> + receive + {CollectPid,chunk_ack} -> + ok; + {CollectPid,cancel_transmission} -> % Some problem at collector side. + cancel; + {'DOWN',MRef,process,_,_} -> % The collector terminated. + 'DOWN' + end. +%% ----------------------------------------------------------------------------- + + +%% ============================================================================= +%% First level do-functions, called from the main server loop on incomming +%% requests. +%% ============================================================================= + +%% Function performing the overload check. Returns {NewLoopData,TimeOut}. +%% Note that this function may also cause a suspend to be carried out if the +%% loadcheck turns out negative. +do_check_overload(LD,Data) -> + case do_check_overload_2(LD#rt.overload,Data) of + ignore -> % Load check not performed. + {LD,calc_diff_to_now(now(),LD#rt.next_loadcheck)}; + {ok,Interval} -> % No problem, continue. + NextLoadCheck=add_to_now(now(),Interval), + {LD#rt{next_loadcheck=NextLoadCheck},Interval}; + {suspend,Reason} -> % Emergency! suspend, suspend! + NewLD=do_suspend(LD,Reason), + {NewLD,infinity}; % No need to do load-checks now! + {new,NewData,Interval} -> % The overload was restarted or something. + NextLoadCheck=add_to_now(now(),Interval), + {LD#rt{overload_data=NewData,next_loadcheck=NextLoadCheck},Interval}; + error -> % Inhibit overload check then. + {LD#rt{overload=?NO_LOADCHECK},infinity} + end. + +%% Help function performing an overload check. Returns {ok,Interval}, +%% {suspend,Reason}, 'error' ir 'ignore'. +do_check_overload_2({{Mod,Func},Interval,_,_},Data) -> + do_check_overload_3(Interval,catch Mod:Func(Data)); +do_check_overload_2({Fun,Interval,_,_},Data) when is_function(Fun) -> + do_check_overload_3(Interval,catch Fun(Data)); +do_check_overload_2(_,_) -> % Bad loadcheck configuration. + error. % Stop using load checks then. + +do_check_overload_3(Interval,ok) -> + {ok,Interval}; +do_check_overload_3(Interval,{new,NewData}) -> + {new,NewData,Interval}; +do_check_overload_3(_Interval,{suspend,Reason}) -> + {suspend,Reason}; +do_check_overload_3(_Interval,ignore) -> % Loadcheck not triggered. + ignore; +do_check_overload_3(_Interval,_) -> % Failure or other return value. + error. % Stop doing loadchecks from now on. +%% ------------------------------------------------------------------------------ + +%% Function setting the trace-pattern according to Args and Flags. Note that +%% Args can contain regexps which must be expanded here. +%% Returns a list: [Result], where Result can be: int()|{error,Reason}. +%% Sometimes an error tuple will represent an entire pattern, sometimes the +%% pattern will expand to a number of error-tuples. +do_set_trace_patterns(Args,Flags) -> + Replies=do_set_trace_patterns_2(Args,Flags,[]), + lists:reverse(Replies). + +do_set_trace_patterns_2([{M,F,Arity,MS}|Rest],Flags,Replies) -> % Option-less. + do_set_trace_patterns_2([{M,F,Arity,MS,[]}|Rest],Flags,Replies); +do_set_trace_patterns_2([{M,F,Arity,MS,Opts}|Rest],Flags,Replies) when is_atom(M) -> + case load_module_on_option(M,Opts) of + true -> % Already present, loaded or no option! + case catch erlang:trace_pattern({M,F,Arity},MS,Flags) of + No when is_integer(No) -> + do_set_trace_patterns_2(Rest,Flags,[No|Replies]); + {'EXIT',Reason} -> + do_set_trace_patterns_2(Rest, + Flags, + [{error,{bad_trace_args,[{M,F,Arity,MS},Reason]}}| + Replies]) + end; + false -> % Module not present, or not found! + do_set_trace_patterns_2(Rest,Flags,[0|Replies]) + end; +do_set_trace_patterns_2([{M,F,Arity,MS,Opts}|Rest],Flags,Replies) when is_list(M) -> + case check_pattern_parameters(void,F,Arity,MS) of % We don't want to repeat bad params. + ok -> + case inviso_rt_lib:expand_regexp(M,Opts) of % Get a list of real modulnames. + Mods when is_list(Mods) -> + MoreReplies= + do_set_trace_patterns_2(lists:map(fun(Mod)-> + {Mod,F,Arity,MS,Opts} + end, + Mods), + Flags, + Replies), + do_set_trace_patterns_2(Rest,Flags,MoreReplies); + {error,Reason} -> + do_set_trace_patterns_2(Rest,Flags,[{error,Reason}|Replies]) + end; + error -> % Bad pattern parameters. + do_set_trace_patterns_2(Rest, + Flags, + [{error,{bad_trace_args,{M,F,Arity,MS}}}|Replies]) + end; +do_set_trace_patterns_2([{{Dir,M},F,Arity,MS,Opts}|Rest],Flags,Replies) + when is_list(Dir),is_list(M) -> + case check_pattern_parameters(void,F,Arity,MS) of % We don't want to repeat bad params. + ok -> + case inviso_rt_lib:expand_regexp(Dir,M,Opts) of % Get a list of real modulnames. + Mods when is_list(Mods) -> + MoreReplies= + do_set_trace_patterns_2(lists:map(fun(Mod)-> + {Mod,F,Arity,MS,Opts} + end, + Mods), + Flags, + Replies), + do_set_trace_patterns_2(Rest,Flags,MoreReplies); + {error,Reason} -> + do_set_trace_patterns_2(Rest,Flags,[{error,Reason}|Replies]) + end; + error -> % Bad pattern parameters. + do_set_trace_patterns_2(Rest, + Flags, + [{error,{bad_trace_args,{M,F,Arity,MS}}}|Replies]) + end; +do_set_trace_patterns_2([Arg|Rest],Flags,Replies) -> + do_set_trace_patterns_2(Rest,Flags,[{error,{bad_trace_args,Arg}}|Replies]); +do_set_trace_patterns_2([],_Flags,Replies) -> + Replies. +%% ----------------------------------------------------------------------------- + +%% Help function which sets the trace flags for all processes specifed in Args. +%% Args shall be a list of {ProcessSpecification,ProcessTraceFlags}. +%% Returns {ok,Answers} where Answers is a list of integer and error descriptions. +%% Note that a process specification may be a particular pid or a {global,Name}. +%% In the case the process does not exist we will fake a zero instead of an +%% error. +do_set_trace_flags(Tracer,Args,How) -> + Fun=fun({Proc,Flags}) -> + case check_traceflag_pidspec(Proc) of + {ok,Proc2} -> % Reg-names converted. + case check_flags(Flags) of + Flags2 when is_list(Flags2) -> % No error! + case (catch + case How of + true -> + erlang:trace(Proc2, + true, + [{tracer,Tracer}|Flags2]); + false -> % No tracer of turning off. + erlang:trace(Proc2, + false, + Flags2) + end) of + N when is_integer(N) -> + N; + {'EXIT',Reason} -> + if + is_pid(Proc2) -> + 0; % Proc2 not alive or not at this node! + true -> % Otherwise, just error! + {error, + {bad_trace_args, + [Reason,Proc2,How,Flags2,Tracer]}} + end + end; + FlagError -> + FlagError + end; + false -> % Skip it. + 0; % Indicate that zero processes matched. + {error,Reason} -> % Bad process specification. + {error,{bad_process,[Reason,Proc]}} + end; + (Faulty) -> + {error,{bad_process,Faulty}} + end, + {ok,lists:map(Fun,Args)}. +%% ------------------------------------------------------------------------------ + +%% Function calling API:s in the trace information server. Note that we have +%% given the responsibility to form a correct functionsname and argument list +%% to the caller. +%% Returns whatever the called function returns. +do_meta_pattern(MPid,{FuncName,ArgList}) -> + case catch apply(inviso_rt_meta,FuncName,[MPid|ArgList]) of + {'EXIT',_Reason} -> + {error,{badarg,{FuncName,ArgList}}}; + Result -> + Result + end; +do_meta_pattern(_MPid,BadArgs) -> + {error,{bad_args,BadArgs}}. +%% ------------------------------------------------------------------------------ + +%% Function removing *all* patterns. Beaware that the one for local patterns +%% causes a walkthrough of all loaded modules. +do_clear_trace_patterns() -> + erlang:trace_pattern({'_','_','_'},false,[local]), %% inc. meta, call_count + erlang:trace_pattern({'_','_','_'},false,[global]). +%% ------------------------------------------------------------------------------ + +%% Function that takes TracerData and initializes the tracing. That can be +%% opening appropriate logfiles, starting meta-tracer. There must be one +%% clause here for every "type" of logging we want to be able to do. +%% Returns the Reply to be forwarded to the caller. +do_init_tracing(LoopData,TD,{HandlerFun,Data},TiTD) when is_function(HandlerFun) -> + {NewLoopData,Reply}= + case do_init_metatracing(TiTD,self()) of + {ok,MetaPid} -> + {LoopData#rt{handler={HandlerFun,Data}, + tracerdata=TD, + meta_tracer=MetaPid, + state=tracing}, + {ok,[{trace_log,ok},{ti_log,ok}]}}; + false -> % No meta tracing requested. + {LoopData#rt{handler={HandlerFun,Data}, + tracerdata=TD, + state=tracing}, + {ok,[{trace_log,ok}]}}; + {error,Reason} -> % Problems starting meta tracing. + {LoopData#rt{handler={HandlerFun,Data}, + tracerdata=TD, + state=tracing}, + {ok,[{trace_log,ok},{ti_log,{error,Reason}}]}} + end, + send_event(state_change,NewLoopData), % Send to subscribing processes. + {NewLoopData,Reply}; +do_init_tracing(LoopData,TD,{Type,Parameters},TiTD) when Type==ip;Type==file -> + case check_traceport_parameters(Type,Parameters) of + ok -> + case catch trace_port(Type,Parameters) of + Fun when is_function(Fun) -> + case catch Fun() of + Port when is_port(Port) -> % Ok, our trace-port is open. + {NewLoopData,Reply}= + case do_init_metatracing(TiTD,Port) of + {ok,MetaPid} -> + {LoopData#rt{tracer_port=Port, + tracerdata=TD, + meta_tracer=MetaPid, + state=tracing}, + {ok,[{trace_log,ok},{ti_log,ok}]}}; + false -> % No meta tracing requested. + {LoopData#rt{tracer_port=Port, + tracerdata=TD, + state=tracing}, + {ok,[{trace_log,ok}]}}; + {error,Reason} -> % Problems starting meta tracing. + {LoopData#rt{tracer_port=Port, + tracerdata=TD, + state=tracing}, + {ok,[{trace_log,ok},{ti_log,{error,Reason}}]}} + end, + send_event(state_change,NewLoopData), + {NewLoopData,Reply}; + {'EXIT',Reason} -> + {LoopData,{error,{bad_port_fun,[Parameters,Reason]}}} + end; + {'EXIT',Reason} -> + {LoopData,{error,{bad_port_args,[Parameters,Reason]}}} + end; + {error,Reason} -> % Bad traceport parameters. + {LoopData,{error,Reason}} + end. + +%% Help function that starts the meta-tracing. Note that the runtime component +%% will becom linked to it. +%% Currently the meta tracer handles two types, 'file' and 'relay'. +%% Note that Tracer tells the meta tracer where regular trace messages shall be +%% sent. This is because the meta tracer is capable of appending a {tracer,Tracer} +%% action term to meta match specs. +do_init_metatracing(LogSpec={_Type,_Arg},Tracer) -> + case inviso_rt_meta:start(LogSpec,Tracer) of + {ok,MetaPid} -> + {ok,MetaPid}; + {error,Reason} -> + {error,Reason} + end; +do_init_metatracing({Type,Arg,{InitPublLDmfa,RemovePublLDmf,CleanPublLDmf}},Tracer)-> + case inviso_rt_meta:start({Type,Arg},Tracer,InitPublLDmfa,RemovePublLDmf,CleanPublLDmf) of + {ok,MetaPid} -> + {ok,MetaPid}; + {error,Reason} -> + {error,Reason} + end; +do_init_metatracing(void,_) -> % Means no meta tracer. + false. +%% ----------------------------------------------------------------------------- + +%% Function that stops all tracing and closes all open files. This function +%% can't fail :-) It tries as hard as it can. +%% This function also kills the autostarter process if one exists. Otherwise it +%% will not be possible from a control component to end an ongoing autostarted +%% tracing. +%% Returns a new loopdata structure since stopping tracing involves updating it. +do_stop_tracing(LoopData) -> + do_stop_tracing_kill_autostarter(LoopData#rt.auto_starter), + do_clear_trace_flags(), % Do not generate any more traces. + NewLoopData1=do_stop_tracing_tracelog(LoopData), + NewLoopData2=do_stop_tracing_metatracing(NewLoopData1), + NewLoopData3=NewLoopData2#rt{state=idle,auto_starter=undefined}, + send_event(state_change,NewLoopData3), + NewLoopData3. + +do_stop_tracing_tracelog(LoopData=#rt{tracer_port=Port}) when is_port(Port) -> + trace_port_control(Port,flush), % Write buffered trace messages. + catch port_close(Port), + LoopData#rt{tracer_port=undefined}; +do_stop_tracing_tracelog(LoopData) -> + LoopData#rt{handler=undefined}. + +do_stop_tracing_metatracing(LoopData=#rt{meta_tracer=MPid}) when is_pid(MPid) -> + inviso_rt_meta:stop(MPid), + LoopData#rt{meta_tracer=undefined}; +do_stop_tracing_metatracing(LoopData) -> % No meta tracer running! + LoopData. + +%% Help function killing the autostarter, if one is active. +do_stop_tracing_kill_autostarter(P) when is_pid(P) -> + exit(P,stop_tracing); +do_stop_tracing_kill_autostarter(_) -> % No autostarter, do nothing. + true. +%% ----------------------------------------------------------------------------- + +%% Help function implementing suspending the runtime component. +%% Returns a new loopdata structure. +do_suspend(LD,Reason) -> + do_clear_trace_flags(), % If no process flags, no output! + do_suspend_metatracer(LD#rt.meta_tracer), + do_suspend_fetchers(LD#rt.fetchers), + do_stop_tracing_kill_autostarter(LD#rt.auto_starter), + NewLD=LD#rt{fetchers=[],status={suspended,Reason},auto_starter=undefined}, + send_event(state_change,NewLD), % Notify subscribers. + NewLD. + +do_suspend_metatracer(MetaTracer) when is_pid(MetaTracer) -> + inviso_rt_meta:suspend(MetaTracer); % This makes it suspended. +do_suspend_metatracer(_) -> + true. + +do_suspend_fetchers([FetcherPid|Rest]) -> + FetcherPid ! {suspend,self()}, % This makes it terminate. + do_suspend_fetchers(Rest); +do_suspend_fetchers([]) -> + true. +%% ------------------------------------------------------------------------------ + +%% Function that stops all tracing, removes all trace-patterns and removes all +%% logfiles. The idea is to return the runtime component to the 'new' state. +do_clear(LoopData,Opts) when is_list(Opts) -> + NewLoopData=do_stop_tracing(LoopData), % First stop tracing, if tracing. + case lists:member(keep_trace_patterns,Opts) of + false -> + do_clear_trace_patterns(); + _ -> + true + end, + case lists:member(keep_log_files,Opts) of + false -> + if + NewLoopData#rt.tracerdata/=undefined -> + do_delete_logs(NewLoopData#rt.tracerdata); + true -> % If no tracerdata, nothing to remove! + true % Do nothing then. + end; + _ -> + true + end, + NewLoopData#rt{state=new,tracerdata=undefined}; +do_clear(LoopData,_Opts) -> % Faulty Opts. + do_clear(LoopData,[]). % Then just ignore the options. +%% ----------------------------------------------------------------------------- + +%% Function which takes a tracerdata, either our own or a "suggested" +%% and tries to find the corresponding files. Note that the return value only +%% contains "types" of logs that the tracerdata is pointing out. Hence +%% is there no ti-log, no one will be mentioned in the return value. +do_list_logs(TracerData) -> % Handles both list and tuple. + case translate_td(TracerData) of + {ok,LogTD,TiTD} -> + {TraceDir,TraceLogs}=list_logs_tracelog(LogTD), + {TiDir,TiLogs}=list_logs_tilog(TiTD), + case {TraceLogs,TiLogs} of + {no_log,no_log} -> % Tracerdata not generating logs! + {ok,no_log}; + {_,no_log} -> % No ti logs. + {ok,[{trace_log,TraceDir,TraceLogs}]}; + {no_log,_} -> % Only ti-logs, unusual! + {ok,[{ti_log,TiDir,TiLogs}]}; + _ -> % Both trace and ti logs. + {ok,[{trace_log,TraceDir,TraceLogs},{ti_log,TiDir,TiLogs}]} + end; + {error,Reason} -> + {error,Reason} + end. +%% ----------------------------------------------------------------------------- + +%% Help function implementing fetching logfiles using distributed Erlang. +%% This function works for both situations, a list of specific files are +%% requested, or a tracerdata is specified. +%% Returns {Reply,NewLoopData}. +do_fetch_log(LD,CollectPid,What) -> + if + LD#rt.state/=tracing -> + case is_list_of_files_or_tracerdata(What) of + files -> + FetcherPid=do_fetch_log_listoffiles(CollectPid,What), + {{ok,FetcherPid},add_fetcher_ld(FetcherPid,LD)}; + tracerdata -> + case do_fetch_log_tracerdata(CollectPid,What) of + {Reply,FetcherPid} when is_pid(FetcherPid) -> + {Reply,add_fetcher_ld(FetcherPid,LD)}; + {Reply,_} -> % No fetch process was started. + {Reply,LD} + end; + false -> % It is an empty list! + {{complete,no_log},LD}; + error -> % Incorrect parameter. + {{error,badarg},LD} + end; + true -> % No transfere during tracing. + {{error,tracing},LD} + end. + +%% Function taking tracerdata to find out what files to send over to the RemotePid. +%% Note that we will not go back to the loop function from here but rather call +%% the fetch_loop instead, prepresenting the fetch-log state. Unless we encounter +%% a problem. +do_fetch_log_tracerdata(CollectPid,TracerData) -> + case do_list_logs(TracerData) of + {ok,no_log} -> + {{complete,no_log},void}; + {ok,Logs} -> % Ok, some trace_log and ti_log. + FetcherPid=do_fetch_log_listoffiles(CollectPid,Logs), + {{ok,FetcherPid},FetcherPid}; + {error,Reason} -> % Problem with tracerdata! + {{error,Reason},void} + end. + +do_fetch_log_listoffiles(CollectPid,FileSpec) -> + ExpandedFileSpec=do_fetch_log_expand_filespec(FileSpec), +%% !!! try out different ChunkSizes +% ChunkSize = 60, +% ChunkSize = 7*1024, + ChunkSize=1024, + _Fetcher=spawn_link(?MODULE, + fetch_init, + [self(),ExpandedFileSpec,CollectPid,ChunkSize]). + +%% Help function which expands the list of logs to have tags in front of every +%% file, as required by the fetch_loop. +do_fetch_log_expand_filespec(Logs) -> + TraceLogs= + case lists:keysearch(trace_log,1,Logs) of + {value,{_,Dir1,Logs1}} -> % There is a list of trace-logs. + lists:map(fun(File)->{trace_log,Dir1,File} end,Logs1); + false -> % No trace-logs! + [] + end, + TiLogs= + case lists:keysearch(ti_log,1,Logs) of + {value,{_,Dir2,Logs2}} -> + lists:map(fun(File)->{ti_log,Dir2,File} end,Logs2); + false -> + [] + end, + TiLogs++TraceLogs. + +%% ------------------------------------------------------------------------------ + +%% Function that removes all logfiles associated with a certain tracerdata. +do_delete_logs(TracerDataOrLogList) -> + case is_list_of_files_or_tracerdata(TracerDataOrLogList) of + tracerdata -> + case translate_td(TracerDataOrLogList) of + {ok,LogTD,TiTD} -> + case {list_logs_tracelog(LogTD),list_logs_tilog(TiTD)} of + {{_,no_log},{_,no_log}} -> % No logs nowhere! + {ok,no_log}; + {{LogDir,LogFiles},{_,no_log}} -> % No ti. + {ok,[{trace_log,delete_files(LogDir,LogFiles)}]}; + {{_,no_log},{TiDir,TiFiles}} -> + {ok,[{ti_log,delete_files(TiDir,TiFiles)}]}; + {{LogDir,LogFiles},{TiDir,TiFiles}} -> + {ok,[{trace_log,delete_files(LogDir,LogFiles)}, + {ti_log,delete_files(TiDir,TiFiles)}]} + end; + {error,Reason} -> + {error,Reason} + end; + files -> % It is [{trace_log,Dir,Files},.. + if + is_list(hd(TracerDataOrLogList)) -> % Just a list of files. + {ok,delete_files(".",TracerDataOrLogList)}; + is_tuple(hd(TracerDataOrLogList)) -> % A "modern" logspec. + case {lists:keysearch(trace_log,1,TracerDataOrLogList), + lists:keysearch(ti_log,1,TracerDataOrLogList)} of + {false,false} -> % Hmm, no logs specified! + {ok,[]}; % Easy response! + {{value,{_,LogDir,LogFiles}},false} -> + {ok,[{trace_log,delete_files(LogDir,LogFiles)}]}; + {false,{value,{_,TiDir,TiFiles}}} -> + {ok,[{ti_log,delete_files(TiDir,TiFiles)}]}; + {{value,{_,LogDir,LogFiles}},{value,{_,TiDir,TiFiles}}} -> + {ok,[{trace_log,delete_files(LogDir,LogFiles)}, + {ti_log,delete_files(TiDir,TiFiles)}]} + end + end; + false -> % Can't tell which! + {ok,[]}; + error -> + {error,{badarg,TracerDataOrLogList}} + end. +%% ----------------------------------------------------------------------------- + +%% Function handling the request when a control component wishing to take +%% control over this already existing control component. It does not matter +%% what state it is in. It can very well already be tracing. +%% Returns {Reply,NewLoopData}. +%% Where the Reply tells the control component wether it took control of it +%% or not. {node_info,node(),self(),Vsn,State,Status,{tag,Tag}} means that we +%% can be adopted (and more precisely considers ourselves being adopted now). +do_try_to_adopt(Tag,if_ref,LoopData=#rt{tag=Tag},_Ctrl) -> + {{error,{wrong_reference,LoopData#rt.tag}},LoopData}; +do_try_to_adopt(NewTag,_Condition,LoopData,CtrlPid) -> + case LoopData#rt.timer_ref of % Do we have a running-alone timer? + undefined -> % No we don't. + true; + TimerRef -> + timer:cancel(TimerRef) + end, + CtrlRef=erlang:monitor(process,CtrlPid), % Lets monitor our new "master"! + {DepVal,_}=LoopData#rt.dependency, + {node_info,Node,Pid,VSN,State,Status,Tag}=collect_node_info(LoopData), + NewLoopData= + LoopData#rt{dependency={DepVal,node(CtrlPid)}, + ctrl=CtrlPid, + ctrl_ref=CtrlRef, % Monitoring our new master. + tag=NewTag, % Use this tag from now on. + timer_ref=undefined}, + {{node_info,Node,Pid,VSN,State,Status,{tag,Tag}},NewLoopData}. +%% ----------------------------------------------------------------------------- + +%% Function changing parameters accoring to a new options list. Note that we +%% can not change control component if the one we have is still working. +%% We can however of course change how this runtime component will react to +%% a running alone scenario. +%% Returns 'stop' or NewLoopData. +do_change_options(Options,LoopData) -> + NewLoopData=read_option_list(Options,LoopData), + if + NewLoopData/=LoopData -> % Some options changed. + case do_change_options_ctrl(LoopData,NewLoopData) of + stop -> + stop; + {ok,NewLoopData2} -> + NewLoopData3=do_change_options_overload(LoopData,NewLoopData2), + NewLoopData3#rt{next_loadcheck=now()} % Force a load check next. + end; + true -> + LoopData + end. + +%% Help function which sets up the new dependencies. Note that we only do that +%% if do not have a working control component. +%% Returns {ok,NewLoopData} or 'stop'. +do_change_options_ctrl(OldLD,NewLD) -> + if + OldLD#rt.timer_ref/=undefined -> % No control and waiting to terminate. + timer:cancel(OldLD#rt.timer_ref), + do_down_message(NewLD#rt{timer_ref=undefined}); + OldLD#rt.ctrl==undefiend -> % No control component. + do_down_message(NewLD); + true -> % We have a working control component! + {ok,NewLD} + end. + +do_change_options_overload(OldLD,NewLD) -> + if + OldLD#rt.overload/=NewLD#rt.overload -> + terminate_overload(OldLD), + NewOverloadData=initialize_overload(NewLD), + NewLD#rt{overload_data=NewOverloadData}; + true -> % No changes done. + NewLD + end. +%% ----------------------------------------------------------------------------- + +%% Help function handling an incoming DOWN message from our control component. +%% If the runtime component is not allowed to run without a control component, it +%% simply terminates which closes the trace-port and process trace flags are +%% therefore automatically removed. +%% Returns 'stop' or a {ok,NewLoopData} structure. +do_down_message(LoopData) -> + case LoopData#rt.dependency of + {0,_} -> % Not allowed to run without controller. + stop; + {infinity,_} -> % Don't care. Just remove the controller. + {ok,LoopData#rt{ctrl=undefined,ctrl_ref=undefined}}; + {TimeOut,_} -> % Allowed to run TimeOut ms alone. + {ok,TimerRef}=timer:exit_after(TimeOut,self(),running_alone), + {ok,LoopData#rt{timer_ref=TimerRef,ctrl=undefined,ctrl_ref=undefined}} + end. +%% ----------------------------------------------------------------------------- + +%% Function handling incomming exit signals. We can expect exit signals from the +%% following: Our parent supervisor (runtime_tools_sup), a meta-tracer process, +%% a logfile fetcher process, or the auto_starter. +%% A trace-port may also generate an exit signal. +%% In addition it is possible that an overload mechanism generates exit-signals. +%% We can also get the running_alone exit signal from our self. This is the +%% situation if our control component has terminated and this runtime component +%% is not allowed to exist on its own for ever. +%% Also note that after we have stopped tracing, for any reason, it is not +%% impossible that we receive the EXIT signals from still working parts that +%% we are now shuting down. This is no problem, the code will mearly update +%% the loopdata structure once again. +%% Returns 'exit' indicating that the runtime component shall terminate now, +%% {NewLoopData,NewTimeOut} if the exit-signal resulted in an overload check, or +%% a new loopdata structure shall we ignore the exit, or it simply resulted in +%% a state-change. +act_on_exit(Parent,_Reason,#rt{parent=Parent}) -> + exit; +act_on_exit(_Pid,running_alone,_LoopData) -> + exit; +act_on_exit(MetaTracer,_Reason,LoopData=#rt{meta_tracer=MetaTracer}) -> + LoopData#rt{meta_tracer=undefined}; % It does not exit anylonger. +act_on_exit(Port,Reason,LoopData=#rt{tracer_port=Port}) -> + send_event({port_down,node(),Reason},LoopData), + _NewLoopData=do_stop_tracing(LoopData); +act_on_exit(AutoStarter,_Reason,LoopData=#rt{auto_starter=AutoStarter}) -> + LoopData#rt{auto_starter=undefined}; % The autostarter has terminated. +act_on_exit(Pid,Reason,LoopData) -> + case remove_fetcher_ld(Pid,LoopData) of + {true,NewLoopData} -> % Yes it really was a fetcher. + NewLoopData; + false -> % No it was not a fetcher. + act_on_exit_overload(Pid,Reason,LoopData) + end. + +%% Help function checking if this exit has anything to do with an overload +%% mechanism. Note that here we run the overload mechanism regardless of +%% if we are tracing or not. This because an exit signal from the overload +%% must most likely always be handled. +act_on_exit_overload(Pid,Reason,LoopData) -> + if + LoopData#rt.overload/=?NO_LOADCHECK -> + {_NewLD,_NewTimeOut}= + do_check_overload(LoopData, + {'EXIT',{Pid,Reason,LoopData#rt.overload_data}}); + true -> % Overload not in use. + LoopData + end. +%% ----------------------------------------------------------------------------- + + + + + + + + + + + + + + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + +%% ============================================================================== +%% Various help functions. +%% ============================================================================== + +%% Help function which calculates a new now-tuple by adding Interval milliseconds +%% to the first argument. Note that Interval may be 'infinity' too. +%% Returns a new now-tuple or "bigvalue" which is greater than any now-tuple. +add_to_now({MegSec,Sec,MicroSec},Interval) when is_integer(Interval) -> + NewSec=Sec+(Interval div 1000), + if + NewSec>=1000000 -> + {MegSec+1,NewSec-1000000,MicroSec}; + true -> + {MegSec,NewSec,MicroSec} + end; +add_to_now(_,infinity) -> + "bigvalue". +%% ------------------------------------------------------------------------------ + +%% Help function calculating the difference in milliseconds between its first +%% and second argument. This is useful when calculating an after timeout value +%% from current now() and next_loadcheck value. +calc_diff_to_now(T1={_,_,_},T2={_,_,_}) -> + TimeOut1=timer:now_diff(T2,T1), % The difference in microseconds. + if + TimeOut1<0 -> + 0; + true -> % Make milliseconds out of it. + TimeOut1 div 1000 + end; +calc_diff_to_now(_T1,_) -> % Next loadcheck is not activated. + infinity. % The the after timeout is infinity. +%% ------------------------------------------------------------------------------ + + +%% Help function returning information about this runtime component. +collect_node_info(#rt{vsn=VSN,state=State,status=Status,tag=Tag}) -> + {node_info,node(),self(),VSN,State,Status,Tag}. +%% ------------------------------------------------------------------------------ + +%% Help function sending information to the control component that state/status +%% change has occurred. Returns nothing significant. +send_event(state_change,LoopData=#rt{ctrl=CtrlPid}) when is_pid(CtrlPid) -> + Event={trace_event,{state_change,node(),{LoopData#rt.state,LoopData#rt.status}}}, + CtrlPid ! Event; +send_event(Event,#rt{ctrl=CtrlPid}) when is_pid(CtrlPid) -> + CtrlPid ! {event,Event}; +send_event(_,_) -> % We have no control to send to! + true. % Maybe tracing alone after autostart. +%% ------------------------------------------------------------------------------ + +%% Help function initializing the overload protection mechanism. This may be +%% necessary if it is a port program or similar. Returns {ok,Data} or 'void'. +%% The datastructure vill be given to LoadMF as argument whenever loadchecks +%% are done. +initialize_overload(#rt{overload={_MF,_Interval,{M,F,Args},_RemoveMFA}}) -> + case catch apply(M,F,Args) of + {ok,Data} -> + Data; + _ -> % 'EXIT' or other faulty returnvalue. + void + end; +initialize_overload(_) -> + void. +%% ------------------------------------------------------------------------------ + +%% Help function which terminates an overload protection mechanism. +%% Returns nothing significant. +terminate_overload(#rt{overload={_MF,_Interval,_InitMFA,{M,F,Args}}, + overload_data=Data}) -> + catch apply(M,F,[Data|Args]), % Interested in the side-effect. + true; +terminate_overload(_) -> + true. +%% ------------------------------------------------------------------------------ + + +%% Help function which checks that a process specified for trace flags is correct. +%% Either the built-in "aliases" for groups of processes, a pid, a locally registered +%% name. This function also works for globally registered names. It must then +%% first be established that the process is local for this node before setting any +%% process flags. +%% Returns {ok,PidSpec}, 'false' or {error,Reason}. +check_traceflag_pidspec(all) -> {ok,all}; +check_traceflag_pidspec(new) -> {ok,new}; +check_traceflag_pidspec(existing) -> {ok,existing}; +check_traceflag_pidspec(Name) when is_atom(Name) -> + check_traceflag_pidspec({local,Name}); +check_traceflag_pidspec({local,A}) when is_atom(A) -> + case whereis(A) of + undefined -> % Then it is considered faulty. + {error,{nonexistent_name,A}}; + Pid when is_pid(Pid) -> + {ok,Pid} + end; +check_traceflag_pidspec({global,Name}) when is_atom(Name) -> + case global:whereis_name(Name) of + undefined -> % Then the name does not exist at all. + {error,{nonexistent_name,{global,Name}}}; + Pid when is_pid(Pid) -> % Ok, but must check that it is here. + if + node()==node(Pid) -> + {ok,Pid}; + true -> % Pid is not at this node. + false % Not an error but cant be used. + end + end; +check_traceflag_pidspec(Pid) when is_pid(Pid) -> + {ok,Pid}; +check_traceflag_pidspec(Proc) -> + {error,{faulty,Proc}}. +%% ------------------------------------------------------------------------------ + +%% Help function removing all trace flags from all processes. Useful in connection +%% with suspend. Returns nothing significant. +do_clear_trace_flags() -> + erlang:trace(all, false, [all]). +%% ------------------------------------------------------------------------------ + +%% Help function which checks that only valid process trace flags are mentioned. +%% In order to create better fault reports. +%% Returns a list of the approved flags, or {error,Reason}. +check_flags(Flags) -> + check_flags_2(Flags,Flags). + +check_flags_2([send|Rest],Flags) -> check_flags_2(Rest,Flags); +check_flags_2(['receive'|Rest],Flags) -> check_flags_2(Rest,Flags); +check_flags_2([call|Rest],Flags) -> check_flags_2(Rest,Flags); +check_flags_2([return_to|Rest],Flags) -> check_flags_2(Rest,Flags); +check_flags_2([procs|Rest],Flags) -> check_flags_2(Rest,Flags); +check_flags_2([garbage_collection|Rest],Flags) -> check_flags_2(Rest,Flags); +check_flags_2([running|Rest],Flags) -> check_flags_2(Rest,Flags); +check_flags_2([set_on_spawn|Rest],Flags) -> check_flags_2(Rest,Flags); +check_flags_2([set_on_first_spawn|Rest],Flags) -> check_flags_2(Rest,Flags); +check_flags_2([set_on_link|Rest],Flags) -> check_flags_2(Rest,Flags); +check_flags_2([timestamp|Rest],Flags) -> check_flags_2(Rest,Flags); +check_flags_2([arity|Rest],Flags) -> check_flags_2(Rest,Flags); +check_flags_2([silent|Rest],Flags) -> check_flags_2(Rest,Flags); +check_flags_2([],Flags) -> Flags; +check_flags_2([Faulty|_],_Flags) -> {error,{bad_flag,Faulty}}. +%% ------------------------------------------------------------------------------ + +%% Help function which checks parameters to erlang:trace_pattern. The purpose of +%% the function is to avoid to get multiple error return values in the return +%% list for a pattern used together with a regexp expanded module name. +check_pattern_parameters(Mod,Func,Arity,MS) -> + if + (Mod=='_') and (Func=='_') and (Arity=='_') and + (is_list(MS) or (MS==true) or (MS==false)) -> + ok; + (is_atom(Mod) and (Mod/='_')) and (Func=='_') and (Arity=='_') and + (is_list(MS) or (MS==true) or (MS==false)) -> + ok; + (is_atom(Mod) and (Mod/='_')) and + (is_atom(Func) and (Func/='_')) and + ((Arity=='_') or is_integer(Arity)) and + (is_list(MS) or (MS==true) or (MS==false)) -> + ok; + true -> + error + end. +%% ----------------------------------------------------------------------------- + +%% Help function finding out if Mod is loaded, and if not, if it can successfully +%% be loaded. The Opts list can prevent modules from being loaded. +%% Returns 'true' or 'false'. +load_module_on_option(Mod,Opts) when is_list(Opts) -> + case lists:member(no_loadcheck,Opts) of + true -> % Then just skip this, return true. + true; + false -> + case erlang:module_loaded(Mod) of + true -> + true; % It is loaded, do no more. + false -> + case lists:member(only_loaded,Opts) of + true -> % Then, make no attempts to load. + false; + false -> % Try to load! + case code:ensure_loaded(Mod) of + {module,_Mod} -> % Successfully loaded! + true; + {error,_Reason} -> + false + end + end + end + end; +load_module_on_option(Mod,_Opts) -> % Most likely Opts not a list! + load_module_on_option(Mod,[]). % Call without options. +%% ----------------------------------------------------------------------------- + +%% Help function taking a tuplelist of options turning them into a loopdata +%% structure. Returns the loopdata structure with the new values changed. +read_option_list([],LD) -> % Done, return loopdata. + LD; +read_option_list([{dependency,{Value,Node}}|Rest],LD) -> + read_option_list(Rest,LD#rt{dependency={Value,Node}}); +read_option_list([{dependency,Value}|Rest],LD) when is_integer(Value);Value==infinity -> + read_option_list(Rest,LD#rt{dependency={Value,node()}}); +read_option_list([overload|Rest],LD) -> % So that we can remove loadcheck. + read_option_list(Rest,LD#rt{overload=?NO_LOADCHECK}); +read_option_list([{overload,{MF,Interval}}|Rest],LD) + when is_integer(Interval);Interval==infinity -> + read_option_list(Rest,LD#rt{overload={MF,Interval,void,void}}); +read_option_list([{overload,{MF,Interval,InitMFA,RemoveMFA}}|Rest],LD) + when is_integer(Interval);Interval==infinity -> + read_option_list(Rest,LD#rt{overload={MF,Interval,InitMFA,RemoveMFA}}); +read_option_list([{overload,Interval}|Rest],LD) + when is_integer(Interval);Interval==infinity -> + read_option_list(Rest,LD#rt{overload={fun ?DEFAULT_OVERLOAD_FUNC/1, + Interval, + void, + void}}); +read_option_list([_|Rest],LD) -> % Unknown option. + read_option_list(Rest,LD). +%% ----------------------------------------------------------------------------- + +%% Help function which returns the version number for the runtime_tools +%% application. Since it is called from within the runtime_tools application +%% we can be "sure" that it really exists. +get_application_vsn() -> + {value,{_,_,VSN}}=lists:keysearch(runtime_tools,1,application:loaded_applications()), + VSN. +%% ----------------------------------------------------------------------------- + +%% Help function that examines an argument to determine if it is a list of files +%% or tracerdata. This since they are both complex structures, looking alike. +%% Returns 'tracerdata', 'files', 'false' or 'error'. Error is returned if it +%% can not be decided which it is. +is_list_of_files_or_tracerdata(What) -> + case inviso_rt_lib:is_tracerdata(What) of + true -> + tracerdata; + false -> + if + What==[] -> + false; + is_list(What),is_list(hd(What)) -> + files; + is_list(What) -> + case lists:keysearch(trace_log,1,What) of + {value,_} -> + files; + false -> + case lists:keysearch(ti_log,1,What) of + {value,_} -> + files; + false -> + error % Neither tracerdata nor list of files. + end + end; + true -> + error + end + end. +%% ------------------------------------------------------------------------------ + +%% Help function which removes all files in the ListOfFiles, assuming they +%% are located in Dir. +%% Returns a list of [{ok,FileName},...{error,Reason},...] +delete_files(Dir,ListOfFiles) -> + delete_files_2(Dir,ListOfFiles, []). + +delete_files_2(Dir,[File|Tail],Reply) when is_list(Dir),is_list(File) -> + case catch file:delete(filename:join(Dir,File)) of + ok -> + delete_files_2(Dir,Tail,[{ok,File}|Reply]); + {error,Posix} -> + delete_files_2(Dir,Tail,[{error,{Posix,File}}|Reply]); + {'EXIT',_Reason} -> % Probably not proper string. + delete_files_2(Dir,Tail,[{error,{badarg,[Dir,File]}}|Reply]) + end; +delete_files_2(Dir,[Faulty|Tail],Reply) -> + delete_files_2(Dir,Tail,[{error,{badarg,[Dir,Faulty]}}|Reply]); +delete_files_2(_,[],Reply) -> + Reply. +%% ----------------------------------------------------------------------------- + +%% Help function which lists all trace logs belonging to this tracerdata. +%% Note that this function operates on internal LogTD structures. +list_logs_tracelog({file,FileName}) when is_list(FileName) -> + case file:read_file_info(FileName) of + {ok,_} -> % The file exists. + {filename:dirname(FileName),[filename:basename(FileName)]}; + _ -> % The file does not exist + {filename:dirname(FileName),[]} + end; +list_logs_tracelog({file,Wrap}) when is_tuple(Wrap),element(2,Wrap)==wrap -> + case {element(1,Wrap),element(3,Wrap)} of + {FileName,Tail} when is_list(FileName),is_list(Tail) -> + case catch {filename:dirname(FileName),list_wrapset(FileName,Tail)} of + {'EXIT',_Reason} -> % Garbage in either lists. + {"",no_log}; % Interpret as no log for tracerdata. + Tuple -> + Tuple + end; + _ -> + {"",no_log} + end; +list_logs_tracelog(void) -> % Trace log not used. + {"",no_log}; +list_logs_tracelog(_) -> % Some fun or similar. + {"",no_log}. % Then there are no files to report. +%% ----------------------------------------------------------------------------- + +%% Help function which lists all ti-files belonging to this tracerdata. +%% Note that this function operates on the internal TiTD structure. +list_logs_tilog(TiTD) + when tuple_size(TiTD)>=2,element(1,TiTD)==file,is_list(element(2,TiTD)) -> + FileName=element(2,TiTD), + case file:read_file_info(FileName) of + {ok,_} -> % Yes the file exists. + {filename:dirname(FileName),[filename:basename(FileName)]}; + _ -> + {filename:dirname(FileName),[]} + end; +list_logs_tilog(void) -> % Internal representation for + {"",no_log}; % ti-file not in use. +list_logs_tilog(_) -> + {"",no_log}. +%% ----------------------------------------------------------------------------- + +%% Help function which lists all files belonging to the wrap-set specified by +%% Prefix and Suffix. Note that there can be a directory in Prefix as well. +%% Will fail if either of Prefix or Suffix are not proper strings. +%% Returns a list of files, without dirname. +list_wrapset(Prefix,Suffix) -> + Name=filename:basename(Prefix), + Dirname=filename:dirname(Prefix), + case file:list_dir(Dirname) of + {ok,Files} -> + RegExp="^"++list_wrapset_escapes(Name)++"[0-9]+"++ + list_wrapset_escapes(Suffix)++"$", + list_wrapset_2(Files,RegExp); + {error,_Reason} -> % Translate this to no files! + [] + end. + +list_wrapset_2([File|Rest],RegExp) -> + Length=length(File), + case regexp:first_match(File,RegExp) of + {match,1,Length} -> % This is a member of the set. + [File|list_wrapset_2(Rest,RegExp)]; + _ -> + list_wrapset_2(Rest,RegExp) + end; +list_wrapset_2([],_) -> + []. + +%% Help function which inserts escape characters infront of characters which +%% will otherwise be missinterpreted by the regexp function as meta rather than +%% just the character itself. +list_wrapset_escapes([$.|Rest]) -> + [$\\,$.|list_wrapset_escapes(Rest)]; +list_wrapset_escapes([Char|Rest]) -> + [Char|list_wrapset_escapes(Rest)]; +list_wrapset_escapes([]) -> + []. +%% ----------------------------------------------------------------------------- + + + + + + +%% ============================================================================== +%% Handler functions for implementing simple trace-message handlers. +%% ============================================================================== +%% +%% A handler must be a function taking two arguments. The first is the trace- +%% message. The second is datastructure used by the handler. The handler shall +%% returns (possibly) new datastructure. + +%% ------------------------------------------------------------------------------ +%% Function implementing a relayer. This function is used to creat a fun handler +%% if the relay option is used in tracer-data. +%% ------------------------------------------------------------------------------ +relay_handler(Msg,Tracer) -> + Tracer ! Msg, + Tracer. + +%% ------------------------------------------------------------------------------ +%% Function implementing a default terminal io handler. +%% ------------------------------------------------------------------------------ + +dhandler(end_of_trace, Out) -> + Out; +dhandler(Trace, Out) when element(1, Trace) == trace, + tuple_size(Trace) >= 3 -> + dhandler1(Trace, tuple_size(Trace), Out); +dhandler(Trace, Out) when element(1, Trace) == trace_ts, + tuple_size(Trace) >= 4 -> + dhandler1(Trace, tuple_size(Trace)-1, Out); +dhandler(Trace, Out) when element(1, Trace) == drop, + tuple_size(Trace) == 2 -> + io:format(Out, "*** Dropped ~p messages.~n", [element(2,Trace)]), + Out; +dhandler(Trace, Out) when element(1, Trace) == seq_trace, + tuple_size(Trace) >= 3 -> + SeqTraceInfo = case Trace of + {seq_trace, Lbl, STI, TS} -> + io:format(Out, "SeqTrace ~p [~p]: ", + [TS, Lbl]), + STI; + {seq_trace, Lbl, STI} -> + io:format(Out, "SeqTrace [~p]: ", + [Lbl]), + STI + end, + case SeqTraceInfo of + {send, Ser, Fr, To, Mes} -> + io:format(Out, "(~p) ~p ! ~p [Serial: ~p]~n", + [Fr, To, Mes, Ser]); + {'receive', Ser, Fr, To, Mes} -> + io:format(Out, "(~p) << ~p [Serial: ~p, From: ~p]~n", + [To, Mes, Ser, Fr]); + {print, Ser, Fr, _, Info} -> + io:format(Out, "-> ~p [Serial: ~p, From: ~p]~n", + [Info, Ser, Fr]); + Else -> + io:format(Out, "~p~n", [Else]) + end, + Out; +dhandler(_Trace, Out) -> + Out. + +dhandler1(Trace, Size, Out) -> +%%%! Self = self(), + From = element(2, Trace), + case element(3, Trace) of + 'receive' -> + case element(4, Trace) of + {dbg,ok} -> ok; + Message -> io:format(Out, "(~p) << ~p~n", [From,Message]) + end; + 'send' -> + Message = element(4, Trace), + case element(5, Trace) of +%%%! This causes messages to disappear when used by ttb (observer). Tests +%%%! so far show that there is no difference in results with dbg even if I +%%%! comment it out, so I hope this is only some old code which isn't +%%%! needed anymore... /siri +%%%! Self -> ok; + To -> io:format(Out, "(~p) ~p ! ~p~n", [From,To,Message]) + end; + call -> + case element(4, Trace) of + MFA when Size == 5 -> + Message = element(5, Trace), + io:format(Out, "(~p) call ~s (~p)~n", + [From,ffunc(MFA),Message]); + MFA -> + io:format(Out, "(~p) call ~s~n", [From,ffunc(MFA)]) + end; + return -> %% To be deleted... + case element(4, Trace) of + MFA when Size == 5 -> + Ret = element(5, Trace), + io:format(Out, "(~p) old_ret ~s -> ~p~n", + [From,ffunc(MFA),Ret]); + MFA -> + io:format(Out, "(~p) old_ret ~s~n", [From,ffunc(MFA)]) + end; + return_from -> + MFA = element(4, Trace), + Ret = element(5, Trace), + io:format(Out, "(~p) returned from ~s -> ~p~n", + [From,ffunc(MFA),Ret]); + return_to -> + MFA = element(4, Trace), + io:format(Out, "(~p) returning to ~s~n", [From,ffunc(MFA)]); + spawn when Size == 5 -> + Pid = element(4, Trace), + MFA = element(5, Trace), + io:format(Out, "(~p) spawn ~p as ~s~n", [From,Pid,ffunc(MFA)]); + Op -> + io:format(Out, "(~p) ~p ~s~n", [From,Op,ftup(Trace,4,Size)]) + end, + Out. + + +%%% These f* functions returns non-flat strings + +%% {M,F,[A1, A2, ..., AN]} -> "M:F(A1, A2, ..., AN)" +%% {M,F,A} -> "M:F/A" +ffunc({M,F,Argl}) when is_list(Argl) -> + io_lib:format("~p:~p(~s)", [M, F, fargs(Argl)]); +ffunc({M,F,Arity}) -> + io_lib:format("~p:~p/~p", [M,F,Arity]); +ffunc(X) -> io_lib:format("~p", [X]). + +%% Integer -> "Integer" +%% [A1, A2, ..., AN] -> "A1, A2, ..., AN" +fargs(Arity) when is_integer(Arity) -> integer_to_list(Arity); +fargs([]) -> []; +fargs([A]) -> io_lib:format("~p", [A]); %% last arg +fargs([A|Args]) -> [io_lib:format("~p,", [A]) | fargs(Args)]; +fargs(A) -> io_lib:format("~p", [A]). % last or only arg + +%% {A_1, A_2, ..., A_N} -> "A_Index A_Index+1 ... A_Size" +ftup(Trace, Index, Index) -> + io_lib:format("~p", [element(Index, Trace)]); +ftup(Trace, Index, Size) -> + [io_lib:format("~p ", [element(Index, Trace)]) + | ftup(Trace, Index+1, Size)]. +%% ------------------------------------------------------------------------------ + +%% ============================================================================== +%% Functions handling the trace-port. Copied from dbg.erl +%% ============================================================================== + +trace_port_control(Port, flush) -> + case trace_port_control(Port, $f, "") of + {ok, [0]} -> ok; + {ok, _} -> {error, not_supported_by_trace_driver}; + Other -> Other + end. + +trace_port_control(Port, Command, Arg) when is_port(Port)-> + case catch port_control(Port, Command, Arg) of + {'EXIT', _} -> {error, {no_trace_driver, node()}}; + Result -> Result + end. + + +trace_port(file, {Filename, wrap, Tail}) -> + trace_port(file, {Filename, wrap, Tail, 128*1024}); +trace_port(file, {Filename, wrap, Tail, WrapSize}) -> + trace_port(file, {Filename, wrap, Tail, WrapSize, 8}); +trace_port(file, {Filename, wrap, Tail, WrapSize, WrapCnt}) + when is_list(Tail), + is_integer(WrapSize), WrapSize >= 0, WrapSize < (1 bsl 32), + is_integer(WrapCnt), WrapCnt >= 1, WrapCnt < (1 bsl 32) -> + trace_port1(file, Filename, {wrap, Tail, WrapSize, WrapCnt, 0}); +trace_port(file, {Filename, wrap, Tail, {time, WrapTime}, WrapCnt}) + when is_list(Tail), + is_integer(WrapTime), WrapTime >= 1, WrapTime < (1 bsl 32), + is_integer(WrapCnt), WrapCnt >= 1, WrapCnt < (1 bsl 32) -> + trace_port1(file, Filename, {wrap, Tail, 0, WrapCnt, WrapTime}); +trace_port(file, Filename) when is_list(Filename) -> + trace_port1(file, Filename, nowrap); + +trace_port(ip, Portno) when is_integer(Portno) -> + trace_port(ip,{Portno,50}); + +trace_port(ip, {Portno, Qsiz}) when is_integer(Portno), is_integer(Qsiz) -> + fun() -> + Driver = "trace_ip_drv", + Dir1 = filename:join(code:priv_dir(runtime_tools), "lib"), + case catch erl_ddll:load_driver(Dir1, Driver) of + ok -> + ok; + _ -> + Dir2 = filename:join( + Dir1, + erlang:system_info(system_architecture)), + catch erl_ddll:load_driver(Dir2, Driver) + end, + L = lists:flatten( + io_lib:format("~s ~p ~p 2", + [Driver, Portno, Qsiz])), + open_port({spawn, L}, [eof]) + end. + +trace_port1(file, Filename, Options) -> + Driver = "trace_file_drv", + fun() -> + Name = filename:absname(Filename), + %% Absname is needed since the driver uses + %% the supplied name without further investigations, + %% and if the name is relative the resulting path + %% might be too long which can cause a bus error + %% on vxworks instead of a nice error code return. + %% Also, the absname must be found inside the fun, + %% in case the actual node where the port shall be + %% started is on another node (or even another host) + {Wrap, Tail} = + case Options of + {wrap, T, WrapSize, WrapCnt, WrapTime} -> + {lists:flatten( + io_lib:format("w ~p ~p ~p ~p ", + [WrapSize, WrapCnt, WrapTime, + length(Name)])), + T}; + nowrap -> + {"", ""} + end, + Command = Driver ++ " " ++ Wrap ++ "n " ++ Name ++ Tail, + Dir1 = filename:join(code:priv_dir(runtime_tools), "lib"), + case catch erl_ddll:load_driver(Dir1, Driver) of + ok -> + ok; + _ -> + Dir2 = filename:join( + Dir1, + erlang:system_info(system_architecture)), + catch erl_ddll:load_driver(Dir2, Driver) + end, + if element(1, Options) == wrap -> + %% Delete all files from any previous wrap log + Files = wrap_postsort(wrap_presort(Name, Tail)), + lists:foreach( + fun(N) -> file:delete(N) end, + Files); + true -> ok + end, + open_port({spawn, Command}, [eof]) + end. + +%% Find all possible wrap log files. +%% Returns: a list of sort converted filenames. +%% +%% The sort conversion is done by extracting the wrap sequence counter +%% from the filename, and calling wrap_encode/2. +wrap_presort(Filename, Tail) -> + Name = filename:basename(Filename), + Dirname = filename:dirname(Filename), + case file:list_dir(Dirname) of + {ok, Files} -> + lists:zf( + fun(N) -> + case match_front(N, Name) of + false -> + false; + X -> + case match_rear(X, Tail) of + false -> + false; + C -> % Counter + case match_0_9(C) of + true -> + {true, +% filename:join(Dirname, N)} + wrap_encode( + filename:join(Dirname, N), + C)}; + false -> + false + end + end + end + end, + Files); + _ -> + [] + end. + +%% Extract the filenames from a list of sort converted ones. +wrap_postsort(Files) -> + lists:map(fun wrap_name/1, Files). + +wrap_encode(N, C) -> + {list_to_integer(C), N}. + +wrap_name({_C, N}) -> + N. + +%% Returns what is left of ListA when removing all matching +%% elements from ListB, or false if some element did not match, +%% or if ListA runs out of elements before ListB. +match_front(ListA, []) when is_list(ListA) -> + ListA; +match_front([], ListB) when is_list(ListB) -> + false; +match_front([Hd|TlA], [Hd|TlB]) -> + match_front(TlA,TlB); +match_front([_HdA|_], [_HdB|_]) -> + false. + +%% Reversed version of match_front/2 +match_rear(ListA, ListB) when is_list(ListA), is_list(ListB) -> + case match_front(lists:reverse(ListA), lists:reverse(ListB)) of + false -> + false; + List -> + lists:reverse(List) + end. + +%% Returns true if the non-empty list arguments contains all +%% characters $0 .. $9. +match_0_9([]) -> + false; +match_0_9([H]) when is_integer(H), $0 =< H, H =< $9 -> + true; +match_0_9([H|T]) when is_integer(H), $0 =< H, H =< $9 -> + match_0_9(T); +match_0_9(L) when is_list(L) -> + false. +%% ----------------------------------------------------------------------------- + + +%% ----------------------------------------------------------------------------- +%% Functions working on the tracerdata structure. +%% ----------------------------------------------------------------------------- + +%% Tracerdata is the structure which specifies to where tracing is logged at this +%% runtime component. It may now (and in the future specify) several things. +%% Currently it can consist of: +%% LogTD: specifying how trace-log data shall be handled. +%% TiTD : trace information, specifying how trace information shall be handled. +%% +%% Tracerdata may also contain quick or standard forms of LogTD and/or TiTD. +%% For instance if a standard handler-fun shall be used. The handler fun is not +%% part of the tracerdata but rather specified by a constant. + + +%% Help function that translates an input-tracerdata to useful internal formats. +%% This since the tracerdata may consist of specifications which shall be +%% translated into funs or similar. +%% Returns {ok,LogTD,TiTD} or {error,Reason}. +%% Note that TiTD may be 'void' since TiTD is not mandatory. +translate_td(TracerData) when is_list(TracerData) -> % Both log and ti. + case translate_td_logtd(get_trace_log_tracerdata(TracerData)) of + {ok,LogTD} -> + case translate_td_titd(get_ti_log_tracerdata(TracerData)) of + {ok,TiTD} -> + {ok,LogTD,TiTD}; + {error,Reason} -> + {error,Reason} + end; + {error,Reason} -> + {error,Reason} + end; +translate_td(TracerData) -> % The it is just LogTD!? + case translate_td_logtd(TracerData) of + {ok,LogTD} -> + {ok,LogTD,void}; + {error,Reason} -> + {error,Reason} + end. +%% ----------------------------------------------------------------------------- + +%% Help function translating trace-log tracerdata. +translate_td_logtd(collector) -> % This rt will act as receiver. + {ok,{fun dhandler/2,user}}; % Simple terminal io. +translate_td_logtd({relayer,Tracer}) when is_pid(Tracer) -> + {ok,{fun relay_handler/2,Tracer}}; % Relay trace-msg to Tracer-pid. +translate_td_logtd({HandlerFun,Data}) when is_function(HandlerFun) -> + {ok,{HandlerFun,Data}}; % Own invented fun. +translate_td_logtd({Type,Parameters}) when Type==ip;Type==file -> + {ok,{Type,Parameters}}; % Built in trace-port +translate_td_logtd(false) -> % Unusual but no trace log. + {ok,void}; +translate_td_logtd(Arg) -> + {error,{bad_log_td,Arg}}. +%% ----------------------------------------------------------------------------- + +%% Help function translating ti-log tracerdata. +translate_td_titd(TiTD={file,FileName}) when is_list(FileName) -> + {ok,TiTD}; +translate_td_titd({file,FileName, + {InitPublLDmfa={M1,F1,L1}, + RemovePublLDmf={M2,F2}, + CleanPublLDmf={M3,F3}}}) + when is_list(FileName),is_atom(M1),is_atom(F1),is_atom(M2),is_atom(F2),is_list(L1),is_atom(M3),is_atom(F3) -> + {ok,{file,FileName,{InitPublLDmfa,RemovePublLDmf,CleanPublLDmf}}}; +translate_td_titd({file,FileName, + {InitPublLDmfa={M1,F1,L1}, + void, + CleanPublLDmf={M3,F3}}}) + when is_list(FileName),is_atom(M1),is_atom(F1),is_list(L1),is_atom(M3),is_atom(F3) -> + {ok,{file,FileName,{InitPublLDmfa,void,CleanPublLDmf}}}; +translate_td_titd(false) -> % Means no ti-tracerdata. + {ok,void}; +translate_td_titd(TiTD) -> + {error,{bad_ti_td,TiTD}}. +%% ----------------------------------------------------------------------------- + +%% This function retrieves the trace-log part of a TracerData list structure. +%% Returns TraceLogTD or 'false'. +get_trace_log_tracerdata(TracerData) -> + case lists:keysearch(trace,1,TracerData) of + {value,{_,LogTD}} -> + LogTD; + false -> + false + end. +%% ----------------------------------------------------------------------------- + +%% This function retrieves the ti-log part of a TracerData list structure. +%% Returns TiLogTD or 'false'. +get_ti_log_tracerdata(TracerData) -> + case lists:keysearch(ti,1,TracerData) of + {value,{_,TiTD}} -> + TiTD; + false -> + false + end. +%% ----------------------------------------------------------------------------- + +%% Help function which checks that parameters to the built in trace-port are +%% sane. +check_traceport_parameters(Type,Args) -> + case {Type,Args} of + {file,{FileName,wrap,Tail}} when is_list(FileName),is_list(Tail) -> + ok; + {file,{FileName,wrap,Tail,WrapSize}} + when is_list(FileName), + is_list(Tail), + is_integer(WrapSize),WrapSize>=0,WrapSize< (1 bsl 32) -> + ok; + {file,{FileName,wrap,Tail,WrapSize,WrapCnt}} + when is_list(FileName),is_list(Tail), + is_integer(WrapSize), WrapSize >= 0, WrapSize < (1 bsl 32), + is_integer(WrapCnt), WrapCnt >= 1, WrapCnt < (1 bsl 32) -> + ok; + {file,{FileName,wrap,Tail,{time,WrapTime},WrapCnt}} + when is_list(FileName),is_list(Tail), + is_integer(WrapTime), WrapTime >= 1, WrapTime < (1 bsl 32), + is_integer(WrapCnt), WrapCnt >= 1, WrapCnt < (1 bsl 32) -> + ok; + {file,FileName} when is_list(FileName) -> + ok; + {ip,Portno} when is_integer(Portno),Portno=<16#FFFF -> + ok; + {ip,{Portno,Qsiz}} when is_integer(Portno),Portno=<16#FFFF,is_integer(Qsiz) -> + ok; + _ -> + {error,{trace_port_args,[Type,Args]}} + end. +%% ----------------------------------------------------------------------------- + + +%% ----------------------------------------------------------------------------- +%% Default overload functionality. +%% ----------------------------------------------------------------------------- + +%% A default overload protection function. An overload function must take +%% one argument and return 'ok' or {suspend,SuspendReason}. +default_overload_func(_) -> + case process_info(self(),message_queue_len) of + {message_queue_len,N} when N > 1000 -> + {suspend,rt_max_queue_len}; + _ -> + ok + end. +%% ----------------------------------------------------------------------------- + +%% ============================================================================= +%% Functions working on the internal loopdata structure. +%% ============================================================================= + +%% Help function simply adding Fetcher as a fetcher process to the loopdata. +%% Returns a new loopdata structure. +add_fetcher_ld(Fetcher,LD) -> + LD#rt{fetchers=[Fetcher|LD#rt.fetchers]}. +%% ----------------------------------------------------------------------------- + +%% Help function investigating if the first argument is a known fetcher process +%% or not. If it is, it also removed it from the fetchers list in the loopdata +%% structure. +%% Returns {true,NewLoopData} or 'false'. +remove_fetcher_ld(Fetcher,LD) -> + NewFetchers=lists:delete(Fetcher,LD#rt.fetchers), + if + NewFetchers/=LD#rt.fetchers -> + {true,LD#rt{fetchers=NewFetchers}}; + true -> % No it was not a fetcher process. + false + end. +%% ----------------------------------------------------------------------------- + +%%% end of file + |