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))
97 tv_nz(struct timeval *a)
99 return a->tv_sec || a->tv_usec;
103 tv_cmp(struct timeval *a, struct timeval *b)
105 if (a->tv_sec < b->tv_sec
106 || (a->tv_sec == b->tv_sec && a->tv_usec < b->tv_usec))
108 if (a->tv_sec > b->tv_sec
109 || (a->tv_sec == b->tv_sec && a->tv_usec > b->tv_usec))
115 tv_float(struct timeval *tv)
117 return tv->tv_sec + tv->tv_usec/1000000.0;
121 tv_add(struct timeval *tv, struct timeval *a, struct timeval *b)
123 tv->tv_sec = a->tv_sec + b->tv_sec;
124 tv->tv_usec = a->tv_usec + b->tv_usec;
125 if (tv->tv_usec >= 1000000) {
127 tv->tv_usec -= 1000000;
132 tv_sub(struct timeval *tv, struct timeval *a, struct timeval *b)
134 tv->tv_sec = a->tv_sec - b->tv_sec;
135 tv->tv_usec = a->tv_usec - b->tv_usec;
136 if (((long) tv->tv_usec) < 0) {
138 tv->tv_usec += 1000000;
143 tv_div(struct timeval *tv, struct timeval *a, int n)
145 tv->tv_usec = (a->tv_sec % n * 1000000 + a->tv_usec + n / 2) / n;
146 tv->tv_sec = a->tv_sec / n + tv->tv_usec / 1000000;
147 tv->tv_usec %= 1000000;
151 tv_mul(struct timeval *tv, struct timeval *a, int n)
153 tv->tv_usec = a->tv_usec * n;
154 tv->tv_sec = a->tv_sec * n + tv->tv_usec / 1000000;
155 tv->tv_usec %= 1000000;
159 xlookup(const struct xlat *xlat, int val)
161 for (; xlat->str != NULL; xlat++)
162 if (xlat->val == val)
167 #if !defined HAVE_STPCPY
169 stpcpy(char *dst, const char *src)
171 while ((*dst = *src++) != '\0')
178 * Generic ptrace wrapper which tracks ESRCH errors
179 * by setting tcp->ptrace_errno to ESRCH.
181 * We assume that ESRCH indicates likely process death (SIGKILL?),
182 * modulo bugs where process somehow ended up not stopped.
183 * Unfortunately kernel uses ESRCH for that case too. Oh well.
185 * Currently used by upeek() only.
186 * TODO: use this in all other ptrace() calls while decoding.
189 do_ptrace(int request, struct tcb *tcp, void *addr, void *data)
194 l = ptrace(request, tcp->pid, addr, (long) data);
195 /* Non-ESRCH errors might be our invalid reg/mem accesses,
196 * we do not record them. */
198 tcp->ptrace_errno = ESRCH;
203 * Used when we want to unblock stopped traced process.
204 * Should be only used with PTRACE_CONT, PTRACE_DETACH and PTRACE_SYSCALL.
205 * Returns 0 on success or if error was ESRCH
206 * (presumably process was killed while we talk to it).
207 * Otherwise prints error message and returns -1.
210 ptrace_restart(int op, struct tcb *tcp, int sig)
216 ptrace(op, tcp->pid, (void *) 1, (long) sig);
218 if (!err || err == ESRCH)
221 tcp->ptrace_errno = err;
223 if (op == PTRACE_CONT)
225 if (op == PTRACE_DETACH)
227 perror_msg("ptrace(PTRACE_%s,1,%d)", msg, sig);
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 || defined(__ARM_EABI__)
257 /* Align 64bit argument to 64bit boundary. */
258 llarg = (llarg + 1) & 0x1e;
260 # if defined LINUX && (defined X86_64 || defined POWERPC64)
261 if (current_personality == 0) {
262 tprintf(format, tcp->u_arg[llarg]);
266 /* Align 64bit argument to 64bit boundary. */
267 llarg = (llarg + 1) & 0x1e;
269 tprintf(format, LONG_LONG(tcp->u_arg[llarg], tcp->u_arg[llarg + 1]));
272 # elif defined IA64 || defined ALPHA
273 tprintf(format, tcp->u_arg[llarg]);
275 # elif defined LINUX_MIPSN32
276 tprintf(format, tcp->ext_arg[llarg]);
279 tprintf(format, LONG_LONG(tcp->u_arg[llarg], tcp->u_arg[llarg + 1]));
287 * Interpret `xlat' as an array of flags
288 * print the entries whose bits are on in `flags'
289 * return # of flags printed.
292 addflags(const struct xlat *xlat, int flags)
294 for (; xlat->str; xlat++) {
295 if (xlat->val && (flags & xlat->val) == xlat->val) {
296 tprintf("|%s", xlat->str);
301 tprintf("|%#x", flags);
306 * Interpret `xlat' as an array of flags.
307 * Print to static string the entries whose bits are on in `flags'
308 * Return static string.
311 sprintflags(const char *prefix, const struct xlat *xlat, int flags)
313 static char outstr[1024];
317 outptr = stpcpy(outstr, prefix);
319 for (; xlat->str; xlat++) {
320 if ((flags & xlat->val) == xlat->val) {
323 outptr = stpcpy(outptr, xlat->str);
331 outptr += sprintf(outptr, "%#x", flags);
338 printflags(const struct xlat *xlat, int flags, const char *dflt)
343 if (flags == 0 && xlat->val == 0) {
349 for (n = 0; xlat->str; xlat++) {
350 if (xlat->val && (flags & xlat->val) == xlat->val) {
351 tprintf("%s%s", sep, xlat->str);
360 tprintf("%s%#x", sep, flags);
365 tprintf("%#x", flags);
367 tprintf(" /* %s */", dflt);
378 printnum(struct tcb *tcp, long addr, const char *fmt)
386 if (umove(tcp, addr, &num) < 0) {
387 tprintf("%#lx", addr);
396 printnum_int(struct tcb *tcp, long addr, const char *fmt)
404 if (umove(tcp, addr, &num) < 0) {
405 tprintf("%#lx", addr);
414 printfd(struct tcb *tcp, int fd)
418 if (show_fd_path && (p = getfdpath(tcp, fd)))
419 tprintf("%d<%s>", fd, p);
425 printuid(const char *text, unsigned long uid)
427 tprintf((uid == -1) ? "%s%ld" : "%s%lu", text, uid);
430 static char path[MAXPATHLEN + 1];
433 * Quote string `instr' of length `size'
434 * Write up to (3 + `size' * 4) bytes to `outstr' buffer.
435 * If `len' < 0, treat `instr' as a NUL-terminated string
436 * and quote at most (`size' - 1) bytes.
439 string_quote(const char *instr, char *outstr, int len, int size)
441 const unsigned char *ustr = (const unsigned char *) instr;
443 int usehex, c, i, eol;
445 eol = 0x100; /* this can never match a char */
455 /* Check for presence of symbol which require
456 to hex-quote the whole string. */
457 for (i = 0; i < size; ++i) {
459 /* Check for NUL-terminated string. */
462 if (!isprint(c) && !isspace(c)) {
472 /* Hex-quote the whole string. */
473 for (i = 0; i < size; ++i) {
475 /* Check for NUL-terminated string. */
480 *s++ = "0123456789abcdef"[c >> 4];
481 *s++ = "0123456789abcdef"[c & 0xf];
484 for (i = 0; i < size; ++i) {
486 /* Check for NUL-terminated string. */
490 case '\"': case '\\':
521 && ustr[i + 1] >= '0'
522 && ustr[i + 1] <= '9'
525 *s++ = '0' + (c >> 6);
526 *s++ = '0' + ((c >> 3) & 0x7);
531 *s++ = '0' + (c >> 6);
532 *s++ = '0' + ((c >> 3) & 0x7);
535 *s++ = '0' + (c & 0x7);
545 /* Return zero if we printed entire ASCIZ string (didn't truncate it) */
546 if (len < 0 && ustr[i] == '\0') {
547 /* We didn't see NUL yet (otherwise we'd jump to 'asciz_ended')
548 * but next char is NUL.
558 /* Return zero: we printed entire ASCIZ string (didn't truncate it) */
563 * Print path string specified by address `addr' and length `n'.
564 * If path length exceeds `n', append `...' to the output.
567 printpathn(struct tcb *tcp, long addr, int n)
574 /* Cap path length to the path buffer size,
575 and NUL-terminate the buffer. */
576 if (n > sizeof path - 1)
580 /* Fetch one byte more to find out whether path length > n. */
581 if (umovestr(tcp, addr, n + 1, path) < 0)
582 tprintf("%#lx", addr);
584 static char outstr[4*(sizeof path - 1) + sizeof "\"...\""];
586 int trunc = (path[n] != '\0');
590 string_quote(path, outstr, -1, n + 1);
594 tprintf(fmt, outstr);
599 printpath(struct tcb *tcp, long addr)
601 printpathn(tcp, addr, sizeof path - 1);
605 * Print string specified by address `addr' and length `len'.
606 * If `len' < 0, treat the string as a NUL-terminated string.
607 * If string length exceeds `max_strlen', append `...' to the output.
610 printstr(struct tcb *tcp, long addr, int len)
612 static char *str = NULL;
621 /* Allocate static buffers if they are not allocated yet. */
623 str = malloc(max_strlen + 1);
628 outstr = malloc(4 * max_strlen + sizeof "\"...\"");
635 * Treat as a NUL-terminated string: fetch one byte more
636 * because string_quote() quotes one byte less.
638 size = max_strlen + 1;
639 str[max_strlen] = '\0';
640 /* FIXME! umovestr can overwrite the '\0' stored above??? */
641 if (umovestr(tcp, addr, size, str) < 0) {
642 tprintf("%#lx", addr);
647 size = MIN(len, max_strlen);
648 if (umoven(tcp, addr, size, str) < 0) {
649 tprintf("%#lx", addr);
655 if (string_quote(str, outstr, len, size) &&
656 (len < 0 || len > max_strlen))
659 tprintf(fmt, outstr);
664 dumpiov(struct tcb *tcp, int len, long addr)
666 #if defined(LINUX) && SUPPORTED_PERSONALITIES > 1
668 struct { u_int32_t base; u_int32_t len; } *iov32;
669 struct { u_int64_t base; u_int64_t len; } *iov64;
671 #define iov iovu.iov64
673 (personality_wordsize[current_personality] == 4 \
674 ? sizeof(*iovu.iov32) : sizeof(*iovu.iov64))
675 #define iov_iov_base(i) \
676 (personality_wordsize[current_personality] == 4 \
677 ? (u_int64_t) iovu.iov32[i].base : iovu.iov64[i].base)
678 #define iov_iov_len(i) \
679 (personality_wordsize[current_personality] == 4 \
680 ? (u_int64_t) iovu.iov32[i].len : iovu.iov64[i].len)
683 #define sizeof_iov sizeof(*iov)
684 #define iov_iov_base(i) iov[i].iov_base
685 #define iov_iov_len(i) iov[i].iov_len
690 size = sizeof_iov * len;
691 /* Assuming no sane program has millions of iovs */
692 if ((unsigned)len > 1024*1024 /* insane or negative size? */
693 || (iov = malloc(size)) == NULL) {
694 fprintf(stderr, "Out of memory\n");
697 if (umoven(tcp, addr, size, (char *) iov) >= 0) {
698 for (i = 0; i < len; i++) {
699 /* include the buffer number to make it easy to
700 * match up the trace with the source */
701 tprintf(" * %lu bytes in buffer %d\n",
702 (unsigned long)iov_iov_len(i), i);
703 dumpstr(tcp, (long) iov_iov_base(i),
716 dumpstr(struct tcb *tcp, long addr, int len)
718 static int strsize = -1;
719 static unsigned char *str;
728 fprintf(stderr, "Out of memory\n");
734 if (umoven(tcp, addr, len, (char *) str) < 0)
737 for (i = 0; i < len; i += 16) {
741 sprintf(s, " | %05x ", i);
743 for (j = 0; j < 16; j++) {
747 sprintf(s, " %02x", str[i + j]);
751 *s++ = ' '; *s++ = ' '; *s++ = ' ';
754 *s++ = ' '; *s++ = ' ';
755 for (j = 0; j < 16; j++) {
759 if (isprint(str[i + j]))
767 tprintf("%s |\n", outstr);
771 #define PAGMASK (~(PAGSIZ - 1))
773 * move `len' bytes of data from process `pid'
774 * at address `addr' to our space at `laddr'
777 umoven(struct tcb *tcp, long addr, int len, char *laddr)
785 char x[sizeof(long)];
788 #if SUPPORTED_PERSONALITIES > 1
789 if (personality_wordsize[current_personality] < sizeof(addr))
790 addr &= (1ul << 8 * personality_wordsize[current_personality]) - 1;
793 if (addr & (sizeof(long) - 1)) {
794 /* addr not a multiple of sizeof(long) */
795 n = addr - (addr & -sizeof(long)); /* residue */
796 addr &= -sizeof(long); /* residue */
798 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
800 /* But if not started, we had a bogus address. */
801 if (addr != 0 && errno != EIO && errno != ESRCH)
802 perror("ptrace: umoven");
806 memcpy(laddr, &u.x[n], m = MIN(sizeof(long) - n, len));
807 addr += sizeof(long), laddr += m, len -= m;
811 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
813 if (started && (errno==EPERM || errno==EIO)) {
814 /* Ran into 'end of memory' - stupid "printpath" */
817 if (addr != 0 && errno != EIO && errno != ESRCH)
818 perror("ptrace: umoven");
822 memcpy(laddr, u.x, m = MIN(sizeof(long), len));
823 addr += sizeof(long), laddr += m, len -= m;
832 n = MIN(len, PAGSIZ);
833 n = MIN(n, ((addr + PAGSIZ) & PAGMASK) - addr);
834 if (ptrace(PTRACE_READDATA, pid,
835 (char *) addr, len, laddr) < 0) {
836 if (errno != ESRCH) {
837 perror("umoven: ptrace(PTRACE_READDATA, ...)");
849 #ifdef HAVE_MP_PROCFS
850 int fd = tcp->pfd_as;
854 lseek(fd, addr, SEEK_SET);
855 if (read(fd, laddr, len) == -1)
857 #endif /* USE_PROCFS */
863 * like `umove' but make the additional effort of looking
864 * for a terminating zero byte.
867 umovestr(struct tcb *tcp, long addr, int len, char *laddr)
870 #ifdef HAVE_MP_PROCFS
871 int fd = tcp->pfd_as;
875 /* Some systems (e.g. FreeBSD) can be upset if we read off the
876 end of valid memory, avoid this by trying to read up
877 to page boundaries. But we don't know what a page is (and
878 getpagesize(2) (if it exists) doesn't necessarily return
879 hardware page size). Assume all pages >= 1024 (a-historical
882 int page = 1024; /* How to find this? */
883 int move = page - (addr & (page - 1));
886 lseek(fd, addr, SEEK_SET);
891 move = read(fd, laddr, move);
893 return left != len ? 0 : -1;
894 if (memchr(laddr, 0, move))
901 #else /* !USE_PROCFS */
907 char x[sizeof(long)];
910 #if SUPPORTED_PERSONALITIES > 1
911 if (personality_wordsize[current_personality] < sizeof(addr))
912 addr &= (1ul << 8 * personality_wordsize[current_personality]) - 1;
915 if (addr & (sizeof(long) - 1)) {
916 /* addr not a multiple of sizeof(long) */
917 n = addr - (addr & -sizeof(long)); /* residue */
918 addr &= -sizeof(long); /* residue */
920 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
922 if (addr != 0 && errno != EIO && errno != ESRCH)
927 memcpy(laddr, &u.x[n], m = MIN(sizeof(long)-n, len));
928 while (n & (sizeof(long) - 1))
929 if (u.x[n++] == '\0')
931 addr += sizeof(long), laddr += m, len -= m;
935 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
937 if (started && (errno==EPERM || errno==EIO)) {
938 /* Ran into 'end of memory' - stupid "printpath" */
941 if (addr != 0 && errno != EIO && errno != ESRCH)
946 memcpy(laddr, u.x, m = MIN(sizeof(long), len));
947 for (i = 0; i < sizeof(long); i++)
951 addr += sizeof(long), laddr += m, len -= m;
953 #endif /* !USE_PROCFS */
958 # if !defined (SPARC) && !defined(SPARC64)
959 # define PTRACE_WRITETEXT 101
960 # define PTRACE_WRITEDATA 102
961 # endif /* !SPARC && !SPARC64 */
967 uload(int cmd, int pid, long addr, int len, char *laddr)
973 char x[sizeof(long)];
976 if (cmd == PTRACE_WRITETEXT) {
977 peek = PTRACE_PEEKTEXT;
978 poke = PTRACE_POKETEXT;
981 peek = PTRACE_PEEKDATA;
982 poke = PTRACE_POKEDATA;
984 if (addr & (sizeof(long) - 1)) {
985 /* addr not a multiple of sizeof(long) */
986 n = addr - (addr & -sizeof(long)); /* residue */
987 addr &= -sizeof(long);
989 u.val = ptrace(peek, pid, (char *) addr, 0);
991 perror("uload: POKE");
994 memcpy(&u.x[n], laddr, m = MIN(sizeof(long) - n, len));
995 if (ptrace(poke, pid, (char *)addr, u.val) < 0) {
996 perror("uload: POKE");
999 addr += sizeof(long), laddr += m, len -= m;
1002 if (len < sizeof(long))
1003 u.val = ptrace(peek, pid, (char *) addr, 0);
1004 memcpy(u.x, laddr, m = MIN(sizeof(long), len));
1005 if (ptrace(poke, pid, (char *) addr, u.val) < 0) {
1006 perror("uload: POKE");
1009 addr += sizeof(long), laddr += m, len -= m;
1015 tload(int pid, int addr, int len, char *laddr)
1017 return uload(PTRACE_WRITETEXT, pid, addr, len, laddr);
1021 dload(int pid, int addr, int len, char *laddr)
1023 return uload(PTRACE_WRITEDATA, pid, addr, len, laddr);
1031 upeek(struct tcb *tcp, long off, long *res)
1035 # ifdef SUNOS4_KERNEL_ARCH_KLUDGE
1037 static int is_sun4m = -1;
1038 struct utsname name;
1040 /* Round up the usual suspects. */
1041 if (is_sun4m == -1) {
1042 if (uname(&name) < 0) {
1043 perror("upeek: uname?");
1046 is_sun4m = strcmp(name.machine, "sun4m") == 0;
1048 const struct xlat *x;
1050 for (x = struct_user_offsets; x->str; x++)
1057 # endif /* SUNOS4_KERNEL_ARCH_KLUDGE */
1059 val = do_ptrace(PTRACE_PEEKUSER, tcp, (char *) off, 0);
1060 if (val == -1 && errno) {
1061 if (errno != ESRCH) {
1063 sprintf(buf, "upeek: ptrace(PTRACE_PEEKUSER,%d,%lu,0)", tcp->pid, off);
1072 #endif /* !USE_PROCFS */
1075 printcall(struct tcb *tcp)
1077 #define PRINTBADPC tprintf(sizeof(long) == 4 ? "[????????] " : \
1078 sizeof(long) == 8 ? "[????????????????] " : \
1085 if (upeek(tcp, 4*EIP, &eip) < 0) {
1089 tprintf("[%08lx] ", eip);
1091 # elif defined(S390) || defined(S390X)
1093 if (upeek(tcp, PT_PSWADDR, &psw) < 0) {
1098 tprintf("[%08lx] ", psw);
1100 tprintf("[%16lx] ", psw);
1103 # elif defined(X86_64)
1106 if (upeek(tcp, 8*RIP, &rip) < 0) {
1110 tprintf("[%16lx] ", rip);
1111 # elif defined(IA64)
1114 if (upeek(tcp, PT_B0, &ip) < 0) {
1118 tprintf("[%08lx] ", ip);
1119 # elif defined(POWERPC)
1122 if (upeek(tcp, sizeof(unsigned long)*PT_NIP, &pc) < 0) {
1127 tprintf("[%016lx] ", pc);
1129 tprintf("[%08lx] ", pc);
1131 # elif defined(M68K)
1134 if (upeek(tcp, 4*PT_PC, &pc) < 0) {
1135 tprints("[????????] ");
1138 tprintf("[%08lx] ", pc);
1139 # elif defined(ALPHA)
1142 if (upeek(tcp, REG_PC, &pc) < 0) {
1143 tprints("[????????????????] ");
1146 tprintf("[%08lx] ", pc);
1147 # elif defined(SPARC) || defined(SPARC64)
1148 struct pt_regs regs;
1149 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) {
1153 # if defined(SPARC64)
1154 tprintf("[%08lx] ", regs.tpc);
1156 tprintf("[%08lx] ", regs.pc);
1158 # elif defined(HPPA)
1161 if (upeek(tcp, PT_IAOQ0, &pc) < 0) {
1162 tprints("[????????] ");
1165 tprintf("[%08lx] ", pc);
1166 # elif defined(MIPS)
1169 if (upeek(tcp, REG_EPC, &pc) < 0) {
1170 tprints("[????????] ");
1173 tprintf("[%08lx] ", pc);
1177 if (upeek(tcp, 4*REG_PC, &pc) < 0) {
1178 tprints("[????????] ");
1181 tprintf("[%08lx] ", pc);
1182 # elif defined(SH64)
1185 if (upeek(tcp, REG_PC, &pc) < 0) {
1186 tprints("[????????????????] ");
1189 tprintf("[%08lx] ", pc);
1193 if (upeek(tcp, 4*15, &pc) < 0) {
1197 tprintf("[%08lx] ", pc);
1198 # elif defined(AVR32)
1201 if (upeek(tcp, REG_PC, &pc) < 0) {
1202 tprints("[????????] ");
1205 tprintf("[%08lx] ", pc);
1206 # elif defined(BFIN)
1209 if (upeek(tcp, PT_PC, &pc) < 0) {
1213 tprintf("[%08lx] ", pc);
1214 #elif defined(CRISV10)
1217 if (upeek(tcp, 4*PT_IRP, &pc) < 0) {
1221 tprintf("[%08lx] ", pc);
1222 #elif defined(CRISV32)
1225 if (upeek(tcp, 4*PT_ERP, &pc) < 0) {
1229 tprintf("[%08lx] ", pc);
1230 # endif /* architecture */
1236 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *) ®s, 0) < 0) {
1237 perror("printcall: ptrace(PTRACE_GETREGS, ...)");
1241 tprintf("[%08x] ", regs.r_o7);
1251 pread(tcp->pfd_reg, ®s, sizeof(regs), 0);
1252 tprintf("[%08x] ", regs.r_eip);
1253 #endif /* FREEBSD */
1258 * These #if's are huge, please indent them correctly.
1259 * It's easy to get confused otherwise.
1265 # include "syscall.h"
1267 # include <sys/syscall.h>
1268 # ifndef CLONE_PTRACE
1269 # define CLONE_PTRACE 0x00002000
1271 # ifndef CLONE_VFORK
1272 # define CLONE_VFORK 0x00004000
1275 # define CLONE_VM 0x00000100
1277 # ifndef CLONE_STOPPED
1278 # define CLONE_STOPPED 0x02000000
1283 /* We don't have fork()/vfork() syscalls on ia64 itself, but the ia32
1284 subsystem has them for x86... */
1286 # define SYS_vfork 190
1288 typedef unsigned long *arg_setup_state;
1291 arg_setup(struct tcb *tcp, arg_setup_state *state)
1293 unsigned long cfm, sof, sol;
1297 /* Satisfy a false GCC warning. */
1302 if (upeek(tcp, PT_AR_BSP, &bsp) < 0)
1304 if (upeek(tcp, PT_CFM, (long *) &cfm) < 0)
1307 sof = (cfm >> 0) & 0x7f;
1308 sol = (cfm >> 7) & 0x7f;
1309 bsp = (long) ia64_rse_skip_regs((unsigned long *) bsp, -sof + sol);
1311 *state = (unsigned long *) bsp;
1315 # define arg_finish_change(tcp, state) 0
1319 get_arg0(struct tcb *tcp, arg_setup_state *state, long *valp)
1324 ret = upeek(tcp, PT_R11, valp);
1327 (unsigned long) ia64_rse_skip_regs(*state, 0),
1328 sizeof(long), (void *) valp);
1333 get_arg1(struct tcb *tcp, arg_setup_state *state, long *valp)
1338 ret = upeek(tcp, PT_R9, valp);
1341 (unsigned long) ia64_rse_skip_regs(*state, 1),
1342 sizeof(long), (void *) valp);
1348 set_arg0(struct tcb *tcp, arg_setup_state *state, long val)
1350 int req = PTRACE_POKEDATA;
1354 ap = (void *) (intptr_t) PT_R11; /* r11 == EBX */
1355 req = PTRACE_POKEUSER;
1357 ap = ia64_rse_skip_regs(*state, 0);
1359 ptrace(req, tcp->pid, ap, val);
1360 return errno ? -1 : 0;
1364 set_arg1(struct tcb *tcp, arg_setup_state *state, long val)
1366 int req = PTRACE_POKEDATA;
1370 ap = (void *) (intptr_t) PT_R9; /* r9 == ECX */
1371 req = PTRACE_POKEUSER;
1373 ap = ia64_rse_skip_regs(*state, 1);
1375 ptrace(req, tcp->pid, ap, val);
1376 return errno ? -1 : 0;
1379 /* ia64 does not return the input arguments from functions (and syscalls)
1380 according to ia64 RSE (Register Stack Engine) behavior. */
1382 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1383 # define restore_arg1(tcp, state, val) ((void) (state), 0)
1385 # elif defined (SPARC) || defined (SPARC64)
1387 typedef struct pt_regs arg_setup_state;
1389 # define arg_setup(tcp, state) \
1390 (ptrace(PTRACE_GETREGS, tcp->pid, (char *) (state), 0))
1391 # define arg_finish_change(tcp, state) \
1392 (ptrace(PTRACE_SETREGS, tcp->pid, (char *) (state), 0))
1394 # define get_arg0(tcp, state, valp) (*(valp) = (state)->u_regs[U_REG_O0], 0)
1395 # define get_arg1(tcp, state, valp) (*(valp) = (state)->u_regs[U_REG_O1], 0)
1396 # define set_arg0(tcp, state, val) ((state)->u_regs[U_REG_O0] = (val), 0)
1397 # define set_arg1(tcp, state, val) ((state)->u_regs[U_REG_O1] = (val), 0)
1398 # define restore_arg0(tcp, state, val) 0
1400 # else /* other architectures */
1402 # if defined S390 || defined S390X
1403 /* Note: this is only true for the `clone' system call, which handles
1404 arguments specially. We could as well say that its first two arguments
1405 are swapped relative to other architectures, but that would just be
1406 another #ifdef in the calls. */
1407 # define arg0_offset PT_GPR3
1408 # define arg1_offset PT_ORIGGPR2
1409 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1410 # define restore_arg1(tcp, state, val) ((void) (state), 0)
1411 # define arg0_index 1
1412 # define arg1_index 0
1413 # elif defined (ALPHA) || defined (MIPS)
1414 # define arg0_offset REG_A0
1415 # define arg1_offset (REG_A0+1)
1416 # elif defined (AVR32)
1417 # define arg0_offset (REG_R12)
1418 # define arg1_offset (REG_R11)
1419 # elif defined (POWERPC)
1420 # define arg0_offset (sizeof(unsigned long)*PT_R3)
1421 # define arg1_offset (sizeof(unsigned long)*PT_R4)
1422 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1423 # elif defined (HPPA)
1424 # define arg0_offset PT_GR26
1425 # define arg1_offset (PT_GR26-4)
1426 # elif defined (X86_64)
1427 # define arg0_offset ((long)(8*(current_personality ? RBX : RDI)))
1428 # define arg1_offset ((long)(8*(current_personality ? RCX : RSI)))
1430 # define arg0_offset (4*(REG_REG0+4))
1431 # define arg1_offset (4*(REG_REG0+5))
1432 # elif defined (SH64)
1433 /* ABI defines arg0 & 1 in r2 & r3 */
1434 # define arg0_offset (REG_OFFSET+16)
1435 # define arg1_offset (REG_OFFSET+24)
1436 # define restore_arg0(tcp, state, val) 0
1437 # elif defined CRISV10 || defined CRISV32
1438 # define arg0_offset (4*PT_R11)
1439 # define arg1_offset (4*PT_ORIG_R10)
1440 # define restore_arg0(tcp, state, val) 0
1441 # define restore_arg1(tcp, state, val) 0
1442 # define arg0_index 1
1443 # define arg1_index 0
1445 # define arg0_offset 0
1446 # define arg1_offset 4
1448 # define restore_arg0(tcp, state, val) 0
1452 typedef int arg_setup_state;
1454 # define arg_setup(tcp, state) (0)
1455 # define arg_finish_change(tcp, state) 0
1456 # define get_arg0(tcp, cookie, valp) \
1457 (upeek((tcp), arg0_offset, (valp)))
1458 # define get_arg1(tcp, cookie, valp) \
1459 (upeek((tcp), arg1_offset, (valp)))
1462 set_arg0(struct tcb *tcp, void *cookie, long val)
1464 return ptrace(PTRACE_POKEUSER, tcp->pid, (char*)arg0_offset, val);
1468 set_arg1(struct tcb *tcp, void *cookie, long val)
1470 return ptrace(PTRACE_POKEUSER, tcp->pid, (char*)arg1_offset, val);
1473 # endif /* architectures */
1475 # ifndef restore_arg0
1476 # define restore_arg0(tcp, state, val) set_arg0((tcp), (state), (val))
1478 # ifndef restore_arg1
1479 # define restore_arg1(tcp, state, val) set_arg1((tcp), (state), (val))
1483 # define arg0_index 0
1484 # define arg1_index 1
1488 setbpt(struct tcb *tcp)
1490 static int clone_scno[SUPPORTED_PERSONALITIES] = { SYS_clone };
1491 arg_setup_state state;
1493 if (tcp->flags & TCB_BPTSET) {
1494 fprintf(stderr, "PANIC: TCB already set in pid %u\n", tcp->pid);
1499 * It's a silly kludge to initialize this with a search at runtime.
1500 * But it's better than maintaining another magic thing in the
1501 * godforsaken tables.
1503 if (clone_scno[current_personality] == 0) {
1505 for (i = 0; i < nsyscalls; ++i)
1506 if (sysent[i].sys_func == sys_clone) {
1507 clone_scno[current_personality] = i;
1512 switch (known_scno(tcp)) {
1519 # if defined SYS_fork || defined SYS_vfork
1520 if (arg_setup(tcp, &state) < 0
1521 || get_arg0(tcp, &state, &tcp->inst[0]) < 0
1522 || get_arg1(tcp, &state, &tcp->inst[1]) < 0
1523 || change_syscall(tcp, clone_scno[current_personality]) < 0
1524 || set_arg0(tcp, &state, CLONE_PTRACE|SIGCHLD) < 0
1525 || set_arg1(tcp, &state, 0) < 0
1526 || arg_finish_change(tcp, &state) < 0)
1528 tcp->u_arg[arg0_index] = CLONE_PTRACE|SIGCHLD;
1529 tcp->u_arg[arg1_index] = 0;
1530 tcp->flags |= TCB_BPTSET;
1538 /* ia64 calls directly `clone (CLONE_VFORK | CLONE_VM)'
1539 contrary to x86 SYS_vfork above. Even on x86 we turn the
1540 vfork semantics into plain fork - each application must not
1541 depend on the vfork specifics according to POSIX. We would
1542 hang waiting for the parent resume otherwise. We need to
1543 clear also CLONE_VM but only in the CLONE_VFORK case as
1544 otherwise we would break pthread_create. */
1546 long new_arg0 = (tcp->u_arg[arg0_index] | CLONE_PTRACE);
1547 if (new_arg0 & CLONE_VFORK)
1548 new_arg0 &= ~(unsigned long)(CLONE_VFORK | CLONE_VM);
1549 if (arg_setup(tcp, &state) < 0
1550 || set_arg0(tcp, &state, new_arg0) < 0
1551 || arg_finish_change(tcp, &state) < 0)
1553 tcp->flags |= TCB_BPTSET;
1554 tcp->inst[0] = tcp->u_arg[arg0_index];
1555 tcp->inst[1] = tcp->u_arg[arg1_index];
1559 fprintf(stderr, "PANIC: setbpt for syscall %ld on %u???\n",
1560 tcp->scno, tcp->pid);
1568 clearbpt(struct tcb *tcp)
1570 arg_setup_state state;
1571 if (arg_setup(tcp, &state) < 0
1572 || restore_arg0(tcp, &state, tcp->inst[0]) < 0
1573 || restore_arg1(tcp, &state, tcp->inst[1]) < 0
1574 || arg_finish_change(tcp, &state))
1577 tcp->flags &= ~TCB_BPTSET;
1581 # else /* !defined LINUX */
1584 setbpt(struct tcb *tcp)
1587 # ifdef SPARC /* This code is slightly sparc specific */
1590 # define BPT 0x91d02001 /* ta 1 */
1591 # define LOOP 0x10800000 /* ba 0 */
1592 # define LOOPA 0x30800000 /* ba,a 0 */
1593 # define NOP 0x01000000
1595 static int loopdeloop[1] = {LOOPA};
1597 static int loopdeloop[2] = {LOOP, NOP};
1600 if (tcp->flags & TCB_BPTSET) {
1601 fprintf(stderr, "PANIC: TCB already set in pid %u\n", tcp->pid);
1604 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) {
1605 perror("setbpt: ptrace(PTRACE_GETREGS, ...)");
1608 tcp->baddr = regs.r_o7 + 8;
1609 if (ptrace(PTRACE_READTEXT, tcp->pid, (char *)tcp->baddr,
1610 sizeof tcp->inst, (char *)tcp->inst) < 0) {
1611 perror("setbpt: ptrace(PTRACE_READTEXT, ...)");
1616 * XXX - BRUTAL MODE ON
1617 * We cannot set a real BPT in the child, since it will not be
1618 * traced at the moment it will reach the trap and would probably
1619 * die with a core dump.
1620 * Thus, we are force our way in by taking out two instructions
1621 * and insert an eternal loop in stead, in expectance of the SIGSTOP
1622 * generated by out PTRACE_ATTACH.
1623 * Of cause, if we evaporate ourselves in the middle of all this...
1625 if (ptrace(PTRACE_WRITETEXT, tcp->pid, (char *) tcp->baddr,
1626 sizeof loopdeloop, (char *) loopdeloop) < 0) {
1627 perror("setbpt: ptrace(PTRACE_WRITETEXT, ...)");
1630 tcp->flags |= TCB_BPTSET;
1633 # endif /* SUNOS4 */
1639 clearbpt(struct tcb *tcp)
1648 if (!(tcp->flags & TCB_BPTSET)) {
1649 fprintf(stderr, "PANIC: TCB not set in pid %u\n", tcp->pid);
1652 if (ptrace(PTRACE_WRITETEXT, tcp->pid, (char *) tcp->baddr,
1653 sizeof tcp->inst, (char *) tcp->inst) < 0) {
1654 perror("clearbtp: ptrace(PTRACE_WRITETEXT, ...)");
1657 tcp->flags &= ~TCB_BPTSET;
1661 * Since we don't have a single instruction breakpoint, we may have
1662 * to adjust the program counter after removing our `breakpoint'.
1664 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) {
1665 perror("clearbpt: ptrace(PTRACE_GETREGS, ...)");
1668 if ((regs.r_pc < tcp->baddr) ||
1669 (regs.r_pc > tcp->baddr + 4)) {
1670 /* The breakpoint has not been reached yet */
1673 "NOTE: PC not at bpt (pc %#x baddr %#x)\n",
1674 regs.r_pc, tcp->baddr);
1677 if (regs.r_pc != tcp->baddr)
1679 fprintf(stderr, "NOTE: PC adjusted (%#x -> %#x\n",
1680 regs.r_pc, tcp->baddr);
1682 regs.r_pc = tcp->baddr;
1683 if (ptrace(PTRACE_SETREGS, tcp->pid, (char *)®s, 0) < 0) {
1684 perror("clearbpt: ptrace(PTRACE_SETREGS, ...)");
1689 # endif /* SUNOS4 */
1694 # endif /* !defined LINUX */
1696 #endif /* !USE_PROCFS */
1702 getex(struct tcb *tcp, struct exec *hdr)
1706 for (n = 0; n < sizeof *hdr; n += 4) {
1708 if (upeek(tcp, uoff(u_exdata) + n, &res) < 0)
1710 memcpy(((char *) hdr) + n, &res, 4);
1713 fprintf(stderr, "[struct exec: magic: %o version %u Mach %o\n",
1714 hdr->a_magic, hdr->a_toolversion, hdr->a_machtype);
1715 fprintf(stderr, "Text %lu Data %lu Bss %lu Syms %lu Entry %#lx]\n",
1716 hdr->a_text, hdr->a_data, hdr->a_bss, hdr->a_syms, hdr->a_entry);
1722 fixvfork(struct tcb *tcp)
1726 * Change `vfork' in a freshly exec'ed dynamically linked
1727 * executable's (internal) symbol table to plain old `fork'
1731 struct link_dynamic dyn;
1732 struct link_dynamic_2 ld;
1735 if (getex(tcp, &hdr) < 0)
1740 if (umove(tcp, (int) N_DATADDR(hdr), &dyn) < 0) {
1741 fprintf(stderr, "Cannot read DYNAMIC\n");
1744 if (umove(tcp, (int) dyn.ld_un.ld_2, &ld) < 0) {
1745 fprintf(stderr, "Cannot read link_dynamic_2\n");
1748 strtab = malloc((unsigned)ld.ld_symb_size);
1750 die_out_of_memory();
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)