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);
419
printfd(struct tcb *tcp, int fd)
430
tprintf((uid == -1) ? "%ld" : "%lu", uid);
433
static char path[MAXPATHLEN + 1];
436
* Quote string `instr' of length `size'
437
* Write up to (3 + `size' * 4) bytes to `outstr' buffer.
438
* If `len' < 0, treat `instr' as a NUL-terminated string
439
* and quote at most (`size' - 1) bytes.
442
string_quote(const char *instr, char *outstr, int len, int size)
444
const unsigned char *ustr = (const unsigned char *) instr;
446
int usehex = 0, c, i;
451
/* Check for presence of symbol which require
452
to hex-quote the whole string. */
453
for (i = 0; i < size; ++i) {
455
/* Check for NUL-terminated string. */
459
/* Quote at most size - 1 bytes. */
463
if (!isprint(c) && !isspace(c)) {
473
/* Hex-quote the whole string. */
474
for (i = 0; i < size; ++i) {
476
/* Check for NUL-terminated string. */
480
/* Quote at most size - 1 bytes. */
484
sprintf(s, "\\x%02x", c);
488
for (i = 0; i < size; ++i) {
490
/* Check for NUL-terminated string. */
494
/* Quote at most size - 1 bytes. */
499
case '\"': case '\\':
526
else if (i + 1 < size
527
&& isdigit(ustr[i + 1])) {
528
sprintf(s, "\\%03o", c);
531
sprintf(s, "\\%o", c);
542
/* Return nonzero if the string was unterminated. */
547
* Print path string specified by address `addr' and length `n'.
548
* If path length exceeds `n', append `...' to the output.
551
printpathn(struct tcb *tcp, long addr, int n)
558
/* Cap path length to the path buffer size,
559
and NUL-terminate the buffer. */
560
if (n > sizeof path - 1)
564
/* Fetch one byte more to find out whether path length > n. */
565
if (umovestr(tcp, addr, n + 1, path) < 0)
566
tprintf("%#lx", addr);
568
static char outstr[4*(sizeof path - 1) + sizeof "\"...\""];
569
int trunc = (path[n] != '\0');
573
(void) string_quote(path, outstr, -1, n + 1);
575
strcat(outstr, "...");
576
tprintf("%s", outstr);
581
printpath(struct tcb *tcp, long addr)
583
printpathn(tcp, addr, sizeof path - 1);
587
* Print string specified by address `addr' and length `len'.
588
* If `len' < 0, treat the string as a NUL-terminated string.
589
* If string length exceeds `max_strlen', append `...' to the output.
592
printstr(struct tcb *tcp, long addr, int len)
594
static char *str = NULL;
602
/* Allocate static buffers if they are not allocated yet. */
604
str = malloc(max_strlen + 1);
606
outstr = malloc(4 * max_strlen + sizeof "\"...\"");
607
if (!str || !outstr) {
608
fprintf(stderr, "out of memory\n");
609
tprintf("%#lx", addr);
615
* Treat as a NUL-terminated string: fetch one byte more
616
* because string_quote() quotes one byte less.
618
size = max_strlen + 1;
619
str[max_strlen] = '\0';
620
if (umovestr(tcp, addr, size, str) < 0) {
621
tprintf("%#lx", addr);
626
size = MIN(len, max_strlen);
627
if (umoven(tcp, addr, size, str) < 0) {
628
tprintf("%#lx", addr);
633
if (string_quote(str, outstr, len, size) &&
634
(len < 0 || len > max_strlen))
635
strcat(outstr, "...");
637
tprintf("%s", outstr);
642
dumpiov(tcp, len, addr)
647
#if defined(LINUX) && SUPPORTED_PERSONALITIES > 1
649
struct { u_int32_t base; u_int32_t len; } *iov32;
650
struct { u_int64_t base; u_int64_t len; } *iov64;
652
#define iov iovu.iov64
654
(personality_wordsize[current_personality] == 4 \
655
? sizeof(*iovu.iov32) : sizeof(*iovu.iov64))
656
#define iov_iov_base(i) \
657
(personality_wordsize[current_personality] == 4 \
658
? (u_int64_t) iovu.iov32[i].base : iovu.iov64[i].base)
659
#define iov_iov_len(i) \
660
(personality_wordsize[current_personality] == 4 \
661
? (u_int64_t) iovu.iov32[i].len : iovu.iov64[i].len)
664
#define sizeof_iov sizeof(*iov)
665
#define iov_iov_base(i) iov[i].iov_base
666
#define iov_iov_len(i) iov[i].iov_len
671
size = sizeof_iov * (unsigned long) len;
672
if (size / sizeof_iov != len
673
|| (iov = malloc(size)) == NULL) {
674
fprintf(stderr, "out of memory\n");
677
if (umoven(tcp, addr, size, (char *) iov) >= 0) {
678
for (i = 0; i < len; i++) {
679
/* include the buffer number to make it easy to
680
* match up the trace with the source */
681
tprintf(" * %lu bytes in buffer %d\n",
682
(unsigned long)iov_iov_len(i), i);
683
dumpstr(tcp, (long) iov_iov_base(i),
696
dumpstr(tcp, addr, len)
701
static int strsize = -1;
702
static unsigned char *str;
703
static char outstr[80];
710
if ((str = malloc(len)) == NULL) {
711
fprintf(stderr, "out of memory\n");
717
if (umoven(tcp, addr, len, (char *) str) < 0)
720
for (i = 0; i < len; i += 16) {
722
sprintf(s, " | %05x ", i);
724
for (j = 0; j < 16; j++) {
728
sprintf(s, " %02x", str[i + j]);
732
*s++ = ' '; *s++ = ' '; *s++ = ' ';
735
*s++ = ' '; *s++ = ' ';
736
for (j = 0; j < 16; j++) {
740
if (isprint(str[i + j]))
748
tprintf("%s |\n", outstr);
752
#define PAGMASK (~(PAGSIZ - 1))
754
* move `len' bytes of data from process `pid'
755
* at address `addr' to our space at `laddr'
758
umoven(struct tcb *tcp, long addr, int len, char *laddr)
766
char x[sizeof(long)];
769
if (addr & (sizeof(long) - 1)) {
770
/* addr not a multiple of sizeof(long) */
771
n = addr - (addr & -sizeof(long)); /* residue */
772
addr &= -sizeof(long); /* residue */
774
u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
776
if (started && (errno==EPERM || errno==EIO)) {
777
/* Ran into 'end of memory' - stupid "printpath" */
780
/* But if not started, we had a bogus address. */
781
if (addr != 0 && errno != EIO && errno != ESRCH)
782
perror("ptrace: umoven");
786
memcpy(laddr, &u.x[n], m = MIN(sizeof(long) - n, len));
787
addr += sizeof(long), laddr += m, len -= m;
791
u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
793
if (started && (errno==EPERM || errno==EIO)) {
794
/* Ran into 'end of memory' - stupid "printpath" */
797
if (addr != 0 && errno != EIO && errno != ESRCH)
798
perror("ptrace: umoven");
802
memcpy(laddr, u.x, m = MIN(sizeof(long), len));
803
addr += sizeof(long), laddr += m, len -= m;
812
n = MIN(len, PAGSIZ);
813
n = MIN(n, ((addr + PAGSIZ) & PAGMASK) - addr);
814
if (ptrace(PTRACE_READDATA, pid,
815
(char *) addr, len, laddr) < 0) {
816
if (errno != ESRCH) {
817
perror("umoven: ptrace(PTRACE_READDATA, ...)");
829
#ifdef HAVE_MP_PROCFS
830
int fd = tcp->pfd_as;
834
lseek(fd, addr, SEEK_SET);
835
if (read(fd, laddr, len) == -1)
837
#endif /* USE_PROCFS */
843
* like `umove' but make the additional effort of looking
844
* for a terminating zero byte.
847
umovestr(struct tcb *tcp, long addr, int len, char *laddr)
850
#ifdef HAVE_MP_PROCFS
851
int fd = tcp->pfd_as;
855
/* Some systems (e.g. FreeBSD) can be upset if we read off the
856
end of valid memory, avoid this by trying to read up
857
to page boundaries. But we don't know what a page is (and
858
getpagesize(2) (if it exists) doesn't necessarily return
859
hardware page size). Assume all pages >= 1024 (a-historical
862
int page = 1024; /* How to find this? */
863
int move = page - (addr & (page - 1));
866
lseek(fd, addr, SEEK_SET);
869
if (move > left) move = left;
870
if ((move = read(fd, laddr, move)) <= 0)
871
return left != len ? 0 : -1;
872
if (memchr (laddr, 0, move)) break;
878
#else /* !USE_PROCFS */
884
char x[sizeof(long)];
887
if (addr & (sizeof(long) - 1)) {
888
/* addr not a multiple of sizeof(long) */
889
n = addr - (addr & -sizeof(long)); /* residue */
890
addr &= -sizeof(long); /* residue */
892
u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
894
if (started && (errno==EPERM || errno==EIO)) {
895
/* Ran into 'end of memory' - stupid "printpath" */
898
if (addr != 0 && errno != EIO && errno != ESRCH)
903
memcpy(laddr, &u.x[n], m = MIN(sizeof(long)-n,len));
904
while (n & (sizeof(long) - 1))
905
if (u.x[n++] == '\0')
907
addr += sizeof(long), laddr += m, len -= m;
911
u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
913
if (started && (errno==EPERM || errno==EIO)) {
914
/* Ran into 'end of memory' - stupid "printpath" */
917
if (addr != 0 && errno != EIO && errno != ESRCH)
922
memcpy(laddr, u.x, m = MIN(sizeof(long), len));
923
for (i = 0; i < sizeof(long); i++)
927
addr += sizeof(long), laddr += m, len -= m;
929
#endif /* !USE_PROCFS */
934
# if !defined (SPARC) && !defined(SPARC64)
935
# define PTRACE_WRITETEXT 101
936
# define PTRACE_WRITEDATA 102
937
# endif /* !SPARC && !SPARC64 */
943
uload(cmd, pid, addr, len, laddr)
954
char x[sizeof(long)];
957
if (cmd == PTRACE_WRITETEXT) {
958
peek = PTRACE_PEEKTEXT;
959
poke = PTRACE_POKETEXT;
962
peek = PTRACE_PEEKDATA;
963
poke = PTRACE_POKEDATA;
965
if (addr & (sizeof(long) - 1)) {
966
/* addr not a multiple of sizeof(long) */
967
n = addr - (addr & -sizeof(long)); /* residue */
968
addr &= -sizeof(long);
970
u.val = ptrace(peek, pid, (char *) addr, 0);
972
perror("uload: POKE");
975
memcpy(&u.x[n], laddr, m = MIN(sizeof(long) - n, len));
976
if (ptrace(poke, pid, (char *)addr, u.val) < 0) {
977
perror("uload: POKE");
980
addr += sizeof(long), laddr += m, len -= m;
983
if (len < sizeof(long))
984
u.val = ptrace(peek, pid, (char *) addr, 0);
985
memcpy(u.x, laddr, m = MIN(sizeof(long), len));
986
if (ptrace(poke, pid, (char *) addr, u.val) < 0) {
987
perror("uload: POKE");
990
addr += sizeof(long), laddr += m, len -= m;
996
tload(pid, addr, len, laddr)
1001
return uload(PTRACE_WRITETEXT, pid, addr, len, laddr);
1005
dload(pid, addr, len, laddr)
1011
return uload(PTRACE_WRITEDATA, pid, addr, len, laddr);
1019
upeek(tcp, off, res)
1026
# ifdef SUNOS4_KERNEL_ARCH_KLUDGE
1028
static int is_sun4m = -1;
1029
struct utsname name;
1031
/* Round up the usual suspects. */
1032
if (is_sun4m == -1) {
1033
if (uname(&name) < 0) {
1034
perror("upeek: uname?");
1037
is_sun4m = strcmp(name.machine, "sun4m") == 0;
1039
const struct xlat *x;
1041
for (x = struct_user_offsets; x->str; x++)
1048
# endif /* SUNOS4_KERNEL_ARCH_KLUDGE */
1050
val = do_ptrace(PTRACE_PEEKUSER, tcp, (char *) off, 0);
1051
if (val == -1 && errno) {
1052
if (errno != ESRCH) {
1054
sprintf(buf,"upeek: ptrace(PTRACE_PEEKUSER,%d,%lu,0)", tcp->pid, off);
1063
#endif /* !USE_PROCFS */
1066
printcall(struct tcb *tcp)
1068
#define PRINTBADPC tprintf(sizeof(long) == 4 ? "[????????] " : \
1069
sizeof(long) == 8 ? "[????????????????] " : \
1076
if (upeek(tcp, 4*EIP, &eip) < 0) {
1080
tprintf("[%08lx] ", eip);
1082
# elif defined(S390) || defined(S390X)
1084
if(upeek(tcp,PT_PSWADDR,&psw) < 0) {
1089
tprintf("[%08lx] ", psw);
1091
tprintf("[%16lx] ", psw);
1094
# elif defined(X86_64)
1097
if (upeek(tcp, 8*RIP, &rip) < 0) {
1101
tprintf("[%16lx] ", rip);
1102
# elif defined(IA64)
1105
if (upeek(tcp, PT_B0, &ip) < 0) {
1109
tprintf("[%08lx] ", ip);
1110
# elif defined(POWERPC)
1113
if (upeek(tcp, sizeof(unsigned long)*PT_NIP, &pc) < 0) {
1118
tprintf("[%016lx] ", pc);
1120
tprintf("[%08lx] ", pc);
1122
# elif defined(M68K)
1125
if (upeek(tcp, 4*PT_PC, &pc) < 0) {
1126
tprintf ("[????????] ");
1129
tprintf("[%08lx] ", pc);
1130
# elif defined(ALPHA)
1133
if (upeek(tcp, REG_PC, &pc) < 0) {
1134
tprintf ("[????????????????] ");
1137
tprintf("[%08lx] ", pc);
1138
# elif defined(SPARC) || defined(SPARC64)
1139
struct pt_regs regs;
1140
if (ptrace(PTRACE_GETREGS,tcp->pid,(char *)®s,0) < 0) {
1144
# if defined(SPARC64)
1145
tprintf("[%08lx] ", regs.tpc);
1147
tprintf("[%08lx] ", regs.pc);
1149
# elif defined(HPPA)
1152
if(upeek(tcp,PT_IAOQ0,&pc) < 0) {
1153
tprintf ("[????????] ");
1156
tprintf("[%08lx] ", pc);
1157
# elif defined(MIPS)
1160
if (upeek(tcp, REG_EPC, &pc) < 0) {
1161
tprintf ("[????????] ");
1164
tprintf("[%08lx] ", pc);
1168
if (upeek(tcp, 4*REG_PC, &pc) < 0) {
1169
tprintf ("[????????] ");
1172
tprintf("[%08lx] ", pc);
1173
# elif defined(SH64)
1176
if (upeek(tcp, REG_PC, &pc) < 0) {
1177
tprintf ("[????????????????] ");
1180
tprintf("[%08lx] ", pc);
1184
if (upeek(tcp, 4*15, &pc) < 0) {
1188
tprintf("[%08lx] ", pc);
1189
# elif defined(AVR32)
1192
if (upeek(tcp, REG_PC, &pc) < 0) {
1193
tprintf("[????????] ");
1196
tprintf("[%08lx] ", pc);
1197
# elif defined(BFIN)
1200
if (upeek(tcp, PT_PC, &pc) < 0) {
1204
tprintf("[%08lx] ", pc);
1205
#elif defined(CRISV10)
1208
if (upeek(tcp, 4*PT_IRP, &pc) < 0) {
1212
tprintf("[%08lx] ", pc);
1213
#elif defined(CRISV32)
1216
if (upeek(tcp, 4*PT_ERP, &pc) < 0) {
1220
tprintf("[%08lx] ", pc);
1221
# endif /* architecture */
1227
if (ptrace(PTRACE_GETREGS, tcp->pid, (char *) ®s, 0) < 0) {
1228
perror("printcall: ptrace(PTRACE_GETREGS, ...)");
1232
tprintf("[%08x] ", regs.r_o7);
1242
pread(tcp->pfd_reg, ®s, sizeof(regs), 0);
1243
tprintf("[%08x] ", regs.r_eip);
1244
#endif /* FREEBSD */
1249
* These #if's are huge, please indent them correctly.
1250
* It's easy to get confused otherwise.
1256
# include "syscall.h"
1258
# include <sys/syscall.h>
1259
# ifndef CLONE_PTRACE
1260
# define CLONE_PTRACE 0x00002000
1262
# ifndef CLONE_VFORK
1263
# define CLONE_VFORK 0x00004000
1266
# define CLONE_VM 0x00000100
1268
# ifndef CLONE_STOPPED
1269
# define CLONE_STOPPED 0x02000000
1274
/* We don't have fork()/vfork() syscalls on ia64 itself, but the ia32
1275
subsystem has them for x86... */
1277
# define SYS_vfork 190
1279
typedef unsigned long *arg_setup_state;
1282
arg_setup(struct tcb *tcp, arg_setup_state *state)
1284
unsigned long cfm, sof, sol;
1288
/* Satisfy a false GCC warning. */
1293
if (upeek(tcp, PT_AR_BSP, &bsp) < 0)
1295
if (upeek(tcp, PT_CFM, (long *) &cfm) < 0)
1298
sof = (cfm >> 0) & 0x7f;
1299
sol = (cfm >> 7) & 0x7f;
1300
bsp = (long) ia64_rse_skip_regs((unsigned long *) bsp, -sof + sol);
1302
*state = (unsigned long *) bsp;
1306
# define arg_finish_change(tcp, state) 0
1310
get_arg0 (struct tcb *tcp, arg_setup_state *state, long *valp)
1315
ret = upeek (tcp, PT_R11, valp);
1318
(unsigned long) ia64_rse_skip_regs(*state, 0),
1319
sizeof(long), (void *) valp);
1324
get_arg1 (struct tcb *tcp, arg_setup_state *state, long *valp)
1329
ret = upeek (tcp, PT_R9, valp);
1332
(unsigned long) ia64_rse_skip_regs(*state, 1),
1333
sizeof(long), (void *) valp);
1339
set_arg0 (struct tcb *tcp, arg_setup_state *state, long val)
1341
int req = PTRACE_POKEDATA;
1345
ap = (void *) (intptr_t) PT_R11; /* r11 == EBX */
1346
req = PTRACE_POKEUSER;
1348
ap = ia64_rse_skip_regs(*state, 0);
1350
ptrace(req, tcp->pid, ap, val);
1351
return errno ? -1 : 0;
1355
set_arg1 (struct tcb *tcp, arg_setup_state *state, long val)
1357
int req = PTRACE_POKEDATA;
1361
ap = (void *) (intptr_t) PT_R9; /* r9 == ECX */
1362
req = PTRACE_POKEUSER;
1364
ap = ia64_rse_skip_regs(*state, 1);
1366
ptrace(req, tcp->pid, ap, val);
1367
return errno ? -1 : 0;
1370
/* ia64 does not return the input arguments from functions (and syscalls)
1371
according to ia64 RSE (Register Stack Engine) behavior. */
1373
# define restore_arg0(tcp, state, val) ((void) (state), 0)
1374
# define restore_arg1(tcp, state, val) ((void) (state), 0)
1376
# elif defined (SPARC) || defined (SPARC64)
1378
typedef struct pt_regs arg_setup_state;
1380
# define arg_setup(tcp, state) \
1381
(ptrace (PTRACE_GETREGS, tcp->pid, (char *) (state), 0))
1382
# define arg_finish_change(tcp, state) \
1383
(ptrace (PTRACE_SETREGS, tcp->pid, (char *) (state), 0))
1385
# define get_arg0(tcp, state, valp) (*(valp) = (state)->u_regs[U_REG_O0], 0)
1386
# define get_arg1(tcp, state, valp) (*(valp) = (state)->u_regs[U_REG_O1], 0)
1387
# define set_arg0(tcp, state, val) ((state)->u_regs[U_REG_O0] = (val), 0)
1388
# define set_arg1(tcp, state, val) ((state)->u_regs[U_REG_O1] = (val), 0)
1389
# define restore_arg0(tcp, state, val) 0
1391
# else /* other architectures */
1393
# if defined S390 || defined S390X
1394
/* Note: this is only true for the `clone' system call, which handles
1395
arguments specially. We could as well say that its first two arguments
1396
are swapped relative to other architectures, but that would just be
1397
another #ifdef in the calls. */
1398
# define arg0_offset PT_GPR3
1399
# define arg1_offset PT_ORIGGPR2
1400
# define restore_arg0(tcp, state, val) ((void) (state), 0)
1401
# define restore_arg1(tcp, state, val) ((void) (state), 0)
1402
# define arg0_index 1
1403
# define arg1_index 0
1404
# elif defined (ALPHA) || defined (MIPS)
1405
# define arg0_offset REG_A0
1406
# define arg1_offset (REG_A0+1)
1407
# elif defined (AVR32)
1408
# define arg0_offset (REG_R12)
1409
# define arg1_offset (REG_R11)
1410
# elif defined (POWERPC)
1411
# define arg0_offset (sizeof(unsigned long)*PT_R3)
1412
# define arg1_offset (sizeof(unsigned long)*PT_R4)
1413
# define restore_arg0(tcp, state, val) ((void) (state), 0)
1414
# elif defined (HPPA)
1415
# define arg0_offset PT_GR26
1416
# define arg1_offset (PT_GR26-4)
1417
# elif defined (X86_64)
1418
# define arg0_offset ((long)(8*(current_personality ? RBX : RDI)))
1419
# define arg1_offset ((long)(8*(current_personality ? RCX : RSI)))
1421
# define arg0_offset (4*(REG_REG0+4))
1422
# define arg1_offset (4*(REG_REG0+5))
1423
# elif defined (SH64)
1424
/* ABI defines arg0 & 1 in r2 & r3 */
1425
# define arg0_offset (REG_OFFSET+16)
1426
# define arg1_offset (REG_OFFSET+24)
1427
# define restore_arg0(tcp, state, val) 0
1428
# elif defined CRISV10 || defined CRISV32
1429
# define arg0_offset (4*PT_R11)
1430
# define arg1_offset (4*PT_ORIG_R10)
1431
# define restore_arg0(tcp, state, val) 0
1432
# define restore_arg1(tcp, state, val) 0
1433
# define arg0_index 1
1434
# define arg1_index 0
1436
# define arg0_offset 0
1437
# define arg1_offset 4
1439
# define restore_arg0(tcp, state, val) 0
1443
typedef int arg_setup_state;
1445
# define arg_setup(tcp, state) (0)
1446
# define arg_finish_change(tcp, state) 0
1447
# define get_arg0(tcp, cookie, valp) \
1448
(upeek ((tcp), arg0_offset, (valp)))
1449
# define get_arg1(tcp, cookie, valp) \
1450
(upeek ((tcp), arg1_offset, (valp)))
1453
set_arg0 (struct tcb *tcp, void *cookie, long val)
1455
return ptrace (PTRACE_POKEUSER, tcp->pid, (char*)arg0_offset, val);
1459
set_arg1 (struct tcb *tcp, void *cookie, long val)
1461
return ptrace (PTRACE_POKEUSER, tcp->pid, (char*)arg1_offset, val);
1464
# endif /* architectures */
1466
# ifndef restore_arg0
1467
# define restore_arg0(tcp, state, val) set_arg0((tcp), (state), (val))
1469
# ifndef restore_arg1
1470
# define restore_arg1(tcp, state, val) set_arg1((tcp), (state), (val))
1474
# define arg0_index 0
1475
# define arg1_index 1
1479
setbpt(struct tcb *tcp)
1481
static int clone_scno[SUPPORTED_PERSONALITIES] = { SYS_clone };
1482
arg_setup_state state;
1484
if (tcp->flags & TCB_BPTSET) {
1485
fprintf(stderr, "PANIC: TCB already set in pid %u\n", tcp->pid);
1490
* It's a silly kludge to initialize this with a search at runtime.
1491
* But it's better than maintaining another magic thing in the
1492
* godforsaken tables.
1494
if (clone_scno[current_personality] == 0) {
1496
for (i = 0; i < nsyscalls; ++i)
1497
if (sysent[i].sys_func == sys_clone) {
1498
clone_scno[current_personality] = i;
1503
switch (known_scno(tcp)) {
1510
# if defined SYS_fork || defined SYS_vfork
1511
if (arg_setup (tcp, &state) < 0
1512
|| get_arg0 (tcp, &state, &tcp->inst[0]) < 0
1513
|| get_arg1 (tcp, &state, &tcp->inst[1]) < 0
1514
|| change_syscall(tcp, clone_scno[current_personality]) < 0
1515
|| set_arg0 (tcp, &state, CLONE_PTRACE|SIGCHLD) < 0
1516
|| set_arg1 (tcp, &state, 0) < 0
1517
|| arg_finish_change (tcp, &state) < 0)
1519
tcp->u_arg[arg0_index] = CLONE_PTRACE|SIGCHLD;
1520
tcp->u_arg[arg1_index] = 0;
1521
tcp->flags |= TCB_BPTSET;
1529
/* ia64 calls directly `clone (CLONE_VFORK | CLONE_VM)'
1530
contrary to x86 SYS_vfork above. Even on x86 we turn the
1531
vfork semantics into plain fork - each application must not
1532
depend on the vfork specifics according to POSIX. We would
1533
hang waiting for the parent resume otherwise. We need to
1534
clear also CLONE_VM but only in the CLONE_VFORK case as
1535
otherwise we would break pthread_create. */
1537
if ((arg_setup (tcp, &state) < 0
1538
|| set_arg0 (tcp, &state,
1539
(tcp->u_arg[arg0_index] | CLONE_PTRACE)
1540
& ~(tcp->u_arg[arg0_index] & CLONE_VFORK
1541
? CLONE_VFORK | CLONE_VM : 0)) < 0
1542
|| arg_finish_change (tcp, &state) < 0))
1544
tcp->flags |= TCB_BPTSET;
1545
tcp->inst[0] = tcp->u_arg[arg0_index];
1546
tcp->inst[1] = tcp->u_arg[arg1_index];
1550
fprintf(stderr, "PANIC: setbpt for syscall %ld on %u???\n",
1551
tcp->scno, tcp->pid);
1562
arg_setup_state state;
1563
if (arg_setup (tcp, &state) < 0
1564
|| restore_arg0 (tcp, &state, tcp->inst[0]) < 0
1565
|| restore_arg1 (tcp, &state, tcp->inst[1]) < 0
1566
|| arg_finish_change (tcp, &state))
1567
if (errno != ESRCH) return -1;
1568
tcp->flags &= ~TCB_BPTSET;
1572
# else /* !defined LINUX */
1579
# ifdef SPARC /* This code is slightly sparc specific */
1582
# define BPT 0x91d02001 /* ta 1 */
1583
# define LOOP 0x10800000 /* ba 0 */
1584
# define LOOPA 0x30800000 /* ba,a 0 */
1585
# define NOP 0x01000000
1587
static int loopdeloop[1] = {LOOPA};
1589
static int loopdeloop[2] = {LOOP, NOP};
1592
if (tcp->flags & TCB_BPTSET) {
1593
fprintf(stderr, "PANIC: TCB already set in pid %u\n", tcp->pid);
1596
if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) {
1597
perror("setbpt: ptrace(PTRACE_GETREGS, ...)");
1600
tcp->baddr = regs.r_o7 + 8;
1601
if (ptrace(PTRACE_READTEXT, tcp->pid, (char *)tcp->baddr,
1602
sizeof tcp->inst, (char *)tcp->inst) < 0) {
1603
perror("setbpt: ptrace(PTRACE_READTEXT, ...)");
1608
* XXX - BRUTAL MODE ON
1609
* We cannot set a real BPT in the child, since it will not be
1610
* traced at the moment it will reach the trap and would probably
1611
* die with a core dump.
1612
* Thus, we are force our way in by taking out two instructions
1613
* and insert an eternal loop in stead, in expectance of the SIGSTOP
1614
* generated by out PTRACE_ATTACH.
1615
* Of cause, if we evaporate ourselves in the middle of all this...
1617
if (ptrace(PTRACE_WRITETEXT, tcp->pid, (char *) tcp->baddr,
1618
sizeof loopdeloop, (char *) loopdeloop) < 0) {
1619
perror("setbpt: ptrace(PTRACE_WRITETEXT, ...)");
1622
tcp->flags |= TCB_BPTSET;
1625
# endif /* SUNOS4 */
1641
if (!(tcp->flags & TCB_BPTSET)) {
1642
fprintf(stderr, "PANIC: TCB not set in pid %u\n", tcp->pid);
1645
if (ptrace(PTRACE_WRITETEXT, tcp->pid, (char *) tcp->baddr,
1646
sizeof tcp->inst, (char *) tcp->inst) < 0) {
1647
perror("clearbtp: ptrace(PTRACE_WRITETEXT, ...)");
1650
tcp->flags &= ~TCB_BPTSET;
1654
* Since we don't have a single instruction breakpoint, we may have
1655
* to adjust the program counter after removing our `breakpoint'.
1657
if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) {
1658
perror("clearbpt: ptrace(PTRACE_GETREGS, ...)");
1661
if ((regs.r_pc < tcp->baddr) ||
1662
(regs.r_pc > tcp->baddr + 4)) {
1663
/* The breakpoint has not been reached yet */
1666
"NOTE: PC not at bpt (pc %#x baddr %#x)\n",
1667
regs.r_pc, tcp->baddr);
1670
if (regs.r_pc != tcp->baddr)
1672
fprintf(stderr, "NOTE: PC adjusted (%#x -> %#x\n",
1673
regs.r_pc, tcp->baddr);
1675
regs.r_pc = tcp->baddr;
1676
if (ptrace(PTRACE_SETREGS, tcp->pid, (char *)®s, 0) < 0) {
1677
perror("clearbpt: ptrace(PTRACE_SETREGS, ...)");
1682
# endif /* SUNOS4 */
1687
# endif /* !defined LINUX */
1689
#endif /* !USE_PROCFS */
1701
for (n = 0; n < sizeof *hdr; n += 4) {
1703
if (upeek(tcp, uoff(u_exdata) + n, &res) < 0)
1705
memcpy(((char *) hdr) + n, &res, 4);
1708
fprintf(stderr, "[struct exec: magic: %o version %u Mach %o\n",
1709
hdr->a_magic, hdr->a_toolversion, hdr->a_machtype);
1710
fprintf(stderr, "Text %lu Data %lu Bss %lu Syms %lu Entry %#lx]\n",
1711
hdr->a_text, hdr->a_data, hdr->a_bss, hdr->a_syms, hdr->a_entry);
1722
* Change `vfork' in a freshly exec'ed dynamically linked
1723
* executable's (internal) symbol table to plain old `fork'
1727
struct link_dynamic dyn;
1728
struct link_dynamic_2 ld;
1731
if (getex(tcp, &hdr) < 0)
1736
if (umove(tcp, (int) N_DATADDR(hdr), &dyn) < 0) {
1737
fprintf(stderr, "Cannot read DYNAMIC\n");
1740
if (umove(tcp, (int) dyn.ld_un.ld_2, &ld) < 0) {
1741
fprintf(stderr, "Cannot read link_dynamic_2\n");
1744
if ((strtab = malloc((unsigned)ld.ld_symb_size)) == NULL) {
1745
fprintf(stderr, "out of memory\n");
1748
if (umoven(tcp, (int)ld.ld_symbols+(int)N_TXTADDR(hdr),
1749
(int)ld.ld_symb_size, strtab) < 0)
1752
for (cp = strtab; cp < strtab + ld.ld_symb_size; ) {
1753
if (strcmp(cp, "_vfork") == 0) {
1755
fprintf(stderr, "fixvfork: FOUND _vfork\n");
1756
strcpy(cp, "_fork");
1761
if (cp < strtab + ld.ld_symb_size)
1763
* Write entire symbol table back to avoid
1764
* memory alignment bugs in ptrace
1766
if (tload(pid, (int)ld.ld_symbols+(int)N_TXTADDR(hdr),
1767
(int)ld.ld_symb_size, strtab) < 0)
added
removed
strace-4.6/util.c
