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))
100 return a->tv_sec || a->tv_usec;
105 struct timeval *a, *b;
107 if (a->tv_sec < b->tv_sec
108 || (a->tv_sec == b->tv_sec && a->tv_usec < b->tv_usec))
110 if (a->tv_sec > b->tv_sec
111 || (a->tv_sec == b->tv_sec && a->tv_usec > b->tv_usec))
120 return tv->tv_sec + tv->tv_usec/1000000.0;
125 struct timeval *tv, *a, *b;
127 tv->tv_sec = a->tv_sec + b->tv_sec;
128 tv->tv_usec = a->tv_usec + b->tv_usec;
129 if (tv->tv_usec >= 1000000) {
131 tv->tv_usec -= 1000000;
137 struct timeval *tv, *a, *b;
139 tv->tv_sec = a->tv_sec - b->tv_sec;
140 tv->tv_usec = a->tv_usec - b->tv_usec;
141 if (((long) tv->tv_usec) < 0) {
143 tv->tv_usec += 1000000;
149 struct timeval *tv, *a;
152 tv->tv_usec = (a->tv_sec % n * 1000000 + a->tv_usec + n / 2) / n;
153 tv->tv_sec = a->tv_sec / n + tv->tv_usec / 1000000;
154 tv->tv_usec %= 1000000;
159 struct timeval *tv, *a;
162 tv->tv_usec = a->tv_usec * n;
163 tv->tv_sec = a->tv_sec * n + tv->tv_usec / 1000000;
164 tv->tv_usec %= 1000000;
168 xlookup(const struct xlat *xlat, int val)
170 for (; xlat->str != NULL; xlat++)
171 if (xlat->val == val)
177 * Generic ptrace wrapper which tracks ESRCH errors
178 * by setting tcp->ptrace_errno to ESRCH.
180 * We assume that ESRCH indicates likely process death (SIGKILL?),
181 * modulo bugs where process somehow ended up not stopped.
182 * Unfortunately kernel uses ESRCH for that case too. Oh well.
184 * Currently used by upeek() only.
185 * TODO: use this in all other ptrace() calls while decoding.
188 do_ptrace(int request, struct tcb *tcp, void *addr, void *data)
193 l = ptrace(request, tcp->pid, addr, (long) data);
194 /* Non-ESRCH errors might be our invalid reg/mem accesses,
195 * we do not record them. */
197 tcp->ptrace_errno = ESRCH;
202 * Used when we want to unblock stopped traced process.
203 * Should be only used with PTRACE_CONT, PTRACE_DETACH and PTRACE_SYSCALL.
204 * Returns 0 on success or if error was ESRCH
205 * (presumably process was killed while we talk to it).
206 * Otherwise prints error message and returns -1.
209 ptrace_restart(int op, struct tcb *tcp, int sig)
215 ptrace(op, tcp->pid, (void *) 1, (long) sig);
217 if (!err || err == ESRCH)
220 tcp->ptrace_errno = err;
222 if (op == PTRACE_CONT)
224 if (op == PTRACE_DETACH)
226 fprintf(stderr, "strace: ptrace(PTRACE_%s,1,%d): %s\n",
227 msg, sig, strerror(err));
232 * Print entry in struct xlat table, if there.
235 printxval(const struct xlat *xlat, int val, const char *dflt)
237 const char *str = xlookup(xlat, val);
242 tprintf("%#x /* %s */", val, dflt);
247 * Print 64bit argument at position llarg and return the index of the next
251 printllval(struct tcb *tcp, const char *format, int llarg)
253 # if defined(FREEBSD) \
254 || (defined(LINUX) && defined(POWERPC) && !defined(POWERPC64)) \
255 || defined (LINUX_MIPSO32)
256 /* Align 64bit argument to 64bit boundary. */
257 if (llarg % 2) llarg++;
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 if (llarg % 2) llarg++;
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(xlat, flags)
292 const struct xlat *xlat;
297 for (n = 0; xlat->str; xlat++) {
298 if (xlat->val && (flags & xlat->val) == xlat->val) {
299 tprintf("|%s", xlat->str);
305 tprintf("|%#x", flags);
312 * Interpret `xlat' as an array of flags/
313 * Print to static string the entries whose bits are on in `flags'
314 * Return static string.
317 sprintflags(const char *prefix, const struct xlat *xlat, int flags)
319 static char outstr[1024];
322 strcpy(outstr, prefix);
324 for (; xlat->str; xlat++) {
325 if ((flags & xlat->val) == xlat->val) {
328 strcat(outstr, xlat->str);
336 sprintf(outstr + strlen(outstr), "%#x", flags);
343 printflags(const struct xlat *xlat, int flags, const char *dflt)
348 if (flags == 0 && xlat->val == 0) {
349 tprintf("%s", xlat->str);
354 for (n = 0; xlat->str; xlat++) {
355 if (xlat->val && (flags & xlat->val) == xlat->val) {
356 tprintf("%s%s", sep, xlat->str);
365 tprintf("%s%#x", sep, flags);
370 tprintf("%#x", flags);
372 tprintf(" /* %s */", dflt);
383 printnum(struct tcb *tcp, long addr, const char *fmt)
391 if (umove(tcp, addr, &num) < 0) {
392 tprintf("%#lx", addr);
401 printnum_int(struct tcb *tcp, long addr, const char *fmt)
409 if (umove(tcp, addr, &num) < 0) {
410 tprintf("%#lx", addr);
424 tprintf((uid == -1) ? "%ld" : "%lu", uid);
427 static char path[MAXPATHLEN + 1];
430 * Quote string `instr' of length `size'
431 * Write up to (3 + `size' * 4) bytes to `outstr' buffer.
432 * If `len' < 0, treat `instr' as a NUL-terminated string
433 * and quote at most (`size' - 1) bytes.
436 string_quote(const char *instr, char *outstr, int len, int size)
438 const unsigned char *ustr = (const unsigned char *) instr;
440 int usehex = 0, c, i;
445 /* Check for presence of symbol which require
446 to hex-quote the whole string. */
447 for (i = 0; i < size; ++i) {
449 /* Check for NUL-terminated string. */
453 /* Quote at most size - 1 bytes. */
457 if (!isprint(c) && !isspace(c)) {
467 /* Hex-quote the whole string. */
468 for (i = 0; i < size; ++i) {
470 /* Check for NUL-terminated string. */
474 /* Quote at most size - 1 bytes. */
478 sprintf(s, "\\x%02x", c);
482 for (i = 0; i < size; ++i) {
484 /* Check for NUL-terminated string. */
488 /* Quote at most size - 1 bytes. */
493 case '\"': case '\\':
520 else if (i + 1 < size
521 && isdigit(ustr[i + 1])) {
522 sprintf(s, "\\%03o", c);
525 sprintf(s, "\\%o", c);
536 /* Return nonzero if the string was unterminated. */
541 * Print path string specified by address `addr' and length `n'.
542 * If path length exceeds `n', append `...' to the output.
545 printpathn(struct tcb *tcp, long addr, int n)
552 /* Cap path length to the path buffer size,
553 and NUL-terminate the buffer. */
554 if (n > sizeof path - 1)
558 /* Fetch one byte more to find out whether path length > n. */
559 if (umovestr(tcp, addr, n + 1, path) < 0)
560 tprintf("%#lx", addr);
562 static char outstr[4*(sizeof path - 1) + sizeof "\"...\""];
563 int trunc = (path[n] != '\0');
567 (void) string_quote(path, outstr, -1, n + 1);
569 strcat(outstr, "...");
570 tprintf("%s", outstr);
575 printpath(struct tcb *tcp, long addr)
577 printpathn(tcp, addr, sizeof path - 1);
581 * Print string specified by address `addr' and length `len'.
582 * If `len' < 0, treat the string as a NUL-terminated string.
583 * If string length exceeds `max_strlen', append `...' to the output.
586 printstr(struct tcb *tcp, long addr, int len)
588 static char *str = NULL;
596 /* Allocate static buffers if they are not allocated yet. */
598 str = malloc(max_strlen + 1);
600 outstr = malloc(4 * max_strlen + sizeof "\"...\"");
601 if (!str || !outstr) {
602 fprintf(stderr, "out of memory\n");
603 tprintf("%#lx", addr);
609 * Treat as a NUL-terminated string: fetch one byte more
610 * because string_quote() quotes one byte less.
612 size = max_strlen + 1;
613 str[max_strlen] = '\0';
614 if (umovestr(tcp, addr, size, str) < 0) {
615 tprintf("%#lx", addr);
620 size = MIN(len, max_strlen);
621 if (umoven(tcp, addr, size, str) < 0) {
622 tprintf("%#lx", addr);
627 if (string_quote(str, outstr, len, size) &&
628 (len < 0 || len > max_strlen))
629 strcat(outstr, "...");
631 tprintf("%s", outstr);
636 dumpiov(tcp, len, addr)
641 #if defined(LINUX) && SUPPORTED_PERSONALITIES > 1
643 struct { u_int32_t base; u_int32_t len; } *iov32;
644 struct { u_int64_t base; u_int64_t len; } *iov64;
646 #define iov iovu.iov64
648 (personality_wordsize[current_personality] == 4 \
649 ? sizeof(*iovu.iov32) : sizeof(*iovu.iov64))
650 #define iov_iov_base(i) \
651 (personality_wordsize[current_personality] == 4 \
652 ? (u_int64_t) iovu.iov32[i].base : iovu.iov64[i].base)
653 #define iov_iov_len(i) \
654 (personality_wordsize[current_personality] == 4 \
655 ? (u_int64_t) iovu.iov32[i].len : iovu.iov64[i].len)
658 #define sizeof_iov sizeof(*iov)
659 #define iov_iov_base(i) iov[i].iov_base
660 #define iov_iov_len(i) iov[i].iov_len
665 size = sizeof_iov * (unsigned long) len;
666 if (size / sizeof_iov != len
667 || (iov = malloc(size)) == NULL) {
668 fprintf(stderr, "out of memory\n");
671 if (umoven(tcp, addr, size, (char *) iov) >= 0) {
672 for (i = 0; i < len; i++) {
673 /* include the buffer number to make it easy to
674 * match up the trace with the source */
675 tprintf(" * %lu bytes in buffer %d\n",
676 (unsigned long)iov_iov_len(i), i);
677 dumpstr(tcp, (long) iov_iov_base(i),
690 dumpstr(tcp, addr, len)
695 static int strsize = -1;
696 static unsigned char *str;
697 static char outstr[80];
704 if ((str = malloc(len)) == NULL) {
705 fprintf(stderr, "out of memory\n");
711 if (umoven(tcp, addr, len, (char *) str) < 0)
714 for (i = 0; i < len; i += 16) {
716 sprintf(s, " | %05x ", i);
718 for (j = 0; j < 16; j++) {
722 sprintf(s, " %02x", str[i + j]);
726 *s++ = ' '; *s++ = ' '; *s++ = ' ';
729 *s++ = ' '; *s++ = ' ';
730 for (j = 0; j < 16; j++) {
734 if (isprint(str[i + j]))
742 tprintf("%s |\n", outstr);
746 #define PAGMASK (~(PAGSIZ - 1))
748 * move `len' bytes of data from process `pid'
749 * at address `addr' to our space at `laddr'
752 umoven(struct tcb *tcp, long addr, int len, char *laddr)
760 char x[sizeof(long)];
763 if (addr & (sizeof(long) - 1)) {
764 /* addr not a multiple of sizeof(long) */
765 n = addr - (addr & -sizeof(long)); /* residue */
766 addr &= -sizeof(long); /* residue */
768 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
770 if (started && (errno==EPERM || errno==EIO)) {
771 /* Ran into 'end of memory' - stupid "printpath" */
774 /* But if not started, we had a bogus address. */
775 if (addr != 0 && errno != EIO && errno != ESRCH)
776 perror("ptrace: umoven");
780 memcpy(laddr, &u.x[n], m = MIN(sizeof(long) - n, len));
781 addr += sizeof(long), laddr += m, len -= m;
785 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
787 if (started && (errno==EPERM || errno==EIO)) {
788 /* Ran into 'end of memory' - stupid "printpath" */
791 if (addr != 0 && errno != EIO && errno != ESRCH)
792 perror("ptrace: umoven");
796 memcpy(laddr, u.x, m = MIN(sizeof(long), len));
797 addr += sizeof(long), laddr += m, len -= m;
806 n = MIN(len, PAGSIZ);
807 n = MIN(n, ((addr + PAGSIZ) & PAGMASK) - addr);
808 if (ptrace(PTRACE_READDATA, pid,
809 (char *) addr, len, laddr) < 0) {
810 if (errno != ESRCH) {
811 perror("umoven: ptrace(PTRACE_READDATA, ...)");
823 #ifdef HAVE_MP_PROCFS
824 int fd = tcp->pfd_as;
828 lseek(fd, addr, SEEK_SET);
829 if (read(fd, laddr, len) == -1)
831 #endif /* USE_PROCFS */
837 * like `umove' but make the additional effort of looking
838 * for a terminating zero byte.
841 umovestr(struct tcb *tcp, long addr, int len, char *laddr)
844 #ifdef HAVE_MP_PROCFS
845 int fd = tcp->pfd_as;
849 /* Some systems (e.g. FreeBSD) can be upset if we read off the
850 end of valid memory, avoid this by trying to read up
851 to page boundaries. But we don't know what a page is (and
852 getpagesize(2) (if it exists) doesn't necessarily return
853 hardware page size). Assume all pages >= 1024 (a-historical
856 int page = 1024; /* How to find this? */
857 int move = page - (addr & (page - 1));
860 lseek(fd, addr, SEEK_SET);
863 if (move > left) move = left;
864 if ((move = read(fd, laddr, move)) <= 0)
865 return left != len ? 0 : -1;
866 if (memchr (laddr, 0, move)) break;
872 #else /* !USE_PROCFS */
878 char x[sizeof(long)];
881 if (addr & (sizeof(long) - 1)) {
882 /* addr not a multiple of sizeof(long) */
883 n = addr - (addr & -sizeof(long)); /* residue */
884 addr &= -sizeof(long); /* residue */
886 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
888 if (started && (errno==EPERM || errno==EIO)) {
889 /* Ran into 'end of memory' - stupid "printpath" */
892 if (addr != 0 && errno != EIO && errno != ESRCH)
897 memcpy(laddr, &u.x[n], m = MIN(sizeof(long)-n,len));
898 while (n & (sizeof(long) - 1))
899 if (u.x[n++] == '\0')
901 addr += sizeof(long), laddr += m, len -= m;
905 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
907 if (started && (errno==EPERM || errno==EIO)) {
908 /* Ran into 'end of memory' - stupid "printpath" */
911 if (addr != 0 && errno != EIO && errno != ESRCH)
916 memcpy(laddr, u.x, m = MIN(sizeof(long), len));
917 for (i = 0; i < sizeof(long); i++)
921 addr += sizeof(long), laddr += m, len -= m;
923 #endif /* !USE_PROCFS */
928 # if !defined (SPARC) && !defined(SPARC64)
929 # define PTRACE_WRITETEXT 101
930 # define PTRACE_WRITEDATA 102
931 # endif /* !SPARC && !SPARC64 */
937 uload(cmd, pid, addr, len, laddr)
948 char x[sizeof(long)];
951 if (cmd == PTRACE_WRITETEXT) {
952 peek = PTRACE_PEEKTEXT;
953 poke = PTRACE_POKETEXT;
956 peek = PTRACE_PEEKDATA;
957 poke = PTRACE_POKEDATA;
959 if (addr & (sizeof(long) - 1)) {
960 /* addr not a multiple of sizeof(long) */
961 n = addr - (addr & -sizeof(long)); /* residue */
962 addr &= -sizeof(long);
964 u.val = ptrace(peek, pid, (char *) addr, 0);
966 perror("uload: POKE");
969 memcpy(&u.x[n], laddr, m = MIN(sizeof(long) - n, len));
970 if (ptrace(poke, pid, (char *)addr, u.val) < 0) {
971 perror("uload: POKE");
974 addr += sizeof(long), laddr += m, len -= m;
977 if (len < sizeof(long))
978 u.val = ptrace(peek, pid, (char *) addr, 0);
979 memcpy(u.x, laddr, m = MIN(sizeof(long), len));
980 if (ptrace(poke, pid, (char *) addr, u.val) < 0) {
981 perror("uload: POKE");
984 addr += sizeof(long), laddr += m, len -= m;
990 tload(pid, addr, len, laddr)
995 return uload(PTRACE_WRITETEXT, pid, addr, len, laddr);
999 dload(pid, addr, len, laddr)
1005 return uload(PTRACE_WRITEDATA, pid, addr, len, laddr);
1013 upeek(tcp, off, res)
1020 # ifdef SUNOS4_KERNEL_ARCH_KLUDGE
1022 static int is_sun4m = -1;
1023 struct utsname name;
1025 /* Round up the usual suspects. */
1026 if (is_sun4m == -1) {
1027 if (uname(&name) < 0) {
1028 perror("upeek: uname?");
1031 is_sun4m = strcmp(name.machine, "sun4m") == 0;
1033 const struct xlat *x;
1035 for (x = struct_user_offsets; x->str; x++)
1042 # endif /* SUNOS4_KERNEL_ARCH_KLUDGE */
1044 val = do_ptrace(PTRACE_PEEKUSER, tcp, (char *) off, 0);
1045 if (val == -1 && errno) {
1046 if (errno != ESRCH) {
1048 sprintf(buf,"upeek: ptrace(PTRACE_PEEKUSER,%d,%lu,0)", tcp->pid, off);
1057 #endif /* !USE_PROCFS */
1060 printcall(struct tcb *tcp)
1062 #define PRINTBADPC tprintf(sizeof(long) == 4 ? "[????????] " : \
1063 sizeof(long) == 8 ? "[????????????????] " : \
1070 if (upeek(tcp, 4*EIP, &eip) < 0) {
1074 tprintf("[%08lx] ", eip);
1076 # elif defined(S390) || defined(S390X)
1078 if(upeek(tcp,PT_PSWADDR,&psw) < 0) {
1083 tprintf("[%08lx] ", psw);
1085 tprintf("[%16lx] ", psw);
1088 # elif defined(X86_64)
1091 if (upeek(tcp, 8*RIP, &rip) < 0) {
1095 tprintf("[%16lx] ", rip);
1096 # elif defined(IA64)
1099 if (upeek(tcp, PT_B0, &ip) < 0) {
1103 tprintf("[%08lx] ", ip);
1104 # elif defined(POWERPC)
1107 if (upeek(tcp, sizeof(unsigned long)*PT_NIP, &pc) < 0) {
1112 tprintf("[%016lx] ", pc);
1114 tprintf("[%08lx] ", pc);
1116 # elif defined(M68K)
1119 if (upeek(tcp, 4*PT_PC, &pc) < 0) {
1120 tprintf ("[????????] ");
1123 tprintf("[%08lx] ", pc);
1124 # elif defined(ALPHA)
1127 if (upeek(tcp, REG_PC, &pc) < 0) {
1128 tprintf ("[????????????????] ");
1131 tprintf("[%08lx] ", pc);
1132 # elif defined(SPARC) || defined(SPARC64)
1133 struct pt_regs regs;
1134 if (ptrace(PTRACE_GETREGS,tcp->pid,(char *)®s,0) < 0) {
1138 # if defined(SPARC64)
1139 tprintf("[%08lx] ", regs.tpc);
1141 tprintf("[%08lx] ", regs.pc);
1143 # elif defined(HPPA)
1146 if(upeek(tcp,PT_IAOQ0,&pc) < 0) {
1147 tprintf ("[????????] ");
1150 tprintf("[%08lx] ", pc);
1151 # elif defined(MIPS)
1154 if (upeek(tcp, REG_EPC, &pc) < 0) {
1155 tprintf ("[????????] ");
1158 tprintf("[%08lx] ", pc);
1162 if (upeek(tcp, 4*REG_PC, &pc) < 0) {
1163 tprintf ("[????????] ");
1166 tprintf("[%08lx] ", pc);
1167 # elif defined(SH64)
1170 if (upeek(tcp, REG_PC, &pc) < 0) {
1171 tprintf ("[????????????????] ");
1174 tprintf("[%08lx] ", pc);
1178 if (upeek(tcp, 4*15, &pc) < 0) {
1182 tprintf("[%08lx] ", pc);
1183 # elif defined(AVR32)
1186 if (upeek(tcp, REG_PC, &pc) < 0) {
1187 tprintf("[????????] ");
1190 tprintf("[%08lx] ", pc);
1191 # elif defined(BFIN)
1194 if (upeek(tcp, PT_PC, &pc) < 0) {
1198 tprintf("[%08lx] ", pc);
1199 #elif defined(CRISV10)
1202 if (upeek(tcp, 4*PT_IRP, &pc) < 0) {
1206 tprintf("[%08lx] ", pc);
1207 #elif defined(CRISV32)
1210 if (upeek(tcp, 4*PT_ERP, &pc) < 0) {
1214 tprintf("[%08lx] ", pc);
1215 # endif /* architecture */
1221 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *) ®s, 0) < 0) {
1222 perror("printcall: ptrace(PTRACE_GETREGS, ...)");
1226 tprintf("[%08x] ", regs.r_o7);
1236 pread(tcp->pfd_reg, ®s, sizeof(regs), 0);
1237 tprintf("[%08x] ", regs.r_eip);
1238 #endif /* FREEBSD */
1243 * These #if's are huge, please indent them correctly.
1244 * It's easy to get confused otherwise.
1250 # include "syscall.h"
1252 # include <sys/syscall.h>
1253 # ifndef CLONE_PTRACE
1254 # define CLONE_PTRACE 0x00002000
1256 # ifndef CLONE_VFORK
1257 # define CLONE_VFORK 0x00004000
1260 # define CLONE_VM 0x00000100
1262 # ifndef CLONE_STOPPED
1263 # define CLONE_STOPPED 0x02000000
1268 /* We don't have fork()/vfork() syscalls on ia64 itself, but the ia32
1269 subsystem has them for x86... */
1271 # define SYS_vfork 190
1273 typedef unsigned long *arg_setup_state;
1276 arg_setup(struct tcb *tcp, arg_setup_state *state)
1278 unsigned long cfm, sof, sol;
1282 /* Satisfy a false GCC warning. */
1287 if (upeek(tcp, PT_AR_BSP, &bsp) < 0)
1289 if (upeek(tcp, PT_CFM, (long *) &cfm) < 0)
1292 sof = (cfm >> 0) & 0x7f;
1293 sol = (cfm >> 7) & 0x7f;
1294 bsp = (long) ia64_rse_skip_regs((unsigned long *) bsp, -sof + sol);
1296 *state = (unsigned long *) bsp;
1300 # define arg_finish_change(tcp, state) 0
1304 get_arg0 (struct tcb *tcp, arg_setup_state *state, long *valp)
1309 ret = upeek (tcp, PT_R11, valp);
1312 (unsigned long) ia64_rse_skip_regs(*state, 0),
1313 sizeof(long), (void *) valp);
1318 get_arg1 (struct tcb *tcp, arg_setup_state *state, long *valp)
1323 ret = upeek (tcp, PT_R9, valp);
1326 (unsigned long) ia64_rse_skip_regs(*state, 1),
1327 sizeof(long), (void *) valp);
1333 set_arg0 (struct tcb *tcp, arg_setup_state *state, long val)
1335 int req = PTRACE_POKEDATA;
1339 ap = (void *) (intptr_t) PT_R11; /* r11 == EBX */
1340 req = PTRACE_POKEUSER;
1342 ap = ia64_rse_skip_regs(*state, 0);
1344 ptrace(req, tcp->pid, ap, val);
1345 return errno ? -1 : 0;
1349 set_arg1 (struct tcb *tcp, arg_setup_state *state, long val)
1351 int req = PTRACE_POKEDATA;
1355 ap = (void *) (intptr_t) PT_R9; /* r9 == ECX */
1356 req = PTRACE_POKEUSER;
1358 ap = ia64_rse_skip_regs(*state, 1);
1360 ptrace(req, tcp->pid, ap, val);
1361 return errno ? -1 : 0;
1364 /* ia64 does not return the input arguments from functions (and syscalls)
1365 according to ia64 RSE (Register Stack Engine) behavior. */
1367 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1368 # define restore_arg1(tcp, state, val) ((void) (state), 0)
1370 # elif defined (SPARC) || defined (SPARC64)
1372 typedef struct pt_regs arg_setup_state;
1374 # define arg_setup(tcp, state) \
1375 (ptrace (PTRACE_GETREGS, tcp->pid, (char *) (state), 0))
1376 # define arg_finish_change(tcp, state) \
1377 (ptrace (PTRACE_SETREGS, tcp->pid, (char *) (state), 0))
1379 # define get_arg0(tcp, state, valp) (*(valp) = (state)->u_regs[U_REG_O0], 0)
1380 # define get_arg1(tcp, state, valp) (*(valp) = (state)->u_regs[U_REG_O1], 0)
1381 # define set_arg0(tcp, state, val) ((state)->u_regs[U_REG_O0] = (val), 0)
1382 # define set_arg1(tcp, state, val) ((state)->u_regs[U_REG_O1] = (val), 0)
1383 # define restore_arg0(tcp, state, val) 0
1385 # else /* other architectures */
1387 # if defined S390 || defined S390X
1388 /* Note: this is only true for the `clone' system call, which handles
1389 arguments specially. We could as well say that its first two arguments
1390 are swapped relative to other architectures, but that would just be
1391 another #ifdef in the calls. */
1392 # define arg0_offset PT_GPR3
1393 # define arg1_offset PT_ORIGGPR2
1394 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1395 # define restore_arg1(tcp, state, val) ((void) (state), 0)
1396 # define arg0_index 1
1397 # define arg1_index 0
1398 # elif defined (ALPHA) || defined (MIPS)
1399 # define arg0_offset REG_A0
1400 # define arg1_offset (REG_A0+1)
1401 # elif defined (AVR32)
1402 # define arg0_offset (REG_R12)
1403 # define arg1_offset (REG_R11)
1404 # elif defined (POWERPC)
1405 # define arg0_offset (sizeof(unsigned long)*PT_R3)
1406 # define arg1_offset (sizeof(unsigned long)*PT_R4)
1407 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1408 # elif defined (HPPA)
1409 # define arg0_offset PT_GR26
1410 # define arg1_offset (PT_GR26-4)
1411 # elif defined (X86_64)
1412 # define arg0_offset ((long)(8*(current_personality ? RBX : RDI)))
1413 # define arg1_offset ((long)(8*(current_personality ? RCX : RSI)))
1415 # define arg0_offset (4*(REG_REG0+4))
1416 # define arg1_offset (4*(REG_REG0+5))
1417 # elif defined (SH64)
1418 /* ABI defines arg0 & 1 in r2 & r3 */
1419 # define arg0_offset (REG_OFFSET+16)
1420 # define arg1_offset (REG_OFFSET+24)
1421 # define restore_arg0(tcp, state, val) 0
1422 # elif defined CRISV10 || defined CRISV32
1423 # define arg0_offset (4*PT_R11)
1424 # define arg1_offset (4*PT_ORIG_R10)
1425 # define restore_arg0(tcp, state, val) 0
1426 # define restore_arg1(tcp, state, val) 0
1427 # define arg0_index 1
1428 # define arg1_index 0
1430 # define arg0_offset 0
1431 # define arg1_offset 4
1433 # define restore_arg0(tcp, state, val) 0
1437 typedef int arg_setup_state;
1439 # define arg_setup(tcp, state) (0)
1440 # define arg_finish_change(tcp, state) 0
1441 # define get_arg0(tcp, cookie, valp) \
1442 (upeek ((tcp), arg0_offset, (valp)))
1443 # define get_arg1(tcp, cookie, valp) \
1444 (upeek ((tcp), arg1_offset, (valp)))
1447 set_arg0 (struct tcb *tcp, void *cookie, long val)
1449 return ptrace (PTRACE_POKEUSER, tcp->pid, (char*)arg0_offset, val);
1453 set_arg1 (struct tcb *tcp, void *cookie, long val)
1455 return ptrace (PTRACE_POKEUSER, tcp->pid, (char*)arg1_offset, val);
1458 # endif /* architectures */
1460 # ifndef restore_arg0
1461 # define restore_arg0(tcp, state, val) set_arg0((tcp), (state), (val))
1463 # ifndef restore_arg1
1464 # define restore_arg1(tcp, state, val) set_arg1((tcp), (state), (val))
1468 # define arg0_index 0
1469 # define arg1_index 1
1473 setbpt(struct tcb *tcp)
1475 static int clone_scno[SUPPORTED_PERSONALITIES] = { SYS_clone };
1476 arg_setup_state state;
1478 if (tcp->flags & TCB_BPTSET) {
1479 fprintf(stderr, "PANIC: TCB already set in pid %u\n", tcp->pid);
1484 * It's a silly kludge to initialize this with a search at runtime.
1485 * But it's better than maintaining another magic thing in the
1486 * godforsaken tables.
1488 if (clone_scno[current_personality] == 0) {
1490 for (i = 0; i < nsyscalls; ++i)
1491 if (sysent[i].sys_func == sys_clone) {
1492 clone_scno[current_personality] = i;
1497 switch (known_scno(tcp)) {
1504 # if defined SYS_fork || defined SYS_vfork
1505 if (arg_setup (tcp, &state) < 0
1506 || get_arg0 (tcp, &state, &tcp->inst[0]) < 0
1507 || get_arg1 (tcp, &state, &tcp->inst[1]) < 0
1508 || change_syscall(tcp, clone_scno[current_personality]) < 0
1509 || set_arg0 (tcp, &state, CLONE_PTRACE|SIGCHLD) < 0
1510 || set_arg1 (tcp, &state, 0) < 0
1511 || arg_finish_change (tcp, &state) < 0)
1513 tcp->u_arg[arg0_index] = CLONE_PTRACE|SIGCHLD;
1514 tcp->u_arg[arg1_index] = 0;
1515 tcp->flags |= TCB_BPTSET;
1523 /* ia64 calls directly `clone (CLONE_VFORK | CLONE_VM)'
1524 contrary to x86 SYS_vfork above. Even on x86 we turn the
1525 vfork semantics into plain fork - each application must not
1526 depend on the vfork specifics according to POSIX. We would
1527 hang waiting for the parent resume otherwise. We need to
1528 clear also CLONE_VM but only in the CLONE_VFORK case as
1529 otherwise we would break pthread_create. */
1531 if ((arg_setup (tcp, &state) < 0
1532 || set_arg0 (tcp, &state,
1533 (tcp->u_arg[arg0_index] | CLONE_PTRACE)
1534 & ~(tcp->u_arg[arg0_index] & CLONE_VFORK
1535 ? CLONE_VFORK | CLONE_VM : 0)) < 0
1536 || arg_finish_change (tcp, &state) < 0))
1538 tcp->flags |= TCB_BPTSET;
1539 tcp->inst[0] = tcp->u_arg[arg0_index];
1540 tcp->inst[1] = tcp->u_arg[arg1_index];
1544 fprintf(stderr, "PANIC: setbpt for syscall %ld on %u???\n",
1545 tcp->scno, tcp->pid);
1556 arg_setup_state state;
1557 if (arg_setup (tcp, &state) < 0
1558 || restore_arg0 (tcp, &state, tcp->inst[0]) < 0
1559 || restore_arg1 (tcp, &state, tcp->inst[1]) < 0
1560 || arg_finish_change (tcp, &state))
1561 if (errno != ESRCH) return -1;
1562 tcp->flags &= ~TCB_BPTSET;
1566 # else /* !defined LINUX */
1573 # ifdef SPARC /* This code is slightly sparc specific */
1576 # define BPT 0x91d02001 /* ta 1 */
1577 # define LOOP 0x10800000 /* ba 0 */
1578 # define LOOPA 0x30800000 /* ba,a 0 */
1579 # define NOP 0x01000000
1581 static int loopdeloop[1] = {LOOPA};
1583 static int loopdeloop[2] = {LOOP, NOP};
1586 if (tcp->flags & TCB_BPTSET) {
1587 fprintf(stderr, "PANIC: TCB already set in pid %u\n", tcp->pid);
1590 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) {
1591 perror("setbpt: ptrace(PTRACE_GETREGS, ...)");
1594 tcp->baddr = regs.r_o7 + 8;
1595 if (ptrace(PTRACE_READTEXT, tcp->pid, (char *)tcp->baddr,
1596 sizeof tcp->inst, (char *)tcp->inst) < 0) {
1597 perror("setbpt: ptrace(PTRACE_READTEXT, ...)");
1602 * XXX - BRUTAL MODE ON
1603 * We cannot set a real BPT in the child, since it will not be
1604 * traced at the moment it will reach the trap and would probably
1605 * die with a core dump.
1606 * Thus, we are force our way in by taking out two instructions
1607 * and insert an eternal loop in stead, in expectance of the SIGSTOP
1608 * generated by out PTRACE_ATTACH.
1609 * Of cause, if we evaporate ourselves in the middle of all this...
1611 if (ptrace(PTRACE_WRITETEXT, tcp->pid, (char *) tcp->baddr,
1612 sizeof loopdeloop, (char *) loopdeloop) < 0) {
1613 perror("setbpt: ptrace(PTRACE_WRITETEXT, ...)");
1616 tcp->flags |= TCB_BPTSET;
1619 # endif /* SUNOS4 */
1635 if (!(tcp->flags & TCB_BPTSET)) {
1636 fprintf(stderr, "PANIC: TCB not set in pid %u\n", tcp->pid);
1639 if (ptrace(PTRACE_WRITETEXT, tcp->pid, (char *) tcp->baddr,
1640 sizeof tcp->inst, (char *) tcp->inst) < 0) {
1641 perror("clearbtp: ptrace(PTRACE_WRITETEXT, ...)");
1644 tcp->flags &= ~TCB_BPTSET;
1648 * Since we don't have a single instruction breakpoint, we may have
1649 * to adjust the program counter after removing our `breakpoint'.
1651 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) {
1652 perror("clearbpt: ptrace(PTRACE_GETREGS, ...)");
1655 if ((regs.r_pc < tcp->baddr) ||
1656 (regs.r_pc > tcp->baddr + 4)) {
1657 /* The breakpoint has not been reached yet */
1660 "NOTE: PC not at bpt (pc %#x baddr %#x)\n",
1661 regs.r_pc, tcp->baddr);
1664 if (regs.r_pc != tcp->baddr)
1666 fprintf(stderr, "NOTE: PC adjusted (%#x -> %#x\n",
1667 regs.r_pc, tcp->baddr);
1669 regs.r_pc = tcp->baddr;
1670 if (ptrace(PTRACE_SETREGS, tcp->pid, (char *)®s, 0) < 0) {
1671 perror("clearbpt: ptrace(PTRACE_SETREGS, ...)");
1676 # endif /* SUNOS4 */
1681 # endif /* !defined LINUX */
1683 #endif /* !USE_PROCFS */
1695 for (n = 0; n < sizeof *hdr; n += 4) {
1697 if (upeek(tcp, uoff(u_exdata) + n, &res) < 0)
1699 memcpy(((char *) hdr) + n, &res, 4);
1702 fprintf(stderr, "[struct exec: magic: %o version %u Mach %o\n",
1703 hdr->a_magic, hdr->a_toolversion, hdr->a_machtype);
1704 fprintf(stderr, "Text %lu Data %lu Bss %lu Syms %lu Entry %#lx]\n",
1705 hdr->a_text, hdr->a_data, hdr->a_bss, hdr->a_syms, hdr->a_entry);
1716 * Change `vfork' in a freshly exec'ed dynamically linked
1717 * executable's (internal) symbol table to plain old `fork'
1721 struct link_dynamic dyn;
1722 struct link_dynamic_2 ld;
1725 if (getex(tcp, &hdr) < 0)
1730 if (umove(tcp, (int) N_DATADDR(hdr), &dyn) < 0) {
1731 fprintf(stderr, "Cannot read DYNAMIC\n");
1734 if (umove(tcp, (int) dyn.ld_un.ld_2, &ld) < 0) {
1735 fprintf(stderr, "Cannot read link_dynamic_2\n");
1738 if ((strtab = malloc((unsigned)ld.ld_symb_size)) == NULL) {
1739 fprintf(stderr, "out of memory\n");
1742 if (umoven(tcp, (int)ld.ld_symbols+(int)N_TXTADDR(hdr),
1743 (int)ld.ld_symb_size, strtab) < 0)
1746 for (cp = strtab; cp < strtab + ld.ld_symb_size; ) {
1747 if (strcmp(cp, "_vfork") == 0) {
1749 fprintf(stderr, "fixvfork: FOUND _vfork\n");
1750 strcpy(cp, "_fork");
1755 if (cp < strtab + ld.ld_symb_size)
1757 * Write entire symbol table back to avoid
1758 * memory alignment bugs in ptrace
1760 if (tload(pid, (int)ld.ld_symbols+(int)N_TXTADDR(hdr),
1761 (int)ld.ld_symb_size, strtab) < 0)