1/*
2 * Copyright 1997 Sean Eric Fagan
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 * 3. All advertising materials mentioning features or use of this software
13 * must display the following acknowledgement:
14 * This product includes software developed by Sean Eric Fagan
15 * 4. Neither the name of the author may be used to endorse or promote
16 * products derived from this software without specific prior written
17 * permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32/*
33 * FreeBSD/arm-specific system call handling. This is probably the most
34 * complex part of the entire truss program, although I've got lots of
35 * it handled relatively cleanly now. The system call names are generated
36 * automatically, thanks to /usr/src/sys/kern/syscalls.master. The
37 * names used for the various structures are confusing, I sadly admit.
38 */
39
40#include <sys/cdefs.h>
41__FBSDID("$FreeBSD: head/usr.bin/truss/arm-fbsd.c 286937 2015-08-19 19:59:42Z jhb $");
42#include <sys/types.h>
43#include <sys/ptrace.h>
44#include <sys/syscall.h>
45
46#include <machine/reg.h>
47#include <machine/armreg.h>
48#include <machine/ucontext.h>
49
50#include <errno.h>
51#include <fcntl.h>
52#include <signal.h>
53#include <stdio.h>
54#include <stdlib.h>
55#include <string.h>
56#include <time.h>
57#include <unistd.h>
58#include <err.h>
59
60#include "truss.h"
61#include "syscall.h"
62#include "extern.h"
63
64#include "syscalls.h"
65
66
67static int nsyscalls = nitems(syscallnames);
68
69/*
70 * This is what this particular file uses to keep track of a system call.
71 * It is probably not quite sufficient -- I can probably use the same
72 * structure for the various syscall personalities, and I also probably
73 * need to nest system calls (for signal handlers).
74 *
75 * 'struct syscall' describes the system call; it may be NULL, however,
76 * if we don't know about this particular system call yet.
77 */
78struct freebsd_syscall {
79 struct syscall *sc;
80 const char *name;
81 int number;
82 unsigned long *args;
83 int nargs; /* number of arguments -- *not* number of words! */
84 char **s_args; /* the printable arguments */
85};
86
87static struct freebsd_syscall *
88alloc_fsc(void)
89{
90
91 return (malloc(sizeof(struct freebsd_syscall)));
92}
93
94/* Clear up and free parts of the fsc structure. */
95static void
96free_fsc(struct freebsd_syscall *fsc)
97{
98 int i;
99
100 free(fsc->args);
101 if (fsc->s_args) {
102 for (i = 0; i < fsc->nargs; i++)
103 free(fsc->s_args[i]);
104 free(fsc->s_args);
105 }
106 free(fsc);
107}
108
109/*
110 * Called when a process has entered a system call. nargs is the
111 * number of words, not number of arguments (a necessary distinction
112 * in some cases). Note that if the STOPEVENT() code in i386/i386/trap.c
113 * is ever changed these functions need to keep up.
114 */
115
116void
117arm_syscall_entry(struct trussinfo *trussinfo, int nargs)
118{
119 struct ptrace_io_desc iorequest;
120 struct reg regs;
121 struct freebsd_syscall *fsc;
122 struct syscall *sc;
123 lwpid_t tid;
124 int i, syscall_num;
125 register_t *ap;
126
127 tid = trussinfo->curthread->tid;
128
129 if (ptrace(PT_GETREGS, tid, (caddr_t)&regs, 0) < 0) {
130 fprintf(trussinfo->outfile, "-- CANNOT READ REGISTERS --\n");
131 return;
132 }
133 ap = &regs.r[0];
134
135 /*
136 * FreeBSD has two special kinds of system call redirctions --
137 * SYS_syscall, and SYS___syscall. The former is the old syscall()
138 * routine, basically; the latter is for quad-aligned arguments.
139 */
140#ifdef __ARM_EABI__
141 syscall_num = regs.r[7];
142#else
143 if ((syscall_num = ptrace(PT_READ_I, tid,
144 (caddr_t)(regs.r[_REG_PC] - INSN_SIZE), 0)) == -1) {
145 fprintf(trussinfo->outfile, "-- CANNOT READ PC --\n");
146 return;
147 }
148 syscall_num = syscall_num & 0x000fffff;
149#endif
150 switch (syscall_num) {
151 case SYS_syscall:
152 syscall_num = *ap++;
153 nargs--;
154 break;
155 case SYS___syscall:
156 syscall_num = ap[_QUAD_LOWWORD];
157 ap += 2;
158 nargs -= 2;
159 break;
160 }
161
162 fsc = alloc_fsc();
163 if (fsc == NULL)
164 return;
165 fsc->number = syscall_num;
166 fsc->name = (syscall_num < 0 || syscall_num >= nsyscalls) ?
167 NULL : syscallnames[syscall_num];
168 if (!fsc->name) {
169 fprintf(trussinfo->outfile, "-- UNKNOWN SYSCALL %d --\n",
170 syscall_num);
171 }
172
173 if (fsc->name && (trussinfo->flags & FOLLOWFORKS) &&
174 (strcmp(fsc->name, "fork") == 0 ||
175 strcmp(fsc->name, "pdfork") == 0 ||
176 strcmp(fsc->name, "rfork") == 0 ||
177 strcmp(fsc->name, "vfork") == 0))
178 trussinfo->curthread->in_fork = 1;
179
180 if (nargs == 0)
181 return;
182
183 fsc->args = malloc((1 + nargs) * sizeof(unsigned long));
184 switch (nargs) {
185 default:
186 /*
187 * The OS doesn't seem to allow more than 10 words of
188 * parameters (yay!). So we shouldn't be here.
189 */
190 warn("More than 10 words (%d) of arguments!\n", nargs);
191 break;
192 case 10:
193 case 9:
194 case 8:
195 case 7:
196 case 6:
197 case 5:
198 /*
199 * If there are 7-10 words of arguments, they are placed
200 * on the stack, as is normal for other processors.
201 * The fall-through for all of these is deliberate!!!
202 */
203 // XXX BAD constant used here
204 iorequest.piod_op = PIOD_READ_D;
205 iorequest.piod_offs = (void *)(regs.r_sp +
206 4 * sizeof(uint32_t));
207 iorequest.piod_addr = &fsc->args[4];
208 iorequest.piod_len = (nargs - 4) * sizeof(fsc->args[0]);
209 ptrace(PT_IO, tid, (caddr_t)&iorequest, 0);
210 if (iorequest.piod_len == 0)
211 return;
212 case 4: fsc->args[3] = ap[3];
213 case 3: fsc->args[2] = ap[2];
214 case 2: fsc->args[1] = ap[1];
215 case 1: fsc->args[0] = ap[0];
216 case 0: break;
217 }
218
219 sc = NULL;
220 if (fsc->name)
221 sc = get_syscall(fsc->name);
222 if (sc)
223 fsc->nargs = sc->nargs;
224 else {
225#if DEBUG
226 fprintf(trussinfo->outfile, "unknown syscall %s -- setting "
227 "args to %d\n", fsc->name, nargs);
228#endif
229 fsc->nargs = nargs;
230 }
231
232 fsc->s_args = calloc(1, (1 + fsc->nargs) * sizeof(char *));
233 fsc->sc = sc;
234
235 /*
236 * At this point, we set up the system call arguments.
237 * We ignore any OUT ones, however -- those are arguments that
238 * are set by the system call, and so are probably meaningless
239 * now. This doesn't currently support arguments that are
240 * passed in *and* out, however.
241 */
242
243 if (fsc->name) {
244#if DEBUG
245 fprintf(stderr, "syscall %s(", fsc->name);
246#endif
247 for (i = 0; i < fsc->nargs; i++) {
248#if DEBUG
249 fprintf(stderr, "0x%x%s", sc ?
250 fsc->args[sc->args[i].offset] : fsc->args[i],
251 i < (fsc->nargs - 1) ? "," : "");
252#endif
253 if (sc && !(sc->args[i].type & OUT)) {
254 fsc->s_args[i] = print_arg(&sc->args[i],
255 fsc->args, 0, trussinfo);
256 }
257 }
258#if DEBUG
259 fprintf(stderr, ")\n");
260#endif
261 }
262
263#if DEBUG
264 fprintf(trussinfo->outfile, "\n");
265#endif
266
267 if (fsc->name != NULL && (strcmp(fsc->name, "execve") == 0 ||
268 strcmp(fsc->name, "exit") == 0)) {
269 /*
270 * XXX
271 * This could be done in a more general
272 * manner but it still wouldn't be very pretty.
273 */
274 if (strcmp(fsc->name, "execve") == 0) {
275 if ((trussinfo->flags & EXECVEARGS) == 0) {
276 if (fsc->s_args[1]) {
277 free(fsc->s_args[1]);
278 fsc->s_args[1] = NULL;
279 }
280 }
281 if ((trussinfo->flags & EXECVEENVS) == 0) {
282 if (fsc->s_args[2]) {
283 free(fsc->s_args[2]);
284 fsc->s_args[2] = NULL;
285 }
286 }
287 }
288 }
289 trussinfo->curthread->fsc = fsc;
290}
291
292/*
293 * And when the system call is done, we handle it here.
294 * Currently, no attempt is made to ensure that the system calls
295 * match -- this needs to be fixed (and is, in fact, why S_SCX includes
296 * the system call number instead of, say, an error status).
297 */
298
299long
300arm_syscall_exit(struct trussinfo *trussinfo, int syscall_num __unused)
301{
302 struct reg regs;
303 struct freebsd_syscall *fsc;
304 struct syscall *sc;
305 lwpid_t tid;
306 long retval;
307 int errorp, i;
308
309 if (trussinfo->curthread->fsc == NULL)
310 return (-1);
311
312 tid = trussinfo->curthread->tid;
313
314 if (ptrace(PT_GETREGS, tid, (caddr_t)&regs, 0) < 0) {
315 fprintf(trussinfo->outfile, "-- CANNOT READ REGISTERS --\n");
316 return (-1);
317 }
318
319 retval = regs.r[0];
320 errorp = !!(regs.r_cpsr & PSR_C);
321
322 /*
323 * This code, while simpler than the initial versions I used, could
324 * stand some significant cleaning.
325 */
326
327 fsc = trussinfo->curthread->fsc;
328 sc = fsc->sc;
329 if (!sc) {
330 for (i = 0; i < fsc->nargs; i++)
331 asprintf(&fsc->s_args[i], "0x%lx", fsc->args[i]);
332 } else {
333 /*
334 * Here, we only look for arguments that have OUT masked in --
335 * otherwise, they were handled in the syscall_entry function.
336 */
337 for (i = 0; i < sc->nargs; i++) {
338 char *temp;
339 if (sc->args[i].type & OUT) {
340 /*
341 * If an error occurred, then don't bother
342 * getting the data; it may not be valid.
343 */
344 if (errorp) {
345 asprintf(&temp, "0x%lx",
346 fsc->args[sc->args[i].offset]);
347 } else {
348 temp = print_arg(&sc->args[i],
349 fsc->args, retval, trussinfo);
350 }
351 fsc->s_args[i] = temp;
352 }
353 }
354 }
355
356 if (fsc->name != NULL && (strcmp(fsc->name, "execve") == 0 ||
357 strcmp(fsc->name, "exit") == 0))
358 trussinfo->curthread->in_syscall = 1;
359
360 /*
361 * It would probably be a good idea to merge the error handling,
362 * but that complicates things considerably.
363 */
364
365 print_syscall_ret(trussinfo, fsc->name, fsc->nargs, fsc->s_args, errorp,
366 retval, fsc->sc);
367 free_fsc(fsc);
368
369 return (retval);
370}