#include <sys/param.h>
#if HAVE_ASM_REG_H
-#ifdef SPARC
+#if defined (SPARC) || defined (SPARC64)
# define fpq kernel_fpq
# define fq kernel_fq
# define fpu kernel_fpu
#endif
#include <asm/reg.h>
-#ifdef SPARC
+#if defined (SPARC) || defined (SPARC64)
# undef fpq
# undef fq
# undef fpu
#endif
#elif defined(HAVE_LINUX_PTRACE_H)
#undef PTRACE_SYSCALL
+# ifdef HAVE_STRUCT_IA64_FPREG
+# define ia64_fpreg XXX_ia64_fpreg
+# endif
+# ifdef HAVE_STRUCT_PT_ALL_USER_REGS
+# define pt_all_user_regs XXX_pt_all_user_regs
+# endif
#include <linux/ptrace.h>
+# undef ia64_fpreg
+# undef pt_all_user_regs
#endif
+#if defined (LINUX) && defined (SPARC64)
+# define r_pc r_tpc
+# undef PTRACE_GETREGS
+# define PTRACE_GETREGS PTRACE_GETREGS64
+# undef PTRACE_SETREGS
+# define PTRACE_SETREGS PTRACE_SETREGS64
+#endif /* LINUX && SPARC64 */
+
#if defined(LINUX) && defined(IA64)
# include <asm/ptrace_offsets.h>
# include <asm/rse.h>
#ifndef ENOIOCTLCMD
#define ENOIOCTLCMD 515 /* No ioctl command */
#endif
+#ifndef ERESTART_RESTARTBLOCK
+#define ERESTART_RESTARTBLOCK 516 /* restart by calling sys_restart_syscall */
+#endif
#ifndef NSIG
#define NSIG 32
#endif
#define TP TRACE_PROCESS
#define TS TRACE_SIGNAL
-struct sysent sysent0[] = {
+static const struct sysent sysent0[] = {
#include "syscallent.h"
};
-int nsyscalls0 = sizeof sysent0 / sizeof sysent0[0];
+static const int nsyscalls0 = sizeof sysent0 / sizeof sysent0[0];
#if SUPPORTED_PERSONALITIES >= 2
-struct sysent sysent1[] = {
+static const struct sysent sysent1[] = {
#include "syscallent1.h"
};
-int nsyscalls1 = sizeof sysent1 / sizeof sysent1[0];
+static const int nsyscalls1 = sizeof sysent1 / sizeof sysent1[0];
#endif /* SUPPORTED_PERSONALITIES >= 2 */
#if SUPPORTED_PERSONALITIES >= 3
-struct sysent sysent2[] = {
+static const struct sysent sysent2[] = {
#include "syscallent2.h"
};
-int nsyscalls2 = sizeof sysent2 / sizeof sysent2[0];
+static const int nsyscalls2 = sizeof sysent2 / sizeof sysent2[0];
#endif /* SUPPORTED_PERSONALITIES >= 3 */
-struct sysent *sysent;
+const struct sysent *sysent;
int nsyscalls;
/* Now undef them since short defines cause wicked namespace pollution. */
#undef TP
#undef TS
-char *errnoent0[] = {
+static const char *const errnoent0[] = {
#include "errnoent.h"
};
-int nerrnos0 = sizeof errnoent0 / sizeof errnoent0[0];
+static const int nerrnos0 = sizeof errnoent0 / sizeof errnoent0[0];
#if SUPPORTED_PERSONALITIES >= 2
-char *errnoent1[] = {
+static const char *const errnoent1[] = {
#include "errnoent1.h"
};
-int nerrnos1 = sizeof errnoent1 / sizeof errnoent1[0];
+static const int nerrnos1 = sizeof errnoent1 / sizeof errnoent1[0];
#endif /* SUPPORTED_PERSONALITIES >= 2 */
#if SUPPORTED_PERSONALITIES >= 3
-char *errnoent2[] = {
+static const char *const errnoent2[] = {
#include "errnoent2.h"
};
-int nerrnos2 = sizeof errnoent2 / sizeof errnoent2[0];
+static const int nerrnos2 = sizeof errnoent2 / sizeof errnoent2[0];
#endif /* SUPPORTED_PERSONALITIES >= 3 */
-char **errnoent;
+const char *const *errnoent;
int nerrnos;
int current_personality;
qualify_one(atoi(s), opt, not);
return 1;
}
+ if (strlen(s) >= sizeof buf)
+ return 0;
strcpy(buf, s);
s = buf;
for (i = 0; s[i]; i++)
{
if (s && *s && isdigit((unsigned char)*s)) {
qualify_one(atoi(s), opt, not);
+ return 0;
}
return -1;
}
return;
switch (tcp->scno + NR_SYSCALL_BASE) {
case SYS_read:
+#ifdef SYS_pread64
+ case SYS_pread64:
+#endif
+#if defined SYS_pread && SYS_pread64 != SYS_pread
+ case SYS_pread:
+#endif
#ifdef SYS_recv
case SYS_recv:
#endif
dumpstr(tcp, tcp->u_arg[1], tcp->u_rval);
break;
case SYS_write:
+#ifdef SYS_pwrite64
+ case SYS_pwrite64:
+#endif
+#if defined SYS_pwrite && SYS_pwrite64 != SYS_pwrite
+ case SYS_pwrite:
+#endif
#ifdef SYS_send
case SYS_send:
#endif
#ifdef SYS_waitsys
case SYS_waitsys:
#endif
- internal_wait(tcp);
+ internal_wait(tcp, 2);
+ break;
+#ifdef SYS_waitid
+ case SYS_waitid:
+ internal_wait(tcp, 3);
break;
+#endif
#ifdef SYS_exit
case SYS_exit:
#endif
#ifdef __NR_exit_group
case __NR_exit_group:
+#endif
+#ifdef IA64
+ case 252: /* IA-32 __NR_exit_group */
#endif
internal_exit(tcp);
break;
#elif defined (M68K)
static int d0;
#elif defined (ARM)
- static int r0;
+ static struct pt_regs regs;
#elif defined (ALPHA)
static long r0;
static long a3;
-#elif defined (SPARC)
+#elif defined (SPARC) || defined (SPARC64)
static struct regs regs;
static unsigned long trap;
#elif defined(MIPS)
static long r28;
#elif defined(SH)
static long r0;
+#elif defined(SH64)
+ static long r9;
#elif defined(X86_64)
static long rax;
#endif
#ifdef LINUX
#if defined(S390) || defined(S390X)
- if (upeek(pid, PT_GPR2, &syscall_mode) < 0)
- return -1;
- if (syscall_mode != -ENOSYS) {
- /*
- * Since kernel version 2.5.44 the scno gets passed in gpr2.
- */
- scno = syscall_mode;
- }
if (tcp->flags & TCB_WAITEXECVE) {
/*
* When the execve system call completes successfully, the
tcp->flags &= ~TCB_WAITEXECVE;
return 0;
}
- else {
+
+ if (upeek(pid, PT_GPR2, &syscall_mode) < 0)
+ return -1;
+
+ if (syscall_mode != -ENOSYS) {
+ /*
+ * Since kernel version 2.5.44 the scno gets passed in gpr2.
+ */
+ scno = syscall_mode;
+ } else {
/*
* Old style of "passing" the scno via the SVC instruction.
*/
return -1;
}
#elif defined (ARM)
- {
- long pc;
- upeek(pid, 4*15, &pc);
- umoven(tcp, pc-4, 4, (char *)&scno);
- scno &= 0x000fffff;
+ /*
+ * Read complete register set in one go.
+ */
+ if (ptrace(PTRACE_GETREGS, pid, NULL, (void *)®s) == -1)
+ return -1;
+
+ /*
+ * We only need to grab the syscall number on syscall entry.
+ */
+ if (regs.ARM_ip == 0) {
+ /*
+ * Note: we only deal with only 32-bit CPUs here.
+ */
+ if (regs.ARM_cpsr & 0x20) {
+ /*
+ * Get the Thumb-mode system call number
+ */
+ scno = regs.ARM_r7;
+ } else {
+ /*
+ * Get the ARM-mode system call number
+ */
+ errno = 0;
+ scno = ptrace(PTRACE_PEEKTEXT, pid, (void *)(regs.ARM_pc - 4), NULL);
+ if (errno)
+ return -1;
+
+ if (scno == 0 && (tcp->flags & TCB_WAITEXECVE)) {
+ tcp->flags &= ~TCB_WAITEXECVE;
+ return 0;
+ }
+
+ if ((scno & 0x0ff00000) != 0x0f900000) {
+ fprintf(stderr, "syscall: unknown syscall trap 0x%08lx\n",
+ scno);
+ return -1;
+ }
+
+ /*
+ * Fixup the syscall number
+ */
+ scno &= 0x000fffff;
+ }
+
+ if (tcp->flags & TCB_INSYSCALL) {
+ fprintf(stderr, "pid %d stray syscall entry\n", tcp->pid);
+ tcp->flags &= ~TCB_INSYSCALL;
+ }
+ } else {
+ if (!(tcp->flags & TCB_INSYSCALL)) {
+ fprintf(stderr, "pid %d stray syscall exit\n", tcp->pid);
+ tcp->flags |= TCB_INSYSCALL;
+ }
}
#elif defined (M68K)
if (upeek(pid, 4*PT_ORIG_D0, &scno) < 0)
if (upeek(pid, REG_R0, &r0) < 0)
return -1;
}
-#elif defined (SPARC)
+#elif defined (SPARC) || defined (SPARC64)
/* Everything we need is in the current register set. */
if (ptrace(PTRACE_GETREGS,pid,(char *)®s,0) < 0)
return -1;
/* Retrieve the syscall trap instruction. */
errno = 0;
trap = ptrace(PTRACE_PEEKTEXT,pid,(char *)regs.r_pc,0);
+#if defined(SPARC64)
+ trap >>= 32;
+#endif
if (errno)
return -1;
break;
case 0x91d0206d:
/* Linux/SPARC64 syscall trap. */
- fprintf(stderr,"syscall: Linux/SPARC64 not supported yet\n");
- return -1;
+ set_personality(2);
+ break;
case 0x91d02000:
/* SunOS syscall trap. (pers 1) */
fprintf(stderr,"syscall: SunOS no support\n");
tcp->flags &= ~TCB_WAITEXECVE;
return 0;
}
+#if defined (SPARC64)
+ fprintf(stderr,"syscall: unknown syscall trap %08lx %016lx\n", trap, regs.r_tpc);
+#else
fprintf(stderr,"syscall: unknown syscall trap %08x %08x\n", trap, regs.r_pc);
+#endif
return -1;
}
return 0;
}
}
-#endif /* SH */
+#elif defined(SH64)
+ if (upeek(pid, REG_SYSCALL, &scno) < 0)
+ return -1;
+ scno &= 0xFFFF;
+
+ if (!(tcp->flags & TCB_INSYSCALL)) {
+ /* Check if we return from execve. */
+ if (tcp->flags & TCB_WAITEXECVE) {
+ tcp->flags &= ~TCB_WAITEXECVE;
+ return 0;
+ }
+ }
+#endif /* SH64 */
#endif /* LINUX */
#ifdef SUNOS4
if (upeek(pid, uoff(u_arg[7]), &scno) < 0)
return -1;
#elif defined(SH)
- /* new syscall ABI returns result in R0 */
- if (upeek(pid, 4*REG_REG0, (long *)&r0) < 0)
- return -1;
+ /* new syscall ABI returns result in R0 */
+ if (upeek(pid, 4*REG_REG0, (long *)&r0) < 0)
+ return -1;
+#elif defined(SH64)
+ /* ABI defines result returned in r9 */
+ if (upeek(pid, REG_GENERAL(9), (long *)&r9) < 0)
+ return -1;
+
#endif
#ifdef USE_PROCFS
#ifdef HAVE_PR_SYSCALL
#elif defined (X86_64)
if (upeek(pid, 8*RAX, &rax) < 0)
return -1;
+ if (current_personality == 1)
+ rax = (long int)(int)rax; /* sign extend from 32 bits */
if (rax != -ENOSYS && !(tcp->flags & TCB_INSYSCALL)) {
if (debug)
fprintf(stderr, "stray syscall exit: rax = %ld\n", rax);
return 0;
}
#elif defined (ARM)
- if (upeek(pid, 4*0, (long *)&r0) < 0)
- return -1;
- if ( 0 && r0 != -ENOSYS && !(tcp->flags & TCB_INSYSCALL)) {
- if (debug)
- fprintf(stderr, "stray syscall exit: d0 = %ld\n", r0);
- return 0;
- }
+ /*
+ * Nothing required
+ */
#elif defined (HPPA)
if (upeek(pid, PT_GR28, &r28) < 0)
return -1;
}
#else
#ifdef POWERPC
- if (result && (unsigned) -result < nerrnos) {
+ if (result && (unsigned long) -result < nerrnos) {
tcp->u_rval = -1;
u_error = -result;
}
}
#else /* !M68K */
#ifdef ARM
- if (r0 && (unsigned) -r0 < nerrnos) {
+ if (regs.ARM_r0 && (unsigned) -regs.ARM_r0 < nerrnos) {
tcp->u_rval = -1;
- u_error = -r0;
+ u_error = -regs.ARM_r0;
}
else {
- tcp->u_rval = r0;
+ tcp->u_rval = regs.ARM_r0;
u_error = 0;
}
#else /* !ARM */
u_error = 0;
}
#else /* !SPARC */
+#ifdef SPARC64
+ if (regs.r_tstate & 0x1100000000UL) {
+ tcp->u_rval = -1;
+ u_error = regs.r_o0;
+ }
+ else {
+ tcp->u_rval = regs.r_o0;
+ u_error = 0;
+ }
+#else /* !SPARC64 */
#ifdef HPPA
if (r28 && (unsigned) -r28 < nerrnos) {
tcp->u_rval = -1;
tcp->u_rval = r0;
u_error = 0;
}
+#else
+#ifdef SH64
+ /* interpret result as return value or error number */
+ if (r9 && (unsigned) -r9 < nerrnos) {
+ tcp->u_rval = -1;
+ u_error = -r9;
+ }
+ else {
+ tcp->u_rval = r9;
+ u_error = 0;
+ }
+#endif /* SH64 */
#endif /* SH */
#endif /* HPPA */
#endif /* SPARC */
+#endif /* SPARC64 */
#endif /* ALPHA */
#endif /* ARM */
#endif /* M68K */
#ifdef LINUX
#if defined(S390) || defined(S390X)
gpr2 = error ? -error : rval;
- if (upeek(tcp->pid, PT_GPR2, &gpr2) < 0)
- return -1;
if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)PT_GPR2, gpr2) < 0)
return -1;
#else /* !S390 && !S390X */
#else /* !I386 */
#ifdef X86_64
rax = error ? -error : rval;
- if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(RAX * 4), rax) < 0)
+ if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(RAX * 8), rax) < 0)
return -1;
#else
#ifdef IA64
return -1;
#else /* !M68K */
#ifdef ARM
- r0 = error ? -error : rval;
- if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*0), r0) < 0)
+ regs.ARM_r0 = error ? -error : rval;
+ if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*0), regs.ARM_r0) < 0)
return -1;
#else /* !ARM */
#ifdef ALPHA
if (ptrace(PTRACE_SETREGS, tcp->pid, (char *)®s, 0) < 0)
return -1;
#else /* !SPARC */
+#ifdef SPARC64
+ if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0)
+ return -1;
+ if (error) {
+ regs.r_tstate |= 0x1100000000UL;
+ regs.r_o0 = error;
+ }
+ else {
+ regs.r_tstate &= ~0x1100000000UL;
+ regs.r_o0 = rval;
+ }
+ if (ptrace(PTRACE_SETREGS, tcp->pid, (char *)®s, 0) < 0)
+ return -1;
+#else /* !SPARC64 */
#ifdef HPPA
r28 = error ? -error : rval;
if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_GR28), r28) < 0)
r0 = error ? -error : rval;
if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*REG_REG0), r0) < 0)
return -1;
+#else
+#ifdef SH64
+ r9 = error ? -error : rval;
+ if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)REG_GENERAL(9), r9) < 0)
+ return -1;
+#endif /* SH64 */
#endif /* SH */
#endif /* HPPA */
#endif /* SPARC */
+#endif /* SPARC64 */
#endif /* ALPHA */
#endif /* ARM */
#endif /* M68K */
return -1;
}
}
-#elif defined (SPARC)
+#elif defined (SPARC) || defined (SPARC64)
{
int i;
return -1;
}
}
+#elif defined(ARM)
+ {
+ int i;
+
+ if (tcp->scno >= 0 && tcp->scno < nsyscalls && sysent[tcp->scno].nargs != -1)
+ tcp->u_nargs = sysent[tcp->scno].nargs;
+ else
+ tcp->u_nargs = MAX_ARGS;
+ for (i = 0; i < tcp->u_nargs; i++)
+ tcp->u_arg[i] = regs.uregs[i];
+ }
#elif defined(SH)
{
int i;
return -1;
}
}
+#elif defined(SH64)
+ {
+ int i;
+ /* Registers used by SH5 Linux system calls for parameters */
+ static int syscall_regs[] = { 2, 3, 4, 5, 6, 7 };
+
+ /*
+ * TODO: should also check that the number of arguments encoded
+ * in the trap number matches the number strace expects.
+ */
+ /*
+ assert(sysent[tcp->scno].nargs <
+ sizeof(syscall_regs)/sizeof(syscall_regs[0]));
+ */
+
+ tcp->u_nargs = sysent[tcp->scno].nargs;
+ for (i = 0; i < tcp->u_nargs; i++) {
+ if (upeek(pid, REG_GENERAL(syscall_regs[i]), &tcp->u_arg[i]) < 0)
+ return -1;
+ }
+ }
+
#elif defined(X86_64)
{
int i;
tv_sub(&tv, &tv, &tcp->etime);
#ifdef LINUX
if (tv_cmp(&tv, &tcp->dtime) > 0) {
- static struct timeval one_tick =
- { 0, 1000000 / HZ };
+ static struct timeval one_tick;
+ if (one_tick.tv_usec == 0) {
+ /* Initialize it. */
+ struct itimerval it;
+ memset(&it, 0, sizeof it);
+ it.it_interval.tv_usec = 1;
+ setitimer(ITIMER_REAL, &it, NULL);
+ getitimer(ITIMER_REAL, &it);
+ one_tick = it.it_interval;
+ }
if (tv_nz(&tcp->dtime))
tv = tcp->dtime;
case ERESTARTNOHAND:
tprintf("= ? ERESTARTNOHAND (To be restarted)");
break;
+ case ERESTART_RESTARTBLOCK:
+ tprintf("= ? ERESTART_RESTARTBLOCK (To be restarted)");
+ break;
#endif /* LINUX */
default:
tprintf("= -1 ");
switch (tcp->scno + NR_SYSCALL_BASE) {
#ifdef LINUX
-#if !defined (ALPHA) && !defined(SPARC) && !defined(MIPS) && !defined(HPPA) && !defined(X86_64)
+#if !defined (ALPHA) && !defined(SPARC) && !defined(SPARC64) && !defined(MIPS) && !defined(HPPA) && !defined(X86_64)
case SYS_socketcall:
decode_subcall(tcp, SYS_socket_subcall,
SYS_socket_nsubcalls, deref_style);
decode_subcall(tcp, SYS_ipc_subcall,
SYS_ipc_nsubcalls, shift_style);
break;
-#endif /* !ALPHA && !MIPS && !SPARC && !HPPA && !X86_64 */
-#ifdef SPARC
+#endif /* !ALPHA && !MIPS && !SPARC && !SPARC64 && !HPPA && !X86_64 */
+#if defined (SPARC) || defined (SPARC64)
case SYS_socketcall:
sparc_socket_decode (tcp);
break;
long val = -1;
#ifdef LINUX
-#ifdef SPARC
+#if defined (SPARC) || defined (SPARC64)
struct regs regs;
if (ptrace(PTRACE_GETREGS,tcp->pid,(char *)®s,0) < 0)
return -1;
#elif defined(SH)
if (upeek(tcp->pid, 4*(REG_REG0+1), &val) < 0)
return -1;
-#endif /* SPARC */
+#endif /* SPARC || SPARC64 */
+#elif defined(IA64)
+ if (upeek(tcp->pid, PT_R9, &val) < 0)
+ return -1;
#endif /* LINUX */
#ifdef SUNOS4
projects / strace / blobdiff