The R13B03 release.OTP_R13B03

1 files changed, 474 insertions, 0 deletions

diff --git a/lib/runtime_tools/src/inviso_rt_lib.erl b/lib/runtime_tools/src/inviso_rt_lib.erl
new file mode 100644
index 0000000000..2c6964e53e
--- /dev/null
+++ b/lib/runtime_tools/src/inviso_rt_lib.erl
@@ -0,0 +1,474 @@
+%%
+%% %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%
+%%
+%% ------------------------------------------------------------------------------
+%% File    : inviso_rt_lib.erl
+%% Author  : Lennart �hman <[email protected]>
+%% Description : 
+%%
+%% Created : 27 Sep 2005 by Lennart �hman <[email protected]>
+%% ------------------------------------------------------------------------------
+-module(inviso_rt_lib).
+
+-export([expand_regexp/2,expand_regexp/3,expand_regexp/4]).
+-export([is_tracerdata/1]).
+-export([transform/2]).
+
+-export([rpc/4,rpc/5,match_modules/2,match_modules/3]).
+-export([debug/3]).
+
+%% ------------------------------------------------------------------------------
+
+%% ==============================================================================
+%% Exported API functions.
+%% ==============================================================================
+
+%% ------------------------------------------------------------------------------
+%% expand_regexp(Nodes,RegExpDir,RegExpMod,Opts) = [{Node,Answer},...] | {error,Reason}
+%% expand_regexp(Nodes,RegExpMod,Opts) = [{Node,Answer},...] | {error,Reason}
+%% expand_regexp(RegExpDir,RegExpMod,Opts) = ListOfModules | {error,Reason}
+%% expand_regexp(RegExpMod,Opts) = ListOfModules | {error,Reason}
+%%   Nodes=List of all nodes (atoms) where to expand.
+%%   RegExpDir=Reg.exp (string) specifying directories.
+%%   RegExpMod=Reg.exp (string) specifying module names.
+%%   Node=node name (atom).
+%%   Opts=[Opt,...]
+%%   Opt=only_loaded
+%%   Answer=List of modules (atoms) | 'badrpc'
+%%
+%% Expands, concurrently, the regular expression on Nodes and returns a list
+%% of what modules it expanded to on the different nodes. Note that it may
+%% differ between Erlang nodes depending on whether the modules are the same
+%% or not. Also note that all modules becomes loaded as a result.
+%% RegExpDir can further limit the modules. It introduces the requirement that
+%% a module must be loaded from a directory with a path satisfying the RegExpDir.
+%% All regular expression are according to the standard lib regexp module.
+expand_regexp(RegExpMod,Opts) when is_list(RegExpMod),is_list(Opts) ->
+    match_modules(RegExpMod,Opts);
+expand_regexp(RegExpMod,Opts) ->
+    {error,{badarg,[RegExpMod,Opts]}}.
+expand_regexp(NodesOrRegExpDir,RegExpMod,Opts)
+  when is_list(NodesOrRegExpDir),is_list(RegExpMod),is_list(Opts) ->
+    case is_list_of_atoms(NodesOrRegExpDir) of
+	true ->                              % Interpret as list of nodes.
+	    lists:foreach(fun(N)->spawn(?MODULE,rpc,[self(),N,RegExpMod,Opts]) end,
+			  NodesOrRegExpDir),
+	    expand_regexp_answers(NodesOrRegExpDir,[]);
+	false ->                             % Interpret as a string.
+	    match_modules(NodesOrRegExpDir,RegExpMod,Opts)
+    end;
+expand_regexp(NodesOrRegExpDir,RegExpMod,Opts) ->
+    {error,{badarg,[NodesOrRegExpDir,RegExpMod,Opts]}}.
+expand_regexp(Nodes,RegExpDir,RegExpMod,Opts)
+  when is_list(Nodes),is_list(RegExpDir),is_list(RegExpMod),is_list(Opts) ->
+    lists:foreach(fun(N)->
+			  spawn(?MODULE,rpc,[self(),N,RegExpDir,RegExpMod,Opts])
+		  end,
+		  Nodes),
+    expand_regexp_answers(Nodes,[]);
+expand_regexp(Nodes,RegExpDir,RegExpMod,Opts) ->
+    {error,{badarg,[Nodes,RegExpDir,RegExpMod,Opts]}}.
+
+expand_regexp_answers([],Answers) -> Answers;  % List of [{Node,Answer},...].
+expand_regexp_answers(Nodes,Answers) ->
+    receive
+	{?MODULE,Node,Answer} ->
+	    expand_regexp_answers(lists:delete(Node,Nodes),[{Node,Answer}|Answers])
+    end.
+%% ------------------------------------------------------------------------------
+
+%% is_tracerdata(TracerData)=true|false
+%% Answers the question if TracerData is proper tracerdata. Note that true can be
+%% returned if it resembles tracerdata very closely.
+is_tracerdata({Fun,_Data}) when is_function(Fun) -> true;
+is_tracerdata({relayer,To}) when is_pid(To);is_atom(To) -> true;
+is_tracerdata(collector) -> true;
+is_tracerdata({file,Param}) when is_tuple(Param);is_list(Param) -> true;
+is_tracerdata({ip,_Param}) -> true;
+is_tracerdata([{trace,LogTD}|Rest]) ->
+    case is_tracerdata(LogTD) of
+	true ->
+	    is_tracerdata(Rest);
+	false ->
+	    false
+    end;
+is_tracerdata([{ti,TiData}|Rest]) ->
+    case is_tidata(TiData) of
+	true ->
+	    is_tracerdata(Rest);
+	false ->
+	    false
+    end;
+is_tracerdata([]) ->
+    true;
+is_tracerdata(_) ->
+    false.
+
+is_tidata({file,FileName}) when is_list(FileName) -> true; 
+is_tidata({file,FileName,{M,F,Args}}) when is_list(FileName),is_atom(M),is_atom(F),is_list(Args) ->
+    true;
+is_tidata(_) -> false.
+%% ------------------------------------------------------------------------------		
+
+
+%% ==============================================================================
+%% Help functions.
+%% ==============================================================================
+
+%% Help function intended to be run in its own process. Will report with
+%% a message when done.
+%% This function will be spawned on.
+rpc(Parent,Node,RegExpMod,Opts) ->			   
+    case rpc:call(Node,?MODULE,match_modules,[RegExpMod,Opts]) of
+	{badrpc,_Reason} ->                  % The node is probably not healthy.
+	    Parent ! {?MODULE,Node,badrpc};
+	Modules ->
+	    Parent ! {?MODULE,Node,Modules}
+    end.
+
+rpc(Parent,Node,RegExpDir,RegExpMod,Opts) ->			   
+    case rpc:call(Node,?MODULE,match_modules,[RegExpDir,RegExpMod,Opts]) of
+	{badrpc,_Reason} ->                  % The node is probably not healthy.
+	    Parent ! {?MODULE,Node,badrpc};
+	Modules ->
+	    Parent ! {?MODULE,Node,Modules}
+    end.
+%% ------------------------------------------------------------------------------
+
+
+%% ==============================================================================
+%% Exported function which actually shall be in code.erl.
+%% ==============================================================================
+
+%% match_modules(RegExpMod,Actions) = [Module,...] | {error,Reason}
+%% match_modules(RegExpDir,RegExpMod,Actions)=[Module,...] | {error,Reason}
+%%   RegExpMod=Erlang regular expression describing module names (string).
+%%   RegExpDir=Erlang regular expression describing directory paths(string) |
+%%             void
+%%   Actions=List of;'only_loaded'.
+%%
+%% Function which matches a regular expresion against module names. The function
+%% can also match the directory from where the module is loaded or will be loaded
+%% against a regular expresion for directory paths.
+%% The function uses the same strategy as code-loading if the same module is
+%% discovered in several places.
+%% (1) An already loaded module shadows all other occurancies.
+%% (2) .beams found in by a path shadows .beams found by paths later in the
+%%   code paths.
+%%
+%% Description of actions:
+%% only_loaded: Only consider modules which are loaded.
+match_modules(RegExpMod,Actions) ->
+    match_modules(void,RegExpMod,Actions).
+match_modules(RegExpDir,RegExpMod,Actions) ->
+    AllLoaded=code:all_loaded(),
+    Mods1=handle_expand_regexp_2(AllLoaded,RegExpDir,RegExpMod,[]),
+    case lists:member(only_loaded,Actions) of % Shall we do not loaded too?
+	false ->                             % Ok, search all paths too then.
+	    Paths=code:get_path(),
+	    handle_expand_regexp_3(Paths,RegExpDir,RegExpMod,AllLoaded,Mods1);
+	true ->                              % Only loaded modules then.
+	    Mods1
+    end.
+
+
+%% Help function which traverses all loaded modules and determines
+%% which shall be returned. First we check that the module satisfies the
+%% module-regexp. Then we, if a dir reg-exp is given, checks that the
+%% module is loaded from an approved path. Note that if it can not be
+%% determined from where it was loaded (like preloaded or cover-compiled
+%% etc), but dir reg-exps are used. That module will be excluded.
+%% Returns a list of modules.
+handle_expand_regexp_2([{Mod,Path}|Rest],RegExpDir,RegExpMod,Result) ->
+    ModStr=atom_to_list(Mod),
+    ModLen=length(ModStr),
+    case regexp:first_match(ModStr,RegExpMod) of
+	{match,1,ModLen} ->                  % Ok, The regexp matches the module.
+	    if
+		is_list(RegExpDir),is_atom(Path) -> % Preloaded or covercompiled...
+		    handle_expand_regexp_2(Rest,RegExpDir,RegExpMod,Result);
+		is_list(RegExpDir),is_list(Path) -> % Dir reg-exp is used!
+		    PathOnly=filename:dirname(Path), % Must remove beam-file name.
+		    case regexp:first_match(PathOnly,RegExpDir) of
+			{match,_,_} ->       % Did find a match, that is enough!
+			    handle_expand_regexp_2(Rest,RegExpDir,RegExpMod,[Mod|Result]);
+			_ ->                 % Either error or nomatch.
+			    handle_expand_regexp_2(Rest,RegExpDir,RegExpMod,Result)
+		    end;
+		true ->                      % Otherwise already done!
+		    handle_expand_regexp_2(Rest,RegExpDir,RegExpMod,[Mod|Result])
+	    end;
+	_ ->                                 % Then Mod is not part of the set.
+	    handle_expand_regexp_2(Rest,RegExpDir,RegExpMod,Result)
+    end;
+handle_expand_regexp_2([],_,_,Result) -> Result.
+
+%% Help function which traverses all paths and looks for modules satisfying
+%% the module reg.exp.
+%% Returns a list of unique module names.
+handle_expand_regexp_3([Path|Rest],RegExpDir,RegExpMod,AllLoaded,Result) ->
+    if
+	is_list(RegExpDir) ->                   % We must consider the directory name.
+	    AbsPath=
+		case filename:pathtype(Path) of
+		    absolute ->              % Is already abs.
+			Path;
+		    relative ->              % Then it must be made absolute.
+			filename:absname(Path);
+		    volumerelative ->        % Only on Windows!?
+			filename:absname(Path)
+		end,
+	    case regexp:first_match(AbsPath,RegExpDir) of
+		{match,_,_} ->               % Ok, the directory is allowed.
+		    NewResult=handle_expand_regexp_3_1(Path,RegExpMod,AllLoaded,Result),
+		    handle_expand_regexp_3(Rest,RegExpDir,RegExpMod,AllLoaded,NewResult);
+		_ ->                         % This directory does not qualify.
+		    handle_expand_regexp_3(Rest,RegExpDir,RegExpMod,AllLoaded,Result)
+	    end;
+	true ->                              % RegExpDir is not used!
+	    NewResult=handle_expand_regexp_3_1(Path,RegExpMod,AllLoaded,Result),
+	    handle_expand_regexp_3(Rest,RegExpDir,RegExpMod,AllLoaded,NewResult)
+    end;
+handle_expand_regexp_3([],_,_,_,Result) -> Result.
+
+handle_expand_regexp_3_1(Path,RegExpMod,AllLoaded,Result) ->
+    case file:list_dir(Path) of
+	{ok,FileNames} ->
+	    handle_expand_regexp_3_2(FileNames,RegExpMod,AllLoaded,Result);
+	{error,_Reason} ->                   % Bad path!? Skip it.
+	    Result
+    end.
+
+handle_expand_regexp_3_2([File|Rest],RegExpMod,AllLoaded,Result) ->
+    case filename:extension(File) of
+	".beam" ->                           % It is a beam-file. Consider it!
+	    ModStr=filename:basename(File,".beam"),
+	    Mod=list_to_atom(ModStr),
+	    case {lists:keysearch(Mod,1,AllLoaded),lists:member(Mod,Result)} of
+		{false,false} ->             % This module is not tried before.
+		    ModLen=length(ModStr),
+		    case regexp:first_match(ModStr,RegExpMod) of
+			{match,1,ModLen} ->  % This module satisfies the regexp.
+			    handle_expand_regexp_3_2(Rest,RegExpMod,AllLoaded,[Mod|Result]);
+			_ ->                 % Error or not perfect match.
+			    handle_expand_regexp_3_2(Rest,RegExpMod,AllLoaded,Result)
+		    end;
+		{_,_} ->                     % This module is already tested.
+		    handle_expand_regexp_3_2(Rest,RegExpMod,AllLoaded,Result)
+	    end;
+	_ ->                                 % Not a beam-file, skip it.
+	    handle_expand_regexp_3_2(Rest,RegExpMod,AllLoaded,Result)
+    end;
+handle_expand_regexp_3_2([],_,_,Result) -> Result.
+%% ------------------------------------------------------------------------------
+
+%% Help function which finds out if its argument is a list of zero or more
+%% atoms.
+%% Returns 'true' or 'false'.
+is_list_of_atoms([A|Rest]) when is_atom(A) ->
+    is_list_of_atoms(Rest);
+is_list_of_atoms([_|_]) ->
+    false;
+is_list_of_atoms([]) ->
+    true.
+%% ------------------------------------------------------------------------------
+
+
+%% =============================================================================
+%% Functions transforming function calls in trace-case file.
+%% =============================================================================
+
+%% transform(Exprs,Translations)=NewExprs
+%%   Exprs=list(); List of abstract format erlang terms, as returned by
+%%     io:parse_erl_exprs/2.
+%%   Translations=list(); List of translations from function calls to other
+%%     function calls. [{Mod,Func,Arity,{NewMod,NewFunc,ParamTransformMF}},...]
+%%     Mod can actually be omitted, ParamTransformMF shall be {M,F} where F is
+%%     a function taking one argument (the parameter list), and returning the
+%%     new parameter list. It can also be anything else should no transformation
+%%     of the parameters be the case.
+%%
+%% Function that transforms function calls in a trace-case file. The transform/2
+%% can only transform shallow function calls. I.e where both module and function
+%% name are specified as atoms. Any binding-environment is not examined.
+transform([Expr|Rest],Translations) ->
+    [transform_2(Expr,Translations)|transform(Rest,Translations)];
+transform([],_) ->
+    [].
+
+%% Help function handling a single expr.
+transform_2({call,L1,{remote,L2,ModExpr,FuncExpr},Params},Translations) ->
+    case transform_2(ModExpr,Translations) of
+	{atom,L3,M} ->
+	    case transform_2(FuncExpr,Translations) of
+		{atom,L4,F} ->               % Now we have a M:F/Arity!
+		    case do_call_translation(M,F,Params,Translations) of
+			{ok,NewM,NewF,NewP} ->
+			    NewParams=transform(NewP,Translations),
+			    {call,L1,{remote,L2,{atom,L3,NewM},{atom,L4,NewF}},NewParams};
+			false ->             % No translation or faulty.
+			    NewParams=transform(Params,Translations),
+			    {call,L1,{remote,L2,ModExpr,FuncExpr},NewParams}
+		    end;
+		NewFuncExpr ->               % Not translated to a shallow term.
+		    NewParams=transform(Params,Translations),
+		    {call,L1,{remote,L2,ModExpr,NewFuncExpr},NewParams}
+	    end;
+	NewModExpr ->                        % Not translated to a shallow term.
+	    NewFuncExpr=transform_2(FuncExpr,Translations),
+	    NewParams=transform(Params,Translations),
+	    {call,L1,{remote,L2,NewModExpr,NewFuncExpr},NewParams}
+    end;
+transform_2({call,L1,FuncExpr,Params},Translations) ->
+    case transform_2(FuncExpr,Translations) of
+	{atom,L3,F} ->                       % Now we have a M:F/Arity!
+	    case do_call_translation(F,Params,Translations) of
+		{ok,NewM,NewF,NewP} ->       % It is turned into a global call.
+		    NewParams=transform(NewP,Translations),
+		    {call,L1,{remote,L1,{atom,L3,NewM},{atom,L3,NewF}},NewParams};
+		false ->                     % No translation or faulty.
+		    NewParams=transform(Params,Translations),
+		    {call,L1,FuncExpr,NewParams}
+	    end;
+	NewFuncExpr ->                       % Not translated to a shallow term.
+	    NewParams=transform(Params,Translations),
+	    {call,L1,NewFuncExpr,NewParams}
+    end;
+transform_2({match,L,P,E},Translations) ->
+    NewPattern=transform_2(P,Translations),
+    NewExpr=transform_2(E,Translations),
+    {match,L,NewPattern,NewExpr};
+transform_2({op,L,Op,Arg1,Arg2},Translations) ->
+    NewArg1=transform_2(Arg1,Translations),
+    NewArg2=transform_2(Arg2,Translations),
+    {op,L,Op,NewArg1,NewArg2};
+transform_2({op,L,Op,Arg},Translations) ->
+    NewArg=transform_2(Arg,Translations),
+    {op,L,Op,NewArg};
+transform_2({block,L,Body},Translations) ->
+    NewBody=transform(Body,Translations),
+    {block,L,NewBody};
+transform_2({'if',L,Clauses},Translations) ->
+    NewClauses=transform_clauses(Clauses,Translations),
+    {'if',L,NewClauses};
+transform_2({'case',L,Func,Clauses},Translations) ->
+    NewFunc=transform_2(Func,Translations),
+    NewClauses=transform_clauses(Clauses,Translations),
+    {'case',L,NewFunc,NewClauses};
+transform_2({'fun',L,{clauses,Clauses}},Translations) ->
+    NewClauses=transform_clauses(Clauses,Translations),
+    {'fun',L,NewClauses};
+transform_2({lc,L,Items,GeneratorsFilters},Translations) ->
+    NewItem=transform_2(Items,Translations),
+    NewGensAndFilters=transform_gensandfilters(GeneratorsFilters,Translations),
+    {lc,L,NewItem,NewGensAndFilters};
+transform_2({'catch',L,Expr},Translations) ->
+    NewExpr=transform_2(Expr,Translations),
+    {'catch',L,NewExpr};
+transform_2({tuple,L,Elements},Translations) ->
+    NewElements=transform(Elements,Translations),
+    {tuple,L,NewElements};
+transform_2({cons,L,Element,Tail},Translations) ->
+    NewElement=transform_2(Element,Translations),
+    NewTail=transform_2(Tail,Translations),
+    {cons,L,NewElement,NewTail};
+transform_2({nil,L},_) ->
+    {nil,L};
+transform_2({bin,L,Elements},Translations) ->
+    NewElements=transform_binary(Elements,Translations),
+    {bin,L,NewElements};
+transform_2(Expr,_) ->                       % Can be a var for instance.
+    Expr.
+
+transform_binary([{bin_element,L,Val,Size,TSL}|Rest],Translations) ->
+    NewVal=transform_2(Val,Translations),
+    NewSize=transform_2(Size,Translations),
+    [{bin_element,L,NewVal,NewSize,TSL}|transform_binary(Rest,Translations)];
+transform_binary([],_) ->
+    [].
+
+transform_clauses([{clause,L,Pattern,Guards,Body}|Rest],Translations) ->
+    NewPattern=transform(Pattern,Translations),
+    NewBody=transform(Body,Translations),
+    [{clause,L,NewPattern,Guards,NewBody}|transform_clauses(Rest,Translations)];
+transform_clauses([],_Translations) ->
+    [].
+
+transform_gensandfilters([{generator,L,Pattern,Exprs}|Rest],Translations) ->
+    NewExprs=transform(Exprs,Translations),
+    [{generator,L,Pattern,NewExprs}|transform_gensandfilters(Rest,Translations)];
+transform_gensandfilters([Expr|Rest],Translations) ->
+    [transform_2(Expr,Translations)|transform_gensandfilters(Rest,Translations)];
+transform_gensandfilters([],_) ->
+    [].
+%% ------------------------------------------------------------------------------
+
+%% This is the heart of the translation functionality. Here we actually try to
+%% replace calls to certain functions with other calls. This can include removing
+%% arguments.
+do_call_translation(M,F,Params,Translations) ->
+    case lists:keysearch({M,F,length(Params)},1,Translations) of
+	{value,{_,{NewM,NewF,ArgFun}}} ->    % Lets transform the function.
+	    do_call_translation_2(Params,NewM,NewF,ArgFun);
+	_ ->
+	    false                            % No translations at all.
+    end.
+do_call_translation(F,Params,Translations) ->
+    case lists:keysearch({F,length(Params)},1,Translations) of
+	{value,{_,{NewM,NewF,ArgFun}}} ->    % Lets transform the function.
+	    do_call_translation_2(Params,NewM,NewF,ArgFun);
+	_ ->
+	    false                            % No translations at all.
+    end.
+
+do_call_translation_2(Params,NewM,NewF,ArgFun) ->
+    case ArgFun of
+	{M,F} when is_atom(M),is_atom(F) ->
+	    case catch M:F(Params) of
+		{'EXIT',_Reason} ->
+		    false;                   % If it does not work, skipp it.
+		MungedParams when is_list(MungedParams) ->
+		    {ok,NewM,NewF,MungedParams};
+		_ ->
+		    false
+	    end;
+	_ ->                                 % No munging of parameters.
+	    {ok,NewM,NewF,Params}
+    end.
+%% ------------------------------------------------------------------------------
+
+
+%% =============================================================================
+%% Functions for the runtime component internal debugging system.
+%% =============================================================================
+
+%% The debug system is meant to provide tracing of ttb at different levels.
+%%
+%% debug(What,Level,Description) -> nothing significant.
+%%   What : controls what kind of event. This can both be certain parts of ttb
+%%          as well as certain levels (info to catastrophy).
+%%   Level: Determines if What shall be printed or not.
+%%   Description: this is what happend.
+debug(off,_What,_Description) ->
+    true;                                    % Debug is off, no action.
+debug(On,What,Description) ->
+    debug_2(On,What,Description).
+
+debug_2(_,What,Description) ->
+    io:format("INVISO DEBUG:~w, ~p~n",[What,Description]).
+%% -----------------------------------------------------------------------------