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.
39 #include <sys/syscall.h>
41 #include <sys/param.h>
47 #include <machine/reg.h>
52 #if defined(linux) && (__GLIBC__ < 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ < 1))
53 #include <linux/ptrace.h>
56 #if defined(LINUX) && defined(IA64)
57 # include <asm/ptrace_offsets.h>
63 # define PTRACE_PEEKUSR PTRACE_PEEKUSER
64 #elif defined(HAVE_LINUX_PTRACE_H)
66 # ifdef HAVE_STRUCT_IA64_FPREG
67 # define ia64_fpreg XXX_ia64_fpreg
69 # ifdef HAVE_STRUCT_PT_ALL_USER_REGS
70 # define pt_all_user_regs XXX_pt_all_user_regs
72 #include <linux/ptrace.h>
74 # undef pt_all_user_regs
77 #ifdef SUNOS4_KERNEL_ARCH_KLUDGE
78 #include <sys/utsname.h>
79 #endif /* SUNOS4_KERNEL_ARCH_KLUDGE */
81 #if defined(LINUXSPARC) && defined (SPARC64)
82 # undef PTRACE_GETREGS
83 # define PTRACE_GETREGS PTRACE_GETREGS64
84 # undef PTRACE_SETREGS
85 # define PTRACE_SETREGS PTRACE_SETREGS64
90 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
93 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
100 return a->tv_sec || a->tv_usec;
105 struct timeval *a, *b;
107 if (a->tv_sec < b->tv_sec
108 || (a->tv_sec == b->tv_sec && a->tv_usec < b->tv_usec))
110 if (a->tv_sec > b->tv_sec
111 || (a->tv_sec == b->tv_sec && a->tv_usec > b->tv_usec))
120 return tv->tv_sec + tv->tv_usec/1000000.0;
125 struct timeval *tv, *a, *b;
127 tv->tv_sec = a->tv_sec + b->tv_sec;
128 tv->tv_usec = a->tv_usec + b->tv_usec;
129 if (tv->tv_usec >= 1000000) {
131 tv->tv_usec -= 1000000;
137 struct timeval *tv, *a, *b;
139 tv->tv_sec = a->tv_sec - b->tv_sec;
140 tv->tv_usec = a->tv_usec - b->tv_usec;
141 if (((long) tv->tv_usec) < 0) {
143 tv->tv_usec += 1000000;
149 struct timeval *tv, *a;
152 tv->tv_usec = (a->tv_sec % n * 1000000 + a->tv_usec + n / 2) / n;
153 tv->tv_sec = a->tv_sec / n + tv->tv_usec / 1000000;
154 tv->tv_usec %= 1000000;
159 struct timeval *tv, *a;
162 tv->tv_usec = a->tv_usec * n;
163 tv->tv_sec = a->tv_sec * n + tv->tv_usec / 1000000;
164 tv->tv_usec %= 1000000;
168 xlookup(const struct xlat *xlat, int val)
170 for (; xlat->str != NULL; xlat++)
171 if (xlat->val == val)
177 * Generic ptrace wrapper which tracks ESRCH errors
178 * by setting tcp->ptrace_errno to ESRCH.
180 * We assume that ESRCH indicates likely process death (SIGKILL?),
181 * modulo bugs where process somehow ended up not stopped.
182 * Unfortunately kernel uses ESRCH for that case too. Oh well.
184 * Currently used by upeek() only.
185 * TODO: use this in all other ptrace() calls while decoding.
188 do_ptrace(int request, struct tcb *tcp, void *addr, void *data)
193 l = ptrace(request, tcp->pid, addr, (long) data);
194 /* Non-ESRCH errors might be our invalid reg/mem accesses,
195 * we do not record them. */
197 tcp->ptrace_errno = ESRCH;
202 * Used when we want to unblock stopped traced process.
203 * Should be only used with PTRACE_CONT, PTRACE_DETACH and PTRACE_SYSCALL.
204 * Returns 0 on success or if error was ESRCH
205 * (presumably process was killed while we talk to it).
206 * Otherwise prints error message and returns -1.
209 ptrace_restart(int op, struct tcb *tcp, int sig)
215 ptrace(op, tcp->pid, (void *) 1, (long) sig);
217 if (!err || err == ESRCH)
220 tcp->ptrace_errno = err;
222 if (op == PTRACE_CONT)
224 if (op == PTRACE_DETACH)
226 fprintf(stderr, "strace: ptrace(PTRACE_%s,1,%d): %s\n",
227 msg, sig, strerror(err));
232 * Print entry in struct xlat table, if there.
235 printxval(const struct xlat *xlat, int val, const char *dflt)
237 const char *str = xlookup(xlat, val);
242 tprintf("%#x /* %s */", val, dflt);
247 * Print 64bit argument at position llarg and return the index of the next
251 printllval(struct tcb *tcp, const char *format, int llarg)
253 # if defined(FREEBSD) \
254 || (defined(LINUX) && defined(POWERPC) && !defined(POWERPC64)) \
255 || defined (LINUX_MIPSO32)
256 /* Align 64bit argument to 64bit boundary. */
257 if (llarg % 2) llarg++;
259 # if defined LINUX && (defined X86_64 || defined POWERPC64)
260 if (current_personality == 0) {
261 tprintf(format, tcp->u_arg[llarg]);
265 /* Align 64bit argument to 64bit boundary. */
266 if (llarg % 2) llarg++;
268 tprintf(format, LONG_LONG(tcp->u_arg[llarg], tcp->u_arg[llarg + 1]));
271 # elif defined IA64 || defined ALPHA
272 tprintf(format, tcp->u_arg[llarg]);
274 # elif defined LINUX_MIPSN32
275 tprintf(format, tcp->ext_arg[llarg]);
278 tprintf(format, LONG_LONG(tcp->u_arg[llarg], tcp->u_arg[llarg + 1]));
286 * Interpret `xlat' as an array of flags
287 * print the entries whose bits are on in `flags'
288 * return # of flags printed.
291 addflags(xlat, flags)
292 const struct xlat *xlat;
297 for (n = 0; xlat->str; xlat++) {
298 if (xlat->val && (flags & xlat->val) == xlat->val) {
299 tprintf("|%s", xlat->str);
305 tprintf("|%#x", flags);
312 * Interpret `xlat' as an array of flags/
313 * Print to static string the entries whose bits are on in `flags'
314 * Return static string.
317 sprintflags(const char *prefix, const struct xlat *xlat, int flags)
319 static char outstr[1024];
322 strcpy(outstr, prefix);
324 for (; xlat->str; xlat++) {
325 if ((flags & xlat->val) == xlat->val) {
328 strcat(outstr, xlat->str);
336 sprintf(outstr + strlen(outstr), "%#x", flags);
343 printflags(xlat, flags, dflt)
344 const struct xlat *xlat;
351 if (flags == 0 && xlat->val == 0) {
352 tprintf("%s", xlat->str);
357 for (n = 0; xlat->str; xlat++) {
358 if (xlat->val && (flags & xlat->val) == xlat->val) {
359 tprintf("%s%s", sep, xlat->str);
368 tprintf("%s%#x", sep, flags);
373 tprintf("%#x", flags);
375 tprintf(" /* %s */", dflt);
386 printnum(tcp, addr, fmt)
397 if (umove(tcp, addr, &num) < 0) {
398 tprintf("%#lx", addr);
407 printnum_int(tcp, addr, fmt)
418 if (umove(tcp, addr, &num) < 0) {
419 tprintf("%#lx", addr);
433 tprintf((uid == -1) ? "%ld" : "%lu", uid);
436 static char path[MAXPATHLEN + 1];
439 * Quote string `instr' of length `size'
440 * Write up to (3 + `size' * 4) bytes to `outstr' buffer.
441 * If `len' < 0, treat `instr' as a NUL-terminated string
442 * and quote at most (`size' - 1) bytes.
445 string_quote(const char *instr, char *outstr, int len, int size)
447 const unsigned char *ustr = (const unsigned char *) instr;
449 int usehex = 0, c, i;
454 /* Check for presence of symbol which require
455 to hex-quote the whole string. */
456 for (i = 0; i < size; ++i) {
458 /* Check for NUL-terminated string. */
462 /* Quote at most size - 1 bytes. */
466 if (!isprint(c) && !isspace(c)) {
476 /* Hex-quote the whole string. */
477 for (i = 0; i < size; ++i) {
479 /* Check for NUL-terminated string. */
483 /* Quote at most size - 1 bytes. */
487 sprintf(s, "\\x%02x", c);
491 for (i = 0; i < size; ++i) {
493 /* Check for NUL-terminated string. */
497 /* Quote at most size - 1 bytes. */
502 case '\"': case '\\':
529 else if (i + 1 < size
530 && isdigit(ustr[i + 1])) {
531 sprintf(s, "\\%03o", c);
534 sprintf(s, "\\%o", c);
545 /* Return nonzero if the string was unterminated. */
550 * Print path string specified by address `addr' and length `n'.
551 * If path length exceeds `n', append `...' to the output.
554 printpathn(struct tcb *tcp, long addr, int n)
561 /* Cap path length to the path buffer size,
562 and NUL-terminate the buffer. */
563 if (n > sizeof path - 1)
567 /* Fetch one byte more to find out whether path length > n. */
568 if (umovestr(tcp, addr, n + 1, path) < 0)
569 tprintf("%#lx", addr);
571 static char outstr[4*(sizeof path - 1) + sizeof "\"...\""];
572 int trunc = (path[n] != '\0');
576 (void) string_quote(path, outstr, -1, n + 1);
578 strcat(outstr, "...");
579 tprintf("%s", outstr);
584 printpath(struct tcb *tcp, long addr)
586 printpathn(tcp, addr, sizeof path - 1);
590 * Print string specified by address `addr' and length `len'.
591 * If `len' < 0, treat the string as a NUL-terminated string.
592 * If string length exceeds `max_strlen', append `...' to the output.
595 printstr(struct tcb *tcp, long addr, int len)
597 static char *str = NULL;
605 /* Allocate static buffers if they are not allocated yet. */
607 str = malloc(max_strlen + 1);
609 outstr = malloc(4 * max_strlen + sizeof "\"...\"");
610 if (!str || !outstr) {
611 fprintf(stderr, "out of memory\n");
612 tprintf("%#lx", addr);
618 * Treat as a NUL-terminated string: fetch one byte more
619 * because string_quote() quotes one byte less.
621 size = max_strlen + 1;
622 str[max_strlen] = '\0';
623 if (umovestr(tcp, addr, size, str) < 0) {
624 tprintf("%#lx", addr);
629 size = MIN(len, max_strlen);
630 if (umoven(tcp, addr, size, str) < 0) {
631 tprintf("%#lx", addr);
636 if (string_quote(str, outstr, len, size) &&
637 (len < 0 || len > max_strlen))
638 strcat(outstr, "...");
640 tprintf("%s", outstr);
645 dumpiov(tcp, len, addr)
650 #if defined(LINUX) && SUPPORTED_PERSONALITIES > 1
652 struct { u_int32_t base; u_int32_t len; } *iov32;
653 struct { u_int64_t base; u_int64_t len; } *iov64;
655 #define iov iovu.iov64
657 (personality_wordsize[current_personality] == 4 \
658 ? sizeof(*iovu.iov32) : sizeof(*iovu.iov64))
659 #define iov_iov_base(i) \
660 (personality_wordsize[current_personality] == 4 \
661 ? (u_int64_t) iovu.iov32[i].base : iovu.iov64[i].base)
662 #define iov_iov_len(i) \
663 (personality_wordsize[current_personality] == 4 \
664 ? (u_int64_t) iovu.iov32[i].len : iovu.iov64[i].len)
667 #define sizeof_iov sizeof(*iov)
668 #define iov_iov_base(i) iov[i].iov_base
669 #define iov_iov_len(i) iov[i].iov_len
674 size = sizeof_iov * (unsigned long) len;
675 if (size / sizeof_iov != len
676 || (iov = malloc(size)) == NULL) {
677 fprintf(stderr, "out of memory\n");
680 if (umoven(tcp, addr, size, (char *) iov) >= 0) {
681 for (i = 0; i < len; i++) {
682 /* include the buffer number to make it easy to
683 * match up the trace with the source */
684 tprintf(" * %lu bytes in buffer %d\n",
685 (unsigned long)iov_iov_len(i), i);
686 dumpstr(tcp, (long) iov_iov_base(i),
699 dumpstr(tcp, addr, len)
704 static int strsize = -1;
705 static unsigned char *str;
706 static char outstr[80];
713 if ((str = malloc(len)) == NULL) {
714 fprintf(stderr, "out of memory\n");
720 if (umoven(tcp, addr, len, (char *) str) < 0)
723 for (i = 0; i < len; i += 16) {
725 sprintf(s, " | %05x ", i);
727 for (j = 0; j < 16; j++) {
731 sprintf(s, " %02x", str[i + j]);
735 *s++ = ' '; *s++ = ' '; *s++ = ' ';
738 *s++ = ' '; *s++ = ' ';
739 for (j = 0; j < 16; j++) {
743 if (isprint(str[i + j]))
751 tprintf("%s |\n", outstr);
755 #define PAGMASK (~(PAGSIZ - 1))
757 * move `len' bytes of data from process `pid'
758 * at address `addr' to our space at `laddr'
761 umoven(struct tcb *tcp, long addr, int len, char *laddr)
769 char x[sizeof(long)];
772 if (addr & (sizeof(long) - 1)) {
773 /* addr not a multiple of sizeof(long) */
774 n = addr - (addr & -sizeof(long)); /* residue */
775 addr &= -sizeof(long); /* residue */
777 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
779 if (started && (errno==EPERM || errno==EIO)) {
780 /* Ran into 'end of memory' - stupid "printpath" */
783 /* But if not started, we had a bogus address. */
784 if (addr != 0 && errno != EIO && errno != ESRCH)
785 perror("ptrace: umoven");
789 memcpy(laddr, &u.x[n], m = MIN(sizeof(long) - n, len));
790 addr += sizeof(long), laddr += m, len -= m;
794 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
796 if (started && (errno==EPERM || errno==EIO)) {
797 /* Ran into 'end of memory' - stupid "printpath" */
800 if (addr != 0 && errno != EIO && errno != ESRCH)
801 perror("ptrace: umoven");
805 memcpy(laddr, u.x, m = MIN(sizeof(long), len));
806 addr += sizeof(long), laddr += m, len -= m;
815 n = MIN(len, PAGSIZ);
816 n = MIN(n, ((addr + PAGSIZ) & PAGMASK) - addr);
817 if (ptrace(PTRACE_READDATA, pid,
818 (char *) addr, len, laddr) < 0) {
819 if (errno != ESRCH) {
820 perror("umoven: ptrace(PTRACE_READDATA, ...)");
832 #ifdef HAVE_MP_PROCFS
833 int fd = tcp->pfd_as;
837 lseek(fd, addr, SEEK_SET);
838 if (read(fd, laddr, len) == -1)
840 #endif /* USE_PROCFS */
846 * like `umove' but make the additional effort of looking
847 * for a terminating zero byte.
850 umovestr(struct tcb *tcp, long addr, int len, char *laddr)
853 #ifdef HAVE_MP_PROCFS
854 int fd = tcp->pfd_as;
858 /* Some systems (e.g. FreeBSD) can be upset if we read off the
859 end of valid memory, avoid this by trying to read up
860 to page boundaries. But we don't know what a page is (and
861 getpagesize(2) (if it exists) doesn't necessarily return
862 hardware page size). Assume all pages >= 1024 (a-historical
865 int page = 1024; /* How to find this? */
866 int move = page - (addr & (page - 1));
869 lseek(fd, addr, SEEK_SET);
872 if (move > left) move = left;
873 if ((move = read(fd, laddr, move)) <= 0)
874 return left != len ? 0 : -1;
875 if (memchr (laddr, 0, move)) break;
881 #else /* !USE_PROCFS */
887 char x[sizeof(long)];
890 if (addr & (sizeof(long) - 1)) {
891 /* addr not a multiple of sizeof(long) */
892 n = addr - (addr & -sizeof(long)); /* residue */
893 addr &= -sizeof(long); /* residue */
895 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
897 if (started && (errno==EPERM || errno==EIO)) {
898 /* Ran into 'end of memory' - stupid "printpath" */
901 if (addr != 0 && errno != EIO && errno != ESRCH)
906 memcpy(laddr, &u.x[n], m = MIN(sizeof(long)-n,len));
907 while (n & (sizeof(long) - 1))
908 if (u.x[n++] == '\0')
910 addr += sizeof(long), laddr += m, len -= m;
914 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
916 if (started && (errno==EPERM || errno==EIO)) {
917 /* Ran into 'end of memory' - stupid "printpath" */
920 if (addr != 0 && errno != EIO && errno != ESRCH)
925 memcpy(laddr, u.x, m = MIN(sizeof(long), len));
926 for (i = 0; i < sizeof(long); i++)
930 addr += sizeof(long), laddr += m, len -= m;
932 #endif /* !USE_PROCFS */
937 # if !defined (SPARC) && !defined(SPARC64)
938 # define PTRACE_WRITETEXT 101
939 # define PTRACE_WRITEDATA 102
940 # endif /* !SPARC && !SPARC64 */
946 uload(cmd, pid, addr, len, laddr)
957 char x[sizeof(long)];
960 if (cmd == PTRACE_WRITETEXT) {
961 peek = PTRACE_PEEKTEXT;
962 poke = PTRACE_POKETEXT;
965 peek = PTRACE_PEEKDATA;
966 poke = PTRACE_POKEDATA;
968 if (addr & (sizeof(long) - 1)) {
969 /* addr not a multiple of sizeof(long) */
970 n = addr - (addr & -sizeof(long)); /* residue */
971 addr &= -sizeof(long);
973 u.val = ptrace(peek, pid, (char *) addr, 0);
975 perror("uload: POKE");
978 memcpy(&u.x[n], laddr, m = MIN(sizeof(long) - n, len));
979 if (ptrace(poke, pid, (char *)addr, u.val) < 0) {
980 perror("uload: POKE");
983 addr += sizeof(long), laddr += m, len -= m;
986 if (len < sizeof(long))
987 u.val = ptrace(peek, pid, (char *) addr, 0);
988 memcpy(u.x, laddr, m = MIN(sizeof(long), len));
989 if (ptrace(poke, pid, (char *) addr, u.val) < 0) {
990 perror("uload: POKE");
993 addr += sizeof(long), laddr += m, len -= m;
999 tload(pid, addr, len, laddr)
1004 return uload(PTRACE_WRITETEXT, pid, addr, len, laddr);
1008 dload(pid, addr, len, laddr)
1014 return uload(PTRACE_WRITEDATA, pid, addr, len, laddr);
1022 upeek(tcp, off, res)
1029 # ifdef SUNOS4_KERNEL_ARCH_KLUDGE
1031 static int is_sun4m = -1;
1032 struct utsname name;
1034 /* Round up the usual suspects. */
1035 if (is_sun4m == -1) {
1036 if (uname(&name) < 0) {
1037 perror("upeek: uname?");
1040 is_sun4m = strcmp(name.machine, "sun4m") == 0;
1042 const struct xlat *x;
1044 for (x = struct_user_offsets; x->str; x++)
1051 # endif /* SUNOS4_KERNEL_ARCH_KLUDGE */
1053 val = do_ptrace(PTRACE_PEEKUSER, tcp, (char *) off, 0);
1054 if (val == -1 && errno) {
1055 if (errno != ESRCH) {
1057 sprintf(buf,"upeek: ptrace(PTRACE_PEEKUSER,%d,%lu,0)", tcp->pid, off);
1066 #endif /* !USE_PROCFS */
1069 printcall(struct tcb *tcp)
1071 #define PRINTBADPC tprintf(sizeof(long) == 4 ? "[????????] " : \
1072 sizeof(long) == 8 ? "[????????????????] " : \
1079 if (upeek(tcp, 4*EIP, &eip) < 0) {
1083 tprintf("[%08lx] ", eip);
1085 # elif defined(S390) || defined(S390X)
1087 if(upeek(tcp,PT_PSWADDR,&psw) < 0) {
1092 tprintf("[%08lx] ", psw);
1094 tprintf("[%16lx] ", psw);
1097 # elif defined(X86_64)
1100 if (upeek(tcp, 8*RIP, &rip) < 0) {
1104 tprintf("[%16lx] ", rip);
1105 # elif defined(IA64)
1108 if (upeek(tcp, PT_B0, &ip) < 0) {
1112 tprintf("[%08lx] ", ip);
1113 # elif defined(POWERPC)
1116 if (upeek(tcp, sizeof(unsigned long)*PT_NIP, &pc) < 0) {
1121 tprintf("[%016lx] ", pc);
1123 tprintf("[%08lx] ", pc);
1125 # elif defined(M68K)
1128 if (upeek(tcp, 4*PT_PC, &pc) < 0) {
1129 tprintf ("[????????] ");
1132 tprintf("[%08lx] ", pc);
1133 # elif defined(ALPHA)
1136 if (upeek(tcp, REG_PC, &pc) < 0) {
1137 tprintf ("[????????????????] ");
1140 tprintf("[%08lx] ", pc);
1141 # elif defined(SPARC) || defined(SPARC64)
1142 struct pt_regs regs;
1143 if (ptrace(PTRACE_GETREGS,tcp->pid,(char *)®s,0) < 0) {
1147 # if defined(SPARC64)
1148 tprintf("[%08lx] ", regs.tpc);
1150 tprintf("[%08lx] ", regs.pc);
1152 # elif defined(HPPA)
1155 if(upeek(tcp,PT_IAOQ0,&pc) < 0) {
1156 tprintf ("[????????] ");
1159 tprintf("[%08lx] ", pc);
1160 # elif defined(MIPS)
1163 if (upeek(tcp, REG_EPC, &pc) < 0) {
1164 tprintf ("[????????] ");
1167 tprintf("[%08lx] ", pc);
1171 if (upeek(tcp, 4*REG_PC, &pc) < 0) {
1172 tprintf ("[????????] ");
1175 tprintf("[%08lx] ", pc);
1176 # elif defined(SH64)
1179 if (upeek(tcp, REG_PC, &pc) < 0) {
1180 tprintf ("[????????????????] ");
1183 tprintf("[%08lx] ", pc);
1187 if (upeek(tcp, 4*15, &pc) < 0) {
1191 tprintf("[%08lx] ", pc);
1192 # elif defined(AVR32)
1195 if (upeek(tcp, REG_PC, &pc) < 0) {
1196 tprintf("[????????] ");
1199 tprintf("[%08lx] ", pc);
1200 # elif defined(BFIN)
1203 if (upeek(tcp, PT_PC, &pc) < 0) {
1207 tprintf("[%08lx] ", pc);
1208 #elif defined(CRISV10)
1211 if (upeek(tcp, 4*PT_IRP, &pc) < 0) {
1215 tprintf("[%08lx] ", pc);
1216 #elif defined(CRISV32)
1219 if (upeek(tcp, 4*PT_ERP, &pc) < 0) {
1223 tprintf("[%08lx] ", pc);
1224 # endif /* architecture */
1230 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *) ®s, 0) < 0) {
1231 perror("printcall: ptrace(PTRACE_GETREGS, ...)");
1235 tprintf("[%08x] ", regs.r_o7);
1245 pread(tcp->pfd_reg, ®s, sizeof(regs), 0);
1246 tprintf("[%08x] ", regs.r_eip);
1247 #endif /* FREEBSD */
1252 * These #if's are huge, please indent them correctly.
1253 * It's easy to get confused otherwise.
1259 # include "syscall.h"
1261 # include <sys/syscall.h>
1262 # ifndef CLONE_PTRACE
1263 # define CLONE_PTRACE 0x00002000
1265 # ifndef CLONE_VFORK
1266 # define CLONE_VFORK 0x00004000
1269 # define CLONE_VM 0x00000100
1271 # ifndef CLONE_STOPPED
1272 # define CLONE_STOPPED 0x02000000
1277 /* We don't have fork()/vfork() syscalls on ia64 itself, but the ia32
1278 subsystem has them for x86... */
1280 # define SYS_vfork 190
1282 typedef unsigned long *arg_setup_state;
1285 arg_setup(struct tcb *tcp, arg_setup_state *state)
1287 unsigned long cfm, sof, sol;
1291 /* Satisfy a false GCC warning. */
1296 if (upeek(tcp, PT_AR_BSP, &bsp) < 0)
1298 if (upeek(tcp, PT_CFM, (long *) &cfm) < 0)
1301 sof = (cfm >> 0) & 0x7f;
1302 sol = (cfm >> 7) & 0x7f;
1303 bsp = (long) ia64_rse_skip_regs((unsigned long *) bsp, -sof + sol);
1305 *state = (unsigned long *) bsp;
1309 # define arg_finish_change(tcp, state) 0
1313 get_arg0 (struct tcb *tcp, arg_setup_state *state, long *valp)
1318 ret = upeek (tcp, PT_R11, valp);
1321 (unsigned long) ia64_rse_skip_regs(*state, 0),
1322 sizeof(long), (void *) valp);
1327 get_arg1 (struct tcb *tcp, arg_setup_state *state, long *valp)
1332 ret = upeek (tcp, PT_R9, valp);
1335 (unsigned long) ia64_rse_skip_regs(*state, 1),
1336 sizeof(long), (void *) valp);
1342 set_arg0 (struct tcb *tcp, arg_setup_state *state, long val)
1344 int req = PTRACE_POKEDATA;
1348 ap = (void *) (intptr_t) PT_R11; /* r11 == EBX */
1349 req = PTRACE_POKEUSER;
1351 ap = ia64_rse_skip_regs(*state, 0);
1353 ptrace(req, tcp->pid, ap, val);
1354 return errno ? -1 : 0;
1358 set_arg1 (struct tcb *tcp, arg_setup_state *state, long val)
1360 int req = PTRACE_POKEDATA;
1364 ap = (void *) (intptr_t) PT_R9; /* r9 == ECX */
1365 req = PTRACE_POKEUSER;
1367 ap = ia64_rse_skip_regs(*state, 1);
1369 ptrace(req, tcp->pid, ap, val);
1370 return errno ? -1 : 0;
1373 /* ia64 does not return the input arguments from functions (and syscalls)
1374 according to ia64 RSE (Register Stack Engine) behavior. */
1376 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1377 # define restore_arg1(tcp, state, val) ((void) (state), 0)
1379 # elif defined (SPARC) || defined (SPARC64)
1381 typedef struct pt_regs arg_setup_state;
1383 # define arg_setup(tcp, state) \
1384 (ptrace (PTRACE_GETREGS, tcp->pid, (char *) (state), 0))
1385 # define arg_finish_change(tcp, state) \
1386 (ptrace (PTRACE_SETREGS, tcp->pid, (char *) (state), 0))
1388 # define get_arg0(tcp, state, valp) (*(valp) = (state)->u_regs[U_REG_O0], 0)
1389 # define get_arg1(tcp, state, valp) (*(valp) = (state)->u_regs[U_REG_O1], 0)
1390 # define set_arg0(tcp, state, val) ((state)->u_regs[U_REG_O0] = (val), 0)
1391 # define set_arg1(tcp, state, val) ((state)->u_regs[U_REG_O1] = (val), 0)
1392 # define restore_arg0(tcp, state, val) 0
1394 # else /* other architectures */
1396 # if defined S390 || defined S390X
1397 /* Note: this is only true for the `clone' system call, which handles
1398 arguments specially. We could as well say that its first two arguments
1399 are swapped relative to other architectures, but that would just be
1400 another #ifdef in the calls. */
1401 # define arg0_offset PT_GPR3
1402 # define arg1_offset PT_ORIGGPR2
1403 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1404 # define restore_arg1(tcp, state, val) ((void) (state), 0)
1405 # define arg0_index 1
1406 # define arg1_index 0
1407 # elif defined (ALPHA) || defined (MIPS)
1408 # define arg0_offset REG_A0
1409 # define arg1_offset (REG_A0+1)
1410 # elif defined (AVR32)
1411 # define arg0_offset (REG_R12)
1412 # define arg1_offset (REG_R11)
1413 # elif defined (POWERPC)
1414 # define arg0_offset (sizeof(unsigned long)*PT_R3)
1415 # define arg1_offset (sizeof(unsigned long)*PT_R4)
1416 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1417 # elif defined (HPPA)
1418 # define arg0_offset PT_GR26
1419 # define arg1_offset (PT_GR26-4)
1420 # elif defined (X86_64)
1421 # define arg0_offset ((long)(8*(current_personality ? RBX : RDI)))
1422 # define arg1_offset ((long)(8*(current_personality ? RCX : RSI)))
1424 # define arg0_offset (4*(REG_REG0+4))
1425 # define arg1_offset (4*(REG_REG0+5))
1426 # elif defined (SH64)
1427 /* ABI defines arg0 & 1 in r2 & r3 */
1428 # define arg0_offset (REG_OFFSET+16)
1429 # define arg1_offset (REG_OFFSET+24)
1430 # define restore_arg0(tcp, state, val) 0
1431 # elif defined CRISV10 || defined CRISV32
1432 # define arg0_offset (4*PT_R11)
1433 # define arg1_offset (4*PT_ORIG_R10)
1434 # define restore_arg0(tcp, state, val) 0
1435 # define restore_arg1(tcp, state, val) 0
1436 # define arg0_index 1
1437 # define arg1_index 0
1439 # define arg0_offset 0
1440 # define arg1_offset 4
1442 # define restore_arg0(tcp, state, val) 0
1446 typedef int arg_setup_state;
1448 # define arg_setup(tcp, state) (0)
1449 # define arg_finish_change(tcp, state) 0
1450 # define get_arg0(tcp, cookie, valp) \
1451 (upeek ((tcp), arg0_offset, (valp)))
1452 # define get_arg1(tcp, cookie, valp) \
1453 (upeek ((tcp), arg1_offset, (valp)))
1456 set_arg0 (struct tcb *tcp, void *cookie, long val)
1458 return ptrace (PTRACE_POKEUSER, tcp->pid, (char*)arg0_offset, val);
1462 set_arg1 (struct tcb *tcp, void *cookie, long val)
1464 return ptrace (PTRACE_POKEUSER, tcp->pid, (char*)arg1_offset, val);
1467 # endif /* architectures */
1469 # ifndef restore_arg0
1470 # define restore_arg0(tcp, state, val) set_arg0((tcp), (state), (val))
1472 # ifndef restore_arg1
1473 # define restore_arg1(tcp, state, val) set_arg1((tcp), (state), (val))
1477 # define arg0_index 0
1478 # define arg1_index 1
1482 setbpt(struct tcb *tcp)
1484 static int clone_scno[SUPPORTED_PERSONALITIES] = { SYS_clone };
1485 arg_setup_state state;
1487 if (tcp->flags & TCB_BPTSET) {
1488 fprintf(stderr, "PANIC: TCB already set in pid %u\n", tcp->pid);
1493 * It's a silly kludge to initialize this with a search at runtime.
1494 * But it's better than maintaining another magic thing in the
1495 * godforsaken tables.
1497 if (clone_scno[current_personality] == 0) {
1499 for (i = 0; i < nsyscalls; ++i)
1500 if (sysent[i].sys_func == sys_clone) {
1501 clone_scno[current_personality] = i;
1506 switch (known_scno(tcp)) {
1513 # if defined SYS_fork || defined SYS_vfork
1514 if (arg_setup (tcp, &state) < 0
1515 || get_arg0 (tcp, &state, &tcp->inst[0]) < 0
1516 || get_arg1 (tcp, &state, &tcp->inst[1]) < 0
1517 || change_syscall(tcp, clone_scno[current_personality]) < 0
1518 || set_arg0 (tcp, &state, CLONE_PTRACE|SIGCHLD) < 0
1519 || set_arg1 (tcp, &state, 0) < 0
1520 || arg_finish_change (tcp, &state) < 0)
1522 tcp->u_arg[arg0_index] = CLONE_PTRACE|SIGCHLD;
1523 tcp->u_arg[arg1_index] = 0;
1524 tcp->flags |= TCB_BPTSET;
1532 /* ia64 calls directly `clone (CLONE_VFORK | CLONE_VM)'
1533 contrary to x86 SYS_vfork above. Even on x86 we turn the
1534 vfork semantics into plain fork - each application must not
1535 depend on the vfork specifics according to POSIX. We would
1536 hang waiting for the parent resume otherwise. We need to
1537 clear also CLONE_VM but only in the CLONE_VFORK case as
1538 otherwise we would break pthread_create. */
1540 if ((arg_setup (tcp, &state) < 0
1541 || set_arg0 (tcp, &state,
1542 (tcp->u_arg[arg0_index] | CLONE_PTRACE)
1543 & ~(tcp->u_arg[arg0_index] & CLONE_VFORK
1544 ? CLONE_VFORK | CLONE_VM : 0)) < 0
1545 || arg_finish_change (tcp, &state) < 0))
1547 tcp->flags |= TCB_BPTSET;
1548 tcp->inst[0] = tcp->u_arg[arg0_index];
1549 tcp->inst[1] = tcp->u_arg[arg1_index];
1553 fprintf(stderr, "PANIC: setbpt for syscall %ld on %u???\n",
1554 tcp->scno, tcp->pid);
1565 arg_setup_state state;
1566 if (arg_setup (tcp, &state) < 0
1567 || restore_arg0 (tcp, &state, tcp->inst[0]) < 0
1568 || restore_arg1 (tcp, &state, tcp->inst[1]) < 0
1569 || arg_finish_change (tcp, &state))
1570 if (errno != ESRCH) return -1;
1571 tcp->flags &= ~TCB_BPTSET;
1575 # else /* !defined LINUX */
1582 # ifdef SPARC /* This code is slightly sparc specific */
1585 # define BPT 0x91d02001 /* ta 1 */
1586 # define LOOP 0x10800000 /* ba 0 */
1587 # define LOOPA 0x30800000 /* ba,a 0 */
1588 # define NOP 0x01000000
1590 static int loopdeloop[1] = {LOOPA};
1592 static int loopdeloop[2] = {LOOP, NOP};
1595 if (tcp->flags & TCB_BPTSET) {
1596 fprintf(stderr, "PANIC: TCB already set in pid %u\n", tcp->pid);
1599 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) {
1600 perror("setbpt: ptrace(PTRACE_GETREGS, ...)");
1603 tcp->baddr = regs.r_o7 + 8;
1604 if (ptrace(PTRACE_READTEXT, tcp->pid, (char *)tcp->baddr,
1605 sizeof tcp->inst, (char *)tcp->inst) < 0) {
1606 perror("setbpt: ptrace(PTRACE_READTEXT, ...)");
1611 * XXX - BRUTAL MODE ON
1612 * We cannot set a real BPT in the child, since it will not be
1613 * traced at the moment it will reach the trap and would probably
1614 * die with a core dump.
1615 * Thus, we are force our way in by taking out two instructions
1616 * and insert an eternal loop in stead, in expectance of the SIGSTOP
1617 * generated by out PTRACE_ATTACH.
1618 * Of cause, if we evaporate ourselves in the middle of all this...
1620 if (ptrace(PTRACE_WRITETEXT, tcp->pid, (char *) tcp->baddr,
1621 sizeof loopdeloop, (char *) loopdeloop) < 0) {
1622 perror("setbpt: ptrace(PTRACE_WRITETEXT, ...)");
1625 tcp->flags |= TCB_BPTSET;
1628 # endif /* SUNOS4 */
1644 if (!(tcp->flags & TCB_BPTSET)) {
1645 fprintf(stderr, "PANIC: TCB not set in pid %u\n", tcp->pid);
1648 if (ptrace(PTRACE_WRITETEXT, tcp->pid, (char *) tcp->baddr,
1649 sizeof tcp->inst, (char *) tcp->inst) < 0) {
1650 perror("clearbtp: ptrace(PTRACE_WRITETEXT, ...)");
1653 tcp->flags &= ~TCB_BPTSET;
1657 * Since we don't have a single instruction breakpoint, we may have
1658 * to adjust the program counter after removing our `breakpoint'.
1660 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) {
1661 perror("clearbpt: ptrace(PTRACE_GETREGS, ...)");
1664 if ((regs.r_pc < tcp->baddr) ||
1665 (regs.r_pc > tcp->baddr + 4)) {
1666 /* The breakpoint has not been reached yet */
1669 "NOTE: PC not at bpt (pc %#x baddr %#x)\n",
1670 regs.r_pc, tcp->baddr);
1673 if (regs.r_pc != tcp->baddr)
1675 fprintf(stderr, "NOTE: PC adjusted (%#x -> %#x\n",
1676 regs.r_pc, tcp->baddr);
1678 regs.r_pc = tcp->baddr;
1679 if (ptrace(PTRACE_SETREGS, tcp->pid, (char *)®s, 0) < 0) {
1680 perror("clearbpt: ptrace(PTRACE_SETREGS, ...)");
1685 # endif /* SUNOS4 */
1690 # endif /* !defined LINUX */
1692 #endif /* !USE_PROCFS */
1704 for (n = 0; n < sizeof *hdr; n += 4) {
1706 if (upeek(tcp, uoff(u_exdata) + n, &res) < 0)
1708 memcpy(((char *) hdr) + n, &res, 4);
1711 fprintf(stderr, "[struct exec: magic: %o version %u Mach %o\n",
1712 hdr->a_magic, hdr->a_toolversion, hdr->a_machtype);
1713 fprintf(stderr, "Text %lu Data %lu Bss %lu Syms %lu Entry %#lx]\n",
1714 hdr->a_text, hdr->a_data, hdr->a_bss, hdr->a_syms, hdr->a_entry);
1725 * Change `vfork' in a freshly exec'ed dynamically linked
1726 * executable's (internal) symbol table to plain old `fork'
1730 struct link_dynamic dyn;
1731 struct link_dynamic_2 ld;
1734 if (getex(tcp, &hdr) < 0)
1739 if (umove(tcp, (int) N_DATADDR(hdr), &dyn) < 0) {
1740 fprintf(stderr, "Cannot read DYNAMIC\n");
1743 if (umove(tcp, (int) dyn.ld_un.ld_2, &ld) < 0) {
1744 fprintf(stderr, "Cannot read link_dynamic_2\n");
1747 if ((strtab = malloc((unsigned)ld.ld_symb_size)) == NULL) {
1748 fprintf(stderr, "out of memory\n");
1751 if (umoven(tcp, (int)ld.ld_symbols+(int)N_TXTADDR(hdr),
1752 (int)ld.ld_symb_size, strtab) < 0)
1755 for (cp = strtab; cp < strtab + ld.ld_symb_size; ) {
1756 if (strcmp(cp, "_vfork") == 0) {
1758 fprintf(stderr, "fixvfork: FOUND _vfork\n");
1759 strcpy(cp, "_fork");
1764 if (cp < strtab + ld.ld_symb_size)
1766 * Write entire symbol table back to avoid
1767 * memory alignment bugs in ptrace
1769 if (tload(pid, (int)ld.ld_symbols+(int)N_TXTADDR(hdr),
1770 (int)ld.ld_symb_size, strtab) < 0)