diff options
Diffstat (limited to 'lib/appmon/src/process_info.erl')
| -rw-r--r-- | lib/appmon/src/process_info.erl | 662 |
1 files changed, 0 insertions, 662 deletions
diff --git a/lib/appmon/src/process_info.erl b/lib/appmon/src/process_info.erl deleted file mode 100644 index e5d44ae50e..0000000000 --- a/lib/appmon/src/process_info.erl +++ /dev/null @@ -1,662 +0,0 @@ -%% -%% %CopyrightBegin% -%% -%% Copyright Ericsson AB 2001-2009. All Rights Reserved. -%% -%% The contents of this file are subject to the Erlang Public License, -%% Version 1.1, (the "License"); you may not use this file except in -%% compliance with the License. You should have received a copy of the -%% Erlang Public License along with this software. If not, it can be -%% retrieved online at http://www.erlang.org/. -%% -%% Software distributed under the License is distributed on an "AS IS" -%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See -%% the License for the specific language governing rights and limitations -%% under the License. -%% -%% %CopyrightEnd% --module(process_info). --behavior(gen_server). - --export([start/0, start_link/0, stop/0]). --export([is_node/1, get_nodes/0, - get_applications/1, get_application_keys/2, - get_processes/3, get_process_data/2, - send_trace/1]). - -%% gen_server callbacks --export([init/1, handle_call/3, handle_cast/2, handle_info/2, - terminate/2, code_change/3]). - --record(data, {que=undef, - procs=undef, - links=undef, - links2=undef}). - -%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -%% %% -%% Functions to retrieve information about which application %% -%% at the node %% -%% %% -%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% - -start() -> - gen_server:start({local, proc_info}, process_info, [], []). - -start_link() -> - gen_server:start_link({local, proc_info}, process_info, [], []). - -stop() -> - gen_server:call(proc_info, stop, 1000). - -%% is_node(NodeS) -> {bool(), Node, NodeS2} -%% NodeS = NodeS2 = string() -%% Node = node() -is_node(NodeS) -> - Node = list_to_atom(NodeS), - case lists:member(Node, [node()|nodes()]) of - true-> - {true, Node, NodeS}; - false -> - {false, node(), atom_to_list(node())} - end. - -%% get_nodes() -> [node()] -get_nodes() -> - [node()|nodes()]. - -%% get_applications(Node) -> [App] -%% Node = node() -%% App = atom() -%% Returns the list of all applications with a supervision tree (that -%% is, not library applications such as stdlib) at Node. -get_applications(Node) -> - Info = rpc:call(Node, application, info, []), - {value, {running, Apps}} = lists:keysearch(running, 1, Info), - [App || {App, Pid} <- Apps, is_pid(Pid)]. - -%% get_application_keys(App, Node) -> {ok, Keys} | {error, Reason} -%% Node = node() -%% App = atom() -%% Keys = [{Key, Val}] -%% Key = atom() -%% Val = term() -%% Reason = badapp | badrpc -get_application_keys(App, Node) -> - case rpc:call(Node, application, get_all_key, [App]) of - {ok, Keys} -> - {ok, Keys}; - undefined -> - {error, badapp}; - {badrpc, _} -> - {error, badrpc} - end. - -%% get_processes(App, Mode, Node) -> {Tree, Dict} | unknown -%% App = atom() -%% Mode = sup | sup_child | all -%% Node = node() -get_processes(App, Mode, Node) -> - gen_server:call(proc_info, {get_processes, App, Mode, Node}). - -%% get_process_data(Pid, Node) -> ProcData -%% Pid = pid() -%% Node = node() -%% ProcData -- see erlang:process_info/1 -get_process_data(Pid, Node) -> - case rpc:call(Node, erlang, process_info, [Pid]) of - {badrpc, _} -> - [{error,"Please try again"}]; - Res -> - Res - end. - -%% send_trace(PidL) -> void() -send_trace(PidL) -> - gen_server:call(proc_info, {send_trace, PidL}). - -%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -%% %% -%% gen_server callbacks %% -%% %% -%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% - -init([]) -> - {ok, ets:new(procs, [])}. - -handle_call({get_processes, App, Mode, Node}, _From, State) -> - case do_get_processes(App, Mode, Node) of - unknown -> - {reply, unknown, State}; - Tree -> - {reply, {Tree, State}, State} - end; -handle_call({send_trace, PidL}, _From, State) -> - do_send_trace(PidL, State), - {reply, ok, State}; -handle_call(stop, _From, State) -> - {stop, normal, ok, State}. - -handle_cast(_, State) -> - {noreply, State}. - -handle_info(_, State) -> - {noreply, State}. - -terminate(_Reason, _State) -> - ok. - -code_change(_, State, _) -> - {ok, State}. - -%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -%% %% -%% Internal functions %% -%% %% -%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% - -%% do_get_processes(App, Mode, Node) -> Tree | unknown -%% App = atom() -%% Mode = all | sup | sup_childs -%% Node = node() -%% Tree = term() -do_get_processes(App, Mode, Node) -> - case rpc:call(Node, application_controller, get_master, [App]) of - Pid when is_pid(Pid) -> - start_collecting_data(Pid, Mode, Node); - undefined -> - unknown - end. - -%% Initiate the database, get the processes and the links. -%% Then build lists and return them. -start_collecting_data(Pid, Mode, Node) -> - Db = get_database(), - {Db2, Tree} = build_graph({master,Pid}, Db, Pid, Mode, Node), - delete_database(Db2), - Tree. - -get_database() -> - P = ets:new(procs,[]), - L = ets:new(link,[bag]), - L2 = ets:new(link2,[bag]), - Q = queue:new(), - ets:insert(P, {whereis(application_controller), crap}), - ets:insert(P, {whereis(gs), crap}), - #data{que=Q, procs=P, links=L, links2=L2}. - -delete_database(Db) -> - ets:delete(Db#data.procs), - ets:delete(Db#data.links), - ets:delete(Db#data.links2). - -%% The thought is -%% 1. Get the processes that links to Pid. -%% Pid is the application master the first time. -%% 2. Add the processes to the database and clear the list of children -%% from processes which for some resason not should be there. -%% 3. Queue the children, so we later can se if they have any links. -%% 4. Add links to the childrens. -%% 5. When the whole tree is retreived remove the unnecessary processes -%% depending on the mode. -%% 6. Take all links that point to the same pid and sort out -%% the primary and secondary relations. -%% If more than one process links to the same process, the relation -%% between a supervisor and a process is primary. The rest is -%% secondary, there is no different in real world just in logic -%% between a secondary and a primary relation. -%% When all processes in the application is collected, -%% fix secondary links and return the tree. -build_graph(finish, Db, Grp, Mode, Node) -> - Db = fix_links(Db, Grp, Node), - delete_unwanted(Db, Mode, Grp), - Tree = start_tree(Db, Node), - {Db, Tree}; -build_graph(Pid, Db, Grp, Mode, Node) -> - Children = get_children(Pid, Mode, Node), - Children2 = add_and_remove(Children, Pid, Db, Grp, Node), - Q2 = queue_children(Db#data.que, Children2), - add_children(Pid, Db, Children2, 1), - case queue:out(Q2) of - {empty, _}-> - build_graph(finish, Db, Grp, Mode, Node); - {{value,NPid}, Q3}-> - Db2 = Db#data{que=Q3}, - build_graph(NPid,Db2,Grp,Mode,Node) - end. - -%% Collect the processes which the current process has a link to -%% Pid is now the application_master and the application master's -%% child is the application supervisor but in reality there are two -%% application master processes. -%% Fix this by reordering the processes a little. -get_children({master,Pid}, _Mode, Node) when is_pid(Pid) -> - %% Get the master pid - MPid = case application_master:get_child(Pid) of - {Pid1, _App} -> Pid1; - Pid1 -> Pid1 - end, - %% Get the second appplication master process and order them - %% correctly - case rpc:call(Node, erlang, process_info, [MPid,links]) of - {links, [H|T]} -> [H,MPid|T]; - {links, []} -> MPid - end; -get_children({Pid, _Name}, _Mode, Node) when is_pid(Pid), - Node==node(Pid) -> - {links,Links} = rpc:call(Node, erlang, process_info, [Pid,links]), - Links; -get_children(Pid, _Mode, Node) when is_pid(Pid), Node==node(Pid) -> - {links,Links} = rpc:call(Node, erlang, process_info, [Pid,links]), - Links; -get_children(Pid, _Mode, Node) when is_pid(Pid), Node/=node(Pid) -> - []; -get_children(Port, _Mode, _Node) when is_port(Port) -> - []. - -%% Add the links to the database. -%% The first case -- when it is the application master process -- there -%% is only one real child even though there are more links. -add_children({master,Pid}, Db, [Child|_Rest], N) -> - add_child(Pid, Db, Child, N); -add_children(_Pid, _Db, [], _N) -> - ok; -add_children(Pid, Db, [Child|Rest], N) -> - add_child(Pid, Db, Child, N), - add_children(Pid, Db, Rest, N+1). - -add_child(Pid, Db, Child, N) -> - case ets:match_object(Db#data.links, {Pid,Child,'_'}) of - [] -> - ets:insert(Db#data.links, {Pid,Child,N}); - _ -> - ok - end. - -%% Add the list of processes to the queue. -queue_children(Queue, []) -> - Queue; -queue_children(Queue, [H|T]) -> - Q = queue:in(H, Queue), - queue_children(Q, T). - -%% The processess that we already has added to the database are -%% not children to the current process, so we don't need to add them a -%% second time. -remove_used_children([], _Db, New_list) -> - lists:reverse(New_list); -remove_used_children([Child|Rest], Db, New) -> - case ets:lookup(Db#data.procs, Child) of - [] -> - remove_used_children(Rest, Db, [Child|New]); - _ -> - remove_used_children(Rest, Db, New) - end. - -%% Take the list of links and separate it into a list with ports and a -%% list with pids. -separate_ports([], Pids, Ports) -> - {Pids, Ports}; -separate_ports([Child|Rest], Pids, Ports) -> - if - is_port(Child) -> - separate_ports(Rest, Pids, [Child|Ports]); - is_pid(Child) -> - separate_ports(Rest, [Child|Pids], Ports) - end. - -%% Add the current pid to the ets table with processes and clear -%% the list of children from processes that should not be there. -%% In the first case, no children are used so it's not necessary. -add_and_remove(Children, {master,Pid}, Db, _Grp, Node) - when is_pid(Pid), Node==node(Pid) -> - ets:insert(Db#data.procs, {Pid, {master,master}, controller}), - {_Pids,Ports} = separate_ports(Children, [], []), - Ports++Children; -%% This clause is removable when using only link as retrieving mode . -add_and_remove(Children, {Pid,_Name}, Db, Grp, Node) - when is_pid(Pid), Node==node(Pid) -> - ets:insert(Db#data.procs, {Pid, - rpc:call(Node,erlang,process_info, - [Pid,registered_name])}), - {Pids, Ports} = separate_ports(Children, [], []), - Children1 = remove_used_children(Pids, Db, []), - Children2 = remove_others_children(Children1, Grp, Node), - Ports++Children2; -add_and_remove(Children, Pid, Db, Grp, Node) when is_pid(Pid), - Node==node(Pid) -> - ets:insert(Db#data.procs, {Pid, - rpc:call(Node,erlang,process_info, - [Pid,registered_name])}), - {Pids, Ports} = separate_ports(Children, [], []), - Children1 = remove_used_children(Pids, Db, []), - Children2 =remove_others_children(Children1, Grp, Node), - Ports++Children2; -add_and_remove(_Children, Pid, _Db, _Grp, Node) when is_pid(Pid), - Node/=node(Pid) -> - []; -%% Take care of the ports, don't add them to the table with processes. -add_and_remove(_Children, Pid, _Db, _Grp, _Node) when is_port(Pid) -> - []. - -%% Control that the application's group leader is the group leader of -%% Pid -group_leader_check({Pid,_Name}, Grp, Node) -> - group_leader_check(Pid, Grp, Node); -group_leader_check(Pid, Grp, Node) -> - case rpc:call(Node, erlang, process_info, [Pid,group_leader]) of - {_Item, Grp} -> yes; - _ -> no - end. - -%% Take the list of children and remove the ones with anoother group -%% leader. -remove_others_children(Children, Grp, Node) -> - lists:filter(fun(Child) -> - case group_leader_check(Child, Grp, Node) of - yes -> true; - no -> false - end - end, - Children). - -%% Mark the processes in the procs table as either supervisor or worker. -fix_links(Db, Leader, Node) -> - {Sup,_Work} = mark_supervisors_workers(Db, Leader, Node), - ets:match_delete(Db#data.procs, {'_',crap}), - [_Pid|Procs] = ets:tab2list(Db#data.procs), - N_links = get_n_links(Procs, Db#data.links, []), - N_links2 = take_sup_links(Sup, Db#data.links, N_links), - add_shared_links(N_links2, Db#data.links2), - Db. - -%% Add the links that point to the same child to the shared links table -add_shared_links(N_links, Links2) -> - Insert_fun = fun(Link) -> ets:insert(Links2, Link) end, - lists:map(fun(List) -> lists:map(Insert_fun, List) end, N_links). - -%% Take the list of links that point to the same children and remove -%% the ones that are children to supervisors. -%% The first argument is a list of the supervisors. -%% N_links contains a list of list of links that points to the same -%% child. -take_sup_links([], _Db, N_links) -> - N_links; -take_sup_links([H|Supervised], Links_table, N_links) -> - N_list_fun = fun(Link) -> - insert_sup_links(Link, H, Links_table) - end, - N_links2 = lists:map(fun(Link_list) -> - lists:filter(N_list_fun,Link_list) - end, - N_links), - take_sup_links(Supervised, Links_table, N_links2). - -%% Insert the supervised links in the primary links list. -%% This function should be used as a fun to the filter function in -%% take_sup_links/3. -insert_sup_links({From,To,N}, Sup, Links_table) -> - case From of - Sup -> - ets:insert(Links_table, {From,To,N}), - false; - _ -> - true - end. - -%% Get the links which points to the same children. -get_n_links([], _Links, N_link) -> - N_link; -get_n_links([{Pid,_,_}|Procs], Links, N_link) -> - case ets:match_object(Links, {'_',Pid,'_'}) of - L when length(L)>1 -> - ets:match_delete(Links, {'_',Pid,'_'}), - get_n_links(Procs, Links, [L|N_link]); - _L -> - get_n_links(Procs, Links, N_link) - end; -get_n_links([{Pid,_}|Procs], Links, N_link) -> - case ets:match_object(Links, {'_',Pid,'_'}) of - L when length(L)>1 -> - ets:match_delete(Links, {'_',Pid,'_'}), - get_n_links(Procs, Links, [L|N_link]); - _L -> - get_n_links(Procs, Links, N_link) - end. - -%% Mark the processes that are in the supervisor tree as either worker -%% or supervisor. -mark_supervisors_workers(Db, Leader, Node) -> - %% Get the supervisors and workers. - {Sup_list, Worker_list} = get_by_supervisors1(Leader), - %% Update the supervisor pids. - lists:map(fun(Pid) -> - ets:insert(Db#data.procs, - {Pid, - rpc:call(Node, erlang,process_info, - [Pid,registered_name]), - supervisor}) - end, - Sup_list), - %% Update the worker pids. - lists:map(fun(Pid) -> - ets:insert(Db#data.procs, - {Pid, - rpc:call(Node, erlang,process_info, - [Pid,registered_name]), - worker}) - end, - Worker_list), - {lists:reverse(Sup_list), Worker_list}. - -%% The second way to retrieve the applications processes is to go by -%% the supervision tree. -get_by_supervisors1(Leader) -> - case application_master:get_child(Leader) of - {Pid, _Name}-> - get_by_supervisors([{namn,Pid,supervisor,list_of_mods}], - [], []); - Pid -> - get_by_supervisors([{namn,Pid,supervisor,list_of_mods}], - [], []) - end. - -get_by_supervisors([], Sup, Work) -> - {Sup, Work}; -get_by_supervisors([{_,Pid,supervisor,_}|Rest], Sup, Work) - when is_pid(Pid) -> - Children = supervisor:which_children(Pid), - Children2 = lists:append(Children, Rest), - get_by_supervisors(Children2, [Pid|Sup], Work); -get_by_supervisors([{_,Pid,_,_}|Rest], Sup, Work) when is_pid(Pid) -> - get_by_supervisors(Rest, Sup, [Pid|Work]); -get_by_supervisors([_Whatever|Rest], Sup, Work) -> - get_by_supervisors(Rest, Sup, Work). - -%% Use pattern matching to select mode and delete the unneccesary pids -delete_unwanted(Db, sup_child, App_pid) -> - delete_not_in_supervisor_tree(Db), - add_main_link(Db, App_pid), - Db; -delete_unwanted(Db, all, _App_pid) -> - Db; -delete_unwanted(Db, sup, App_pid) -> - delete_workers(Db), - delete_not_in_supervisor_tree(Db), - add_main_link(Db, App_pid), - Db. - -add_main_link(Db, App_pid) -> - case application_master:get_child(App_pid) of - {Pid, _Name} when is_pid(Pid) -> - ets:insert(Db#data.links, {App_pid,Pid,1}); - Pid when is_pid(Pid) -> - ets:insert(Db#data.links, {App_pid,Pid,1}); - _ -> - false - end. - -%% Delete the processes that are in the supervision tree but are -%% workers, and their links. -delete_workers(Db) -> - Pids = ets:match_object(Db#data.procs, {'_','_',worker}), - Pids2 = - lists:map( - fun({Pid,_,_}) -> - %% Remove the unwanted pids from the process table. - ets:match_delete(Db#data.procs, {Pid,'_','_'}), - %% Remove the links to and from the pid. - ets:match_delete(Db#data.links, {Pid,'_','_'}), - ets:match_delete(Db#data.links, {'_',Pid,'_'}), - ets:match_delete(Db#data.links2, {Pid,'_','_'}), - ets:match_delete(Db#data.links2, {'_',Pid,'_'}) - end, - Pids), - Pids2. - -%% Delete the processes that are not in the supervision tree. -delete_not_in_supervisor_tree(Db) -> - Pids = ets:match_object(Db#data.procs,{'_','_'}), - Pids2 = - lists:map( - fun({Pid,_}) -> - %% Remove the unwanted from the process table. - ets:match_delete(Db#data.procs, {Pid,'_'}), - %% Remove the links to and from the pid. - ets:match_delete(Db#data.links, {Pid,'_','_'}), - ets:match_delete(Db#data.links, {'_',Pid,'_'}), - ets:match_delete(Db#data.links2, {Pid,'_','_'}), - ets:match_delete(Db#data.links2, {'_',Pid,'_'}) - end, - Pids), - Pids2. - -%% Start generating the tree. -start_tree(Db, Node) -> - case get_master(Db) of - no -> false; - Pid -> - build_node(Pid, Db, Node) - end. - -%% Build a node and then it runs itself on every child to the current -%% pid. -build_node(Pid, Db, Node) when is_pid(Pid), Node==node(Pid) -> - Sort_fun = fun sort_order/2, - Fix_sec_name_fun = fun(Pid2) -> get_link_name(Pid2, Db) end, - Build_tree_fun = fun({_,Pid1,_}) -> build_node(Pid1,Db,Node) end, - Children = ets:match_object(Db#data.links, {Pid,'_','_'}), - Children1 = lists:sort(Sort_fun, Children), - Sec_children = ets:match_object(Db#data.links2, {Pid,'_','_'}), - {get_name(Pid,Db), - lists:map(Build_tree_fun,Children1), - lists:map(Fix_sec_name_fun,Sec_children)}; -build_node(Pid, _Db, Node) when is_pid(Pid), Node/=node(Pid) -> - {"Runs on another node:"++erlang:pid_to_list(Pid), [], []}; -build_node(Pid, _Db, _Node) when is_port(Pid) -> - {"Port :"++erlang:port_to_list(Pid), [], []}. - -%% Select the name of the pid from the database where we previosly -%% added it. -get_name(Pid, Db) -> - case ets:lookup(Db#data.procs, Pid) of - [{_,{_,master},_}] -> pid_to_list(Pid); - [{_,{_,Name}}] -> atom_to_list(Name)++" : "++pid_to_list(Pid); - [{_,{_,Name},_}] -> atom_to_list(Name)++" : "++pid_to_list(Pid); - _ -> pid_to_list(Pid) - end. - -%% Select the name of the process which we have a link to. -get_link_name({_,Pid,_}, Db) when is_pid(Pid) -> - case ets:lookup(Db#data.procs, Pid) of - [{_,{_,Name}}] -> atom_to_list(Name)++" : "++pid_to_list(Pid); - [{_,{_,Name},_}] -> atom_to_list(Name)++" : "++pid_to_list(Pid); - _ -> pid_to_list(Pid) - end; -get_link_name({_,Port,_}, _Db) when is_port(Port) -> - "Port :"++" : "; -get_link_name(_, _) -> - "". - -%% Sort the links in the order they where added, in ascending order. -sort_order({_,_,N1}, {_,_,N2}) when N1>N2 -> true; -sort_order(_N1, _N2) -> false. - -%% Select the pid of the application master. -get_master(Db) -> - case ets:match_object(Db#data.procs, - {'_',{master,master},controller}) of - [{Pid,_,_}|_Rest] -> Pid; - _ -> no - end. - -%% The main function to handle tracing. -%% Checks if the process is in the table with traced processes. If so, -%% it stops the trace, otherwise it starts the trace. -do_send_trace(PidL, Traced_tab) -> - Pid = list_to_pid(PidL), - Key = get_key(Pid), - case catch ets:lookup(Traced_tab, Key) of - [] -> - trace_process(Pid, Key, true, Traced_tab); - [_Object]-> - trace_process(Pid, Key, false, Traced_tab) - end, - filter_procs(Traced_tab, ets:tab2list(Traced_tab)). - -get_key(Pid) -> - Node = node(Pid), - case rpc:call(Node, erlang, process_info, [Pid,registered_name]) of - [] -> pid_to_list(Pid); - {registered_name, Name} -> - atom_to_list(Name)++" : "++pid_to_list(Pid) - end. - -%% Tries to toggle the trace flag for the process. -trace_process(Pid, Key, On_or_off, Procs_tab) -> - case rpc:call(node(Pid), sys, trace, [Pid,On_or_off,1000]) of - timeout -> - Node = node(Pid), - io:fwrite("timeout node= ~w, Pid= ~w mode= ~w ~n", - [Node, Pid, On_or_off]); - {badrpc, _} -> - Node = node(Pid), - io:fwrite("badrpc node= ~w, Pid= ~w mode= ~w ~n", - [Node, Pid, On_or_off]); - Res -> - Node = node(Pid), - io:fwrite("anymode ~w node= ~w, Pid= ~w mode= ~w ~n", - [Res, Node, Pid,On_or_off]), - case On_or_off of - true -> ets:insert(Procs_tab, {Key,On_or_off}); - false -> ets:delete(Procs_tab, Key) - end - end. - -%% Check if the processes in the ets table with traced processes -%% are alive. If not, remove them. -filter_procs(Tab, Tab_list) -> - lists:foreach(fun({Key,_Val}) -> is_alive(Key, Tab) end, Tab_list). - -is_alive(Key, Tab) -> - case get_pid(Key) of - nopid -> false; - Pid -> is_alive2(Pid, Key, Tab) - end. - -%% Key is either a pid in list form or Pidname:Pid in list form. -get_pid(Key) -> - case catch list_to_pid(string:substr(Key,string:rchr(Key,$<))) of - Pid when is_pid(Pid) -> - Pid; - _ -> - nopid - end. - -is_alive2(Pid, Key, Tab) -> - case catch rpc:call(node(Pid), erlang, is_process_alive, [Pid]) of - true -> true; - false -> - catch ets:delete(Tab, Key), - ok - end. |