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.
36 #include <sys/param.h>
43 # include <asm/ptrace_offsets.h>
49 # define PTRACE_PEEKUSR PTRACE_PEEKUSER
50 #elif defined(HAVE_LINUX_PTRACE_H)
51 # undef PTRACE_SYSCALL
52 # ifdef HAVE_STRUCT_IA64_FPREG
53 # define ia64_fpreg XXX_ia64_fpreg
55 # ifdef HAVE_STRUCT_PT_ALL_USER_REGS
56 # define pt_all_user_regs XXX_pt_all_user_regs
58 # include <linux/ptrace.h>
60 # undef pt_all_user_regs
65 # define MAX(a,b) (((a) > (b)) ? (a) : (b))
68 # define MIN(a,b) (((a) < (b)) ? (a) : (b))
72 string_to_uint(const char *str)
80 value = strtol(str, &error, 10);
81 if (errno || *error || value < 0 || (long)(int)value != value)
87 tv_nz(struct timeval *a)
89 return a->tv_sec || a->tv_usec;
93 tv_cmp(struct timeval *a, struct timeval *b)
95 if (a->tv_sec < b->tv_sec
96 || (a->tv_sec == b->tv_sec && a->tv_usec < b->tv_usec))
98 if (a->tv_sec > b->tv_sec
99 || (a->tv_sec == b->tv_sec && a->tv_usec > b->tv_usec))
105 tv_float(struct timeval *tv)
107 return tv->tv_sec + tv->tv_usec/1000000.0;
111 tv_add(struct timeval *tv, struct timeval *a, struct timeval *b)
113 tv->tv_sec = a->tv_sec + b->tv_sec;
114 tv->tv_usec = a->tv_usec + b->tv_usec;
115 if (tv->tv_usec >= 1000000) {
117 tv->tv_usec -= 1000000;
122 tv_sub(struct timeval *tv, struct timeval *a, struct timeval *b)
124 tv->tv_sec = a->tv_sec - b->tv_sec;
125 tv->tv_usec = a->tv_usec - b->tv_usec;
126 if (((long) tv->tv_usec) < 0) {
128 tv->tv_usec += 1000000;
133 tv_div(struct timeval *tv, struct timeval *a, int n)
135 tv->tv_usec = (a->tv_sec % n * 1000000 + a->tv_usec + n / 2) / n;
136 tv->tv_sec = a->tv_sec / n + tv->tv_usec / 1000000;
137 tv->tv_usec %= 1000000;
141 tv_mul(struct timeval *tv, struct timeval *a, int n)
143 tv->tv_usec = a->tv_usec * n;
144 tv->tv_sec = a->tv_sec * n + tv->tv_usec / 1000000;
145 tv->tv_usec %= 1000000;
149 xlookup(const struct xlat *xlat, int val)
151 for (; xlat->str != NULL; xlat++)
152 if (xlat->val == val)
157 #if !defined HAVE_STPCPY
159 stpcpy(char *dst, const char *src)
161 while ((*dst = *src++) != '\0')
168 * Print entry in struct xlat table, if there.
171 printxval(const struct xlat *xlat, int val, const char *dflt)
173 const char *str = xlookup(xlat, val);
178 tprintf("%#x /* %s */", val, dflt);
182 * Print 64bit argument at position arg_no and return the index of the next
186 printllval(struct tcb *tcp, const char *format, int arg_no)
188 #if defined(X86_64) || defined(POWERPC64) || defined(TILE)
189 if (current_personality == 0) {
190 /* Technically, format expects "long long",
191 * but we supply "long". We expect that
192 * on this arch, they are the same.
194 tprintf(format, tcp->u_arg[arg_no]);
197 # if defined(POWERPC64)
198 /* Align arg_no to next even number */
199 arg_no = (arg_no + 1) & 0xe;
201 tprintf(format, LONG_LONG(tcp->u_arg[arg_no], tcp->u_arg[arg_no + 1]));
204 #elif defined IA64 || defined ALPHA
205 /* Technically, format expects "long long",
206 * but we supply "long". We expect that
207 * on this arch, they are the same.
209 tprintf(format, tcp->u_arg[arg_no]);
211 #elif defined LINUX_MIPSN32 || defined X32
212 tprintf(format, tcp->ext_arg[arg_no]);
216 # error BUG: must not combine two args for long long on this arch
218 tprintf(format, LONG_LONG(tcp->u_arg[arg_no], tcp->u_arg[arg_no + 1]));
225 * Interpret `xlat' as an array of flags
226 * print the entries whose bits are on in `flags'
227 * return # of flags printed.
230 addflags(const struct xlat *xlat, int flags)
232 for (; xlat->str; xlat++) {
233 if (xlat->val && (flags & xlat->val) == xlat->val) {
234 tprintf("|%s", xlat->str);
239 tprintf("|%#x", flags);
244 * Interpret `xlat' as an array of flags.
245 * Print to static string the entries whose bits are on in `flags'
246 * Return static string.
249 sprintflags(const char *prefix, const struct xlat *xlat, int flags)
251 static char outstr[1024];
255 outptr = stpcpy(outstr, prefix);
257 for (; xlat->str; xlat++) {
258 if ((flags & xlat->val) == xlat->val) {
261 outptr = stpcpy(outptr, xlat->str);
271 outptr += sprintf(outptr, "%#x", flags);
278 printflags(const struct xlat *xlat, int flags, const char *dflt)
283 if (flags == 0 && xlat->val == 0) {
289 for (n = 0; xlat->str; xlat++) {
290 if (xlat->val && (flags & xlat->val) == xlat->val) {
291 tprintf("%s%s", sep, xlat->str);
300 tprintf("%s%#x", sep, flags);
305 tprintf("%#x", flags);
307 tprintf(" /* %s */", dflt);
318 printnum(struct tcb *tcp, long addr, const char *fmt)
326 if (umove(tcp, addr, &num) < 0) {
327 tprintf("%#lx", addr);
336 printnum_int(struct tcb *tcp, long addr, const char *fmt)
344 if (umove(tcp, addr, &num) < 0) {
345 tprintf("%#lx", addr);
354 printfd(struct tcb *tcp, int fd)
356 char path[PATH_MAX + 1];
358 if (show_fd_path && getfdpath(tcp, fd, path, sizeof(path)) >= 0)
359 tprintf("%d<%s>", fd, path);
365 printuid(const char *text, unsigned long uid)
367 tprintf((uid == -1) ? "%s%ld" : "%s%lu", text, uid);
371 * Quote string `instr' of length `size'
372 * Write up to (3 + `size' * 4) bytes to `outstr' buffer.
373 * If `len' is -1, treat `instr' as a NUL-terminated string
374 * and quote at most (`size' - 1) bytes.
376 * Returns 0 if len == -1 and NUL was seen, 1 otherwise.
377 * Note that if len >= 0, always returns 1.
380 string_quote(const char *instr, char *outstr, long len, int size)
382 const unsigned char *ustr = (const unsigned char *) instr;
384 int usehex, c, i, eol;
386 eol = 0x100; /* this can never match a char */
396 /* Check for presence of symbol which require
397 to hex-quote the whole string. */
398 for (i = 0; i < size; ++i) {
400 /* Check for NUL-terminated string. */
404 /* Force hex unless c is printable or whitespace */
409 /* In ASCII isspace is only these chars: "\t\n\v\f\r".
410 * They happen to have ASCII codes 9,10,11,12,13.
412 if (c < ' ' && (unsigned)(c - 9) >= 5) {
422 /* Hex-quote the whole string. */
423 for (i = 0; i < size; ++i) {
425 /* Check for NUL-terminated string. */
430 *s++ = "0123456789abcdef"[c >> 4];
431 *s++ = "0123456789abcdef"[c & 0xf];
434 for (i = 0; i < size; ++i) {
436 /* Check for NUL-terminated string. */
440 case '\"': case '\\':
465 if (c >= ' ' && c <= 0x7e)
471 && ustr[i + 1] >= '0'
472 && ustr[i + 1] <= '9'
475 *s++ = '0' + (c >> 6);
476 *s++ = '0' + ((c >> 3) & 0x7);
481 *s++ = '0' + (c >> 6);
482 *s++ = '0' + ((c >> 3) & 0x7);
485 *s++ = '0' + (c & 0x7);
495 /* Return zero if we printed entire ASCIZ string (didn't truncate it) */
496 if (len == -1 && ustr[i] == '\0') {
497 /* We didn't see NUL yet (otherwise we'd jump to 'asciz_ended')
498 * but next char is NUL.
508 /* Return zero: we printed entire ASCIZ string (didn't truncate it) */
513 * Print path string specified by address `addr' and length `n'.
514 * If path length exceeds `n', append `...' to the output.
517 printpathn(struct tcb *tcp, long addr, int n)
519 char path[MAXPATHLEN + 1];
527 /* Cap path length to the path buffer size */
528 if (n > sizeof path - 1)
531 /* Fetch one byte more to find out whether path length > n. */
532 nul_seen = umovestr(tcp, addr, n + 1, path);
534 tprintf("%#lx", addr);
540 outstr = alloca(4 * n); /* 4*(n-1) + 3 for quotes and NUL */
541 string_quote(path, outstr, -1, n);
549 printpath(struct tcb *tcp, long addr)
551 /* Size must correspond to char path[] size in printpathn */
552 printpathn(tcp, addr, MAXPATHLEN);
556 * Print string specified by address `addr' and length `len'.
557 * If `len' < 0, treat the string as a NUL-terminated string.
558 * If string length exceeds `max_strlen', append `...' to the output.
561 printstr(struct tcb *tcp, long addr, long len)
563 static char *str = NULL;
572 /* Allocate static buffers if they are not allocated yet. */
574 unsigned int outstr_size = 4 * max_strlen + /*for quotes and NUL:*/ 3;
576 if (outstr_size / 4 != max_strlen)
578 str = malloc(max_strlen + 1);
581 outstr = malloc(outstr_size);
588 * Treat as a NUL-terminated string: fetch one byte more
589 * because string_quote() quotes one byte less.
591 size = max_strlen + 1;
592 if (umovestr(tcp, addr, size, str) < 0) {
593 tprintf("%#lx", addr);
599 if (size > (unsigned long)len)
600 size = (unsigned long)len;
601 if (umoven(tcp, addr, size, str) < 0) {
602 tprintf("%#lx", addr);
607 /* If string_quote didn't see NUL and (it was supposed to be ASCIZ str
608 * or we were requested to print more than -s NUM chars)...
610 ellipsis = (string_quote(str, outstr, len, size) &&
611 (len < 0 || len > max_strlen));
620 dumpiov(struct tcb *tcp, int len, long addr)
622 #if SUPPORTED_PERSONALITIES > 1
624 struct { u_int32_t base; u_int32_t len; } *iov32;
625 struct { u_int64_t base; u_int64_t len; } *iov64;
627 #define iov iovu.iov64
629 (current_wordsize == 4 ? sizeof(*iovu.iov32) : sizeof(*iovu.iov64))
630 #define iov_iov_base(i) \
631 (current_wordsize == 4 ? (uint64_t) iovu.iov32[i].base : iovu.iov64[i].base)
632 #define iov_iov_len(i) \
633 (current_wordsize == 4 ? (uint64_t) iovu.iov32[i].len : iovu.iov64[i].len)
636 #define sizeof_iov sizeof(*iov)
637 #define iov_iov_base(i) iov[i].iov_base
638 #define iov_iov_len(i) iov[i].iov_len
643 size = sizeof_iov * len;
644 /* Assuming no sane program has millions of iovs */
645 if ((unsigned)len > 1024*1024 /* insane or negative size? */
646 || (iov = malloc(size)) == NULL) {
647 fprintf(stderr, "Out of memory\n");
650 if (umoven(tcp, addr, size, (char *) iov) >= 0) {
651 for (i = 0; i < len; i++) {
652 /* include the buffer number to make it easy to
653 * match up the trace with the source */
654 tprintf(" * %lu bytes in buffer %d\n",
655 (unsigned long)iov_iov_len(i), i);
656 dumpstr(tcp, (long) iov_iov_base(i),
669 dumpstr(struct tcb *tcp, long addr, int len)
671 static int strsize = -1;
672 static unsigned char *str;
677 "xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx "
678 "1234567890123456") + /*in case I'm off by few:*/ 4)
679 /*align to 8 to make memset easier:*/ + 7) & -8
681 const unsigned char *src;
684 memset(outbuf, ' ', sizeof(outbuf));
686 if (strsize < len + 16) {
688 str = malloc(len + 16);
691 fprintf(stderr, "Out of memory\n");
697 if (umoven(tcp, addr, len, (char *) str) < 0)
700 /* Space-pad to 16 bytes */
712 *dst++ = "0123456789abcdef"[*src >> 4];
713 *dst++ = "0123456789abcdef"[*src & 0xf];
719 dst++; /* space is there by memset */
722 dst++; /* space is there by memset */
729 if (*src >= ' ' && *src < 0x7f)
736 tprintf(" | %05x %s |\n", i - 16, outbuf);
740 #ifdef HAVE_PROCESS_VM_READV
741 /* C library supports this, but the kernel might not. */
742 static bool process_vm_readv_not_supported = 0;
745 /* Need to do this since process_vm_readv() is not yet available in libc.
746 * When libc is be updated, only "static bool process_vm_readv_not_supported"
747 * line should remain.
749 #if !defined(__NR_process_vm_readv)
751 # define __NR_process_vm_readv 347
752 # elif defined(X86_64)
753 # define __NR_process_vm_readv 310
754 # elif defined(POWERPC)
755 # define __NR_process_vm_readv 351
759 #if defined(__NR_process_vm_readv)
760 static bool process_vm_readv_not_supported = 0;
761 /* Have to avoid duplicating with the C library headers. */
762 static ssize_t strace_process_vm_readv(pid_t pid,
763 const struct iovec *lvec,
764 unsigned long liovcnt,
765 const struct iovec *rvec,
766 unsigned long riovcnt,
769 return syscall(__NR_process_vm_readv, (long)pid, lvec, liovcnt, rvec, riovcnt, flags);
771 #define process_vm_readv strace_process_vm_readv
773 static bool process_vm_readv_not_supported = 1;
774 # define process_vm_readv(...) (errno = ENOSYS, -1)
777 #endif /* end of hack */
779 #define PAGMASK (~(PAGSIZ - 1))
781 * move `len' bytes of data from process `pid'
782 * at address `addr' to our space at `laddr'
785 umoven(struct tcb *tcp, long addr, int len, char *laddr)
791 char x[sizeof(long)];
794 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
795 if (current_wordsize < sizeof(addr))
796 addr &= (1ul << 8 * current_wordsize) - 1;
799 if (!process_vm_readv_not_supported) {
800 struct iovec local[1], remote[1];
803 local[0].iov_base = laddr;
804 remote[0].iov_base = (void*)addr;
805 local[0].iov_len = remote[0].iov_len = len;
806 r = process_vm_readv(pid, local, 1, remote, 1, 0);
810 error_msg("umoven: short read (%d < %d) @0x%lx",
816 process_vm_readv_not_supported = 1;
819 /* the process is gone */
821 case EFAULT: case EIO: case EPERM:
822 /* address space is inaccessible */
825 /* all the rest is strange and should be reported */
826 perror_msg("process_vm_readv");
832 if (addr & (sizeof(long) - 1)) {
833 /* addr not a multiple of sizeof(long) */
834 n = addr - (addr & -sizeof(long)); /* residue */
835 addr &= -sizeof(long); /* residue */
837 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
841 case ESRCH: case EINVAL:
842 /* these could be seen if the process is gone */
844 case EFAULT: case EIO: case EPERM:
845 /* address space is inaccessible */
848 /* all the rest is strange and should be reported */
849 perror_msg("umoven: PTRACE_PEEKDATA pid:%d @0x%lx",
853 m = MIN(sizeof(long) - n, len);
854 memcpy(laddr, &u.x[n], m);
855 addr += sizeof(long);
862 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
866 case ESRCH: case EINVAL:
867 /* these could be seen if the process is gone */
869 case EFAULT: case EIO: case EPERM:
870 /* address space is inaccessible */
872 perror_msg("umoven: short read (%d < %d) @0x%lx",
873 nread, nread + len, addr - nread);
877 /* all the rest is strange and should be reported */
878 perror_msg("umoven: PTRACE_PEEKDATA pid:%d @0x%lx",
882 m = MIN(sizeof(long), len);
883 memcpy(laddr, u.x, m);
884 addr += sizeof(long);
894 * Like `umove' but make the additional effort of looking
895 * for a terminating zero byte.
897 * Returns < 0 on error, > 0 if NUL was seen,
898 * (TODO if useful: return count of bytes including NUL),
899 * else 0 if len bytes were read but no NUL byte seen.
901 * Note: there is no guarantee we won't overwrite some bytes
902 * in laddr[] _after_ terminating NUL (but, of course,
903 * we never write past laddr[len-1]).
906 umovestr(struct tcb *tcp, long addr, int len, char *laddr)
909 const unsigned long x01010101 = 0x01010101ul;
910 const unsigned long x80808080 = 0x80808080ul;
911 #elif SIZEOF_LONG == 8
912 const unsigned long x01010101 = 0x0101010101010101ul;
913 const unsigned long x80808080 = 0x8080808080808080ul;
915 # error SIZEOF_LONG > 8
922 char x[sizeof(long)];
925 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
926 if (current_wordsize < sizeof(addr))
927 addr &= (1ul << 8 * current_wordsize) - 1;
931 if (!process_vm_readv_not_supported) {
932 struct iovec local[1], remote[1];
934 local[0].iov_base = laddr;
935 remote[0].iov_base = (void*)addr;
942 /* Don't read kilobytes: most strings are short */
946 /* Don't cross pages. I guess otherwise we can get EFAULT
947 * and fail to notice that terminating NUL lies
948 * in the existing (first) page.
949 * (I hope there aren't arches with pages < 4K)
951 end_in_page = ((addr + chunk_len) & 4095);
952 r = chunk_len - end_in_page;
953 if (r > 0) /* if chunk_len > end_in_page */
954 chunk_len = r; /* chunk_len -= end_in_page */
956 local[0].iov_len = remote[0].iov_len = chunk_len;
957 r = process_vm_readv(pid, local, 1, remote, 1, 0);
959 if (memchr(local[0].iov_base, '\0', r))
961 local[0].iov_base += r;
962 remote[0].iov_base += r;
969 process_vm_readv_not_supported = 1;
970 goto vm_readv_didnt_work;
972 /* the process is gone */
974 case EFAULT: case EIO: case EPERM:
975 /* address space is inaccessible */
977 perror_msg("umovestr: short read (%d < %d) @0x%lx",
978 nread, nread + len, addr);
982 /* all the rest is strange and should be reported */
983 perror_msg("process_vm_readv");
991 if (addr & (sizeof(long) - 1)) {
992 /* addr not a multiple of sizeof(long) */
993 n = addr - (addr & -sizeof(long)); /* residue */
994 addr &= -sizeof(long); /* residue */
996 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
1000 case ESRCH: case EINVAL:
1001 /* these could be seen if the process is gone */
1003 case EFAULT: case EIO: case EPERM:
1004 /* address space is inaccessible */
1007 /* all the rest is strange and should be reported */
1008 perror_msg("umovestr: PTRACE_PEEKDATA pid:%d @0x%lx",
1012 m = MIN(sizeof(long) - n, len);
1013 memcpy(laddr, &u.x[n], m);
1014 while (n & (sizeof(long) - 1))
1015 if (u.x[n++] == '\0')
1017 addr += sizeof(long);
1025 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
1029 case ESRCH: case EINVAL:
1030 /* these could be seen if the process is gone */
1032 case EFAULT: case EIO: case EPERM:
1033 /* address space is inaccessible */
1035 perror_msg("umovestr: short read (%d < %d) @0x%lx",
1036 nread, nread + len, addr - nread);
1040 /* all the rest is strange and should be reported */
1041 perror_msg("umovestr: PTRACE_PEEKDATA pid:%d @0x%lx",
1045 m = MIN(sizeof(long), len);
1046 memcpy(laddr, u.x, m);
1047 /* "If a NUL char exists in this word" */
1048 if ((u.val - x01010101) & ~u.val & x80808080)
1050 addr += sizeof(long);
1059 upeek(struct tcb *tcp, long off, long *res)
1064 val = ptrace(PTRACE_PEEKUSER, tcp->pid, (char *) off, 0);
1065 if (val == -1 && errno) {
1066 if (errno != ESRCH) {
1067 perror_msg("upeek: PTRACE_PEEKUSER pid:%d @0x%lx)", tcp->pid, off);
1075 /* Note! On new kernels (about 2.5.46+), we use PTRACE_O_TRACECLONE
1076 * and PTRACE_O_TRACE[V]FORK for tracing children.
1077 * If you are adding a new arch which is only supported by newer kernels,
1078 * you most likely don't need to add any code below
1079 * beside a dummy "return 0" block in change_syscall().
1083 * These #if's are huge, please indent them correctly.
1084 * It's easy to get confused otherwise.
1087 #include "syscall.h"
1089 #ifndef CLONE_PTRACE
1090 # define CLONE_PTRACE 0x00002000
1093 # define CLONE_VFORK 0x00004000
1096 # define CLONE_VM 0x00000100
1101 typedef unsigned long *arg_setup_state;
1104 arg_setup(struct tcb *tcp, arg_setup_state *state)
1106 unsigned long cfm, sof, sol;
1110 /* Satisfy a false GCC warning. */
1115 if (upeek(tcp, PT_AR_BSP, &bsp) < 0)
1117 if (upeek(tcp, PT_CFM, (long *) &cfm) < 0)
1120 sof = (cfm >> 0) & 0x7f;
1121 sol = (cfm >> 7) & 0x7f;
1122 bsp = (long) ia64_rse_skip_regs((unsigned long *) bsp, -sof + sol);
1124 *state = (unsigned long *) bsp;
1128 # define arg_finish_change(tcp, state) 0
1131 get_arg0(struct tcb *tcp, arg_setup_state *state, long *valp)
1136 ret = upeek(tcp, PT_R11, valp);
1139 (unsigned long) ia64_rse_skip_regs(*state, 0),
1140 sizeof(long), (void *) valp);
1145 get_arg1(struct tcb *tcp, arg_setup_state *state, long *valp)
1150 ret = upeek(tcp, PT_R9, valp);
1153 (unsigned long) ia64_rse_skip_regs(*state, 1),
1154 sizeof(long), (void *) valp);
1159 set_arg0(struct tcb *tcp, arg_setup_state *state, long val)
1161 int req = PTRACE_POKEDATA;
1165 ap = (void *) (intptr_t) PT_R11; /* r11 == EBX */
1166 req = PTRACE_POKEUSER;
1168 ap = ia64_rse_skip_regs(*state, 0);
1170 ptrace(req, tcp->pid, ap, val);
1171 return errno ? -1 : 0;
1175 set_arg1(struct tcb *tcp, arg_setup_state *state, long val)
1177 int req = PTRACE_POKEDATA;
1181 ap = (void *) (intptr_t) PT_R9; /* r9 == ECX */
1182 req = PTRACE_POKEUSER;
1184 ap = ia64_rse_skip_regs(*state, 1);
1186 ptrace(req, tcp->pid, ap, val);
1187 return errno ? -1 : 0;
1190 /* ia64 does not return the input arguments from functions (and syscalls)
1191 according to ia64 RSE (Register Stack Engine) behavior. */
1193 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1194 # define restore_arg1(tcp, state, val) ((void) (state), 0)
1196 #elif defined(SPARC) || defined(SPARC64)
1198 # if defined(SPARC64)
1199 # undef PTRACE_GETREGS
1200 # define PTRACE_GETREGS PTRACE_GETREGS64
1201 # undef PTRACE_SETREGS
1202 # define PTRACE_SETREGS PTRACE_SETREGS64
1205 typedef struct pt_regs arg_setup_state;
1207 # define arg_setup(tcp, state) \
1208 (ptrace(PTRACE_GETREGS, (tcp)->pid, (char *) (state), 0))
1209 # define arg_finish_change(tcp, state) \
1210 (ptrace(PTRACE_SETREGS, (tcp)->pid, (char *) (state), 0))
1212 # define get_arg0(tcp, state, valp) (*(valp) = (state)->u_regs[U_REG_O0], 0)
1213 # define get_arg1(tcp, state, valp) (*(valp) = (state)->u_regs[U_REG_O1], 0)
1214 # define set_arg0(tcp, state, val) ((state)->u_regs[U_REG_O0] = (val), 0)
1215 # define set_arg1(tcp, state, val) ((state)->u_regs[U_REG_O1] = (val), 0)
1216 # define restore_arg0(tcp, state, val) 0
1218 #else /* other architectures */
1220 # if defined S390 || defined S390X
1221 /* Note: this is only true for the `clone' system call, which handles
1222 arguments specially. We could as well say that its first two arguments
1223 are swapped relative to other architectures, but that would just be
1224 another #ifdef in the calls. */
1225 # define arg0_offset PT_GPR3
1226 # define arg1_offset PT_ORIGGPR2
1227 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1228 # define restore_arg1(tcp, state, val) ((void) (state), 0)
1229 # define arg0_index 1
1230 # define arg1_index 0
1231 # elif defined(ALPHA) || defined(MIPS)
1232 # define arg0_offset REG_A0
1233 # define arg1_offset (REG_A0+1)
1234 # elif defined(POWERPC)
1235 # define arg0_offset (sizeof(unsigned long)*PT_R3)
1236 # define arg1_offset (sizeof(unsigned long)*PT_R4)
1237 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1238 # elif defined(HPPA)
1239 # define arg0_offset PT_GR26
1240 # define arg1_offset (PT_GR26-4)
1241 # elif defined(X86_64) || defined(X32)
1242 # define arg0_offset ((long)(8*(current_personality ? RBX : RDI)))
1243 # define arg1_offset ((long)(8*(current_personality ? RCX : RSI)))
1245 # define arg0_offset (4*(REG_REG0+4))
1246 # define arg1_offset (4*(REG_REG0+5))
1247 # elif defined(SH64)
1248 /* ABI defines arg0 & 1 in r2 & r3 */
1249 # define arg0_offset (REG_OFFSET+16)
1250 # define arg1_offset (REG_OFFSET+24)
1251 # define restore_arg0(tcp, state, val) 0
1252 # elif defined CRISV10 || defined CRISV32
1253 # define arg0_offset (4*PT_R11)
1254 # define arg1_offset (4*PT_ORIG_R10)
1255 # define restore_arg0(tcp, state, val) 0
1256 # define restore_arg1(tcp, state, val) 0
1257 # define arg0_index 1
1258 # define arg1_index 0
1260 # define arg0_offset 0
1261 # define arg1_offset 4
1263 # define restore_arg0(tcp, state, val) 0
1267 typedef int arg_setup_state;
1269 # define arg_setup(tcp, state) (0)
1270 # define arg_finish_change(tcp, state) 0
1271 # define get_arg0(tcp, cookie, valp) (upeek((tcp), arg0_offset, (valp)))
1272 # define get_arg1(tcp, cookie, valp) (upeek((tcp), arg1_offset, (valp)))
1275 set_arg0(struct tcb *tcp, void *cookie, long val)
1277 return ptrace(PTRACE_POKEUSER, tcp->pid, (char*)arg0_offset, val);
1281 set_arg1(struct tcb *tcp, void *cookie, long val)
1283 return ptrace(PTRACE_POKEUSER, tcp->pid, (char*)arg1_offset, val);
1286 #endif /* architectures */
1288 #ifndef restore_arg0
1289 # define restore_arg0(tcp, state, val) set_arg0((tcp), (state), (val))
1291 #ifndef restore_arg1
1292 # define restore_arg1(tcp, state, val) set_arg1((tcp), (state), (val))
1296 # define arg0_index 0
1297 # define arg1_index 1
1301 change_syscall(struct tcb *tcp, arg_setup_state *state, int new)
1304 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(ORIG_EAX * 4), new) < 0)
1307 #elif defined(X86_64)
1308 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(ORIG_RAX * 8), new) < 0)
1312 /* setbpt/clearbpt never used: */
1313 /* X32 is only supported since about linux-3.0.30 */
1314 #elif defined(POWERPC)
1315 if (ptrace(PTRACE_POKEUSER, tcp->pid,
1316 (char*)(sizeof(unsigned long)*PT_R0), new) < 0)
1319 #elif defined(S390) || defined(S390X)
1320 /* s390 linux after 2.4.7 has a hook in entry.S to allow this */
1321 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_GPR2), new) < 0)
1325 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*PT_ORIG_D0), new) < 0)
1328 #elif defined(SPARC) || defined(SPARC64)
1329 state->u_regs[U_REG_G1] = new;
1332 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_V0), new) < 0)
1335 #elif defined(ALPHA)
1336 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_A3), new) < 0)
1339 #elif defined(AVR32)
1340 /* setbpt/clearbpt never used: */
1341 /* AVR32 is only supported since about linux-2.6.19 */
1343 /* setbpt/clearbpt never used: */
1344 /* Blackfin is only supported since about linux-2.6.23 */
1349 break; /* x86 SYS_fork */
1354 fprintf(stderr, "%s: unexpected syscall %d\n",
1358 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_R1), new) < 0)
1360 } else if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_R15), new) < 0)
1364 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_GR20), new) < 0)
1368 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*(REG_REG0+3)), new) < 0)
1372 /* Top half of reg encodes the no. of args n as 0x1n.
1373 Assume 0 args as kernel never actually checks... */
1374 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_SYSCALL),
1375 0x100000 | new) < 0)
1378 #elif defined(CRISV10) || defined(CRISV32)
1379 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*PT_R9), new) < 0)
1383 /* Some kernels support this, some (pre-2.6.16 or so) don't. */
1384 # ifndef PTRACE_SET_SYSCALL
1385 # define PTRACE_SET_SYSCALL 23
1387 if (ptrace(PTRACE_SET_SYSCALL, tcp->pid, 0, new & 0xffff) != 0)
1390 #elif defined(AARCH64)
1391 /* setbpt/clearbpt never used: */
1392 /* AARCH64 is only supported since about linux-3.0.31 */
1394 /* setbpt/clearbpt never used: */
1395 /* Tilera CPUs are only supported since about linux-2.6.34 */
1396 #elif defined(MICROBLAZE)
1397 /* setbpt/clearbpt never used: */
1398 /* microblaze is only supported since about linux-2.6.30 */
1400 /* never reached; OR1K is only supported by kernels since 3.1.0. */
1401 #elif defined(METAG)
1402 /* setbpt/clearbpt never used: */
1403 /* Meta is only supported since linux-3.7 */
1405 #warning Do not know how to handle change_syscall for this architecture
1406 #endif /* architecture */
1411 setbpt(struct tcb *tcp)
1413 static int clone_scno[SUPPORTED_PERSONALITIES] = { SYS_clone };
1414 arg_setup_state state;
1416 if (tcp->flags & TCB_BPTSET) {
1417 fprintf(stderr, "PANIC: TCB already set in pid %u\n", tcp->pid);
1422 * It's a silly kludge to initialize this with a search at runtime.
1423 * But it's better than maintaining another magic thing in the
1424 * godforsaken tables.
1426 if (clone_scno[current_personality] == 0) {
1428 for (i = 0; i < nsyscalls; ++i)
1429 if (sysent[i].sys_func == sys_clone) {
1430 clone_scno[current_personality] = i;
1435 if (tcp->s_ent->sys_func == sys_fork ||
1436 tcp->s_ent->sys_func == sys_vfork) {
1437 if (arg_setup(tcp, &state) < 0
1438 || get_arg0(tcp, &state, &tcp->inst[0]) < 0
1439 || get_arg1(tcp, &state, &tcp->inst[1]) < 0
1440 || change_syscall(tcp, &state,
1441 clone_scno[current_personality]) < 0
1442 || set_arg0(tcp, &state, CLONE_PTRACE|SIGCHLD) < 0
1443 || set_arg1(tcp, &state, 0) < 0
1444 || arg_finish_change(tcp, &state) < 0)
1446 tcp->u_arg[arg0_index] = CLONE_PTRACE|SIGCHLD;
1447 tcp->u_arg[arg1_index] = 0;
1448 tcp->flags |= TCB_BPTSET;
1452 if (tcp->s_ent->sys_func == sys_clone) {
1453 /* ia64 calls directly `clone (CLONE_VFORK | CLONE_VM)'
1454 contrary to x86 vfork above. Even on x86 we turn the
1455 vfork semantics into plain fork - each application must not
1456 depend on the vfork specifics according to POSIX. We would
1457 hang waiting for the parent resume otherwise. We need to
1458 clear also CLONE_VM but only in the CLONE_VFORK case as
1459 otherwise we would break pthread_create. */
1461 long new_arg0 = (tcp->u_arg[arg0_index] | CLONE_PTRACE);
1462 if (new_arg0 & CLONE_VFORK)
1463 new_arg0 &= ~(unsigned long)(CLONE_VFORK | CLONE_VM);
1464 if (arg_setup(tcp, &state) < 0
1465 || set_arg0(tcp, &state, new_arg0) < 0
1466 || arg_finish_change(tcp, &state) < 0)
1468 tcp->inst[0] = tcp->u_arg[arg0_index];
1469 tcp->inst[1] = tcp->u_arg[arg1_index];
1470 tcp->flags |= TCB_BPTSET;
1474 fprintf(stderr, "PANIC: setbpt for syscall %ld on %u???\n",
1475 tcp->scno, tcp->pid);
1480 clearbpt(struct tcb *tcp)
1482 arg_setup_state state;
1483 if (arg_setup(tcp, &state) < 0
1484 || change_syscall(tcp, &state, tcp->scno) < 0
1485 || restore_arg0(tcp, &state, tcp->inst[0]) < 0
1486 || restore_arg1(tcp, &state, tcp->inst[1]) < 0
1487 || arg_finish_change(tcp, &state))
1490 tcp->flags &= ~TCB_BPTSET;