1 /*
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>
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
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.
21 *
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.
32 */
33
34 #include "defs.h"
35 #include <sys/user.h>
36 #include <sys/param.h>
37 #include <fcntl.h>
38 #if HAVE_SYS_UIO_H
39 # include <sys/uio.h>
40 #endif
41
42 #if defined(IA64)
43 # include <asm/ptrace_offsets.h>
44 # include <asm/rse.h>
45 #endif
46
47 #ifdef HAVE_SYS_REG_H
48 # include <sys/reg.h>
49 #elif defined(HAVE_LINUX_PTRACE_H)
50 # undef PTRACE_SYSCALL
51 # ifdef HAVE_STRUCT_IA64_FPREG
52 # define ia64_fpreg XXX_ia64_fpreg
53 # endif
54 # ifdef HAVE_STRUCT_PT_ALL_USER_REGS
55 # define pt_all_user_regs XXX_pt_all_user_regs
56 # endif
57 # ifdef HAVE_STRUCT_PTRACE_PEEKSIGINFO_ARGS
58 # define ptrace_peeksiginfo_args XXX_ptrace_peeksiginfo_args
59 # endif
60 # include <linux/ptrace.h>
61 # undef ptrace_peeksiginfo_args
62 # undef ia64_fpreg
63 # undef pt_all_user_regs
64 #endif
65
66 int
string_to_uint(const char * str)67 string_to_uint(const char *str)
68 {
69 char *error;
70 long value;
71
72 if (!*str)
73 return -1;
74 errno = 0;
75 value = strtol(str, &error, 10);
76 if (errno || *error || value < 0 || (long)(int)value != value)
77 return -1;
78 return (int)value;
79 }
80
81 int
tv_nz(const struct timeval * a)82 tv_nz(const struct timeval *a)
83 {
84 return a->tv_sec || a->tv_usec;
85 }
86
87 int
tv_cmp(const struct timeval * a,const struct timeval * b)88 tv_cmp(const struct timeval *a, const struct timeval *b)
89 {
90 if (a->tv_sec < b->tv_sec
91 || (a->tv_sec == b->tv_sec && a->tv_usec < b->tv_usec))
92 return -1;
93 if (a->tv_sec > b->tv_sec
94 || (a->tv_sec == b->tv_sec && a->tv_usec > b->tv_usec))
95 return 1;
96 return 0;
97 }
98
99 double
tv_float(const struct timeval * tv)100 tv_float(const struct timeval *tv)
101 {
102 return tv->tv_sec + tv->tv_usec/1000000.0;
103 }
104
105 void
tv_add(struct timeval * tv,const struct timeval * a,const struct timeval * b)106 tv_add(struct timeval *tv, const struct timeval *a, const struct timeval *b)
107 {
108 tv->tv_sec = a->tv_sec + b->tv_sec;
109 tv->tv_usec = a->tv_usec + b->tv_usec;
110 if (tv->tv_usec >= 1000000) {
111 tv->tv_sec++;
112 tv->tv_usec -= 1000000;
113 }
114 }
115
116 void
tv_sub(struct timeval * tv,const struct timeval * a,const struct timeval * b)117 tv_sub(struct timeval *tv, const struct timeval *a, const struct timeval *b)
118 {
119 tv->tv_sec = a->tv_sec - b->tv_sec;
120 tv->tv_usec = a->tv_usec - b->tv_usec;
121 if (((long) tv->tv_usec) < 0) {
122 tv->tv_sec--;
123 tv->tv_usec += 1000000;
124 }
125 }
126
127 void
tv_div(struct timeval * tv,const struct timeval * a,int n)128 tv_div(struct timeval *tv, const struct timeval *a, int n)
129 {
130 tv->tv_usec = (a->tv_sec % n * 1000000 + a->tv_usec + n / 2) / n;
131 tv->tv_sec = a->tv_sec / n + tv->tv_usec / 1000000;
132 tv->tv_usec %= 1000000;
133 }
134
135 void
tv_mul(struct timeval * tv,const struct timeval * a,int n)136 tv_mul(struct timeval *tv, const struct timeval *a, int n)
137 {
138 tv->tv_usec = a->tv_usec * n;
139 tv->tv_sec = a->tv_sec * n + tv->tv_usec / 1000000;
140 tv->tv_usec %= 1000000;
141 }
142
143 const char *
xlookup(const struct xlat * xlat,int val)144 xlookup(const struct xlat *xlat, int val)
145 {
146 for (; xlat->str != NULL; xlat++)
147 if (xlat->val == val)
148 return xlat->str;
149 return NULL;
150 }
151
152 #if !defined HAVE_STPCPY
153 char *
stpcpy(char * dst,const char * src)154 stpcpy(char *dst, const char *src)
155 {
156 while ((*dst = *src++) != '\0')
157 dst++;
158 return dst;
159 }
160 #endif
161
162 /* Find a next bit which is set.
163 * Starts testing at cur_bit.
164 * Returns -1 if no more bits are set.
165 *
166 * We never touch bytes we don't need to.
167 * On big-endian, array is assumed to consist of
168 * current_wordsize wide words: for example, is current_wordsize is 4,
169 * the bytes are walked in 3,2,1,0, 7,6,5,4, 11,10,9,8 ... sequence.
170 * On little-endian machines, word size is immaterial.
171 */
172 int
next_set_bit(const void * bit_array,unsigned cur_bit,unsigned size_bits)173 next_set_bit(const void *bit_array, unsigned cur_bit, unsigned size_bits)
174 {
175 const unsigned endian = 1;
176 int little_endian = *(char*)&endian;
177
178 const uint8_t *array = bit_array;
179 unsigned pos = cur_bit / 8;
180 unsigned pos_xor_mask = little_endian ? 0 : current_wordsize-1;
181
182 for (;;) {
183 uint8_t bitmask;
184 uint8_t cur_byte;
185
186 if (cur_bit >= size_bits)
187 return -1;
188 cur_byte = array[pos ^ pos_xor_mask];
189 if (cur_byte == 0) {
190 cur_bit = (cur_bit + 8) & (-8);
191 pos++;
192 continue;
193 }
194 bitmask = 1 << (cur_bit & 7);
195 for (;;) {
196 if (cur_byte & bitmask)
197 return cur_bit;
198 cur_bit++;
199 if (cur_bit >= size_bits)
200 return -1;
201 bitmask <<= 1;
202 /* This check *can't be* optimized out: */
203 if (bitmask == 0)
204 break;
205 }
206 pos++;
207 }
208 }
209 /*
210 * Print entry in struct xlat table, if there.
211 */
212 void
printxval(const struct xlat * xlat,int val,const char * dflt)213 printxval(const struct xlat *xlat, int val, const char *dflt)
214 {
215 const char *str = xlookup(xlat, val);
216
217 if (str)
218 tprints(str);
219 else
220 tprintf("%#x /* %s */", val, dflt);
221 }
222
223 /*
224 * Print 64bit argument at position arg_no and return the index of the next
225 * argument.
226 */
227 int
printllval(struct tcb * tcp,const char * format,int arg_no,bool align)228 printllval(struct tcb *tcp, const char *format, int arg_no, bool align)
229 {
230 #if SIZEOF_LONG > 4 && SIZEOF_LONG == SIZEOF_LONG_LONG
231 # if SUPPORTED_PERSONALITIES > 1
232 if (current_wordsize > 4) {
233 # endif
234 tprintf(format, tcp->u_arg[arg_no]);
235 arg_no++;
236 # if SUPPORTED_PERSONALITIES > 1
237 } else {
238 # if defined(AARCH64) || defined(POWERPC64)
239 if (align) {
240 /* Align arg_no to the next even number. */
241 arg_no = (arg_no + 1) & 0xe;
242 }
243 # endif
244 tprintf(format, LONG_LONG(tcp->u_arg[arg_no], tcp->u_arg[arg_no + 1]));
245 arg_no += 2;
246 }
247 # endif /* SUPPORTED_PERSONALITIES */
248 #elif SIZEOF_LONG > 4
249 # error Unsupported configuration: SIZEOF_LONG > 4 && SIZEOF_LONG_LONG > SIZEOF_LONG
250 #elif defined LINUX_MIPSN32
251 tprintf(format, tcp->ext_arg[arg_no]);
252 arg_no++;
253 #elif defined X32
254 if (current_personality == 0) {
255 tprintf(format, tcp->ext_arg[arg_no]);
256 arg_no++;
257 } else {
258 tprintf(format, LONG_LONG(tcp->u_arg[arg_no], tcp->u_arg[arg_no + 1]));
259 arg_no += 2;
260 }
261 #else
262 # if defined __ARM_EABI__ || \
263 defined LINUX_MIPSO32 || \
264 defined POWERPC || \
265 defined XTENSA
266 if (align) {
267 /* Align arg_no to the next even number. */
268 arg_no = (arg_no + 1) & 0xe;
269 }
270 # endif
271 tprintf(format, LONG_LONG(tcp->u_arg[arg_no], tcp->u_arg[arg_no + 1]));
272 arg_no += 2;
273 #endif
274
275 return arg_no;
276 }
277
278 /*
279 * Interpret `xlat' as an array of flags
280 * print the entries whose bits are on in `flags'
281 * return # of flags printed.
282 */
283 void
addflags(const struct xlat * xlat,int flags)284 addflags(const struct xlat *xlat, int flags)
285 {
286 for (; xlat->str; xlat++) {
287 if (xlat->val && (flags & xlat->val) == xlat->val) {
288 tprintf("|%s", xlat->str);
289 flags &= ~xlat->val;
290 }
291 }
292 if (flags) {
293 tprintf("|%#x", flags);
294 }
295 }
296
297 /*
298 * Interpret `xlat' as an array of flags.
299 * Print to static string the entries whose bits are on in `flags'
300 * Return static string.
301 */
302 const char *
sprintflags(const char * prefix,const struct xlat * xlat,int flags)303 sprintflags(const char *prefix, const struct xlat *xlat, int flags)
304 {
305 static char outstr[1024];
306 char *outptr;
307 int found = 0;
308
309 outptr = stpcpy(outstr, prefix);
310
311 for (; xlat->str; xlat++) {
312 if ((flags & xlat->val) == xlat->val) {
313 if (found)
314 *outptr++ = '|';
315 outptr = stpcpy(outptr, xlat->str);
316 found = 1;
317 flags &= ~xlat->val;
318 if (!flags)
319 break;
320 }
321 }
322 if (flags) {
323 if (found)
324 *outptr++ = '|';
325 outptr += sprintf(outptr, "%#x", flags);
326 }
327
328 return outstr;
329 }
330
331 int
printflags(const struct xlat * xlat,int flags,const char * dflt)332 printflags(const struct xlat *xlat, int flags, const char *dflt)
333 {
334 int n;
335 const char *sep;
336
337 if (flags == 0 && xlat->val == 0) {
338 tprints(xlat->str);
339 return 1;
340 }
341
342 sep = "";
343 for (n = 0; xlat->str; xlat++) {
344 if (xlat->val && (flags & xlat->val) == xlat->val) {
345 tprintf("%s%s", sep, xlat->str);
346 flags &= ~xlat->val;
347 sep = "|";
348 n++;
349 }
350 }
351
352 if (n) {
353 if (flags) {
354 tprintf("%s%#x", sep, flags);
355 n++;
356 }
357 } else {
358 if (flags) {
359 tprintf("%#x", flags);
360 if (dflt)
361 tprintf(" /* %s */", dflt);
362 } else {
363 if (dflt)
364 tprints("0");
365 }
366 }
367
368 return n;
369 }
370
371 void
printnum(struct tcb * tcp,long addr,const char * fmt)372 printnum(struct tcb *tcp, long addr, const char *fmt)
373 {
374 long num;
375
376 if (!addr) {
377 tprints("NULL");
378 return;
379 }
380 if (umove(tcp, addr, &num) < 0) {
381 tprintf("%#lx", addr);
382 return;
383 }
384 tprints("[");
385 tprintf(fmt, num);
386 tprints("]");
387 }
388
389 void
printnum_int(struct tcb * tcp,long addr,const char * fmt)390 printnum_int(struct tcb *tcp, long addr, const char *fmt)
391 {
392 int num;
393
394 if (!addr) {
395 tprints("NULL");
396 return;
397 }
398 if (umove(tcp, addr, &num) < 0) {
399 tprintf("%#lx", addr);
400 return;
401 }
402 tprints("[");
403 tprintf(fmt, num);
404 tprints("]");
405 }
406
407 void
printfd(struct tcb * tcp,int fd)408 printfd(struct tcb *tcp, int fd)
409 {
410 char path[PATH_MAX + 1];
411
412 if (show_fd_path && getfdpath(tcp, fd, path, sizeof(path)) >= 0)
413 tprintf("%d<%s>", fd, path);
414 else
415 tprintf("%d", fd);
416 }
417
418 void
printuid(const char * text,unsigned long uid)419 printuid(const char *text, unsigned long uid)
420 {
421 tprintf((uid == -1) ? "%s%ld" : "%s%lu", text, uid);
422 }
423
424 /*
425 * Quote string `instr' of length `size'
426 * Write up to (3 + `size' * 4) bytes to `outstr' buffer.
427 * If `len' is -1, treat `instr' as a NUL-terminated string
428 * and quote at most (`size' - 1) bytes.
429 *
430 * Returns 0 if len == -1 and NUL was seen, 1 otherwise.
431 * Note that if len >= 0, always returns 1.
432 */
433 int
string_quote(const char * instr,char * outstr,long len,int size)434 string_quote(const char *instr, char *outstr, long len, int size)
435 {
436 const unsigned char *ustr = (const unsigned char *) instr;
437 char *s = outstr;
438 int usehex, c, i, eol;
439
440 eol = 0x100; /* this can never match a char */
441 if (len == -1) {
442 size--;
443 eol = '\0';
444 }
445
446 usehex = 0;
447 if (xflag > 1)
448 usehex = 1;
449 else if (xflag) {
450 /* Check for presence of symbol which require
451 to hex-quote the whole string. */
452 for (i = 0; i < size; ++i) {
453 c = ustr[i];
454 /* Check for NUL-terminated string. */
455 if (c == eol)
456 break;
457
458 /* Force hex unless c is printable or whitespace */
459 if (c > 0x7e) {
460 usehex = 1;
461 break;
462 }
463 /* In ASCII isspace is only these chars: "\t\n\v\f\r".
464 * They happen to have ASCII codes 9,10,11,12,13.
465 */
466 if (c < ' ' && (unsigned)(c - 9) >= 5) {
467 usehex = 1;
468 break;
469 }
470 }
471 }
472
473 *s++ = '\"';
474
475 if (usehex) {
476 /* Hex-quote the whole string. */
477 for (i = 0; i < size; ++i) {
478 c = ustr[i];
479 /* Check for NUL-terminated string. */
480 if (c == eol)
481 goto asciz_ended;
482 *s++ = '\\';
483 *s++ = 'x';
484 *s++ = "0123456789abcdef"[c >> 4];
485 *s++ = "0123456789abcdef"[c & 0xf];
486 }
487 } else {
488 for (i = 0; i < size; ++i) {
489 c = ustr[i];
490 /* Check for NUL-terminated string. */
491 if (c == eol)
492 goto asciz_ended;
493 switch (c) {
494 case '\"': case '\\':
495 *s++ = '\\';
496 *s++ = c;
497 break;
498 case '\f':
499 *s++ = '\\';
500 *s++ = 'f';
501 break;
502 case '\n':
503 *s++ = '\\';
504 *s++ = 'n';
505 break;
506 case '\r':
507 *s++ = '\\';
508 *s++ = 'r';
509 break;
510 case '\t':
511 *s++ = '\\';
512 *s++ = 't';
513 break;
514 case '\v':
515 *s++ = '\\';
516 *s++ = 'v';
517 break;
518 default:
519 if (c >= ' ' && c <= 0x7e)
520 *s++ = c;
521 else {
522 /* Print \octal */
523 *s++ = '\\';
524 if (i + 1 < size
525 && ustr[i + 1] >= '0'
526 && ustr[i + 1] <= '9'
527 ) {
528 /* Print \ooo */
529 *s++ = '0' + (c >> 6);
530 *s++ = '0' + ((c >> 3) & 0x7);
531 } else {
532 /* Print \[[o]o]o */
533 if ((c >> 3) != 0) {
534 if ((c >> 6) != 0)
535 *s++ = '0' + (c >> 6);
536 *s++ = '0' + ((c >> 3) & 0x7);
537 }
538 }
539 *s++ = '0' + (c & 0x7);
540 }
541 break;
542 }
543 }
544 }
545
546 *s++ = '\"';
547 *s = '\0';
548
549 /* Return zero if we printed entire ASCIZ string (didn't truncate it) */
550 if (len == -1 && ustr[i] == '\0') {
551 /* We didn't see NUL yet (otherwise we'd jump to 'asciz_ended')
552 * but next char is NUL.
553 */
554 return 0;
555 }
556
557 return 1;
558
559 asciz_ended:
560 *s++ = '\"';
561 *s = '\0';
562 /* Return zero: we printed entire ASCIZ string (didn't truncate it) */
563 return 0;
564 }
565
566 /*
567 * Print path string specified by address `addr' and length `n'.
568 * If path length exceeds `n', append `...' to the output.
569 */
570 void
printpathn(struct tcb * tcp,long addr,int n)571 printpathn(struct tcb *tcp, long addr, int n)
572 {
573 char path[MAXPATHLEN + 1];
574 int nul_seen;
575
576 if (!addr) {
577 tprints("NULL");
578 return;
579 }
580
581 /* Cap path length to the path buffer size */
582 if (n > sizeof path - 1)
583 n = sizeof path - 1;
584
585 /* Fetch one byte more to find out whether path length > n. */
586 nul_seen = umovestr(tcp, addr, n + 1, path);
587 if (nul_seen < 0)
588 tprintf("%#lx", addr);
589 else {
590 char *outstr;
591
592 path[n] = '\0';
593 n++;
594 outstr = alloca(4 * n); /* 4*(n-1) + 3 for quotes and NUL */
595 string_quote(path, outstr, -1, n);
596 tprints(outstr);
597 if (!nul_seen)
598 tprints("...");
599 }
600 }
601
602 void
printpath(struct tcb * tcp,long addr)603 printpath(struct tcb *tcp, long addr)
604 {
605 /* Size must correspond to char path[] size in printpathn */
606 printpathn(tcp, addr, MAXPATHLEN);
607 }
608
609 /*
610 * Print string specified by address `addr' and length `len'.
611 * If `len' < 0, treat the string as a NUL-terminated string.
612 * If string length exceeds `max_strlen', append `...' to the output.
613 */
614 void
printstr(struct tcb * tcp,long addr,long len)615 printstr(struct tcb *tcp, long addr, long len)
616 {
617 static char *str = NULL;
618 static char *outstr;
619 int size;
620 int ellipsis;
621
622 if (!addr) {
623 tprints("NULL");
624 return;
625 }
626 /* Allocate static buffers if they are not allocated yet. */
627 if (!str) {
628 unsigned int outstr_size = 4 * max_strlen + /*for quotes and NUL:*/ 3;
629
630 if (outstr_size / 4 != max_strlen)
631 die_out_of_memory();
632 str = malloc(max_strlen + 1);
633 if (!str)
634 die_out_of_memory();
635 outstr = malloc(outstr_size);
636 if (!outstr)
637 die_out_of_memory();
638 }
639
640 if (len == -1) {
641 /*
642 * Treat as a NUL-terminated string: fetch one byte more
643 * because string_quote() quotes one byte less.
644 */
645 size = max_strlen + 1;
646 if (umovestr(tcp, addr, size, str) < 0) {
647 tprintf("%#lx", addr);
648 return;
649 }
650 }
651 else {
652 size = max_strlen;
653 if (size > (unsigned long)len)
654 size = (unsigned long)len;
655 if (umoven(tcp, addr, size, str) < 0) {
656 tprintf("%#lx", addr);
657 return;
658 }
659 }
660
661 /* If string_quote didn't see NUL and (it was supposed to be ASCIZ str
662 * or we were requested to print more than -s NUM chars)...
663 */
664 ellipsis = (string_quote(str, outstr, len, size) &&
665 (len < 0 || len > max_strlen));
666
667 tprints(outstr);
668 if (ellipsis)
669 tprints("...");
670 }
671
672 #if HAVE_SYS_UIO_H
673 void
dumpiov(struct tcb * tcp,int len,long addr)674 dumpiov(struct tcb *tcp, int len, long addr)
675 {
676 #if SUPPORTED_PERSONALITIES > 1
677 union {
678 struct { u_int32_t base; u_int32_t len; } *iov32;
679 struct { u_int64_t base; u_int64_t len; } *iov64;
680 } iovu;
681 #define iov iovu.iov64
682 #define sizeof_iov \
683 (current_wordsize == 4 ? sizeof(*iovu.iov32) : sizeof(*iovu.iov64))
684 #define iov_iov_base(i) \
685 (current_wordsize == 4 ? (uint64_t) iovu.iov32[i].base : iovu.iov64[i].base)
686 #define iov_iov_len(i) \
687 (current_wordsize == 4 ? (uint64_t) iovu.iov32[i].len : iovu.iov64[i].len)
688 #else
689 struct iovec *iov;
690 #define sizeof_iov sizeof(*iov)
691 #define iov_iov_base(i) iov[i].iov_base
692 #define iov_iov_len(i) iov[i].iov_len
693 #endif
694 int i;
695 unsigned size;
696
697 size = sizeof_iov * len;
698 /* Assuming no sane program has millions of iovs */
699 if ((unsigned)len > 1024*1024 /* insane or negative size? */
700 || (iov = malloc(size)) == NULL) {
701 fprintf(stderr, "Out of memory\n");
702 return;
703 }
704 if (umoven(tcp, addr, size, (char *) iov) >= 0) {
705 for (i = 0; i < len; i++) {
706 /* include the buffer number to make it easy to
707 * match up the trace with the source */
708 tprintf(" * %lu bytes in buffer %d\n",
709 (unsigned long)iov_iov_len(i), i);
710 dumpstr(tcp, (long) iov_iov_base(i),
711 iov_iov_len(i));
712 }
713 }
714 free(iov);
715 #undef sizeof_iov
716 #undef iov_iov_base
717 #undef iov_iov_len
718 #undef iov
719 }
720 #endif
721
722 void
dumpstr(struct tcb * tcp,long addr,int len)723 dumpstr(struct tcb *tcp, long addr, int len)
724 {
725 static int strsize = -1;
726 static unsigned char *str;
727
728 char outbuf[
729 (
730 (sizeof(
731 "xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx "
732 "1234567890123456") + /*in case I'm off by few:*/ 4)
733 /*align to 8 to make memset easier:*/ + 7) & -8
734 ];
735 const unsigned char *src;
736 int i;
737
738 memset(outbuf, ' ', sizeof(outbuf));
739
740 if (strsize < len + 16) {
741 free(str);
742 str = malloc(len + 16);
743 if (!str) {
744 strsize = -1;
745 fprintf(stderr, "Out of memory\n");
746 return;
747 }
748 strsize = len + 16;
749 }
750
751 if (umoven(tcp, addr, len, (char *) str) < 0)
752 return;
753
754 /* Space-pad to 16 bytes */
755 i = len;
756 while (i & 0xf)
757 str[i++] = ' ';
758
759 i = 0;
760 src = str;
761 while (i < len) {
762 char *dst = outbuf;
763 /* Hex dump */
764 do {
765 if (i < len) {
766 *dst++ = "0123456789abcdef"[*src >> 4];
767 *dst++ = "0123456789abcdef"[*src & 0xf];
768 }
769 else {
770 *dst++ = ' ';
771 *dst++ = ' ';
772 }
773 dst++; /* space is there by memset */
774 i++;
775 if ((i & 7) == 0)
776 dst++; /* space is there by memset */
777 src++;
778 } while (i & 0xf);
779 /* ASCII dump */
780 i -= 16;
781 src -= 16;
782 do {
783 if (*src >= ' ' && *src < 0x7f)
784 *dst++ = *src;
785 else
786 *dst++ = '.';
787 src++;
788 } while (++i & 0xf);
789 *dst = '\0';
790 tprintf(" | %05x %s |\n", i - 16, outbuf);
791 }
792 }
793
794 #ifdef HAVE_PROCESS_VM_READV
795 /* C library supports this, but the kernel might not. */
796 static bool process_vm_readv_not_supported = 0;
797 #else
798
799 /* Need to do this since process_vm_readv() is not yet available in libc.
800 * When libc is be updated, only "static bool process_vm_readv_not_supported"
801 * line should remain.
802 */
803 #if !defined(__NR_process_vm_readv)
804 # if defined(I386)
805 # define __NR_process_vm_readv 347
806 # elif defined(X86_64)
807 # define __NR_process_vm_readv 310
808 # elif defined(POWERPC)
809 # define __NR_process_vm_readv 351
810 # endif
811 #endif
812
813 #if defined(__NR_process_vm_readv)
814 static bool process_vm_readv_not_supported = 0;
815 /* Have to avoid duplicating with the C library headers. */
strace_process_vm_readv(pid_t pid,const struct iovec * lvec,unsigned long liovcnt,const struct iovec * rvec,unsigned long riovcnt,unsigned long flags)816 static ssize_t strace_process_vm_readv(pid_t pid,
817 const struct iovec *lvec,
818 unsigned long liovcnt,
819 const struct iovec *rvec,
820 unsigned long riovcnt,
821 unsigned long flags)
822 {
823 return syscall(__NR_process_vm_readv, (long)pid, lvec, liovcnt, rvec, riovcnt, flags);
824 }
825 #define process_vm_readv strace_process_vm_readv
826 #else
827 static bool process_vm_readv_not_supported = 1;
828 # define process_vm_readv(...) (errno = ENOSYS, -1)
829 #endif
830
831 #endif /* end of hack */
832
833 #define PAGMASK (~(PAGSIZ - 1))
834 /*
835 * move `len' bytes of data from process `pid'
836 * at address `addr' to our space at `laddr'
837 */
838 int
umoven(struct tcb * tcp,long addr,int len,char * laddr)839 umoven(struct tcb *tcp, long addr, int len, char *laddr)
840 {
841 int pid = tcp->pid;
842 int n, m, nread;
843 union {
844 long val;
845 char x[sizeof(long)];
846 } u;
847
848 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
849 if (current_wordsize < sizeof(addr))
850 addr &= (1ul << 8 * current_wordsize) - 1;
851 #endif
852
853 if (!process_vm_readv_not_supported) {
854 struct iovec local[1], remote[1];
855 int r;
856
857 local[0].iov_base = laddr;
858 remote[0].iov_base = (void*)addr;
859 local[0].iov_len = remote[0].iov_len = len;
860 r = process_vm_readv(pid, local, 1, remote, 1, 0);
861 if (r == len)
862 return 0;
863 if (r >= 0) {
864 error_msg("umoven: short read (%d < %d) @0x%lx",
865 r, len, addr);
866 return -1;
867 }
868 switch (errno) {
869 case ENOSYS:
870 process_vm_readv_not_supported = 1;
871 break;
872 case ESRCH:
873 /* the process is gone */
874 return -1;
875 case EFAULT: case EIO: case EPERM:
876 /* address space is inaccessible */
877 return -1;
878 default:
879 /* all the rest is strange and should be reported */
880 perror_msg("process_vm_readv");
881 return -1;
882 }
883 }
884
885 nread = 0;
886 if (addr & (sizeof(long) - 1)) {
887 /* addr not a multiple of sizeof(long) */
888 n = addr - (addr & -sizeof(long)); /* residue */
889 addr &= -sizeof(long); /* residue */
890 errno = 0;
891 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
892 switch (errno) {
893 case 0:
894 break;
895 case ESRCH: case EINVAL:
896 /* these could be seen if the process is gone */
897 return -1;
898 case EFAULT: case EIO: case EPERM:
899 /* address space is inaccessible */
900 return -1;
901 default:
902 /* all the rest is strange and should be reported */
903 perror_msg("umoven: PTRACE_PEEKDATA pid:%d @0x%lx",
904 pid, addr);
905 return -1;
906 }
907 m = MIN(sizeof(long) - n, len);
908 memcpy(laddr, &u.x[n], m);
909 addr += sizeof(long);
910 laddr += m;
911 nread += m;
912 len -= m;
913 }
914 while (len) {
915 errno = 0;
916 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
917 switch (errno) {
918 case 0:
919 break;
920 case ESRCH: case EINVAL:
921 /* these could be seen if the process is gone */
922 return -1;
923 case EFAULT: case EIO: case EPERM:
924 /* address space is inaccessible */
925 if (nread) {
926 perror_msg("umoven: short read (%d < %d) @0x%lx",
927 nread, nread + len, addr - nread);
928 }
929 return -1;
930 default:
931 /* all the rest is strange and should be reported */
932 perror_msg("umoven: PTRACE_PEEKDATA pid:%d @0x%lx",
933 pid, addr);
934 return -1;
935 }
936 m = MIN(sizeof(long), len);
937 memcpy(laddr, u.x, m);
938 addr += sizeof(long);
939 laddr += m;
940 nread += m;
941 len -= m;
942 }
943
944 return 0;
945 }
946
947 /*
948 * Like `umove' but make the additional effort of looking
949 * for a terminating zero byte.
950 *
951 * Returns < 0 on error, > 0 if NUL was seen,
952 * (TODO if useful: return count of bytes including NUL),
953 * else 0 if len bytes were read but no NUL byte seen.
954 *
955 * Note: there is no guarantee we won't overwrite some bytes
956 * in laddr[] _after_ terminating NUL (but, of course,
957 * we never write past laddr[len-1]).
958 */
959 int
umovestr(struct tcb * tcp,long addr,int len,char * laddr)960 umovestr(struct tcb *tcp, long addr, int len, char *laddr)
961 {
962 #if SIZEOF_LONG == 4
963 const unsigned long x01010101 = 0x01010101ul;
964 const unsigned long x80808080 = 0x80808080ul;
965 #elif SIZEOF_LONG == 8
966 const unsigned long x01010101 = 0x0101010101010101ul;
967 const unsigned long x80808080 = 0x8080808080808080ul;
968 #else
969 # error SIZEOF_LONG > 8
970 #endif
971
972 int pid = tcp->pid;
973 int n, m, nread;
974 union {
975 unsigned long val;
976 char x[sizeof(long)];
977 } u;
978
979 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
980 if (current_wordsize < sizeof(addr))
981 addr &= (1ul << 8 * current_wordsize) - 1;
982 #endif
983
984 nread = 0;
985 if (!process_vm_readv_not_supported) {
986 struct iovec local[1], remote[1];
987
988 local[0].iov_base = laddr;
989 remote[0].iov_base = (void*)addr;
990
991 while (len > 0) {
992 int end_in_page;
993 int r;
994 int chunk_len;
995
996 /* Don't read kilobytes: most strings are short */
997 chunk_len = len;
998 if (chunk_len > 256)
999 chunk_len = 256;
1000 /* Don't cross pages. I guess otherwise we can get EFAULT
1001 * and fail to notice that terminating NUL lies
1002 * in the existing (first) page.
1003 * (I hope there aren't arches with pages < 4K)
1004 */
1005 end_in_page = ((addr + chunk_len) & 4095);
1006 r = chunk_len - end_in_page;
1007 if (r > 0) /* if chunk_len > end_in_page */
1008 chunk_len = r; /* chunk_len -= end_in_page */
1009
1010 local[0].iov_len = remote[0].iov_len = chunk_len;
1011 r = process_vm_readv(pid, local, 1, remote, 1, 0);
1012 if (r > 0) {
1013 if (memchr(local[0].iov_base, '\0', r))
1014 return 1;
1015 local[0].iov_base += r;
1016 remote[0].iov_base += r;
1017 len -= r;
1018 nread += r;
1019 continue;
1020 }
1021 switch (errno) {
1022 case ENOSYS:
1023 process_vm_readv_not_supported = 1;
1024 goto vm_readv_didnt_work;
1025 case ESRCH:
1026 /* the process is gone */
1027 return -1;
1028 case EFAULT: case EIO: case EPERM:
1029 /* address space is inaccessible */
1030 if (nread) {
1031 perror_msg("umovestr: short read (%d < %d) @0x%lx",
1032 nread, nread + len, addr);
1033 }
1034 return -1;
1035 default:
1036 /* all the rest is strange and should be reported */
1037 perror_msg("process_vm_readv");
1038 return -1;
1039 }
1040 }
1041 return 0;
1042 }
1043 vm_readv_didnt_work:
1044
1045 if (addr & (sizeof(long) - 1)) {
1046 /* addr not a multiple of sizeof(long) */
1047 n = addr - (addr & -sizeof(long)); /* residue */
1048 addr &= -sizeof(long); /* residue */
1049 errno = 0;
1050 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
1051 switch (errno) {
1052 case 0:
1053 break;
1054 case ESRCH: case EINVAL:
1055 /* these could be seen if the process is gone */
1056 return -1;
1057 case EFAULT: case EIO: case EPERM:
1058 /* address space is inaccessible */
1059 return -1;
1060 default:
1061 /* all the rest is strange and should be reported */
1062 perror_msg("umovestr: PTRACE_PEEKDATA pid:%d @0x%lx",
1063 pid, addr);
1064 return -1;
1065 }
1066 m = MIN(sizeof(long) - n, len);
1067 memcpy(laddr, &u.x[n], m);
1068 while (n & (sizeof(long) - 1))
1069 if (u.x[n++] == '\0')
1070 return 1;
1071 addr += sizeof(long);
1072 laddr += m;
1073 nread += m;
1074 len -= m;
1075 }
1076
1077 while (len) {
1078 errno = 0;
1079 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
1080 switch (errno) {
1081 case 0:
1082 break;
1083 case ESRCH: case EINVAL:
1084 /* these could be seen if the process is gone */
1085 return -1;
1086 case EFAULT: case EIO: case EPERM:
1087 /* address space is inaccessible */
1088 if (nread) {
1089 perror_msg("umovestr: short read (%d < %d) @0x%lx",
1090 nread, nread + len, addr - nread);
1091 }
1092 return -1;
1093 default:
1094 /* all the rest is strange and should be reported */
1095 perror_msg("umovestr: PTRACE_PEEKDATA pid:%d @0x%lx",
1096 pid, addr);
1097 return -1;
1098 }
1099 m = MIN(sizeof(long), len);
1100 memcpy(laddr, u.x, m);
1101 /* "If a NUL char exists in this word" */
1102 if ((u.val - x01010101) & ~u.val & x80808080)
1103 return 1;
1104 addr += sizeof(long);
1105 laddr += m;
1106 nread += m;
1107 len -= m;
1108 }
1109 return 0;
1110 }
1111
1112 int
upeek(int pid,long off,long * res)1113 upeek(int pid, long off, long *res)
1114 {
1115 long val;
1116
1117 errno = 0;
1118 val = ptrace(PTRACE_PEEKUSER, (pid_t)pid, (char *) off, 0);
1119 if (val == -1 && errno) {
1120 if (errno != ESRCH) {
1121 perror_msg("upeek: PTRACE_PEEKUSER pid:%d @0x%lx)", pid, off);
1122 }
1123 return -1;
1124 }
1125 *res = val;
1126 return 0;
1127 }
1128
1129 /* Note! On new kernels (about 2.5.46+), we use PTRACE_O_TRACECLONE
1130 * and PTRACE_O_TRACE[V]FORK for tracing children.
1131 * If you are adding a new arch which is only supported by newer kernels,
1132 * you most likely don't need to add any code below
1133 * beside a dummy "return 0" block in change_syscall().
1134 */
1135
1136 /*
1137 * These #if's are huge, please indent them correctly.
1138 * It's easy to get confused otherwise.
1139 */
1140
1141 #include "syscall.h"
1142
1143 #ifndef CLONE_PTRACE
1144 # define CLONE_PTRACE 0x00002000
1145 #endif
1146 #ifndef CLONE_VFORK
1147 # define CLONE_VFORK 0x00004000
1148 #endif
1149 #ifndef CLONE_VM
1150 # define CLONE_VM 0x00000100
1151 #endif
1152
1153 #ifdef IA64
1154
1155 typedef unsigned long *arg_setup_state;
1156
1157 static int
arg_setup(struct tcb * tcp,arg_setup_state * state)1158 arg_setup(struct tcb *tcp, arg_setup_state *state)
1159 {
1160 unsigned long cfm, sof, sol;
1161 long bsp;
1162
1163 if (ia64_ia32mode) {
1164 /* Satisfy a false GCC warning. */
1165 *state = NULL;
1166 return 0;
1167 }
1168
1169 if (upeek(tcp->pid, PT_AR_BSP, &bsp) < 0)
1170 return -1;
1171 if (upeek(tcp->pid, PT_CFM, (long *) &cfm) < 0)
1172 return -1;
1173
1174 sof = (cfm >> 0) & 0x7f;
1175 sol = (cfm >> 7) & 0x7f;
1176 bsp = (long) ia64_rse_skip_regs((unsigned long *) bsp, -sof + sol);
1177
1178 *state = (unsigned long *) bsp;
1179 return 0;
1180 }
1181
1182 # define arg_finish_change(tcp, state) 0
1183
1184 static int
get_arg0(struct tcb * tcp,arg_setup_state * state,long * valp)1185 get_arg0(struct tcb *tcp, arg_setup_state *state, long *valp)
1186 {
1187 int ret;
1188
1189 if (ia64_ia32mode)
1190 ret = upeek(tcp->pid, PT_R11, valp);
1191 else
1192 ret = umoven(tcp,
1193 (unsigned long) ia64_rse_skip_regs(*state, 0),
1194 sizeof(long), (void *) valp);
1195 return ret;
1196 }
1197
1198 static int
get_arg1(struct tcb * tcp,arg_setup_state * state,long * valp)1199 get_arg1(struct tcb *tcp, arg_setup_state *state, long *valp)
1200 {
1201 int ret;
1202
1203 if (ia64_ia32mode)
1204 ret = upeek(tcp->pid, PT_R9, valp);
1205 else
1206 ret = umoven(tcp,
1207 (unsigned long) ia64_rse_skip_regs(*state, 1),
1208 sizeof(long), (void *) valp);
1209 return ret;
1210 }
1211
1212 static int
set_arg0(struct tcb * tcp,arg_setup_state * state,long val)1213 set_arg0(struct tcb *tcp, arg_setup_state *state, long val)
1214 {
1215 int req = PTRACE_POKEDATA;
1216 void *ap;
1217
1218 if (ia64_ia32mode) {
1219 ap = (void *) (intptr_t) PT_R11; /* r11 == EBX */
1220 req = PTRACE_POKEUSER;
1221 } else
1222 ap = ia64_rse_skip_regs(*state, 0);
1223 errno = 0;
1224 ptrace(req, tcp->pid, ap, val);
1225 return errno ? -1 : 0;
1226 }
1227
1228 static int
set_arg1(struct tcb * tcp,arg_setup_state * state,long val)1229 set_arg1(struct tcb *tcp, arg_setup_state *state, long val)
1230 {
1231 int req = PTRACE_POKEDATA;
1232 void *ap;
1233
1234 if (ia64_ia32mode) {
1235 ap = (void *) (intptr_t) PT_R9; /* r9 == ECX */
1236 req = PTRACE_POKEUSER;
1237 } else
1238 ap = ia64_rse_skip_regs(*state, 1);
1239 errno = 0;
1240 ptrace(req, tcp->pid, ap, val);
1241 return errno ? -1 : 0;
1242 }
1243
1244 /* ia64 does not return the input arguments from functions (and syscalls)
1245 according to ia64 RSE (Register Stack Engine) behavior. */
1246
1247 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1248 # define restore_arg1(tcp, state, val) ((void) (state), 0)
1249
1250 #elif defined(SPARC) || defined(SPARC64)
1251
1252 # if defined(SPARC64)
1253 # undef PTRACE_GETREGS
1254 # define PTRACE_GETREGS PTRACE_GETREGS64
1255 # undef PTRACE_SETREGS
1256 # define PTRACE_SETREGS PTRACE_SETREGS64
1257 # endif
1258
1259 typedef struct pt_regs arg_setup_state;
1260
1261 # define arg_setup(tcp, state) \
1262 (ptrace(PTRACE_GETREGS, (tcp)->pid, (char *) (state), 0))
1263 # define arg_finish_change(tcp, state) \
1264 (ptrace(PTRACE_SETREGS, (tcp)->pid, (char *) (state), 0))
1265
1266 # define get_arg0(tcp, state, valp) (*(valp) = (state)->u_regs[U_REG_O0], 0)
1267 # define get_arg1(tcp, state, valp) (*(valp) = (state)->u_regs[U_REG_O1], 0)
1268 # define set_arg0(tcp, state, val) ((state)->u_regs[U_REG_O0] = (val), 0)
1269 # define set_arg1(tcp, state, val) ((state)->u_regs[U_REG_O1] = (val), 0)
1270 # define restore_arg0(tcp, state, val) 0
1271
1272 #else /* other architectures */
1273
1274 # if defined S390 || defined S390X
1275 /* Note: this is only true for the `clone' system call, which handles
1276 arguments specially. We could as well say that its first two arguments
1277 are swapped relative to other architectures, but that would just be
1278 another #ifdef in the calls. */
1279 # define arg0_offset PT_GPR3
1280 # define arg1_offset PT_ORIGGPR2
1281 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1282 # define restore_arg1(tcp, state, val) ((void) (state), 0)
1283 # define arg0_index 1
1284 # define arg1_index 0
1285 # elif defined(ALPHA) || defined(MIPS)
1286 # define arg0_offset REG_A0
1287 # define arg1_offset (REG_A0+1)
1288 # elif defined(POWERPC)
1289 # define arg0_offset (sizeof(unsigned long)*PT_R3)
1290 # define arg1_offset (sizeof(unsigned long)*PT_R4)
1291 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1292 # elif defined(HPPA)
1293 # define arg0_offset PT_GR26
1294 # define arg1_offset (PT_GR26-4)
1295 # elif defined(X86_64) || defined(X32)
1296 # define arg0_offset ((long)(8*(current_personality ? RBX : RDI)))
1297 # define arg1_offset ((long)(8*(current_personality ? RCX : RSI)))
1298 # elif defined(SH)
1299 # define arg0_offset (4*(REG_REG0+4))
1300 # define arg1_offset (4*(REG_REG0+5))
1301 # elif defined(SH64)
1302 /* ABI defines arg0 & 1 in r2 & r3 */
1303 # define arg0_offset (REG_OFFSET+16)
1304 # define arg1_offset (REG_OFFSET+24)
1305 # define restore_arg0(tcp, state, val) 0
1306 # elif defined CRISV10 || defined CRISV32
1307 # define arg0_offset (4*PT_R11)
1308 # define arg1_offset (4*PT_ORIG_R10)
1309 # define restore_arg0(tcp, state, val) 0
1310 # define restore_arg1(tcp, state, val) 0
1311 # define arg0_index 1
1312 # define arg1_index 0
1313 # else
1314 # define arg0_offset 0
1315 # define arg1_offset 4
1316 # if defined ARM
1317 # define restore_arg0(tcp, state, val) 0
1318 # endif
1319 # endif
1320
1321 typedef int arg_setup_state;
1322
1323 # define arg_setup(tcp, state) (0)
1324 # define arg_finish_change(tcp, state) 0
1325 # define get_arg0(tcp, cookie, valp) (upeek((tcp)->pid, arg0_offset, (valp)))
1326 # define get_arg1(tcp, cookie, valp) (upeek((tcp)->pid, arg1_offset, (valp)))
1327
1328 static int
set_arg0(struct tcb * tcp,void * cookie,long val)1329 set_arg0(struct tcb *tcp, void *cookie, long val)
1330 {
1331 return ptrace(PTRACE_POKEUSER, tcp->pid, (char*)arg0_offset, val);
1332 }
1333
1334 static int
set_arg1(struct tcb * tcp,void * cookie,long val)1335 set_arg1(struct tcb *tcp, void *cookie, long val)
1336 {
1337 return ptrace(PTRACE_POKEUSER, tcp->pid, (char*)arg1_offset, val);
1338 }
1339
1340 #endif /* architectures */
1341
1342 #ifndef restore_arg0
1343 # define restore_arg0(tcp, state, val) set_arg0((tcp), (state), (val))
1344 #endif
1345 #ifndef restore_arg1
1346 # define restore_arg1(tcp, state, val) set_arg1((tcp), (state), (val))
1347 #endif
1348
1349 #ifndef arg0_index
1350 # define arg0_index 0
1351 # define arg1_index 1
1352 #endif
1353
1354 static int
change_syscall(struct tcb * tcp,arg_setup_state * state,int new)1355 change_syscall(struct tcb *tcp, arg_setup_state *state, int new)
1356 {
1357 #if defined(I386)
1358 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(ORIG_EAX * 4), new) < 0)
1359 return -1;
1360 return 0;
1361 #elif defined(X86_64)
1362 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(ORIG_RAX * 8), new) < 0)
1363 return -1;
1364 return 0;
1365 #elif defined(X32)
1366 /* setbpt/clearbpt never used: */
1367 /* X32 is only supported since about linux-3.0.30 */
1368 #elif defined(POWERPC)
1369 if (ptrace(PTRACE_POKEUSER, tcp->pid,
1370 (char*)(sizeof(unsigned long)*PT_R0), new) < 0)
1371 return -1;
1372 return 0;
1373 #elif defined(S390) || defined(S390X)
1374 /* s390 linux after 2.4.7 has a hook in entry.S to allow this */
1375 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_GPR2), new) < 0)
1376 return -1;
1377 return 0;
1378 #elif defined(M68K)
1379 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*PT_ORIG_D0), new) < 0)
1380 return -1;
1381 return 0;
1382 #elif defined(SPARC) || defined(SPARC64)
1383 state->u_regs[U_REG_G1] = new;
1384 return 0;
1385 #elif defined(MIPS)
1386 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_V0), new) < 0)
1387 return -1;
1388 return 0;
1389 #elif defined(ALPHA)
1390 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_A3), new) < 0)
1391 return -1;
1392 return 0;
1393 #elif defined(AVR32)
1394 /* setbpt/clearbpt never used: */
1395 /* AVR32 is only supported since about linux-2.6.19 */
1396 #elif defined(BFIN)
1397 /* setbpt/clearbpt never used: */
1398 /* Blackfin is only supported since about linux-2.6.23 */
1399 #elif defined(IA64)
1400 if (ia64_ia32mode) {
1401 switch (new) {
1402 case 2:
1403 break; /* x86 SYS_fork */
1404 case SYS_clone:
1405 new = 120;
1406 break;
1407 default:
1408 fprintf(stderr, "%s: unexpected syscall %d\n",
1409 __FUNCTION__, new);
1410 return -1;
1411 }
1412 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_R1), new) < 0)
1413 return -1;
1414 } else if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_R15), new) < 0)
1415 return -1;
1416 return 0;
1417 #elif defined(HPPA)
1418 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_GR20), new) < 0)
1419 return -1;
1420 return 0;
1421 #elif defined(SH)
1422 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*(REG_REG0+3)), new) < 0)
1423 return -1;
1424 return 0;
1425 #elif defined(SH64)
1426 /* Top half of reg encodes the no. of args n as 0x1n.
1427 Assume 0 args as kernel never actually checks... */
1428 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_SYSCALL),
1429 0x100000 | new) < 0)
1430 return -1;
1431 return 0;
1432 #elif defined(CRISV10) || defined(CRISV32)
1433 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*PT_R9), new) < 0)
1434 return -1;
1435 return 0;
1436 #elif defined(ARM)
1437 /* Some kernels support this, some (pre-2.6.16 or so) don't. */
1438 # ifndef PTRACE_SET_SYSCALL
1439 # define PTRACE_SET_SYSCALL 23
1440 # endif
1441 if (ptrace(PTRACE_SET_SYSCALL, tcp->pid, 0, new & 0xffff) != 0)
1442 return -1;
1443 return 0;
1444 #elif defined(AARCH64)
1445 /* setbpt/clearbpt never used: */
1446 /* AARCH64 is only supported since about linux-3.0.31 */
1447 #elif defined(TILE)
1448 /* setbpt/clearbpt never used: */
1449 /* Tilera CPUs are only supported since about linux-2.6.34 */
1450 #elif defined(MICROBLAZE)
1451 /* setbpt/clearbpt never used: */
1452 /* microblaze is only supported since about linux-2.6.30 */
1453 #elif defined(OR1K)
1454 /* never reached; OR1K is only supported by kernels since 3.1.0. */
1455 #elif defined(METAG)
1456 /* setbpt/clearbpt never used: */
1457 /* Meta is only supported since linux-3.7 */
1458 #elif defined(XTENSA)
1459 /* setbpt/clearbpt never used: */
1460 /* Xtensa is only supported since linux 2.6.13 */
1461 #elif defined(ARC)
1462 /* setbpt/clearbpt never used: */
1463 /* ARC only supported since 3.9 */
1464 #else
1465 #warning Do not know how to handle change_syscall for this architecture
1466 #endif /* architecture */
1467 return -1;
1468 }
1469
1470 int
setbpt(struct tcb * tcp)1471 setbpt(struct tcb *tcp)
1472 {
1473 static int clone_scno[SUPPORTED_PERSONALITIES] = { SYS_clone };
1474 arg_setup_state state;
1475
1476 if (tcp->flags & TCB_BPTSET) {
1477 fprintf(stderr, "PANIC: TCB already set in pid %u\n", tcp->pid);
1478 return -1;
1479 }
1480
1481 /*
1482 * It's a silly kludge to initialize this with a search at runtime.
1483 * But it's better than maintaining another magic thing in the
1484 * godforsaken tables.
1485 */
1486 if (clone_scno[current_personality] == 0) {
1487 int i;
1488 for (i = 0; i < nsyscalls; ++i)
1489 if (sysent[i].sys_func == sys_clone) {
1490 clone_scno[current_personality] = i;
1491 break;
1492 }
1493 }
1494
1495 if (tcp->s_ent->sys_func == sys_fork) {
1496 if (arg_setup(tcp, &state) < 0
1497 || get_arg0(tcp, &state, &tcp->inst[0]) < 0
1498 || get_arg1(tcp, &state, &tcp->inst[1]) < 0
1499 || change_syscall(tcp, &state,
1500 clone_scno[current_personality]) < 0
1501 || set_arg0(tcp, &state, CLONE_PTRACE|SIGCHLD) < 0
1502 || set_arg1(tcp, &state, 0) < 0
1503 || arg_finish_change(tcp, &state) < 0)
1504 return -1;
1505 tcp->u_arg[arg0_index] = CLONE_PTRACE|SIGCHLD;
1506 tcp->u_arg[arg1_index] = 0;
1507 tcp->flags |= TCB_BPTSET;
1508 return 0;
1509 }
1510
1511 if (tcp->s_ent->sys_func == sys_clone) {
1512 /* ia64 calls directly `clone (CLONE_VFORK | CLONE_VM)'
1513 contrary to x86 vfork above. Even on x86 we turn the
1514 vfork semantics into plain fork - each application must not
1515 depend on the vfork specifics according to POSIX. We would
1516 hang waiting for the parent resume otherwise. We need to
1517 clear also CLONE_VM but only in the CLONE_VFORK case as
1518 otherwise we would break pthread_create. */
1519
1520 long new_arg0 = (tcp->u_arg[arg0_index] | CLONE_PTRACE);
1521 if (new_arg0 & CLONE_VFORK)
1522 new_arg0 &= ~(unsigned long)(CLONE_VFORK | CLONE_VM);
1523 if (arg_setup(tcp, &state) < 0
1524 || set_arg0(tcp, &state, new_arg0) < 0
1525 || arg_finish_change(tcp, &state) < 0)
1526 return -1;
1527 tcp->inst[0] = tcp->u_arg[arg0_index];
1528 tcp->inst[1] = tcp->u_arg[arg1_index];
1529 tcp->flags |= TCB_BPTSET;
1530 return 0;
1531 }
1532
1533 fprintf(stderr, "PANIC: setbpt for syscall %ld on %u???\n",
1534 tcp->scno, tcp->pid);
1535 return -1;
1536 }
1537
1538 int
clearbpt(struct tcb * tcp)1539 clearbpt(struct tcb *tcp)
1540 {
1541 arg_setup_state state;
1542 if (arg_setup(tcp, &state) < 0
1543 || change_syscall(tcp, &state, tcp->scno) < 0
1544 || restore_arg0(tcp, &state, tcp->inst[0]) < 0
1545 || restore_arg1(tcp, &state, tcp->inst[1]) < 0
1546 || arg_finish_change(tcp, &state))
1547 if (errno != ESRCH)
1548 return -1;
1549 tcp->flags &= ~TCB_BPTSET;
1550 return 0;
1551 }
1552