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