trace.c revision c1990eb670b2786ffabe712fdb9bf3512dd1501c 
1/*
2 * This file is part of ltrace.
3 * Copyright (C) 2010,2012 Petr Machata, Red Hat Inc.
4 * Copyright (C) 2011 Andreas Schwab
5 * Copyright (C) 2002,2004,2008,2009 Juan Cespedes
6 * Copyright (C) 2008 Luis Machado, IBM Corporation
7 * Copyright (C) 2006 Ian Wienand
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License as
11 * published by the Free Software Foundation; either version 2 of the
12 * License, or (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17 * General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
22 * 02110-1301 USA
23 */
24
25#include "config.h"
26
27#include <assert.h>
28#include <elf.h>
29#include <errno.h>
30#include <signal.h>
31#include <string.h>
32#include <sys/types.h>
33#include <sys/wait.h>
34
35#include "backend.h"
36#include "breakpoint.h"
37#include "common.h"
38#include "insn.h"
39#include "proc.h"
40#include "ptrace.h"
41#include "type.h"
42
43#if (!defined(PTRACE_PEEKUSER) && defined(PTRACE_PEEKUSR))
44# define PTRACE_PEEKUSER PTRACE_PEEKUSR
45#endif
46
47#if (!defined(PTRACE_POKEUSER) && defined(PTRACE_POKEUSR))
48# define PTRACE_POKEUSER PTRACE_POKEUSR
49#endif
50
51void
52get_arch_dep(Process *proc) {
53#ifdef __powerpc64__
54	proc->mask_32bit = (proc->e_machine == EM_PPC);
55#endif
56}
57
58#define SYSCALL_INSN   0x44000002
59
60/* Returns 1 if syscall, 2 if sysret, 0 otherwise. */
61int
62syscall_p(Process *proc, int status, int *sysnum) {
63	if (WIFSTOPPED(status)
64	    && WSTOPSIG(status) == (SIGTRAP | proc->tracesysgood)) {
65		long pc = (long)get_instruction_pointer(proc);
66		int insn =
67		    (int)ptrace(PTRACE_PEEKTEXT, proc->pid, pc - sizeof(long),
68				0);
69
70		if (insn == SYSCALL_INSN) {
71			*sysnum =
72			    (int)ptrace(PTRACE_PEEKUSER, proc->pid,
73					sizeof(long) * PT_R0, 0);
74			if (proc->callstack_depth > 0 &&
75					proc->callstack[proc->callstack_depth - 1].is_syscall &&
76					proc->callstack[proc->callstack_depth - 1].c_un.syscall == *sysnum) {
77				return 2;
78			}
79			return 1;
80		}
81	}
82	return 0;
83}
84
85/* The atomic skip code is mostly taken from GDB.  */
86
87/* In plt.h.  XXX make this official interface.  */
88int read_target_4(struct Process *proc, arch_addr_t addr, uint32_t *lp);
89
90int
91arch_atomic_singlestep(struct Process *proc, struct breakpoint *sbp,
92		       int (*add_cb)(void *addr, void *data),
93		       void *add_cb_data)
94{
95	arch_addr_t ip = get_instruction_pointer(proc);
96	struct breakpoint *other = address2bpstruct(proc->leader, ip);
97
98	debug(1, "arch_atomic_singlestep pid=%d addr=%p %s(%p)",
99	      proc->pid, ip, breakpoint_name(sbp), sbp->addr);
100
101	/* If the original instruction was lwarx/ldarx, we can't
102	 * single-step over it, instead we have to execute the whole
103	 * atomic block at once.  */
104	union {
105		uint32_t insn;
106		char buf[BREAKPOINT_LENGTH];
107	} u;
108	if (other != NULL) {
109		memcpy(u.buf, sbp->orig_value, BREAKPOINT_LENGTH);
110	} else if (read_target_4(proc, ip, &u.insn) < 0) {
111		fprintf(stderr, "couldn't read instruction at IP %p\n", ip);
112		/* Do the normal singlestep.  */
113		return 1;
114	}
115
116	if ((u.insn & LWARX_MASK) != LWARX_INSTRUCTION
117	    && (u.insn & LWARX_MASK) != LDARX_INSTRUCTION)
118		return 1;
119
120	debug(1, "singlestep over atomic block at %p", ip);
121
122	int insn_count;
123	arch_addr_t addr = ip;
124	for (insn_count = 0; ; ++insn_count) {
125		addr += 4;
126		unsigned long l = ptrace(PTRACE_PEEKTEXT, proc->pid, addr, 0);
127		if (l == (unsigned long)-1 && errno)
128			return -1;
129		uint32_t insn;
130#ifdef __powerpc64__
131		insn = l >> 32;
132#else
133		insn = l;
134#endif
135
136		/* If a conditional branch is found, put a breakpoint
137		 * in its destination address.  */
138		if ((insn & BRANCH_MASK) == BC_INSN) {
139			arch_addr_t branch_addr = ppc_branch_dest(addr, insn);
140			debug(1, "pid=%d, branch in atomic block from %p to %p",
141			      proc->pid, addr, branch_addr);
142			if (add_cb(branch_addr, add_cb_data) < 0)
143				return -1;
144		}
145
146		/* Assume that the atomic sequence ends with a
147		 * stwcx/stdcx instruction.  */
148		if ((insn & STWCX_MASK) == STWCX_INSTRUCTION
149		    || (insn & STWCX_MASK) == STDCX_INSTRUCTION) {
150			debug(1, "pid=%d, found end of atomic block %p at %p",
151			      proc->pid, ip, addr);
152			break;
153		}
154
155		/* Arbitrary cut-off.  If we didn't find the
156		 * terminating instruction by now, just give up.  */
157		if (insn_count > 16) {
158			fprintf(stderr, "[%d] couldn't find end of atomic block"
159				" at %p\n", proc->pid, ip);
160			return -1;
161		}
162	}
163
164	/* Put the breakpoint to the next instruction.  */
165	addr += 4;
166	if (add_cb(addr, add_cb_data) < 0)
167		return -1;
168
169	debug(1, "PTRACE_CONT");
170	ptrace(PTRACE_CONT, proc->pid, 0, 0);
171	return 0;
172}
173
174size_t
175arch_type_sizeof(struct Process *proc, struct arg_type_info *info)
176{
177	if (proc == NULL)
178		return (size_t)-2;
179
180	switch (info->type) {
181	case ARGTYPE_VOID:
182		return 0;
183
184	case ARGTYPE_CHAR:
185		return 1;
186
187	case ARGTYPE_SHORT:
188	case ARGTYPE_USHORT:
189		return 2;
190
191	case ARGTYPE_INT:
192	case ARGTYPE_UINT:
193		return 4;
194
195	case ARGTYPE_LONG:
196	case ARGTYPE_ULONG:
197	case ARGTYPE_POINTER:
198		return proc->e_machine == EM_PPC64 ? 8 : 4;
199
200	case ARGTYPE_FLOAT:
201		return 4;
202	case ARGTYPE_DOUBLE:
203		return 8;
204
205	case ARGTYPE_ARRAY:
206	case ARGTYPE_STRUCT:
207		/* Use default value.  */
208		return (size_t)-2;
209
210	default:
211		assert(info->type != info->type);
212		abort();
213		break;
214	}
215}
216
217size_t
218arch_type_alignof(struct Process *proc, struct arg_type_info *info)
219{
220	if (proc == NULL)
221		return (size_t)-2;
222
223	switch (info->type) {
224	default:
225		assert(info->type != info->type);
226		abort();
227		break;
228
229	case ARGTYPE_CHAR:
230	case ARGTYPE_SHORT:
231	case ARGTYPE_USHORT:
232	case ARGTYPE_INT:
233	case ARGTYPE_UINT:
234	case ARGTYPE_LONG:
235	case ARGTYPE_ULONG:
236	case ARGTYPE_POINTER:
237	case ARGTYPE_FLOAT:
238	case ARGTYPE_DOUBLE:
239		/* On both PPC and PPC64, fundamental types have the
240		 * same alignment as size.  */
241		return arch_type_sizeof(proc, info);
242
243	case ARGTYPE_ARRAY:
244	case ARGTYPE_STRUCT:
245		/* Use default value.  */
246		return (size_t)-2;
247	}
248}
249