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)
168 stpcpy(char *dst, const char *src)
170 while ((*dst = *src++) != '\0')
176 * Generic ptrace wrapper which tracks ESRCH errors
177 * by setting tcp->ptrace_errno to ESRCH.
179 * We assume that ESRCH indicates likely process death (SIGKILL?),
180 * modulo bugs where process somehow ended up not stopped.
181 * Unfortunately kernel uses ESRCH for that case too. Oh well.
183 * Currently used by upeek() only.
184 * TODO: use this in all other ptrace() calls while decoding.
187 do_ptrace(int request, struct tcb *tcp, void *addr, void *data)
192 l = ptrace(request, tcp->pid, addr, (long) data);
193 /* Non-ESRCH errors might be our invalid reg/mem accesses,
194 * we do not record them. */
196 tcp->ptrace_errno = ESRCH;
201 * Used when we want to unblock stopped traced process.
202 * Should be only used with PTRACE_CONT, PTRACE_DETACH and PTRACE_SYSCALL.
203 * Returns 0 on success or if error was ESRCH
204 * (presumably process was killed while we talk to it).
205 * Otherwise prints error message and returns -1.
208 ptrace_restart(int op, struct tcb *tcp, int sig)
214 ptrace(op, tcp->pid, (void *) 1, (long) sig);
216 if (!err || err == ESRCH)
219 tcp->ptrace_errno = err;
221 if (op == PTRACE_CONT)
223 if (op == PTRACE_DETACH)
225 fprintf(stderr, "strace: ptrace(PTRACE_%s,1,%d): %s\n",
226 msg, sig, strerror(err));
231 * Print entry in struct xlat table, if there.
234 printxval(const struct xlat *xlat, int val, const char *dflt)
236 const char *str = xlookup(xlat, val);
241 tprintf("%#x /* %s */", val, dflt);
246 * Print 64bit argument at position llarg and return the index of the next
250 printllval(struct tcb *tcp, const char *format, int llarg)
252 # if defined(FREEBSD) \
253 || (defined(LINUX) && defined(POWERPC) && !defined(POWERPC64)) \
254 || defined(LINUX_MIPSO32) \
255 || defined(__ARM_EABI__)
256 /* Align 64bit argument to 64bit boundary. */
257 llarg = (llarg + 1) & 0x1e;
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 llarg = (llarg + 1) & 0x1e;
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(const struct xlat *xlat, int flags)
293 for (; xlat->str; xlat++) {
294 if (xlat->val && (flags & xlat->val) == xlat->val) {
295 tprintf("|%s", xlat->str);
300 tprintf("|%#x", flags);
305 * Interpret `xlat' as an array of flags.
306 * Print to static string the entries whose bits are on in `flags'
307 * Return static string.
310 sprintflags(const char *prefix, const struct xlat *xlat, int flags)
312 static char outstr[1024];
316 outptr = stpcpy(outstr, prefix);
318 for (; xlat->str; xlat++) {
319 if ((flags & xlat->val) == xlat->val) {
322 outptr = stpcpy(outptr, xlat->str);
330 outptr += sprintf(outptr, "%#x", flags);
337 printflags(const struct xlat *xlat, int flags, const char *dflt)
342 if (flags == 0 && xlat->val == 0) {
343 tprintf("%s", xlat->str);
348 for (n = 0; xlat->str; xlat++) {
349 if (xlat->val && (flags & xlat->val) == xlat->val) {
350 tprintf("%s%s", sep, xlat->str);
359 tprintf("%s%#x", sep, flags);
364 tprintf("%#x", flags);
366 tprintf(" /* %s */", dflt);
377 printnum(struct tcb *tcp, long addr, const char *fmt)
385 if (umove(tcp, addr, &num) < 0) {
386 tprintf("%#lx", addr);
395 printnum_int(struct tcb *tcp, long addr, const char *fmt)
403 if (umove(tcp, addr, &num) < 0) {
404 tprintf("%#lx", addr);
413 printfd(struct tcb *tcp, int fd)
417 if (show_fd_path && (p = getfdpath(tcp, fd)))
418 tprintf("%d<%s>", fd, p);
424 printuid(const char *text, unsigned long uid)
427 tprintf((uid == -1) ? "%ld" : "%lu", 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 * (unsigned long) len;
691 if (size / sizeof_iov != len /* overflow? */
692 || (iov = malloc(size)) == NULL) {
695 if (umoven(tcp, addr, size, (char *) iov) >= 0) {
696 for (i = 0; i < len; i++) {
697 /* include the buffer number to make it easy to
698 * match up the trace with the source */
699 tprintf(" * %lu bytes in buffer %d\n",
700 (unsigned long)iov_iov_len(i), i);
701 dumpstr(tcp, (long) iov_iov_base(i),
714 dumpstr(struct tcb *tcp, long addr, int len)
716 static int strsize = -1;
717 static unsigned char *str;
729 if (umoven(tcp, addr, len, (char *) str) < 0)
732 for (i = 0; i < len; i += 16) {
736 sprintf(s, " | %05x ", i);
738 for (j = 0; j < 16; j++) {
742 sprintf(s, " %02x", str[i + j]);
746 *s++ = ' '; *s++ = ' '; *s++ = ' ';
749 *s++ = ' '; *s++ = ' ';
750 for (j = 0; j < 16; j++) {
754 if (isprint(str[i + j]))
762 tprintf("%s |\n", outstr);
766 #define PAGMASK (~(PAGSIZ - 1))
768 * move `len' bytes of data from process `pid'
769 * at address `addr' to our space at `laddr'
772 umoven(struct tcb *tcp, long addr, int len, char *laddr)
780 char x[sizeof(long)];
783 if (addr & (sizeof(long) - 1)) {
784 /* addr not a multiple of sizeof(long) */
785 n = addr - (addr & -sizeof(long)); /* residue */
786 addr &= -sizeof(long); /* residue */
788 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
790 if (started && (errno==EPERM || errno==EIO)) {
791 /* Ran into 'end of memory' - stupid "printpath" */
794 /* But if not started, we had a bogus address. */
795 if (addr != 0 && errno != EIO && errno != ESRCH)
796 perror("ptrace: umoven");
800 memcpy(laddr, &u.x[n], m = MIN(sizeof(long) - n, len));
801 addr += sizeof(long), laddr += m, len -= m;
805 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
807 if (started && (errno==EPERM || errno==EIO)) {
808 /* Ran into 'end of memory' - stupid "printpath" */
811 if (addr != 0 && errno != EIO && errno != ESRCH)
812 perror("ptrace: umoven");
816 memcpy(laddr, u.x, m = MIN(sizeof(long), len));
817 addr += sizeof(long), laddr += m, len -= m;
826 n = MIN(len, PAGSIZ);
827 n = MIN(n, ((addr + PAGSIZ) & PAGMASK) - addr);
828 if (ptrace(PTRACE_READDATA, pid,
829 (char *) addr, len, laddr) < 0) {
830 if (errno != ESRCH) {
831 perror("umoven: ptrace(PTRACE_READDATA, ...)");
843 #ifdef HAVE_MP_PROCFS
844 int fd = tcp->pfd_as;
848 lseek(fd, addr, SEEK_SET);
849 if (read(fd, laddr, len) == -1)
851 #endif /* USE_PROCFS */
857 * like `umove' but make the additional effort of looking
858 * for a terminating zero byte.
861 umovestr(struct tcb *tcp, long addr, int len, char *laddr)
864 #ifdef HAVE_MP_PROCFS
865 int fd = tcp->pfd_as;
869 /* Some systems (e.g. FreeBSD) can be upset if we read off the
870 end of valid memory, avoid this by trying to read up
871 to page boundaries. But we don't know what a page is (and
872 getpagesize(2) (if it exists) doesn't necessarily return
873 hardware page size). Assume all pages >= 1024 (a-historical
876 int page = 1024; /* How to find this? */
877 int move = page - (addr & (page - 1));
880 lseek(fd, addr, SEEK_SET);
885 move = read(fd, laddr, move);
887 return left != len ? 0 : -1;
888 if (memchr(laddr, 0, move))
895 #else /* !USE_PROCFS */
901 char x[sizeof(long)];
904 if (addr & (sizeof(long) - 1)) {
905 /* addr not a multiple of sizeof(long) */
906 n = addr - (addr & -sizeof(long)); /* residue */
907 addr &= -sizeof(long); /* residue */
909 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
911 if (started && (errno==EPERM || errno==EIO)) {
912 /* Ran into 'end of memory' - stupid "printpath" */
915 if (addr != 0 && errno != EIO && errno != ESRCH)
920 memcpy(laddr, &u.x[n], m = MIN(sizeof(long)-n, len));
921 while (n & (sizeof(long) - 1))
922 if (u.x[n++] == '\0')
924 addr += sizeof(long), laddr += m, len -= m;
928 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
930 if (started && (errno==EPERM || errno==EIO)) {
931 /* Ran into 'end of memory' - stupid "printpath" */
934 if (addr != 0 && errno != EIO && errno != ESRCH)
939 memcpy(laddr, u.x, m = MIN(sizeof(long), len));
940 for (i = 0; i < sizeof(long); i++)
944 addr += sizeof(long), laddr += m, len -= m;
946 #endif /* !USE_PROCFS */
951 # if !defined (SPARC) && !defined(SPARC64)
952 # define PTRACE_WRITETEXT 101
953 # define PTRACE_WRITEDATA 102
954 # endif /* !SPARC && !SPARC64 */
960 uload(int cmd, int pid, long addr, int len, char *laddr)
966 char x[sizeof(long)];
969 if (cmd == PTRACE_WRITETEXT) {
970 peek = PTRACE_PEEKTEXT;
971 poke = PTRACE_POKETEXT;
974 peek = PTRACE_PEEKDATA;
975 poke = PTRACE_POKEDATA;
977 if (addr & (sizeof(long) - 1)) {
978 /* addr not a multiple of sizeof(long) */
979 n = addr - (addr & -sizeof(long)); /* residue */
980 addr &= -sizeof(long);
982 u.val = ptrace(peek, pid, (char *) addr, 0);
984 perror("uload: POKE");
987 memcpy(&u.x[n], laddr, m = MIN(sizeof(long) - n, len));
988 if (ptrace(poke, pid, (char *)addr, u.val) < 0) {
989 perror("uload: POKE");
992 addr += sizeof(long), laddr += m, len -= m;
995 if (len < sizeof(long))
996 u.val = ptrace(peek, pid, (char *) addr, 0);
997 memcpy(u.x, laddr, m = MIN(sizeof(long), len));
998 if (ptrace(poke, pid, (char *) addr, u.val) < 0) {
999 perror("uload: POKE");
1002 addr += sizeof(long), laddr += m, len -= m;
1008 tload(int pid, int addr, int len, char *laddr)
1010 return uload(PTRACE_WRITETEXT, pid, addr, len, laddr);
1014 dload(int pid, int addr, int len, char *laddr)
1016 return uload(PTRACE_WRITEDATA, pid, addr, len, laddr);
1024 upeek(struct tcb *tcp, long off, long *res)
1028 # ifdef SUNOS4_KERNEL_ARCH_KLUDGE
1030 static int is_sun4m = -1;
1031 struct utsname name;
1033 /* Round up the usual suspects. */
1034 if (is_sun4m == -1) {
1035 if (uname(&name) < 0) {
1036 perror("upeek: uname?");
1039 is_sun4m = strcmp(name.machine, "sun4m") == 0;
1041 const struct xlat *x;
1043 for (x = struct_user_offsets; x->str; x++)
1050 # endif /* SUNOS4_KERNEL_ARCH_KLUDGE */
1052 val = do_ptrace(PTRACE_PEEKUSER, tcp, (char *) off, 0);
1053 if (val == -1 && errno) {
1054 if (errno != ESRCH) {
1056 sprintf(buf, "upeek: ptrace(PTRACE_PEEKUSER,%d,%lu,0)", tcp->pid, off);
1065 #endif /* !USE_PROCFS */
1068 printcall(struct tcb *tcp)
1070 #define PRINTBADPC tprintf(sizeof(long) == 4 ? "[????????] " : \
1071 sizeof(long) == 8 ? "[????????????????] " : \
1078 if (upeek(tcp, 4*EIP, &eip) < 0) {
1082 tprintf("[%08lx] ", eip);
1084 # elif defined(S390) || defined(S390X)
1086 if (upeek(tcp, PT_PSWADDR, &psw) < 0) {
1091 tprintf("[%08lx] ", psw);
1093 tprintf("[%16lx] ", psw);
1096 # elif defined(X86_64)
1099 if (upeek(tcp, 8*RIP, &rip) < 0) {
1103 tprintf("[%16lx] ", rip);
1104 # elif defined(IA64)
1107 if (upeek(tcp, PT_B0, &ip) < 0) {
1111 tprintf("[%08lx] ", ip);
1112 # elif defined(POWERPC)
1115 if (upeek(tcp, sizeof(unsigned long)*PT_NIP, &pc) < 0) {
1120 tprintf("[%016lx] ", pc);
1122 tprintf("[%08lx] ", pc);
1124 # elif defined(M68K)
1127 if (upeek(tcp, 4*PT_PC, &pc) < 0) {
1128 tprintf("[????????] ");
1131 tprintf("[%08lx] ", pc);
1132 # elif defined(ALPHA)
1135 if (upeek(tcp, REG_PC, &pc) < 0) {
1136 tprintf("[????????????????] ");
1139 tprintf("[%08lx] ", pc);
1140 # elif defined(SPARC) || defined(SPARC64)
1141 struct pt_regs regs;
1142 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) {
1146 # if defined(SPARC64)
1147 tprintf("[%08lx] ", regs.tpc);
1149 tprintf("[%08lx] ", regs.pc);
1151 # elif defined(HPPA)
1154 if (upeek(tcp, PT_IAOQ0, &pc) < 0) {
1155 tprintf("[????????] ");
1158 tprintf("[%08lx] ", pc);
1159 # elif defined(MIPS)
1162 if (upeek(tcp, REG_EPC, &pc) < 0) {
1163 tprintf("[????????] ");
1166 tprintf("[%08lx] ", pc);
1170 if (upeek(tcp, 4*REG_PC, &pc) < 0) {
1171 tprintf("[????????] ");
1174 tprintf("[%08lx] ", pc);
1175 # elif defined(SH64)
1178 if (upeek(tcp, REG_PC, &pc) < 0) {
1179 tprintf("[????????????????] ");
1182 tprintf("[%08lx] ", pc);
1186 if (upeek(tcp, 4*15, &pc) < 0) {
1190 tprintf("[%08lx] ", pc);
1191 # elif defined(AVR32)
1194 if (upeek(tcp, REG_PC, &pc) < 0) {
1195 tprintf("[????????] ");
1198 tprintf("[%08lx] ", pc);
1199 # elif defined(BFIN)
1202 if (upeek(tcp, PT_PC, &pc) < 0) {
1206 tprintf("[%08lx] ", pc);
1207 #elif defined(CRISV10)
1210 if (upeek(tcp, 4*PT_IRP, &pc) < 0) {
1214 tprintf("[%08lx] ", pc);
1215 #elif defined(CRISV32)
1218 if (upeek(tcp, 4*PT_ERP, &pc) < 0) {
1222 tprintf("[%08lx] ", pc);
1223 # endif /* architecture */
1229 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *) ®s, 0) < 0) {
1230 perror("printcall: ptrace(PTRACE_GETREGS, ...)");
1234 tprintf("[%08x] ", regs.r_o7);
1244 pread(tcp->pfd_reg, ®s, sizeof(regs), 0);
1245 tprintf("[%08x] ", regs.r_eip);
1246 #endif /* FREEBSD */
1251 * These #if's are huge, please indent them correctly.
1252 * It's easy to get confused otherwise.
1258 # include "syscall.h"
1260 # include <sys/syscall.h>
1261 # ifndef CLONE_PTRACE
1262 # define CLONE_PTRACE 0x00002000
1264 # ifndef CLONE_VFORK
1265 # define CLONE_VFORK 0x00004000
1268 # define CLONE_VM 0x00000100
1270 # ifndef CLONE_STOPPED
1271 # define CLONE_STOPPED 0x02000000
1276 /* We don't have fork()/vfork() syscalls on ia64 itself, but the ia32
1277 subsystem has them for x86... */
1279 # define SYS_vfork 190
1281 typedef unsigned long *arg_setup_state;
1284 arg_setup(struct tcb *tcp, arg_setup_state *state)
1286 unsigned long cfm, sof, sol;
1290 /* Satisfy a false GCC warning. */
1295 if (upeek(tcp, PT_AR_BSP, &bsp) < 0)
1297 if (upeek(tcp, PT_CFM, (long *) &cfm) < 0)
1300 sof = (cfm >> 0) & 0x7f;
1301 sol = (cfm >> 7) & 0x7f;
1302 bsp = (long) ia64_rse_skip_regs((unsigned long *) bsp, -sof + sol);
1304 *state = (unsigned long *) bsp;
1308 # define arg_finish_change(tcp, state) 0
1312 get_arg0(struct tcb *tcp, arg_setup_state *state, long *valp)
1317 ret = upeek(tcp, PT_R11, valp);
1320 (unsigned long) ia64_rse_skip_regs(*state, 0),
1321 sizeof(long), (void *) valp);
1326 get_arg1(struct tcb *tcp, arg_setup_state *state, long *valp)
1331 ret = upeek(tcp, PT_R9, valp);
1334 (unsigned long) ia64_rse_skip_regs(*state, 1),
1335 sizeof(long), (void *) valp);
1341 set_arg0(struct tcb *tcp, arg_setup_state *state, long val)
1343 int req = PTRACE_POKEDATA;
1347 ap = (void *) (intptr_t) PT_R11; /* r11 == EBX */
1348 req = PTRACE_POKEUSER;
1350 ap = ia64_rse_skip_regs(*state, 0);
1352 ptrace(req, tcp->pid, ap, val);
1353 return errno ? -1 : 0;
1357 set_arg1(struct tcb *tcp, arg_setup_state *state, long val)
1359 int req = PTRACE_POKEDATA;
1363 ap = (void *) (intptr_t) PT_R9; /* r9 == ECX */
1364 req = PTRACE_POKEUSER;
1366 ap = ia64_rse_skip_regs(*state, 1);
1368 ptrace(req, tcp->pid, ap, val);
1369 return errno ? -1 : 0;
1372 /* ia64 does not return the input arguments from functions (and syscalls)
1373 according to ia64 RSE (Register Stack Engine) behavior. */
1375 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1376 # define restore_arg1(tcp, state, val) ((void) (state), 0)
1378 # elif defined (SPARC) || defined (SPARC64)
1380 typedef struct pt_regs arg_setup_state;
1382 # define arg_setup(tcp, state) \
1383 (ptrace(PTRACE_GETREGS, tcp->pid, (char *) (state), 0))
1384 # define arg_finish_change(tcp, state) \
1385 (ptrace(PTRACE_SETREGS, tcp->pid, (char *) (state), 0))
1387 # define get_arg0(tcp, state, valp) (*(valp) = (state)->u_regs[U_REG_O0], 0)
1388 # define get_arg1(tcp, state, valp) (*(valp) = (state)->u_regs[U_REG_O1], 0)
1389 # define set_arg0(tcp, state, val) ((state)->u_regs[U_REG_O0] = (val), 0)
1390 # define set_arg1(tcp, state, val) ((state)->u_regs[U_REG_O1] = (val), 0)
1391 # define restore_arg0(tcp, state, val) 0
1393 # else /* other architectures */
1395 # if defined S390 || defined S390X
1396 /* Note: this is only true for the `clone' system call, which handles
1397 arguments specially. We could as well say that its first two arguments
1398 are swapped relative to other architectures, but that would just be
1399 another #ifdef in the calls. */
1400 # define arg0_offset PT_GPR3
1401 # define arg1_offset PT_ORIGGPR2
1402 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1403 # define restore_arg1(tcp, state, val) ((void) (state), 0)
1404 # define arg0_index 1
1405 # define arg1_index 0
1406 # elif defined (ALPHA) || defined (MIPS)
1407 # define arg0_offset REG_A0
1408 # define arg1_offset (REG_A0+1)
1409 # elif defined (AVR32)
1410 # define arg0_offset (REG_R12)
1411 # define arg1_offset (REG_R11)
1412 # elif defined (POWERPC)
1413 # define arg0_offset (sizeof(unsigned long)*PT_R3)
1414 # define arg1_offset (sizeof(unsigned long)*PT_R4)
1415 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1416 # elif defined (HPPA)
1417 # define arg0_offset PT_GR26
1418 # define arg1_offset (PT_GR26-4)
1419 # elif defined (X86_64)
1420 # define arg0_offset ((long)(8*(current_personality ? RBX : RDI)))
1421 # define arg1_offset ((long)(8*(current_personality ? RCX : RSI)))
1423 # define arg0_offset (4*(REG_REG0+4))
1424 # define arg1_offset (4*(REG_REG0+5))
1425 # elif defined (SH64)
1426 /* ABI defines arg0 & 1 in r2 & r3 */
1427 # define arg0_offset (REG_OFFSET+16)
1428 # define arg1_offset (REG_OFFSET+24)
1429 # define restore_arg0(tcp, state, val) 0
1430 # elif defined CRISV10 || defined CRISV32
1431 # define arg0_offset (4*PT_R11)
1432 # define arg1_offset (4*PT_ORIG_R10)
1433 # define restore_arg0(tcp, state, val) 0
1434 # define restore_arg1(tcp, state, val) 0
1435 # define arg0_index 1
1436 # define arg1_index 0
1438 # define arg0_offset 0
1439 # define arg1_offset 4
1441 # define restore_arg0(tcp, state, val) 0
1445 typedef int arg_setup_state;
1447 # define arg_setup(tcp, state) (0)
1448 # define arg_finish_change(tcp, state) 0
1449 # define get_arg0(tcp, cookie, valp) \
1450 (upeek((tcp), arg0_offset, (valp)))
1451 # define get_arg1(tcp, cookie, valp) \
1452 (upeek((tcp), arg1_offset, (valp)))
1455 set_arg0(struct tcb *tcp, void *cookie, long val)
1457 return ptrace(PTRACE_POKEUSER, tcp->pid, (char*)arg0_offset, val);
1461 set_arg1(struct tcb *tcp, void *cookie, long val)
1463 return ptrace(PTRACE_POKEUSER, tcp->pid, (char*)arg1_offset, val);
1466 # endif /* architectures */
1468 # ifndef restore_arg0
1469 # define restore_arg0(tcp, state, val) set_arg0((tcp), (state), (val))
1471 # ifndef restore_arg1
1472 # define restore_arg1(tcp, state, val) set_arg1((tcp), (state), (val))
1476 # define arg0_index 0
1477 # define arg1_index 1
1481 setbpt(struct tcb *tcp)
1483 static int clone_scno[SUPPORTED_PERSONALITIES] = { SYS_clone };
1484 arg_setup_state state;
1486 if (tcp->flags & TCB_BPTSET) {
1487 fprintf(stderr, "PANIC: TCB already set in pid %u\n", tcp->pid);
1492 * It's a silly kludge to initialize this with a search at runtime.
1493 * But it's better than maintaining another magic thing in the
1494 * godforsaken tables.
1496 if (clone_scno[current_personality] == 0) {
1498 for (i = 0; i < nsyscalls; ++i)
1499 if (sysent[i].sys_func == sys_clone) {
1500 clone_scno[current_personality] = i;
1505 switch (known_scno(tcp)) {
1512 # if defined SYS_fork || defined SYS_vfork
1513 if (arg_setup(tcp, &state) < 0
1514 || get_arg0(tcp, &state, &tcp->inst[0]) < 0
1515 || get_arg1(tcp, &state, &tcp->inst[1]) < 0
1516 || change_syscall(tcp, clone_scno[current_personality]) < 0
1517 || set_arg0(tcp, &state, CLONE_PTRACE|SIGCHLD) < 0
1518 || set_arg1(tcp, &state, 0) < 0
1519 || arg_finish_change(tcp, &state) < 0)
1521 tcp->u_arg[arg0_index] = CLONE_PTRACE|SIGCHLD;
1522 tcp->u_arg[arg1_index] = 0;
1523 tcp->flags |= TCB_BPTSET;
1531 /* ia64 calls directly `clone (CLONE_VFORK | CLONE_VM)'
1532 contrary to x86 SYS_vfork above. Even on x86 we turn the
1533 vfork semantics into plain fork - each application must not
1534 depend on the vfork specifics according to POSIX. We would
1535 hang waiting for the parent resume otherwise. We need to
1536 clear also CLONE_VM but only in the CLONE_VFORK case as
1537 otherwise we would break pthread_create. */
1539 long new_arg0 = (tcp->u_arg[arg0_index] | CLONE_PTRACE);
1540 if (new_arg0 & CLONE_VFORK)
1541 new_arg0 &= ~(unsigned long)(CLONE_VFORK | CLONE_VM);
1542 if (arg_setup(tcp, &state) < 0
1543 || set_arg0(tcp, &state, new_arg0) < 0
1544 || arg_finish_change(tcp, &state) < 0)
1546 tcp->flags |= TCB_BPTSET;
1547 tcp->inst[0] = tcp->u_arg[arg0_index];
1548 tcp->inst[1] = tcp->u_arg[arg1_index];
1552 fprintf(stderr, "PANIC: setbpt for syscall %ld on %u???\n",
1553 tcp->scno, tcp->pid);
1561 clearbpt(struct tcb *tcp)
1563 arg_setup_state state;
1564 if (arg_setup(tcp, &state) < 0
1565 || restore_arg0(tcp, &state, tcp->inst[0]) < 0
1566 || restore_arg1(tcp, &state, tcp->inst[1]) < 0
1567 || arg_finish_change(tcp, &state))
1570 tcp->flags &= ~TCB_BPTSET;
1574 # else /* !defined LINUX */
1577 setbpt(struct tcb *tcp)
1580 # ifdef SPARC /* This code is slightly sparc specific */
1583 # define BPT 0x91d02001 /* ta 1 */
1584 # define LOOP 0x10800000 /* ba 0 */
1585 # define LOOPA 0x30800000 /* ba,a 0 */
1586 # define NOP 0x01000000
1588 static int loopdeloop[1] = {LOOPA};
1590 static int loopdeloop[2] = {LOOP, NOP};
1593 if (tcp->flags & TCB_BPTSET) {
1594 fprintf(stderr, "PANIC: TCB already set in pid %u\n", tcp->pid);
1597 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) {
1598 perror("setbpt: ptrace(PTRACE_GETREGS, ...)");
1601 tcp->baddr = regs.r_o7 + 8;
1602 if (ptrace(PTRACE_READTEXT, tcp->pid, (char *)tcp->baddr,
1603 sizeof tcp->inst, (char *)tcp->inst) < 0) {
1604 perror("setbpt: ptrace(PTRACE_READTEXT, ...)");
1609 * XXX - BRUTAL MODE ON
1610 * We cannot set a real BPT in the child, since it will not be
1611 * traced at the moment it will reach the trap and would probably
1612 * die with a core dump.
1613 * Thus, we are force our way in by taking out two instructions
1614 * and insert an eternal loop in stead, in expectance of the SIGSTOP
1615 * generated by out PTRACE_ATTACH.
1616 * Of cause, if we evaporate ourselves in the middle of all this...
1618 if (ptrace(PTRACE_WRITETEXT, tcp->pid, (char *) tcp->baddr,
1619 sizeof loopdeloop, (char *) loopdeloop) < 0) {
1620 perror("setbpt: ptrace(PTRACE_WRITETEXT, ...)");
1623 tcp->flags |= TCB_BPTSET;
1626 # endif /* SUNOS4 */
1632 clearbpt(struct tcb *tcp)
1641 if (!(tcp->flags & TCB_BPTSET)) {
1642 fprintf(stderr, "PANIC: TCB not set in pid %u\n", tcp->pid);
1645 if (ptrace(PTRACE_WRITETEXT, tcp->pid, (char *) tcp->baddr,
1646 sizeof tcp->inst, (char *) tcp->inst) < 0) {
1647 perror("clearbtp: ptrace(PTRACE_WRITETEXT, ...)");
1650 tcp->flags &= ~TCB_BPTSET;
1654 * Since we don't have a single instruction breakpoint, we may have
1655 * to adjust the program counter after removing our `breakpoint'.
1657 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) {
1658 perror("clearbpt: ptrace(PTRACE_GETREGS, ...)");
1661 if ((regs.r_pc < tcp->baddr) ||
1662 (regs.r_pc > tcp->baddr + 4)) {
1663 /* The breakpoint has not been reached yet */
1666 "NOTE: PC not at bpt (pc %#x baddr %#x)\n",
1667 regs.r_pc, tcp->baddr);
1670 if (regs.r_pc != tcp->baddr)
1672 fprintf(stderr, "NOTE: PC adjusted (%#x -> %#x\n",
1673 regs.r_pc, tcp->baddr);
1675 regs.r_pc = tcp->baddr;
1676 if (ptrace(PTRACE_SETREGS, tcp->pid, (char *)®s, 0) < 0) {
1677 perror("clearbpt: ptrace(PTRACE_SETREGS, ...)");
1682 # endif /* SUNOS4 */
1687 # endif /* !defined LINUX */
1689 #endif /* !USE_PROCFS */
1695 getex(struct tcb *tcp, struct exec *hdr)
1699 for (n = 0; n < sizeof *hdr; n += 4) {
1701 if (upeek(tcp, uoff(u_exdata) + n, &res) < 0)
1703 memcpy(((char *) hdr) + n, &res, 4);
1706 fprintf(stderr, "[struct exec: magic: %o version %u Mach %o\n",
1707 hdr->a_magic, hdr->a_toolversion, hdr->a_machtype);
1708 fprintf(stderr, "Text %lu Data %lu Bss %lu Syms %lu Entry %#lx]\n",
1709 hdr->a_text, hdr->a_data, hdr->a_bss, hdr->a_syms, hdr->a_entry);
1715 fixvfork(struct tcb *tcp)
1719 * Change `vfork' in a freshly exec'ed dynamically linked
1720 * executable's (internal) symbol table to plain old `fork'
1724 struct link_dynamic dyn;
1725 struct link_dynamic_2 ld;
1728 if (getex(tcp, &hdr) < 0)
1733 if (umove(tcp, (int) N_DATADDR(hdr), &dyn) < 0) {
1734 fprintf(stderr, "Cannot read DYNAMIC\n");
1737 if (umove(tcp, (int) dyn.ld_un.ld_2, &ld) < 0) {
1738 fprintf(stderr, "Cannot read link_dynamic_2\n");
1741 strtab = malloc((unsigned)ld.ld_symb_size);
1743 die_out_of_memory();
1744 if (umoven(tcp, (int)ld.ld_symbols+(int)N_TXTADDR(hdr),
1745 (int)ld.ld_symb_size, strtab) < 0)
1748 for (cp = strtab; cp < strtab + ld.ld_symb_size; ) {
1749 if (strcmp(cp, "_vfork") == 0) {
1751 fprintf(stderr, "fixvfork: FOUND _vfork\n");
1752 strcpy(cp, "_fork");
1757 if (cp < strtab + ld.ld_symb_size)
1759 * Write entire symbol table back to avoid
1760 * memory alignment bugs in ptrace
1762 if (tload(pid, (int)ld.ld_symbols+(int)N_TXTADDR(hdr),
1763 (int)ld.ld_symb_size, strtab) < 0)