1 /* 2 * Copyright (c) 1991, 1992 Paul Kranenburg <pk (at) cs.few.eur.nl> 3 * Copyright (c) 1993 Branko Lankester <branko (at) hacktic.nl> 4 * Copyright (c) 1993, 1994, 1995, 1996 Rick Sladkey <jrs (at) world.std.com> 5 * Copyright (c) 1996-1999 Wichert Akkerman <wichert (at) cistron.nl> 6 * Copyright (c) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation 7 * Linux for s390 port by D.J. Barrow 8 * <barrow_dj (at) mail.yahoo.com,djbarrow (at) 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 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 82 tv_nz(const struct timeval *a) 83 { 84 return a->tv_sec || a->tv_usec; 85 } 86 87 int 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 100 tv_float(const struct timeval *tv) 101 { 102 return tv->tv_sec + tv->tv_usec/1000000.0; 103 } 104 105 void 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 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 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 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 * 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 * 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 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 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 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 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 * 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 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 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 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 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 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 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 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 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 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 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 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. */ 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 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 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 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 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 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 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 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 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 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 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 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 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 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
