breakpoints.c revision dad1b779e2ed29c9fce17853ca71cb719240b9cf 
1/*
2 * This file is part of ltrace.
3 * Copyright (C) 2006,2007,2011,2012,2013 Petr Machata, Red Hat Inc.
4 * Copyright (C) 2009 Juan Cespedes
5 * Copyright (C) 1998,2001,2002,2003,2007,2008,2009 Juan Cespedes
6 * Copyright (C) 2006 Ian Wienand
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License as
10 * published by the Free Software Foundation; either version 2 of the
11 * License, or (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16 * General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
21 * 02110-1301 USA
22 */
23
24#include "config.h"
25
26#include <assert.h>
27#include <errno.h>
28#include <stdio.h>
29#include <stdlib.h>
30#include <string.h>
31
32#ifdef __powerpc__
33#include <sys/ptrace.h>
34#endif
35
36#include "backend.h"
37#include "breakpoint.h"
38#include "debug.h"
39#include "library.h"
40#include "ltrace-elf.h"
41#include "proc.h"
42
43#ifndef ARCH_HAVE_TRANSLATE_ADDRESS
44int
45arch_translate_address_dyn(struct process *proc,
46		       arch_addr_t addr, arch_addr_t *ret)
47{
48	*ret = addr;
49	return 0;
50}
51
52struct ltelf;
53int
54arch_translate_address(struct ltelf *lte,
55		       arch_addr_t addr, arch_addr_t *ret)
56{
57	*ret = addr;
58	return 0;
59}
60#endif
61
62void
63breakpoint_on_hit(struct breakpoint *bp, struct process *proc)
64{
65	assert(bp != NULL);
66	if (bp->cbs != NULL && bp->cbs->on_hit != NULL)
67		(bp->cbs->on_hit)(bp, proc);
68}
69
70void
71breakpoint_on_continue(struct breakpoint *bp, struct process *proc)
72{
73	assert(bp != NULL);
74	if (bp->cbs != NULL && bp->cbs->on_continue != NULL)
75		(bp->cbs->on_continue)(bp, proc);
76	else
77		continue_after_breakpoint(proc, bp);
78}
79
80void
81breakpoint_on_retract(struct breakpoint *bp, struct process *proc)
82{
83	assert(bp != NULL);
84	if (bp->cbs != NULL && bp->cbs->on_retract != NULL)
85		(bp->cbs->on_retract)(bp, proc);
86}
87
88/*****************************************************************************/
89
90struct breakpoint *
91address2bpstruct(struct process *proc, arch_addr_t addr)
92{
93	assert(proc != NULL);
94	assert(proc->breakpoints != NULL);
95	assert(proc->leader == proc);
96	debug(DEBUG_FUNCTION, "address2bpstruct(pid=%d, addr=%p)", proc->pid, addr);
97
98	struct breakpoint *found;
99	if (DICT_FIND_VAL(proc->breakpoints, &addr, &found) < 0)
100		return NULL;
101	return found;
102}
103
104#ifndef ARCH_HAVE_BREAKPOINT_DATA
105int
106arch_breakpoint_init(struct process *proc, struct breakpoint *sbp)
107{
108	return 0;
109}
110
111void
112arch_breakpoint_destroy(struct breakpoint *sbp)
113{
114}
115
116int
117arch_breakpoint_clone(struct breakpoint *retp, struct breakpoint *sbp)
118{
119	return 0;
120}
121#endif
122
123static void
124breakpoint_init_base(struct breakpoint *bp,
125		     arch_addr_t addr, struct library_symbol *libsym)
126{
127	bp->cbs = NULL;
128	bp->addr = addr;
129	memset(bp->orig_value, 0, sizeof(bp->orig_value));
130	bp->enabled = 0;
131	bp->libsym = libsym;
132}
133
134/* On second thought, I don't think we need PROC.  All the translation
135 * (arch_translate_address in particular) should be doable using
136 * static lookups of various sections in the ELF file.  We shouldn't
137 * need process for anything.  */
138int
139breakpoint_init(struct breakpoint *bp, struct process *proc,
140		arch_addr_t addr, struct library_symbol *libsym)
141{
142	breakpoint_init_base(bp, addr, libsym);
143	return arch_breakpoint_init(proc, bp);
144}
145
146void
147breakpoint_set_callbacks(struct breakpoint *bp, struct bp_callbacks *cbs)
148{
149	if (bp->cbs != NULL)
150		assert(bp->cbs == NULL);
151	bp->cbs = cbs;
152}
153
154void
155breakpoint_destroy(struct breakpoint *bp)
156{
157	if (bp == NULL)
158		return;
159	arch_breakpoint_destroy(bp);
160}
161
162int
163breakpoint_clone(struct breakpoint *retp, struct process *new_proc,
164		 struct breakpoint *bp)
165{
166	struct library_symbol *libsym = NULL;
167	if (bp->libsym != NULL) {
168		int rc = proc_find_symbol(new_proc, bp->libsym, NULL, &libsym);
169		assert(rc == 0);
170	}
171
172	breakpoint_init_base(retp, bp->addr, libsym);
173	memcpy(retp->orig_value, bp->orig_value, sizeof(bp->orig_value));
174	retp->enabled = bp->enabled;
175	if (arch_breakpoint_clone(retp, bp) < 0)
176		return -1;
177	breakpoint_set_callbacks(retp, bp->cbs);
178	return 0;
179}
180
181int
182breakpoint_turn_on(struct breakpoint *bp, struct process *proc)
183{
184	bp->enabled++;
185	if (bp->enabled == 1) {
186		assert(proc->pid != 0);
187		enable_breakpoint(proc, bp);
188	}
189	return 0;
190}
191
192int
193breakpoint_turn_off(struct breakpoint *bp, struct process *proc)
194{
195	bp->enabled--;
196	if (bp->enabled == 0)
197		disable_breakpoint(proc, bp);
198	assert(bp->enabled >= 0);
199	return 0;
200}
201
202struct breakpoint *
203insert_breakpoint_at(struct process *proc, arch_addr_t addr,
204		     struct library_symbol *libsym)
205{
206	debug(DEBUG_FUNCTION,
207	      "insert_breakpoint_at(pid=%d, addr=%p, symbol=%s)",
208	      proc->pid, addr, libsym ? libsym->name : "NULL");
209
210	assert(addr != 0);
211
212	struct breakpoint *bp = malloc(sizeof *bp);
213	if (bp == NULL || breakpoint_init(bp, proc, addr, libsym) < 0) {
214		free(bp);
215		return NULL;
216	}
217
218	/* N.B. (and XXX): BP->addr might differ from ADDR.  On ARM
219	 * this is a real possibility.  The problem here is that to
220	 * create a return breakpoint ltrace calls get_return_addr and
221	 * then insert_breakpoint_at.  So get_return_addr needs to
222	 * encode all the information necessary for breakpoint_init
223	 * into the address itself, so ADDR is potentially
224	 * mangled.  */
225
226	struct breakpoint *tmp = insert_breakpoint(proc, bp);
227	if (tmp != bp) {
228		breakpoint_destroy(bp);
229		free(bp);
230	}
231	return tmp;
232}
233
234struct breakpoint *
235insert_breakpoint(struct process *proc, struct breakpoint *bp)
236{
237	/* Only the group leader should be getting the breakpoints and
238	 * thus have ->breakpoint initialized.  */
239	struct process *leader = proc->leader;
240	assert(leader != NULL);
241	assert(leader->breakpoints != NULL);
242
243	/* XXX what we need to do instead is have a list of
244	 * breakpoints that are enabled at this address.  The
245	 * following works if every breakpoint is the same and there's
246	 * no extra data, but that doesn't hold anymore.  For now it
247	 * will suffice, about the only realistic case where we need
248	 * to have more than one breakpoint per address is return from
249	 * a recursive library call.  */
250	struct breakpoint *ext_bp = bp;
251	if (DICT_FIND_VAL(leader->breakpoints, &bp->addr, &ext_bp) != 0) {
252		if (proc_add_breakpoint(leader, bp) < 0)
253			return NULL;
254		ext_bp = bp;
255	}
256
257	if (breakpoint_turn_on(ext_bp, proc) < 0) {
258		if (ext_bp != bp)
259			proc_remove_breakpoint(leader, bp);
260		return NULL;
261	}
262
263	return ext_bp;
264}
265
266void
267delete_breakpoint(struct process *proc, arch_addr_t addr)
268{
269	debug(DEBUG_FUNCTION, "delete_breakpoint(pid=%d, addr=%p)", proc->pid, addr);
270
271	struct process *leader = proc->leader;
272	assert(leader != NULL);
273
274	struct breakpoint *sbp = NULL;
275	DICT_FIND_VAL(leader->breakpoints, &addr, &sbp);
276	assert(sbp != NULL);
277
278	if (breakpoint_turn_off(sbp, proc) < 0) {
279		fprintf(stderr, "Couldn't turn off the breakpoint %s@%p\n",
280			breakpoint_name(sbp), sbp->addr);
281		return;
282	}
283	if (sbp->enabled == 0) {
284		proc_remove_breakpoint(leader, sbp);
285		breakpoint_destroy(sbp);
286		free(sbp);
287	}
288}
289
290const char *
291breakpoint_name(const struct breakpoint *bp)
292{
293	assert(bp != NULL);
294	return bp->libsym != NULL ? bp->libsym->name : NULL;
295}
296
297struct library *
298breakpoint_library(const struct breakpoint *bp)
299{
300	assert(bp != NULL);
301	return bp->libsym != NULL ? bp->libsym->lib : NULL;
302}
303
304static enum callback_status
305enable_bp_cb(arch_addr_t *addr, struct breakpoint **bpp, void *data)
306{
307	struct process *proc = data;
308	debug(DEBUG_FUNCTION, "enable_bp_cb(pid=%d)", proc->pid);
309	if ((*bpp)->enabled)
310		enable_breakpoint(proc, *bpp);
311	return CBS_CONT;
312}
313
314void
315enable_all_breakpoints(struct process *proc)
316{
317	debug(DEBUG_FUNCTION, "enable_all_breakpoints(pid=%d)", proc->pid);
318
319	debug(1, "Enabling breakpoints for pid %u...", proc->pid);
320	if (proc->breakpoints != NULL)
321		DICT_EACH(proc->breakpoints, arch_addr_t, struct breakpoint *,
322			  NULL, enable_bp_cb, proc);
323}
324
325static enum callback_status
326disable_bp_cb(arch_addr_t *addr, struct breakpoint **bpp, void *data)
327{
328	struct process *proc = data;
329	debug(DEBUG_FUNCTION, "disable_bp_cb(pid=%d)", proc->pid);
330	if ((*bpp)->enabled)
331		disable_breakpoint(proc, *bpp);
332	return CBS_CONT;
333}
334
335void
336disable_all_breakpoints(struct process *proc)
337{
338	debug(DEBUG_FUNCTION, "disable_all_breakpoints(pid=%d)", proc->pid);
339	assert(proc->leader == proc);
340	DICT_EACH(proc->breakpoints, arch_addr_t, struct breakpoint *,
341		  NULL, disable_bp_cb, proc);
342}
343
344static void
345entry_breakpoint_on_hit(struct breakpoint *bp, struct process *proc)
346{
347	if (proc == NULL || proc->leader == NULL)
348		return;
349	delete_breakpoint(proc, bp->addr);
350	process_hit_start(proc);
351}
352
353int
354entry_breakpoint_init(struct process *proc,
355		      struct breakpoint *bp, arch_addr_t addr,
356		      struct library *lib)
357{
358	assert(addr != 0);
359	int err = breakpoint_init(bp, proc, addr, NULL);
360	if (err < 0)
361		return err;
362
363	static struct bp_callbacks entry_callbacks = {
364		.on_hit = entry_breakpoint_on_hit,
365	};
366	bp->cbs = &entry_callbacks;
367	return 0;
368}
369
370int
371breakpoints_init(struct process *proc)
372{
373	debug(DEBUG_FUNCTION, "breakpoints_init(pid=%d)", proc->pid);
374
375	/* XXX breakpoint dictionary should be initialized
376	 * outside.  Here we just put in breakpoints.  */
377	assert(proc->breakpoints != NULL);
378
379	/* Only the thread group leader should hold the breakpoints.  */
380	assert(proc->leader == proc);
381
382	/* N.B. the following used to be conditional on this, and
383	 * maybe it still needs to be.  */
384	assert(proc->filename != NULL);
385
386	struct library *lib = ltelf_read_main_binary(proc, proc->filename);
387	struct breakpoint *entry_bp = NULL;
388	int bp_state = 0;
389	int result = -1;
390	switch ((int)(lib != NULL)) {
391	fail:
392		switch (bp_state) {
393		case 2:
394			proc_remove_library(proc, lib);
395			proc_remove_breakpoint(proc, entry_bp);
396		case 1:
397			breakpoint_destroy(entry_bp);
398		}
399		library_destroy(lib);
400		free(entry_bp);
401	case 0:
402		return result;
403	}
404
405	entry_bp = malloc(sizeof(*entry_bp));
406	if (entry_bp == NULL
407	    || (entry_breakpoint_init(proc, entry_bp,
408				      lib->entry, lib)) < 0) {
409		fprintf(stderr,
410			"Couldn't initialize entry breakpoint for PID %d.\n"
411			"Some tracing events may be missed.\n", proc->pid);
412		free(entry_bp);
413
414	} else {
415		++bp_state;
416
417		if ((result = proc_add_breakpoint(proc, entry_bp)) < 0)
418			goto fail;
419		++bp_state;
420
421		if ((result = breakpoint_turn_on(entry_bp, proc)) < 0)
422			goto fail;
423	}
424	proc_add_library(proc, lib);
425
426	proc->callstack_depth = 0;
427	return 0;
428}
429