common.h revision 1974dbccbf10a2dd8e06724d2fb4eb61fd91076a
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_zombie, 259 ps_other, /* Necessary other states can be added as needed. */ 260}; 261 262enum pcb_status { 263 pcb_stop, /* The iteration should stop. */ 264 pcb_cont, /* The iteration should continue. */ 265}; 266 267/* Process list */ 268extern Process * pid2proc(pid_t pid); 269extern void add_process(Process * proc); 270extern void remove_process(Process * proc); 271extern Process *each_process(Process * start, 272 enum pcb_status (* cb)(Process * proc, void * data), 273 void * data); 274extern Process *each_task(Process * start, 275 enum pcb_status (* cb)(Process * proc, void * data), 276 void * data); 277 278/* Events */ 279enum ecb_status { 280 ecb_cont, /* The iteration should continue. */ 281 ecb_yield, /* The iteration should stop, yielding this 282 * event. */ 283 ecb_deque, /* Like ecb_stop, but the event should be removed 284 * from the queue. */ 285}; 286extern Event * next_event(void); 287extern Event * each_qd_event(enum ecb_status (* cb)(Event * event, void * data), 288 void * data); 289extern void enque_event(Event * event); 290extern void handle_event(Event * event); 291 292extern void install_event_handler(Process * proc, Event_Handler * handler); 293extern void destroy_event_handler(Process * proc); 294 295extern pid_t execute_program(const char * command, char ** argv); 296extern int display_arg(enum tof type, Process * proc, int arg_num, arg_type_info * info); 297extern Breakpoint * address2bpstruct(Process * proc, void * addr); 298extern int breakpoints_init(Process * proc, int enable); 299extern void insert_breakpoint(Process * proc, void * addr, 300 struct library_symbol * libsym, int enable); 301extern void delete_breakpoint(Process * proc, void * addr); 302extern void enable_all_breakpoints(Process * proc); 303extern void disable_all_breakpoints(Process * proc); 304extern void reinitialize_breakpoints(Process *); 305 306extern Process * open_program(char * filename, pid_t pid, int init_breakpoints); 307extern void open_pid(pid_t pid); 308extern void show_summary(void); 309extern arg_type_info * lookup_prototype(enum arg_type at); 310 311extern int do_init_elf(struct ltelf *lte, const char *filename); 312extern void do_close_elf(struct ltelf *lte); 313extern int in_load_libraries(const char *name, struct ltelf *lte, size_t count, GElf_Sym *sym); 314extern struct library_symbol *library_symbols; 315extern void add_library_symbol(GElf_Addr addr, const char *name, 316 struct library_symbol **library_symbolspp, 317 enum toplt type_of_plt, int is_weak); 318 319/* Arch-dependent stuff: */ 320extern char * pid2name(pid_t pid); 321extern pid_t process_leader(pid_t pid); 322extern int process_tasks(pid_t pid, pid_t **ret_tasks, size_t *ret_n); 323extern int process_stopped(pid_t pid); 324extern enum process_status process_status(pid_t pid); 325extern void trace_set_options(Process * proc, pid_t pid); 326extern void trace_me(void); 327extern int trace_pid(pid_t pid); 328extern void untrace_pid(pid_t pid); 329extern void get_arch_dep(Process * proc); 330extern void * get_instruction_pointer(Process * proc); 331extern void set_instruction_pointer(Process * proc, void * addr); 332extern void * get_stack_pointer(Process * proc); 333extern void * get_return_addr(Process * proc, void * stack_pointer); 334extern void set_return_addr(Process * proc, void * addr); 335extern void enable_breakpoint(Process * proc, Breakpoint * sbp); 336extern void disable_breakpoint(Process * proc, Breakpoint * sbp); 337extern int syscall_p(Process * proc, int status, int * sysnum); 338extern void continue_process(pid_t pid); 339extern void continue_after_signal(pid_t pid, int signum); 340extern void continue_after_breakpoint(Process * proc, Breakpoint * sbp); 341extern void ltrace_exiting(void); 342extern long gimme_arg(enum tof type, Process * proc, int arg_num, arg_type_info * info); 343extern void save_register_args(enum tof type, Process * proc); 344extern int umovestr(Process * proc, void * addr, int len, void * laddr); 345extern int umovelong (Process * proc, void * addr, long * result, arg_type_info * info); 346extern size_t umovebytes (Process *proc, void * addr, void * laddr, size_t count); 347extern int ffcheck(void * maddr); 348extern void * sym2addr(Process *, struct library_symbol *); 349extern int linkmap_init(Process *, struct ltelf *); 350extern void arch_check_dbg(Process *proc); 351extern int task_kill (pid_t pid, int sig); 352 353 354extern struct ltelf main_lte; 355 356#endif 357