crashdump_translate.erl

来自「OTP是开放电信平台的简称」· ERL 代码 · 共 1,132 行 · 第 1/3 页

	    translate_internal_tables(Read,Write,AtomSpace)
    end.

translate_hash_table(Write,Line) ->
    Rest1 = translate_internal_table_line(Write,Line,"=hash_table:", ", size"),
    Rest2 = translate_internal_table_line(Write,Rest1,"size: ", ", used"),
    Rest3 = translate_internal_table_line(Write,Rest2,"used: ", ", objs"),
    Rest4 = translate_internal_table_line(Write,Rest3,"objs: ", ", depth"),
    translate_internal_table_line(Write, Rest4, "depth: ", []).
				    
translate_index_table(Write,Line) ->
    Rest1 = translate_internal_table_line(Write,Line,"=index_table:",", size"),
    Rest2 = translate_internal_table_line(Write,Rest1,"size: ", ", limit"),
    Rest3 = translate_internal_table_line(Write,Rest2,"limit: ", ", used"),
    Rest4 = translate_internal_table_line(Write,Rest3,"used: ", ", rate"),
    translate_internal_table_line(Write, Rest4, "rate: ", []).

translate_internal_table_line(Write,Line,ThisHeading,NextMatch) ->
    Rest1 = copy_word(Write,Line,$),ThisHeading),
    case split($(,Rest1) of
	{NextMatch,Rest2} when Rest2=/=[]; NextMatch=:=[] ->
	    Rest2;
	{_Other,_Rest2} ->
	    truncated(Rest1)
    end.
	    
translate_allocated_areas(Read,Write,Line,{Used,Allocated}) ->
    write(Write,["=allocated_areas\natom_space: ",Allocated," ",Used,"\n"]),
    translate_allocated_areas(Read,Write,Line).

translate_allocated_areas(Read,Write,Line) ->
    {Truncated,InputLine} = 
	case Line of
	    {eof,InputLine0} -> {true,InputLine0};
	    InputLine0 -> {false,InputLine0}
	end,
    case InputLine of
    	?divider ->
	    ok;
	"Allocated by " ++ Rest ->
	    {Tag,Value} = split(Rest),
	    write(Write,[Tag,": ",Value]),
	    translate_allocated_areas(Read,Write,line(Read));
	"Allocated binary data " ++ Value -> % R8B/R9B
	    write(Write,["binary: ",Value]),
	    translate_allocated_areas(Read,Write,line(Read));
	"Allocated binary " ++ Value ->      % R7B
	    write(Write,["binary: ",Value]),
	    translate_allocated_areas(Read,Write,line(Read));
	"Totally allocated " ++ Value ->     % R7B
	    write(Write,["total: ",Value]),
	    translate_allocated_areas(Read,Write,line(Read));	    
	"Maximum allocated " ++ Value ->     % R7B
	    write(Write,["maximum: ",Value]),
	    translate_allocated_areas(Read,Write,line(Read));	    
	PartOfLine when Truncated ->
	    truncated(PartOfLine);
	Unexpected ->
	    unexpected(Unexpected),
	    translate_allocated_areas(Read,Write,line(Read))
    end.
	
translate_memory_and_allocated_area_r9b(Read,Write,AtomSpace) ->
    {Truncated,InputLine} = 
	case line(Read) of
	    {eof,InputLine0} -> {true,InputLine0};
	    InputLine0 -> {false,InputLine0}
	end,
    case InputLine of
	"Misc allocated areas (bytes):\n" ->
	    write(Write,"=allocated_areas\n"),
	    translate_memory_and_allocated_area_r9b(Read,Write,AtomSpace);
	"sl_alloc: ver(" ++ Rest ->
	    translate_sl_alloc(Read,Write,Rest,AtomSpace);
	"sl_alloc: disabled\n" ->
	    write(Write,"=allocator:sl_alloc\noption e: false\n");
	PartOfLine when Truncated ->
	    write(Write,PartOfLine),
	    truncated();
	Line ->
	    write(Write,Line),
	    translate_memory_and_allocated_area_r9b(Read,Write,AtomSpace)
    end.

translate_sl_alloc(Read,Write,Vsn0,AtomSpace) ->
    {Vsn,_} = split($),Vsn0),
    write(Write,["=allocator:sl_alloc\nversion: ",Vsn,"\noption e: true\n"]),
    do_translate_sl_alloc(Read,Write,AtomSpace,undefined).

do_translate_sl_alloc(Read,Write,AtomSpace,SbcOrMbc) ->
    Line = line(Read),
    {Truncated,InputLine} = 
	case Line of
	    {eof,InputLine0} -> {true,InputLine0};
	    InputLine0 -> {false,InputLine0}
	end,
    case InputLine of
	?divider ->
	    ok;
	"Allocated " ++ _ ->
	    translate_allocated_areas(Read,Write,Line,AtomSpace);
	"          sbc: cno(" ++ Rest1 ->
	    Rest2 = copy_word(Write,Rest1,$:,"no of sbcs: "),
	    case copy_word(Write,Rest2,$),"no of seg sbcs: ") of
		", csz(" ++ Rest3 ->
		    Rest4 = copy_word(Write,Rest3,$:,"sbcs size: "),
		    _Rest5 = copy_word(Write,Rest4,$),"seg sbcs size: ");
		PartOfLine when Truncated ->
		    truncated(PartOfLine)
	    end,
	    do_translate_sl_alloc(Read,Write,AtomSpace,"sbc");
	"               mcno(" ++ Rest ->
	    translate_sl_alloc_line(Write,Rest,
				    [["max no of ",SbcOrMbc,"s: "],
				     ["max ",SbcOrMbc,"s size: "]], 
				    [", mcsz"]),
	    do_translate_sl_alloc(Read,Write,AtomSpace,SbcOrMbc);
	"               bno(" ++ Rest ->
	    translate_sl_alloc_line(Write,Rest,
				    [["no of ",SbcOrMbc," blocks: "],
				     [SbcOrMbc," blocks size: "],
				     [SbcOrMbc," blocks adm size: "]],
				    [", bsz",", asz"]),
	    do_translate_sl_alloc(Read,Write,AtomSpace,SbcOrMbc);
	"               mbno(" ++ Rest ->
	    translate_sl_alloc_line(Write,Rest,
				    [["max no of ",SbcOrMbc," blocks: "],
				     ["max ",SbcOrMbc," block size: "]], 
				    [", mbsz"]),
	    do_translate_sl_alloc(Read,Write,AtomSpace,SbcOrMbc);
	"          mbc: cno(" ++ Rest1 ->
	    Rest2 = copy_word(Write,Rest1,$:,"no of mbcs: "),
	    case copy_word(Write,Rest2,$),"no of seg mbcs: ") of
		", csz(" ++ Rest3 ->
		    Rest4 = copy_word(Write,Rest3,$:,"mbcs size: "),
		    _Rest5 = copy_word(Write,Rest4,$),"seg mbcs size: ");
		PartOfLine when Truncated ->
		    truncated(PartOfLine)
	    end,
	    do_translate_sl_alloc(Read,Write,AtomSpace,"mbc");
	PartOfLine when Truncated ->
	    truncated(PartOfLine);
	Unexpected ->
	    unexpected(Unexpected),
	    do_translate_sl_alloc(Read,Write,AtomSpace,SbcOrMbc)
    end.
	    
	    

translate_sl_alloc_line(Write,Rest1,[Heading|Headings],[Match|Matches]) ->
    Rest2 = copy_word(Write,Rest1,$),Heading),
    case split($(,Rest2) of
	{Match,Rest3} when Rest2=/=[] ->
	    translate_sl_alloc_line(Write,Rest3,Headings,Matches);
	{_Other,_Rest3} ->
	    truncated(Rest2)
    end;
translate_sl_alloc_line(Write,Rest1,[Heading],[]) ->
    copy_word(Write,Rest1,$),Heading).
    

translate_sl_alloc_r7_r8(Write,Heading,Line) ->
    write(Write,["=allocator:sl_alloc\nversion: release2\n"]),
    do_translate_sl_alloc_r7_r8(Write,Heading,Line).

do_translate_sl_alloc_r7_r8(Write,Heading1,Line) ->
    case split($),Line) of
	{Value,", " ++ Rest1} ->
	    write(Write,[Heading1,": ",Value,"\n"]),
	    case split($(,Rest1) of
		{Heading2,Rest2} when Rest2=/=[] ->
		    do_translate_sl_alloc_r7_r8(Write,Heading2,Rest2);
		_ ->
		    truncated(Rest1)
	    end;
	{Value,"\n"} ->
	    write(Write,[Heading1,": ",Value,"\n"]);
	_ ->
	    truncated(Line)
    end.

translate_ets_tables(Read,Write) ->
    case line(Read) of
	"In slot " ++ Slot ->
	    translate_ets(Read,Write,["Slot: ",Slot]);
	"\n" ->
	    ok;
	{eof,PartOfLine} ->
	    truncated(PartOfLine)
    end.

translate_ets(Read,Write,Acc) ->
    case line(Read) of
	"Table " ++ Rest1 = Line ->
	    case split($(,Rest1) of
		{Table,"with name)"++NameNl} ->
		    translate_ets(Read,Write,
				  [Acc,"Table: ",Table,"\n","Name: ",NameNl]);
		_ ->
		    truncated(Line)
	    end;
	"Owner " ++ OwnerNl ->
	    write(Write,["=ets:",OwnerNl,Acc]),
	    translate_ets(Read,Write,"");
	"Table's got " ++ Got ->
	    case split(Got) of
		{Objects,"objects\n"} -> 
		    write(Write,["Objects: ",Objects,"\n"]);
		{Words,"words of active data\n"} ->
		    write(Write,["Words: ",Words,"\n"])
	    end,
	    translate_ets(Read,Write,Acc);
	"\n" ->
	    translate_ets_tables(Read,Write);
	{eof,PartOfLine} ->
	    case Acc of
		"" -> ok;
		Acc -> write(Write,["=ets:unknown\n",Acc])
	    end,
	    truncated(PartOfLine);
	Line ->
	    write(Write,Line),
	    translate_ets(Read,Write,Acc)
    end.

translate_timers(Read,Write) ->
    {Truncated,InputLine} = 
	case line(Read) of
	    {eof,InputLine0} -> {true,InputLine0};
	    InputLine0 -> {false,InputLine0}
	end,
    case InputLine of
	?divider ->
	    ok;
	"message=" ++ Rest1 ->
	    {Msg,Rest2} = get_msg(Rest1,Truncated,[]),
	    case split($,,Rest2) of
		{Pid," time left " ++ TimeLeftNl} when not Truncated  ->
		    write(Write,["=timer:",Pid,"\n",
				 "Message: ",Msg,"\n",
				 "Time left: ",TimeLeftNl]),
		    translate_timers(Read,Write);
		{[],[]} ->
		    write(Write,["=timer:unknown\n",
				 "Message: ",Msg,"\n"]),
		    truncated();
		{PartOfPid,[]} ->
		    write(Write,["=timer:",PartOfPid,"\n",
				 "Message: ",Msg,"\n"]),
		    truncated();
		{Pid,PartOfLine} when Truncated  ->
		    write(Write,["=timer:",Pid,"\n",
				 "Message: ",Msg,"\n"]),
		    truncated(PartOfLine);
		{_,_} ->
		    unexpected(Rest2),
		    translate_timers(Read,Write)
		end;
	PartOfLine when Truncated ->
	    truncated(PartOfLine);
	Unexpected ->
	    unexpected(Unexpected),
	    translate_timers(Read,Write)
    end.

get_msg(Str,Truncated,Acc) ->
    case split($,,Str) of
	{RestOfMsg," pid=" ++ Rest} ->
	    [$,|Msg] = lists:reverse([RestOfMsg,$,|Acc]),
	    {Msg,Rest};
	{PartOfMsg,Rest} when Truncated ->
	    {PartOfMsg,Rest};
	{PartOfMsg,Rest} ->
	    get_msg(Rest,Truncated,[PartOfMsg,$,|Acc])
    end.
    

translate_dist_info(Read,Write) ->
    case line(Read) of
	"------------------------\n" ->
	    translate_dist_info2(Read,Write,"=visible_node:");
	"Not alive\n" ->
	    write(Write,"=no_distribution\n");
	{eof,PartOfLine} ->
	    truncated(PartOfLine)
    end.
	    
translate_dist_info2(Read,Write,Tag) ->
    {Truncated,InputLine} = 
	case line(Read) of
	    {eof,InputLine0} -> {true,InputLine0};
	    InputLine0 -> {false,InputLine0}
	end,    
    case InputLine of
	"Alive but not holding any connections \n" ->
	    ok;
	"-- Visible nodes -------\n" ->
	    drop_line(Read), % divider
	    translate_node_info(Read,Write,line(Read),"=visible_node:"),
	    translate_dist_info2(Read,Write,Tag);
	"-- Hidden nodes --------\n" ->
	    drop_line(Read), % divider
	    translate_node_info(Read,Write,line(Read),"=hidden_node:"),
	    translate_dist_info2(Read,Write,Tag);
	"-- Not connected -------\n" ->		    
	    drop_line(Read), % divider
	    translate_node_info(Read,Write,line(Read),"=not_connected:"),
	    translate_dist_info2(Read,Write,Tag);
	"\n" ->
	    ok; % all nodes done
	"------------------------\n" ->
	    translate_dist_info2(Read,Write,Tag);
	TruncText when Truncated ->
	    truncated(TruncText);
	Node ->
	    translate_node_info(Read,Write,Node,Tag),
	    translate_dist_info2(Read,Write,Tag)
    end.


translate_node_info(Read,Write,Node,Tag) ->    
    case copy_word(Write,Node,$ ,Tag) of
	": Connection to:" ++ Rest1 ->
	    case copy_word(Write,Rest1,$ ,"Name: ") of
		"Controller:"++Rest2 ->
		    %% Here (_Rest3) i might be throwing away some 
		    %% info about cookies (R7/R8)!!
		    _Rest3 = copy_word(Write,Rest2,$ ,"Controller: "),
		    translate_node_info2(Read,Write,Tag);
		Unexpected ->
		    unexpected(Unexpected),
		    %% Would never come here if truncated, and I know
		    %% it's a node - so I'll just dive into it.
		    translate_node_info2(Read,Write,Tag)
	    end;
	": " ++ Name ->
	    write(Write,["Name: ",Name]),
	    translate_node_info2(Read,Write,Tag);
	Unexpected ->
	    %% dont know what to do, so I can't dive further into this
	    unexpected(Unexpected)
    end.

translate_node_info2(Read,Write,Tag) ->
    {Truncated,InputLine} = 
	case line(Read) of
	    {eof,InputLine0} -> {true,InputLine0};
	    InputLine0 -> {false,InputLine0}
	end,
    case InputLine of
	"Creation: " ++ _ = CreationNl ->
	    get_all_creations(Read,Write,CreationNl),
	    translate_node_info2(Read,Write,Tag);
	"Processes holding remote links to " ++ _node -> % R7/R8
	    translate_links(Read,Write,Tag);
	"Remote links and monitors to/from " ++ _node -> % R9
	    translate_links(Read,Write,Tag);
	"error .. " ++ Error ->
	    write(Write,["Error: ",Error]),
	    translate_node_info2(Read,Write,Tag);
	"------------------------\n" ->
	    ok;
	"\n" ->
	    translate_node_info2(Read,Write,Tag);
	PartOfLine when Truncated ->
	    truncated(PartOfLine);
	Unexpected ->
	    unexpected(Unexpected),
	    translate_node_info2(Read,Write,Tag)
    end.


get_all_creations(Read,Write,Creation) ->
    {Truncated,InputLine} = 
	case line(Read) of
	    {eof,InputLine0} -> {true,InputLine0};
	    InputLine0 -> {false,InputLine0}
	end,