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 if (llarg % 2) llarg++;
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 if (llarg % 2) llarg++;
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)
287 for (n = 0; xlat->str; xlat++) {
288 if (xlat->val && (flags & xlat->val) == xlat->val) {
289 tprintf("|%s", xlat->str);
295 tprintf("|%#x", flags);
302 * Interpret `xlat' as an array of flags/
303 * Print to static string the entries whose bits are on in `flags'
304 * Return static string.
307 sprintflags(const char *prefix, const struct xlat *xlat, int flags)
309 static char outstr[1024];
312 strcpy(outstr, prefix);
314 for (; xlat->str; xlat++) {
315 if ((flags & xlat->val) == xlat->val) {
318 strcat(outstr, xlat->str);
326 sprintf(outstr + strlen(outstr), "%#x", flags);
333 printflags(const struct xlat *xlat, int flags, const char *dflt)
338 if (flags == 0 && xlat->val == 0) {
339 tprintf("%s", xlat->str);
344 for (n = 0; xlat->str; xlat++) {
345 if (xlat->val && (flags & xlat->val) == xlat->val) {
346 tprintf("%s%s", sep, xlat->str);
355 tprintf("%s%#x", sep, flags);
360 tprintf("%#x", flags);
362 tprintf(" /* %s */", dflt);
373 printnum(struct tcb *tcp, long addr, const char *fmt)
381 if (umove(tcp, addr, &num) < 0) {
382 tprintf("%#lx", addr);
391 printnum_int(struct tcb *tcp, long addr, const char *fmt)
399 if (umove(tcp, addr, &num) < 0) {
400 tprintf("%#lx", addr);
409 printfd(struct tcb *tcp, int fd)
413 if (show_fd_path && (p = getfdpath(tcp, fd)))
414 tprintf("%d<%s>", fd, p);
420 printuid(const char *text, unsigned long uid)
423 tprintf((uid == -1) ? "%ld" : "%lu", uid);
426 static char path[MAXPATHLEN + 1];
429 * Quote string `instr' of length `size'
430 * Write up to (3 + `size' * 4) bytes to `outstr' buffer.
431 * If `len' < 0, treat `instr' as a NUL-terminated string
432 * and quote at most (`size' - 1) bytes.
435 string_quote(const char *instr, char *outstr, int len, int size)
437 const unsigned char *ustr = (const unsigned char *) instr;
439 int usehex = 0, c, i;
444 /* Check for presence of symbol which require
445 to hex-quote the whole string. */
446 for (i = 0; i < size; ++i) {
448 /* Check for NUL-terminated string. */
452 /* Quote at most size - 1 bytes. */
456 if (!isprint(c) && !isspace(c)) {
466 /* Hex-quote the whole string. */
467 for (i = 0; i < size; ++i) {
469 /* Check for NUL-terminated string. */
473 /* Quote at most size - 1 bytes. */
477 sprintf(s, "\\x%02x", c);
481 for (i = 0; i < size; ++i) {
483 /* Check for NUL-terminated string. */
487 /* Quote at most size - 1 bytes. */
492 case '\"': case '\\':
519 else if (i + 1 < size
520 && isdigit(ustr[i + 1])) {
521 sprintf(s, "\\%03o", c);
524 sprintf(s, "\\%o", c);
535 /* Return nonzero if the string was unterminated. */
540 * Print path string specified by address `addr' and length `n'.
541 * If path length exceeds `n', append `...' to the output.
544 printpathn(struct tcb *tcp, long addr, int n)
551 /* Cap path length to the path buffer size,
552 and NUL-terminate the buffer. */
553 if (n > sizeof path - 1)
557 /* Fetch one byte more to find out whether path length > n. */
558 if (umovestr(tcp, addr, n + 1, path) < 0)
559 tprintf("%#lx", addr);
561 static char outstr[4*(sizeof path - 1) + sizeof "\"...\""];
562 int trunc = (path[n] != '\0');
566 (void) string_quote(path, outstr, -1, n + 1);
568 strcat(outstr, "...");
569 tprintf("%s", outstr);
574 printpath(struct tcb *tcp, long addr)
576 printpathn(tcp, addr, sizeof path - 1);
580 * Print string specified by address `addr' and length `len'.
581 * If `len' < 0, treat the string as a NUL-terminated string.
582 * If string length exceeds `max_strlen', append `...' to the output.
585 printstr(struct tcb *tcp, long addr, int len)
587 static char *str = NULL;
595 /* Allocate static buffers if they are not allocated yet. */
597 str = malloc(max_strlen + 1);
599 outstr = malloc(4 * max_strlen + sizeof "\"...\"");
600 if (!str || !outstr) {
601 fprintf(stderr, "out of memory\n");
602 tprintf("%#lx", addr);
608 * Treat as a NUL-terminated string: fetch one byte more
609 * because string_quote() quotes one byte less.
611 size = max_strlen + 1;
612 str[max_strlen] = '\0';
613 if (umovestr(tcp, addr, size, str) < 0) {
614 tprintf("%#lx", addr);
619 size = MIN(len, max_strlen);
620 if (umoven(tcp, addr, size, str) < 0) {
621 tprintf("%#lx", addr);
626 if (string_quote(str, outstr, len, size) &&
627 (len < 0 || len > max_strlen))
628 strcat(outstr, "...");
630 tprintf("%s", outstr);
635 dumpiov(struct tcb *tcp, int len, long addr)
637 #if defined(LINUX) && SUPPORTED_PERSONALITIES > 1
639 struct { u_int32_t base; u_int32_t len; } *iov32;
640 struct { u_int64_t base; u_int64_t len; } *iov64;
642 #define iov iovu.iov64
644 (personality_wordsize[current_personality] == 4 \
645 ? sizeof(*iovu.iov32) : sizeof(*iovu.iov64))
646 #define iov_iov_base(i) \
647 (personality_wordsize[current_personality] == 4 \
648 ? (u_int64_t) iovu.iov32[i].base : iovu.iov64[i].base)
649 #define iov_iov_len(i) \
650 (personality_wordsize[current_personality] == 4 \
651 ? (u_int64_t) iovu.iov32[i].len : iovu.iov64[i].len)
654 #define sizeof_iov sizeof(*iov)
655 #define iov_iov_base(i) iov[i].iov_base
656 #define iov_iov_len(i) iov[i].iov_len
661 size = sizeof_iov * (unsigned long) len;
662 if (size / sizeof_iov != len
663 || (iov = malloc(size)) == NULL) {
664 fprintf(stderr, "out of memory\n");
667 if (umoven(tcp, addr, size, (char *) iov) >= 0) {
668 for (i = 0; i < len; i++) {
669 /* include the buffer number to make it easy to
670 * match up the trace with the source */
671 tprintf(" * %lu bytes in buffer %d\n",
672 (unsigned long)iov_iov_len(i), i);
673 dumpstr(tcp, (long) iov_iov_base(i),
686 dumpstr(struct tcb *tcp, long addr, int len)
688 static int strsize = -1;
689 static unsigned char *str;
690 static char outstr[80];
697 if ((str = malloc(len)) == NULL) {
698 fprintf(stderr, "out of memory\n");
704 if (umoven(tcp, addr, len, (char *) str) < 0)
707 for (i = 0; i < len; i += 16) {
709 sprintf(s, " | %05x ", i);
711 for (j = 0; j < 16; j++) {
715 sprintf(s, " %02x", str[i + j]);
719 *s++ = ' '; *s++ = ' '; *s++ = ' ';
722 *s++ = ' '; *s++ = ' ';
723 for (j = 0; j < 16; j++) {
727 if (isprint(str[i + j]))
735 tprintf("%s |\n", outstr);
739 #define PAGMASK (~(PAGSIZ - 1))
741 * move `len' bytes of data from process `pid'
742 * at address `addr' to our space at `laddr'
745 umoven(struct tcb *tcp, long addr, int len, char *laddr)
753 char x[sizeof(long)];
756 if (addr & (sizeof(long) - 1)) {
757 /* addr not a multiple of sizeof(long) */
758 n = addr - (addr & -sizeof(long)); /* residue */
759 addr &= -sizeof(long); /* residue */
761 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
763 if (started && (errno==EPERM || errno==EIO)) {
764 /* Ran into 'end of memory' - stupid "printpath" */
767 /* But if not started, we had a bogus address. */
768 if (addr != 0 && errno != EIO && errno != ESRCH)
769 perror("ptrace: umoven");
773 memcpy(laddr, &u.x[n], m = MIN(sizeof(long) - n, len));
774 addr += sizeof(long), laddr += m, len -= m;
778 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
780 if (started && (errno==EPERM || errno==EIO)) {
781 /* Ran into 'end of memory' - stupid "printpath" */
784 if (addr != 0 && errno != EIO && errno != ESRCH)
785 perror("ptrace: umoven");
789 memcpy(laddr, u.x, m = MIN(sizeof(long), len));
790 addr += sizeof(long), laddr += m, len -= m;
799 n = MIN(len, PAGSIZ);
800 n = MIN(n, ((addr + PAGSIZ) & PAGMASK) - addr);
801 if (ptrace(PTRACE_READDATA, pid,
802 (char *) addr, len, laddr) < 0) {
803 if (errno != ESRCH) {
804 perror("umoven: ptrace(PTRACE_READDATA, ...)");
816 #ifdef HAVE_MP_PROCFS
817 int fd = tcp->pfd_as;
821 lseek(fd, addr, SEEK_SET);
822 if (read(fd, laddr, len) == -1)
824 #endif /* USE_PROCFS */
830 * like `umove' but make the additional effort of looking
831 * for a terminating zero byte.
834 umovestr(struct tcb *tcp, long addr, int len, char *laddr)
837 #ifdef HAVE_MP_PROCFS
838 int fd = tcp->pfd_as;
842 /* Some systems (e.g. FreeBSD) can be upset if we read off the
843 end of valid memory, avoid this by trying to read up
844 to page boundaries. But we don't know what a page is (and
845 getpagesize(2) (if it exists) doesn't necessarily return
846 hardware page size). Assume all pages >= 1024 (a-historical
849 int page = 1024; /* How to find this? */
850 int move = page - (addr & (page - 1));
853 lseek(fd, addr, SEEK_SET);
856 if (move > left) move = left;
857 if ((move = read(fd, laddr, move)) <= 0)
858 return left != len ? 0 : -1;
859 if (memchr(laddr, 0, move)) break;
865 #else /* !USE_PROCFS */
871 char x[sizeof(long)];
874 if (addr & (sizeof(long) - 1)) {
875 /* addr not a multiple of sizeof(long) */
876 n = addr - (addr & -sizeof(long)); /* residue */
877 addr &= -sizeof(long); /* residue */
879 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
881 if (started && (errno==EPERM || errno==EIO)) {
882 /* Ran into 'end of memory' - stupid "printpath" */
885 if (addr != 0 && errno != EIO && errno != ESRCH)
890 memcpy(laddr, &u.x[n], m = MIN(sizeof(long)-n, len));
891 while (n & (sizeof(long) - 1))
892 if (u.x[n++] == '\0')
894 addr += sizeof(long), laddr += m, len -= m;
898 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
900 if (started && (errno==EPERM || errno==EIO)) {
901 /* Ran into 'end of memory' - stupid "printpath" */
904 if (addr != 0 && errno != EIO && errno != ESRCH)
909 memcpy(laddr, u.x, m = MIN(sizeof(long), len));
910 for (i = 0; i < sizeof(long); i++)
914 addr += sizeof(long), laddr += m, len -= m;
916 #endif /* !USE_PROCFS */
921 # if !defined (SPARC) && !defined(SPARC64)
922 # define PTRACE_WRITETEXT 101
923 # define PTRACE_WRITEDATA 102
924 # endif /* !SPARC && !SPARC64 */
930 uload(int cmd, int pid, long addr, int len, char *laddr)
936 char x[sizeof(long)];
939 if (cmd == PTRACE_WRITETEXT) {
940 peek = PTRACE_PEEKTEXT;
941 poke = PTRACE_POKETEXT;
944 peek = PTRACE_PEEKDATA;
945 poke = PTRACE_POKEDATA;
947 if (addr & (sizeof(long) - 1)) {
948 /* addr not a multiple of sizeof(long) */
949 n = addr - (addr & -sizeof(long)); /* residue */
950 addr &= -sizeof(long);
952 u.val = ptrace(peek, pid, (char *) addr, 0);
954 perror("uload: POKE");
957 memcpy(&u.x[n], laddr, m = MIN(sizeof(long) - n, len));
958 if (ptrace(poke, pid, (char *)addr, u.val) < 0) {
959 perror("uload: POKE");
962 addr += sizeof(long), laddr += m, len -= m;
965 if (len < sizeof(long))
966 u.val = ptrace(peek, pid, (char *) addr, 0);
967 memcpy(u.x, laddr, m = MIN(sizeof(long), len));
968 if (ptrace(poke, pid, (char *) addr, u.val) < 0) {
969 perror("uload: POKE");
972 addr += sizeof(long), laddr += m, len -= m;
978 tload(int pid, int addr, int len, char *laddr)
980 return uload(PTRACE_WRITETEXT, pid, addr, len, laddr);
984 dload(int pid, int addr, int len, char *laddr)
986 return uload(PTRACE_WRITEDATA, pid, addr, len, laddr);
994 upeek(struct tcb *tcp, long off, long *res)
998 # ifdef SUNOS4_KERNEL_ARCH_KLUDGE
1000 static int is_sun4m = -1;
1001 struct utsname name;
1003 /* Round up the usual suspects. */
1004 if (is_sun4m == -1) {
1005 if (uname(&name) < 0) {
1006 perror("upeek: uname?");
1009 is_sun4m = strcmp(name.machine, "sun4m") == 0;
1011 const struct xlat *x;
1013 for (x = struct_user_offsets; x->str; x++)
1020 # endif /* SUNOS4_KERNEL_ARCH_KLUDGE */
1022 val = do_ptrace(PTRACE_PEEKUSER, tcp, (char *) off, 0);
1023 if (val == -1 && errno) {
1024 if (errno != ESRCH) {
1026 sprintf(buf, "upeek: ptrace(PTRACE_PEEKUSER,%d,%lu,0)", tcp->pid, off);
1035 #endif /* !USE_PROCFS */
1038 printcall(struct tcb *tcp)
1040 #define PRINTBADPC tprintf(sizeof(long) == 4 ? "[????????] " : \
1041 sizeof(long) == 8 ? "[????????????????] " : \
1048 if (upeek(tcp, 4*EIP, &eip) < 0) {
1052 tprintf("[%08lx] ", eip);
1054 # elif defined(S390) || defined(S390X)
1056 if (upeek(tcp, PT_PSWADDR, &psw) < 0) {
1061 tprintf("[%08lx] ", psw);
1063 tprintf("[%16lx] ", psw);
1066 # elif defined(X86_64)
1069 if (upeek(tcp, 8*RIP, &rip) < 0) {
1073 tprintf("[%16lx] ", rip);
1074 # elif defined(IA64)
1077 if (upeek(tcp, PT_B0, &ip) < 0) {
1081 tprintf("[%08lx] ", ip);
1082 # elif defined(POWERPC)
1085 if (upeek(tcp, sizeof(unsigned long)*PT_NIP, &pc) < 0) {
1090 tprintf("[%016lx] ", pc);
1092 tprintf("[%08lx] ", pc);
1094 # elif defined(M68K)
1097 if (upeek(tcp, 4*PT_PC, &pc) < 0) {
1098 tprintf("[????????] ");
1101 tprintf("[%08lx] ", pc);
1102 # elif defined(ALPHA)
1105 if (upeek(tcp, REG_PC, &pc) < 0) {
1106 tprintf("[????????????????] ");
1109 tprintf("[%08lx] ", pc);
1110 # elif defined(SPARC) || defined(SPARC64)
1111 struct pt_regs regs;
1112 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) {
1116 # if defined(SPARC64)
1117 tprintf("[%08lx] ", regs.tpc);
1119 tprintf("[%08lx] ", regs.pc);
1121 # elif defined(HPPA)
1124 if (upeek(tcp, PT_IAOQ0, &pc) < 0) {
1125 tprintf("[????????] ");
1128 tprintf("[%08lx] ", pc);
1129 # elif defined(MIPS)
1132 if (upeek(tcp, REG_EPC, &pc) < 0) {
1133 tprintf("[????????] ");
1136 tprintf("[%08lx] ", pc);
1140 if (upeek(tcp, 4*REG_PC, &pc) < 0) {
1141 tprintf("[????????] ");
1144 tprintf("[%08lx] ", pc);
1145 # elif defined(SH64)
1148 if (upeek(tcp, REG_PC, &pc) < 0) {
1149 tprintf("[????????????????] ");
1152 tprintf("[%08lx] ", pc);
1156 if (upeek(tcp, 4*15, &pc) < 0) {
1160 tprintf("[%08lx] ", pc);
1161 # elif defined(AVR32)
1164 if (upeek(tcp, REG_PC, &pc) < 0) {
1165 tprintf("[????????] ");
1168 tprintf("[%08lx] ", pc);
1169 # elif defined(BFIN)
1172 if (upeek(tcp, PT_PC, &pc) < 0) {
1176 tprintf("[%08lx] ", pc);
1177 #elif defined(CRISV10)
1180 if (upeek(tcp, 4*PT_IRP, &pc) < 0) {
1184 tprintf("[%08lx] ", pc);
1185 #elif defined(CRISV32)
1188 if (upeek(tcp, 4*PT_ERP, &pc) < 0) {
1192 tprintf("[%08lx] ", pc);
1193 # endif /* architecture */
1199 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *) ®s, 0) < 0) {
1200 perror("printcall: ptrace(PTRACE_GETREGS, ...)");
1204 tprintf("[%08x] ", regs.r_o7);
1214 pread(tcp->pfd_reg, ®s, sizeof(regs), 0);
1215 tprintf("[%08x] ", regs.r_eip);
1216 #endif /* FREEBSD */
1221 * These #if's are huge, please indent them correctly.
1222 * It's easy to get confused otherwise.
1228 # include "syscall.h"
1230 # include <sys/syscall.h>
1231 # ifndef CLONE_PTRACE
1232 # define CLONE_PTRACE 0x00002000
1234 # ifndef CLONE_VFORK
1235 # define CLONE_VFORK 0x00004000
1238 # define CLONE_VM 0x00000100
1240 # ifndef CLONE_STOPPED
1241 # define CLONE_STOPPED 0x02000000
1246 /* We don't have fork()/vfork() syscalls on ia64 itself, but the ia32
1247 subsystem has them for x86... */
1249 # define SYS_vfork 190
1251 typedef unsigned long *arg_setup_state;
1254 arg_setup(struct tcb *tcp, arg_setup_state *state)
1256 unsigned long cfm, sof, sol;
1260 /* Satisfy a false GCC warning. */
1265 if (upeek(tcp, PT_AR_BSP, &bsp) < 0)
1267 if (upeek(tcp, PT_CFM, (long *) &cfm) < 0)
1270 sof = (cfm >> 0) & 0x7f;
1271 sol = (cfm >> 7) & 0x7f;
1272 bsp = (long) ia64_rse_skip_regs((unsigned long *) bsp, -sof + sol);
1274 *state = (unsigned long *) bsp;
1278 # define arg_finish_change(tcp, state) 0
1282 get_arg0(struct tcb *tcp, arg_setup_state *state, long *valp)
1287 ret = upeek(tcp, PT_R11, valp);
1290 (unsigned long) ia64_rse_skip_regs(*state, 0),
1291 sizeof(long), (void *) valp);
1296 get_arg1(struct tcb *tcp, arg_setup_state *state, long *valp)
1301 ret = upeek(tcp, PT_R9, valp);
1304 (unsigned long) ia64_rse_skip_regs(*state, 1),
1305 sizeof(long), (void *) valp);
1311 set_arg0(struct tcb *tcp, arg_setup_state *state, long val)
1313 int req = PTRACE_POKEDATA;
1317 ap = (void *) (intptr_t) PT_R11; /* r11 == EBX */
1318 req = PTRACE_POKEUSER;
1320 ap = ia64_rse_skip_regs(*state, 0);
1322 ptrace(req, tcp->pid, ap, val);
1323 return errno ? -1 : 0;
1327 set_arg1(struct tcb *tcp, arg_setup_state *state, long val)
1329 int req = PTRACE_POKEDATA;
1333 ap = (void *) (intptr_t) PT_R9; /* r9 == ECX */
1334 req = PTRACE_POKEUSER;
1336 ap = ia64_rse_skip_regs(*state, 1);
1338 ptrace(req, tcp->pid, ap, val);
1339 return errno ? -1 : 0;
1342 /* ia64 does not return the input arguments from functions (and syscalls)
1343 according to ia64 RSE (Register Stack Engine) behavior. */
1345 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1346 # define restore_arg1(tcp, state, val) ((void) (state), 0)
1348 # elif defined (SPARC) || defined (SPARC64)
1350 typedef struct pt_regs arg_setup_state;
1352 # define arg_setup(tcp, state) \
1353 (ptrace(PTRACE_GETREGS, tcp->pid, (char *) (state), 0))
1354 # define arg_finish_change(tcp, state) \
1355 (ptrace(PTRACE_SETREGS, tcp->pid, (char *) (state), 0))
1357 # define get_arg0(tcp, state, valp) (*(valp) = (state)->u_regs[U_REG_O0], 0)
1358 # define get_arg1(tcp, state, valp) (*(valp) = (state)->u_regs[U_REG_O1], 0)
1359 # define set_arg0(tcp, state, val) ((state)->u_regs[U_REG_O0] = (val), 0)
1360 # define set_arg1(tcp, state, val) ((state)->u_regs[U_REG_O1] = (val), 0)
1361 # define restore_arg0(tcp, state, val) 0
1363 # else /* other architectures */
1365 # if defined S390 || defined S390X
1366 /* Note: this is only true for the `clone' system call, which handles
1367 arguments specially. We could as well say that its first two arguments
1368 are swapped relative to other architectures, but that would just be
1369 another #ifdef in the calls. */
1370 # define arg0_offset PT_GPR3
1371 # define arg1_offset PT_ORIGGPR2
1372 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1373 # define restore_arg1(tcp, state, val) ((void) (state), 0)
1374 # define arg0_index 1
1375 # define arg1_index 0
1376 # elif defined (ALPHA) || defined (MIPS)
1377 # define arg0_offset REG_A0
1378 # define arg1_offset (REG_A0+1)
1379 # elif defined (AVR32)
1380 # define arg0_offset (REG_R12)
1381 # define arg1_offset (REG_R11)
1382 # elif defined (POWERPC)
1383 # define arg0_offset (sizeof(unsigned long)*PT_R3)
1384 # define arg1_offset (sizeof(unsigned long)*PT_R4)
1385 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1386 # elif defined (HPPA)
1387 # define arg0_offset PT_GR26
1388 # define arg1_offset (PT_GR26-4)
1389 # elif defined (X86_64)
1390 # define arg0_offset ((long)(8*(current_personality ? RBX : RDI)))
1391 # define arg1_offset ((long)(8*(current_personality ? RCX : RSI)))
1393 # define arg0_offset (4*(REG_REG0+4))
1394 # define arg1_offset (4*(REG_REG0+5))
1395 # elif defined (SH64)
1396 /* ABI defines arg0 & 1 in r2 & r3 */
1397 # define arg0_offset (REG_OFFSET+16)
1398 # define arg1_offset (REG_OFFSET+24)
1399 # define restore_arg0(tcp, state, val) 0
1400 # elif defined CRISV10 || defined CRISV32
1401 # define arg0_offset (4*PT_R11)
1402 # define arg1_offset (4*PT_ORIG_R10)
1403 # define restore_arg0(tcp, state, val) 0
1404 # define restore_arg1(tcp, state, val) 0
1405 # define arg0_index 1
1406 # define arg1_index 0
1408 # define arg0_offset 0
1409 # define arg1_offset 4
1411 # define restore_arg0(tcp, state, val) 0
1415 typedef int arg_setup_state;
1417 # define arg_setup(tcp, state) (0)
1418 # define arg_finish_change(tcp, state) 0
1419 # define get_arg0(tcp, cookie, valp) \
1420 (upeek((tcp), arg0_offset, (valp)))
1421 # define get_arg1(tcp, cookie, valp) \
1422 (upeek((tcp), arg1_offset, (valp)))
1425 set_arg0(struct tcb *tcp, void *cookie, long val)
1427 return ptrace(PTRACE_POKEUSER, tcp->pid, (char*)arg0_offset, val);
1431 set_arg1(struct tcb *tcp, void *cookie, long val)
1433 return ptrace(PTRACE_POKEUSER, tcp->pid, (char*)arg1_offset, val);
1436 # endif /* architectures */
1438 # ifndef restore_arg0
1439 # define restore_arg0(tcp, state, val) set_arg0((tcp), (state), (val))
1441 # ifndef restore_arg1
1442 # define restore_arg1(tcp, state, val) set_arg1((tcp), (state), (val))
1446 # define arg0_index 0
1447 # define arg1_index 1
1451 setbpt(struct tcb *tcp)
1453 static int clone_scno[SUPPORTED_PERSONALITIES] = { SYS_clone };
1454 arg_setup_state state;
1456 if (tcp->flags & TCB_BPTSET) {
1457 fprintf(stderr, "PANIC: TCB already set in pid %u\n", tcp->pid);
1462 * It's a silly kludge to initialize this with a search at runtime.
1463 * But it's better than maintaining another magic thing in the
1464 * godforsaken tables.
1466 if (clone_scno[current_personality] == 0) {
1468 for (i = 0; i < nsyscalls; ++i)
1469 if (sysent[i].sys_func == sys_clone) {
1470 clone_scno[current_personality] = i;
1475 switch (known_scno(tcp)) {
1482 # if defined SYS_fork || defined SYS_vfork
1483 if (arg_setup(tcp, &state) < 0
1484 || get_arg0(tcp, &state, &tcp->inst[0]) < 0
1485 || get_arg1(tcp, &state, &tcp->inst[1]) < 0
1486 || change_syscall(tcp, clone_scno[current_personality]) < 0
1487 || set_arg0(tcp, &state, CLONE_PTRACE|SIGCHLD) < 0
1488 || set_arg1(tcp, &state, 0) < 0
1489 || arg_finish_change(tcp, &state) < 0)
1491 tcp->u_arg[arg0_index] = CLONE_PTRACE|SIGCHLD;
1492 tcp->u_arg[arg1_index] = 0;
1493 tcp->flags |= TCB_BPTSET;
1501 /* ia64 calls directly `clone (CLONE_VFORK | CLONE_VM)'
1502 contrary to x86 SYS_vfork above. Even on x86 we turn the
1503 vfork semantics into plain fork - each application must not
1504 depend on the vfork specifics according to POSIX. We would
1505 hang waiting for the parent resume otherwise. We need to
1506 clear also CLONE_VM but only in the CLONE_VFORK case as
1507 otherwise we would break pthread_create. */
1509 long new_arg0 = (tcp->u_arg[arg0_index] | CLONE_PTRACE);
1510 if (new_arg0 & CLONE_VFORK)
1511 new_arg0 &= ~(unsigned long)(CLONE_VFORK | CLONE_VM);
1512 if (arg_setup(tcp, &state) < 0
1513 || set_arg0(tcp, &state, new_arg0) < 0
1514 || arg_finish_change(tcp, &state) < 0)
1516 tcp->flags |= TCB_BPTSET;
1517 tcp->inst[0] = tcp->u_arg[arg0_index];
1518 tcp->inst[1] = tcp->u_arg[arg1_index];
1522 fprintf(stderr, "PANIC: setbpt for syscall %ld on %u???\n",
1523 tcp->scno, tcp->pid);
1531 clearbpt(struct tcb *tcp)
1533 arg_setup_state state;
1534 if (arg_setup(tcp, &state) < 0
1535 || restore_arg0(tcp, &state, tcp->inst[0]) < 0
1536 || restore_arg1(tcp, &state, tcp->inst[1]) < 0
1537 || arg_finish_change(tcp, &state))
1540 tcp->flags &= ~TCB_BPTSET;
1544 # else /* !defined LINUX */
1547 setbpt(struct tcb *tcp)
1550 # ifdef SPARC /* This code is slightly sparc specific */
1553 # define BPT 0x91d02001 /* ta 1 */
1554 # define LOOP 0x10800000 /* ba 0 */
1555 # define LOOPA 0x30800000 /* ba,a 0 */
1556 # define NOP 0x01000000
1558 static int loopdeloop[1] = {LOOPA};
1560 static int loopdeloop[2] = {LOOP, NOP};
1563 if (tcp->flags & TCB_BPTSET) {
1564 fprintf(stderr, "PANIC: TCB already set in pid %u\n", tcp->pid);
1567 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) {
1568 perror("setbpt: ptrace(PTRACE_GETREGS, ...)");
1571 tcp->baddr = regs.r_o7 + 8;
1572 if (ptrace(PTRACE_READTEXT, tcp->pid, (char *)tcp->baddr,
1573 sizeof tcp->inst, (char *)tcp->inst) < 0) {
1574 perror("setbpt: ptrace(PTRACE_READTEXT, ...)");
1579 * XXX - BRUTAL MODE ON
1580 * We cannot set a real BPT in the child, since it will not be
1581 * traced at the moment it will reach the trap and would probably
1582 * die with a core dump.
1583 * Thus, we are force our way in by taking out two instructions
1584 * and insert an eternal loop in stead, in expectance of the SIGSTOP
1585 * generated by out PTRACE_ATTACH.
1586 * Of cause, if we evaporate ourselves in the middle of all this...
1588 if (ptrace(PTRACE_WRITETEXT, tcp->pid, (char *) tcp->baddr,
1589 sizeof loopdeloop, (char *) loopdeloop) < 0) {
1590 perror("setbpt: ptrace(PTRACE_WRITETEXT, ...)");
1593 tcp->flags |= TCB_BPTSET;
1596 # endif /* SUNOS4 */
1602 clearbpt(struct tcb *tcp)
1611 if (!(tcp->flags & TCB_BPTSET)) {
1612 fprintf(stderr, "PANIC: TCB not set in pid %u\n", tcp->pid);
1615 if (ptrace(PTRACE_WRITETEXT, tcp->pid, (char *) tcp->baddr,
1616 sizeof tcp->inst, (char *) tcp->inst) < 0) {
1617 perror("clearbtp: ptrace(PTRACE_WRITETEXT, ...)");
1620 tcp->flags &= ~TCB_BPTSET;
1624 * Since we don't have a single instruction breakpoint, we may have
1625 * to adjust the program counter after removing our `breakpoint'.
1627 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) {
1628 perror("clearbpt: ptrace(PTRACE_GETREGS, ...)");
1631 if ((regs.r_pc < tcp->baddr) ||
1632 (regs.r_pc > tcp->baddr + 4)) {
1633 /* The breakpoint has not been reached yet */
1636 "NOTE: PC not at bpt (pc %#x baddr %#x)\n",
1637 regs.r_pc, tcp->baddr);
1640 if (regs.r_pc != tcp->baddr)
1642 fprintf(stderr, "NOTE: PC adjusted (%#x -> %#x\n",
1643 regs.r_pc, tcp->baddr);
1645 regs.r_pc = tcp->baddr;
1646 if (ptrace(PTRACE_SETREGS, tcp->pid, (char *)®s, 0) < 0) {
1647 perror("clearbpt: ptrace(PTRACE_SETREGS, ...)");
1652 # endif /* SUNOS4 */
1657 # endif /* !defined LINUX */
1659 #endif /* !USE_PROCFS */
1665 getex(struct tcb *tcp, struct exec *hdr)
1669 for (n = 0; n < sizeof *hdr; n += 4) {
1671 if (upeek(tcp, uoff(u_exdata) + n, &res) < 0)
1673 memcpy(((char *) hdr) + n, &res, 4);
1676 fprintf(stderr, "[struct exec: magic: %o version %u Mach %o\n",
1677 hdr->a_magic, hdr->a_toolversion, hdr->a_machtype);
1678 fprintf(stderr, "Text %lu Data %lu Bss %lu Syms %lu Entry %#lx]\n",
1679 hdr->a_text, hdr->a_data, hdr->a_bss, hdr->a_syms, hdr->a_entry);
1685 fixvfork(struct tcb *tcp)
1689 * Change `vfork' in a freshly exec'ed dynamically linked
1690 * executable's (internal) symbol table to plain old `fork'
1694 struct link_dynamic dyn;
1695 struct link_dynamic_2 ld;
1698 if (getex(tcp, &hdr) < 0)
1703 if (umove(tcp, (int) N_DATADDR(hdr), &dyn) < 0) {
1704 fprintf(stderr, "Cannot read DYNAMIC\n");
1707 if (umove(tcp, (int) dyn.ld_un.ld_2, &ld) < 0) {
1708 fprintf(stderr, "Cannot read link_dynamic_2\n");
1711 if ((strtab = malloc((unsigned)ld.ld_symb_size)) == 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)