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 * Generic ptrace wrapper which tracks ESRCH errors
169 * by setting tcp->ptrace_errno to ESRCH.
171 * We assume that ESRCH indicates likely process death (SIGKILL?),
172 * modulo bugs where process somehow ended up not stopped.
173 * Unfortunately kernel uses ESRCH for that case too. Oh well.
175 * Currently used by upeek() only.
176 * TODO: use this in all other ptrace() calls while decoding.
179 do_ptrace(int request, struct tcb *tcp, void *addr, void *data)
184 l = ptrace(request, tcp->pid, addr, (long) data);
185 /* Non-ESRCH errors might be our invalid reg/mem accesses,
186 * we do not record them. */
188 tcp->ptrace_errno = ESRCH;
193 * Used when we want to unblock stopped traced process.
194 * Should be only used with PTRACE_CONT, PTRACE_DETACH and PTRACE_SYSCALL.
195 * Returns 0 on success or if error was ESRCH
196 * (presumably process was killed while we talk to it).
197 * Otherwise prints error message and returns -1.
200 ptrace_restart(int op, struct tcb *tcp, int sig)
206 ptrace(op, tcp->pid, (void *) 1, (long) sig);
208 if (!err || err == ESRCH)
211 tcp->ptrace_errno = err;
213 if (op == PTRACE_CONT)
215 if (op == PTRACE_DETACH)
217 fprintf(stderr, "strace: ptrace(PTRACE_%s,1,%d): %s\n",
218 msg, sig, strerror(err));
223 * Print entry in struct xlat table, if there.
226 printxval(const struct xlat *xlat, int val, const char *dflt)
228 const char *str = xlookup(xlat, val);
233 tprintf("%#x /* %s */", val, dflt);
238 * Print 64bit argument at position llarg and return the index of the next
242 printllval(struct tcb *tcp, const char *format, int llarg)
244 # if defined(FREEBSD) \
245 || (defined(LINUX) && defined(POWERPC) && !defined(POWERPC64)) \
246 || defined(LINUX_MIPSO32) \
247 || defined(__ARM_EABI__)
248 /* Align 64bit argument to 64bit boundary. */
249 llarg = (llarg + 1) & 0x1e;
251 # if defined LINUX && (defined X86_64 || defined POWERPC64)
252 if (current_personality == 0) {
253 tprintf(format, tcp->u_arg[llarg]);
257 /* Align 64bit argument to 64bit boundary. */
258 llarg = (llarg + 1) & 0x1e;
260 tprintf(format, LONG_LONG(tcp->u_arg[llarg], tcp->u_arg[llarg + 1]));
263 # elif defined IA64 || defined ALPHA
264 tprintf(format, tcp->u_arg[llarg]);
266 # elif defined LINUX_MIPSN32
267 tprintf(format, tcp->ext_arg[llarg]);
270 tprintf(format, LONG_LONG(tcp->u_arg[llarg], tcp->u_arg[llarg + 1]));
278 * Interpret `xlat' as an array of flags
279 * print the entries whose bits are on in `flags'
280 * return # of flags printed.
283 addflags(const struct xlat *xlat, int flags)
285 for (; xlat->str; xlat++) {
286 if (xlat->val && (flags & xlat->val) == xlat->val) {
287 tprintf("|%s", xlat->str);
292 tprintf("|%#x", flags);
297 * Interpret `xlat' as an array of flags.
298 * Print to static string the entries whose bits are on in `flags'
299 * Return static string.
302 sprintflags(const char *prefix, const struct xlat *xlat, int flags)
304 static char outstr[1024];
307 strcpy(outstr, prefix);
309 for (; xlat->str; xlat++) {
310 if ((flags & xlat->val) == xlat->val) {
313 strcat(outstr, xlat->str);
321 sprintf(outstr + strlen(outstr), "%#x", flags);
328 printflags(const struct xlat *xlat, int flags, const char *dflt)
333 if (flags == 0 && xlat->val == 0) {
334 tprintf("%s", xlat->str);
339 for (n = 0; xlat->str; xlat++) {
340 if (xlat->val && (flags & xlat->val) == xlat->val) {
341 tprintf("%s%s", sep, xlat->str);
350 tprintf("%s%#x", sep, flags);
355 tprintf("%#x", flags);
357 tprintf(" /* %s */", dflt);
368 printnum(struct tcb *tcp, long addr, const char *fmt)
376 if (umove(tcp, addr, &num) < 0) {
377 tprintf("%#lx", addr);
386 printnum_int(struct tcb *tcp, long addr, const char *fmt)
394 if (umove(tcp, addr, &num) < 0) {
395 tprintf("%#lx", addr);
404 printfd(struct tcb *tcp, int fd)
408 if (show_fd_path && (p = getfdpath(tcp, fd)))
409 tprintf("%d<%s>", fd, p);
415 printuid(const char *text, unsigned long uid)
418 tprintf((uid == -1) ? "%ld" : "%lu", uid);
421 static char path[MAXPATHLEN + 1];
424 * Quote string `instr' of length `size'
425 * Write up to (3 + `size' * 4) bytes to `outstr' buffer.
426 * If `len' < 0, treat `instr' as a NUL-terminated string
427 * and quote at most (`size' - 1) bytes.
430 string_quote(const char *instr, char *outstr, int len, int size)
432 const unsigned char *ustr = (const unsigned char *) instr;
434 int usehex = 0, c, i;
439 /* Check for presence of symbol which require
440 to hex-quote the whole string. */
441 for (i = 0; i < size; ++i) {
443 /* Check for NUL-terminated string. */
447 /* Quote at most size - 1 bytes. */
451 if (!isprint(c) && !isspace(c)) {
461 /* Hex-quote the whole string. */
462 for (i = 0; i < size; ++i) {
464 /* Check for NUL-terminated string. */
468 /* Quote at most size - 1 bytes. */
472 sprintf(s, "\\x%02x", c);
476 for (i = 0; i < size; ++i) {
478 /* Check for NUL-terminated string. */
482 /* Quote at most size - 1 bytes. */
487 case '\"': case '\\':
514 else if (i + 1 < size
515 && isdigit(ustr[i + 1])) {
516 sprintf(s, "\\%03o", c);
519 sprintf(s, "\\%o", c);
530 /* Return nonzero if the string was unterminated. */
535 * Print path string specified by address `addr' and length `n'.
536 * If path length exceeds `n', append `...' to the output.
539 printpathn(struct tcb *tcp, long addr, int n)
546 /* Cap path length to the path buffer size,
547 and NUL-terminate the buffer. */
548 if (n > sizeof path - 1)
552 /* Fetch one byte more to find out whether path length > n. */
553 if (umovestr(tcp, addr, n + 1, path) < 0)
554 tprintf("%#lx", addr);
556 static char outstr[4*(sizeof path - 1) + sizeof "\"...\""];
557 int trunc = (path[n] != '\0');
561 (void) string_quote(path, outstr, -1, n + 1);
563 strcat(outstr, "...");
564 tprintf("%s", outstr);
569 printpath(struct tcb *tcp, long addr)
571 printpathn(tcp, addr, sizeof path - 1);
575 * Print string specified by address `addr' and length `len'.
576 * If `len' < 0, treat the string as a NUL-terminated string.
577 * If string length exceeds `max_strlen', append `...' to the output.
580 printstr(struct tcb *tcp, long addr, int len)
582 static char *str = NULL;
590 /* Allocate static buffers if they are not allocated yet. */
592 str = malloc(max_strlen + 1);
594 outstr = malloc(4 * max_strlen + sizeof "\"...\"");
595 if (!str || !outstr) {
596 fprintf(stderr, "out of memory\n");
597 tprintf("%#lx", addr);
603 * Treat as a NUL-terminated string: fetch one byte more
604 * because string_quote() quotes one byte less.
606 size = max_strlen + 1;
607 str[max_strlen] = '\0';
608 if (umovestr(tcp, addr, size, str) < 0) {
609 tprintf("%#lx", addr);
614 size = MIN(len, max_strlen);
615 if (umoven(tcp, addr, size, str) < 0) {
616 tprintf("%#lx", addr);
621 if (string_quote(str, outstr, len, size) &&
622 (len < 0 || len > max_strlen))
623 strcat(outstr, "...");
625 tprintf("%s", outstr);
630 dumpiov(struct tcb *tcp, int len, long addr)
632 #if defined(LINUX) && SUPPORTED_PERSONALITIES > 1
634 struct { u_int32_t base; u_int32_t len; } *iov32;
635 struct { u_int64_t base; u_int64_t len; } *iov64;
637 #define iov iovu.iov64
639 (personality_wordsize[current_personality] == 4 \
640 ? sizeof(*iovu.iov32) : sizeof(*iovu.iov64))
641 #define iov_iov_base(i) \
642 (personality_wordsize[current_personality] == 4 \
643 ? (u_int64_t) iovu.iov32[i].base : iovu.iov64[i].base)
644 #define iov_iov_len(i) \
645 (personality_wordsize[current_personality] == 4 \
646 ? (u_int64_t) iovu.iov32[i].len : iovu.iov64[i].len)
649 #define sizeof_iov sizeof(*iov)
650 #define iov_iov_base(i) iov[i].iov_base
651 #define iov_iov_len(i) iov[i].iov_len
656 size = sizeof_iov * (unsigned long) len;
657 if (size / sizeof_iov != len
658 || (iov = malloc(size)) == NULL) {
659 fprintf(stderr, "out of memory\n");
662 if (umoven(tcp, addr, size, (char *) iov) >= 0) {
663 for (i = 0; i < len; i++) {
664 /* include the buffer number to make it easy to
665 * match up the trace with the source */
666 tprintf(" * %lu bytes in buffer %d\n",
667 (unsigned long)iov_iov_len(i), i);
668 dumpstr(tcp, (long) iov_iov_base(i),
681 dumpstr(struct tcb *tcp, long addr, int len)
683 static int strsize = -1;
684 static unsigned char *str;
685 static char outstr[80];
693 fprintf(stderr, "out of memory\n");
694 /* BUG! On next call we may use NULL str! */
700 if (umoven(tcp, addr, len, (char *) str) < 0)
703 for (i = 0; i < len; i += 16) {
705 sprintf(s, " | %05x ", i);
707 for (j = 0; j < 16; j++) {
711 sprintf(s, " %02x", str[i + j]);
715 *s++ = ' '; *s++ = ' '; *s++ = ' ';
718 *s++ = ' '; *s++ = ' ';
719 for (j = 0; j < 16; j++) {
723 if (isprint(str[i + j]))
731 tprintf("%s |\n", outstr);
735 #define PAGMASK (~(PAGSIZ - 1))
737 * move `len' bytes of data from process `pid'
738 * at address `addr' to our space at `laddr'
741 umoven(struct tcb *tcp, long addr, int len, char *laddr)
749 char x[sizeof(long)];
752 if (addr & (sizeof(long) - 1)) {
753 /* addr not a multiple of sizeof(long) */
754 n = addr - (addr & -sizeof(long)); /* residue */
755 addr &= -sizeof(long); /* residue */
757 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
759 if (started && (errno==EPERM || errno==EIO)) {
760 /* Ran into 'end of memory' - stupid "printpath" */
763 /* But if not started, we had a bogus address. */
764 if (addr != 0 && errno != EIO && errno != ESRCH)
765 perror("ptrace: umoven");
769 memcpy(laddr, &u.x[n], m = MIN(sizeof(long) - n, len));
770 addr += sizeof(long), laddr += m, len -= m;
774 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
776 if (started && (errno==EPERM || errno==EIO)) {
777 /* Ran into 'end of memory' - stupid "printpath" */
780 if (addr != 0 && errno != EIO && errno != ESRCH)
781 perror("ptrace: umoven");
785 memcpy(laddr, u.x, m = MIN(sizeof(long), len));
786 addr += sizeof(long), laddr += m, len -= m;
795 n = MIN(len, PAGSIZ);
796 n = MIN(n, ((addr + PAGSIZ) & PAGMASK) - addr);
797 if (ptrace(PTRACE_READDATA, pid,
798 (char *) addr, len, laddr) < 0) {
799 if (errno != ESRCH) {
800 perror("umoven: ptrace(PTRACE_READDATA, ...)");
812 #ifdef HAVE_MP_PROCFS
813 int fd = tcp->pfd_as;
817 lseek(fd, addr, SEEK_SET);
818 if (read(fd, laddr, len) == -1)
820 #endif /* USE_PROCFS */
826 * like `umove' but make the additional effort of looking
827 * for a terminating zero byte.
830 umovestr(struct tcb *tcp, long addr, int len, char *laddr)
833 #ifdef HAVE_MP_PROCFS
834 int fd = tcp->pfd_as;
838 /* Some systems (e.g. FreeBSD) can be upset if we read off the
839 end of valid memory, avoid this by trying to read up
840 to page boundaries. But we don't know what a page is (and
841 getpagesize(2) (if it exists) doesn't necessarily return
842 hardware page size). Assume all pages >= 1024 (a-historical
845 int page = 1024; /* How to find this? */
846 int move = page - (addr & (page - 1));
849 lseek(fd, addr, SEEK_SET);
854 move = read(fd, laddr, move);
856 return left != len ? 0 : -1;
857 if (memchr(laddr, 0, move))
864 #else /* !USE_PROCFS */
870 char x[sizeof(long)];
873 if (addr & (sizeof(long) - 1)) {
874 /* addr not a multiple of sizeof(long) */
875 n = addr - (addr & -sizeof(long)); /* residue */
876 addr &= -sizeof(long); /* residue */
878 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
880 if (started && (errno==EPERM || errno==EIO)) {
881 /* Ran into 'end of memory' - stupid "printpath" */
884 if (addr != 0 && errno != EIO && errno != ESRCH)
889 memcpy(laddr, &u.x[n], m = MIN(sizeof(long)-n, len));
890 while (n & (sizeof(long) - 1))
891 if (u.x[n++] == '\0')
893 addr += sizeof(long), laddr += m, len -= m;
897 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
899 if (started && (errno==EPERM || errno==EIO)) {
900 /* Ran into 'end of memory' - stupid "printpath" */
903 if (addr != 0 && errno != EIO && errno != ESRCH)
908 memcpy(laddr, u.x, m = MIN(sizeof(long), len));
909 for (i = 0; i < sizeof(long); i++)
913 addr += sizeof(long), laddr += m, len -= m;
915 #endif /* !USE_PROCFS */
920 # if !defined (SPARC) && !defined(SPARC64)
921 # define PTRACE_WRITETEXT 101
922 # define PTRACE_WRITEDATA 102
923 # endif /* !SPARC && !SPARC64 */
929 uload(int cmd, int pid, long addr, int len, char *laddr)
935 char x[sizeof(long)];
938 if (cmd == PTRACE_WRITETEXT) {
939 peek = PTRACE_PEEKTEXT;
940 poke = PTRACE_POKETEXT;
943 peek = PTRACE_PEEKDATA;
944 poke = PTRACE_POKEDATA;
946 if (addr & (sizeof(long) - 1)) {
947 /* addr not a multiple of sizeof(long) */
948 n = addr - (addr & -sizeof(long)); /* residue */
949 addr &= -sizeof(long);
951 u.val = ptrace(peek, pid, (char *) addr, 0);
953 perror("uload: POKE");
956 memcpy(&u.x[n], laddr, m = MIN(sizeof(long) - n, len));
957 if (ptrace(poke, pid, (char *)addr, u.val) < 0) {
958 perror("uload: POKE");
961 addr += sizeof(long), laddr += m, len -= m;
964 if (len < sizeof(long))
965 u.val = ptrace(peek, pid, (char *) addr, 0);
966 memcpy(u.x, laddr, m = MIN(sizeof(long), len));
967 if (ptrace(poke, pid, (char *) addr, u.val) < 0) {
968 perror("uload: POKE");
971 addr += sizeof(long), laddr += m, len -= m;
977 tload(int pid, int addr, int len, char *laddr)
979 return uload(PTRACE_WRITETEXT, pid, addr, len, laddr);
983 dload(int pid, int addr, int len, char *laddr)
985 return uload(PTRACE_WRITEDATA, pid, addr, len, laddr);
993 upeek(struct tcb *tcp, long off, long *res)
997 # ifdef SUNOS4_KERNEL_ARCH_KLUDGE
999 static int is_sun4m = -1;
1000 struct utsname name;
1002 /* Round up the usual suspects. */
1003 if (is_sun4m == -1) {
1004 if (uname(&name) < 0) {
1005 perror("upeek: uname?");
1008 is_sun4m = strcmp(name.machine, "sun4m") == 0;
1010 const struct xlat *x;
1012 for (x = struct_user_offsets; x->str; x++)
1019 # endif /* SUNOS4_KERNEL_ARCH_KLUDGE */
1021 val = do_ptrace(PTRACE_PEEKUSER, tcp, (char *) off, 0);
1022 if (val == -1 && errno) {
1023 if (errno != ESRCH) {
1025 sprintf(buf, "upeek: ptrace(PTRACE_PEEKUSER,%d,%lu,0)", tcp->pid, off);
1034 #endif /* !USE_PROCFS */
1037 printcall(struct tcb *tcp)
1039 #define PRINTBADPC tprintf(sizeof(long) == 4 ? "[????????] " : \
1040 sizeof(long) == 8 ? "[????????????????] " : \
1047 if (upeek(tcp, 4*EIP, &eip) < 0) {
1051 tprintf("[%08lx] ", eip);
1053 # elif defined(S390) || defined(S390X)
1055 if (upeek(tcp, PT_PSWADDR, &psw) < 0) {
1060 tprintf("[%08lx] ", psw);
1062 tprintf("[%16lx] ", psw);
1065 # elif defined(X86_64)
1068 if (upeek(tcp, 8*RIP, &rip) < 0) {
1072 tprintf("[%16lx] ", rip);
1073 # elif defined(IA64)
1076 if (upeek(tcp, PT_B0, &ip) < 0) {
1080 tprintf("[%08lx] ", ip);
1081 # elif defined(POWERPC)
1084 if (upeek(tcp, sizeof(unsigned long)*PT_NIP, &pc) < 0) {
1089 tprintf("[%016lx] ", pc);
1091 tprintf("[%08lx] ", pc);
1093 # elif defined(M68K)
1096 if (upeek(tcp, 4*PT_PC, &pc) < 0) {
1097 tprintf("[????????] ");
1100 tprintf("[%08lx] ", pc);
1101 # elif defined(ALPHA)
1104 if (upeek(tcp, REG_PC, &pc) < 0) {
1105 tprintf("[????????????????] ");
1108 tprintf("[%08lx] ", pc);
1109 # elif defined(SPARC) || defined(SPARC64)
1110 struct pt_regs regs;
1111 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) {
1115 # if defined(SPARC64)
1116 tprintf("[%08lx] ", regs.tpc);
1118 tprintf("[%08lx] ", regs.pc);
1120 # elif defined(HPPA)
1123 if (upeek(tcp, PT_IAOQ0, &pc) < 0) {
1124 tprintf("[????????] ");
1127 tprintf("[%08lx] ", pc);
1128 # elif defined(MIPS)
1131 if (upeek(tcp, REG_EPC, &pc) < 0) {
1132 tprintf("[????????] ");
1135 tprintf("[%08lx] ", pc);
1139 if (upeek(tcp, 4*REG_PC, &pc) < 0) {
1140 tprintf("[????????] ");
1143 tprintf("[%08lx] ", pc);
1144 # elif defined(SH64)
1147 if (upeek(tcp, REG_PC, &pc) < 0) {
1148 tprintf("[????????????????] ");
1151 tprintf("[%08lx] ", pc);
1155 if (upeek(tcp, 4*15, &pc) < 0) {
1159 tprintf("[%08lx] ", pc);
1160 # elif defined(AVR32)
1163 if (upeek(tcp, REG_PC, &pc) < 0) {
1164 tprintf("[????????] ");
1167 tprintf("[%08lx] ", pc);
1168 # elif defined(BFIN)
1171 if (upeek(tcp, PT_PC, &pc) < 0) {
1175 tprintf("[%08lx] ", pc);
1176 #elif defined(CRISV10)
1179 if (upeek(tcp, 4*PT_IRP, &pc) < 0) {
1183 tprintf("[%08lx] ", pc);
1184 #elif defined(CRISV32)
1187 if (upeek(tcp, 4*PT_ERP, &pc) < 0) {
1191 tprintf("[%08lx] ", pc);
1192 # endif /* architecture */
1198 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *) ®s, 0) < 0) {
1199 perror("printcall: ptrace(PTRACE_GETREGS, ...)");
1203 tprintf("[%08x] ", regs.r_o7);
1213 pread(tcp->pfd_reg, ®s, sizeof(regs), 0);
1214 tprintf("[%08x] ", regs.r_eip);
1215 #endif /* FREEBSD */
1220 * These #if's are huge, please indent them correctly.
1221 * It's easy to get confused otherwise.
1227 # include "syscall.h"
1229 # include <sys/syscall.h>
1230 # ifndef CLONE_PTRACE
1231 # define CLONE_PTRACE 0x00002000
1233 # ifndef CLONE_VFORK
1234 # define CLONE_VFORK 0x00004000
1237 # define CLONE_VM 0x00000100
1239 # ifndef CLONE_STOPPED
1240 # define CLONE_STOPPED 0x02000000
1245 /* We don't have fork()/vfork() syscalls on ia64 itself, but the ia32
1246 subsystem has them for x86... */
1248 # define SYS_vfork 190
1250 typedef unsigned long *arg_setup_state;
1253 arg_setup(struct tcb *tcp, arg_setup_state *state)
1255 unsigned long cfm, sof, sol;
1259 /* Satisfy a false GCC warning. */
1264 if (upeek(tcp, PT_AR_BSP, &bsp) < 0)
1266 if (upeek(tcp, PT_CFM, (long *) &cfm) < 0)
1269 sof = (cfm >> 0) & 0x7f;
1270 sol = (cfm >> 7) & 0x7f;
1271 bsp = (long) ia64_rse_skip_regs((unsigned long *) bsp, -sof + sol);
1273 *state = (unsigned long *) bsp;
1277 # define arg_finish_change(tcp, state) 0
1281 get_arg0(struct tcb *tcp, arg_setup_state *state, long *valp)
1286 ret = upeek(tcp, PT_R11, valp);
1289 (unsigned long) ia64_rse_skip_regs(*state, 0),
1290 sizeof(long), (void *) valp);
1295 get_arg1(struct tcb *tcp, arg_setup_state *state, long *valp)
1300 ret = upeek(tcp, PT_R9, valp);
1303 (unsigned long) ia64_rse_skip_regs(*state, 1),
1304 sizeof(long), (void *) valp);
1310 set_arg0(struct tcb *tcp, arg_setup_state *state, long val)
1312 int req = PTRACE_POKEDATA;
1316 ap = (void *) (intptr_t) PT_R11; /* r11 == EBX */
1317 req = PTRACE_POKEUSER;
1319 ap = ia64_rse_skip_regs(*state, 0);
1321 ptrace(req, tcp->pid, ap, val);
1322 return errno ? -1 : 0;
1326 set_arg1(struct tcb *tcp, arg_setup_state *state, long val)
1328 int req = PTRACE_POKEDATA;
1332 ap = (void *) (intptr_t) PT_R9; /* r9 == ECX */
1333 req = PTRACE_POKEUSER;
1335 ap = ia64_rse_skip_regs(*state, 1);
1337 ptrace(req, tcp->pid, ap, val);
1338 return errno ? -1 : 0;
1341 /* ia64 does not return the input arguments from functions (and syscalls)
1342 according to ia64 RSE (Register Stack Engine) behavior. */
1344 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1345 # define restore_arg1(tcp, state, val) ((void) (state), 0)
1347 # elif defined (SPARC) || defined (SPARC64)
1349 typedef struct pt_regs arg_setup_state;
1351 # define arg_setup(tcp, state) \
1352 (ptrace(PTRACE_GETREGS, tcp->pid, (char *) (state), 0))
1353 # define arg_finish_change(tcp, state) \
1354 (ptrace(PTRACE_SETREGS, tcp->pid, (char *) (state), 0))
1356 # define get_arg0(tcp, state, valp) (*(valp) = (state)->u_regs[U_REG_O0], 0)
1357 # define get_arg1(tcp, state, valp) (*(valp) = (state)->u_regs[U_REG_O1], 0)
1358 # define set_arg0(tcp, state, val) ((state)->u_regs[U_REG_O0] = (val), 0)
1359 # define set_arg1(tcp, state, val) ((state)->u_regs[U_REG_O1] = (val), 0)
1360 # define restore_arg0(tcp, state, val) 0
1362 # else /* other architectures */
1364 # if defined S390 || defined S390X
1365 /* Note: this is only true for the `clone' system call, which handles
1366 arguments specially. We could as well say that its first two arguments
1367 are swapped relative to other architectures, but that would just be
1368 another #ifdef in the calls. */
1369 # define arg0_offset PT_GPR3
1370 # define arg1_offset PT_ORIGGPR2
1371 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1372 # define restore_arg1(tcp, state, val) ((void) (state), 0)
1373 # define arg0_index 1
1374 # define arg1_index 0
1375 # elif defined (ALPHA) || defined (MIPS)
1376 # define arg0_offset REG_A0
1377 # define arg1_offset (REG_A0+1)
1378 # elif defined (AVR32)
1379 # define arg0_offset (REG_R12)
1380 # define arg1_offset (REG_R11)
1381 # elif defined (POWERPC)
1382 # define arg0_offset (sizeof(unsigned long)*PT_R3)
1383 # define arg1_offset (sizeof(unsigned long)*PT_R4)
1384 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1385 # elif defined (HPPA)
1386 # define arg0_offset PT_GR26
1387 # define arg1_offset (PT_GR26-4)
1388 # elif defined (X86_64)
1389 # define arg0_offset ((long)(8*(current_personality ? RBX : RDI)))
1390 # define arg1_offset ((long)(8*(current_personality ? RCX : RSI)))
1392 # define arg0_offset (4*(REG_REG0+4))
1393 # define arg1_offset (4*(REG_REG0+5))
1394 # elif defined (SH64)
1395 /* ABI defines arg0 & 1 in r2 & r3 */
1396 # define arg0_offset (REG_OFFSET+16)
1397 # define arg1_offset (REG_OFFSET+24)
1398 # define restore_arg0(tcp, state, val) 0
1399 # elif defined CRISV10 || defined CRISV32
1400 # define arg0_offset (4*PT_R11)
1401 # define arg1_offset (4*PT_ORIG_R10)
1402 # define restore_arg0(tcp, state, val) 0
1403 # define restore_arg1(tcp, state, val) 0
1404 # define arg0_index 1
1405 # define arg1_index 0
1407 # define arg0_offset 0
1408 # define arg1_offset 4
1410 # define restore_arg0(tcp, state, val) 0
1414 typedef int arg_setup_state;
1416 # define arg_setup(tcp, state) (0)
1417 # define arg_finish_change(tcp, state) 0
1418 # define get_arg0(tcp, cookie, valp) \
1419 (upeek((tcp), arg0_offset, (valp)))
1420 # define get_arg1(tcp, cookie, valp) \
1421 (upeek((tcp), arg1_offset, (valp)))
1424 set_arg0(struct tcb *tcp, void *cookie, long val)
1426 return ptrace(PTRACE_POKEUSER, tcp->pid, (char*)arg0_offset, val);
1430 set_arg1(struct tcb *tcp, void *cookie, long val)
1432 return ptrace(PTRACE_POKEUSER, tcp->pid, (char*)arg1_offset, val);
1435 # endif /* architectures */
1437 # ifndef restore_arg0
1438 # define restore_arg0(tcp, state, val) set_arg0((tcp), (state), (val))
1440 # ifndef restore_arg1
1441 # define restore_arg1(tcp, state, val) set_arg1((tcp), (state), (val))
1445 # define arg0_index 0
1446 # define arg1_index 1
1450 setbpt(struct tcb *tcp)
1452 static int clone_scno[SUPPORTED_PERSONALITIES] = { SYS_clone };
1453 arg_setup_state state;
1455 if (tcp->flags & TCB_BPTSET) {
1456 fprintf(stderr, "PANIC: TCB already set in pid %u\n", tcp->pid);
1461 * It's a silly kludge to initialize this with a search at runtime.
1462 * But it's better than maintaining another magic thing in the
1463 * godforsaken tables.
1465 if (clone_scno[current_personality] == 0) {
1467 for (i = 0; i < nsyscalls; ++i)
1468 if (sysent[i].sys_func == sys_clone) {
1469 clone_scno[current_personality] = i;
1474 switch (known_scno(tcp)) {
1481 # if defined SYS_fork || defined SYS_vfork
1482 if (arg_setup(tcp, &state) < 0
1483 || get_arg0(tcp, &state, &tcp->inst[0]) < 0
1484 || get_arg1(tcp, &state, &tcp->inst[1]) < 0
1485 || change_syscall(tcp, clone_scno[current_personality]) < 0
1486 || set_arg0(tcp, &state, CLONE_PTRACE|SIGCHLD) < 0
1487 || set_arg1(tcp, &state, 0) < 0
1488 || arg_finish_change(tcp, &state) < 0)
1490 tcp->u_arg[arg0_index] = CLONE_PTRACE|SIGCHLD;
1491 tcp->u_arg[arg1_index] = 0;
1492 tcp->flags |= TCB_BPTSET;
1500 /* ia64 calls directly `clone (CLONE_VFORK | CLONE_VM)'
1501 contrary to x86 SYS_vfork above. Even on x86 we turn the
1502 vfork semantics into plain fork - each application must not
1503 depend on the vfork specifics according to POSIX. We would
1504 hang waiting for the parent resume otherwise. We need to
1505 clear also CLONE_VM but only in the CLONE_VFORK case as
1506 otherwise we would break pthread_create. */
1508 long new_arg0 = (tcp->u_arg[arg0_index] | CLONE_PTRACE);
1509 if (new_arg0 & CLONE_VFORK)
1510 new_arg0 &= ~(unsigned long)(CLONE_VFORK | CLONE_VM);
1511 if (arg_setup(tcp, &state) < 0
1512 || set_arg0(tcp, &state, new_arg0) < 0
1513 || arg_finish_change(tcp, &state) < 0)
1515 tcp->flags |= TCB_BPTSET;
1516 tcp->inst[0] = tcp->u_arg[arg0_index];
1517 tcp->inst[1] = tcp->u_arg[arg1_index];
1521 fprintf(stderr, "PANIC: setbpt for syscall %ld on %u???\n",
1522 tcp->scno, tcp->pid);
1530 clearbpt(struct tcb *tcp)
1532 arg_setup_state state;
1533 if (arg_setup(tcp, &state) < 0
1534 || restore_arg0(tcp, &state, tcp->inst[0]) < 0
1535 || restore_arg1(tcp, &state, tcp->inst[1]) < 0
1536 || arg_finish_change(tcp, &state))
1539 tcp->flags &= ~TCB_BPTSET;
1543 # else /* !defined LINUX */
1546 setbpt(struct tcb *tcp)
1549 # ifdef SPARC /* This code is slightly sparc specific */
1552 # define BPT 0x91d02001 /* ta 1 */
1553 # define LOOP 0x10800000 /* ba 0 */
1554 # define LOOPA 0x30800000 /* ba,a 0 */
1555 # define NOP 0x01000000
1557 static int loopdeloop[1] = {LOOPA};
1559 static int loopdeloop[2] = {LOOP, NOP};
1562 if (tcp->flags & TCB_BPTSET) {
1563 fprintf(stderr, "PANIC: TCB already set in pid %u\n", tcp->pid);
1566 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) {
1567 perror("setbpt: ptrace(PTRACE_GETREGS, ...)");
1570 tcp->baddr = regs.r_o7 + 8;
1571 if (ptrace(PTRACE_READTEXT, tcp->pid, (char *)tcp->baddr,
1572 sizeof tcp->inst, (char *)tcp->inst) < 0) {
1573 perror("setbpt: ptrace(PTRACE_READTEXT, ...)");
1578 * XXX - BRUTAL MODE ON
1579 * We cannot set a real BPT in the child, since it will not be
1580 * traced at the moment it will reach the trap and would probably
1581 * die with a core dump.
1582 * Thus, we are force our way in by taking out two instructions
1583 * and insert an eternal loop in stead, in expectance of the SIGSTOP
1584 * generated by out PTRACE_ATTACH.
1585 * Of cause, if we evaporate ourselves in the middle of all this...
1587 if (ptrace(PTRACE_WRITETEXT, tcp->pid, (char *) tcp->baddr,
1588 sizeof loopdeloop, (char *) loopdeloop) < 0) {
1589 perror("setbpt: ptrace(PTRACE_WRITETEXT, ...)");
1592 tcp->flags |= TCB_BPTSET;
1595 # endif /* SUNOS4 */
1601 clearbpt(struct tcb *tcp)
1610 if (!(tcp->flags & TCB_BPTSET)) {
1611 fprintf(stderr, "PANIC: TCB not set in pid %u\n", tcp->pid);
1614 if (ptrace(PTRACE_WRITETEXT, tcp->pid, (char *) tcp->baddr,
1615 sizeof tcp->inst, (char *) tcp->inst) < 0) {
1616 perror("clearbtp: ptrace(PTRACE_WRITETEXT, ...)");
1619 tcp->flags &= ~TCB_BPTSET;
1623 * Since we don't have a single instruction breakpoint, we may have
1624 * to adjust the program counter after removing our `breakpoint'.
1626 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) {
1627 perror("clearbpt: ptrace(PTRACE_GETREGS, ...)");
1630 if ((regs.r_pc < tcp->baddr) ||
1631 (regs.r_pc > tcp->baddr + 4)) {
1632 /* The breakpoint has not been reached yet */
1635 "NOTE: PC not at bpt (pc %#x baddr %#x)\n",
1636 regs.r_pc, tcp->baddr);
1639 if (regs.r_pc != tcp->baddr)
1641 fprintf(stderr, "NOTE: PC adjusted (%#x -> %#x\n",
1642 regs.r_pc, tcp->baddr);
1644 regs.r_pc = tcp->baddr;
1645 if (ptrace(PTRACE_SETREGS, tcp->pid, (char *)®s, 0) < 0) {
1646 perror("clearbpt: ptrace(PTRACE_SETREGS, ...)");
1651 # endif /* SUNOS4 */
1656 # endif /* !defined LINUX */
1658 #endif /* !USE_PROCFS */
1664 getex(struct tcb *tcp, struct exec *hdr)
1668 for (n = 0; n < sizeof *hdr; n += 4) {
1670 if (upeek(tcp, uoff(u_exdata) + n, &res) < 0)
1672 memcpy(((char *) hdr) + n, &res, 4);
1675 fprintf(stderr, "[struct exec: magic: %o version %u Mach %o\n",
1676 hdr->a_magic, hdr->a_toolversion, hdr->a_machtype);
1677 fprintf(stderr, "Text %lu Data %lu Bss %lu Syms %lu Entry %#lx]\n",
1678 hdr->a_text, hdr->a_data, hdr->a_bss, hdr->a_syms, hdr->a_entry);
1684 fixvfork(struct tcb *tcp)
1688 * Change `vfork' in a freshly exec'ed dynamically linked
1689 * executable's (internal) symbol table to plain old `fork'
1693 struct link_dynamic dyn;
1694 struct link_dynamic_2 ld;
1697 if (getex(tcp, &hdr) < 0)
1702 if (umove(tcp, (int) N_DATADDR(hdr), &dyn) < 0) {
1703 fprintf(stderr, "Cannot read DYNAMIC\n");
1706 if (umove(tcp, (int) dyn.ld_un.ld_2, &ld) < 0) {
1707 fprintf(stderr, "Cannot read link_dynamic_2\n");
1710 strtab = malloc((unsigned)ld.ld_symb_size);
1711 if (strtab == NULL) {
1712 fprintf(stderr, "out of memory\n");
1715 if (umoven(tcp, (int)ld.ld_symbols+(int)N_TXTADDR(hdr),
1716 (int)ld.ld_symb_size, strtab) < 0)
1719 for (cp = strtab; cp < strtab + ld.ld_symb_size; ) {
1720 if (strcmp(cp, "_vfork") == 0) {
1722 fprintf(stderr, "fixvfork: FOUND _vfork\n");
1723 strcpy(cp, "_fork");
1728 if (cp < strtab + ld.ld_symb_size)
1730 * Write entire symbol table back to avoid
1731 * memory alignment bugs in ptrace
1733 if (tload(pid, (int)ld.ld_symbols+(int)N_TXTADDR(hdr),
1734 (int)ld.ld_symb_size, strtab) < 0)