2 * Copyright (c) 1991, 1992 Paul Kranenburg <pk@cs.few.eur.nl>
3 * Copyright (c) 1993 Branko Lankester <branko@hacktic.nl>
4 * Copyright (c) 1993, 1994, 1995, 1996 Rick Sladkey <jrs@world.std.com>
5 * Copyright (c) 1996-1999 Wichert Akkerman <wichert@cistron.nl>
6 * Copyright (c) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation
7 * Linux for s390 port by D.J. Barrow
8 * <barrow_dj@mail.yahoo.com,djbarrow@de.ibm.com>
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. The name of the author may not be used to endorse or promote products
20 * derived from this software without specific prior written permission.
22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
25 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
27 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
31 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
42 #include <sys/syscall.h>
43 #include <sys/param.h>
47 #ifndef PTRACE_PEEKUSR
48 # define PTRACE_PEEKUSR PTRACE_PEEKUSER
50 #elif defined(HAVE_LINUX_PTRACE_H)
52 # ifdef HAVE_STRUCT_IA64_FPREG
53 # define ia64_fpreg XXX_ia64_fpreg
55 # ifdef HAVE_STRUCT_PT_ALL_USER_REGS
56 # define pt_all_user_regs XXX_pt_all_user_regs
58 #include <linux/ptrace.h>
60 # undef pt_all_user_regs
63 #if defined (LINUX) && defined (SPARC64)
64 # undef PTRACE_GETREGS
65 # define PTRACE_GETREGS PTRACE_GETREGS64
66 # undef PTRACE_SETREGS
67 # define PTRACE_SETREGS PTRACE_SETREGS64
68 #endif /* LINUX && SPARC64 */
70 #if defined(LINUX) && defined(IA64)
71 # include <asm/ptrace_offsets.h>
75 #define NR_SYSCALL_BASE 0
78 #define ERESTARTSYS 512
80 #ifndef ERESTARTNOINTR
81 #define ERESTARTNOINTR 513
83 #ifndef ERESTARTNOHAND
84 #define ERESTARTNOHAND 514 /* restart if no handler.. */
87 #define ENOIOCTLCMD 515 /* No ioctl command */
89 #ifndef ERESTART_RESTARTBLOCK
90 #define ERESTART_RESTARTBLOCK 516 /* restart by calling sys_restart_syscall */
93 #warning: NSIG is not defined, using 32
97 /* Ugh. Is this really correct? ARM has no RT signals?! */
100 #undef NR_SYSCALL_BASE
101 #define NR_SYSCALL_BASE __NR_SYSCALL_BASE
107 /* Define these shorthand notations to simplify the syscallent files. */
108 #define TD TRACE_DESC
109 #define TF TRACE_FILE
111 #define TN TRACE_NETWORK
112 #define TP TRACE_PROCESS
113 #define TS TRACE_SIGNAL
114 #define NF SYSCALL_NEVER_FAILS
117 static const struct sysent sysent0[] = {
118 #include "syscallent.h"
121 #if SUPPORTED_PERSONALITIES >= 2
122 static const struct sysent sysent1[] = {
123 #include "syscallent1.h"
127 #if SUPPORTED_PERSONALITIES >= 3
128 static const struct sysent sysent2[] = {
129 #include "syscallent2.h"
133 /* Now undef them since short defines cause wicked namespace pollution. */
145 * `ioctlent.h' may be generated from `ioctlent.raw' by the auxiliary
146 * program `ioctlsort', such that the list is sorted by the `code' field.
147 * This has the side-effect of resolving the _IO.. macros into
148 * plain integers, eliminating the need to include here everything
153 static const char *const errnoent0[] = {
154 #include "errnoent.h"
156 static const char *const signalent0[] = {
157 #include "signalent.h"
159 static const struct ioctlent ioctlent0[] = {
160 #include "ioctlent.h"
162 enum { nsyscalls0 = ARRAY_SIZE(sysent0) };
163 enum { nerrnos0 = ARRAY_SIZE(errnoent0) };
164 enum { nsignals0 = ARRAY_SIZE(signalent0) };
165 enum { nioctlents0 = ARRAY_SIZE(ioctlent0) };
166 int qual_flags0[MAX_QUALS];
168 #if SUPPORTED_PERSONALITIES >= 2
169 static const char *const errnoent1[] = {
170 #include "errnoent1.h"
172 static const char *const signalent1[] = {
173 #include "signalent1.h"
175 static const struct ioctlent ioctlent1[] = {
176 #include "ioctlent1.h"
178 enum { nsyscalls1 = ARRAY_SIZE(sysent1) };
179 enum { nerrnos1 = ARRAY_SIZE(errnoent1) };
180 enum { nsignals1 = ARRAY_SIZE(signalent1) };
181 enum { nioctlents1 = ARRAY_SIZE(ioctlent1) };
182 int qual_flags1[MAX_QUALS];
185 #if SUPPORTED_PERSONALITIES >= 3
186 static const char *const errnoent2[] = {
187 #include "errnoent2.h"
189 static const char *const signalent2[] = {
190 #include "signalent2.h"
192 static const struct ioctlent ioctlent2[] = {
193 #include "ioctlent2.h"
195 enum { nsyscalls2 = ARRAY_SIZE(sysent2) };
196 enum { nerrnos2 = ARRAY_SIZE(errnoent2) };
197 enum { nsignals2 = ARRAY_SIZE(signalent2) };
198 enum { nioctlents2 = ARRAY_SIZE(ioctlent2) };
199 int qual_flags2[MAX_QUALS];
203 const struct sysent *sysent;
204 const char *const *errnoent;
205 const char *const *signalent;
206 const struct ioctlent *ioctlent;
213 int current_personality;
215 #ifndef PERSONALITY0_WORDSIZE
216 # define PERSONALITY0_WORDSIZE sizeof(long)
218 const int personality_wordsize[SUPPORTED_PERSONALITIES] = {
219 PERSONALITY0_WORDSIZE,
220 #if SUPPORTED_PERSONALITIES > 1
221 PERSONALITY1_WORDSIZE,
223 #if SUPPORTED_PERSONALITIES > 2
224 PERSONALITY2_WORDSIZE,
229 set_personality(int personality)
231 switch (personality) {
233 errnoent = errnoent0;
236 nsyscalls = nsyscalls0;
237 ioctlent = ioctlent0;
238 nioctlents = nioctlents0;
239 signalent = signalent0;
240 nsignals = nsignals0;
241 qual_flags = qual_flags0;
244 #if SUPPORTED_PERSONALITIES >= 2
246 errnoent = errnoent1;
249 nsyscalls = nsyscalls1;
250 ioctlent = ioctlent1;
251 nioctlents = nioctlents1;
252 signalent = signalent1;
253 nsignals = nsignals1;
254 qual_flags = qual_flags1;
258 #if SUPPORTED_PERSONALITIES >= 3
260 errnoent = errnoent2;
263 nsyscalls = nsyscalls2;
264 ioctlent = ioctlent2;
265 nioctlents = nioctlents2;
266 signalent = signalent2;
267 nsignals = nsignals2;
268 qual_flags = qual_flags2;
273 current_personality = personality;
277 static int qual_syscall(), qual_signal(), qual_fault(), qual_desc();
279 static const struct qual_options {
281 const char *option_name;
282 int (*qualify)(const char *, int, int);
283 const char *argument_name;
285 { QUAL_TRACE, "trace", qual_syscall, "system call" },
286 { QUAL_TRACE, "t", qual_syscall, "system call" },
287 { QUAL_ABBREV, "abbrev", qual_syscall, "system call" },
288 { QUAL_ABBREV, "a", qual_syscall, "system call" },
289 { QUAL_VERBOSE, "verbose", qual_syscall, "system call" },
290 { QUAL_VERBOSE, "v", qual_syscall, "system call" },
291 { QUAL_RAW, "raw", qual_syscall, "system call" },
292 { QUAL_RAW, "x", qual_syscall, "system call" },
293 { QUAL_SIGNAL, "signal", qual_signal, "signal" },
294 { QUAL_SIGNAL, "signals", qual_signal, "signal" },
295 { QUAL_SIGNAL, "s", qual_signal, "signal" },
296 { QUAL_FAULT, "fault", qual_fault, "fault" },
297 { QUAL_FAULT, "faults", qual_fault, "fault" },
298 { QUAL_FAULT, "m", qual_fault, "fault" },
299 { QUAL_READ, "read", qual_desc, "descriptor" },
300 { QUAL_READ, "reads", qual_desc, "descriptor" },
301 { QUAL_READ, "r", qual_desc, "descriptor" },
302 { QUAL_WRITE, "write", qual_desc, "descriptor" },
303 { QUAL_WRITE, "writes", qual_desc, "descriptor" },
304 { QUAL_WRITE, "w", qual_desc, "descriptor" },
305 { 0, NULL, NULL, NULL },
309 qualify_one(int n, int bitflag, int not, int pers)
311 if (pers == 0 || pers < 0) {
313 qual_flags0[n] &= ~bitflag;
315 qual_flags0[n] |= bitflag;
318 #if SUPPORTED_PERSONALITIES >= 2
319 if (pers == 1 || pers < 0) {
321 qual_flags1[n] &= ~bitflag;
323 qual_flags1[n] |= bitflag;
325 #endif /* SUPPORTED_PERSONALITIES >= 2 */
327 #if SUPPORTED_PERSONALITIES >= 3
328 if (pers == 2 || pers < 0) {
330 qual_flags2[n] &= ~bitflag;
332 qual_flags2[n] |= bitflag;
334 #endif /* SUPPORTED_PERSONALITIES >= 3 */
338 qual_syscall(const char *s, int bitflag, int not)
343 if (isdigit((unsigned char)*s)) {
345 if (i < 0 || i >= MAX_QUALS)
347 qualify_one(i, bitflag, not, -1);
350 for (i = 0; i < nsyscalls0; i++)
351 if (strcmp(s, sysent0[i].sys_name) == 0) {
352 qualify_one(i, bitflag, not, 0);
356 #if SUPPORTED_PERSONALITIES >= 2
357 for (i = 0; i < nsyscalls1; i++)
358 if (strcmp(s, sysent1[i].sys_name) == 0) {
359 qualify_one(i, bitflag, not, 1);
362 #endif /* SUPPORTED_PERSONALITIES >= 2 */
364 #if SUPPORTED_PERSONALITIES >= 3
365 for (i = 0; i < nsyscalls2; i++)
366 if (strcmp(s, sysent2[i].sys_name) == 0) {
367 qualify_one(i, bitflag, not, 2);
370 #endif /* SUPPORTED_PERSONALITIES >= 3 */
376 qual_signal(const char *s, int bitflag, int not)
381 if (isdigit((unsigned char)*s)) {
383 if (signo < 0 || signo >= MAX_QUALS)
385 qualify_one(signo, bitflag, not, -1);
388 if (strlen(s) >= sizeof buf)
392 if (strncasecmp(s, "SIG", 3) == 0)
394 for (i = 0; i <= NSIG; i++)
395 if (strcasecmp(s, signame(i) + 3) == 0) {
396 qualify_one(i, bitflag, not, -1);
403 qual_fault(const char *s, int bitflag, int not)
409 qual_desc(const char *s, int bitflag, int not)
411 if (isdigit((unsigned char)*s)) {
413 if (desc < 0 || desc >= MAX_QUALS)
415 qualify_one(desc, bitflag, not, -1);
422 lookup_class(const char *s)
424 if (strcmp(s, "file") == 0)
426 if (strcmp(s, "ipc") == 0)
428 if (strcmp(s, "network") == 0)
429 return TRACE_NETWORK;
430 if (strcmp(s, "process") == 0)
431 return TRACE_PROCESS;
432 if (strcmp(s, "signal") == 0)
434 if (strcmp(s, "desc") == 0)
440 qualify(const char *s)
442 const struct qual_options *opt;
448 opt = &qual_options[0];
449 for (i = 0; (p = qual_options[i].option_name); i++) {
451 if (strncmp(s, p, n) == 0 && s[n] == '=') {
452 opt = &qual_options[i];
462 if (strcmp(s, "none") == 0) {
466 if (strcmp(s, "all") == 0) {
467 for (i = 0; i < MAX_QUALS; i++) {
468 qualify_one(i, opt->bitflag, not, -1);
472 for (i = 0; i < MAX_QUALS; i++) {
473 qualify_one(i, opt->bitflag, !not, -1);
477 fprintf(stderr, "out of memory\n");
480 for (p = strtok(copy, ","); p; p = strtok(NULL, ",")) {
481 if (opt->bitflag == QUAL_TRACE && (n = lookup_class(p)) > 0) {
482 for (i = 0; i < nsyscalls0; i++)
483 if (sysent0[i].sys_flags & n)
484 qualify_one(i, opt->bitflag, not, 0);
486 #if SUPPORTED_PERSONALITIES >= 2
487 for (i = 0; i < nsyscalls1; i++)
488 if (sysent1[i].sys_flags & n)
489 qualify_one(i, opt->bitflag, not, 1);
490 #endif /* SUPPORTED_PERSONALITIES >= 2 */
492 #if SUPPORTED_PERSONALITIES >= 3
493 for (i = 0; i < nsyscalls2; i++)
494 if (sysent2[i].sys_flags & n)
495 qualify_one(i, opt->bitflag, not, 2);
496 #endif /* SUPPORTED_PERSONALITIES >= 3 */
500 if (opt->qualify(p, opt->bitflag, not)) {
501 fprintf(stderr, "strace: invalid %s `%s'\n",
502 opt->argument_name, p);
511 enum subcall_style { shift_style, deref_style, mask_style, door_style };
513 enum subcall_style { shift_style, deref_style, mask_style, door_style, table_style };
521 static const struct subcall subcalls_table[] = {
522 { SYS_shmsys, 5, { SYS_shmat, SYS_shmctl, SYS_shmdt, SYS_shmget, SYS_shmctl } },
524 { SYS_semsys, 4, { SYS___semctl, SYS_semget, SYS_semop, SYS_semconfig } },
526 { SYS_semsys, 3, { SYS___semctl, SYS_semget, SYS_semop } },
528 { SYS_msgsys, 4, { SYS_msgctl, SYS_msgget, SYS_msgsnd, SYS_msgrcv } },
532 #if !(defined(LINUX) && ( defined(ALPHA) || defined(MIPS) || defined(__ARM_EABI__) ))
535 decode_subcall(struct tcb *tcp, int subcall, int nsubcalls, enum subcall_style style)
537 unsigned long addr, mask;
539 int size = personality_wordsize[current_personality];
543 if (tcp->u_arg[0] < 0 || tcp->u_arg[0] >= nsubcalls)
545 tcp->scno = subcall + tcp->u_arg[0];
546 tcp->u_nargs = n = sysent[tcp->scno].nargs;
547 for (i = 0; i < n; i++)
548 tcp->u_arg[i] = tcp->u_arg[i + 1];
551 if (tcp->u_arg[0] < 0 || tcp->u_arg[0] >= nsubcalls)
553 tcp->scno = subcall + tcp->u_arg[0];
554 addr = tcp->u_arg[1];
555 tcp->u_nargs = n = sysent[tcp->scno].nargs;
556 for (i = 0; i < n; i++) {
557 if (size == sizeof(int)) {
559 if (umove(tcp, addr, &arg) < 0)
563 else if (size == sizeof(long)) {
565 if (umove(tcp, addr, &arg) < 0)
575 mask = (tcp->u_arg[0] >> 8) & 0xff;
576 for (i = 0; mask; i++)
580 tcp->u_arg[0] &= 0xff;
581 tcp->scno = subcall + i;
582 tcp->u_nargs = sysent[tcp->scno].nargs;
586 * Oh, yuck. The call code is the *sixth* argument.
587 * (don't you mean the *last* argument? - JH)
589 if (tcp->u_arg[5] < 0 || tcp->u_arg[5] >= nsubcalls)
591 tcp->scno = subcall + tcp->u_arg[5];
592 tcp->u_nargs = sysent[tcp->scno].nargs;
596 for (i = 0; i < ARRAY_SIZE(subcalls_table); i++)
597 if (subcalls_table[i].call == tcp->scno) break;
598 if (i < ARRAY_SIZE(subcalls_table) &&
599 tcp->u_arg[0] >= 0 && tcp->u_arg[0] < subcalls_table[i].nsubcalls) {
600 tcp->scno = subcalls_table[i].subcalls[tcp->u_arg[0]];
601 for (i = 0; i < tcp->u_nargs; i++)
602 tcp->u_arg[i] = tcp->u_arg[i + 1];
611 printargs(struct tcb *tcp)
616 for (i = 0; i < tcp->u_nargs; i++)
617 tprintf("%s%#lx", i ? ", " : "", tcp->u_arg[i]);
623 getrval2(struct tcb *tcp)
628 #if defined (SPARC) || defined (SPARC64)
630 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0)
632 val = regs.u_regs[U_REG_O1];
634 if (upeek(tcp, 4*(REG_REG0+1), &val) < 0)
637 if (upeek(tcp, PT_R9, &val) < 0)
643 if (upeek(tcp, uoff(u_rval2), &val) < 0)
649 val = tcp->status.PR_REG[R_O1];
652 val = tcp->status.PR_REG[EDX];
655 val = tcp->status.PR_REG[RDX];
658 val = tcp->status.PR_REG[CTX_V1];
664 pread(tcp->pfd_reg, ®s, sizeof(regs), 0);
672 * Apparently, indirect system calls have already be converted by ptrace(2),
673 * so if you see "indir" this program has gone astray.
676 sys_indir(struct tcb *tcp)
681 scno = tcp->u_arg[0];
682 if (scno > nsyscalls) {
683 fprintf(stderr, "Bogus syscall: %u\n", scno);
686 nargs = sysent[scno].nargs;
687 tprintf("%s", sysent[scno].sys_name);
688 for (i = 0; i < nargs; i++)
689 tprintf(", %#lx", tcp->u_arg[i+1]);
696 is_restart_error(struct tcb *tcp)
701 switch (tcp->u_error) {
705 case ERESTART_RESTARTBLOCK:
714 struct tcb *tcp_last = NULL;
719 # elif defined (IA64)
720 long r8, r10, psr; /* TODO: make static? */
721 long ia32 = 0; /* not static */
722 # elif defined (POWERPC)
723 static long result, flags;
724 # elif defined (M68K)
729 static struct pt_regs regs;
730 # elif defined (ALPHA)
733 # elif defined(AVR32)
734 static struct pt_regs regs;
735 # elif defined (SPARC) || defined (SPARC64)
736 static struct pt_regs regs;
737 static unsigned long trap;
738 # elif defined(LINUX_MIPSN32)
744 # elif defined(S390) || defined(S390X)
747 static long syscall_mode;
754 # elif defined(X86_64)
756 # elif defined(CRISV10) || defined(CRISV32)
758 # elif defined(MICROBLAZE)
763 struct reg regs; /* TODO: make static? */
767 * 0: "ignore this ptrace stop", bail out of trace_syscall() silently.
768 * 1: ok, continue in trace_syscall().
769 * other: error, trace_syscall() should print error indicator
770 * ("????" etc) and bail out.
776 get_scno(struct tcb *tcp)
781 # if defined(S390) || defined(S390X)
782 if (upeek(tcp, PT_GPR2, &syscall_mode) < 0)
785 if (syscall_mode != -ENOSYS) {
787 * Since kernel version 2.5.44 the scno gets passed in gpr2.
792 * Old style of "passing" the scno via the SVC instruction.
794 long opcode, offset_reg, tmp;
796 static const int gpr_offset[16] = {
797 PT_GPR0, PT_GPR1, PT_ORIGGPR2, PT_GPR3,
798 PT_GPR4, PT_GPR5, PT_GPR6, PT_GPR7,
799 PT_GPR8, PT_GPR9, PT_GPR10, PT_GPR11,
800 PT_GPR12, PT_GPR13, PT_GPR14, PT_GPR15
803 if (upeek(tcp, PT_PSWADDR, &pc) < 0)
806 opcode = ptrace(PTRACE_PEEKTEXT, tcp->pid, (char *)(pc-sizeof(long)), 0);
808 perror("peektext(pc-oneword)");
813 * We have to check if the SVC got executed directly or via an
814 * EXECUTE instruction. In case of EXECUTE it is necessary to do
815 * instruction decoding to derive the system call number.
816 * Unfortunately the opcode sizes of EXECUTE and SVC are differently,
817 * so that this doesn't work if a SVC opcode is part of an EXECUTE
818 * opcode. Since there is no way to find out the opcode size this
819 * is the best we can do...
821 if ((opcode & 0xff00) == 0x0a00) {
823 scno = opcode & 0xff;
826 /* SVC got executed by EXECUTE instruction */
829 * Do instruction decoding of EXECUTE. If you really want to
830 * understand this, read the Principles of Operations.
832 svc_addr = (void *) (opcode & 0xfff);
835 offset_reg = (opcode & 0x000f0000) >> 16;
836 if (offset_reg && (upeek(tcp, gpr_offset[offset_reg], &tmp) < 0))
841 offset_reg = (opcode & 0x0000f000) >> 12;
842 if (offset_reg && (upeek(tcp, gpr_offset[offset_reg], &tmp) < 0))
846 scno = ptrace(PTRACE_PEEKTEXT, tcp->pid, svc_addr, 0);
855 offset_reg = (opcode & 0x00f00000) >> 20;
856 if (offset_reg && (upeek(tcp, gpr_offset[offset_reg], &tmp) < 0))
859 scno = (scno | tmp) & 0xff;
862 # elif defined (POWERPC)
863 if (upeek(tcp, sizeof(unsigned long)*PT_R0, &scno) < 0)
866 /* TODO: speed up strace by not doing this at every syscall.
867 * We only need to do it after execve.
873 /* Check for 64/32 bit mode. */
874 if (upeek(tcp, sizeof(unsigned long)*PT_MSR, &val) < 0)
876 /* SF is bit 0 of MSR */
881 if (currpers != current_personality) {
882 static const char *const names[] = {"64 bit", "32 bit"};
883 set_personality(currpers);
884 fprintf(stderr, "[ Process PID=%d runs in %s mode. ]\n",
885 pid, names[current_personality]);
888 # elif defined(AVR32)
889 /* Read complete register set in one go. */
890 if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, ®s) < 0)
894 if (upeek(tcp, PT_ORIG_P0, &scno))
896 # elif defined (I386)
897 if (upeek(tcp, 4*ORIG_EAX, &scno) < 0)
899 # elif defined (X86_64)
900 if (upeek(tcp, 8*ORIG_RAX, &scno) < 0)
903 /* TODO: speed up strace by not doing this at every syscall.
904 * We only need to do it after execve.
910 /* Check CS register value. On x86-64 linux it is:
911 * 0x33 for long mode (64 bit)
912 * 0x23 for compatibility mode (32 bit)
913 * It takes only one ptrace and thus doesn't need
916 if (upeek(tcp, 8*CS, &val) < 0)
919 case 0x23: currpers = 1; break;
920 case 0x33: currpers = 0; break;
922 fprintf(stderr, "Unknown value CS=0x%02X while "
923 "detecting personality of process "
924 "PID=%d\n", (int)val, pid);
925 currpers = current_personality;
929 /* This version analyzes the opcode of a syscall instruction.
930 * (int 0x80 on i386 vs. syscall on x86-64)
931 * It works, but is too complicated.
933 unsigned long val, rip, i;
935 if (upeek(tcp, 8*RIP, &rip) < 0)
936 perror("upeek(RIP)");
938 /* sizeof(syscall) == sizeof(int 0x80) == 2 */
942 call = ptrace(PTRACE_PEEKTEXT, pid, (char *)rip, (char *)0);
944 fprintf(stderr, "ptrace_peektext failed: %s\n",
946 switch (call & 0xffff) {
947 /* x86-64: syscall = 0x0f 0x05 */
948 case 0x050f: currpers = 0; break;
949 /* i386: int 0x80 = 0xcd 0x80 */
950 case 0x80cd: currpers = 1; break;
952 currpers = current_personality;
954 "Unknown syscall opcode (0x%04X) while "
955 "detecting personality of process "
956 "PID=%d\n", (int)call, pid);
960 if (currpers != current_personality) {
961 static const char *const names[] = {"64 bit", "32 bit"};
962 set_personality(currpers);
963 fprintf(stderr, "[ Process PID=%d runs in %s mode. ]\n",
964 pid, names[current_personality]);
967 # define IA64_PSR_IS ((long)1 << 34)
968 if (upeek(tcp, PT_CR_IPSR, &psr) >= 0)
969 ia32 = (psr & IA64_PSR_IS) != 0;
971 if (upeek(tcp, PT_R1, &scno) < 0) /* orig eax */
974 if (upeek(tcp, PT_R15, &scno) < 0)
978 /* Read complete register set in one go. */
979 if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (void *)®s) == -1)
983 * We only need to grab the syscall number on syscall entry.
985 if (regs.ARM_ip == 0) {
987 * Note: we only deal with only 32-bit CPUs here.
989 if (regs.ARM_cpsr & 0x20) {
991 * Get the Thumb-mode system call number
996 * Get the ARM-mode system call number
999 scno = ptrace(PTRACE_PEEKTEXT, tcp->pid, (void *)(regs.ARM_pc - 4), NULL);
1003 /* Handle the EABI syscall convention. We do not
1004 bother converting structures between the two
1005 ABIs, but basic functionality should work even
1006 if strace and the traced program have different
1008 if (scno == 0xef000000) {
1011 if ((scno & 0x0ff00000) != 0x0f900000) {
1012 fprintf(stderr, "syscall: unknown syscall trap 0x%08lx\n",
1018 * Fixup the syscall number
1023 if (scno & 0x0f0000) {
1025 * Handle ARM specific syscall
1033 fprintf(stderr, "pid %d stray syscall entry\n", tcp->pid);
1034 tcp->flags |= TCB_INSYSCALL;
1036 # elif defined (M68K)
1037 if (upeek(tcp, 4*PT_ORIG_D0, &scno) < 0)
1039 # elif defined (LINUX_MIPSN32)
1040 unsigned long long regs[38];
1042 if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (long) ®s) < 0)
1048 if (scno < 0 || scno > nsyscalls) {
1049 if (a3 == 0 || a3 == -1) {
1051 fprintf(stderr, "stray syscall exit: v0 = %ld\n", scno);
1055 # elif defined (MIPS)
1056 if (upeek(tcp, REG_A3, &a3) < 0)
1058 if (upeek(tcp, REG_V0, &scno) < 0)
1061 if (scno < 0 || scno > nsyscalls) {
1062 if (a3 == 0 || a3 == -1) {
1064 fprintf(stderr, "stray syscall exit: v0 = %ld\n", scno);
1068 # elif defined (ALPHA)
1069 if (upeek(tcp, REG_A3, &a3) < 0)
1071 if (upeek(tcp, REG_R0, &scno) < 0)
1075 * Do some sanity checks to figure out if it's
1076 * really a syscall entry
1078 if (scno < 0 || scno > nsyscalls) {
1079 if (a3 == 0 || a3 == -1) {
1081 fprintf(stderr, "stray syscall exit: r0 = %ld\n", scno);
1085 # elif defined (SPARC) || defined (SPARC64)
1086 /* Everything we need is in the current register set. */
1087 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0)
1090 /* Disassemble the syscall trap. */
1091 /* Retrieve the syscall trap instruction. */
1093 # if defined(SPARC64)
1094 trap = ptrace(PTRACE_PEEKTEXT, tcp->pid, (char *)regs.tpc, 0);
1097 trap = ptrace(PTRACE_PEEKTEXT, tcp->pid, (char *)regs.pc, 0);
1102 /* Disassemble the trap to see what personality to use. */
1105 /* Linux/SPARC syscall trap. */
1109 /* Linux/SPARC64 syscall trap. */
1113 /* SunOS syscall trap. (pers 1) */
1114 fprintf(stderr, "syscall: SunOS no support\n");
1117 /* Solaris 2.x syscall trap. (per 2) */
1121 /* NetBSD/FreeBSD syscall trap. */
1122 fprintf(stderr, "syscall: NetBSD/FreeBSD not supported\n");
1125 /* Solaris 2.x gettimeofday */
1129 # if defined (SPARC64)
1130 fprintf(stderr, "syscall: unknown syscall trap %08lx %016lx\n", trap, regs.tpc);
1132 fprintf(stderr, "syscall: unknown syscall trap %08lx %08lx\n", trap, regs.pc);
1137 /* Extract the system call number from the registers. */
1138 if (trap == 0x91d02027)
1141 scno = regs.u_regs[U_REG_G1];
1143 scno = regs.u_regs[U_REG_O0];
1144 memmove(®s.u_regs[U_REG_O0], ®s.u_regs[U_REG_O1], 7*sizeof(regs.u_regs[0]));
1146 # elif defined(HPPA)
1147 if (upeek(tcp, PT_GR20, &scno) < 0)
1151 * In the new syscall ABI, the system call number is in R3.
1153 if (upeek(tcp, 4*(REG_REG0+3), &scno) < 0)
1157 /* Odd as it may seem, a glibc bug has been known to cause
1158 glibc to issue bogus negative syscall numbers. So for
1159 our purposes, make strace print what it *should* have been */
1160 long correct_scno = (scno & 0xff);
1163 "Detected glibc bug: bogus system call"
1164 " number = %ld, correcting to %ld\n",
1167 scno = correct_scno;
1169 # elif defined(SH64)
1170 if (upeek(tcp, REG_SYSCALL, &scno) < 0)
1173 # elif defined(CRISV10) || defined(CRISV32)
1174 if (upeek(tcp, 4*PT_R9, &scno) < 0)
1176 # elif defined(TILE)
1177 if (upeek(tcp, PTREGS_OFFSET_REG(10), &scno) < 0)
1179 # elif defined(MICROBLAZE)
1180 if (upeek(tcp, 0, &scno) < 0)
1186 if (upeek(tcp, uoff(u_arg[7]), &scno) < 0)
1189 /* new syscall ABI returns result in R0 */
1190 if (upeek(tcp, 4*REG_REG0, (long *)&r0) < 0)
1193 /* ABI defines result returned in r9 */
1194 if (upeek(tcp, REG_GENERAL(9), (long *)&r9) < 0)
1199 # ifdef HAVE_PR_SYSCALL
1200 scno = tcp->status.PR_SYSCALL;
1203 scno = tcp->status.PR_WHAT;
1205 if (pread(tcp->pfd_reg, ®s, sizeof(regs), 0) < 0) {
1209 switch (regs.r_eax) {
1212 pread(tcp->pfd, &scno, sizeof(scno), regs.r_esp + sizeof(int));
1218 # endif /* FREEBSD */
1219 # endif /* !HAVE_PR_SYSCALL */
1220 #endif /* USE_PROCFS */
1227 known_scno(struct tcb *tcp)
1229 long scno = tcp->scno;
1230 #if SUPPORTED_PERSONALITIES > 1
1231 if (scno >= 0 && scno < nsyscalls && sysent[scno].native_scno != 0)
1232 scno = sysent[scno].native_scno;
1235 scno += NR_SYSCALL_BASE;
1239 /* Called in trace_syscall() at each syscall entry and exit.
1241 * 0: "ignore this ptrace stop", bail out of trace_syscall() silently.
1242 * 1: ok, continue in trace_syscall().
1243 * other: error, trace_syscall() should print error indicator
1244 * ("????" etc) and bail out.
1247 syscall_fixup(struct tcb *tcp)
1250 int scno = known_scno(tcp);
1252 if (entering(tcp)) {
1253 if (tcp->status.PR_WHY != PR_SYSENTRY) {
1257 || scno == SYS_vfork
1258 #endif /* SYS_vfork */
1260 || scno == SYS_fork1
1261 #endif /* SYS_fork1 */
1263 || scno == SYS_forkall
1264 #endif /* SYS_forkall */
1266 || scno == SYS_rfork1
1267 #endif /* SYS_fork1 */
1269 || scno == SYS_rforkall
1270 #endif /* SYS_rforkall */
1272 /* We are returning in the child, fake it. */
1273 tcp->status.PR_WHY = PR_SYSENTRY;
1275 tcp->status.PR_WHY = PR_SYSEXIT;
1278 fprintf(stderr, "syscall: missing entry\n");
1279 tcp->flags |= TCB_INSYSCALL;
1284 if (tcp->status.PR_WHY != PR_SYSEXIT) {
1285 fprintf(stderr, "syscall: missing exit\n");
1286 tcp->flags &= ~TCB_INSYSCALL;
1289 #endif /* USE_PROCFS */
1292 if (entering(tcp)) {
1294 fprintf(stderr, "syscall: missing entry\n");
1295 tcp->flags |= TCB_INSYSCALL;
1302 * This happens when a signal handler
1303 * for a signal which interrupted a
1304 * a system call makes another system call.
1306 fprintf(stderr, "syscall: missing exit\n");
1308 tcp->flags &= ~TCB_INSYSCALL;
1314 /* A common case of "not a syscall entry" is post-execve SIGTRAP */
1316 /* With PTRACE_O_TRACEEXEC, post-execve SIGTRAP is disabled.
1317 * Every extra ptrace call is expensive, so check EAX
1318 * on syscall entry only if PTRACE_O_TRACEEXEC is not enabled:
1320 if (entering(tcp) && !(ptrace_setoptions & PTRACE_O_TRACEEXEC)) {
1321 if (upeek(tcp, 4*EAX, &eax) < 0)
1323 if (eax != -ENOSYS) {
1325 fprintf(stderr, "not a syscall entry (eax = %ld)\n", eax);
1329 #elif defined (X86_64)
1330 if (entering(tcp) && !(ptrace_setoptions & PTRACE_O_TRACEEXEC)) {
1331 if (upeek(tcp, 8*RAX, &rax) < 0)
1333 if (current_personality == 1)
1334 rax = (long int)(int)rax; /* sign extend from 32 bits */
1335 if (rax != -ENOSYS && entering(tcp)) {
1337 fprintf(stderr, "not a syscall entry (rax = %ld)\n", rax);
1341 #elif defined (S390) || defined (S390X)
1342 if (upeek(tcp, PT_GPR2, &gpr2) < 0)
1344 if (syscall_mode != -ENOSYS)
1345 syscall_mode = tcp->scno;
1346 if (gpr2 != syscall_mode && entering(tcp)) {
1348 fprintf(stderr, "not a syscall entry (gpr2 = %ld)\n", gpr2);
1351 else if (((tcp->flags & (TCB_INSYSCALL|TCB_WAITEXECVE))
1352 == (TCB_INSYSCALL|TCB_WAITEXECVE))
1353 && (gpr2 == -ENOSYS || gpr2 == tcp->scno)) {
1355 * Return from execve.
1356 * Fake a return value of zero. We leave the TCB_WAITEXECVE
1357 * flag set for the post-execve SIGTRAP to see and reset.
1361 #elif defined (POWERPC)
1362 # define SO_MASK 0x10000000
1363 if (upeek(tcp, sizeof(unsigned long)*PT_CCR, &flags) < 0)
1365 if (upeek(tcp, sizeof(unsigned long)*PT_R3, &result) < 0)
1367 if (flags & SO_MASK)
1369 #elif defined (M68K)
1370 if (upeek(tcp, 4*PT_D0, &d0) < 0)
1372 if (d0 != -ENOSYS && entering(tcp)) {
1374 fprintf(stderr, "not a syscall entry (d0 = %ld)\n", d0);
1382 if (upeek(tcp, PT_R0, &r0) < 0)
1384 #elif defined (HPPA)
1385 if (upeek(tcp, PT_GR28, &r28) < 0)
1388 if (upeek(tcp, PT_R10, &r10) < 0)
1390 if (upeek(tcp, PT_R8, &r8) < 0)
1392 if (ia32 && r8 != -ENOSYS && entering(tcp)) {
1394 fprintf(stderr, "not a syscall entry (r8 = %ld)\n", r8);
1397 #elif defined(CRISV10) || defined(CRISV32)
1398 if (upeek(tcp, 4*PT_R10, &r10) < 0)
1400 if (r10 != -ENOSYS && entering(tcp)) {
1402 fprintf(stderr, "not a syscall entry (r10 = %ld)\n", r10);
1405 #elif defined(MICROBLAZE)
1406 if (upeek(tcp, 3 * 4, &r3) < 0)
1408 if (r3 != -ENOSYS && entering(tcp)) {
1410 fprintf(stderr, "not a syscall entry (r3 = %ld)\n", r3);
1419 internal_syscall(struct tcb *tcp)
1422 * We must always trace a few critical system calls in order to
1423 * correctly support following forks in the presence of tracing
1428 if (tcp->scno < 0 || tcp->scno >= nsyscalls)
1431 func = sysent[tcp->scno].sys_func;
1433 if ( sys_fork == func
1434 #if defined(FREEBSD) || defined(LINUX) || defined(SUNOS4)
1435 || sys_vfork == func
1438 || sys_clone == func
1441 || sys_rfork == func
1444 return internal_fork(tcp);
1446 #if defined SUNOS4 || (defined LINUX && defined TCB_WAITEXECVE)
1447 if ( sys_execve == func
1448 # if defined(SPARC) || defined(SPARC64) || defined(SUNOS4)
1449 || sys_execv == func
1452 || sys_rexecve == func
1455 return internal_exec(tcp);
1462 syscall_enter(struct tcb *tcp)
1467 if (tcp->scno >= 0 && tcp->scno < nsyscalls)
1468 nargs = tcp->u_nargs = sysent[tcp->scno].nargs;
1470 nargs = tcp->u_nargs = MAX_ARGS;
1472 # if defined(S390) || defined(S390X)
1473 for (i = 0; i < nargs; ++i)
1474 if (upeek(tcp, i==0 ? PT_ORIGGPR2 : PT_GPR2 + i*sizeof(long), &tcp->u_arg[i]) < 0)
1476 # elif defined(ALPHA)
1477 for (i = 0; i < nargs; ++i)
1478 if (upeek(tcp, REG_A0+i, &tcp->u_arg[i]) < 0)
1480 # elif defined(IA64)
1482 unsigned long *out0, cfm, sof, sol;
1484 /* be backwards compatible with kernel < 2.4.4... */
1486 # define PT_RBS_END PT_AR_BSP
1489 if (upeek(tcp, PT_RBS_END, &rbs_end) < 0)
1491 if (upeek(tcp, PT_CFM, (long *) &cfm) < 0)
1494 sof = (cfm >> 0) & 0x7f;
1495 sol = (cfm >> 7) & 0x7f;
1496 out0 = ia64_rse_skip_regs((unsigned long *) rbs_end, -sof + sol);
1498 for (i = 0; i < nargs; ++i) {
1499 if (umoven(tcp, (unsigned long) ia64_rse_skip_regs(out0, i),
1500 sizeof(long), (char *) &tcp->u_arg[i]) < 0)
1504 static const int argreg[MAX_ARGS] = { PT_R11 /* EBX = out0 */,
1505 PT_R9 /* ECX = out1 */,
1506 PT_R10 /* EDX = out2 */,
1507 PT_R14 /* ESI = out3 */,
1508 PT_R15 /* EDI = out4 */,
1509 PT_R13 /* EBP = out5 */};
1511 for (i = 0; i < nargs; ++i) {
1512 if (upeek(tcp, argreg[i], &tcp->u_arg[i]) < 0)
1514 /* truncate away IVE sign-extension */
1515 tcp->u_arg[i] &= 0xffffffff;
1518 # elif defined(LINUX_MIPSN32) || defined(LINUX_MIPSN64)
1519 /* N32 and N64 both use up to six registers. */
1520 unsigned long long regs[38];
1522 if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (long) ®s) < 0)
1525 for (i = 0; i < nargs; ++i) {
1526 tcp->u_arg[i] = regs[REG_A0 + i];
1527 # if defined(LINUX_MIPSN32)
1528 tcp->ext_arg[i] = regs[REG_A0 + i];
1531 # elif defined(MIPS)
1535 if (upeek(tcp, REG_SP, &sp) < 0)
1537 for (i = 0; i < 4; ++i)
1538 if (upeek(tcp, REG_A0 + i, &tcp->u_arg[i]) < 0)
1540 umoven(tcp, sp + 16, (nargs - 4) * sizeof(tcp->u_arg[0]),
1541 (char *)(tcp->u_arg + 4));
1543 for (i = 0; i < nargs; ++i)
1544 if (upeek(tcp, REG_A0 + i, &tcp->u_arg[i]) < 0)
1547 # elif defined(POWERPC)
1549 # define PT_ORIG_R3 34
1551 for (i = 0; i < nargs; ++i) {
1552 if (upeek(tcp, (i==0) ?
1553 (sizeof(unsigned long) * PT_ORIG_R3) :
1554 ((i+PT_R3) * sizeof(unsigned long)),
1555 &tcp->u_arg[i]) < 0)
1558 # elif defined(SPARC) || defined(SPARC64)
1559 for (i = 0; i < nargs; ++i)
1560 tcp->u_arg[i] = regs.u_regs[U_REG_O0 + i];
1561 # elif defined(HPPA)
1562 for (i = 0; i < nargs; ++i)
1563 if (upeek(tcp, PT_GR26-4*i, &tcp->u_arg[i]) < 0)
1566 for (i = 0; i < nargs; ++i)
1567 tcp->u_arg[i] = regs.uregs[i];
1568 # elif defined(AVR32)
1569 static const unsigned long *argregp[MAX_ARGS] = { ®s.r12,
1575 for (i = 0; i < nargs; ++i)
1576 tcp->u_arg[i] = *argregp[i];
1577 # elif defined(BFIN)
1578 static const int argreg[MAX_ARGS] = { PT_R0, PT_R1, PT_R2, PT_R3, PT_R4, PT_R5 };
1580 for (i = 0; i < nargs; ++i)
1581 if (upeek(tcp, argreg[i], &tcp->u_arg[i]) < 0)
1584 static const int syscall_regs[MAX_ARGS] = {
1585 4 * (REG_REG0+4), 4 * (REG_REG0+5), 4 * (REG_REG0+6),
1586 4 * (REG_REG0+7), 4 * (REG_REG0 ), 4 * (REG_REG0+1)
1589 for (i = 0; i < nargs; ++i)
1590 if (upeek(tcp, syscall_regs[i], &tcp->u_arg[i]) < 0)
1592 # elif defined(SH64)
1594 /* Registers used by SH5 Linux system calls for parameters */
1595 static const int syscall_regs[MAX_ARGS] = { 2, 3, 4, 5, 6, 7 };
1597 for (i = 0; i < nargs; ++i)
1598 if (upeek(tcp, REG_GENERAL(syscall_regs[i]), &tcp->u_arg[i]) < 0)
1600 # elif defined(X86_64)
1601 static const int argreg[SUPPORTED_PERSONALITIES][MAX_ARGS] = {
1602 { 8 * RDI, 8 * RSI, 8 * RDX, 8 * R10, 8 * R8 , 8 * R9 }, /* x86-64 ABI */
1603 { 8 * RBX, 8 * RCX, 8 * RDX, 8 * RSI, 8 * RDI, 8 * RBP } /* i386 ABI */
1606 for (i = 0; i < nargs; ++i)
1607 if (upeek(tcp, argreg[current_personality][i], &tcp->u_arg[i]) < 0)
1609 # elif defined(MICROBLAZE)
1610 for (i = 0; i < nargs; ++i)
1611 if (upeek(tcp, (5 + i) * 4, &tcp->u_arg[i]) < 0)
1613 # elif defined(CRISV10) || defined(CRISV32)
1614 static const int crisregs[MAX_ARGS] = {
1615 4*PT_ORIG_R10, 4*PT_R11, 4*PT_R12,
1616 4*PT_R13 , 4*PT_MOF, 4*PT_SRP
1619 for (i = 0; i < nargs; ++i)
1620 if (upeek(tcp, crisregs[i], &tcp->u_arg[i]) < 0)
1622 # elif defined(TILE)
1623 for (i = 0; i < nargs; ++i)
1624 if (upeek(tcp, PTREGS_OFFSET_REG(i), &tcp->u_arg[i]) < 0)
1626 # elif defined(M68K)
1627 for (i = 0; i < nargs; ++i)
1628 if (upeek(tcp, (i < 5 ? i : i + 2)*4, &tcp->u_arg[i]) < 0)
1630 # else /* Other architecture (like i386) (32bits specific) */
1631 for (i = 0; i < nargs; ++i)
1632 if (upeek(tcp, i*4, &tcp->u_arg[i]) < 0)
1638 if (tcp->scno >= 0 && tcp->scno < nsyscalls)
1639 nargs = tcp->u_nargs = sysent[tcp->scno].nargs;
1641 nargs = tcp->u_nargs = MAX_ARGS;
1642 for (i = 0; i < nargs; i++) {
1645 if (upeek(tcp, uoff(u_arg[0]) +
1646 (i * sizeof(u->u_arg[0])), &tcp->u_arg[i]) < 0)
1653 * SGI is broken: even though it has pr_sysarg, it doesn't
1654 * set them on system call entry. Get a clue.
1656 if (tcp->scno >= 0 && tcp->scno < nsyscalls)
1657 tcp->u_nargs = sysent[tcp->scno].nargs;
1659 tcp->u_nargs = tcp->status.pr_nsysarg;
1660 if (tcp->u_nargs > 4) {
1661 memcpy(tcp->u_arg, &tcp->status.pr_reg[CTX_A0],
1662 4 * sizeof(tcp->u_arg[0]));
1663 umoven(tcp, tcp->status.pr_reg[CTX_SP] + 16,
1664 (tcp->u_nargs - 4) * sizeof(tcp->u_arg[0]), (char *) (tcp->u_arg + 4));
1667 memcpy(tcp->u_arg, &tcp->status.pr_reg[CTX_A0],
1668 tcp->u_nargs * sizeof(tcp->u_arg[0]));
1670 # elif UNIXWARE >= 2
1672 * Like SGI, UnixWare doesn't set pr_sysarg until system call exit
1674 if (tcp->scno >= 0 && tcp->scno < nsyscalls)
1675 tcp->u_nargs = sysent[tcp->scno].nargs;
1677 tcp->u_nargs = tcp->status.pr_lwp.pr_nsysarg;
1678 umoven(tcp, tcp->status.PR_REG[UESP] + 4,
1679 tcp->u_nargs * sizeof(tcp->u_arg[0]), (char *) tcp->u_arg);
1680 # elif defined(HAVE_PR_SYSCALL)
1682 if (tcp->scno >= 0 && tcp->scno < nsyscalls)
1683 tcp->u_nargs = sysent[tcp->scno].nargs;
1685 tcp->u_nargs = tcp->status.pr_nsysarg;
1686 for (i = 0; i < tcp->u_nargs; i++)
1687 tcp->u_arg[i] = tcp->status.pr_sysarg[i];
1688 # elif defined(I386)
1689 if (tcp->scno >= 0 && tcp->scno < nsyscalls)
1690 tcp->u_nargs = sysent[tcp->scno].nargs;
1693 if (tcp->u_nargs > 0)
1694 umoven(tcp, tcp->status.PR_REG[UESP] + 4,
1695 tcp->u_nargs * sizeof(tcp->u_arg[0]), (char *) tcp->u_arg);
1697 I DONT KNOW WHAT TO DO
1701 if (tcp->scno >= 0 && tcp->scno < nsyscalls &&
1702 sysent[tcp->scno].nargs > tcp->status.val)
1703 tcp->u_nargs = sysent[tcp->scno].nargs;
1705 tcp->u_nargs = tcp->status.val;
1706 if (tcp->u_nargs < 0)
1708 if (tcp->u_nargs > MAX_ARGS)
1709 tcp->u_nargs = MAX_ARGS;
1710 switch (regs.r_eax) {
1712 pread(tcp->pfd, &tcp->u_arg, tcp->u_nargs * sizeof(unsigned long),
1713 regs.r_esp + sizeof(int) + sizeof(quad_t));
1716 pread(tcp->pfd, &tcp->u_arg, tcp->u_nargs * sizeof(unsigned long),
1717 regs.r_esp + 2 * sizeof(int));
1720 pread(tcp->pfd, &tcp->u_arg, tcp->u_nargs * sizeof(unsigned long),
1721 regs.r_esp + sizeof(int));
1724 #endif /* FREEBSD */
1729 trace_syscall_entering(struct tcb *tcp)
1733 #if defined TCB_WAITEXECVE
1734 if (tcp->flags & TCB_WAITEXECVE) {
1735 /* This is the post-execve SIGTRAP. */
1736 tcp->flags &= ~TCB_WAITEXECVE;
1741 scno_good = res = get_scno(tcp);
1745 res = syscall_fixup(tcp);
1749 res = syscall_enter(tcp);
1755 tcp->flags &= ~TCB_REPRINT;
1758 tprintf("????" /* anti-trigraph gap */ "(");
1759 else if (tcp->scno >= nsyscalls || tcp->scno < 0)
1760 tprintf("syscall_%lu(", tcp->scno);
1762 tprintf("%s(", sysent[tcp->scno].sys_name);
1764 * " <unavailable>" will be added later by the code which
1765 * detects ptrace errors.
1770 switch (known_scno(tcp)) {
1771 #ifdef SYS_socket_subcall
1772 case SYS_socketcall:
1773 decode_subcall(tcp, SYS_socket_subcall,
1774 SYS_socket_nsubcalls, deref_style);
1777 #ifdef SYS_ipc_subcall
1779 decode_subcall(tcp, SYS_ipc_subcall,
1780 SYS_ipc_nsubcalls, shift_style);
1784 #ifdef SYS_pgrpsys_subcall
1786 decode_subcall(tcp, SYS_pgrpsys_subcall,
1787 SYS_pgrpsys_nsubcalls, shift_style);
1789 #endif /* SYS_pgrpsys_subcall */
1790 #ifdef SYS_sigcall_subcall
1792 decode_subcall(tcp, SYS_sigcall_subcall,
1793 SYS_sigcall_nsubcalls, mask_style);
1795 #endif /* SYS_sigcall_subcall */
1797 decode_subcall(tcp, SYS_msgsys_subcall,
1798 SYS_msgsys_nsubcalls, shift_style);
1801 decode_subcall(tcp, SYS_shmsys_subcall,
1802 SYS_shmsys_nsubcalls, shift_style);
1805 decode_subcall(tcp, SYS_semsys_subcall,
1806 SYS_semsys_nsubcalls, shift_style);
1809 decode_subcall(tcp, SYS_sysfs_subcall,
1810 SYS_sysfs_nsubcalls, shift_style);
1813 decode_subcall(tcp, SYS_spcall_subcall,
1814 SYS_spcall_nsubcalls, shift_style);
1816 #ifdef SYS_context_subcall
1818 decode_subcall(tcp, SYS_context_subcall,
1819 SYS_context_nsubcalls, shift_style);
1821 #endif /* SYS_context_subcall */
1822 #ifdef SYS_door_subcall
1824 decode_subcall(tcp, SYS_door_subcall,
1825 SYS_door_nsubcalls, door_style);
1827 #endif /* SYS_door_subcall */
1828 #ifdef SYS_kaio_subcall
1830 decode_subcall(tcp, SYS_kaio_subcall,
1831 SYS_kaio_nsubcalls, shift_style);
1839 decode_subcall(tcp, 0, 0, table_style);
1844 decode_subcall(tcp, SYS_semsys_subcall,
1845 SYS_semsys_nsubcalls, shift_style);
1848 decode_subcall(tcp, SYS_msgsys_subcall,
1849 SYS_msgsys_nsubcalls, shift_style);
1852 decode_subcall(tcp, SYS_shmsys_subcall,
1853 SYS_shmsys_nsubcalls, shift_style);
1858 internal_syscall(tcp);
1860 if ((tcp->scno >= 0 && tcp->scno < nsyscalls &&
1861 !(qual_flags[tcp->scno] & QUAL_TRACE)) ||
1862 (tracing_paths && !pathtrace_match(tcp))) {
1863 tcp->flags |= TCB_INSYSCALL | TCB_FILTERED;
1867 tcp->flags &= ~TCB_FILTERED;
1869 if (cflag == CFLAG_ONLY_STATS) {
1875 tcp->flags &= ~TCB_REPRINT;
1877 if (tcp->scno >= nsyscalls || tcp->scno < 0)
1878 tprintf("syscall_%lu(", tcp->scno);
1880 tprintf("%s(", sysent[tcp->scno].sys_name);
1881 if (tcp->scno >= nsyscalls || tcp->scno < 0 ||
1882 ((qual_flags[tcp->scno] & QUAL_RAW) &&
1883 sysent[tcp->scno].sys_func != sys_exit))
1884 res = printargs(tcp);
1886 res = (*sysent[tcp->scno].sys_func)(tcp);
1888 if (fflush(tcp->outf) == EOF)
1891 tcp->flags |= TCB_INSYSCALL;
1892 /* Measure the entrance time as late as possible to avoid errors. */
1894 gettimeofday(&tcp->etime, NULL);
1899 * 0: "ignore this ptrace stop", bail out of trace_syscall() silently.
1900 * 1: ok, continue in trace_syscall().
1901 * other: error, trace_syscall() should print error indicator
1902 * ("????" etc) and bail out.
1905 get_syscall_result(struct tcb *tcp)
1908 # if defined(S390) || defined(S390X)
1909 # elif defined (POWERPC)
1910 # elif defined(AVR32)
1911 /* Read complete register set in one go. */
1912 if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, ®s) < 0)
1914 # elif defined(BFIN)
1915 # elif defined (I386)
1916 if (upeek(tcp, 4*EAX, &eax) < 0)
1918 # elif defined (X86_64)
1919 if (upeek(tcp, 8*RAX, &rax) < 0)
1921 # elif defined(IA64)
1922 # define IA64_PSR_IS ((long)1 << 34)
1923 if (upeek(tcp, PT_CR_IPSR, &psr) >= 0)
1924 ia32 = (psr & IA64_PSR_IS) != 0;
1925 if (upeek(tcp, PT_R8, &r8) < 0)
1927 if (upeek(tcp, PT_R10, &r10) < 0)
1929 # elif defined (ARM)
1930 /* Read complete register set in one go. */
1931 if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (void *)®s) == -1)
1933 # elif defined (M68K)
1934 # elif defined (LINUX_MIPSN32)
1935 unsigned long long regs[38];
1937 if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (long) ®s) < 0)
1941 # elif defined (MIPS)
1942 if (upeek(tcp, REG_A3, &a3) < 0)
1944 if (upeek(tcp, REG_V0, &r2) < 0)
1946 # elif defined (ALPHA)
1947 if (upeek(tcp, REG_A3, &a3) < 0)
1949 if (upeek(tcp, REG_R0, &r0) < 0)
1951 # elif defined (SPARC) || defined (SPARC64)
1952 /* Everything we need is in the current register set. */
1953 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0)
1955 # elif defined(HPPA)
1957 # elif defined(SH64)
1958 # elif defined(CRISV10) || defined(CRISV32)
1959 # elif defined(TILE)
1960 # elif defined(MICROBLAZE)
1966 /* new syscall ABI returns result in R0 */
1967 if (upeek(tcp, 4*REG_REG0, (long *)&r0) < 0)
1970 /* ABI defines result returned in r9 */
1971 if (upeek(tcp, REG_GENERAL(9), (long *)&r9) < 0)
1976 # ifndef HAVE_PR_SYSCALL
1978 if (pread(tcp->pfd_reg, ®s, sizeof(regs), 0) < 0) {
1982 # endif /* FREEBSD */
1983 # endif /* !HAVE_PR_SYSCALL */
1984 #endif /* USE_PROCFS */
1991 * Check the syscall return value register value for whether it is
1992 * a negated errno code indicating an error, or a success return value.
1995 is_negated_errno(unsigned long int val)
1997 unsigned long int max = -(long int) nerrnos;
1998 # if SUPPORTED_PERSONALITIES > 1
1999 if (personality_wordsize[current_personality] < sizeof(val)) {
2000 val = (unsigned int) val;
2001 max = (unsigned int) max;
2009 get_error(struct tcb *tcp)
2013 int check_errno = 1;
2014 if (tcp->scno >= 0 && tcp->scno < nsyscalls &&
2015 sysent[tcp->scno].sys_flags & SYSCALL_NEVER_FAILS) {
2018 # if defined(S390) || defined(S390X)
2019 if (check_errno && is_negated_errno(gpr2)) {
2026 # elif defined(I386)
2027 if (check_errno && is_negated_errno(eax)) {
2034 # elif defined(X86_64)
2035 if (check_errno && is_negated_errno(rax)) {
2042 # elif defined(IA64)
2047 if (check_errno && is_negated_errno(err)) {
2055 if (check_errno && r10) {
2062 # elif defined(MIPS)
2063 if (check_errno && a3) {
2069 # elif defined(POWERPC)
2070 if (check_errno && is_negated_errno(result)) {
2075 tcp->u_rval = result;
2077 # elif defined(M68K)
2078 if (check_errno && is_negated_errno(d0)) {
2086 if (check_errno && is_negated_errno(regs.ARM_r0)) {
2088 u_error = -regs.ARM_r0;
2091 tcp->u_rval = regs.ARM_r0;
2093 # elif defined(AVR32)
2094 if (check_errno && regs.r12 && (unsigned) -regs.r12 < nerrnos) {
2096 u_error = -regs.r12;
2099 tcp->u_rval = regs.r12;
2101 # elif defined(BFIN)
2102 if (check_errno && is_negated_errno(r0)) {
2108 # elif defined(ALPHA)
2109 if (check_errno && a3) {
2116 # elif defined(SPARC)
2117 if (check_errno && regs.psr & PSR_C) {
2119 u_error = regs.u_regs[U_REG_O0];
2122 tcp->u_rval = regs.u_regs[U_REG_O0];
2124 # elif defined(SPARC64)
2125 if (check_errno && regs.tstate & 0x1100000000UL) {
2127 u_error = regs.u_regs[U_REG_O0];
2130 tcp->u_rval = regs.u_regs[U_REG_O0];
2132 # elif defined(HPPA)
2133 if (check_errno && is_negated_errno(r28)) {
2141 if (check_errno && is_negated_errno(r0)) {
2148 # elif defined(SH64)
2149 if (check_errno && is_negated_errno(r9)) {
2156 # elif defined(CRISV10) || defined(CRISV32)
2157 if (check_errno && r10 && (unsigned) -r10 < nerrnos) {
2164 # elif defined(TILE)
2166 if (upeek(tcp, PTREGS_OFFSET_REG(0), &rval) < 0)
2168 if (check_errno && rval < 0 && rval > -nerrnos) {
2175 # elif defined(MICROBLAZE)
2176 if (check_errno && is_negated_errno(r3)) {
2186 /* get error code from user struct */
2187 if (upeek(tcp, uoff(u_error), &u_error) < 0)
2189 u_error >>= 24; /* u_error is a char */
2191 /* get system call return value */
2192 if (upeek(tcp, uoff(u_rval1), &tcp->u_rval) < 0)
2197 /* Judicious guessing goes a long way. */
2198 if (tcp->status.pr_reg[R_PSR] & 0x100000) {
2200 u_error = tcp->status.pr_reg[R_O0];
2203 tcp->u_rval = tcp->status.pr_reg[R_O0];
2207 if (tcp->status.PR_REG[EFL] & 0x1) {
2209 u_error = tcp->status.PR_REG[EAX];
2212 tcp->u_rval = tcp->status.PR_REG[EAX];
2213 # ifdef HAVE_LONG_LONG
2215 ((unsigned long long) tcp->status.PR_REG[EDX] << 32) +
2216 tcp->status.PR_REG[EAX];
2221 if (tcp->status.PR_REG[EFLAGS] & 0x1) {
2223 u_error = tcp->status.PR_REG[RAX];
2226 tcp->u_rval = tcp->status.PR_REG[RAX];
2228 # endif /* X86_64 */
2230 if (tcp->status.pr_reg[CTX_A3]) {
2232 u_error = tcp->status.pr_reg[CTX_V0];
2235 tcp->u_rval = tcp->status.pr_reg[CTX_V0];
2240 if (regs.r_eflags & PSL_C) {
2242 u_error = regs.r_eax;
2244 tcp->u_rval = regs.r_eax;
2246 ((unsigned long long) regs.r_edx << 32) + regs.r_eax;
2248 #endif /* FREEBSD */
2249 tcp->u_error = u_error;
2254 dumpio(struct tcb *tcp)
2258 if (tcp->u_arg[0] < 0 || tcp->u_arg[0] >= MAX_QUALS)
2260 if (tcp->scno < 0 || tcp->scno >= nsyscalls)
2262 if (sysent[tcp->scno].sys_func == printargs)
2264 if (qual_flags[tcp->u_arg[0]] & QUAL_READ) {
2265 if (sysent[tcp->scno].sys_func == sys_read ||
2266 sysent[tcp->scno].sys_func == sys_pread ||
2267 sysent[tcp->scno].sys_func == sys_pread64 ||
2268 sysent[tcp->scno].sys_func == sys_recv ||
2269 sysent[tcp->scno].sys_func == sys_recvfrom)
2270 dumpstr(tcp, tcp->u_arg[1], tcp->u_rval);
2271 else if (sysent[tcp->scno].sys_func == sys_readv)
2272 dumpiov(tcp, tcp->u_arg[2], tcp->u_arg[1]);
2275 if (qual_flags[tcp->u_arg[0]] & QUAL_WRITE) {
2276 if (sysent[tcp->scno].sys_func == sys_write ||
2277 sysent[tcp->scno].sys_func == sys_pwrite ||
2278 sysent[tcp->scno].sys_func == sys_pwrite64 ||
2279 sysent[tcp->scno].sys_func == sys_send ||
2280 sysent[tcp->scno].sys_func == sys_sendto)
2281 dumpstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
2282 else if (sysent[tcp->scno].sys_func == sys_writev)
2283 dumpiov(tcp, tcp->u_arg[2], tcp->u_arg[1]);
2289 trace_syscall_exiting(struct tcb *tcp)
2296 /* Measure the exit time as early as possible to avoid errors. */
2298 gettimeofday(&tv, NULL);
2300 res = get_syscall_result(tcp);
2304 res = syscall_fixup(tcp);
2308 res = get_error(tcp);
2312 internal_syscall(tcp);
2314 if (res == 1 && filtered(tcp)) {
2318 if (tcp->flags & TCB_REPRINT) {
2320 if (tcp->scno >= nsyscalls || tcp->scno < 0)
2321 tprintf("<... syscall_%lu resumed> ", tcp->scno);
2323 tprintf("<... %s resumed> ", sysent[tcp->scno].sys_name);
2327 struct timeval t = tv;
2328 count_syscall(tcp, &t);
2329 if (cflag == CFLAG_ONLY_STATS) {
2337 tprintf("= ? <unavailable>");
2339 tcp->flags &= ~TCB_INSYSCALL;
2343 if (tcp->scno >= nsyscalls || tcp->scno < 0
2344 || (qual_flags[tcp->scno] & QUAL_RAW))
2345 sys_res = printargs(tcp);
2347 /* FIXME: not_failing_only (IOW, option -z) is broken:
2348 * failure of syscall is known only after syscall return.
2349 * Thus we end up with something like this on, say, ENOENT:
2350 * open("doesnt_exist", O_RDONLY <unfinished ...>
2351 * {next syscall decode}
2352 * whereas the intended result is that open(...) line
2353 * is not shown at all.
2355 if (not_failing_only && tcp->u_error)
2356 goto ret; /* ignore failed syscalls */
2357 sys_res = (*sysent[tcp->scno].sys_func)(tcp);
2362 u_error = tcp->u_error;
2363 if (tcp->scno >= nsyscalls || tcp->scno < 0 ||
2364 qual_flags[tcp->scno] & QUAL_RAW) {
2366 tprintf("= -1 (errno %ld)", u_error);
2368 tprintf("= %#lx", tcp->u_rval);
2370 else if (!(sys_res & RVAL_NONE) && u_error) {
2374 tprintf("= ? ERESTARTSYS (To be restarted)");
2376 case ERESTARTNOINTR:
2377 tprintf("= ? ERESTARTNOINTR (To be restarted)");
2379 case ERESTARTNOHAND:
2380 tprintf("= ? ERESTARTNOHAND (To be restarted)");
2382 case ERESTART_RESTARTBLOCK:
2383 tprintf("= ? ERESTART_RESTARTBLOCK (To be restarted)");
2388 tprintf("= -1 E??? (errno %ld)", u_error);
2389 else if (u_error < nerrnos)
2390 tprintf("= -1 %s (%s)", errnoent[u_error],
2393 tprintf("= -1 ERRNO_%ld (%s)", u_error,
2397 if ((sys_res & RVAL_STR) && tcp->auxstr)
2398 tprintf(" (%s)", tcp->auxstr);
2401 if (sys_res & RVAL_NONE)
2404 switch (sys_res & RVAL_MASK) {
2406 tprintf("= %#lx", tcp->u_rval);
2409 tprintf("= %#lo", tcp->u_rval);
2412 tprintf("= %lu", tcp->u_rval);
2415 tprintf("= %ld", tcp->u_rval);
2417 #ifdef HAVE_LONG_LONG
2419 tprintf("= %#llx", tcp->u_lrval);
2422 tprintf("= %#llo", tcp->u_lrval);
2424 case RVAL_LUDECIMAL:
2425 tprintf("= %llu", tcp->u_lrval);
2428 tprintf("= %lld", tcp->u_lrval);
2433 "invalid rval format\n");
2437 if ((sys_res & RVAL_STR) && tcp->auxstr)
2438 tprintf(" (%s)", tcp->auxstr);
2441 tv_sub(&tv, &tv, &tcp->etime);
2442 tprintf(" <%ld.%06ld>",
2443 (long) tv.tv_sec, (long) tv.tv_usec);
2448 if (fflush(tcp->outf) == EOF)
2451 tcp->flags &= ~TCB_INSYSCALL;
2456 trace_syscall(struct tcb *tcp)
2458 return exiting(tcp) ?
2459 trace_syscall_exiting(tcp) : trace_syscall_entering(tcp);