common.h revision cec06ec8282c538a40bde968ae36fe8356daffaa 
1#ifndef COMMON_H
2#define COMMON_H
3
4#include <config.h>
5#if defined(HAVE_LIBUNWIND)
6#include <libunwind.h>
7#endif /* defined(HAVE_LIBUNWIND) */
8
9#include <sys/types.h>
10#include <sys/time.h>
11#include <stdio.h>
12
13#include "ltrace.h"
14#include "defs.h"
15#include "dict.h"
16#include "sysdep.h"
17#include "debug.h"
18#include "ltrace-elf.h"
19#include "read_config_file.h"
20
21#if defined HAVE_LIBIBERTY || defined HAVE_LIBSUPC__
22# define USE_DEMANGLE
23#endif
24
25extern char * command;
26
27extern int exiting;  /* =1 if we have to exit ASAP */
28
29typedef struct Breakpoint Breakpoint;
30struct Breakpoint {
31	void * addr;
32	unsigned char orig_value[BREAKPOINT_LENGTH];
33	int enabled;
34	struct library_symbol * libsym;
35#ifdef __arm__
36	int thumb_mode;
37#endif
38};
39
40enum arg_type {
41	ARGTYPE_UNKNOWN = -1,
42	ARGTYPE_VOID,
43	ARGTYPE_INT,
44	ARGTYPE_UINT,
45	ARGTYPE_LONG,
46	ARGTYPE_ULONG,
47	ARGTYPE_OCTAL,
48	ARGTYPE_CHAR,
49	ARGTYPE_SHORT,
50	ARGTYPE_USHORT,
51	ARGTYPE_FLOAT,		/* float value, may require index */
52	ARGTYPE_DOUBLE,		/* double value, may require index */
53	ARGTYPE_ADDR,
54	ARGTYPE_FILE,
55	ARGTYPE_FORMAT,		/* printf-like format */
56	ARGTYPE_STRING,		/* NUL-terminated string */
57	ARGTYPE_STRING_N,	/* String of known maxlen */
58	ARGTYPE_ARRAY,		/* Series of values in memory */
59	ARGTYPE_ENUM,		/* Enumeration */
60	ARGTYPE_STRUCT,		/* Structure of values */
61	ARGTYPE_POINTER,	/* Pointer to some other type */
62	ARGTYPE_COUNT		/* number of ARGTYPE_* values */
63};
64
65typedef struct arg_type_info_t {
66	enum arg_type type;
67	union {
68		/* ARGTYPE_ENUM */
69		struct {
70			size_t entries;
71			char ** keys;
72			int * values;
73		} enum_info;
74
75		/* ARGTYPE_ARRAY */
76		struct {
77			struct arg_type_info_t * elt_type;
78			size_t elt_size;
79			int len_spec;
80		} array_info;
81
82		/* ARGTYPE_STRING_N */
83		struct {
84			int size_spec;
85		} string_n_info;
86
87		/* ARGTYPE_STRUCT */
88		struct {
89			struct arg_type_info_t ** fields;	/* NULL-terminated */
90			size_t * offset;
91			size_t size;
92		} struct_info;
93
94		/* ARGTYPE_POINTER */
95		struct {
96			struct arg_type_info_t * info;
97		} ptr_info;
98
99		/* ARGTYPE_FLOAT */
100		struct {
101			size_t float_index;
102		} float_info;
103
104		/* ARGTYPE_DOUBLE */
105		struct {
106			size_t float_index;
107		} double_info;
108	} u;
109} arg_type_info;
110
111enum tof {
112	LT_TOF_NONE = 0,
113	LT_TOF_FUNCTION,	/* A real library function */
114	LT_TOF_FUNCTIONR,	/* Return from a real library function */
115	LT_TOF_SYSCALL,		/* A syscall */
116	LT_TOF_SYSCALLR,	/* Return from a syscall */
117	LT_TOF_STRUCT		/* Not a function; read args from struct */
118};
119
120typedef struct Function Function;
121struct Function {
122	const char * name;
123	arg_type_info * return_info;
124	int num_params;
125	arg_type_info * arg_info[MAX_ARGS];
126	int params_right;
127	Function * next;
128};
129
130enum toplt {
131	LS_TOPLT_NONE = 0,	/* PLT not used for this symbol. */
132	LS_TOPLT_EXEC,		/* PLT for this symbol is executable. */
133	LS_TOPLT_POINT		/* PLT for this symbol is a non-executable. */
134};
135
136extern Function * list_of_functions;
137extern char *PLTs_initialized_by_here;
138
139struct library_symbol {
140	char * name;
141	void * enter_addr;
142	char needs_init;
143	enum toplt plt_type;
144	char is_weak;
145	struct library_symbol * next;
146};
147
148struct callstack_element {
149	union {
150		int syscall;
151		struct library_symbol * libfunc;
152	} c_un;
153	int is_syscall;
154	void * return_addr;
155	struct timeval time_spent;
156	void * arch_ptr;
157};
158
159#define MAX_CALLDEPTH 64
160
161typedef enum Process_State Process_State;
162enum Process_State {
163	STATE_ATTACHED = 0,
164	STATE_BEING_CREATED,
165	STATE_IGNORED  /* ignore this process (it's a fork and no -f was used) */
166};
167
168typedef struct Event_Handler Event_Handler;
169struct Event_Handler {
170	/* Event handler that overrides the default one.  Should
171	 * return NULL if the event was handled, otherwise the
172	 * returned event is passed to the default handler.  */
173	Event * (* on_event)(Event_Handler * self, Event * event);
174
175	/* Called when the event handler removal is requested.  */
176	void (* destroy)(Event_Handler * self);
177};
178
179/* XXX We would rather have this all organized a little differently,
180 * have Process for the whole group and Task for what's there for
181 * per-thread stuff.  But for now this is the less invasive way of
182 * structuring it.  */
183struct Process {
184	Process_State state;
185	Process * parent;         /* needed by STATE_BEING_CREATED */
186	char * filename;
187	pid_t pid;
188
189	/* Dictionary of breakpoints (which is a mapping
190	 * address->Breakpoint).  This is NULL for non-leader
191	 * processes.  */
192	Dict * breakpoints;
193
194	int breakpoints_enabled;  /* -1:not enabled yet, 0:disabled, 1:enabled */
195	int mask_32bit;           /* 1 if 64-bit ltrace is tracing 32-bit process */
196	unsigned int personality;
197	int tracesysgood;         /* signal indicating a PTRACE_SYSCALL trap */
198
199	int callstack_depth;
200	struct callstack_element callstack[MAX_CALLDEPTH];
201	struct library_symbol * list_of_symbols;
202
203	int libdl_hooked;
204	/* Arch-dependent: */
205	void * debug;	/* arch-dep process debug struct */
206	long debug_state; /* arch-dep debug state */
207	void * instruction_pointer;
208	void * stack_pointer;      /* To get return addr, args... */
209	void * return_addr;
210	void * arch_ptr;
211	short e_machine;
212	short need_to_reinitialize_breakpoints;
213#ifdef __arm__
214	int thumb_mode;           /* ARM execution mode: 0: ARM, 1: Thumb */
215#endif
216
217#if defined(HAVE_LIBUNWIND)
218	/* libunwind address space */
219	unw_addr_space_t unwind_as;
220	void *unwind_priv;
221#endif /* defined(HAVE_LIBUNWIND) */
222
223	/* Set in leader.  */
224	Event_Handler * event_handler;
225
226
227	/**
228	 * Process chaining.
229	 **/
230	Process * next;
231
232	/* LEADER points to the leader thread of the POSIX.1 process.
233	   If X->LEADER == X, then X is the leader thread and the
234	   Process structures chained by NEXT represent other threads,
235	   up until, but not including, the next leader thread.
236	   LEADER may be NULL after the leader has already exited.  In
237	   that case this process is waiting to be collected.  */
238	Process * leader;
239};
240
241struct opt_c_struct {
242	int count;
243	struct timeval tv;
244};
245
246#include "options.h"
247#include "output.h"
248#ifdef USE_DEMANGLE
249#include "demangle.h"
250#endif
251
252extern Dict * dict_opt_c;
253
254enum process_status {
255	ps_invalid,	/* Failure.  */
256	ps_stop,	/* Job-control stop.  */
257	ps_tracing_stop,
258	ps_sleeping,
259	ps_zombie,
260	ps_other,	/* Necessary other states can be added as needed.  */
261};
262
263enum pcb_status {
264	pcb_stop, /* The iteration should stop.  */
265	pcb_cont, /* The iteration should continue.  */
266};
267
268/* Process list  */
269extern Process * pid2proc(pid_t pid);
270extern void add_process(Process * proc);
271extern void remove_process(Process * proc);
272extern void change_process_leader(Process * proc, Process * leader);
273extern Process *each_process(Process * start,
274			     enum pcb_status (* cb)(Process * proc, void * data),
275			     void * data);
276extern Process *each_task(Process * start,
277			  enum pcb_status (* cb)(Process * proc, void * data),
278			  void * data);
279
280/* Events  */
281enum ecb_status {
282	ecb_cont, /* The iteration should continue.  */
283	ecb_yield, /* The iteration should stop, yielding this
284		    * event.  */
285	ecb_deque, /* Like ecb_stop, but the event should be removed
286		    * from the queue.  */
287};
288extern Event * next_event(void);
289extern Event * each_qd_event(enum ecb_status (* cb)(Event * event, void * data),
290			     void * data);
291extern void enque_event(Event * event);
292extern void handle_event(Event * event);
293
294extern void install_event_handler(Process * proc, Event_Handler * handler);
295extern void destroy_event_handler(Process * proc);
296
297extern pid_t execute_program(const char * command, char ** argv);
298extern int display_arg(enum tof type, Process * proc, int arg_num, arg_type_info * info);
299extern Breakpoint * address2bpstruct(Process * proc, void * addr);
300extern int breakpoints_init(Process * proc, int enable);
301extern void insert_breakpoint(Process * proc, void * addr,
302			      struct library_symbol * libsym, int enable);
303extern void delete_breakpoint(Process * proc, void * addr);
304extern void enable_all_breakpoints(Process * proc);
305extern void disable_all_breakpoints(Process * proc);
306extern void reinitialize_breakpoints(Process *);
307
308extern Process * open_program(char * filename, pid_t pid, int init_breakpoints);
309extern void open_pid(pid_t pid);
310extern void show_summary(void);
311extern arg_type_info * lookup_prototype(enum arg_type at);
312
313extern int do_init_elf(struct ltelf *lte, const char *filename);
314extern void do_close_elf(struct ltelf *lte);
315extern int in_load_libraries(const char *name, struct ltelf *lte, size_t count, GElf_Sym *sym);
316extern struct library_symbol *library_symbols;
317extern void add_library_symbol(GElf_Addr addr, const char *name,
318		struct library_symbol **library_symbolspp,
319		enum toplt type_of_plt, int is_weak);
320
321extern struct library_symbol * clone_library_symbol(struct library_symbol * s);
322extern void destroy_library_symbol(struct library_symbol * s);
323extern void destroy_library_symbol_chain(struct library_symbol * chain);
324
325/* Arch-dependent stuff: */
326extern char * pid2name(pid_t pid);
327extern pid_t process_leader(pid_t pid);
328extern int process_tasks(pid_t pid, pid_t **ret_tasks, size_t *ret_n);
329extern int process_stopped(pid_t pid);
330extern enum process_status process_status(pid_t pid);
331extern void trace_set_options(Process * proc, pid_t pid);
332extern void wait_for_proc(pid_t pid);
333extern void trace_me(void);
334extern int trace_pid(pid_t pid);
335extern void untrace_pid(pid_t pid);
336extern void get_arch_dep(Process * proc);
337extern void * get_instruction_pointer(Process * proc);
338extern void set_instruction_pointer(Process * proc, void * addr);
339extern void * get_stack_pointer(Process * proc);
340extern void * get_return_addr(Process * proc, void * stack_pointer);
341extern void set_return_addr(Process * proc, void * addr);
342extern void enable_breakpoint(Process * proc, Breakpoint * sbp);
343extern void disable_breakpoint(Process * proc, Breakpoint * sbp);
344extern int syscall_p(Process * proc, int status, int * sysnum);
345extern void continue_process(pid_t pid);
346extern void continue_after_signal(pid_t pid, int signum);
347extern void continue_after_syscall(Process *proc, int sysnum, int ret_p);
348extern void continue_after_breakpoint(Process * proc, Breakpoint * sbp);
349extern void continue_after_vfork(Process * proc);
350extern void ltrace_exiting(void);
351extern long gimme_arg(enum tof type, Process * proc, int arg_num, arg_type_info * info);
352extern void save_register_args(enum tof type, Process * proc);
353extern int umovestr(Process * proc, void * addr, int len, void * laddr);
354extern int umovelong (Process * proc, void * addr, long * result, arg_type_info * info);
355extern size_t umovebytes (Process *proc, void * addr, void * laddr, size_t count);
356extern int ffcheck(void * maddr);
357extern void * sym2addr(Process *, struct library_symbol *);
358extern int linkmap_init(Process *, struct ltelf *);
359extern void arch_check_dbg(Process *proc);
360extern int task_kill (pid_t pid, int sig);
361
362/* Called when trace_me or primary trace_pid fail.  This may plug in
363 * any platform-specific knowledge of why it could be so.  */
364void trace_fail_warning(pid_t pid);
365
366
367extern struct ltelf main_lte;
368
369#endif
370