1 /* 2 * This file is part of ltrace. 3 * Copyright (C) 2010,2011,2012,2013,2014 Petr Machata, Red Hat Inc. 4 * Copyright (C) 2010 Joe Damato 5 * Copyright (C) 1998,2001,2008,2009 Juan Cespedes 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License as 9 * published by the Free Software Foundation; either version 2 of the 10 * License, or (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, but 13 * WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 20 * 02110-1301 USA 21 */ 22 23 #ifndef _PROC_H_ 24 #define _PROC_H_ 25 26 #include "config.h" 27 28 #include <sys/time.h> 29 #include <stdint.h> 30 31 #if defined(HAVE_LIBDW) 32 # include <elfutils/libdwfl.h> 33 #endif 34 35 #if defined(HAVE_LIBUNWIND) 36 # include <libunwind.h> 37 # include <libunwind-ptrace.h> 38 #endif /* defined(HAVE_LIBUNWIND) */ 39 40 #include "ltrace.h" 41 #include "dict.h" 42 #include "sysdep.h" 43 #include "callback.h" 44 #include "forward.h" 45 46 struct event_handler { 47 /* Event handler that overrides the default one. Should 48 * return NULL if the event was handled, otherwise the 49 * returned event is passed to the default handler. */ 50 Event *(*on_event)(struct event_handler *self, Event *event); 51 52 /* Called when the event handler removal is requested. */ 53 void (*destroy)(struct event_handler *self); 54 }; 55 56 enum process_state { 57 STATE_ATTACHED = 0, 58 STATE_BEING_CREATED, 59 STATE_IGNORED /* ignore this process (it's a fork and no -f was used) */ 60 }; 61 62 struct output_state { 63 size_t params_left; 64 int need_delim; 65 }; 66 67 struct callstack_element { 68 union { 69 int syscall; 70 struct library_symbol * libfunc; 71 } c_un; 72 int is_syscall; 73 arch_addr_t return_addr; 74 struct timeval enter_time; 75 struct fetch_context *fetch_context; 76 struct value_dict *arguments; 77 struct output_state out; 78 }; 79 80 /* XXX We should get rid of this. */ 81 #define MAX_CALLDEPTH 64 82 83 /* XXX We would rather have this all organized a little differently, 84 * have struct process for the whole group and struct task (or struct 85 * lwp, struct thread) for what's there for per-thread stuff. But for 86 * now this is the less invasive way of structuring it. */ 87 struct process { 88 enum process_state state; 89 struct process *parent; /* needed by STATE_BEING_CREATED */ 90 char * filename; 91 pid_t pid; 92 93 /* Dictionary of breakpoints (which is a mapping 94 * address->breakpoint). This is NULL for non-leader 95 * processes. */ 96 struct dict *breakpoints; 97 98 int mask_32bit; /* 1 if 64-bit ltrace is tracing 32-bit process */ 99 unsigned int personality; 100 int tracesysgood; /* signal indicating a PTRACE_SYSCALL trap */ 101 102 size_t callstack_depth; 103 struct callstack_element callstack[MAX_CALLDEPTH]; 104 105 /* Linked list of libraries in backwards order of mapping. 106 * The last element is the executed binary itself. */ 107 struct library *libraries; 108 109 /* Arch-dependent: */ 110 void * instruction_pointer; 111 void * stack_pointer; /* To get return addr, args... */ 112 void * arch_ptr; 113 114 /* XXX We would like to replace this with a pointer to ABI 115 * object that would provide the relevant services, instead of 116 * checking the necessary flags in the back end ad 117 * nauseam. */ 118 short e_machine; 119 char e_class; 120 121 #if defined(HAVE_LIBDW) 122 /* Unwind info for leader, NULL for non-leader procs. */ 123 Dwfl *dwfl; 124 #endif /* defined(HAVE_LIBDW) */ 125 126 #if defined(HAVE_LIBUNWIND) 127 /* libunwind address space */ 128 unw_addr_space_t unwind_as; 129 void *unwind_priv; 130 #endif /* defined(HAVE_LIBUNWIND) */ 131 132 /* Set in leader. */ 133 struct event_handler *event_handler; 134 135 /** 136 * Process chaining. 137 **/ 138 struct process *next; 139 140 /* LEADER points to the leader thread of the POSIX.1 process. 141 If X->LEADER == X, then X is the leader thread and the 142 process structures chained by NEXT represent other threads, 143 up until, but not including, the next leader thread. 144 LEADER may be NULL after the leader has already exited. In 145 that case this process is waiting to be collected. */ 146 struct process *leader; 147 148 struct os_process_data os; 149 struct arch_process_data arch; 150 }; 151 152 /* Initialize a process given a path to binary FILENAME, with a PID, 153 * and add the process to an internal chain of traced processes. */ 154 int process_init(struct process *proc, const char *filename, pid_t pid); 155 156 /* PROC underwent an exec. This is a bit like process_destroy 157 * followed by process_init, except that some state is kept and the 158 * process doesn't lose it's place in the list of processes. */ 159 int process_exec(struct process *proc); 160 161 /* Release any memory allocated for PROC (but not PROC itself). Does 162 * NOT remove PROC from internal chain. 163 * 164 * XXX clearly this init/destroy pair is different than others and 165 * should be fixed. process_init should presumably be separate from 166 * process_add. */ 167 void process_destroy(struct process *proc); 168 169 struct process *open_program(const char *filename, pid_t pid); 170 void open_pid(pid_t pid); 171 struct process *pid2proc(pid_t pid); 172 173 /* Clone the contents of PROC into the memory referenced by RETP. 174 * Returns 0 on success or a negative value on failure. */ 175 int process_clone(struct process *retp, struct process *proc, pid_t pid); 176 177 /* Iterate through the processes that ltrace currently traces. Tasks 178 * are considered to be processes for the purpose of this iterator. 179 * See callback.h for notes on iteration interfaces. */ 180 struct process *each_process(struct process *start_after, 181 enum callback_status (*cb)(struct process *proc, 182 void *data), 183 void *data); 184 185 /* Iterate through list of tasks of given process PROC. See 186 * callback.h for notes on iteration interfaces. */ 187 struct process *each_task(struct process *proc, struct process *start_after, 188 enum callback_status (*cb)(struct process *proc, 189 void *data), 190 void *data); 191 192 void change_process_leader(struct process *proc, struct process *leader); 193 194 /* Prepare those parts of process initialization that need to be done 195 * after _start is hit (i.e. after dynamic linking was done). */ 196 void process_hit_start(struct process *proc); 197 198 /* Remove process from the list of traced processes, drop any events 199 * in the event queue, destroy it and free memory. */ 200 void remove_process(struct process *proc); 201 202 void install_event_handler(struct process *proc, struct event_handler *handler); 203 void destroy_event_handler(struct process *proc); 204 205 /* Add a library LIB to the list of PROC's libraries. */ 206 void proc_add_library(struct process *proc, struct library *lib); 207 208 /* Remove LIB from list of PROC's libraries. Returns 0 if the library 209 * was found and unlinked, otherwise returns a negative value. */ 210 int proc_remove_library(struct process *proc, struct library *lib); 211 212 /* Clear a delayed flag. If a symbol is neither latent, nor delayed, 213 * a breakpoint is inserted for it. Returns 0 if the activation was 214 * successful or a negative value if it failed. Note that if a symbol 215 * is both latent and delayed, this will not enable the corresponding 216 * breakpoint. */ 217 int proc_activate_delayed_symbol(struct process *proc, 218 struct library_symbol *libsym); 219 220 /* Iterate through the libraries of PROC. See callback.h for notes on 221 * iteration interfaces. */ 222 struct library *proc_each_library(struct process *proc, 223 struct library *start_after, 224 enum callback_status (*cb)(struct process *p, 225 struct library *l, 226 void *data), 227 void *data); 228 229 /* Insert BP into PROC. */ 230 int proc_add_breakpoint(struct process *proc, struct breakpoint *bp); 231 232 /* Remove BP from PROC. This has no reason to fail in runtime. If it 233 * does not find BP in PROC, it's hard error guarded by assertion. */ 234 void proc_remove_breakpoint(struct process *proc, struct breakpoint *bp); 235 236 /* Iterate through the breakpoints of PROC. See callback.h for notes 237 * on iteration interfaces. */ 238 arch_addr_t *proc_each_breakpoint(struct process *proc, arch_addr_t *start, 239 enum callback_status (*cb) 240 (struct process *proc, 241 struct breakpoint *bp, 242 void *data), 243 void *data); 244 245 /* Iterate through the dynamic section at src_addr looking for D_TAG. 246 * If tag is found, fill it's value in RET and return 0. 247 * If tag is not found, return a negative value. */ 248 int proc_find_dynamic_entry_addr(struct process *proc, arch_addr_t src_addr, 249 int d_tag, arch_addr_t *ret); 250 251 /* Finds a symbol corresponding to LIBSYM in a process PROC. Returns 252 * 0 and sets *RETLIB and *RETSYM if the corresponding pointer is 253 * non-NULL. Returns a negative value when the symbols couldn't be 254 * found. */ 255 int proc_find_symbol(struct process *proc, struct library_symbol *sym, 256 struct library **retlib, struct library_symbol **retsym); 257 258 /* Iterate through all symbols in all libraries of PROC. See 259 * callback.h for notes on this interface. */ 260 struct library_symbol *proc_each_symbol 261 (struct process *proc, struct library_symbol *start_after, 262 enum callback_status (*cb)(struct library_symbol *, void *), 263 void *data); 264 265 /* Read 8, 16, 32 or 64-bit quantity located at ADDR in PROC. The 266 * resulting value is stored in *LP. 0 is returned on success or a 267 * negative value on failure. This uses umovebytes under the hood 268 * (see backend.h). */ 269 int proc_read_8(struct process *proc, arch_addr_t addr, uint8_t *lp); 270 int proc_read_16(struct process *proc, arch_addr_t addr, uint16_t *lp); 271 int proc_read_32(struct process *proc, arch_addr_t addr, uint32_t *lp); 272 int proc_read_64(struct process *proc, arch_addr_t addr, uint64_t *lp); 273 274 #endif /* _PROC_H_ */ 275