From 84adefa331c4159d432d22840663c38f155cd4c1 Mon Sep 17 00:00:00 2001 From: Erlang/OTP Date: Fri, 20 Nov 2009 14:54:40 +0000 Subject: The R13B03 release. --- lib/debugger/src/dbg_iserver.erl | 606 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 606 insertions(+) create mode 100644 lib/debugger/src/dbg_iserver.erl (limited to 'lib/debugger/src/dbg_iserver.erl') diff --git a/lib/debugger/src/dbg_iserver.erl b/lib/debugger/src/dbg_iserver.erl new file mode 100644 index 0000000000..4c1e9ccb7b --- /dev/null +++ b/lib/debugger/src/dbg_iserver.erl @@ -0,0 +1,606 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1998-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(dbg_iserver). +-behaviour(gen_server). + +%% External exports +-export([start/0, stop/0, find/0, + call/1, call/2, cast/1, cast/2, safe_call/1, safe_cast/1]). + +%% gen_server callbacks +-export([init/1, handle_call/3, handle_cast/2, handle_info/2, + terminate/2, code_change/3]). + +-record(proc, {pid, % pid() Debugged process + meta, % pid() Meta process + attpid, % pid() | undefined Attached process + status, % running | exit | idle | waiting + info = {}, % {} | term() + exit_info= {}, % {} | {{Mod,Line}, Bs, Stack} + function % {Mod,Func,Args} Initial function call + }). + +-record(state, {db, % ETS table + procs = [], % [#proc{}] + breaks = [], % [{{M,L},Options} Breakpoints + auto, % Auto attach settings + stack, % Stack trace settings + subs = [] % [pid()] Subscribers (Debugger) + }). + + +%%==================================================================== +%% External exports +%%==================================================================== + +start() -> + gen_server:start({local, ?MODULE}, ?MODULE, [], []). + +stop() -> + gen_server:cast(?MODULE, stop). + +find() -> + global:whereis_name(?MODULE). + +call(Request) -> + gen_server:call(?MODULE, Request, infinity). + +call(Int, Request) -> + gen_server:call(Int, Request, infinity). + +cast(Request) -> + gen_server:cast(?MODULE, Request). + +cast(Int, Request) -> + gen_server:cast(Int, Request). + +safe_call(Request) -> + ensure_started(), + call(Request). + +safe_cast(Request) -> + ensure_started(), + cast(Request). + +ensure_started() -> + case whereis(?MODULE) of + undefined -> start(); + _Pid -> ignore + end. + +%%--Module database--------------------------------------------------- +%% This server creates an ETS table, where the following information +%% is saved: +%% +%% Key Value +%% --- ----- +%% {Mod, refs} [ModDb] +%% ModDb [pid()] +%% +%% In each ModDb, the following information is saved by dbg_iload: +%% +%% Key Value +%% --- ----- +%% attributes Attr +%% exports Exp +%% defs [] +%% mod_bin Binary +%% mod_raw Raw Binary +%% mod_file File +%% module Mod +%% {Mod,Name,Arity,Exported} Cs +%% {'fun',Mod,Index,Uniq} {Name,Arity,Cs} +%% Line {Pos,PosNL} + + +%%==================================================================== +%% gen_server callbacks +%%==================================================================== + +init([]) -> + process_flag(trap_exit, true), + global:register_name(?MODULE, self()), + Db = ets:new(?MODULE, [ordered_set, protected]), + {ok, #state{db=Db, auto=false, stack=all}}. + +%% Attaching to a process +handle_call({attached, AttPid, Pid}, _From, State) -> + {true, Proc} = get_proc({pid, Pid}, State#state.procs), + case Proc#proc.attpid of + undefined -> + link(AttPid), + case Proc#proc.status of + exit -> + Args = [self(), + AttPid,Pid,Proc#proc.info, + Proc#proc.exit_info], + Meta = spawn_link(dbg_ieval, exit_info, Args), + Proc2 = Proc#proc{meta=Meta, attpid=AttPid}, + Procs = lists:keyreplace(Pid, #proc.pid, + State#state.procs, Proc2), + {reply, {ok,Meta}, State#state{procs=Procs}}; + _Status -> + Meta = Proc#proc.meta, + send(Meta, {attached, AttPid}), + Procs = lists:keyreplace(Pid, #proc.pid, + State#state.procs, + Proc#proc{attpid=AttPid}), + {reply, {ok, Meta}, State#state{procs=Procs}} + end; + _AttPid -> % there is already an attached process + {reply, error, State} + end; + +%% Getting and setting options +handle_call(get_auto_attach, _From, State) -> + {reply, State#state.auto, State}; +handle_call(get_stack_trace, _From, State) -> + {reply, State#state.stack, State}; + +%% Retrieving information +handle_call(snapshot, _From, State) -> + Reply = lists:map(fun(Proc) -> + {Proc#proc.pid, Proc#proc.function, + Proc#proc.status, Proc#proc.info} + end, + State#state.procs), + {reply, Reply, State}; +handle_call({get_meta, Pid}, _From, State) -> + Reply = case get_proc({pid, Pid}, State#state.procs) of + {true, Proc} -> + {ok, Proc#proc.meta}; + false -> + {error, not_interpreted} + end, + {reply, Reply, State}; +handle_call({get_attpid, Pid}, _From, State) -> + Reply = case get_proc({pid, Pid}, State#state.procs) of + {true, Proc} -> + {ok, Proc#proc.attpid}; + false -> + {error, not_interpreted} + end, + {reply, Reply, State}; + + +%% Breakpoint handling +handle_call({new_break, Point, Options}, _From, State) -> + case lists:keysearch(Point, 1, State#state.breaks) of + false -> + Break = {Point, Options}, + send_all([subscriber, meta, attached], + {new_break, Break}, State), + Breaks = keyinsert(Break, 1, State#state.breaks), + {reply, ok, State#state{breaks=Breaks}}; + {value, _Break} -> + {reply, {error, break_exists}, State} + end; +handle_call(all_breaks, _From, State) -> + {reply, State#state.breaks, State}; +handle_call({all_breaks, Mod}, _From, State) -> + Reply = lists:filter(fun({{M,_L}, _Options}) -> + if M==Mod -> true; true -> false end + end, + State#state.breaks), + {reply, Reply, State}; + +%% From Meta process +handle_call({new_process, Pid, Meta, Function}, _From, State) -> + link(Meta), + + %% A new, debugged process has been started. Return its status, + %% ie running (running as usual) or break (stop) + %% The status depends on if the process is automatically attached to + %% or not. + Reply = case auto_attach(init, State#state.auto, Pid) of + AttPid when is_pid(AttPid) -> break; + ignore -> running + end, + + %% Do not add AttPid, it should call attached/2 when started instead + Proc = #proc{pid=Pid, meta=Meta, status=running, function=Function}, + send_all(subscriber, + {new_process, {Pid,Function,running,{}}}, State), + + {reply, Reply, State#state{procs=State#state.procs++[Proc]}}; + +%% Code loading +handle_call({load, Mod, Src, Bin}, _From, State) -> + + %% Create an ETS table for storing information about the module + Db = State#state.db, + ModDb = ets:new(Mod, [ordered_set, public]), + ModDbs = case ets:lookup(Db, {Mod, refs}) of + [] -> []; + [{{Mod, refs}, ModDbs1}] -> ModDbs1 + end, + ets:insert(Db, {{Mod, refs}, [ModDb|ModDbs]}), + ets:insert(Db, {ModDb, []}), + + %% Load the code + {ok, Mod} = dbg_iload:load_mod(Mod, Src, Bin, ModDb), + + %% Inform all subscribers and attached processes + send_all([subscriber, attached], {interpret, Mod}, State), + + {reply, {module, Mod}, State}; + +%% Module database +handle_call({get_module_db, Mod, Pid}, _From, State) -> + Db = State#state.db, + Reply = case ets:lookup(Db, {Mod, refs}) of + [] -> not_found; + [{{Mod, refs}, [ModDb|_ModDbs]}] -> + [{ModDb, Pids}] = ets:lookup(Db, ModDb), + ets:insert(Db, {ModDb, [Pid|Pids]}), + ModDb + end, + {reply, Reply, State}; +handle_call({lookup, Mod, Key}, _From, State) -> + Db = State#state.db, + Reply = case ets:lookup(Db, {Mod, refs}) of + [] -> not_found; + [{{Mod, refs}, [ModDb|_ModDbs]}] -> + case ets:lookup(ModDb, Key) of + [] -> not_found; + [{Key, Value}] -> {ok, Value} + end + end, + {reply, Reply, State}; +handle_call({functions, Mod}, _From, State) -> + Db = State#state.db, + Reply = case ets:lookup(Db, {Mod, refs}) of + [] -> []; + [{{Mod, refs}, [ModDb|_ModDbs]}] -> + Pattern = {{Mod,'$1','$2','_'}, '_'}, + ets:match(ModDb, Pattern) + end, + {reply, Reply, State}; +handle_call({contents, Mod, Pid}, _From, State) -> + Db = State#state.db, + [{{Mod, refs}, ModDbs}] = ets:lookup(Db, {Mod, refs}), + ModDb = if + Pid==any -> hd(ModDbs); + true -> + lists:foldl(fun(T, not_found) -> + [{T, Pids}] = ets:lookup(Db, T), + case lists:member(Pid, Pids) of + true -> T; + false -> not_found + end; + (_T, T) -> T + end, + not_found, + ModDbs) + end, + [{mod_bin, Bin}] = ets:lookup(ModDb, mod_bin), + {reply, {ok, Bin}, State}; +handle_call({raw_contents, Mod, Pid}, _From, State) -> + Db = State#state.db, + [{{Mod, refs}, ModDbs}] = ets:lookup(Db, {Mod, refs}), + ModDb = if + Pid==any -> hd(ModDbs); + true -> + lists:foldl(fun(T, not_found) -> + [{T, Pids}] = ets:lookup(Db, T), + case lists:member(Pid, Pids) of + true -> T; + false -> not_found + end; + (_T, T) -> T + end, + not_found, + ModDbs) + end, + [{mod_raw, Bin}] = ets:lookup(ModDb, mod_raw), + {reply, {ok, Bin}, State}; +handle_call({is_interpreted, Mod, Name, Arity}, _From, State) -> + Db = State#state.db, + Reply = case ets:lookup(Db, {Mod, refs}) of + [] -> false; + [{{Mod, refs}, [ModDb|_ModDbs]}] -> + Pattern = {{Mod,Name,Arity,'_'}, '_'}, + case ets:match_object(ModDb, Pattern) of + [{_Key, Clauses}] -> {true, Clauses}; + [] -> false + end + end, + {reply, Reply, State}; +handle_call(all_interpreted, _From, State) -> + Db = State#state.db, + Mods = ets:select(Db, [{{{'$1',refs},'_'},[],['$1']}]), + {reply, Mods, State}; +handle_call({file, Mod}, From, State) -> + {reply, Res, _} = handle_call({lookup, Mod, mod_file}, From, State), + Reply = case Res of + {ok, File} -> File; + not_found -> {error, not_loaded} + end, + {reply, Reply, State}. + + +handle_cast(stop, State) -> + {stop, shutdown, State}; +handle_cast({subscribe, Sub}, State) -> + {noreply, State#state{subs=[Sub|State#state.subs]}}; + +%% Attaching to a process +handle_cast({attach, Pid, {Mod, Func, Args}}, State) -> + %% Simply spawn process, which should call int:attached(Pid) + spawn(Mod, Func, [Pid | Args]), + {noreply, State}; + +%% Getting and setting options +handle_cast({set_auto_attach, false}, State) -> + send_all(subscriber, {auto_attach, false}, State), + {noreply, State#state{auto=false}}; +handle_cast({set_auto_attach, Flags, Function}, State) -> + send_all(subscriber, {auto_attach, {Flags, Function}}, State), + {noreply, State#state{auto={Flags, Function}}}; +handle_cast({set_stack_trace, Flag}, State) -> + send_all(subscriber, {stack_trace, Flag}, State), + {noreply, State#state{stack=Flag}}; + +%% Retrieving information +handle_cast(clear, State) -> + Procs = lists:filter(fun(#proc{status=Status}) -> + if Status==exit -> false; true -> true end + end, + State#state.procs), + {noreply, State#state{procs=Procs}}; + +%% Breakpoint handling +handle_cast({delete_break, Point}, State) -> + case lists:keysearch(Point, 1, State#state.breaks) of + {value, _Break} -> + send_all([subscriber, meta, attached], + {delete_break, Point}, State), + Breaks = lists:keydelete(Point, 1, State#state.breaks), + {noreply, State#state{breaks=Breaks}}; + false -> + {noreply, State} + end; +handle_cast({break_option, Point, Option, Value}, State) -> + case lists:keysearch(Point, 1, State#state.breaks) of + {value, {Point, Options}} -> + N = case Option of + status -> 1; + action -> 2; + condition -> 4 + end, + Options2 = list_setelement(N, Options, Value), + send_all([subscriber, meta, attached], + {break_options, {Point, Options2}}, State), + Breaks = lists:keyreplace(Point, 1, State#state.breaks, + {Point, Options2}), + {noreply, State#state{breaks=Breaks}}; + false -> + {noreply, State} + end; +handle_cast(no_break, State) -> + send_all([subscriber, meta, attached], no_break, State), + {noreply, State#state{breaks=[]}}; +handle_cast({no_break, Mod}, State) -> + send_all([subscriber, meta, attached], {no_break, Mod}, State), + Breaks = lists:filter(fun({{M, _L}, _O}) -> + if M==Mod -> false; true -> true end + end, + State#state.breaks), + {noreply, State#state{breaks=Breaks}}; + +%% From Meta process +handle_cast({set_status, Meta, Status, Info}, State) -> + {true, Proc} = get_proc({meta, Meta}, State#state.procs), + send_all(subscriber, {new_status, Proc#proc.pid, Status, Info}, State), + if + Status==break -> + auto_attach(break, State#state.auto, Proc); + true -> ignore + end, + Proc2 = Proc#proc{status=Status, info=Info}, + {noreply, State#state{procs=lists:keyreplace(Meta, #proc.meta, + State#state.procs, Proc2)}}; +handle_cast({set_exit_info, Meta, ExitInfo}, State) -> + {true, Proc} = get_proc({meta, Meta}, State#state.procs), + Procs = lists:keyreplace(Meta, #proc.meta, State#state.procs, + Proc#proc{exit_info=ExitInfo}), + {noreply,State#state{procs=Procs}}; + +%% Code loading +handle_cast({delete, Mod}, State) -> + + %% Remove the ETS table with information about the module + Db = State#state.db, + case ets:lookup(Db, {Mod, refs}) of + [] -> % Mod is not interpreted + {noreply, State}; + [{{Mod, refs}, ModDbs}] -> + ets:delete(Db, {Mod, refs}), + AllPids = lists:foldl( + fun(ModDb, PidsAcc) -> + [{ModDb, Pids}] = ets:lookup(Db, ModDb), + ets:delete(Db, ModDb), + ets:delete(ModDb), + PidsAcc++Pids + end, + [], + ModDbs), + lists:foreach(fun(Pid) -> + case get_proc({pid, Pid}, + State#state.procs) of + {true, Proc} -> + send(Proc#proc.meta, + {old_code, Mod}); + false -> ignore % pid may have exited + end + end, + AllPids), + + send_all([subscriber,attached], {no_interpret, Mod}, State), + + %% Remove all breakpoints for Mod + handle_cast({no_break, Mod}, State) + end. + +%% Process exits +handle_info({'EXIT',Who,Why}, State) -> + case get_proc({meta, Who}, State#state.procs) of + + %% Exited process is a meta process for exit_info + {true,#proc{status=exit}} -> + {noreply,State}; + + %% Exited process is a meta process + {true,Proc} -> + Pid = Proc#proc.pid, + ExitInfo = Proc#proc.exit_info, + %% Check if someone is attached to the debugged process, + %% if so a new meta process should be started + Meta = case Proc#proc.attpid of + AttPid when is_pid(AttPid) -> + spawn_link(dbg_ieval, exit_info, + [self(),AttPid,Pid,Why,ExitInfo]); + undefined -> + %% Otherwise, auto attach if necessary + auto_attach(exit, State#state.auto, Pid), + Who + end, + send_all(subscriber, {new_status,Pid,exit,Why}, State), + Procs = lists:keyreplace(Who, #proc.meta, State#state.procs, + Proc#proc{meta=Meta, + status=exit, + info=Why}), + {noreply,State#state{procs=Procs}}; + + false -> + case get_proc({attpid, Who}, State#state.procs) of + + %% Exited process is an attached process + {true, Proc} -> + %% If status==exit, then the meta process is a + %% simple meta for a terminated process and can be + %% terminated as well (it is only needed by + %% the attached process) + case Proc#proc.status of + exit -> send(Proc#proc.meta, stop); + _Status -> send(Proc#proc.meta, detached) + end, + Procs = lists:keyreplace(Proc#proc.pid, #proc.pid, + State#state.procs, + Proc#proc{attpid=undefined}), + {noreply, State#state{procs=Procs}}; + + %% Otherwise exited process must be a subscriber + false -> + Subs = lists:delete(Who, State#state.subs), + {noreply, State#state{subs=Subs}} + end + end. + +terminate(_Reason, _State) -> + EbinDir = filename:join(code:lib_dir(debugger), "ebin"), + code:unstick_dir(EbinDir), + ok. + +code_change(_OldVsn, State, _Extra) -> + {ok, State}. + + +%%==================================================================== +%% Internal functions +%%==================================================================== + +auto_attach(Why, Auto, Proc) when is_record(Proc, proc) -> + case Proc#proc.attpid of + AttPid when is_pid(AttPid) -> ignore; + undefined -> + auto_attach(Why, Auto, Proc#proc.pid) + end; +auto_attach(Why, Auto, Pid) when is_pid(Pid) -> + case Auto of + false -> ignore; + {Flags, {Mod, Func, Args}} -> + case lists:member(Why, Flags) of + true -> + spawn(Mod, Func, [Pid | Args]); + false -> ignore + end + end. + +keyinsert(Tuple1, N, [Tuple2|Tuples]) -> + if + element(N, Tuple1) + [Tuple1, Tuple2|Tuples]; + true -> + [Tuple2 | keyinsert(Tuple1, N, Tuples)] + end; +keyinsert(Tuple, _N, []) -> + [Tuple]. + +list_setelement(N, L, E) -> list_setelement(1, N, L, E). + +list_setelement(I, I, [_|T], E) -> + [E|T]; +list_setelement(I, N, [H|T], E) -> + [H|list_setelement(I+1, N, T, E)]. + +mapfilter(Fun, [H|T]) -> + case Fun(H) of + ignore -> mapfilter(Fun, T); + H2 -> [H2|mapfilter(Fun, T)] + end; +mapfilter(_Fun, []) -> + []. + +send_all([Type|Types], Msg, State) -> + send_all(Type, Msg, State), + send_all(Types, Msg, State); +send_all([], _Msg, _State) -> ok; + +send_all(subscriber, Msg, State) -> + send_all(State#state.subs, Msg); +send_all(meta, Msg, State) -> + Metas = lists:map(fun(Proc) -> Proc#proc.meta end, State#state.procs), + send_all(Metas, Msg); +send_all(attached, Msg, State) -> + AttPids= mapfilter(fun(Proc) -> + case Proc#proc.attpid of + Pid when is_pid(Pid) -> Pid; + undefined -> ignore + end + end, + State#state.procs), + send_all(AttPids, Msg). + +send_all(Pids, Msg) -> + lists:foreach(fun(Pid) -> send(Pid, Msg) end, Pids). + +send(Pid, Msg) -> + Pid ! {int, Msg}. + +get_proc({Type, Pid}, Procs) -> + Index = case Type of + pid -> #proc.pid; + meta -> #proc.meta; + attpid -> #proc.attpid + end, + case lists:keysearch(Pid, Index, Procs) of + {value, Proc} -> {true, Proc}; + false -> false + end. -- cgit v1.2.3