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) {
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)
426 tprintf((uid == -1) ? "%s%ld" : "%s%lu", text, uid);
429 static char path[MAXPATHLEN + 1];
432 * Quote string `instr' of length `size'
433 * Write up to (3 + `size' * 4) bytes to `outstr' buffer.
434 * If `len' < 0, treat `instr' as a NUL-terminated string
435 * and quote at most (`size' - 1) bytes.
438 string_quote(const char *instr, char *outstr, int len, int size)
440 const unsigned char *ustr = (const unsigned char *) instr;
442 int usehex, c, i, eol;
444 eol = 0x100; /* this can never match a char */
454 /* Check for presence of symbol which require
455 to hex-quote the whole string. */
456 for (i = 0; i < size; ++i) {
458 /* Check for NUL-terminated string. */
461 if (!isprint(c) && !isspace(c)) {
471 /* Hex-quote the whole string. */
472 for (i = 0; i < size; ++i) {
474 /* Check for NUL-terminated string. */
479 *s++ = "0123456789abcdef"[c >> 4];
480 *s++ = "0123456789abcdef"[c & 0xf];
483 for (i = 0; i < size; ++i) {
485 /* Check for NUL-terminated string. */
489 case '\"': case '\\':
520 && ustr[i + 1] >= '0'
521 && ustr[i + 1] <= '9'
524 *s++ = '0' + (c >> 6);
525 *s++ = '0' + ((c >> 3) & 0x7);
530 *s++ = '0' + (c >> 6);
531 *s++ = '0' + ((c >> 3) & 0x7);
534 *s++ = '0' + (c & 0x7);
544 /* Return zero if we printed entire ASCIZ string (didn't truncate it) */
545 if (len < 0 && ustr[i] == '\0') {
546 /* We didn't see NUL yet (otherwise we'd jump to 'asciz_ended')
547 * but next char is NUL.
557 /* Return zero: we printed entire ASCIZ string (didn't truncate it) */
562 * Print path string specified by address `addr' and length `n'.
563 * If path length exceeds `n', append `...' to the output.
566 printpathn(struct tcb *tcp, long addr, int n)
573 /* Cap path length to the path buffer size,
574 and NUL-terminate the buffer. */
575 if (n > sizeof path - 1)
579 /* Fetch one byte more to find out whether path length > n. */
580 if (umovestr(tcp, addr, n + 1, path) < 0)
581 tprintf("%#lx", addr);
583 static char outstr[4*(sizeof path - 1) + sizeof "\"...\""];
585 int trunc = (path[n] != '\0');
589 string_quote(path, outstr, -1, n + 1);
593 tprintf(fmt, outstr);
598 printpath(struct tcb *tcp, long addr)
600 printpathn(tcp, addr, sizeof path - 1);
604 * Print string specified by address `addr' and length `len'.
605 * If `len' < 0, treat the string as a NUL-terminated string.
606 * If string length exceeds `max_strlen', append `...' to the output.
609 printstr(struct tcb *tcp, long addr, int len)
611 static char *str = NULL;
620 /* Allocate static buffers if they are not allocated yet. */
622 str = malloc(max_strlen + 1);
627 outstr = malloc(4 * max_strlen + sizeof "\"...\"");
634 * Treat as a NUL-terminated string: fetch one byte more
635 * because string_quote() quotes one byte less.
637 size = max_strlen + 1;
638 str[max_strlen] = '\0';
639 /* FIXME! umovestr can overwrite the '\0' stored above??? */
640 if (umovestr(tcp, addr, size, str) < 0) {
641 tprintf("%#lx", addr);
646 size = MIN(len, max_strlen);
647 if (umoven(tcp, addr, size, str) < 0) {
648 tprintf("%#lx", addr);
654 if (string_quote(str, outstr, len, size) &&
655 (len < 0 || len > max_strlen))
658 tprintf(fmt, outstr);
663 dumpiov(struct tcb *tcp, int len, long addr)
665 #if defined(LINUX) && SUPPORTED_PERSONALITIES > 1
667 struct { u_int32_t base; u_int32_t len; } *iov32;
668 struct { u_int64_t base; u_int64_t len; } *iov64;
670 #define iov iovu.iov64
672 (personality_wordsize[current_personality] == 4 \
673 ? sizeof(*iovu.iov32) : sizeof(*iovu.iov64))
674 #define iov_iov_base(i) \
675 (personality_wordsize[current_personality] == 4 \
676 ? (u_int64_t) iovu.iov32[i].base : iovu.iov64[i].base)
677 #define iov_iov_len(i) \
678 (personality_wordsize[current_personality] == 4 \
679 ? (u_int64_t) iovu.iov32[i].len : iovu.iov64[i].len)
682 #define sizeof_iov sizeof(*iov)
683 #define iov_iov_base(i) iov[i].iov_base
684 #define iov_iov_len(i) iov[i].iov_len
689 size = sizeof_iov * (unsigned long) len;
690 if (size / sizeof_iov != len /* overflow? */
691 || (iov = malloc(size)) == NULL) {
694 if (umoven(tcp, addr, size, (char *) iov) >= 0) {
695 for (i = 0; i < len; i++) {
696 /* include the buffer number to make it easy to
697 * match up the trace with the source */
698 tprintf(" * %lu bytes in buffer %d\n",
699 (unsigned long)iov_iov_len(i), i);
700 dumpstr(tcp, (long) iov_iov_base(i),
713 dumpstr(struct tcb *tcp, long addr, int len)
715 static int strsize = -1;
716 static unsigned char *str;
728 if (umoven(tcp, addr, len, (char *) str) < 0)
731 for (i = 0; i < len; i += 16) {
735 sprintf(s, " | %05x ", i);
737 for (j = 0; j < 16; j++) {
741 sprintf(s, " %02x", str[i + j]);
745 *s++ = ' '; *s++ = ' '; *s++ = ' ';
748 *s++ = ' '; *s++ = ' ';
749 for (j = 0; j < 16; j++) {
753 if (isprint(str[i + j]))
761 tprintf("%s |\n", outstr);
765 #define PAGMASK (~(PAGSIZ - 1))
767 * move `len' bytes of data from process `pid'
768 * at address `addr' to our space at `laddr'
771 umoven(struct tcb *tcp, long addr, int len, char *laddr)
779 char x[sizeof(long)];
782 if (addr & (sizeof(long) - 1)) {
783 /* addr not a multiple of sizeof(long) */
784 n = addr - (addr & -sizeof(long)); /* residue */
785 addr &= -sizeof(long); /* residue */
787 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
789 if (started && (errno==EPERM || errno==EIO)) {
790 /* Ran into 'end of memory' - stupid "printpath" */
793 /* But if not started, we had a bogus address. */
794 if (addr != 0 && errno != EIO && errno != ESRCH)
795 perror("ptrace: umoven");
799 memcpy(laddr, &u.x[n], m = MIN(sizeof(long) - n, len));
800 addr += sizeof(long), laddr += m, len -= m;
804 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
806 if (started && (errno==EPERM || errno==EIO)) {
807 /* Ran into 'end of memory' - stupid "printpath" */
810 if (addr != 0 && errno != EIO && errno != ESRCH)
811 perror("ptrace: umoven");
815 memcpy(laddr, u.x, m = MIN(sizeof(long), len));
816 addr += sizeof(long), laddr += m, len -= m;
825 n = MIN(len, PAGSIZ);
826 n = MIN(n, ((addr + PAGSIZ) & PAGMASK) - addr);
827 if (ptrace(PTRACE_READDATA, pid,
828 (char *) addr, len, laddr) < 0) {
829 if (errno != ESRCH) {
830 perror("umoven: ptrace(PTRACE_READDATA, ...)");
842 #ifdef HAVE_MP_PROCFS
843 int fd = tcp->pfd_as;
847 lseek(fd, addr, SEEK_SET);
848 if (read(fd, laddr, len) == -1)
850 #endif /* USE_PROCFS */
856 * like `umove' but make the additional effort of looking
857 * for a terminating zero byte.
860 umovestr(struct tcb *tcp, long addr, int len, char *laddr)
863 #ifdef HAVE_MP_PROCFS
864 int fd = tcp->pfd_as;
868 /* Some systems (e.g. FreeBSD) can be upset if we read off the
869 end of valid memory, avoid this by trying to read up
870 to page boundaries. But we don't know what a page is (and
871 getpagesize(2) (if it exists) doesn't necessarily return
872 hardware page size). Assume all pages >= 1024 (a-historical
875 int page = 1024; /* How to find this? */
876 int move = page - (addr & (page - 1));
879 lseek(fd, addr, SEEK_SET);
884 move = read(fd, laddr, move);
886 return left != len ? 0 : -1;
887 if (memchr(laddr, 0, move))
894 #else /* !USE_PROCFS */
900 char x[sizeof(long)];
903 if (addr & (sizeof(long) - 1)) {
904 /* addr not a multiple of sizeof(long) */
905 n = addr - (addr & -sizeof(long)); /* residue */
906 addr &= -sizeof(long); /* residue */
908 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
910 if (started && (errno==EPERM || errno==EIO)) {
911 /* Ran into 'end of memory' - stupid "printpath" */
914 if (addr != 0 && errno != EIO && errno != ESRCH)
919 memcpy(laddr, &u.x[n], m = MIN(sizeof(long)-n, len));
920 while (n & (sizeof(long) - 1))
921 if (u.x[n++] == '\0')
923 addr += sizeof(long), laddr += m, len -= m;
927 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
929 if (started && (errno==EPERM || errno==EIO)) {
930 /* Ran into 'end of memory' - stupid "printpath" */
933 if (addr != 0 && errno != EIO && errno != ESRCH)
938 memcpy(laddr, u.x, m = MIN(sizeof(long), len));
939 for (i = 0; i < sizeof(long); i++)
943 addr += sizeof(long), laddr += m, len -= m;
945 #endif /* !USE_PROCFS */
950 # if !defined (SPARC) && !defined(SPARC64)
951 # define PTRACE_WRITETEXT 101
952 # define PTRACE_WRITEDATA 102
953 # endif /* !SPARC && !SPARC64 */
959 uload(int cmd, int pid, long addr, int len, char *laddr)
965 char x[sizeof(long)];
968 if (cmd == PTRACE_WRITETEXT) {
969 peek = PTRACE_PEEKTEXT;
970 poke = PTRACE_POKETEXT;
973 peek = PTRACE_PEEKDATA;
974 poke = PTRACE_POKEDATA;
976 if (addr & (sizeof(long) - 1)) {
977 /* addr not a multiple of sizeof(long) */
978 n = addr - (addr & -sizeof(long)); /* residue */
979 addr &= -sizeof(long);
981 u.val = ptrace(peek, pid, (char *) addr, 0);
983 perror("uload: POKE");
986 memcpy(&u.x[n], laddr, m = MIN(sizeof(long) - n, len));
987 if (ptrace(poke, pid, (char *)addr, u.val) < 0) {
988 perror("uload: POKE");
991 addr += sizeof(long), laddr += m, len -= m;
994 if (len < sizeof(long))
995 u.val = ptrace(peek, pid, (char *) addr, 0);
996 memcpy(u.x, laddr, m = MIN(sizeof(long), len));
997 if (ptrace(poke, pid, (char *) addr, u.val) < 0) {
998 perror("uload: POKE");
1001 addr += sizeof(long), laddr += m, len -= m;
1007 tload(int pid, int addr, int len, char *laddr)
1009 return uload(PTRACE_WRITETEXT, pid, addr, len, laddr);
1013 dload(int pid, int addr, int len, char *laddr)
1015 return uload(PTRACE_WRITEDATA, pid, addr, len, laddr);
1023 upeek(struct tcb *tcp, long off, long *res)
1027 # ifdef SUNOS4_KERNEL_ARCH_KLUDGE
1029 static int is_sun4m = -1;
1030 struct utsname name;
1032 /* Round up the usual suspects. */
1033 if (is_sun4m == -1) {
1034 if (uname(&name) < 0) {
1035 perror("upeek: uname?");
1038 is_sun4m = strcmp(name.machine, "sun4m") == 0;
1040 const struct xlat *x;
1042 for (x = struct_user_offsets; x->str; x++)
1049 # endif /* SUNOS4_KERNEL_ARCH_KLUDGE */
1051 val = do_ptrace(PTRACE_PEEKUSER, tcp, (char *) off, 0);
1052 if (val == -1 && errno) {
1053 if (errno != ESRCH) {
1055 sprintf(buf, "upeek: ptrace(PTRACE_PEEKUSER,%d,%lu,0)", tcp->pid, off);
1064 #endif /* !USE_PROCFS */
1067 printcall(struct tcb *tcp)
1069 #define PRINTBADPC tprintf(sizeof(long) == 4 ? "[????????] " : \
1070 sizeof(long) == 8 ? "[????????????????] " : \
1077 if (upeek(tcp, 4*EIP, &eip) < 0) {
1081 tprintf("[%08lx] ", eip);
1083 # elif defined(S390) || defined(S390X)
1085 if (upeek(tcp, PT_PSWADDR, &psw) < 0) {
1090 tprintf("[%08lx] ", psw);
1092 tprintf("[%16lx] ", psw);
1095 # elif defined(X86_64)
1098 if (upeek(tcp, 8*RIP, &rip) < 0) {
1102 tprintf("[%16lx] ", rip);
1103 # elif defined(IA64)
1106 if (upeek(tcp, PT_B0, &ip) < 0) {
1110 tprintf("[%08lx] ", ip);
1111 # elif defined(POWERPC)
1114 if (upeek(tcp, sizeof(unsigned long)*PT_NIP, &pc) < 0) {
1119 tprintf("[%016lx] ", pc);
1121 tprintf("[%08lx] ", pc);
1123 # elif defined(M68K)
1126 if (upeek(tcp, 4*PT_PC, &pc) < 0) {
1127 tprintf("[????????] ");
1130 tprintf("[%08lx] ", pc);
1131 # elif defined(ALPHA)
1134 if (upeek(tcp, REG_PC, &pc) < 0) {
1135 tprintf("[????????????????] ");
1138 tprintf("[%08lx] ", pc);
1139 # elif defined(SPARC) || defined(SPARC64)
1140 struct pt_regs regs;
1141 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) {
1145 # if defined(SPARC64)
1146 tprintf("[%08lx] ", regs.tpc);
1148 tprintf("[%08lx] ", regs.pc);
1150 # elif defined(HPPA)
1153 if (upeek(tcp, PT_IAOQ0, &pc) < 0) {
1154 tprintf("[????????] ");
1157 tprintf("[%08lx] ", pc);
1158 # elif defined(MIPS)
1161 if (upeek(tcp, REG_EPC, &pc) < 0) {
1162 tprintf("[????????] ");
1165 tprintf("[%08lx] ", pc);
1169 if (upeek(tcp, 4*REG_PC, &pc) < 0) {
1170 tprintf("[????????] ");
1173 tprintf("[%08lx] ", pc);
1174 # elif defined(SH64)
1177 if (upeek(tcp, REG_PC, &pc) < 0) {
1178 tprintf("[????????????????] ");
1181 tprintf("[%08lx] ", pc);
1185 if (upeek(tcp, 4*15, &pc) < 0) {
1189 tprintf("[%08lx] ", pc);
1190 # elif defined(AVR32)
1193 if (upeek(tcp, REG_PC, &pc) < 0) {
1194 tprintf("[????????] ");
1197 tprintf("[%08lx] ", pc);
1198 # elif defined(BFIN)
1201 if (upeek(tcp, PT_PC, &pc) < 0) {
1205 tprintf("[%08lx] ", pc);
1206 #elif defined(CRISV10)
1209 if (upeek(tcp, 4*PT_IRP, &pc) < 0) {
1213 tprintf("[%08lx] ", pc);
1214 #elif defined(CRISV32)
1217 if (upeek(tcp, 4*PT_ERP, &pc) < 0) {
1221 tprintf("[%08lx] ", pc);
1222 # endif /* architecture */
1228 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *) ®s, 0) < 0) {
1229 perror("printcall: ptrace(PTRACE_GETREGS, ...)");
1233 tprintf("[%08x] ", regs.r_o7);
1243 pread(tcp->pfd_reg, ®s, sizeof(regs), 0);
1244 tprintf("[%08x] ", regs.r_eip);
1245 #endif /* FREEBSD */
1250 * These #if's are huge, please indent them correctly.
1251 * It's easy to get confused otherwise.
1257 # include "syscall.h"
1259 # include <sys/syscall.h>
1260 # ifndef CLONE_PTRACE
1261 # define CLONE_PTRACE 0x00002000
1263 # ifndef CLONE_VFORK
1264 # define CLONE_VFORK 0x00004000
1267 # define CLONE_VM 0x00000100
1269 # ifndef CLONE_STOPPED
1270 # define CLONE_STOPPED 0x02000000
1275 /* We don't have fork()/vfork() syscalls on ia64 itself, but the ia32
1276 subsystem has them for x86... */
1278 # define SYS_vfork 190
1280 typedef unsigned long *arg_setup_state;
1283 arg_setup(struct tcb *tcp, arg_setup_state *state)
1285 unsigned long cfm, sof, sol;
1289 /* Satisfy a false GCC warning. */
1294 if (upeek(tcp, PT_AR_BSP, &bsp) < 0)
1296 if (upeek(tcp, PT_CFM, (long *) &cfm) < 0)
1299 sof = (cfm >> 0) & 0x7f;
1300 sol = (cfm >> 7) & 0x7f;
1301 bsp = (long) ia64_rse_skip_regs((unsigned long *) bsp, -sof + sol);
1303 *state = (unsigned long *) bsp;
1307 # define arg_finish_change(tcp, state) 0
1311 get_arg0(struct tcb *tcp, arg_setup_state *state, long *valp)
1316 ret = upeek(tcp, PT_R11, valp);
1319 (unsigned long) ia64_rse_skip_regs(*state, 0),
1320 sizeof(long), (void *) valp);
1325 get_arg1(struct tcb *tcp, arg_setup_state *state, long *valp)
1330 ret = upeek(tcp, PT_R9, valp);
1333 (unsigned long) ia64_rse_skip_regs(*state, 1),
1334 sizeof(long), (void *) valp);
1340 set_arg0(struct tcb *tcp, arg_setup_state *state, long val)
1342 int req = PTRACE_POKEDATA;
1346 ap = (void *) (intptr_t) PT_R11; /* r11 == EBX */
1347 req = PTRACE_POKEUSER;
1349 ap = ia64_rse_skip_regs(*state, 0);
1351 ptrace(req, tcp->pid, ap, val);
1352 return errno ? -1 : 0;
1356 set_arg1(struct tcb *tcp, arg_setup_state *state, long val)
1358 int req = PTRACE_POKEDATA;
1362 ap = (void *) (intptr_t) PT_R9; /* r9 == ECX */
1363 req = PTRACE_POKEUSER;
1365 ap = ia64_rse_skip_regs(*state, 1);
1367 ptrace(req, tcp->pid, ap, val);
1368 return errno ? -1 : 0;
1371 /* ia64 does not return the input arguments from functions (and syscalls)
1372 according to ia64 RSE (Register Stack Engine) behavior. */
1374 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1375 # define restore_arg1(tcp, state, val) ((void) (state), 0)
1377 # elif defined (SPARC) || defined (SPARC64)
1379 typedef struct pt_regs arg_setup_state;
1381 # define arg_setup(tcp, state) \
1382 (ptrace(PTRACE_GETREGS, tcp->pid, (char *) (state), 0))
1383 # define arg_finish_change(tcp, state) \
1384 (ptrace(PTRACE_SETREGS, tcp->pid, (char *) (state), 0))
1386 # define get_arg0(tcp, state, valp) (*(valp) = (state)->u_regs[U_REG_O0], 0)
1387 # define get_arg1(tcp, state, valp) (*(valp) = (state)->u_regs[U_REG_O1], 0)
1388 # define set_arg0(tcp, state, val) ((state)->u_regs[U_REG_O0] = (val), 0)
1389 # define set_arg1(tcp, state, val) ((state)->u_regs[U_REG_O1] = (val), 0)
1390 # define restore_arg0(tcp, state, val) 0
1392 # else /* other architectures */
1394 # if defined S390 || defined S390X
1395 /* Note: this is only true for the `clone' system call, which handles
1396 arguments specially. We could as well say that its first two arguments
1397 are swapped relative to other architectures, but that would just be
1398 another #ifdef in the calls. */
1399 # define arg0_offset PT_GPR3
1400 # define arg1_offset PT_ORIGGPR2
1401 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1402 # define restore_arg1(tcp, state, val) ((void) (state), 0)
1403 # define arg0_index 1
1404 # define arg1_index 0
1405 # elif defined (ALPHA) || defined (MIPS)
1406 # define arg0_offset REG_A0
1407 # define arg1_offset (REG_A0+1)
1408 # elif defined (AVR32)
1409 # define arg0_offset (REG_R12)
1410 # define arg1_offset (REG_R11)
1411 # elif defined (POWERPC)
1412 # define arg0_offset (sizeof(unsigned long)*PT_R3)
1413 # define arg1_offset (sizeof(unsigned long)*PT_R4)
1414 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1415 # elif defined (HPPA)
1416 # define arg0_offset PT_GR26
1417 # define arg1_offset (PT_GR26-4)
1418 # elif defined (X86_64)
1419 # define arg0_offset ((long)(8*(current_personality ? RBX : RDI)))
1420 # define arg1_offset ((long)(8*(current_personality ? RCX : RSI)))
1422 # define arg0_offset (4*(REG_REG0+4))
1423 # define arg1_offset (4*(REG_REG0+5))
1424 # elif defined (SH64)
1425 /* ABI defines arg0 & 1 in r2 & r3 */
1426 # define arg0_offset (REG_OFFSET+16)
1427 # define arg1_offset (REG_OFFSET+24)
1428 # define restore_arg0(tcp, state, val) 0
1429 # elif defined CRISV10 || defined CRISV32
1430 # define arg0_offset (4*PT_R11)
1431 # define arg1_offset (4*PT_ORIG_R10)
1432 # define restore_arg0(tcp, state, val) 0
1433 # define restore_arg1(tcp, state, val) 0
1434 # define arg0_index 1
1435 # define arg1_index 0
1437 # define arg0_offset 0
1438 # define arg1_offset 4
1440 # define restore_arg0(tcp, state, val) 0
1444 typedef int arg_setup_state;
1446 # define arg_setup(tcp, state) (0)
1447 # define arg_finish_change(tcp, state) 0
1448 # define get_arg0(tcp, cookie, valp) \
1449 (upeek((tcp), arg0_offset, (valp)))
1450 # define get_arg1(tcp, cookie, valp) \
1451 (upeek((tcp), arg1_offset, (valp)))
1454 set_arg0(struct tcb *tcp, void *cookie, long val)
1456 return ptrace(PTRACE_POKEUSER, tcp->pid, (char*)arg0_offset, val);
1460 set_arg1(struct tcb *tcp, void *cookie, long val)
1462 return ptrace(PTRACE_POKEUSER, tcp->pid, (char*)arg1_offset, val);
1465 # endif /* architectures */
1467 # ifndef restore_arg0
1468 # define restore_arg0(tcp, state, val) set_arg0((tcp), (state), (val))
1470 # ifndef restore_arg1
1471 # define restore_arg1(tcp, state, val) set_arg1((tcp), (state), (val))
1475 # define arg0_index 0
1476 # define arg1_index 1
1480 setbpt(struct tcb *tcp)
1482 static int clone_scno[SUPPORTED_PERSONALITIES] = { SYS_clone };
1483 arg_setup_state state;
1485 if (tcp->flags & TCB_BPTSET) {
1486 fprintf(stderr, "PANIC: TCB already set in pid %u\n", tcp->pid);
1491 * It's a silly kludge to initialize this with a search at runtime.
1492 * But it's better than maintaining another magic thing in the
1493 * godforsaken tables.
1495 if (clone_scno[current_personality] == 0) {
1497 for (i = 0; i < nsyscalls; ++i)
1498 if (sysent[i].sys_func == sys_clone) {
1499 clone_scno[current_personality] = i;
1504 switch (known_scno(tcp)) {
1511 # if defined SYS_fork || defined SYS_vfork
1512 if (arg_setup(tcp, &state) < 0
1513 || get_arg0(tcp, &state, &tcp->inst[0]) < 0
1514 || get_arg1(tcp, &state, &tcp->inst[1]) < 0
1515 || change_syscall(tcp, clone_scno[current_personality]) < 0
1516 || set_arg0(tcp, &state, CLONE_PTRACE|SIGCHLD) < 0
1517 || set_arg1(tcp, &state, 0) < 0
1518 || arg_finish_change(tcp, &state) < 0)
1520 tcp->u_arg[arg0_index] = CLONE_PTRACE|SIGCHLD;
1521 tcp->u_arg[arg1_index] = 0;
1522 tcp->flags |= TCB_BPTSET;
1530 /* ia64 calls directly `clone (CLONE_VFORK | CLONE_VM)'
1531 contrary to x86 SYS_vfork above. Even on x86 we turn the
1532 vfork semantics into plain fork - each application must not
1533 depend on the vfork specifics according to POSIX. We would
1534 hang waiting for the parent resume otherwise. We need to
1535 clear also CLONE_VM but only in the CLONE_VFORK case as
1536 otherwise we would break pthread_create. */
1538 long new_arg0 = (tcp->u_arg[arg0_index] | CLONE_PTRACE);
1539 if (new_arg0 & CLONE_VFORK)
1540 new_arg0 &= ~(unsigned long)(CLONE_VFORK | CLONE_VM);
1541 if (arg_setup(tcp, &state) < 0
1542 || set_arg0(tcp, &state, new_arg0) < 0
1543 || arg_finish_change(tcp, &state) < 0)
1545 tcp->flags |= TCB_BPTSET;
1546 tcp->inst[0] = tcp->u_arg[arg0_index];
1547 tcp->inst[1] = tcp->u_arg[arg1_index];
1551 fprintf(stderr, "PANIC: setbpt for syscall %ld on %u???\n",
1552 tcp->scno, tcp->pid);
1560 clearbpt(struct tcb *tcp)
1562 arg_setup_state state;
1563 if (arg_setup(tcp, &state) < 0
1564 || restore_arg0(tcp, &state, tcp->inst[0]) < 0
1565 || restore_arg1(tcp, &state, tcp->inst[1]) < 0
1566 || arg_finish_change(tcp, &state))
1569 tcp->flags &= ~TCB_BPTSET;
1573 # else /* !defined LINUX */
1576 setbpt(struct tcb *tcp)
1579 # ifdef SPARC /* This code is slightly sparc specific */
1582 # define BPT 0x91d02001 /* ta 1 */
1583 # define LOOP 0x10800000 /* ba 0 */
1584 # define LOOPA 0x30800000 /* ba,a 0 */
1585 # define NOP 0x01000000
1587 static int loopdeloop[1] = {LOOPA};
1589 static int loopdeloop[2] = {LOOP, NOP};
1592 if (tcp->flags & TCB_BPTSET) {
1593 fprintf(stderr, "PANIC: TCB already set in pid %u\n", tcp->pid);
1596 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) {
1597 perror("setbpt: ptrace(PTRACE_GETREGS, ...)");
1600 tcp->baddr = regs.r_o7 + 8;
1601 if (ptrace(PTRACE_READTEXT, tcp->pid, (char *)tcp->baddr,
1602 sizeof tcp->inst, (char *)tcp->inst) < 0) {
1603 perror("setbpt: ptrace(PTRACE_READTEXT, ...)");
1608 * XXX - BRUTAL MODE ON
1609 * We cannot set a real BPT in the child, since it will not be
1610 * traced at the moment it will reach the trap and would probably
1611 * die with a core dump.
1612 * Thus, we are force our way in by taking out two instructions
1613 * and insert an eternal loop in stead, in expectance of the SIGSTOP
1614 * generated by out PTRACE_ATTACH.
1615 * Of cause, if we evaporate ourselves in the middle of all this...
1617 if (ptrace(PTRACE_WRITETEXT, tcp->pid, (char *) tcp->baddr,
1618 sizeof loopdeloop, (char *) loopdeloop) < 0) {
1619 perror("setbpt: ptrace(PTRACE_WRITETEXT, ...)");
1622 tcp->flags |= TCB_BPTSET;
1625 # endif /* SUNOS4 */
1631 clearbpt(struct tcb *tcp)
1640 if (!(tcp->flags & TCB_BPTSET)) {
1641 fprintf(stderr, "PANIC: TCB not set in pid %u\n", tcp->pid);
1644 if (ptrace(PTRACE_WRITETEXT, tcp->pid, (char *) tcp->baddr,
1645 sizeof tcp->inst, (char *) tcp->inst) < 0) {
1646 perror("clearbtp: ptrace(PTRACE_WRITETEXT, ...)");
1649 tcp->flags &= ~TCB_BPTSET;
1653 * Since we don't have a single instruction breakpoint, we may have
1654 * to adjust the program counter after removing our `breakpoint'.
1656 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) {
1657 perror("clearbpt: ptrace(PTRACE_GETREGS, ...)");
1660 if ((regs.r_pc < tcp->baddr) ||
1661 (regs.r_pc > tcp->baddr + 4)) {
1662 /* The breakpoint has not been reached yet */
1665 "NOTE: PC not at bpt (pc %#x baddr %#x)\n",
1666 regs.r_pc, tcp->baddr);
1669 if (regs.r_pc != tcp->baddr)
1671 fprintf(stderr, "NOTE: PC adjusted (%#x -> %#x\n",
1672 regs.r_pc, tcp->baddr);
1674 regs.r_pc = tcp->baddr;
1675 if (ptrace(PTRACE_SETREGS, tcp->pid, (char *)®s, 0) < 0) {
1676 perror("clearbpt: ptrace(PTRACE_SETREGS, ...)");
1681 # endif /* SUNOS4 */
1686 # endif /* !defined LINUX */
1688 #endif /* !USE_PROCFS */
1694 getex(struct tcb *tcp, struct exec *hdr)
1698 for (n = 0; n < sizeof *hdr; n += 4) {
1700 if (upeek(tcp, uoff(u_exdata) + n, &res) < 0)
1702 memcpy(((char *) hdr) + n, &res, 4);
1705 fprintf(stderr, "[struct exec: magic: %o version %u Mach %o\n",
1706 hdr->a_magic, hdr->a_toolversion, hdr->a_machtype);
1707 fprintf(stderr, "Text %lu Data %lu Bss %lu Syms %lu Entry %#lx]\n",
1708 hdr->a_text, hdr->a_data, hdr->a_bss, hdr->a_syms, hdr->a_entry);
1714 fixvfork(struct tcb *tcp)
1718 * Change `vfork' in a freshly exec'ed dynamically linked
1719 * executable's (internal) symbol table to plain old `fork'
1723 struct link_dynamic dyn;
1724 struct link_dynamic_2 ld;
1727 if (getex(tcp, &hdr) < 0)
1732 if (umove(tcp, (int) N_DATADDR(hdr), &dyn) < 0) {
1733 fprintf(stderr, "Cannot read DYNAMIC\n");
1736 if (umove(tcp, (int) dyn.ld_un.ld_2, &ld) < 0) {
1737 fprintf(stderr, "Cannot read link_dynamic_2\n");
1740 strtab = malloc((unsigned)ld.ld_symb_size);
1742 die_out_of_memory();
1743 if (umoven(tcp, (int)ld.ld_symbols+(int)N_TXTADDR(hdr),
1744 (int)ld.ld_symb_size, strtab) < 0)
1747 for (cp = strtab; cp < strtab + ld.ld_symb_size; ) {
1748 if (strcmp(cp, "_vfork") == 0) {
1750 fprintf(stderr, "fixvfork: FOUND _vfork\n");
1751 strcpy(cp, "_fork");
1756 if (cp < strtab + ld.ld_symb_size)
1758 * Write entire symbol table back to avoid
1759 * memory alignment bugs in ptrace
1761 if (tload(pid, (int)ld.ld_symbols+(int)N_TXTADDR(hdr),
1762 (int)ld.ld_symb_size, strtab) < 0)