granicus.if.org Git - strace/blob - util.c

   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
  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 }