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);
431 * Quote string `instr' of length `size'
432 * Write up to (3 + `size' * 4) bytes to `outstr' buffer.
433 * If `len' < 0, treat `instr' as a NUL-terminated string
434 * and quote at most (`size' - 1) bytes.
436 * Returns 0 if len < 0 and NUL was seen, 1 otherwise.
437 * Note that if len >= 0, always returns 1.
440 string_quote(const char *instr, char *outstr, int len, int size)
442 const unsigned char *ustr = (const unsigned char *) instr;
444 int usehex, c, i, eol;
446 eol = 0x100; /* this can never match a char */
456 /* Check for presence of symbol which require
457 to hex-quote the whole string. */
458 for (i = 0; i < size; ++i) {
460 /* Check for NUL-terminated string. */
463 if (!isprint(c) && !isspace(c)) {
473 /* Hex-quote the whole string. */
474 for (i = 0; i < size; ++i) {
476 /* Check for NUL-terminated string. */
481 *s++ = "0123456789abcdef"[c >> 4];
482 *s++ = "0123456789abcdef"[c & 0xf];
485 for (i = 0; i < size; ++i) {
487 /* Check for NUL-terminated string. */
491 case '\"': case '\\':
522 && ustr[i + 1] >= '0'
523 && ustr[i + 1] <= '9'
526 *s++ = '0' + (c >> 6);
527 *s++ = '0' + ((c >> 3) & 0x7);
532 *s++ = '0' + (c >> 6);
533 *s++ = '0' + ((c >> 3) & 0x7);
536 *s++ = '0' + (c & 0x7);
546 /* Return zero if we printed entire ASCIZ string (didn't truncate it) */
547 if (len < 0 && ustr[i] == '\0') {
548 /* We didn't see NUL yet (otherwise we'd jump to 'asciz_ended')
549 * but next char is NUL.
559 /* Return zero: we printed entire ASCIZ string (didn't truncate it) */
564 * Print path string specified by address `addr' and length `n'.
565 * If path length exceeds `n', append `...' to the output.
568 printpathn(struct tcb *tcp, long addr, int n)
570 char path[MAXPATHLEN + 1];
578 /* Cap path length to the path buffer size */
579 if (n > sizeof path - 1)
582 /* Fetch one byte more to find out whether path length > n. */
583 nul_seen = umovestr(tcp, addr, n + 1, path);
585 tprintf("%#lx", addr);
591 outstr = alloca(4 * n); /* 4*(n-1) + 3 for quotes and NUL */
592 string_quote(path, outstr, -1, n);
600 printpath(struct tcb *tcp, long addr)
602 /* Size must correspond to char path[] size in printpathn */
603 printpathn(tcp, addr, MAXPATHLEN);
607 * Print string specified by address `addr' and length `len'.
608 * If `len' < 0, treat the string as a NUL-terminated string.
609 * If string length exceeds `max_strlen', append `...' to the output.
612 printstr(struct tcb *tcp, long addr, int len)
614 static char *str = NULL;
623 /* Allocate static buffers if they are not allocated yet. */
625 str = malloc(max_strlen + 1);
628 outstr = malloc(4 * max_strlen + /*for quotes and NUL:*/ 3);
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 if (umovestr(tcp, addr, size, str) < 0) {
640 tprintf("%#lx", addr);
645 size = MIN(len, max_strlen);
646 if (umoven(tcp, addr, size, str) < 0) {
647 tprintf("%#lx", addr);
652 /* If string_quote didn't see NUL and (it was supposed to be ASCIZ str
653 * or we were requested to print more than -s NUM chars)...
655 ellipsis = (string_quote(str, outstr, len, size) &&
656 (len < 0 || len > max_strlen));
665 dumpiov(struct tcb *tcp, int len, long addr)
667 #if defined(LINUX) && SUPPORTED_PERSONALITIES > 1
669 struct { u_int32_t base; u_int32_t len; } *iov32;
670 struct { u_int64_t base; u_int64_t len; } *iov64;
672 #define iov iovu.iov64
674 (personality_wordsize[current_personality] == 4 \
675 ? sizeof(*iovu.iov32) : sizeof(*iovu.iov64))
676 #define iov_iov_base(i) \
677 (personality_wordsize[current_personality] == 4 \
678 ? (u_int64_t) iovu.iov32[i].base : iovu.iov64[i].base)
679 #define iov_iov_len(i) \
680 (personality_wordsize[current_personality] == 4 \
681 ? (u_int64_t) iovu.iov32[i].len : iovu.iov64[i].len)
684 #define sizeof_iov sizeof(*iov)
685 #define iov_iov_base(i) iov[i].iov_base
686 #define iov_iov_len(i) iov[i].iov_len
691 size = sizeof_iov * len;
692 /* Assuming no sane program has millions of iovs */
693 if ((unsigned)len > 1024*1024 /* insane or negative size? */
694 || (iov = malloc(size)) == NULL) {
695 fprintf(stderr, "Out of memory\n");
698 if (umoven(tcp, addr, size, (char *) iov) >= 0) {
699 for (i = 0; i < len; i++) {
700 /* include the buffer number to make it easy to
701 * match up the trace with the source */
702 tprintf(" * %lu bytes in buffer %d\n",
703 (unsigned long)iov_iov_len(i), i);
704 dumpstr(tcp, (long) iov_iov_base(i),
717 dumpstr(struct tcb *tcp, long addr, int len)
719 static int strsize = -1;
720 static unsigned char *str;
729 fprintf(stderr, "Out of memory\n");
735 if (umoven(tcp, addr, len, (char *) str) < 0)
738 for (i = 0; i < len; i += 16) {
742 sprintf(s, " | %05x ", i);
744 for (j = 0; j < 16; j++) {
748 sprintf(s, " %02x", str[i + j]);
752 *s++ = ' '; *s++ = ' '; *s++ = ' ';
755 *s++ = ' '; *s++ = ' ';
756 for (j = 0; j < 16; j++) {
760 if (isprint(str[i + j]))
768 tprintf("%s |\n", outstr);
772 #define PAGMASK (~(PAGSIZ - 1))
774 * move `len' bytes of data from process `pid'
775 * at address `addr' to our space at `laddr'
778 umoven(struct tcb *tcp, long addr, int len, char *laddr)
786 char x[sizeof(long)];
789 #if SUPPORTED_PERSONALITIES > 1
790 if (personality_wordsize[current_personality] < sizeof(addr))
791 addr &= (1ul << 8 * personality_wordsize[current_personality]) - 1;
795 if (addr & (sizeof(long) - 1)) {
796 /* addr not a multiple of sizeof(long) */
797 n = addr - (addr & -sizeof(long)); /* residue */
798 addr &= -sizeof(long); /* residue */
800 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
802 /* But if not started, we had a bogus address. */
803 if (addr != 0 && errno != EIO && errno != ESRCH)
804 perror("ptrace: umoven");
808 m = MIN(sizeof(long) - n, len);
809 memcpy(laddr, &u.x[n], m);
810 addr += sizeof(long), laddr += m, len -= m;
814 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
816 if (started && (errno==EPERM || errno==EIO)) {
817 /* Ran into 'end of memory' - stupid "printpath" */
820 if (addr != 0 && errno != EIO && errno != ESRCH)
821 perror("ptrace: umoven");
825 m = MIN(sizeof(long), len);
826 memcpy(laddr, u.x, m);
827 addr += sizeof(long), laddr += m, len -= m;
836 n = MIN(len, PAGSIZ);
837 n = MIN(n, ((addr + PAGSIZ) & PAGMASK) - addr);
838 if (ptrace(PTRACE_READDATA, pid,
839 (char *) addr, len, laddr) < 0) {
840 if (errno != ESRCH) {
841 perror("umoven: ptrace(PTRACE_READDATA, ...)");
853 #ifdef HAVE_MP_PROCFS
854 int fd = tcp->pfd_as;
858 lseek(fd, addr, SEEK_SET);
859 if (read(fd, laddr, len) == -1)
861 #endif /* USE_PROCFS */
867 * Like `umove' but make the additional effort of looking
868 * for a terminating zero byte.
870 * Returns < 0 on error, > 0 if NUL was seen,
871 * (TODO if useful: return count of bytes including NUL),
872 * else 0 if len bytes were read but no NUL byte seen.
874 * Note: there is no guarantee we won't overwrite some bytes
875 * in laddr[] _after_ terminating NUL (but, of course,
876 * we never write past laddr[len-1]).
879 umovestr(struct tcb *tcp, long addr, int len, char *laddr)
882 # ifdef HAVE_MP_PROCFS
883 int fd = tcp->pfd_as;
887 /* Some systems (e.g. FreeBSD) can be upset if we read off the
888 end of valid memory, avoid this by trying to read up
889 to page boundaries. But we don't know what a page is (and
890 getpagesize(2) (if it exists) doesn't necessarily return
891 hardware page size). Assume all pages >= 1024 (a-historical
894 int page = 1024; /* How to find this? */
895 int move = page - (addr & (page - 1));
898 lseek(fd, addr, SEEK_SET);
903 move = read(fd, laddr, move);
905 return left != len ? 0 : -1;
906 if (memchr(laddr, 0, move))
914 #else /* !USE_PROCFS */
920 char x[sizeof(long)];
923 #if SUPPORTED_PERSONALITIES > 1
924 if (personality_wordsize[current_personality] < sizeof(addr))
925 addr &= (1ul << 8 * personality_wordsize[current_personality]) - 1;
929 if (addr & (sizeof(long) - 1)) {
930 /* addr not a multiple of sizeof(long) */
931 n = addr - (addr & -sizeof(long)); /* residue */
932 addr &= -sizeof(long); /* residue */
934 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
936 if (addr != 0 && errno != EIO && errno != ESRCH)
941 m = MIN(sizeof(long) - n, len);
942 memcpy(laddr, &u.x[n], m);
943 while (n & (sizeof(long) - 1))
944 if (u.x[n++] == '\0')
946 addr += sizeof(long), laddr += m, len -= m;
950 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
952 if (started && (errno==EPERM || errno==EIO)) {
953 /* Ran into 'end of memory' - stupid "printpath" */
956 if (addr != 0 && errno != EIO && errno != ESRCH)
961 m = MIN(sizeof(long), len);
962 memcpy(laddr, u.x, m);
963 for (i = 0; i < sizeof(long); i++)
966 addr += sizeof(long), laddr += m, len -= m;
968 #endif /* !USE_PROCFS */
973 # if !defined (SPARC) && !defined(SPARC64)
974 # define PTRACE_WRITETEXT 101
975 # define PTRACE_WRITEDATA 102
976 # endif /* !SPARC && !SPARC64 */
982 uload(int cmd, int pid, long addr, int len, char *laddr)
988 char x[sizeof(long)];
991 if (cmd == PTRACE_WRITETEXT) {
992 peek = PTRACE_PEEKTEXT;
993 poke = PTRACE_POKETEXT;
996 peek = PTRACE_PEEKDATA;
997 poke = PTRACE_POKEDATA;
999 if (addr & (sizeof(long) - 1)) {
1000 /* addr not a multiple of sizeof(long) */
1001 n = addr - (addr & -sizeof(long)); /* residue */
1002 addr &= -sizeof(long);
1004 u.val = ptrace(peek, pid, (char *) addr, 0);
1006 perror("uload: POKE");
1009 m = MIN(sizeof(long) - n, len);
1010 memcpy(&u.x[n], laddr, m);
1011 if (ptrace(poke, pid, (char *)addr, u.val) < 0) {
1012 perror("uload: POKE");
1015 addr += sizeof(long), laddr += m, len -= m;
1018 if (len < sizeof(long))
1019 u.val = ptrace(peek, pid, (char *) addr, 0);
1020 m = MIN(sizeof(long), len);
1021 memcpy(u.x, laddr, m);
1022 if (ptrace(poke, pid, (char *) addr, u.val) < 0) {
1023 perror("uload: POKE");
1026 addr += sizeof(long), laddr += m, len -= m;
1032 tload(int pid, int addr, int len, char *laddr)
1034 return uload(PTRACE_WRITETEXT, pid, addr, len, laddr);
1038 dload(int pid, int addr, int len, char *laddr)
1040 return uload(PTRACE_WRITEDATA, pid, addr, len, laddr);
1048 upeek(struct tcb *tcp, long off, long *res)
1052 # ifdef SUNOS4_KERNEL_ARCH_KLUDGE
1054 static int is_sun4m = -1;
1055 struct utsname name;
1057 /* Round up the usual suspects. */
1058 if (is_sun4m == -1) {
1059 if (uname(&name) < 0) {
1060 perror("upeek: uname?");
1063 is_sun4m = strcmp(name.machine, "sun4m") == 0;
1065 const struct xlat *x;
1067 for (x = struct_user_offsets; x->str; x++)
1074 # endif /* SUNOS4_KERNEL_ARCH_KLUDGE */
1076 val = do_ptrace(PTRACE_PEEKUSER, tcp, (char *) off, 0);
1077 if (val == -1 && errno) {
1078 if (errno != ESRCH) {
1080 sprintf(buf, "upeek: ptrace(PTRACE_PEEKUSER,%d,%lu,0)", tcp->pid, off);
1089 #endif /* !USE_PROCFS */
1092 printcall(struct tcb *tcp)
1094 #define PRINTBADPC tprintf(sizeof(long) == 4 ? "[????????] " : \
1095 sizeof(long) == 8 ? "[????????????????] " : \
1102 if (upeek(tcp, 4*EIP, &eip) < 0) {
1106 tprintf("[%08lx] ", eip);
1108 # elif defined(S390) || defined(S390X)
1110 if (upeek(tcp, PT_PSWADDR, &psw) < 0) {
1115 tprintf("[%08lx] ", psw);
1117 tprintf("[%16lx] ", psw);
1120 # elif defined(X86_64)
1123 if (upeek(tcp, 8*RIP, &rip) < 0) {
1127 tprintf("[%16lx] ", rip);
1128 # elif defined(IA64)
1131 if (upeek(tcp, PT_B0, &ip) < 0) {
1135 tprintf("[%08lx] ", ip);
1136 # elif defined(POWERPC)
1139 if (upeek(tcp, sizeof(unsigned long)*PT_NIP, &pc) < 0) {
1144 tprintf("[%016lx] ", pc);
1146 tprintf("[%08lx] ", pc);
1148 # elif defined(M68K)
1151 if (upeek(tcp, 4*PT_PC, &pc) < 0) {
1152 tprints("[????????] ");
1155 tprintf("[%08lx] ", pc);
1156 # elif defined(ALPHA)
1159 if (upeek(tcp, REG_PC, &pc) < 0) {
1160 tprints("[????????????????] ");
1163 tprintf("[%08lx] ", pc);
1164 # elif defined(SPARC) || defined(SPARC64)
1165 struct pt_regs regs;
1166 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) {
1170 # if defined(SPARC64)
1171 tprintf("[%08lx] ", regs.tpc);
1173 tprintf("[%08lx] ", regs.pc);
1175 # elif defined(HPPA)
1178 if (upeek(tcp, PT_IAOQ0, &pc) < 0) {
1179 tprints("[????????] ");
1182 tprintf("[%08lx] ", pc);
1183 # elif defined(MIPS)
1186 if (upeek(tcp, REG_EPC, &pc) < 0) {
1187 tprints("[????????] ");
1190 tprintf("[%08lx] ", pc);
1194 if (upeek(tcp, 4*REG_PC, &pc) < 0) {
1195 tprints("[????????] ");
1198 tprintf("[%08lx] ", pc);
1199 # elif defined(SH64)
1202 if (upeek(tcp, REG_PC, &pc) < 0) {
1203 tprints("[????????????????] ");
1206 tprintf("[%08lx] ", pc);
1210 if (upeek(tcp, 4*15, &pc) < 0) {
1214 tprintf("[%08lx] ", pc);
1215 # elif defined(AVR32)
1218 if (upeek(tcp, REG_PC, &pc) < 0) {
1219 tprints("[????????] ");
1222 tprintf("[%08lx] ", pc);
1223 # elif defined(BFIN)
1226 if (upeek(tcp, PT_PC, &pc) < 0) {
1230 tprintf("[%08lx] ", pc);
1231 #elif defined(CRISV10)
1234 if (upeek(tcp, 4*PT_IRP, &pc) < 0) {
1238 tprintf("[%08lx] ", pc);
1239 #elif defined(CRISV32)
1242 if (upeek(tcp, 4*PT_ERP, &pc) < 0) {
1246 tprintf("[%08lx] ", pc);
1247 # endif /* architecture */
1253 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *) ®s, 0) < 0) {
1254 perror("printcall: ptrace(PTRACE_GETREGS, ...)");
1258 tprintf("[%08x] ", regs.r_o7);
1268 pread(tcp->pfd_reg, ®s, sizeof(regs), 0);
1269 tprintf("[%08x] ", regs.r_eip);
1270 #endif /* FREEBSD */
1275 * These #if's are huge, please indent them correctly.
1276 * It's easy to get confused otherwise.
1282 # include "syscall.h"
1284 # include <sys/syscall.h>
1285 # ifndef CLONE_PTRACE
1286 # define CLONE_PTRACE 0x00002000
1288 # ifndef CLONE_VFORK
1289 # define CLONE_VFORK 0x00004000
1292 # define CLONE_VM 0x00000100
1294 # ifndef CLONE_STOPPED
1295 # define CLONE_STOPPED 0x02000000
1300 /* We don't have fork()/vfork() syscalls on ia64 itself, but the ia32
1301 subsystem has them for x86... */
1303 # define SYS_vfork 190
1305 typedef unsigned long *arg_setup_state;
1308 arg_setup(struct tcb *tcp, arg_setup_state *state)
1310 unsigned long cfm, sof, sol;
1314 /* Satisfy a false GCC warning. */
1319 if (upeek(tcp, PT_AR_BSP, &bsp) < 0)
1321 if (upeek(tcp, PT_CFM, (long *) &cfm) < 0)
1324 sof = (cfm >> 0) & 0x7f;
1325 sol = (cfm >> 7) & 0x7f;
1326 bsp = (long) ia64_rse_skip_regs((unsigned long *) bsp, -sof + sol);
1328 *state = (unsigned long *) bsp;
1332 # define arg_finish_change(tcp, state) 0
1336 get_arg0(struct tcb *tcp, arg_setup_state *state, long *valp)
1341 ret = upeek(tcp, PT_R11, valp);
1344 (unsigned long) ia64_rse_skip_regs(*state, 0),
1345 sizeof(long), (void *) valp);
1350 get_arg1(struct tcb *tcp, arg_setup_state *state, long *valp)
1355 ret = upeek(tcp, PT_R9, valp);
1358 (unsigned long) ia64_rse_skip_regs(*state, 1),
1359 sizeof(long), (void *) valp);
1365 set_arg0(struct tcb *tcp, arg_setup_state *state, long val)
1367 int req = PTRACE_POKEDATA;
1371 ap = (void *) (intptr_t) PT_R11; /* r11 == EBX */
1372 req = PTRACE_POKEUSER;
1374 ap = ia64_rse_skip_regs(*state, 0);
1376 ptrace(req, tcp->pid, ap, val);
1377 return errno ? -1 : 0;
1381 set_arg1(struct tcb *tcp, arg_setup_state *state, long val)
1383 int req = PTRACE_POKEDATA;
1387 ap = (void *) (intptr_t) PT_R9; /* r9 == ECX */
1388 req = PTRACE_POKEUSER;
1390 ap = ia64_rse_skip_regs(*state, 1);
1392 ptrace(req, tcp->pid, ap, val);
1393 return errno ? -1 : 0;
1396 /* ia64 does not return the input arguments from functions (and syscalls)
1397 according to ia64 RSE (Register Stack Engine) behavior. */
1399 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1400 # define restore_arg1(tcp, state, val) ((void) (state), 0)
1402 # elif defined (SPARC) || defined (SPARC64)
1404 typedef struct pt_regs arg_setup_state;
1406 # define arg_setup(tcp, state) \
1407 (ptrace(PTRACE_GETREGS, tcp->pid, (char *) (state), 0))
1408 # define arg_finish_change(tcp, state) \
1409 (ptrace(PTRACE_SETREGS, tcp->pid, (char *) (state), 0))
1411 # define get_arg0(tcp, state, valp) (*(valp) = (state)->u_regs[U_REG_O0], 0)
1412 # define get_arg1(tcp, state, valp) (*(valp) = (state)->u_regs[U_REG_O1], 0)
1413 # define set_arg0(tcp, state, val) ((state)->u_regs[U_REG_O0] = (val), 0)
1414 # define set_arg1(tcp, state, val) ((state)->u_regs[U_REG_O1] = (val), 0)
1415 # define restore_arg0(tcp, state, val) 0
1417 # else /* other architectures */
1419 # if defined S390 || defined S390X
1420 /* Note: this is only true for the `clone' system call, which handles
1421 arguments specially. We could as well say that its first two arguments
1422 are swapped relative to other architectures, but that would just be
1423 another #ifdef in the calls. */
1424 # define arg0_offset PT_GPR3
1425 # define arg1_offset PT_ORIGGPR2
1426 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1427 # define restore_arg1(tcp, state, val) ((void) (state), 0)
1428 # define arg0_index 1
1429 # define arg1_index 0
1430 # elif defined (ALPHA) || defined (MIPS)
1431 # define arg0_offset REG_A0
1432 # define arg1_offset (REG_A0+1)
1433 # elif defined (AVR32)
1434 # define arg0_offset (REG_R12)
1435 # define arg1_offset (REG_R11)
1436 # elif defined (POWERPC)
1437 # define arg0_offset (sizeof(unsigned long)*PT_R3)
1438 # define arg1_offset (sizeof(unsigned long)*PT_R4)
1439 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1440 # elif defined (HPPA)
1441 # define arg0_offset PT_GR26
1442 # define arg1_offset (PT_GR26-4)
1443 # elif defined (X86_64)
1444 # define arg0_offset ((long)(8*(current_personality ? RBX : RDI)))
1445 # define arg1_offset ((long)(8*(current_personality ? RCX : RSI)))
1447 # define arg0_offset (4*(REG_REG0+4))
1448 # define arg1_offset (4*(REG_REG0+5))
1449 # elif defined (SH64)
1450 /* ABI defines arg0 & 1 in r2 & r3 */
1451 # define arg0_offset (REG_OFFSET+16)
1452 # define arg1_offset (REG_OFFSET+24)
1453 # define restore_arg0(tcp, state, val) 0
1454 # elif defined CRISV10 || defined CRISV32
1455 # define arg0_offset (4*PT_R11)
1456 # define arg1_offset (4*PT_ORIG_R10)
1457 # define restore_arg0(tcp, state, val) 0
1458 # define restore_arg1(tcp, state, val) 0
1459 # define arg0_index 1
1460 # define arg1_index 0
1462 # define arg0_offset 0
1463 # define arg1_offset 4
1465 # define restore_arg0(tcp, state, val) 0
1469 typedef int arg_setup_state;
1471 # define arg_setup(tcp, state) (0)
1472 # define arg_finish_change(tcp, state) 0
1473 # define get_arg0(tcp, cookie, valp) \
1474 (upeek((tcp), arg0_offset, (valp)))
1475 # define get_arg1(tcp, cookie, valp) \
1476 (upeek((tcp), arg1_offset, (valp)))
1479 set_arg0(struct tcb *tcp, void *cookie, long val)
1481 return ptrace(PTRACE_POKEUSER, tcp->pid, (char*)arg0_offset, val);
1485 set_arg1(struct tcb *tcp, void *cookie, long val)
1487 return ptrace(PTRACE_POKEUSER, tcp->pid, (char*)arg1_offset, val);
1490 # endif /* architectures */
1492 # ifndef restore_arg0
1493 # define restore_arg0(tcp, state, val) set_arg0((tcp), (state), (val))
1495 # ifndef restore_arg1
1496 # define restore_arg1(tcp, state, val) set_arg1((tcp), (state), (val))
1500 # define arg0_index 0
1501 # define arg1_index 1
1505 setbpt(struct tcb *tcp)
1507 static int clone_scno[SUPPORTED_PERSONALITIES] = { SYS_clone };
1508 arg_setup_state state;
1510 if (tcp->flags & TCB_BPTSET) {
1511 fprintf(stderr, "PANIC: TCB already set in pid %u\n", tcp->pid);
1516 * It's a silly kludge to initialize this with a search at runtime.
1517 * But it's better than maintaining another magic thing in the
1518 * godforsaken tables.
1520 if (clone_scno[current_personality] == 0) {
1522 for (i = 0; i < nsyscalls; ++i)
1523 if (sysent[i].sys_func == sys_clone) {
1524 clone_scno[current_personality] = i;
1529 switch (known_scno(tcp)) {
1536 # if defined SYS_fork || defined SYS_vfork
1537 if (arg_setup(tcp, &state) < 0
1538 || get_arg0(tcp, &state, &tcp->inst[0]) < 0
1539 || get_arg1(tcp, &state, &tcp->inst[1]) < 0
1540 || change_syscall(tcp, clone_scno[current_personality]) < 0
1541 || set_arg0(tcp, &state, CLONE_PTRACE|SIGCHLD) < 0
1542 || set_arg1(tcp, &state, 0) < 0
1543 || arg_finish_change(tcp, &state) < 0)
1545 tcp->u_arg[arg0_index] = CLONE_PTRACE|SIGCHLD;
1546 tcp->u_arg[arg1_index] = 0;
1547 tcp->flags |= TCB_BPTSET;
1555 /* ia64 calls directly `clone (CLONE_VFORK | CLONE_VM)'
1556 contrary to x86 SYS_vfork above. Even on x86 we turn the
1557 vfork semantics into plain fork - each application must not
1558 depend on the vfork specifics according to POSIX. We would
1559 hang waiting for the parent resume otherwise. We need to
1560 clear also CLONE_VM but only in the CLONE_VFORK case as
1561 otherwise we would break pthread_create. */
1563 long new_arg0 = (tcp->u_arg[arg0_index] | CLONE_PTRACE);
1564 if (new_arg0 & CLONE_VFORK)
1565 new_arg0 &= ~(unsigned long)(CLONE_VFORK | CLONE_VM);
1566 if (arg_setup(tcp, &state) < 0
1567 || set_arg0(tcp, &state, new_arg0) < 0
1568 || arg_finish_change(tcp, &state) < 0)
1570 tcp->flags |= TCB_BPTSET;
1571 tcp->inst[0] = tcp->u_arg[arg0_index];
1572 tcp->inst[1] = tcp->u_arg[arg1_index];
1576 fprintf(stderr, "PANIC: setbpt for syscall %ld on %u???\n",
1577 tcp->scno, tcp->pid);
1585 clearbpt(struct tcb *tcp)
1587 arg_setup_state state;
1588 if (arg_setup(tcp, &state) < 0
1589 || restore_arg0(tcp, &state, tcp->inst[0]) < 0
1590 || restore_arg1(tcp, &state, tcp->inst[1]) < 0
1591 || arg_finish_change(tcp, &state))
1594 tcp->flags &= ~TCB_BPTSET;
1598 # else /* !defined LINUX */
1601 setbpt(struct tcb *tcp)
1604 # ifdef SPARC /* This code is slightly sparc specific */
1607 # define BPT 0x91d02001 /* ta 1 */
1608 # define LOOP 0x10800000 /* ba 0 */
1609 # define LOOPA 0x30800000 /* ba,a 0 */
1610 # define NOP 0x01000000
1612 static int loopdeloop[1] = {LOOPA};
1614 static int loopdeloop[2] = {LOOP, NOP};
1617 if (tcp->flags & TCB_BPTSET) {
1618 fprintf(stderr, "PANIC: TCB already set in pid %u\n", tcp->pid);
1621 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) {
1622 perror("setbpt: ptrace(PTRACE_GETREGS, ...)");
1625 tcp->baddr = regs.r_o7 + 8;
1626 if (ptrace(PTRACE_READTEXT, tcp->pid, (char *)tcp->baddr,
1627 sizeof tcp->inst, (char *)tcp->inst) < 0) {
1628 perror("setbpt: ptrace(PTRACE_READTEXT, ...)");
1633 * XXX - BRUTAL MODE ON
1634 * We cannot set a real BPT in the child, since it will not be
1635 * traced at the moment it will reach the trap and would probably
1636 * die with a core dump.
1637 * Thus, we are force our way in by taking out two instructions
1638 * and insert an eternal loop in stead, in expectance of the SIGSTOP
1639 * generated by out PTRACE_ATTACH.
1640 * Of cause, if we evaporate ourselves in the middle of all this...
1642 if (ptrace(PTRACE_WRITETEXT, tcp->pid, (char *) tcp->baddr,
1643 sizeof loopdeloop, (char *) loopdeloop) < 0) {
1644 perror("setbpt: ptrace(PTRACE_WRITETEXT, ...)");
1647 tcp->flags |= TCB_BPTSET;
1650 # endif /* SUNOS4 */
1656 clearbpt(struct tcb *tcp)
1665 if (!(tcp->flags & TCB_BPTSET)) {
1666 fprintf(stderr, "PANIC: TCB not set in pid %u\n", tcp->pid);
1669 if (ptrace(PTRACE_WRITETEXT, tcp->pid, (char *) tcp->baddr,
1670 sizeof tcp->inst, (char *) tcp->inst) < 0) {
1671 perror("clearbtp: ptrace(PTRACE_WRITETEXT, ...)");
1674 tcp->flags &= ~TCB_BPTSET;
1678 * Since we don't have a single instruction breakpoint, we may have
1679 * to adjust the program counter after removing our `breakpoint'.
1681 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) {
1682 perror("clearbpt: ptrace(PTRACE_GETREGS, ...)");
1685 if ((regs.r_pc < tcp->baddr) ||
1686 (regs.r_pc > tcp->baddr + 4)) {
1687 /* The breakpoint has not been reached yet */
1690 "NOTE: PC not at bpt (pc %#x baddr %#x)\n",
1691 regs.r_pc, tcp->baddr);
1694 if (regs.r_pc != tcp->baddr)
1696 fprintf(stderr, "NOTE: PC adjusted (%#x -> %#x\n",
1697 regs.r_pc, tcp->baddr);
1699 regs.r_pc = tcp->baddr;
1700 if (ptrace(PTRACE_SETREGS, tcp->pid, (char *)®s, 0) < 0) {
1701 perror("clearbpt: ptrace(PTRACE_SETREGS, ...)");
1706 # endif /* SUNOS4 */
1711 # endif /* !defined LINUX */
1713 #endif /* !USE_PROCFS */
1719 getex(struct tcb *tcp, struct exec *hdr)
1723 for (n = 0; n < sizeof *hdr; n += 4) {
1725 if (upeek(tcp, uoff(u_exdata) + n, &res) < 0)
1727 memcpy(((char *) hdr) + n, &res, 4);
1730 fprintf(stderr, "[struct exec: magic: %o version %u Mach %o\n",
1731 hdr->a_magic, hdr->a_toolversion, hdr->a_machtype);
1732 fprintf(stderr, "Text %lu Data %lu Bss %lu Syms %lu Entry %#lx]\n",
1733 hdr->a_text, hdr->a_data, hdr->a_bss, hdr->a_syms, hdr->a_entry);
1739 fixvfork(struct tcb *tcp)
1743 * Change `vfork' in a freshly exec'ed dynamically linked
1744 * executable's (internal) symbol table to plain old `fork'
1748 struct link_dynamic dyn;
1749 struct link_dynamic_2 ld;
1752 if (getex(tcp, &hdr) < 0)
1757 if (umove(tcp, (int) N_DATADDR(hdr), &dyn) < 0) {
1758 fprintf(stderr, "Cannot read DYNAMIC\n");
1761 if (umove(tcp, (int) dyn.ld_un.ld_2, &ld) < 0) {
1762 fprintf(stderr, "Cannot read link_dynamic_2\n");
1765 strtab = malloc((unsigned)ld.ld_symb_size);
1767 die_out_of_memory();
1768 if (umoven(tcp, (int)ld.ld_symbols+(int)N_TXTADDR(hdr),
1769 (int)ld.ld_symb_size, strtab) < 0)
1772 for (cp = strtab; cp < strtab + ld.ld_symb_size; ) {
1773 if (strcmp(cp, "_vfork") == 0) {
1775 fprintf(stderr, "fixvfork: FOUND _vfork\n");
1776 strcpy(cp, "_fork");
1781 if (cp < strtab + ld.ld_symb_size)
1783 * Write entire symbol table back to avoid
1784 * memory alignment bugs in ptrace
1786 if (tload(pid, (int)ld.ld_symbols+(int)N_TXTADDR(hdr),
1787 (int)ld.ld_symb_size, strtab) < 0)