← Back to branch summary

~ubuntu-branches/ubuntu/trusty/erlang/trusty

« back to all changes in this revision

Viewing changes to lib/inviso/src/inviso_c.erl

  • Committer: Bazaar Package Importer
  • Author(s): Clint Byrum
  • Date: 2011-05-05 15:48:43 UTC
  • mfrom: (3.5.13 sid)
  • Revision ID: james.westby@ubuntu.com-20110505154843-0om6ekzg6m7ugj27
Tags: 1:14.b.2-dfsg-3ubuntu1
* Merge from debian unstable.  Remaining changes:
  - Drop libwxgtk2.8-dev build dependency. Wx isn't in main, and not
    supposed to.
  - Drop erlang-wx binary.
  - Drop erlang-wx dependency from -megaco, -common-test, and -reltool, they
    do not really need wx. Also drop it from -debugger; the GUI needs wx,
    but it apparently has CLI bits as well, and is also needed by -megaco,
    so let's keep the package for now.
  - debian/patches/series: Do what I meant, and enable build-options.patch
    instead.
* Additional changes:
  - Drop erlang-wx from -et
* Dropped Changes:
  - patches/pcre-crash.patch: CVE-2008-2371: outer level option with
    alternatives caused crash. (Applied Upstream)
  - fix for ssl certificate verification in newSSL: 
    ssl_cacertfile_fix.patch (Applied Upstream)
  - debian/patches/series: Enable native.patch again, to get stripped beam
    files and reduce the package size again. (build-options is what
    actually accomplished this)
  - Remove build-options.patch on advice from upstream and because it caused
    odd build failures.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/inviso/src/inviso_c.erl
100
100
    end.
101
101
%% ------------------------------------------------------------------------------
102
102
 
103
 
handle_call({subscribe,Pid},_From,LD) when pid(Pid) ->
 
103
handle_call({subscribe,Pid},_From,LD) when is_pid(Pid) ->
104
104
    MRef=erlang:monitor(process,Pid),
105
105
    {reply,ok,LD#state{subscribers=[{Pid,MRef}|LD#state.subscribers]}};
106
106
handle_call({subscribe,Faulty},_From,LD) ->
131
131
    end;
132
132
handle_call({init_tracing,TracerDataList},_From,LD) ->
133
133
    {reply,adapt_reply(LD,do_init_tracing(TracerDataList,LD)),LD};
134
 
handle_call({init_tracing,Nodes,TracerData},_From,LD) when list(Nodes) ->
 
134
handle_call({init_tracing,Nodes,TracerData},_From,LD) when is_list(Nodes) ->
135
135
    TracerDataList=
136
136
        lists:map(fun(N)->{N,TracerData} end,started_trace_nodes(Nodes,LD)),
137
137
    {reply,adapt_reply(LD,do_init_tracing(TracerDataList,LD)),LD};
173
173
    end;
174
174
handle_call({delete_log,NodesOrNodeSpecs},_From,LD) ->
175
175
    {reply,adapt_reply(LD,do_delete_log(NodesOrNodeSpecs,LD)),LD};
176
 
handle_call({delete_log,Nodes,Specs},_From,LD) when list(Nodes) ->
 
176
handle_call({delete_log,Nodes,Specs},_From,LD) when is_list(Nodes) ->
177
177
    Reply=do_delete_log(lists:map(fun(N)->{N,Specs} end,Nodes),LD),
178
178
    {reply,adapt_reply(LD,Reply),LD};
179
179
handle_call({delete_log,FaultyNodes,_Specs},_From,LD) ->
283
283
 
284
284
do_change_option_2([Node|Tail],Options,LD,Replies) ->
285
285
    case get_node_rec(Node,LD) of
286
 
        Rec when record(Rec,node) ->
 
286
        Rec when is_record(Rec,node) ->
287
287
            Answer=?RUNTIME:change_options(Rec#node.pid,Options),
288
288
            do_change_option_2(Tail,Options,LD,[{Node,Answer}|Replies]);
289
289
        Error ->
333
333
%% Returns {ok,Reply} or {error,Reason}.
334
334
distribute_tp(all,Patterns,FlagList,LD) ->
335
335
    distribute_tp(started_trace_nodes(all,LD),Patterns,FlagList,LD);
336
 
distribute_tp(Nodes,Patterns,FlagList,LD) when list(Nodes) ->
 
336
distribute_tp(Nodes,Patterns,FlagList,LD) when is_list(Nodes) ->
337
337
    RTpids=lists:map(fun(N)->case get_node_rec(N,LD) of
338
338
                                 #node{pid=Pid} ->
339
339
                                     {Pid,N};
354
354
%% Returns {ok,Reply} or {error,Reason}.
355
355
distribute_tf(all,Args,How,LD) ->
356
356
    distribute_tf(started_trace_nodes(all,LD),Args,How,LD);
357
 
distribute_tf(Nodes,Args,How,LD) when list(Nodes) ->
 
357
distribute_tf(Nodes,Args,How,LD) when is_list(Nodes) ->
358
358
    RTpids=lists:map(fun(Node)->
359
359
                             case get_node_rec(Node,LD) of
360
360
                                 #node{pid=Pid} ->
369
369
    {error,{badarg,Faulty}}.
370
370
 
371
371
%% As above but specific args for each node.
372
 
distribute_tf(NodeArgs,How,LD) when list(NodeArgs) ->
 
372
distribute_tf(NodeArgs,How,LD) when is_list(NodeArgs) ->
373
373
    RTpidArgs=lists:map(fun({Node,Args})->
374
374
                                case get_node_rec(Node,LD) of
375
375
                                    #node{pid=Pid} ->
384
384
    {error,{badarg,Faulty}}.
385
385
 
386
386
%% As above but both specific args for each node and How (set or remove flag).
387
 
distribute_tf(NodeArgHows,LD) when list(NodeArgHows) ->
 
387
distribute_tf(NodeArgHows,LD) when is_list(NodeArgHows) ->
388
388
    RTpidArgHows=
389
389
        lists:map(fun({Node,Args,How}) ->
390
390
                          case get_node_rec(Node,LD) of
405
405
%% Returns {ok,Reply} or {error,Reason}.
406
406
distribute_metapattern(all,Args,LD) ->
407
407
    distribute_metapattern(started_trace_nodes(all,LD),Args,LD);
408
 
distribute_metapattern(Nodes,Args,LD) when list(Nodes) ->
 
408
distribute_metapattern(Nodes,Args,LD) when is_list(Nodes) ->
409
409
    RTpids=lists:map(fun(N)->case get_node_rec(N,LD) of
410
410
                                 #node{pid=Pid} ->
411
411
                                     {Pid,N};
480
480
%% Return {ok,Reply} or {error,Reason}.
481
481
do_stop_tracing(all,LD) ->
482
482
    do_stop_tracing(started_trace_nodes(all,LD),LD);
483
 
do_stop_tracing(Nodes,LD) when list(Nodes) ->
 
483
do_stop_tracing(Nodes,LD) when is_list(Nodes) ->
484
484
    RTpids=lists:map(fun(N)->case get_node_rec(N,LD) of
485
485
                                 #node{pid=Pid} ->
486
486
                                     {Pid,N};
580
580
%% proper strings.
581
581
do_fetch_log(ToNode,all,Dest,Prefix,From,LD) ->
582
582
    do_fetch_log(ToNode,started_trace_nodes(all,LD),Dest,Prefix,From,LD);
583
 
do_fetch_log(ToNode,Specs,Dest,Prefix,From,LD) when list(Dest),list(Prefix) ->
 
583
do_fetch_log(ToNode,Specs,Dest,Prefix,From,LD) when is_list(Dest),is_list(Prefix) ->
584
584
    CollectPid=spawn_link(ToNode,?MODULE,log_rec_init,[self(),Dest,Prefix,From]),
585
585
    do_fetch_log_2(Specs,LD,CollectPid,[],[]);
586
586
do_fetch_log(_ToNode,_Specs,Dest,Prefix,From,_LD) ->
639
639
                            LD,[]);
640
640
        false ->
641
641
            if
642
 
                list(NodeSpecs),list(hd(NodeSpecs)) -> % A list of files.
 
642
                is_list(NodeSpecs),is_list(hd(NodeSpecs)) -> % A list of files.
643
643
                    do_delete_log_2(lists:map(fun(N)->{N,NodeSpecs} end,
644
644
                                              started_trace_nodes(all,LD)),
645
645
                                    LD,[]);
785
785
 
786
786
check_options_2([],_Context,Result) ->
787
787
    {ok,Result};
788
 
check_options_2([{subscribe,Pid}|OptionsTail],start,Result) when pid(Pid) ->
 
788
check_options_2([{subscribe,Pid}|OptionsTail],start,Result) when is_pid(Pid) ->
789
789
    check_options_2(OptionsTail,start,[{subscribe,Pid}|Result]);
790
 
check_options_2([{unsubscribe,Pid}|OptionsTail],start,Result) when pid(Pid) ->
 
790
check_options_2([{unsubscribe,Pid}|OptionsTail],start,Result) when is_pid(Pid) ->
791
791
    check_options_2(OptionsTail,start,[{unsubscribe,Pid}|Result]);
792
792
check_options_2([{dependency,How}|OptionsTail],Context,Result) ->
793
793
    check_options_2(OptionsTail,Context,[{dependency,How}|Result]);
819
819
            LD1#state{distributed=true}
820
820
    end.
821
821
 
822
 
initiate_state_2([{subscribe,Proc}|Tail],LD) when pid(Proc);atom(Proc)->
 
822
initiate_state_2([{subscribe,Proc}|Tail],LD) when is_pid(Proc);is_atom(Proc)->
823
823
    MRef=erlang:monitor(process,Proc),
824
824
    initiate_state_2(Tail,LD#state{subscribers=[{Proc,MRef}|LD#state.subscribers]});
825
 
initiate_state_2([Opt|Tail],LD) when tuple(Opt),size(Opt)>=1 ->
 
825
initiate_state_2([Opt|Tail],LD) when is_tuple(Opt),size(Opt)>=1 ->
826
826
    initiate_state_2(Tail,initiate_state_3(element(1,Opt),Opt,LD));
827
 
initiate_state_2([Opt|Tail],LD) when atom(Opt) ->
 
827
initiate_state_2([Opt|Tail],LD) when is_atom(Opt) ->
828
828
    initiate_state_2(Tail,initiate_state_3(Opt,Opt,LD));
829
829
initiate_state_2([_|Tail],LD) ->
830
830
    initiate_state_2(Tail,LD);
853
853
%% or more values associated with the Parameter, or just an atom.
854
854
merge_options([], Options) ->
855
855
    Options;
856
 
merge_options([T|DefaultTail],Options) when tuple(T),size(T)>=1 ->
 
856
merge_options([T|DefaultTail],Options) when is_tuple(T),size(T)>=1 ->
857
857
    merge_options(DefaultTail,merge_options_2(element(1,T),T,Options));
858
 
merge_options([Param|DefaultTail],Options) when atom(Param) ->
 
858
merge_options([Param|DefaultTail],Options) when is_atom(Param) ->
859
859
    merge_options(DefaultTail,merge_options_2(Param,Param,Options));
860
860
merge_options([_|DefaultTail],Options) ->    % Strange, bad default option!
861
861
    merge_options(DefaultTail,Options).
868
868
            [Opt|Options]
869
869
    end.
870
870
 
871
 
merge_options_find(Param,[T|_]) when tuple(T),element(1,T)==Param ->
 
871
merge_options_find(Param,[T|_]) when is_tuple(T),element(1,T)==Param ->
872
872
    true;
873
873
merge_options_find(Param,[Param|_]) ->
874
874
    true;
883
883
%% It also checks the formatting of the tracerdata since runtime components
884
884
%% does not accept too badly formatted tracerdata.
885
885
%% Returns {ok,NewTraceData} or {error,Reason}.
886
 
check_modify_tracerdata(TracerData,LoopData) when list(TracerData) ->
 
886
check_modify_tracerdata(TracerData,LoopData) when is_list(TracerData) ->
887
887
    case lists:keysearch(trace,1,TracerData) of
888
888
        {value,{_,TraceTD}} ->               % Examine the trace part.
889
889
            case check_modify_tracerdata(TraceTD,LoopData) of
908
908
    end;
909
909
check_modify_tracerdata({Type,Data},_LoopData) when Type==ip;Type==file ->
910
910
    {ok,{Type,Data}};
911
 
check_modify_tracerdata({Handler,Data},_LoopData) when function(Handler) ->
 
911
check_modify_tracerdata({Handler,Data},_LoopData) when is_function(Handler) ->
912
912
    {ok,{Handler,Data}};
913
913
check_modify_tracerdata(Data,_LoopData) ->
914
914
    {error,{bad_tracerdata,Data}}.
999
999
 
1000
1000
%% Help function finding a node record for Node in a list of #node or in loopdata.
1001
1001
%% Returns the #node in question or {error,not_an_added_node}.
1002
 
get_node_rec(Node,NodeList) when list(NodeList) ->
 
1002
get_node_rec(Node,NodeList) when is_list(NodeList) ->
1003
1003
    get_node_rec_2(Node,NodeList);
1004
1004
get_node_rec(Node,#state{nodes=NodeList}) ->
1005
1005
    get_node_rec_2(Node,NodeList).
1016
1016
%% structure. Returns a new list of #node or a new loopdata structure.
1017
1017
delete_node_rec(Node,LD=#state{nodes=NodeList}) ->
1018
1018
    LD#state{nodes=delete_node_rec_2(Node,NodeList)};
1019
 
delete_node_rec(Node,NodeList) when list(NodeList) ->
 
1019
delete_node_rec(Node,NodeList) when is_list(NodeList) ->
1020
1020
    delete_node_rec_2(Node,NodeList).
1021
1021
 
1022
1022
delete_node_rec_2(_,[]) ->
1059
1059
                          Fetchers),
1060
1060
            CMRef=erlang:monitor(process,ClientPid), % Monitor the client.
1061
1061
            case log_rec_loop(Dest,Prefix,RTs,InitialReplies,CMRef) of
1062
 
                Reply when list(Reply) ->   % It is an ok value.
 
1062
                Reply when is_list(Reply) ->   % It is an ok value.
1063
1063
                    gen_server:reply(From,{ok,Reply});
1064
1064
                {error,Reason} ->
1065
1065
                    gen_server:reply(From,{error,Reason});