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)
51 # undef PTRACE_SYSCALL
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
64 # undef PTRACE_GETREGS
65 # define PTRACE_GETREGS PTRACE_GETREGS64
66 # undef PTRACE_SETREGS
67 # define PTRACE_SETREGS PTRACE_SETREGS64
71 # include <asm/ptrace_offsets.h>
76 # define ERESTARTSYS 512
78 # ifndef ERESTARTNOINTR
79 # define ERESTARTNOINTR 513
81 # ifndef ERESTARTNOHAND
82 # define ERESTARTNOHAND 514 /* restart if no handler.. */
85 # define ENOIOCTLCMD 515 /* No ioctl command */
87 # ifndef ERESTART_RESTARTBLOCK
88 # define ERESTART_RESTARTBLOCK 516 /* restart by calling sys_restart_syscall */
92 # warning: NSIG is not defined, using 32
96 /* Ugh. Is this really correct? ARM has no RT signals?! */
103 /* Define these shorthand notations to simplify the syscallent files. */
104 #define TD TRACE_DESC
105 #define TF TRACE_FILE
107 #define TN TRACE_NETWORK
108 #define TP TRACE_PROCESS
109 #define TS TRACE_SIGNAL
110 #define NF SYSCALL_NEVER_FAILS
113 static const struct sysent sysent0[] = {
114 #include "syscallent.h"
117 #if SUPPORTED_PERSONALITIES >= 2
118 static const struct sysent sysent1[] = {
119 # include "syscallent1.h"
123 #if SUPPORTED_PERSONALITIES >= 3
124 static const struct sysent sysent2[] = {
125 # include "syscallent2.h"
129 /* Now undef them since short defines cause wicked namespace pollution. */
140 * `ioctlent.h' may be generated from `ioctlent.raw' by the auxiliary
141 * program `ioctlsort', such that the list is sorted by the `code' field.
142 * This has the side-effect of resolving the _IO.. macros into
143 * plain integers, eliminating the need to include here everything
147 static const char *const errnoent0[] = {
148 #include "errnoent.h"
150 static const char *const signalent0[] = {
151 #include "signalent.h"
153 static const struct ioctlent ioctlent0[] = {
154 #include "ioctlent.h"
156 enum { nsyscalls0 = ARRAY_SIZE(sysent0) };
157 enum { nerrnos0 = ARRAY_SIZE(errnoent0) };
158 enum { nsignals0 = ARRAY_SIZE(signalent0) };
159 enum { nioctlents0 = ARRAY_SIZE(ioctlent0) };
160 int qual_flags0[MAX_QUALS];
162 #if SUPPORTED_PERSONALITIES >= 2
163 static const char *const errnoent1[] = {
164 # include "errnoent1.h"
166 static const char *const signalent1[] = {
167 # include "signalent1.h"
169 static const struct ioctlent ioctlent1[] = {
170 # include "ioctlent1.h"
172 enum { nsyscalls1 = ARRAY_SIZE(sysent1) };
173 enum { nerrnos1 = ARRAY_SIZE(errnoent1) };
174 enum { nsignals1 = ARRAY_SIZE(signalent1) };
175 enum { nioctlents1 = ARRAY_SIZE(ioctlent1) };
176 int qual_flags1[MAX_QUALS];
179 #if SUPPORTED_PERSONALITIES >= 3
180 static const char *const errnoent2[] = {
181 # include "errnoent2.h"
183 static const char *const signalent2[] = {
184 # include "signalent2.h"
186 static const struct ioctlent ioctlent2[] = {
187 # include "ioctlent2.h"
189 enum { nsyscalls2 = ARRAY_SIZE(sysent2) };
190 enum { nerrnos2 = ARRAY_SIZE(errnoent2) };
191 enum { nsignals2 = ARRAY_SIZE(signalent2) };
192 enum { nioctlents2 = ARRAY_SIZE(ioctlent2) };
193 int qual_flags2[MAX_QUALS];
196 const struct sysent *sysent;
197 const char *const *errnoent;
198 const char *const *signalent;
199 const struct ioctlent *ioctlent;
206 int current_personality;
208 #ifndef PERSONALITY0_WORDSIZE
209 # define PERSONALITY0_WORDSIZE sizeof(long)
211 const int personality_wordsize[SUPPORTED_PERSONALITIES] = {
212 PERSONALITY0_WORDSIZE,
213 #if SUPPORTED_PERSONALITIES > 1
214 PERSONALITY1_WORDSIZE,
216 #if SUPPORTED_PERSONALITIES > 2
217 PERSONALITY2_WORDSIZE,
222 set_personality(int personality)
224 switch (personality) {
226 errnoent = errnoent0;
229 nsyscalls = nsyscalls0;
230 ioctlent = ioctlent0;
231 nioctlents = nioctlents0;
232 signalent = signalent0;
233 nsignals = nsignals0;
234 qual_flags = qual_flags0;
237 #if SUPPORTED_PERSONALITIES >= 2
239 errnoent = errnoent1;
242 nsyscalls = nsyscalls1;
243 ioctlent = ioctlent1;
244 nioctlents = nioctlents1;
245 signalent = signalent1;
246 nsignals = nsignals1;
247 qual_flags = qual_flags1;
251 #if SUPPORTED_PERSONALITIES >= 3
253 errnoent = errnoent2;
256 nsyscalls = nsyscalls2;
257 ioctlent = ioctlent2;
258 nioctlents = nioctlents2;
259 signalent = signalent2;
260 nsignals = nsignals2;
261 qual_flags = qual_flags2;
266 current_personality = personality;
269 #if SUPPORTED_PERSONALITIES > 1
271 update_personality(struct tcb *tcp, int personality)
273 if (personality == current_personality)
275 set_personality(personality);
277 if (personality == tcp->currpers)
279 tcp->currpers = personality;
281 # if defined(POWERPC64) || defined(X86_64)
283 static const char *const names[] = {"64 bit", "32 bit"};
284 fprintf(stderr, "[ Process PID=%d runs in %s mode. ]\n",
285 tcp->pid, names[personality]);
291 static int qual_syscall(), qual_signal(), qual_fault(), qual_desc();
293 static const struct qual_options {
295 const char *option_name;
296 int (*qualify)(const char *, int, int);
297 const char *argument_name;
299 { QUAL_TRACE, "trace", qual_syscall, "system call" },
300 { QUAL_TRACE, "t", qual_syscall, "system call" },
301 { QUAL_ABBREV, "abbrev", qual_syscall, "system call" },
302 { QUAL_ABBREV, "a", qual_syscall, "system call" },
303 { QUAL_VERBOSE, "verbose", qual_syscall, "system call" },
304 { QUAL_VERBOSE, "v", qual_syscall, "system call" },
305 { QUAL_RAW, "raw", qual_syscall, "system call" },
306 { QUAL_RAW, "x", qual_syscall, "system call" },
307 { QUAL_SIGNAL, "signal", qual_signal, "signal" },
308 { QUAL_SIGNAL, "signals", qual_signal, "signal" },
309 { QUAL_SIGNAL, "s", qual_signal, "signal" },
310 { QUAL_FAULT, "fault", qual_fault, "fault" },
311 { QUAL_FAULT, "faults", qual_fault, "fault" },
312 { QUAL_FAULT, "m", qual_fault, "fault" },
313 { QUAL_READ, "read", qual_desc, "descriptor" },
314 { QUAL_READ, "reads", qual_desc, "descriptor" },
315 { QUAL_READ, "r", qual_desc, "descriptor" },
316 { QUAL_WRITE, "write", qual_desc, "descriptor" },
317 { QUAL_WRITE, "writes", qual_desc, "descriptor" },
318 { QUAL_WRITE, "w", qual_desc, "descriptor" },
319 { 0, NULL, NULL, NULL },
323 qualify_one(int n, int bitflag, int not, int pers)
325 if (pers == 0 || pers < 0) {
327 qual_flags0[n] &= ~bitflag;
329 qual_flags0[n] |= bitflag;
332 #if SUPPORTED_PERSONALITIES >= 2
333 if (pers == 1 || pers < 0) {
335 qual_flags1[n] &= ~bitflag;
337 qual_flags1[n] |= bitflag;
341 #if SUPPORTED_PERSONALITIES >= 3
342 if (pers == 2 || pers < 0) {
344 qual_flags2[n] &= ~bitflag;
346 qual_flags2[n] |= bitflag;
352 qual_syscall(const char *s, int bitflag, int not)
357 if (isdigit((unsigned char)*s)) {
359 if (i < 0 || i >= MAX_QUALS)
361 qualify_one(i, bitflag, not, -1);
364 for (i = 0; i < nsyscalls0; i++)
365 if (strcmp(s, sysent0[i].sys_name) == 0) {
366 qualify_one(i, bitflag, not, 0);
370 #if SUPPORTED_PERSONALITIES >= 2
371 for (i = 0; i < nsyscalls1; i++)
372 if (strcmp(s, sysent1[i].sys_name) == 0) {
373 qualify_one(i, bitflag, not, 1);
378 #if SUPPORTED_PERSONALITIES >= 3
379 for (i = 0; i < nsyscalls2; i++)
380 if (strcmp(s, sysent2[i].sys_name) == 0) {
381 qualify_one(i, bitflag, not, 2);
390 qual_signal(const char *s, int bitflag, int not)
395 if (isdigit((unsigned char)*s)) {
397 if (signo < 0 || signo >= MAX_QUALS)
399 qualify_one(signo, bitflag, not, -1);
402 if (strlen(s) >= sizeof buf)
406 if (strncasecmp(s, "SIG", 3) == 0)
408 for (i = 0; i <= NSIG; i++)
409 if (strcasecmp(s, signame(i) + 3) == 0) {
410 qualify_one(i, bitflag, not, -1);
417 qual_fault(const char *s, int bitflag, int not)
423 qual_desc(const char *s, int bitflag, int not)
425 if (isdigit((unsigned char)*s)) {
427 if (desc < 0 || desc >= MAX_QUALS)
429 qualify_one(desc, bitflag, not, -1);
436 lookup_class(const char *s)
438 if (strcmp(s, "file") == 0)
440 if (strcmp(s, "ipc") == 0)
442 if (strcmp(s, "network") == 0)
443 return TRACE_NETWORK;
444 if (strcmp(s, "process") == 0)
445 return TRACE_PROCESS;
446 if (strcmp(s, "signal") == 0)
448 if (strcmp(s, "desc") == 0)
454 qualify(const char *s)
456 const struct qual_options *opt;
462 opt = &qual_options[0];
463 for (i = 0; (p = qual_options[i].option_name); i++) {
465 if (strncmp(s, p, n) == 0 && s[n] == '=') {
466 opt = &qual_options[i];
476 if (strcmp(s, "none") == 0) {
480 if (strcmp(s, "all") == 0) {
481 for (i = 0; i < MAX_QUALS; i++) {
482 qualify_one(i, opt->bitflag, not, -1);
486 for (i = 0; i < MAX_QUALS; i++) {
487 qualify_one(i, opt->bitflag, !not, -1);
492 for (p = strtok(copy, ","); p; p = strtok(NULL, ",")) {
493 if (opt->bitflag == QUAL_TRACE && (n = lookup_class(p)) > 0) {
494 for (i = 0; i < nsyscalls0; i++)
495 if (sysent0[i].sys_flags & n)
496 qualify_one(i, opt->bitflag, not, 0);
498 #if SUPPORTED_PERSONALITIES >= 2
499 for (i = 0; i < nsyscalls1; i++)
500 if (sysent1[i].sys_flags & n)
501 qualify_one(i, opt->bitflag, not, 1);
504 #if SUPPORTED_PERSONALITIES >= 3
505 for (i = 0; i < nsyscalls2; i++)
506 if (sysent2[i].sys_flags & n)
507 qualify_one(i, opt->bitflag, not, 2);
512 if (opt->qualify(p, opt->bitflag, not)) {
513 error_msg_and_die("invalid %s '%s'",
514 opt->argument_name, p);
521 enum subcall_style { shift_style, deref_style, mask_style, door_style };
523 #if !(defined(ALPHA) || defined(MIPS) || defined(__ARM_EABI__))
526 decode_subcall(struct tcb *tcp, int subcall, int nsubcalls, enum subcall_style style)
528 unsigned long addr, mask;
530 int size = personality_wordsize[current_personality];
534 if (tcp->u_arg[0] < 0 || tcp->u_arg[0] >= nsubcalls)
536 tcp->scno = subcall + tcp->u_arg[0];
537 tcp->u_nargs = n = sysent[tcp->scno].nargs;
538 for (i = 0; i < n; i++)
539 tcp->u_arg[i] = tcp->u_arg[i + 1];
542 if (tcp->u_arg[0] < 0 || tcp->u_arg[0] >= nsubcalls)
544 tcp->scno = subcall + tcp->u_arg[0];
545 addr = tcp->u_arg[1];
546 tcp->u_nargs = n = sysent[tcp->scno].nargs;
547 for (i = 0; i < n; i++) {
548 if (size == sizeof(int)) {
550 if (umove(tcp, addr, &arg) < 0)
554 else if (size == sizeof(long)) {
556 if (umove(tcp, addr, &arg) < 0)
566 mask = (tcp->u_arg[0] >> 8) & 0xff;
567 for (i = 0; mask; i++)
571 tcp->u_arg[0] &= 0xff;
572 tcp->scno = subcall + i;
573 tcp->u_nargs = sysent[tcp->scno].nargs;
577 * Oh, yuck. The call code is the *sixth* argument.
578 * (don't you mean the *last* argument? - JH)
580 if (tcp->u_arg[5] < 0 || tcp->u_arg[5] >= nsubcalls)
582 tcp->scno = subcall + tcp->u_arg[5];
583 tcp->u_nargs = sysent[tcp->scno].nargs;
590 printargs(struct tcb *tcp)
595 for (i = 0; i < tcp->u_nargs; i++)
596 tprintf("%s%#lx", i ? ", " : "", tcp->u_arg[i]);
602 printargs_lu(struct tcb *tcp)
607 for (i = 0; i < tcp->u_nargs; i++)
608 tprintf("%s%lu", i ? ", " : "", tcp->u_arg[i]);
614 printargs_ld(struct tcb *tcp)
619 for (i = 0; i < tcp->u_nargs; i++)
620 tprintf("%s%ld", i ? ", " : "", tcp->u_arg[i]);
626 getrval2(struct tcb *tcp)
630 #if defined(SPARC) || defined(SPARC64)
632 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0)
634 val = regs.u_regs[U_REG_O1];
636 if (upeek(tcp, 4*(REG_REG0+1), &val) < 0)
639 if (upeek(tcp, PT_R9, &val) < 0)
647 is_restart_error(struct tcb *tcp)
649 switch (tcp->u_error) {
653 case ERESTART_RESTARTBLOCK:
662 struct pt_regs i386_regs;
663 #elif defined(X86_64)
665 * On 32 bits, pt_regs and user_regs_struct are the same,
666 * but on 64 bits, user_regs_struct has six more fields:
667 * fs_base, gs_base, ds, es, fs, gs.
668 * PTRACE_GETREGS fills them too, so struct pt_regs would overflow.
670 static struct user_regs_struct x86_64_regs;
672 long r8, r10, psr; /* TODO: make static? */
673 long ia32 = 0; /* not static */
674 #elif defined(POWERPC)
681 static struct pt_regs regs;
686 static struct pt_regs regs;
687 #elif defined(SPARC) || defined(SPARC64)
688 static struct pt_regs regs;
689 static unsigned long trap;
690 #elif defined(LINUX_MIPSN32)
696 #elif defined(S390) || defined(S390X)
699 static long syscall_mode;
706 #elif defined(CRISV10) || defined(CRISV32)
708 #elif defined(MICROBLAZE)
713 * 0: "ignore this ptrace stop", bail out of trace_syscall() silently.
714 * 1: ok, continue in trace_syscall().
715 * other: error, trace_syscall() should print error indicator
716 * ("????" etc) and bail out.
720 get_scno(struct tcb *tcp)
724 #if defined(S390) || defined(S390X)
725 if (upeek(tcp, PT_GPR2, &syscall_mode) < 0)
728 if (syscall_mode != -ENOSYS) {
730 * Since kernel version 2.5.44 the scno gets passed in gpr2.
735 * Old style of "passing" the scno via the SVC instruction.
737 long opcode, offset_reg, tmp;
739 static const int gpr_offset[16] = {
740 PT_GPR0, PT_GPR1, PT_ORIGGPR2, PT_GPR3,
741 PT_GPR4, PT_GPR5, PT_GPR6, PT_GPR7,
742 PT_GPR8, PT_GPR9, PT_GPR10, PT_GPR11,
743 PT_GPR12, PT_GPR13, PT_GPR14, PT_GPR15
746 if (upeek(tcp, PT_PSWADDR, &pc) < 0)
749 opcode = ptrace(PTRACE_PEEKTEXT, tcp->pid, (char *)(pc-sizeof(long)), 0);
751 perror("peektext(pc-oneword)");
756 * We have to check if the SVC got executed directly or via an
757 * EXECUTE instruction. In case of EXECUTE it is necessary to do
758 * instruction decoding to derive the system call number.
759 * Unfortunately the opcode sizes of EXECUTE and SVC are differently,
760 * so that this doesn't work if a SVC opcode is part of an EXECUTE
761 * opcode. Since there is no way to find out the opcode size this
762 * is the best we can do...
764 if ((opcode & 0xff00) == 0x0a00) {
766 scno = opcode & 0xff;
769 /* SVC got executed by EXECUTE instruction */
772 * Do instruction decoding of EXECUTE. If you really want to
773 * understand this, read the Principles of Operations.
775 svc_addr = (void *) (opcode & 0xfff);
778 offset_reg = (opcode & 0x000f0000) >> 16;
779 if (offset_reg && (upeek(tcp, gpr_offset[offset_reg], &tmp) < 0))
784 offset_reg = (opcode & 0x0000f000) >> 12;
785 if (offset_reg && (upeek(tcp, gpr_offset[offset_reg], &tmp) < 0))
789 scno = ptrace(PTRACE_PEEKTEXT, tcp->pid, svc_addr, 0);
798 offset_reg = (opcode & 0x00f00000) >> 20;
799 if (offset_reg && (upeek(tcp, gpr_offset[offset_reg], &tmp) < 0))
802 scno = (scno | tmp) & 0xff;
805 #elif defined(POWERPC)
806 if (upeek(tcp, sizeof(unsigned long)*PT_R0, &scno) < 0)
809 /* TODO: speed up strace by not doing this at every syscall.
810 * We only need to do it after execve.
816 /* Check for 64/32 bit mode. */
817 if (upeek(tcp, sizeof(unsigned long)*PT_MSR, &val) < 0)
819 /* SF is bit 0 of MSR */
824 update_personality(tcp, currpers);
827 /* Read complete register set in one go. */
828 if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, ®s) < 0)
832 if (upeek(tcp, PT_ORIG_P0, &scno))
835 if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (long) &i386_regs) < 0)
837 scno = i386_regs.orig_eax;
838 #elif defined(X86_64)
840 if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (long) &x86_64_regs) < 0)
842 scno = x86_64_regs.orig_rax;
844 /* Check CS register value. On x86-64 linux it is:
845 * 0x33 for long mode (64 bit)
846 * 0x23 for compatibility mode (32 bit)
848 switch (x86_64_regs.cs) {
849 case 0x23: currpers = 1; break;
850 case 0x33: currpers = 0; break;
852 fprintf(stderr, "Unknown value CS=0x%08X while "
853 "detecting personality of process "
854 "PID=%d\n", (int)x86_64_regs.cs, tcp->pid);
855 currpers = current_personality;
859 /* This version analyzes the opcode of a syscall instruction.
860 * (int 0x80 on i386 vs. syscall on x86-64)
861 * It works, but is too complicated.
863 unsigned long val, rip, i;
865 rip = x86_64_regs.rip;
867 /* sizeof(syscall) == sizeof(int 0x80) == 2 */
871 call = ptrace(PTRACE_PEEKTEXT, tcp->pid, (char *)rip, (char *)0);
873 fprintf(stderr, "ptrace_peektext failed: %s\n",
875 switch (call & 0xffff) {
876 /* x86-64: syscall = 0x0f 0x05 */
877 case 0x050f: currpers = 0; break;
878 /* i386: int 0x80 = 0xcd 0x80 */
879 case 0x80cd: currpers = 1; break;
881 currpers = current_personality;
883 "Unknown syscall opcode (0x%04X) while "
884 "detecting personality of process "
885 "PID=%d\n", (int)call, tcp->pid);
889 update_personality(tcp, currpers);
891 # define IA64_PSR_IS ((long)1 << 34)
892 if (upeek(tcp, PT_CR_IPSR, &psr) >= 0)
893 ia32 = (psr & IA64_PSR_IS) != 0;
895 if (upeek(tcp, PT_R1, &scno) < 0)
898 if (upeek(tcp, PT_R15, &scno) < 0)
902 /* Read complete register set in one go. */
903 if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (void *)®s) == -1)
907 * We only need to grab the syscall number on syscall entry.
909 if (regs.ARM_ip == 0) {
911 * Note: we only deal with only 32-bit CPUs here.
913 if (regs.ARM_cpsr & 0x20) {
915 * Get the Thumb-mode system call number
920 * Get the ARM-mode system call number
923 scno = ptrace(PTRACE_PEEKTEXT, tcp->pid, (void *)(regs.ARM_pc - 4), NULL);
927 /* Handle the EABI syscall convention. We do not
928 bother converting structures between the two
929 ABIs, but basic functionality should work even
930 if strace and the traced program have different
932 if (scno == 0xef000000) {
935 if ((scno & 0x0ff00000) != 0x0f900000) {
936 fprintf(stderr, "syscall: unknown syscall trap 0x%08lx\n",
942 * Fixup the syscall number
947 if (scno & 0x0f0000) {
949 * Handle ARM specific syscall
951 update_personality(tcp, 1);
954 update_personality(tcp, 0);
957 fprintf(stderr, "pid %d stray syscall entry\n", tcp->pid);
958 tcp->flags |= TCB_INSYSCALL;
961 if (upeek(tcp, 4*PT_ORIG_D0, &scno) < 0)
963 #elif defined(LINUX_MIPSN32)
964 unsigned long long regs[38];
966 if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (long) ®s) < 0)
972 if (!SCNO_IN_RANGE(scno)) {
973 if (a3 == 0 || a3 == -1) {
975 fprintf(stderr, "stray syscall exit: v0 = %ld\n", scno);
980 if (upeek(tcp, REG_A3, &a3) < 0)
982 if (upeek(tcp, REG_V0, &scno) < 0)
985 if (!SCNO_IN_RANGE(scno)) {
986 if (a3 == 0 || a3 == -1) {
988 fprintf(stderr, "stray syscall exit: v0 = %ld\n", scno);
993 if (upeek(tcp, REG_A3, &a3) < 0)
995 if (upeek(tcp, REG_R0, &scno) < 0)
999 * Do some sanity checks to figure out if it's
1000 * really a syscall entry
1002 if (!SCNO_IN_RANGE(scno)) {
1003 if (a3 == 0 || a3 == -1) {
1005 fprintf(stderr, "stray syscall exit: r0 = %ld\n", scno);
1009 #elif defined(SPARC) || defined(SPARC64)
1010 /* Everything we need is in the current register set. */
1011 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0)
1014 /* Disassemble the syscall trap. */
1015 /* Retrieve the syscall trap instruction. */
1017 # if defined(SPARC64)
1018 trap = ptrace(PTRACE_PEEKTEXT, tcp->pid, (char *)regs.tpc, 0);
1021 trap = ptrace(PTRACE_PEEKTEXT, tcp->pid, (char *)regs.pc, 0);
1026 /* Disassemble the trap to see what personality to use. */
1029 /* Linux/SPARC syscall trap. */
1030 update_personality(tcp, 0);
1033 /* Linux/SPARC64 syscall trap. */
1034 update_personality(tcp, 2);
1037 /* SunOS syscall trap. (pers 1) */
1038 fprintf(stderr, "syscall: SunOS no support\n");
1041 /* Solaris 2.x syscall trap. (per 2) */
1042 update_personality(tcp, 1);
1045 /* NetBSD/FreeBSD syscall trap. */
1046 fprintf(stderr, "syscall: NetBSD/FreeBSD not supported\n");
1049 /* Solaris 2.x gettimeofday */
1050 update_personality(tcp, 1);
1053 # if defined(SPARC64)
1054 fprintf(stderr, "syscall: unknown syscall trap %08lx %016lx\n", trap, regs.tpc);
1056 fprintf(stderr, "syscall: unknown syscall trap %08lx %08lx\n", trap, regs.pc);
1061 /* Extract the system call number from the registers. */
1062 if (trap == 0x91d02027)
1065 scno = regs.u_regs[U_REG_G1];
1067 scno = regs.u_regs[U_REG_O0];
1068 memmove(®s.u_regs[U_REG_O0], ®s.u_regs[U_REG_O1], 7*sizeof(regs.u_regs[0]));
1071 if (upeek(tcp, PT_GR20, &scno) < 0)
1075 * In the new syscall ABI, the system call number is in R3.
1077 if (upeek(tcp, 4*(REG_REG0+3), &scno) < 0)
1081 /* Odd as it may seem, a glibc bug has been known to cause
1082 glibc to issue bogus negative syscall numbers. So for
1083 our purposes, make strace print what it *should* have been */
1084 long correct_scno = (scno & 0xff);
1087 "Detected glibc bug: bogus system call"
1088 " number = %ld, correcting to %ld\n",
1091 scno = correct_scno;
1094 if (upeek(tcp, REG_SYSCALL, &scno) < 0)
1097 #elif defined(CRISV10) || defined(CRISV32)
1098 if (upeek(tcp, 4*PT_R9, &scno) < 0)
1101 if (upeek(tcp, PTREGS_OFFSET_REG(10), &scno) < 0)
1103 #elif defined(MICROBLAZE)
1104 if (upeek(tcp, 0, &scno) < 0)
1109 /* new syscall ABI returns result in R0 */
1110 if (upeek(tcp, 4*REG_REG0, (long *)&r0) < 0)
1113 /* ABI defines result returned in r9 */
1114 if (upeek(tcp, REG_GENERAL(9), (long *)&r9) < 0)
1122 /* Called at each syscall entry.
1124 * 0: "ignore this ptrace stop", bail out of trace_syscall() silently.
1125 * 1: ok, continue in trace_syscall().
1126 * other: error, trace_syscall() should print error indicator
1127 * ("????" etc) and bail out.
1130 syscall_fixup_on_sysenter(struct tcb *tcp)
1132 /* A common case of "not a syscall entry" is post-execve SIGTRAP */
1134 if (i386_regs.eax != -ENOSYS) {
1136 fprintf(stderr, "not a syscall entry (eax = %ld)\n", i386_regs.eax);
1139 #elif defined(X86_64)
1141 long rax = x86_64_regs.rax;
1142 if (current_personality == 1)
1143 rax = (int)rax; /* sign extend from 32 bits */
1144 if (rax != -ENOSYS) {
1146 fprintf(stderr, "not a syscall entry (rax = %ld)\n", rax);
1150 #elif defined(S390) || defined(S390X)
1151 /* TODO: we already fetched PT_GPR2 in get_scno
1152 * and stored it in syscall_mode, reuse it here
1153 * instead of re-fetching?
1155 if (upeek(tcp, PT_GPR2, &gpr2) < 0)
1157 if (syscall_mode != -ENOSYS)
1158 syscall_mode = tcp->scno;
1159 if (gpr2 != syscall_mode) {
1161 fprintf(stderr, "not a syscall entry (gpr2 = %ld)\n", gpr2);
1165 /* TODO? Eliminate upeek's in arches below like we did in x86 */
1166 if (upeek(tcp, 4*PT_D0, &d0) < 0)
1168 if (d0 != -ENOSYS) {
1170 fprintf(stderr, "not a syscall entry (d0 = %ld)\n", d0);
1174 if (upeek(tcp, PT_R10, &r10) < 0)
1176 if (upeek(tcp, PT_R8, &r8) < 0)
1178 if (ia32 && r8 != -ENOSYS) {
1180 fprintf(stderr, "not a syscall entry (r8 = %ld)\n", r8);
1183 #elif defined(CRISV10) || defined(CRISV32)
1184 if (upeek(tcp, 4*PT_R10, &r10) < 0)
1186 if (r10 != -ENOSYS) {
1188 fprintf(stderr, "not a syscall entry (r10 = %ld)\n", r10);
1191 #elif defined(MICROBLAZE)
1192 if (upeek(tcp, 3 * 4, &r3) < 0)
1194 if (r3 != -ENOSYS) {
1196 fprintf(stderr, "not a syscall entry (r3 = %ld)\n", r3);
1204 internal_syscall(struct tcb *tcp)
1207 * We must always trace a few critical system calls in order to
1208 * correctly support following forks in the presence of tracing
1213 if (!SCNO_IN_RANGE(tcp->scno))
1216 func = sysent[tcp->scno].sys_func;
1218 if ( sys_fork == func
1219 || sys_vfork == func
1220 || sys_clone == func
1222 return internal_fork(tcp);
1224 #if defined(TCB_WAITEXECVE)
1225 if ( sys_execve == func
1226 # if defined(SPARC) || defined(SPARC64)
1227 || sys_execv == func
1230 return internal_exec(tcp);
1237 syscall_enter(struct tcb *tcp)
1241 if (SCNO_IN_RANGE(tcp->scno))
1242 nargs = tcp->u_nargs = sysent[tcp->scno].nargs;
1244 nargs = tcp->u_nargs = MAX_ARGS;
1246 #if defined(S390) || defined(S390X)
1247 for (i = 0; i < nargs; ++i)
1248 if (upeek(tcp, i==0 ? PT_ORIGGPR2 : PT_GPR2 + i*sizeof(long), &tcp->u_arg[i]) < 0)
1250 #elif defined(ALPHA)
1251 for (i = 0; i < nargs; ++i)
1252 if (upeek(tcp, REG_A0+i, &tcp->u_arg[i]) < 0)
1256 unsigned long *out0, cfm, sof, sol;
1258 /* be backwards compatible with kernel < 2.4.4... */
1260 # define PT_RBS_END PT_AR_BSP
1263 if (upeek(tcp, PT_RBS_END, &rbs_end) < 0)
1265 if (upeek(tcp, PT_CFM, (long *) &cfm) < 0)
1268 sof = (cfm >> 0) & 0x7f;
1269 sol = (cfm >> 7) & 0x7f;
1270 out0 = ia64_rse_skip_regs((unsigned long *) rbs_end, -sof + sol);
1272 for (i = 0; i < nargs; ++i) {
1273 if (umoven(tcp, (unsigned long) ia64_rse_skip_regs(out0, i),
1274 sizeof(long), (char *) &tcp->u_arg[i]) < 0)
1278 static const int argreg[MAX_ARGS] = { PT_R11 /* EBX = out0 */,
1279 PT_R9 /* ECX = out1 */,
1280 PT_R10 /* EDX = out2 */,
1281 PT_R14 /* ESI = out3 */,
1282 PT_R15 /* EDI = out4 */,
1283 PT_R13 /* EBP = out5 */};
1285 for (i = 0; i < nargs; ++i) {
1286 if (upeek(tcp, argreg[i], &tcp->u_arg[i]) < 0)
1288 /* truncate away IVE sign-extension */
1289 tcp->u_arg[i] &= 0xffffffff;
1292 #elif defined(LINUX_MIPSN32) || defined(LINUX_MIPSN64)
1293 /* N32 and N64 both use up to six registers. */
1294 unsigned long long regs[38];
1296 if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (long) ®s) < 0)
1299 for (i = 0; i < nargs; ++i) {
1300 tcp->u_arg[i] = regs[REG_A0 + i];
1301 # if defined(LINUX_MIPSN32)
1302 tcp->ext_arg[i] = regs[REG_A0 + i];
1309 if (upeek(tcp, REG_SP, &sp) < 0)
1311 for (i = 0; i < 4; ++i)
1312 if (upeek(tcp, REG_A0 + i, &tcp->u_arg[i]) < 0)
1314 umoven(tcp, sp + 16, (nargs - 4) * sizeof(tcp->u_arg[0]),
1315 (char *)(tcp->u_arg + 4));
1317 for (i = 0; i < nargs; ++i)
1318 if (upeek(tcp, REG_A0 + i, &tcp->u_arg[i]) < 0)
1321 #elif defined(POWERPC)
1323 # define PT_ORIG_R3 34
1325 for (i = 0; i < nargs; ++i) {
1326 if (upeek(tcp, (i==0) ?
1327 (sizeof(unsigned long) * PT_ORIG_R3) :
1328 ((i+PT_R3) * sizeof(unsigned long)),
1329 &tcp->u_arg[i]) < 0)
1332 #elif defined(SPARC) || defined(SPARC64)
1333 for (i = 0; i < nargs; ++i)
1334 tcp->u_arg[i] = regs.u_regs[U_REG_O0 + i];
1336 for (i = 0; i < nargs; ++i)
1337 if (upeek(tcp, PT_GR26-4*i, &tcp->u_arg[i]) < 0)
1340 for (i = 0; i < nargs; ++i)
1341 tcp->u_arg[i] = regs.uregs[i];
1342 #elif defined(AVR32)
1345 tcp->u_arg[0] = regs.r12;
1346 tcp->u_arg[1] = regs.r11;
1347 tcp->u_arg[2] = regs.r10;
1348 tcp->u_arg[3] = regs.r9;
1349 tcp->u_arg[4] = regs.r5;
1350 tcp->u_arg[5] = regs.r3;
1352 static const int argreg[MAX_ARGS] = { PT_R0, PT_R1, PT_R2, PT_R3, PT_R4, PT_R5 };
1354 for (i = 0; i < nargs; ++i)
1355 if (upeek(tcp, argreg[i], &tcp->u_arg[i]) < 0)
1358 static const int syscall_regs[MAX_ARGS] = {
1359 4 * (REG_REG0+4), 4 * (REG_REG0+5), 4 * (REG_REG0+6),
1360 4 * (REG_REG0+7), 4 * (REG_REG0 ), 4 * (REG_REG0+1)
1363 for (i = 0; i < nargs; ++i)
1364 if (upeek(tcp, syscall_regs[i], &tcp->u_arg[i]) < 0)
1368 /* Registers used by SH5 Linux system calls for parameters */
1369 static const int syscall_regs[MAX_ARGS] = { 2, 3, 4, 5, 6, 7 };
1371 for (i = 0; i < nargs; ++i)
1372 if (upeek(tcp, REG_GENERAL(syscall_regs[i]), &tcp->u_arg[i]) < 0)
1374 #elif defined(X86_64)
1377 if (current_personality == 0) { /* x86-64 ABI */
1378 tcp->u_arg[0] = x86_64_regs.rdi;
1379 tcp->u_arg[1] = x86_64_regs.rsi;
1380 tcp->u_arg[2] = x86_64_regs.rdx;
1381 tcp->u_arg[3] = x86_64_regs.r10;
1382 tcp->u_arg[4] = x86_64_regs.r8;
1383 tcp->u_arg[5] = x86_64_regs.r9;
1384 } else { /* i386 ABI */
1385 /* Sign-extend lower 32 bits */
1386 tcp->u_arg[0] = (long)(int)x86_64_regs.rbx;
1387 tcp->u_arg[1] = (long)(int)x86_64_regs.rcx;
1388 tcp->u_arg[2] = (long)(int)x86_64_regs.rdx;
1389 tcp->u_arg[3] = (long)(int)x86_64_regs.rsi;
1390 tcp->u_arg[4] = (long)(int)x86_64_regs.rdi;
1391 tcp->u_arg[5] = (long)(int)x86_64_regs.rbp;
1393 #elif defined(MICROBLAZE)
1394 for (i = 0; i < nargs; ++i)
1395 if (upeek(tcp, (5 + i) * 4, &tcp->u_arg[i]) < 0)
1397 #elif defined(CRISV10) || defined(CRISV32)
1398 static const int crisregs[MAX_ARGS] = {
1399 4*PT_ORIG_R10, 4*PT_R11, 4*PT_R12,
1400 4*PT_R13 , 4*PT_MOF, 4*PT_SRP
1403 for (i = 0; i < nargs; ++i)
1404 if (upeek(tcp, crisregs[i], &tcp->u_arg[i]) < 0)
1407 for (i = 0; i < nargs; ++i)
1408 if (upeek(tcp, PTREGS_OFFSET_REG(i), &tcp->u_arg[i]) < 0)
1411 for (i = 0; i < nargs; ++i)
1412 if (upeek(tcp, (i < 5 ? i : i + 2)*4, &tcp->u_arg[i]) < 0)
1417 tcp->u_arg[0] = i386_regs.ebx;
1418 tcp->u_arg[1] = i386_regs.ecx;
1419 tcp->u_arg[2] = i386_regs.edx;
1420 tcp->u_arg[3] = i386_regs.esi;
1421 tcp->u_arg[4] = i386_regs.edi;
1422 tcp->u_arg[5] = i386_regs.ebp;
1423 #else /* Other architecture (32bits specific) */
1424 for (i = 0; i < nargs; ++i)
1425 if (upeek(tcp, i*4, &tcp->u_arg[i]) < 0)
1432 trace_syscall_entering(struct tcb *tcp)
1436 #if defined TCB_WAITEXECVE
1437 if (tcp->flags & TCB_WAITEXECVE) {
1438 /* This is the post-execve SIGTRAP. */
1439 tcp->flags &= ~TCB_WAITEXECVE;
1444 scno_good = res = get_scno(tcp);
1448 res = syscall_fixup_on_sysenter(tcp);
1452 res = syscall_enter(tcp);
1458 tcp->flags &= ~TCB_REPRINT;
1460 tprintf("????" /* anti-trigraph gap */ "(");
1461 else if (!SCNO_IN_RANGE(tcp->scno))
1462 tprintf("syscall_%lu(", tcp->scno);
1464 tprintf("%s(", sysent[tcp->scno].sys_name);
1466 * " <unavailable>" will be added later by the code which
1467 * detects ptrace errors.
1472 #if defined(SYS_socket_subcall) || defined(SYS_ipc_subcall)
1473 while (SCNO_IN_RANGE(tcp->scno)) {
1474 # ifdef SYS_socket_subcall
1475 if (sysent[tcp->scno].sys_func == sys_socketcall) {
1476 decode_subcall(tcp, SYS_socket_subcall,
1477 SYS_socket_nsubcalls, deref_style);
1481 # ifdef SYS_ipc_subcall
1482 if (sysent[tcp->scno].sys_func == sys_ipc) {
1483 decode_subcall(tcp, SYS_ipc_subcall,
1484 SYS_ipc_nsubcalls, shift_style);
1490 #endif /* SYS_socket_subcall || SYS_ipc_subcall */
1492 internal_syscall(tcp);
1494 if ((SCNO_IN_RANGE(tcp->scno) &&
1495 !(qual_flags[tcp->scno] & QUAL_TRACE)) ||
1496 (tracing_paths && !pathtrace_match(tcp))) {
1497 tcp->flags |= TCB_INSYSCALL | TCB_FILTERED;
1501 tcp->flags &= ~TCB_FILTERED;
1503 if (cflag == CFLAG_ONLY_STATS) {
1509 tcp->flags &= ~TCB_REPRINT;
1510 if (!SCNO_IN_RANGE(tcp->scno))
1511 tprintf("syscall_%lu(", tcp->scno);
1513 tprintf("%s(", sysent[tcp->scno].sys_name);
1514 if (!SCNO_IN_RANGE(tcp->scno) ||
1515 ((qual_flags[tcp->scno] & QUAL_RAW) &&
1516 sysent[tcp->scno].sys_func != sys_exit))
1517 res = printargs(tcp);
1519 res = (*sysent[tcp->scno].sys_func)(tcp);
1521 if (fflush(tcp->outf) == EOF)
1524 tcp->flags |= TCB_INSYSCALL;
1525 /* Measure the entrance time as late as possible to avoid errors. */
1527 gettimeofday(&tcp->etime, NULL);
1532 * 0: "ignore this ptrace stop", bail out of trace_syscall() silently.
1533 * 1: ok, continue in trace_syscall().
1534 * other: error, trace_syscall() should print error indicator
1535 * ("????" etc) and bail out.
1538 get_syscall_result(struct tcb *tcp)
1540 #if defined(S390) || defined(S390X)
1541 if (upeek(tcp, PT_GPR2, &gpr2) < 0)
1543 #elif defined(POWERPC)
1544 # define SO_MASK 0x10000000
1547 if (upeek(tcp, sizeof(unsigned long)*PT_CCR, &flags) < 0)
1549 if (upeek(tcp, sizeof(unsigned long)*PT_R3, &result) < 0)
1551 if (flags & SO_MASK)
1554 #elif defined(AVR32)
1555 /* Read complete register set in one go. */
1556 if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, ®s) < 0)
1559 if (upeek(tcp, PT_R0, &r0) < 0)
1562 if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (long) &i386_regs) < 0)
1564 #elif defined(X86_64)
1565 if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (long) &x86_64_regs) < 0)
1568 # define IA64_PSR_IS ((long)1 << 34)
1569 if (upeek(tcp, PT_CR_IPSR, &psr) >= 0)
1570 ia32 = (psr & IA64_PSR_IS) != 0;
1571 if (upeek(tcp, PT_R8, &r8) < 0)
1573 if (upeek(tcp, PT_R10, &r10) < 0)
1576 /* Read complete register set in one go. */
1577 if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (void *)®s) == -1)
1580 if (upeek(tcp, 4*PT_D0, &d0) < 0)
1582 #elif defined(LINUX_MIPSN32)
1583 unsigned long long regs[38];
1585 if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (long) ®s) < 0)
1590 if (upeek(tcp, REG_A3, &a3) < 0)
1592 if (upeek(tcp, REG_V0, &r2) < 0)
1594 #elif defined(ALPHA)
1595 if (upeek(tcp, REG_A3, &a3) < 0)
1597 if (upeek(tcp, REG_R0, &r0) < 0)
1599 #elif defined(SPARC) || defined(SPARC64)
1600 /* Everything we need is in the current register set. */
1601 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0)
1604 if (upeek(tcp, PT_GR28, &r28) < 0)
1608 #elif defined(CRISV10) || defined(CRISV32)
1609 if (upeek(tcp, 4*PT_R10, &r10) < 0)
1612 #elif defined(MICROBLAZE)
1613 if (upeek(tcp, 3 * 4, &r3) < 0)
1618 /* new syscall ABI returns result in R0 */
1619 if (upeek(tcp, 4*REG_REG0, (long *)&r0) < 0)
1622 /* ABI defines result returned in r9 */
1623 if (upeek(tcp, REG_GENERAL(9), (long *)&r9) < 0)
1630 /* Called at each syscall exit.
1632 * 0: "ignore this ptrace stop", bail out of trace_syscall() silently.
1633 * 1: ok, continue in trace_syscall().
1634 * other: error, trace_syscall() should print error indicator
1635 * ("????" etc) and bail out.
1638 syscall_fixup_on_sysexit(struct tcb *tcp)
1640 #if defined(S390) || defined(S390X)
1641 if (syscall_mode != -ENOSYS)
1642 syscall_mode = tcp->scno;
1643 if ((tcp->flags & TCB_WAITEXECVE)
1644 && (gpr2 == -ENOSYS || gpr2 == tcp->scno)) {
1646 * Return from execve.
1647 * Fake a return value of zero. We leave the TCB_WAITEXECVE
1648 * flag set for the post-execve SIGTRAP to see and reset.
1657 * Check the syscall return value register value for whether it is
1658 * a negated errno code indicating an error, or a success return value.
1661 is_negated_errno(unsigned long int val)
1663 unsigned long int max = -(long int) nerrnos;
1664 #if SUPPORTED_PERSONALITIES > 1
1665 if (personality_wordsize[current_personality] < sizeof(val)) {
1666 val = (unsigned int) val;
1667 max = (unsigned int) max;
1674 get_error(struct tcb *tcp)
1677 int check_errno = 1;
1678 if (SCNO_IN_RANGE(tcp->scno) &&
1679 sysent[tcp->scno].sys_flags & SYSCALL_NEVER_FAILS) {
1682 #if defined(S390) || defined(S390X)
1683 if (check_errno && is_negated_errno(gpr2)) {
1691 if (check_errno && is_negated_errno(i386_regs.eax)) {
1693 u_error = -i386_regs.eax;
1696 tcp->u_rval = i386_regs.eax;
1698 #elif defined(X86_64)
1699 if (check_errno && is_negated_errno(x86_64_regs.rax)) {
1701 u_error = -x86_64_regs.rax;
1704 tcp->u_rval = x86_64_regs.rax;
1711 if (check_errno && is_negated_errno(err)) {
1719 if (check_errno && r10) {
1727 if (check_errno && a3) {
1733 #elif defined(POWERPC)
1734 if (check_errno && is_negated_errno(result)) {
1739 tcp->u_rval = result;
1742 if (check_errno && is_negated_errno(d0)) {
1750 if (check_errno && is_negated_errno(regs.ARM_r0)) {
1752 u_error = -regs.ARM_r0;
1755 tcp->u_rval = regs.ARM_r0;
1757 #elif defined(AVR32)
1758 if (check_errno && regs.r12 && (unsigned) -regs.r12 < nerrnos) {
1760 u_error = -regs.r12;
1763 tcp->u_rval = regs.r12;
1766 if (check_errno && is_negated_errno(r0)) {
1772 #elif defined(ALPHA)
1773 if (check_errno && a3) {
1780 #elif defined(SPARC)
1781 if (check_errno && regs.psr & PSR_C) {
1783 u_error = regs.u_regs[U_REG_O0];
1786 tcp->u_rval = regs.u_regs[U_REG_O0];
1788 #elif defined(SPARC64)
1789 if (check_errno && regs.tstate & 0x1100000000UL) {
1791 u_error = regs.u_regs[U_REG_O0];
1794 tcp->u_rval = regs.u_regs[U_REG_O0];
1797 if (check_errno && is_negated_errno(r28)) {
1805 if (check_errno && is_negated_errno(r0)) {
1813 if (check_errno && is_negated_errno(r9)) {
1820 #elif defined(CRISV10) || defined(CRISV32)
1821 if (check_errno && r10 && (unsigned) -r10 < nerrnos) {
1830 if (upeek(tcp, PTREGS_OFFSET_REG(0), &rval) < 0)
1832 if (check_errno && rval < 0 && rval > -nerrnos) {
1839 #elif defined(MICROBLAZE)
1840 if (check_errno && is_negated_errno(r3)) {
1848 tcp->u_error = u_error;
1853 dumpio(struct tcb *tcp)
1857 if (tcp->u_arg[0] < 0 || tcp->u_arg[0] >= MAX_QUALS)
1859 if (!SCNO_IN_RANGE(tcp->scno))
1861 if (sysent[tcp->scno].sys_func == printargs)
1863 if (qual_flags[tcp->u_arg[0]] & QUAL_READ) {
1864 if (sysent[tcp->scno].sys_func == sys_read ||
1865 sysent[tcp->scno].sys_func == sys_pread ||
1866 sysent[tcp->scno].sys_func == sys_recv ||
1867 sysent[tcp->scno].sys_func == sys_recvfrom)
1868 dumpstr(tcp, tcp->u_arg[1], tcp->u_rval);
1869 else if (sysent[tcp->scno].sys_func == sys_readv)
1870 dumpiov(tcp, tcp->u_arg[2], tcp->u_arg[1]);
1873 if (qual_flags[tcp->u_arg[0]] & QUAL_WRITE) {
1874 if (sysent[tcp->scno].sys_func == sys_write ||
1875 sysent[tcp->scno].sys_func == sys_pwrite ||
1876 sysent[tcp->scno].sys_func == sys_send ||
1877 sysent[tcp->scno].sys_func == sys_sendto)
1878 dumpstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
1879 else if (sysent[tcp->scno].sys_func == sys_writev)
1880 dumpiov(tcp, tcp->u_arg[2], tcp->u_arg[1]);
1886 trace_syscall_exiting(struct tcb *tcp)
1893 /* Measure the exit time as early as possible to avoid errors. */
1895 gettimeofday(&tv, NULL);
1897 #if SUPPORTED_PERSONALITIES > 1
1898 update_personality(tcp, tcp->currpers);
1900 res = get_syscall_result(tcp);
1904 res = syscall_fixup_on_sysexit(tcp);
1908 res = get_error(tcp);
1912 internal_syscall(tcp);
1914 if (res == 1 && filtered(tcp)) {
1918 /* TODO: TCB_REPRINT is probably not necessary:
1919 * we can determine whether reprinting is needed
1920 * by examining printing_tcp. Something like:
1921 * if not in -ff mode, and printing_tcp != tcp,
1922 * then the log is not currenlty ends with *our*
1923 * syscall entry output, but with something else,
1924 * and we need to reprint.
1925 * If we'd implement this, printing_tcp = tcp
1926 * assignments in code below can be made more logical.
1929 if (tcp->flags & TCB_REPRINT) {
1931 if (!SCNO_IN_RANGE(tcp->scno))
1932 tprintf("<... syscall_%lu resumed> ", tcp->scno);
1934 tprintf("<... %s resumed> ", sysent[tcp->scno].sys_name);
1938 struct timeval t = tv;
1939 count_syscall(tcp, &t);
1940 if (cflag == CFLAG_ONLY_STATS) {
1949 tprints("= ? <unavailable>\n");
1951 tcp->flags &= ~TCB_INSYSCALL;
1955 if (!SCNO_IN_RANGE(tcp->scno)
1956 || (qual_flags[tcp->scno] & QUAL_RAW)) {
1958 sys_res = printargs(tcp);
1960 /* FIXME: not_failing_only (IOW, option -z) is broken:
1961 * failure of syscall is known only after syscall return.
1962 * Thus we end up with something like this on, say, ENOENT:
1963 * open("doesnt_exist", O_RDONLY <unfinished ...>
1964 * {next syscall decode}
1965 * whereas the intended result is that open(...) line
1966 * is not shown at all.
1968 if (not_failing_only && tcp->u_error)
1969 goto ret; /* ignore failed syscalls */
1971 sys_res = (*sysent[tcp->scno].sys_func)(tcp);
1976 u_error = tcp->u_error;
1977 if (!SCNO_IN_RANGE(tcp->scno) ||
1978 qual_flags[tcp->scno] & QUAL_RAW) {
1980 tprintf("= -1 (errno %ld)", u_error);
1982 tprintf("= %#lx", tcp->u_rval);
1984 else if (!(sys_res & RVAL_NONE) && u_error) {
1986 /* Blocked signals do not interrupt any syscalls.
1987 * In this case syscalls don't return ERESTARTfoo codes.
1989 * Deadly signals set to SIG_DFL interrupt syscalls
1990 * and kill the process regardless of which of the codes below
1991 * is returned by the interrupted syscall.
1992 * In some cases, kernel forces a kernel-generated deadly
1993 * signal to be unblocked and set to SIG_DFL (and thus cause
1994 * death) if it is blocked or SIG_IGNed: for example, SIGSEGV
1995 * or SIGILL. (The alternative is to leave process spinning
1996 * forever on the faulty instruction - not useful).
1998 * SIG_IGNed signals and non-deadly signals set to SIG_DFL
1999 * (for example, SIGCHLD, SIGWINCH) interrupt syscalls,
2000 * but kernel will always restart them.
2003 /* Most common type of signal-interrupted syscall exit code.
2004 * The system call will be restarted with the same arguments
2005 * if SA_RESTART is set; otherwise, it will fail with EINTR.
2007 tprints("= ? ERESTARTSYS (To be restarted if SA_RESTART is set)");
2009 case ERESTARTNOINTR:
2010 /* Rare. For example, fork() returns this if interrupted.
2011 * SA_RESTART is ignored (assumed set): the restart is unconditional.
2013 tprints("= ? ERESTARTNOINTR (To be restarted)");
2015 case ERESTARTNOHAND:
2016 /* pause(), rt_sigsuspend() etc use this code.
2017 * SA_RESTART is ignored (assumed not set):
2018 * syscall won't restart (will return EINTR instead)
2019 * even after signal with SA_RESTART set.
2020 * However, after SIG_IGN or SIG_DFL signal it will.
2022 tprints("= ? ERESTARTNOHAND (Interrupted by signal)");
2024 case ERESTART_RESTARTBLOCK:
2025 /* Syscalls like nanosleep(), poll() which can't be
2026 * restarted with their original arguments use this
2027 * code. Kernel will execute restart_syscall() instead,
2028 * which changes arguments before restarting syscall.
2029 * SA_RESTART is ignored (assumed not set) similarly
2030 * to ERESTARTNOHAND. (Kernel can't honor SA_RESTART
2031 * since restart data is saved in "restart block"
2032 * in task struct, and if signal handler uses a syscall
2033 * which in turn saves another such restart block,
2034 * old data is lost and restart becomes impossible)
2036 tprints("= ? ERESTART_RESTARTBLOCK (Interrupted by signal)");
2040 tprintf("= -1 E??? (errno %ld)", u_error);
2041 else if (u_error < nerrnos)
2042 tprintf("= -1 %s (%s)", errnoent[u_error],
2045 tprintf("= -1 ERRNO_%ld (%s)", u_error,
2049 if ((sys_res & RVAL_STR) && tcp->auxstr)
2050 tprintf(" (%s)", tcp->auxstr);
2053 if (sys_res & RVAL_NONE)
2056 switch (sys_res & RVAL_MASK) {
2058 tprintf("= %#lx", tcp->u_rval);
2061 tprintf("= %#lo", tcp->u_rval);
2064 tprintf("= %lu", tcp->u_rval);
2067 tprintf("= %ld", tcp->u_rval);
2069 #ifdef HAVE_LONG_LONG
2071 tprintf("= %#llx", tcp->u_lrval);
2074 tprintf("= %#llo", tcp->u_lrval);
2076 case RVAL_LUDECIMAL:
2077 tprintf("= %llu", tcp->u_lrval);
2080 tprintf("= %lld", tcp->u_lrval);
2085 "invalid rval format\n");
2089 if ((sys_res & RVAL_STR) && tcp->auxstr)
2090 tprintf(" (%s)", tcp->auxstr);
2093 tv_sub(&tv, &tv, &tcp->etime);
2094 tprintf(" <%ld.%06ld>",
2095 (long) tv.tv_sec, (long) tv.tv_usec);
2102 tcp->flags &= ~TCB_INSYSCALL;
2107 trace_syscall(struct tcb *tcp)
2109 return exiting(tcp) ?
2110 trace_syscall_exiting(tcp) : trace_syscall_entering(tcp);