proc.h 9.77 KB
Newer Older
1 2
/*
 * This file is part of ltrace.
3
 * Copyright (C) 2010,2011,2012,2013,2014 Petr Machata, Red Hat Inc.
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
 * Copyright (C) 2010 Joe Damato
 * Copyright (C) 1998,2001,2008,2009 Juan Cespedes
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 */

Petr Machata's avatar
Petr Machata committed
23 24
#ifndef PROC_H
#define PROC_H
25

26 27
#include "config.h"

28
#include <sys/time.h>
29
#include <stdint.h>
30

31 32 33 34
#if defined(HAVE_LIBDW)
# include <elfutils/libdwfl.h>
#endif

35 36
#if defined(HAVE_LIBUNWIND)
# include <libunwind.h>
37
# include <libunwind-ptrace.h>
38 39 40 41
#endif /* defined(HAVE_LIBUNWIND) */

#include "ltrace.h"
#include "dict.h"
42
#include "sysdep.h"
43
#include "callback.h"
44
#include "forward.h"
45

46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61
struct event_handler {
	/* Event handler that overrides the default one.  Should
	 * return NULL if the event was handled, otherwise the
	 * returned event is passed to the default handler.  */
	Event *(*on_event)(struct event_handler *self, Event *event);

	/* Called when the event handler removal is requested.  */
	void (*destroy)(struct event_handler *self);
};

enum process_state {
	STATE_ATTACHED = 0,
	STATE_BEING_CREATED,
	STATE_IGNORED  /* ignore this process (it's a fork and no -f was used) */
};

62 63 64 65 66
struct output_state {
	size_t params_left;
	int need_delim;
};

67 68 69 70 71 72
struct callstack_element {
	union {
		int syscall;
		struct library_symbol * libfunc;
	} c_un;
	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 81 82 83
};

/* XXX We should get rid of this.  */
#define MAX_CALLDEPTH 64

/* XXX We would rather have this all organized a little differently,
84 85 86 87
 * have struct process for the whole group and struct task (or struct
 * lwp, struct thread) for what's there for per-thread stuff.  But for
 * now this is the less invasive way of structuring it.  */
struct process {
88
	enum process_state state;
89
	struct process *parent;         /* needed by STATE_BEING_CREATED */
90 91 92 93 94
	char * filename;
	pid_t pid;

	/* Dictionary of breakpoints (which is a mapping
	 * address->breakpoint).  This is NULL for non-leader
95 96
	 * processes.  */
	struct dict *breakpoints;
97 98 99 100 101

	int mask_32bit;           /* 1 if 64-bit ltrace is tracing 32-bit process */
	unsigned int personality;
	int tracesysgood;         /* signal indicating a PTRACE_SYSCALL trap */

Petr Machata's avatar
Petr Machata committed
102
	size_t callstack_depth;
103
	struct callstack_element callstack[MAX_CALLDEPTH];
Petr Machata's avatar
Petr Machata committed
104 105 106

	/* Linked list of libraries in backwards order of mapping.
	 * The last element is the executed binary itself.  */
107
	struct library *libraries;
108 109 110 111 112

	/* Arch-dependent: */
	void * instruction_pointer;
	void * stack_pointer;      /* To get return addr, args... */
	void * arch_ptr;
113 114 115 116 117

	/* XXX We would like to replace this with a pointer to ABI
	 * object that would provide the relevant services, instead of
	 * checking the necessary flags in the back end ad
	 * nauseam.  */
118
	short e_machine;
119 120
	char e_class;

121 122 123
#if defined(HAVE_LIBDW)
	/* Unwind info for leader, NULL for non-leader procs. */
	Dwfl *dwfl;
124 125 126 127 128 129

	/* Whether we still need to attach the DWARF library to this process. We
	 * try only once, and never again, regardless of whether we succeeded or
	 * not. 0 = shouldn't attach */
	int should_attach_dwfl;

130 131
#endif /* defined(HAVE_LIBDW) */

132 133 134 135 136 137 138 139 140 141 142 143
#if defined(HAVE_LIBUNWIND)
	/* libunwind address space */
	unw_addr_space_t unwind_as;
	void *unwind_priv;
#endif /* defined(HAVE_LIBUNWIND) */

	/* Set in leader.  */
	struct event_handler *event_handler;

	/**
	 * Process chaining.
	 **/
144
	struct process *next;
145 146 147

	/* LEADER points to the leader thread of the POSIX.1 process.
	   If X->LEADER == X, then X is the leader thread and the
148
	   process structures chained by NEXT represent other threads,
149 150 151
	   up until, but not including, the next leader thread.
	   LEADER may be NULL after the leader has already exited.  In
	   that case this process is waiting to be collected.  */
152
	struct process *leader;
153

154
	struct os_process_data os;
155
	struct arch_process_data arch;
156 157
};

158 159
/* Initialize a process given a path to binary FILENAME, with a PID,
 * and add the process to an internal chain of traced processes.  */
160
int process_init(struct process *proc, const char *filename, pid_t pid);
161

Petr Machata's avatar
Petr Machata committed
162 163 164
/* PROC underwent an exec.  This is a bit like process_destroy
 * followed by process_init, except that some state is kept and the
 * process doesn't lose it's place in the list of processes.  */
165
int process_exec(struct process *proc);
Petr Machata's avatar
Petr Machata committed
166 167 168 169 170 171 172

/* Release any memory allocated for PROC (but not PROC itself).  Does
 * NOT remove PROC from internal chain.
 *
 * XXX clearly this init/destroy pair is different than others and
 * should be fixed.  process_init should presumably be separate from
 * process_add.  */
173
void process_destroy(struct process *proc);
Petr Machata's avatar
Petr Machata committed
174

175
struct process *open_program(const char *filename, pid_t pid);
176
void open_pid(pid_t pid);
177
struct process *pid2proc(pid_t pid);
178 179 180

/* Clone the contents of PROC into the memory referenced by RETP.
 * Returns 0 on success or a negative value on failure.  */
181
int process_clone(struct process *retp, struct process *proc, pid_t pid);
182

183 184 185
/* Iterate through the processes that ltrace currently traces.  Tasks
 * are considered to be processes for the purpose of this iterator.
 * See callback.h for notes on iteration interfaces.  */
186 187 188 189
struct process *each_process(struct process *start_after,
			     enum callback_status (*cb)(struct process *proc,
							void *data),
			     void *data);
190

191 192
/* Iterate through list of tasks of given process PROC.  See
 * callback.h for notes on iteration interfaces.  */
193 194 195 196
struct process *each_task(struct process *proc, struct process *start_after,
			  enum callback_status (*cb)(struct process *proc,
						     void *data),
			  void *data);
197

198
void change_process_leader(struct process *proc, struct process *leader);
199

200 201 202 203
/* Prepare those parts of process initialization that need to be done
 * after _start is hit (i.e. after dynamic linking was done).  */
void process_hit_start(struct process *proc);

204 205
/* Remove process from the list of traced processes, drop any events
 * in the event queue, destroy it and free memory.  */
206
void remove_process(struct process *proc);
207

208 209
void install_event_handler(struct process *proc, struct event_handler *handler);
void destroy_event_handler(struct process *proc);
210

211
/* Add a library LIB to the list of PROC's libraries.  */
212
void proc_add_library(struct process *proc, struct library *lib);
213 214 215

/* Remove LIB from list of PROC's libraries.  Returns 0 if the library
 * was found and unlinked, otherwise returns a negative value.  */
216
int proc_remove_library(struct process *proc, struct library *lib);
217

218 219 220 221 222
/* Clear a delayed flag.  If a symbol is neither latent, nor delayed,
 * a breakpoint is inserted for it.  Returns 0 if the activation was
 * successful or a negative value if it failed.  Note that if a symbol
 * is both latent and delayed, this will not enable the corresponding
 * breakpoint.  */
223
int proc_activate_delayed_symbol(struct process *proc,
224 225
				 struct library_symbol *libsym);

226 227
/* Iterate through the libraries of PROC.  See callback.h for notes on
 * iteration interfaces.  */
228 229
struct library *proc_each_library(struct process *proc,
				  struct library *start_after,
230
				  enum callback_status (*cb)(struct process *p,
231 232 233 234
							     struct library *l,
							     void *data),
				  void *data);

235
/* Insert BP into PROC.  */
236
int proc_add_breakpoint(struct process *proc, struct breakpoint *bp);
237

238 239
/* Remove BP from PROC.  This has no reason to fail in runtime.  If it
 * does not find BP in PROC, it's hard error guarded by assertion.  */
240
void proc_remove_breakpoint(struct process *proc, struct breakpoint *bp);
241

242 243
/* Iterate through the breakpoints of PROC.  See callback.h for notes
 * on iteration interfaces.  */
244 245 246 247 248 249
arch_addr_t *proc_each_breakpoint(struct process *proc, arch_addr_t *start,
				  enum callback_status (*cb)
					(struct process *proc,
					 struct breakpoint *bp,
					 void *data),
				  void *data);
Petr Machata's avatar
Petr Machata committed
250

251 252 253
/* Iterate through the dynamic section at src_addr looking for D_TAG.
 * If tag is found, fill it's value in RET and return 0.
 * If tag is not found, return a negative value.  */
254
int proc_find_dynamic_entry_addr(struct process *proc, arch_addr_t src_addr,
255
				 int d_tag, arch_addr_t *ret);
256 257 258 259 260

/* Finds a symbol corresponding to LIBSYM in a process PROC.  Returns
 * 0 and sets *RETLIB and *RETSYM if the corresponding pointer is
 * non-NULL.  Returns a negative value when the symbols couldn't be
 * found.  */
261
int proc_find_symbol(struct process *proc, struct library_symbol *sym,
262 263
		     struct library **retlib, struct library_symbol **retsym);

Petr Machata's avatar
Petr Machata committed
264 265 266
/* Iterate through all symbols in all libraries of PROC.  See
 * callback.h for notes on this interface.  */
struct library_symbol *proc_each_symbol
267
	(struct process *proc, struct library_symbol *start_after,
Petr Machata's avatar
Petr Machata committed
268 269 270
	 enum callback_status (*cb)(struct library_symbol *, void *),
	 void *data);

Petr Machata's avatar
Petr Machata committed
271
/* Read 8, 16, 32 or 64-bit quantity located at ADDR in PROC.  The
272 273 274
 * resulting value is stored in *LP.  0 is returned on success or a
 * negative value on failure.  This uses umovebytes under the hood
 * (see backend.h).  */
Petr Machata's avatar
Petr Machata committed
275
int proc_read_8(struct process *proc, arch_addr_t addr, uint8_t *lp);
276 277 278 279
int proc_read_16(struct process *proc, arch_addr_t addr, uint16_t *lp);
int proc_read_32(struct process *proc, arch_addr_t addr, uint32_t *lp);
int proc_read_64(struct process *proc, arch_addr_t addr, uint64_t *lp);

Petr Machata's avatar
Petr Machata committed
280
#endif /* PROC_H */