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  *      $Id$
  34  */
  35
  36 #include "defs.h"
  37
  38 #include <signal.h>
  39 #include <sys/syscall.h>
  40 #include <sys/user.h>
  41 #include <sys/param.h>
  42 #include <fcntl.h>
  43 #if HAVE_SYS_UIO_H
  44 #include <sys/uio.h>
  45 #endif
  46 #ifdef SUNOS4
  47 #include <machine/reg.h>
  48 #include <a.out.h>
  49 #include <link.h>
  50 #endif /* SUNOS4 */
  51
  52 #if defined(linux) && (__GLIBC__ < 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ < 1))
  53 #include <linux/ptrace.h>
  54 #endif
  55
  56 #if defined(LINUX) && defined(IA64)
  57 # include <asm/ptrace_offsets.h>
  58 # include <asm/rse.h>
  59 #endif
  60
  61 #ifdef HAVE_SYS_REG_H
  62 #include <sys/reg.h>
  63 # define PTRACE_PEEKUSR PTRACE_PEEKUSER
  64 #elif defined(HAVE_LINUX_PTRACE_H)
  65 #undef PTRACE_SYSCALL
  66 # ifdef HAVE_STRUCT_IA64_FPREG
  67 #  define ia64_fpreg XXX_ia64_fpreg
  68 # endif
  69 # ifdef HAVE_STRUCT_PT_ALL_USER_REGS
  70 #  define pt_all_user_regs XXX_pt_all_user_regs
  71 # endif
  72 #include <linux/ptrace.h>
  73 # undef ia64_fpreg
  74 # undef pt_all_user_regs
  75 #endif
  76
  77 #ifdef SUNOS4_KERNEL_ARCH_KLUDGE
  78 #include <sys/utsname.h>
  79 #endif /* SUNOS4_KERNEL_ARCH_KLUDGE */
  80
  81 #if defined(LINUXSPARC) && defined (SPARC64)
  82 # undef PTRACE_GETREGS
  83 # define PTRACE_GETREGS PTRACE_GETREGS64
  84 # undef PTRACE_SETREGS
  85 # define PTRACE_SETREGS PTRACE_SETREGS64
  86 #endif
  87
  88 /* macros */
  89 #ifndef MAX
  90 #define MAX(a,b)                (((a) > (b)) ? (a) : (b))
  91 #endif
  92 #ifndef MIN
  93 #define MIN(a,b)                (((a) < (b)) ? (a) : (b))
  94 #endif
  95
  96 int
  97 tv_nz(struct timeval *a)
  98 {
  99         return a->tv_sec || a->tv_usec;
 100 }
 101
 102 int
 103 tv_cmp(struct timeval *a, struct timeval *b)
 104 {
 105         if (a->tv_sec < b->tv_sec
 106             || (a->tv_sec == b->tv_sec && a->tv_usec < b->tv_usec))
 107                 return -1;
 108         if (a->tv_sec > b->tv_sec
 109             || (a->tv_sec == b->tv_sec && a->tv_usec > b->tv_usec))
 110                 return 1;
 111         return 0;
 112 }
 113
 114 double
 115 tv_float(struct timeval *tv)
 116 {
 117         return tv->tv_sec + tv->tv_usec/1000000.0;
 118 }
 119
 120 void
 121 tv_add(struct timeval *tv, struct timeval *a, struct timeval *b)
 122 {
 123         tv->tv_sec = a->tv_sec + b->tv_sec;
 124         tv->tv_usec = a->tv_usec + b->tv_usec;
 125         if (tv->tv_usec >= 1000000) {
 126                 tv->tv_sec++;
 127                 tv->tv_usec -= 1000000;
 128         }
 129 }
 130
 131 void
 132 tv_sub(struct timeval *tv, struct timeval *a, struct timeval *b)
 133 {
 134         tv->tv_sec = a->tv_sec - b->tv_sec;
 135         tv->tv_usec = a->tv_usec - b->tv_usec;
 136         if (((long) tv->tv_usec) < 0) {
 137                 tv->tv_sec--;
 138                 tv->tv_usec += 1000000;
 139         }
 140 }
 141
 142 void
 143 tv_div(struct timeval *tv, struct timeval *a, int n)
 144 {
 145         tv->tv_usec = (a->tv_sec % n * 1000000 + a->tv_usec + n / 2) / n;
 146         tv->tv_sec = a->tv_sec / n + tv->tv_usec / 1000000;
 147         tv->tv_usec %= 1000000;
 148 }
 149
 150 void
 151 tv_mul(struct timeval *tv, struct timeval *a, int n)
 152 {
 153         tv->tv_usec = a->tv_usec * n;
 154         tv->tv_sec = a->tv_sec * n + tv->tv_usec / 1000000;
 155         tv->tv_usec %= 1000000;
 156 }
 157
 158 const char *
 159 xlookup(const struct xlat *xlat, int val)
 160 {
 161         for (; xlat->str != NULL; xlat++)
 162                 if (xlat->val == val)
 163                         return xlat->str;
 164         return NULL;
 165 }
 166
 167 #if !defined HAVE_STPCPY
 168 char *
 169 stpcpy(char *dst, const char *src)
 170 {
 171         while ((*dst = *src++) != '\0')
 172                 dst++;
 173         return dst;
 174 }
 175 #endif
 176
 177 /*
 178  * Generic ptrace wrapper which tracks ESRCH errors
 179  * by setting tcp->ptrace_errno to ESRCH.
 180  *
 181  * We assume that ESRCH indicates likely process death (SIGKILL?),
 182  * modulo bugs where process somehow ended up not stopped.
 183  * Unfortunately kernel uses ESRCH for that case too. Oh well.
 184  *
 185  * Currently used by upeek() only.
 186  * TODO: use this in all other ptrace() calls while decoding.
 187  */
 188 long
 189 do_ptrace(int request, struct tcb *tcp, void *addr, void *data)
 190 {
 191         long l;
 192
 193         errno = 0;
 194         l = ptrace(request, tcp->pid, addr, (long) data);
 195         /* Non-ESRCH errors might be our invalid reg/mem accesses,
 196          * we do not record them. */
 197         if (errno == ESRCH)
 198                 tcp->ptrace_errno = ESRCH;
 199         return l;
 200 }
 201
 202 /*
 203  * Used when we want to unblock stopped traced process.
 204  * Should be only used with PTRACE_CONT, PTRACE_DETACH and PTRACE_SYSCALL.
 205  * Returns 0 on success or if error was ESRCH
 206  * (presumably process was killed while we talk to it).
 207  * Otherwise prints error message and returns -1.
 208  */
 209 int
 210 ptrace_restart(int op, struct tcb *tcp, int sig)
 211 {
 212         int err;
 213         const char *msg;
 214
 215         errno = 0;
 216         ptrace(op, tcp->pid, (void *) 1, (long) sig);
 217         err = errno;
 218         if (!err || err == ESRCH)
 219                 return 0;
 220
 221         tcp->ptrace_errno = err;
 222         msg = "SYSCALL";
 223         if (op == PTRACE_CONT)
 224                 msg = "CONT";
 225         if (op == PTRACE_DETACH)
 226                 msg = "DETACH";
 227         perror_msg("ptrace(PTRACE_%s,1,%d)", msg, sig);
 228         return -1;
 229 }
 230
 231 /*
 232  * Print entry in struct xlat table, if there.
 233  */
 234 void
 235 printxval(const struct xlat *xlat, int val, const char *dflt)
 236 {
 237         const char *str = xlookup(xlat, val);
 238
 239         if (str)
 240                 tprints(str);
 241         else
 242                 tprintf("%#x /* %s */", val, dflt);
 243 }
 244
 245 #if HAVE_LONG_LONG
 246 /*
 247  * Print 64bit argument at position llarg and return the index of the next
 248  * argument.
 249  */
 250 int
 251 printllval(struct tcb *tcp, const char *format, int llarg)
 252 {
 253 # if defined(FREEBSD) \
 254      || (defined(LINUX) && defined(POWERPC) && !defined(POWERPC64)) \
 255      || defined(LINUX_MIPSO32) \
 256      || defined(__ARM_EABI__)
 257         /* Align 64bit argument to 64bit boundary.  */
 258         llarg = (llarg + 1) & 0x1e;
 259 # endif
 260 # if defined LINUX && (defined X86_64 || defined POWERPC64)
 261         if (current_personality == 0) {
 262                 tprintf(format, tcp->u_arg[llarg]);
 263                 llarg++;
 264         } else {
 265 #  ifdef POWERPC64
 266                 /* Align 64bit argument to 64bit boundary.  */
 267                 llarg = (llarg + 1) & 0x1e;
 268 #  endif
 269                 tprintf(format, LONG_LONG(tcp->u_arg[llarg], tcp->u_arg[llarg + 1]));
 270                 llarg += 2;
 271         }
 272 # elif defined IA64 || defined ALPHA
 273         tprintf(format, tcp->u_arg[llarg]);
 274         llarg++;
 275 # elif defined LINUX_MIPSN32
 276         tprintf(format, tcp->ext_arg[llarg]);
 277         llarg++;
 278 # else
 279         tprintf(format, LONG_LONG(tcp->u_arg[llarg], tcp->u_arg[llarg + 1]));
 280         llarg += 2;
 281 # endif
 282         return llarg;
 283 }
 284 #endif
 285
 286 /*
 287  * Interpret `xlat' as an array of flags
 288  * print the entries whose bits are on in `flags'
 289  * return # of flags printed.
 290  */
 291 void
 292 addflags(const struct xlat *xlat, int flags)
 293 {
 294         for (; xlat->str; xlat++) {
 295                 if (xlat->val && (flags & xlat->val) == xlat->val) {
 296                         tprintf("|%s", xlat->str);
 297                         flags &= ~xlat->val;
 298                 }
 299         }
 300         if (flags) {
 301                 tprintf("|%#x", flags);
 302         }
 303 }
 304
 305 /*
 306  * Interpret `xlat' as an array of flags.
 307  * Print to static string the entries whose bits are on in `flags'
 308  * Return static string.
 309  */
 310 const char *
 311 sprintflags(const char *prefix, const struct xlat *xlat, int flags)
 312 {
 313         static char outstr[1024];
 314         char *outptr;
 315         int found = 0;
 316
 317         outptr = stpcpy(outstr, prefix);
 318
 319         for (; xlat->str; xlat++) {
 320                 if ((flags & xlat->val) == xlat->val) {
 321                         if (found)
 322                                 *outptr++ = '|';
 323                         outptr = stpcpy(outptr, xlat->str);
 324                         flags &= ~xlat->val;
 325                         found = 1;
 326                 }
 327         }
 328         if (flags) {
 329                 if (found)
 330                         *outptr++ = '|';
 331                 outptr += sprintf(outptr, "%#x", flags);
 332         }
 333
 334         return outstr;
 335 }
 336
 337 int
 338 printflags(const struct xlat *xlat, int flags, const char *dflt)
 339 {
 340         int n;
 341         const char *sep;
 342
 343         if (flags == 0 && xlat->val == 0) {
 344                 tprints(xlat->str);
 345                 return 1;
 346         }
 347
 348         sep = "";
 349         for (n = 0; xlat->str; xlat++) {
 350                 if (xlat->val && (flags & xlat->val) == xlat->val) {
 351                         tprintf("%s%s", sep, xlat->str);
 352                         flags &= ~xlat->val;
 353                         sep = "|";
 354                         n++;
 355                 }
 356         }
 357
 358         if (n) {
 359                 if (flags) {
 360                         tprintf("%s%#x", sep, flags);
 361                         n++;
 362                 }
 363         } else {
 364                 if (flags) {
 365                         tprintf("%#x", flags);
 366                         if (dflt)
 367                                 tprintf(" /* %s */", dflt);
 368                 } else {
 369                         if (dflt)
 370                                 tprints("0");
 371                 }
 372         }
 373
 374         return n;
 375 }
 376
 377 void
 378 printnum(struct tcb *tcp, long addr, const char *fmt)
 379 {
 380         long num;
 381
 382         if (!addr) {
 383                 tprints("NULL");
 384                 return;
 385         }
 386         if (umove(tcp, addr, &num) < 0) {
 387                 tprintf("%#lx", addr);
 388                 return;
 389         }
 390         tprints("[");
 391         tprintf(fmt, num);
 392         tprints("]");
 393 }
 394
 395 void
 396 printnum_int(struct tcb *tcp, long addr, const char *fmt)
 397 {
 398         int num;
 399
 400         if (!addr) {
 401                 tprints("NULL");
 402                 return;
 403         }
 404         if (umove(tcp, addr, &num) < 0) {
 405                 tprintf("%#lx", addr);
 406                 return;
 407         }
 408         tprints("[");
 409         tprintf(fmt, num);
 410         tprints("]");
 411 }
 412
 413 void
 414 printfd(struct tcb *tcp, int fd)
 415 {
 416         const char *p;
 417
 418         if (show_fd_path && (p = getfdpath(tcp, fd)))
 419                 tprintf("%d<%s>", fd, p);
 420         else
 421                 tprintf("%d", fd);
 422 }
 423
 424 void
 425 printuid(const char *text, unsigned long uid)
 426 {
 427         tprintf((uid == -1) ? "%s%ld" : "%s%lu", text, uid);
 428 }
 429
 430 /*
 431  * Quote string `instr' of length `size'
 432  * Write up to (3 + `size' * 4) bytes to `outstr' buffer.
 433  * If `len' < 0, treat `instr' as a NUL-terminated string
 434  * and quote at most (`size' - 1) bytes.
 435  *
 436  * Returns 0 if len < 0 and NUL was seen, 1 otherwise.
 437  * Note that if len >= 0, always returns 1.
 438  */
 439 static int
 440 string_quote(const char *instr, char *outstr, int len, int size)
 441 {
 442         const unsigned char *ustr = (const unsigned char *) instr;
 443         char *s = outstr;
 444         int usehex, c, i, eol;
 445
 446         eol = 0x100; /* this can never match a char */
 447         if (len < 0) {
 448                 size--;
 449                 eol = '\0';
 450         }
 451
 452         usehex = 0;
 453         if (xflag > 1)
 454                 usehex = 1;
 455         else if (xflag) {
 456                 /* Check for presence of symbol which require
 457                    to hex-quote the whole string. */
 458                 for (i = 0; i < size; ++i) {
 459                         c = ustr[i];
 460                         /* Check for NUL-terminated string. */
 461                         if (c == eol)
 462                                 break;
 463                         if (!isprint(c) && !isspace(c)) {
 464                                 usehex = 1;
 465                                 break;
 466                         }
 467                 }
 468         }
 469
 470         *s++ = '\"';
 471
 472         if (usehex) {
 473                 /* Hex-quote the whole string. */
 474                 for (i = 0; i < size; ++i) {
 475                         c = ustr[i];
 476                         /* Check for NUL-terminated string. */
 477                         if (c == eol)
 478                                 goto asciz_ended;
 479                         *s++ = '\\';
 480                         *s++ = 'x';
 481                         *s++ = "0123456789abcdef"[c >> 4];
 482                         *s++ = "0123456789abcdef"[c & 0xf];
 483                 }
 484         } else {
 485                 for (i = 0; i < size; ++i) {
 486                         c = ustr[i];
 487                         /* Check for NUL-terminated string. */
 488                         if (c == eol)
 489                                 goto asciz_ended;
 490                         switch (c) {
 491                                 case '\"': case '\\':
 492                                         *s++ = '\\';
 493                                         *s++ = c;
 494                                         break;
 495                                 case '\f':
 496                                         *s++ = '\\';
 497                                         *s++ = 'f';
 498                                         break;
 499                                 case '\n':
 500                                         *s++ = '\\';
 501                                         *s++ = 'n';
 502                                         break;
 503                                 case '\r':
 504                                         *s++ = '\\';
 505                                         *s++ = 'r';
 506                                         break;
 507                                 case '\t':
 508                                         *s++ = '\\';
 509                                         *s++ = 't';
 510                                         break;
 511                                 case '\v':
 512                                         *s++ = '\\';
 513                                         *s++ = 'v';
 514                                         break;
 515                                 default:
 516                                         if (isprint(c))
 517                                                 *s++ = c;
 518                                         else {
 519                                                 /* Print \octal */
 520                                                 *s++ = '\\';
 521                                                 if (i + 1 < size
 522                                                     && ustr[i + 1] >= '0'
 523                                                     && ustr[i + 1] <= '9'
 524                                                 ) {
 525                                                         /* Print \ooo */
 526                                                         *s++ = '0' + (c >> 6);
 527                                                         *s++ = '0' + ((c >> 3) & 0x7);
 528                                                 } else {
 529                                                         /* Print \[[o]o]o */
 530                                                         if ((c >> 3) != 0) {
 531                                                                 if ((c >> 6) != 0)
 532                                                                         *s++ = '0' + (c >> 6);
 533                                                                 *s++ = '0' + ((c >> 3) & 0x7);
 534                                                         }
 535                                                 }
 536                                                 *s++ = '0' + (c & 0x7);
 537                                         }
 538                                         break;
 539                         }
 540                 }
 541         }
 542
 543         *s++ = '\"';
 544         *s = '\0';
 545
 546         /* Return zero if we printed entire ASCIZ string (didn't truncate it) */
 547         if (len < 0 && ustr[i] == '\0') {
 548                 /* We didn't see NUL yet (otherwise we'd jump to 'asciz_ended')
 549                  * but next char is NUL.
 550                  */
 551                 return 0;
 552         }
 553
 554         return 1;
 555
 556  asciz_ended:
 557         *s++ = '\"';
 558         *s = '\0';
 559         /* Return zero: we printed entire ASCIZ string (didn't truncate it) */
 560         return 0;
 561 }
 562
 563 /*
 564  * Print path string specified by address `addr' and length `n'.
 565  * If path length exceeds `n', append `...' to the output.
 566  */
 567 void
 568 printpathn(struct tcb *tcp, long addr, int n)
 569 {
 570         char path[MAXPATHLEN + 1];
 571         int nul_seen;
 572
 573         if (!addr) {
 574                 tprints("NULL");
 575                 return;
 576         }
 577
 578         /* Cap path length to the path buffer size */
 579         if (n > sizeof path - 1)
 580                 n = sizeof path - 1;
 581
 582         /* Fetch one byte more to find out whether path length > n. */
 583         nul_seen = umovestr(tcp, addr, n + 1, path);
 584         if (nul_seen < 0)
 585                 tprintf("%#lx", addr);
 586         else {
 587                 char *outstr;
 588
 589                 path[n] = '\0';
 590                 n++;
 591                 outstr = alloca(4 * n); /* 4*(n-1) + 3 for quotes and NUL */
 592                 string_quote(path, outstr, -1, n);
 593                 tprints(outstr);
 594                 if (!nul_seen)
 595                         tprints("...");
 596         }
 597 }
 598
 599 void
 600 printpath(struct tcb *tcp, long addr)
 601 {
 602         /* Size must correspond to char path[] size in printpathn */
 603         printpathn(tcp, addr, MAXPATHLEN);
 604 }
 605
 606 /*
 607  * Print string specified by address `addr' and length `len'.
 608  * If `len' < 0, treat the string as a NUL-terminated string.
 609  * If string length exceeds `max_strlen', append `...' to the output.
 610  */
 611 void
 612 printstr(struct tcb *tcp, long addr, int len)
 613 {
 614         static char *str = NULL;
 615         static char *outstr;
 616         int size;
 617         int ellipsis;
 618
 619         if (!addr) {
 620                 tprints("NULL");
 621                 return;
 622         }
 623         /* Allocate static buffers if they are not allocated yet. */
 624         if (!str) {
 625                 str = malloc(max_strlen + 1);
 626                 if (!str)
 627                         die_out_of_memory();
 628                 outstr = malloc(4 * max_strlen + /*for quotes and NUL:*/ 3);
 629                 if (!outstr)
 630                         die_out_of_memory();
 631         }
 632
 633         if (len < 0) {
 634                 /*
 635                  * Treat as a NUL-terminated string: fetch one byte more
 636                  * because string_quote() quotes one byte less.
 637                  */
 638                 size = max_strlen + 1;
 639                 if (umovestr(tcp, addr, size, str) < 0) {
 640                         tprintf("%#lx", addr);
 641                         return;
 642                 }
 643         }
 644         else {
 645                 size = MIN(len, max_strlen);
 646                 if (umoven(tcp, addr, size, str) < 0) {
 647                         tprintf("%#lx", addr);
 648                         return;
 649                 }
 650         }
 651
 652         /* If string_quote didn't see NUL and (it was supposed to be ASCIZ str
 653          * or we were requested to print more than -s NUM chars)...
 654          */
 655         ellipsis = (string_quote(str, outstr, len, size) &&
 656                         (len < 0 || len > max_strlen));
 657
 658         tprints(outstr);
 659         if (ellipsis)
 660                 tprints("...");
 661 }
 662
 663 #if HAVE_SYS_UIO_H
 664 void
 665 dumpiov(struct tcb *tcp, int len, long addr)
 666 {
 667 #if defined(LINUX) && SUPPORTED_PERSONALITIES > 1
 668         union {
 669                 struct { u_int32_t base; u_int32_t len; } *iov32;
 670                 struct { u_int64_t base; u_int64_t len; } *iov64;
 671         } iovu;
 672 #define iov iovu.iov64
 673 #define sizeof_iov \
 674   (personality_wordsize[current_personality] == 4 \
 675    ? sizeof(*iovu.iov32) : sizeof(*iovu.iov64))
 676 #define iov_iov_base(i) \
 677   (personality_wordsize[current_personality] == 4 \
 678    ? (u_int64_t) iovu.iov32[i].base : iovu.iov64[i].base)
 679 #define iov_iov_len(i) \
 680   (personality_wordsize[current_personality] == 4 \
 681    ? (u_int64_t) iovu.iov32[i].len : iovu.iov64[i].len)
 682 #else
 683         struct iovec *iov;
 684 #define sizeof_iov sizeof(*iov)
 685 #define iov_iov_base(i) iov[i].iov_base
 686 #define iov_iov_len(i) iov[i].iov_len
 687 #endif
 688         int i;
 689         unsigned size;
 690
 691         size = sizeof_iov * len;
 692         /* Assuming no sane program has millions of iovs */
 693         if ((unsigned)len > 1024*1024 /* insane or negative size? */
 694             || (iov = malloc(size)) == NULL) {
 695                 fprintf(stderr, "Out of memory\n");
 696                 return;
 697         }
 698         if (umoven(tcp, addr, size, (char *) iov) >= 0) {
 699                 for (i = 0; i < len; i++) {
 700                         /* include the buffer number to make it easy to
 701                          * match up the trace with the source */
 702                         tprintf(" * %lu bytes in buffer %d\n",
 703                                 (unsigned long)iov_iov_len(i), i);
 704                         dumpstr(tcp, (long) iov_iov_base(i),
 705                                 iov_iov_len(i));
 706                 }
 707         }
 708         free(iov);
 709 #undef sizeof_iov
 710 #undef iov_iov_base
 711 #undef iov_iov_len
 712 #undef iov
 713 }
 714 #endif
 715
 716 void
 717 dumpstr(struct tcb *tcp, long addr, int len)
 718 {
 719         static int strsize = -1;
 720         static unsigned char *str;
 721         char *s;
 722         int i, j;
 723
 724         if (strsize < len) {
 725                 free(str);
 726                 str = malloc(len);
 727                 if (!str) {
 728                         strsize = -1;
 729                         fprintf(stderr, "Out of memory\n");
 730                         return;
 731                 }
 732                 strsize = len;
 733         }
 734
 735         if (umoven(tcp, addr, len, (char *) str) < 0)
 736                 return;
 737
 738         for (i = 0; i < len; i += 16) {
 739                 char outstr[80];
 740
 741                 s = outstr;
 742                 sprintf(s, " | %05x ", i);
 743                 s += 9;
 744                 for (j = 0; j < 16; j++) {
 745                         if (j == 8)
 746                                 *s++ = ' ';
 747                         if (i + j < len) {
 748                                 sprintf(s, " %02x", str[i + j]);
 749                                 s += 3;
 750                         }
 751                         else {
 752                                 *s++ = ' '; *s++ = ' '; *s++ = ' ';
 753                         }
 754                 }
 755                 *s++ = ' '; *s++ = ' ';
 756                 for (j = 0; j < 16; j++) {
 757                         if (j == 8)
 758                                 *s++ = ' ';
 759                         if (i + j < len) {
 760                                 if (isprint(str[i + j]))
 761                                         *s++ = str[i + j];
 762                                 else
 763                                         *s++ = '.';
 764                         }
 765                         else
 766                                 *s++ = ' ';
 767                 }
 768                 tprintf("%s |\n", outstr);
 769         }
 770 }
 771
 772
 773 /* Need to do this since process_vm_readv() is not yet available in libc.
 774  * When libc is be updated, only "static bool process_vm_readv_not_supported"
 775  * line should remain.
 776  */
 777 #if !defined(__NR_process_vm_readv)
 778 # if defined(I386)
 779 #  define __NR_process_vm_readv  347
 780 # elif defined(X86_64)
 781 #  define __NR_process_vm_readv  310
 782 # elif defined(POWERPC)
 783 #  define __NR_process_vm_readv  351
 784 # endif
 785 #endif
 786
 787 #if defined(__NR_process_vm_readv)
 788 static bool process_vm_readv_not_supported = 0;
 789 static ssize_t process_vm_readv(pid_t pid,
 790                  const struct iovec *lvec,
 791                  unsigned long liovcnt,
 792                  const struct iovec *rvec,
 793                  unsigned long riovcnt,
 794                  unsigned long flags)
 795 {
 796         return syscall(__NR_process_vm_readv, (long)pid, lvec, liovcnt, rvec, riovcnt, flags);
 797 }
 798 #else
 799 static bool process_vm_readv_not_supported = 1;
 800 # define process_vm_readv(...) (errno = ENOSYS, -1)
 801 #endif
 802 /* end of hack */
 803
 804
 805 #define PAGMASK (~(PAGSIZ - 1))
 806 /*
 807  * move `len' bytes of data from process `pid'
 808  * at address `addr' to our space at `laddr'
 809  */
 810 int
 811 umoven(struct tcb *tcp, long addr, int len, char *laddr)
 812 {
 813 #ifdef LINUX
 814         int pid = tcp->pid;
 815         int n, m;
 816         int started;
 817         union {
 818                 long val;
 819                 char x[sizeof(long)];
 820         } u;
 821
 822         if (!process_vm_readv_not_supported) {
 823                 struct iovec local[1], remote[1];
 824                 int r;
 825
 826                 local[0].iov_base = laddr;
 827                 remote[0].iov_base = (void*)addr;
 828                 local[0].iov_len = remote[0].iov_len = len;
 829                 r = process_vm_readv(pid,
 830                                 local, 1,
 831                                 remote, 1,
 832                                 /*flags:*/ 0
 833                 );
 834                 if (r < 0) {
 835                         if (errno == ENOSYS)
 836                                 process_vm_readv_not_supported = 1;
 837                         else if (errno != EINVAL) /* EINVAL is seen if process is gone */
 838                                 /* strange... */
 839                                 perror("process_vm_readv");
 840                         goto vm_readv_didnt_work;
 841                 }
 842                 return r;
 843         }
 844  vm_readv_didnt_work:
 845
 846 #if SUPPORTED_PERSONALITIES > 1
 847         if (personality_wordsize[current_personality] < sizeof(addr))
 848                 addr &= (1ul << 8 * personality_wordsize[current_personality]) - 1;
 849 #endif
 850
 851         started = 0;
 852         if (addr & (sizeof(long) - 1)) {
 853                 /* addr not a multiple of sizeof(long) */
 854                 n = addr - (addr & -sizeof(long)); /* residue */
 855                 addr &= -sizeof(long); /* residue */
 856                 errno = 0;
 857                 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
 858                 if (errno) {
 859                         /* But if not started, we had a bogus address. */
 860                         if (addr != 0 && errno != EIO && errno != ESRCH)
 861                                 perror("ptrace: umoven");
 862                         return -1;
 863                 }
 864                 started = 1;
 865                 m = MIN(sizeof(long) - n, len);
 866                 memcpy(laddr, &u.x[n], m);
 867                 addr += sizeof(long), laddr += m, len -= m;
 868         }
 869         while (len) {
 870                 errno = 0;
 871                 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
 872                 if (errno) {
 873                         if (started && (errno==EPERM || errno==EIO)) {
 874                                 /* Ran into 'end of memory' - stupid "printpath" */
 875                                 return 0;
 876                         }
 877                         if (addr != 0 && errno != EIO && errno != ESRCH)
 878                                 perror("ptrace: umoven");
 879                         return -1;
 880                 }
 881                 started = 1;
 882                 m = MIN(sizeof(long), len);
 883                 memcpy(laddr, u.x, m);
 884                 addr += sizeof(long), laddr += m, len -= m;
 885         }
 886 #endif /* LINUX */
 887
 888 #ifdef SUNOS4
 889         int pid = tcp->pid;
 890         int n;
 891
 892         while (len) {
 893                 n = MIN(len, PAGSIZ);
 894                 n = MIN(n, ((addr + PAGSIZ) & PAGMASK) - addr);
 895                 if (ptrace(PTRACE_READDATA, pid,
 896                            (char *) addr, len, laddr) < 0) {
 897                         if (errno != ESRCH) {
 898                                 perror("umoven: ptrace(PTRACE_READDATA, ...)");
 899                                 abort();
 900                         }
 901                         return -1;
 902                 }
 903                 len -= n;
 904                 addr += n;
 905                 laddr += n;
 906         }
 907 #endif /* SUNOS4 */
 908
 909 #ifdef USE_PROCFS
 910 #ifdef HAVE_MP_PROCFS
 911         int fd = tcp->pfd_as;
 912 #else
 913         int fd = tcp->pfd;
 914 #endif
 915         lseek(fd, addr, SEEK_SET);
 916         if (read(fd, laddr, len) == -1)
 917                 return -1;
 918 #endif /* USE_PROCFS */
 919
 920         return 0;
 921 }
 922
 923 /*
 924  * Like `umove' but make the additional effort of looking
 925  * for a terminating zero byte.
 926  *
 927  * Returns < 0 on error, > 0 if NUL was seen,
 928  * (TODO if useful: return count of bytes including NUL),
 929  * else 0 if len bytes were read but no NUL byte seen.
 930  *
 931  * Note: there is no guarantee we won't overwrite some bytes
 932  * in laddr[] _after_ terminating NUL (but, of course,
 933  * we never write past laddr[len-1]).
 934  */
 935 int
 936 umovestr(struct tcb *tcp, long addr, int len, char *laddr)
 937 {
 938 #ifdef USE_PROCFS
 939 # ifdef HAVE_MP_PROCFS
 940         int fd = tcp->pfd_as;
 941 # else
 942         int fd = tcp->pfd;
 943 # endif
 944         /* Some systems (e.g. FreeBSD) can be upset if we read off the
 945            end of valid memory,  avoid this by trying to read up
 946            to page boundaries.  But we don't know what a page is (and
 947            getpagesize(2) (if it exists) doesn't necessarily return
 948            hardware page size).  Assume all pages >= 1024 (a-historical
 949            I know) */
 950
 951         int page = 1024;        /* How to find this? */
 952         int move = page - (addr & (page - 1));
 953         int left = len;
 954
 955         lseek(fd, addr, SEEK_SET);
 956
 957         while (left) {
 958                 if (move > left)
 959                         move = left;
 960                 move = read(fd, laddr, move);
 961                 if (move <= 0)
 962                         return left != len ? 0 : -1;
 963                 if (memchr(laddr, 0, move))
 964                         return 1;
 965                 left -= move;
 966                 laddr += move;
 967                 addr += move;
 968                 move = page;
 969         }
 970         return 0;
 971 #else /* !USE_PROCFS */
 972         int started;
 973         int pid = tcp->pid;
 974         int i, n, m;
 975         union {
 976                 long val;
 977                 char x[sizeof(long)];
 978         } u;
 979
 980 #if SUPPORTED_PERSONALITIES > 1
 981         if (personality_wordsize[current_personality] < sizeof(addr))
 982                 addr &= (1ul << 8 * personality_wordsize[current_personality]) - 1;
 983 #endif
 984
 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,
1012                                         local, 1,
1013                                         remote, 1,
1014                                         /*flags:*/ 0
1015                         );
1016                         if (r < 0) {
1017                                 if (errno == ENOSYS)
1018                                         process_vm_readv_not_supported = 1;
1019                                 else if (errno != EINVAL) /* EINVAL is seen if process is gone */
1020                                         /* strange... */
1021                                         perror("process_vm_readv");
1022                                 goto vm_readv_didnt_work;
1023                         }
1024                         if (memchr(local[0].iov_base, '\0', r))
1025                                 return 1;
1026                         local[0].iov_base += r;
1027                         remote[0].iov_base += r;
1028                         len -= r;
1029                 }
1030                 return 0;
1031         }
1032  vm_readv_didnt_work:
1033
1034         started = 0;
1035         if (addr & (sizeof(long) - 1)) {
1036                 /* addr not a multiple of sizeof(long) */
1037                 n = addr - (addr & -sizeof(long)); /* residue */
1038                 addr &= -sizeof(long); /* residue */
1039                 errno = 0;
1040                 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
1041                 if (errno) {
1042                         if (addr != 0 && errno != EIO && errno != ESRCH)
1043                                 perror("umovestr");
1044                         return -1;
1045                 }
1046                 started = 1;
1047                 m = MIN(sizeof(long) - n, len);
1048                 memcpy(laddr, &u.x[n], m);
1049                 while (n & (sizeof(long) - 1))
1050                         if (u.x[n++] == '\0')
1051                                 return 1;
1052                 addr += sizeof(long), laddr += m, len -= m;
1053         }
1054         while (len) {
1055                 errno = 0;
1056                 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
1057                 if (errno) {
1058                         if (started && (errno==EPERM || errno==EIO)) {
1059                                 /* Ran into 'end of memory' - stupid "printpath" */
1060                                 return 0;
1061                         }
1062                         if (addr != 0 && errno != EIO && errno != ESRCH)
1063                                 perror("umovestr");
1064                         return -1;
1065                 }
1066                 started = 1;
1067                 m = MIN(sizeof(long), len);
1068                 memcpy(laddr, u.x, m);
1069                 for (i = 0; i < sizeof(long); i++)
1070                         if (u.x[i] == '\0')
1071                                 return 1;
1072                 addr += sizeof(long), laddr += m, len -= m;
1073         }
1074 #endif /* !USE_PROCFS */
1075         return 0;
1076 }
1077
1078 #ifdef LINUX
1079 # if !defined (SPARC) && !defined(SPARC64)
1080 #  define PTRACE_WRITETEXT      101
1081 #  define PTRACE_WRITEDATA      102
1082 # endif /* !SPARC && !SPARC64 */
1083 #endif /* LINUX */
1084
1085 #ifdef SUNOS4
1086
1087 static int
1088 uload(int cmd, int pid, long addr, int len, char *laddr)
1089 {
1090         int peek, poke;
1091         int n, m;
1092         union {
1093                 long val;
1094                 char x[sizeof(long)];
1095         } u;
1096
1097         if (cmd == PTRACE_WRITETEXT) {
1098                 peek = PTRACE_PEEKTEXT;
1099                 poke = PTRACE_POKETEXT;
1100         }
1101         else {
1102                 peek = PTRACE_PEEKDATA;
1103                 poke = PTRACE_POKEDATA;
1104         }
1105         if (addr & (sizeof(long) - 1)) {
1106                 /* addr not a multiple of sizeof(long) */
1107                 n = addr - (addr & -sizeof(long)); /* residue */
1108                 addr &= -sizeof(long);
1109                 errno = 0;
1110                 u.val = ptrace(peek, pid, (char *) addr, 0);
1111                 if (errno) {
1112                         perror("uload: POKE");
1113                         return -1;
1114                 }
1115                 m = MIN(sizeof(long) - n, len);
1116                 memcpy(&u.x[n], laddr, m);
1117                 if (ptrace(poke, pid, (char *)addr, u.val) < 0) {
1118                         perror("uload: POKE");
1119                         return -1;
1120                 }
1121                 addr += sizeof(long), laddr += m, len -= m;
1122         }
1123         while (len) {
1124                 if (len < sizeof(long))
1125                         u.val = ptrace(peek, pid, (char *) addr, 0);
1126                 m = MIN(sizeof(long), len);
1127                 memcpy(u.x, laddr, m);
1128                 if (ptrace(poke, pid, (char *) addr, u.val) < 0) {
1129                         perror("uload: POKE");
1130                         return -1;
1131                 }
1132                 addr += sizeof(long), laddr += m, len -= m;
1133         }
1134         return 0;
1135 }
1136
1137 int
1138 tload(int pid, int addr, int len, char *laddr)
1139 {
1140         return uload(PTRACE_WRITETEXT, pid, addr, len, laddr);
1141 }
1142
1143 int
1144 dload(int pid, int addr, int len, char *laddr)
1145 {
1146         return uload(PTRACE_WRITEDATA, pid, addr, len, laddr);
1147 }
1148
1149 #endif /* SUNOS4 */
1150
1151 #ifndef USE_PROCFS
1152
1153 int
1154 upeek(struct tcb *tcp, long off, long *res)
1155 {
1156         long val;
1157
1158 # ifdef SUNOS4_KERNEL_ARCH_KLUDGE
1159         {
1160                 static int is_sun4m = -1;
1161                 struct utsname name;
1162
1163                 /* Round up the usual suspects. */
1164                 if (is_sun4m == -1) {
1165                         if (uname(&name) < 0) {
1166                                 perror("upeek: uname?");
1167                                 exit(1);
1168                         }
1169                         is_sun4m = strcmp(name.machine, "sun4m") == 0;
1170                         if (is_sun4m) {
1171                                 const struct xlat *x;
1172
1173                                 for (x = struct_user_offsets; x->str; x++)
1174                                         x->val += 1024;
1175                         }
1176                 }
1177                 if (is_sun4m)
1178                         off += 1024;
1179         }
1180 # endif /* SUNOS4_KERNEL_ARCH_KLUDGE */
1181         errno = 0;
1182         val = do_ptrace(PTRACE_PEEKUSER, tcp, (char *) off, 0);
1183         if (val == -1 && errno) {
1184                 if (errno != ESRCH) {
1185                         char buf[60];
1186                         sprintf(buf, "upeek: ptrace(PTRACE_PEEKUSER,%d,%lu,0)", tcp->pid, off);
1187                         perror(buf);
1188                 }
1189                 return -1;
1190         }
1191         *res = val;
1192         return 0;
1193 }
1194
1195 #endif /* !USE_PROCFS */
1196
1197 void
1198 printcall(struct tcb *tcp)
1199 {
1200 #define PRINTBADPC tprintf(sizeof(long) == 4 ? "[????????] " : \
1201                            sizeof(long) == 8 ? "[????????????????] " : \
1202                            NULL /* crash */)
1203
1204 #ifdef LINUX
1205 # ifdef I386
1206         long eip;
1207
1208         if (upeek(tcp, 4*EIP, &eip) < 0) {
1209                 PRINTBADPC;
1210                 return;
1211         }
1212         tprintf("[%08lx] ", eip);
1213
1214 # elif defined(S390) || defined(S390X)
1215         long psw;
1216         if (upeek(tcp, PT_PSWADDR, &psw) < 0) {
1217                 PRINTBADPC;
1218                 return;
1219         }
1220 #  ifdef S390
1221         tprintf("[%08lx] ", psw);
1222 #  elif S390X
1223         tprintf("[%16lx] ", psw);
1224 #  endif
1225
1226 # elif defined(X86_64)
1227         long rip;
1228
1229         if (upeek(tcp, 8*RIP, &rip) < 0) {
1230                 PRINTBADPC;
1231                 return;
1232         }
1233         tprintf("[%16lx] ", rip);
1234 # elif defined(IA64)
1235         long ip;
1236
1237         if (upeek(tcp, PT_B0, &ip) < 0) {
1238                 PRINTBADPC;
1239                 return;
1240         }
1241         tprintf("[%08lx] ", ip);
1242 # elif defined(POWERPC)
1243         long pc;
1244
1245         if (upeek(tcp, sizeof(unsigned long)*PT_NIP, &pc) < 0) {
1246                 PRINTBADPC;
1247                 return;
1248         }
1249 #  ifdef POWERPC64
1250         tprintf("[%016lx] ", pc);
1251 #  else
1252         tprintf("[%08lx] ", pc);
1253 #  endif
1254 # elif defined(M68K)
1255         long pc;
1256
1257         if (upeek(tcp, 4*PT_PC, &pc) < 0) {
1258                 tprints("[????????] ");
1259                 return;
1260         }
1261         tprintf("[%08lx] ", pc);
1262 # elif defined(ALPHA)
1263         long pc;
1264
1265         if (upeek(tcp, REG_PC, &pc) < 0) {
1266                 tprints("[????????????????] ");
1267                 return;
1268         }
1269         tprintf("[%08lx] ", pc);
1270 # elif defined(SPARC) || defined(SPARC64)
1271         struct pt_regs regs;
1272         if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)&regs, 0) < 0) {
1273                 PRINTBADPC;
1274                 return;
1275         }
1276 #  if defined(SPARC64)
1277         tprintf("[%08lx] ", regs.tpc);
1278 #  else
1279         tprintf("[%08lx] ", regs.pc);
1280 #  endif
1281 # elif defined(HPPA)
1282         long pc;
1283
1284         if (upeek(tcp, PT_IAOQ0, &pc) < 0) {
1285                 tprints("[????????] ");
1286                 return;
1287         }
1288         tprintf("[%08lx] ", pc);
1289 # elif defined(MIPS)
1290         long pc;
1291
1292         if (upeek(tcp, REG_EPC, &pc) < 0) {
1293                 tprints("[????????] ");
1294                 return;
1295         }
1296         tprintf("[%08lx] ", pc);
1297 # elif defined(SH)
1298         long pc;
1299
1300         if (upeek(tcp, 4*REG_PC, &pc) < 0) {
1301                 tprints("[????????] ");
1302                 return;
1303         }
1304         tprintf("[%08lx] ", pc);
1305 # elif defined(SH64)
1306         long pc;
1307
1308         if (upeek(tcp, REG_PC, &pc) < 0) {
1309                 tprints("[????????????????] ");
1310                 return;
1311         }
1312         tprintf("[%08lx] ", pc);
1313 # elif defined(ARM)
1314         long pc;
1315
1316         if (upeek(tcp, 4*15, &pc) < 0) {
1317                 PRINTBADPC;
1318                 return;
1319         }
1320         tprintf("[%08lx] ", pc);
1321 # elif defined(AVR32)
1322         long pc;
1323
1324         if (upeek(tcp, REG_PC, &pc) < 0) {
1325                 tprints("[????????] ");
1326                 return;
1327         }
1328         tprintf("[%08lx] ", pc);
1329 # elif defined(BFIN)
1330         long pc;
1331
1332         if (upeek(tcp, PT_PC, &pc) < 0) {
1333                 PRINTBADPC;
1334                 return;
1335         }
1336         tprintf("[%08lx] ", pc);
1337 #elif defined(CRISV10)
1338         long pc;
1339
1340         if (upeek(tcp, 4*PT_IRP, &pc) < 0) {
1341                 PRINTBADPC;
1342                 return;
1343         }
1344         tprintf("[%08lx] ", pc);
1345 #elif defined(CRISV32)
1346         long pc;
1347
1348         if (upeek(tcp, 4*PT_ERP, &pc) < 0) {
1349                 PRINTBADPC;
1350                 return;
1351         }
1352         tprintf("[%08lx] ", pc);
1353 # endif /* architecture */
1354 #endif /* LINUX */
1355
1356 #ifdef SUNOS4
1357         struct regs regs;
1358
1359         if (ptrace(PTRACE_GETREGS, tcp->pid, (char *) &regs, 0) < 0) {
1360                 perror("printcall: ptrace(PTRACE_GETREGS, ...)");
1361                 PRINTBADPC;
1362                 return;
1363         }
1364         tprintf("[%08x] ", regs.r_o7);
1365 #endif /* SUNOS4 */
1366
1367 #ifdef SVR4
1368         /* XXX */
1369         PRINTBADPC;
1370 #endif
1371
1372 #ifdef FREEBSD
1373         struct reg regs;
1374         pread(tcp->pfd_reg, &regs, sizeof(regs), 0);
1375         tprintf("[%08x] ", regs.r_eip);
1376 #endif /* FREEBSD */
1377 }
1378
1379
1380 /*
1381  * These #if's are huge, please indent them correctly.
1382  * It's easy to get confused otherwise.
1383  */
1384 #ifndef USE_PROCFS
1385
1386 # ifdef LINUX
1387
1388 #  include "syscall.h"
1389
1390 #  include <sys/syscall.h>
1391 #  ifndef CLONE_PTRACE
1392 #   define CLONE_PTRACE    0x00002000
1393 #  endif
1394 #  ifndef CLONE_VFORK
1395 #   define CLONE_VFORK     0x00004000
1396 #  endif
1397 #  ifndef CLONE_VM
1398 #   define CLONE_VM        0x00000100
1399 #  endif
1400 #  ifndef CLONE_STOPPED
1401 #   define CLONE_STOPPED   0x02000000
1402 #  endif
1403
1404 #  ifdef IA64
1405
1406 /* We don't have fork()/vfork() syscalls on ia64 itself, but the ia32
1407    subsystem has them for x86... */
1408 #   define SYS_fork     2
1409 #   define SYS_vfork    190
1410
1411 typedef unsigned long *arg_setup_state;
1412
1413 static int
1414 arg_setup(struct tcb *tcp, arg_setup_state *state)
1415 {
1416         unsigned long cfm, sof, sol;
1417         long bsp;
1418
1419         if (ia32) {
1420                 /* Satisfy a false GCC warning.  */
1421                 *state = NULL;
1422                 return 0;
1423         }
1424
1425         if (upeek(tcp, PT_AR_BSP, &bsp) < 0)
1426                 return -1;
1427         if (upeek(tcp, PT_CFM, (long *) &cfm) < 0)
1428                 return -1;
1429
1430         sof = (cfm >> 0) & 0x7f;
1431         sol = (cfm >> 7) & 0x7f;
1432         bsp = (long) ia64_rse_skip_regs((unsigned long *) bsp, -sof + sol);
1433
1434         *state = (unsigned long *) bsp;
1435         return 0;
1436 }
1437
1438 #   define arg_finish_change(tcp, state)        0
1439
1440 #   ifdef SYS_fork
1441 static int
1442 get_arg0(struct tcb *tcp, arg_setup_state *state, long *valp)
1443 {
1444         int ret;
1445
1446         if (ia32)
1447                 ret = upeek(tcp, PT_R11, valp);
1448         else
1449                 ret = umoven(tcp,
1450                               (unsigned long) ia64_rse_skip_regs(*state, 0),
1451                               sizeof(long), (void *) valp);
1452         return ret;
1453 }
1454
1455 static int
1456 get_arg1(struct tcb *tcp, arg_setup_state *state, long *valp)
1457 {
1458         int ret;
1459
1460         if (ia32)
1461                 ret = upeek(tcp, PT_R9, valp);
1462         else
1463                 ret = umoven(tcp,
1464                               (unsigned long) ia64_rse_skip_regs(*state, 1),
1465                               sizeof(long), (void *) valp);
1466         return ret;
1467 }
1468 #   endif
1469
1470 static int
1471 set_arg0(struct tcb *tcp, arg_setup_state *state, long val)
1472 {
1473         int req = PTRACE_POKEDATA;
1474         void *ap;
1475
1476         if (ia32) {
1477                 ap = (void *) (intptr_t) PT_R11;         /* r11 == EBX */
1478                 req = PTRACE_POKEUSER;
1479         } else
1480                 ap = ia64_rse_skip_regs(*state, 0);
1481         errno = 0;
1482         ptrace(req, tcp->pid, ap, val);
1483         return errno ? -1 : 0;
1484 }
1485
1486 static int
1487 set_arg1(struct tcb *tcp, arg_setup_state *state, long val)
1488 {
1489         int req = PTRACE_POKEDATA;
1490         void *ap;
1491
1492         if (ia32) {
1493                 ap = (void *) (intptr_t) PT_R9;         /* r9 == ECX */
1494                 req = PTRACE_POKEUSER;
1495         } else
1496                 ap = ia64_rse_skip_regs(*state, 1);
1497         errno = 0;
1498         ptrace(req, tcp->pid, ap, val);
1499         return errno ? -1 : 0;
1500 }
1501
1502 /* ia64 does not return the input arguments from functions (and syscalls)
1503    according to ia64 RSE (Register Stack Engine) behavior.  */
1504
1505 #   define restore_arg0(tcp, state, val) ((void) (state), 0)
1506 #   define restore_arg1(tcp, state, val) ((void) (state), 0)
1507
1508 #  elif defined (SPARC) || defined (SPARC64)
1509
1510 typedef struct pt_regs arg_setup_state;
1511
1512 #   define arg_setup(tcp, state) \
1513     (ptrace(PTRACE_GETREGS, tcp->pid, (char *) (state), 0))
1514 #   define arg_finish_change(tcp, state) \
1515     (ptrace(PTRACE_SETREGS, tcp->pid, (char *) (state), 0))
1516
1517 #   define get_arg0(tcp, state, valp) (*(valp) = (state)->u_regs[U_REG_O0], 0)
1518 #   define get_arg1(tcp, state, valp) (*(valp) = (state)->u_regs[U_REG_O1], 0)
1519 #   define set_arg0(tcp, state, val) ((state)->u_regs[U_REG_O0] = (val), 0)
1520 #   define set_arg1(tcp, state, val) ((state)->u_regs[U_REG_O1] = (val), 0)
1521 #   define restore_arg0(tcp, state, val) 0
1522
1523 #  else /* other architectures */
1524
1525 #   if defined S390 || defined S390X
1526 /* Note: this is only true for the `clone' system call, which handles
1527    arguments specially.  We could as well say that its first two arguments
1528    are swapped relative to other architectures, but that would just be
1529    another #ifdef in the calls.  */
1530 #    define arg0_offset PT_GPR3
1531 #    define arg1_offset PT_ORIGGPR2
1532 #    define restore_arg0(tcp, state, val) ((void) (state), 0)
1533 #    define restore_arg1(tcp, state, val) ((void) (state), 0)
1534 #    define arg0_index  1
1535 #    define arg1_index  0
1536 #   elif defined (ALPHA) || defined (MIPS)
1537 #    define arg0_offset REG_A0
1538 #    define arg1_offset (REG_A0+1)
1539 #   elif defined (AVR32)
1540 #    define arg0_offset (REG_R12)
1541 #    define arg1_offset (REG_R11)
1542 #   elif defined (POWERPC)
1543 #    define arg0_offset (sizeof(unsigned long)*PT_R3)
1544 #    define arg1_offset (sizeof(unsigned long)*PT_R4)
1545 #    define restore_arg0(tcp, state, val) ((void) (state), 0)
1546 #   elif defined (HPPA)
1547 #    define arg0_offset  PT_GR26
1548 #    define arg1_offset  (PT_GR26-4)
1549 #   elif defined (X86_64)
1550 #    define arg0_offset ((long)(8*(current_personality ? RBX : RDI)))
1551 #    define arg1_offset ((long)(8*(current_personality ? RCX : RSI)))
1552 #   elif defined (SH)
1553 #    define arg0_offset (4*(REG_REG0+4))
1554 #    define arg1_offset (4*(REG_REG0+5))
1555 #   elif defined (SH64)
1556     /* ABI defines arg0 & 1 in r2 & r3 */
1557 #    define arg0_offset   (REG_OFFSET+16)
1558 #    define arg1_offset   (REG_OFFSET+24)
1559 #    define restore_arg0(tcp, state, val) 0
1560 #   elif defined CRISV10 || defined CRISV32
1561 #    define arg0_offset   (4*PT_R11)
1562 #    define arg1_offset   (4*PT_ORIG_R10)
1563 #    define restore_arg0(tcp, state, val) 0
1564 #    define restore_arg1(tcp, state, val) 0
1565 #    define arg0_index   1
1566 #    define arg1_index   0
1567 #   else
1568 #    define arg0_offset 0
1569 #    define arg1_offset 4
1570 #    if defined ARM
1571 #     define restore_arg0(tcp, state, val) 0
1572 #    endif
1573 #   endif
1574
1575 typedef int arg_setup_state;
1576
1577 #   define arg_setup(tcp, state) (0)
1578 #   define arg_finish_change(tcp, state)        0
1579 #   define get_arg0(tcp, cookie, valp) \
1580     (upeek((tcp), arg0_offset, (valp)))
1581 #   define get_arg1(tcp, cookie, valp) \
1582     (upeek((tcp), arg1_offset, (valp)))
1583
1584 static int
1585 set_arg0(struct tcb *tcp, void *cookie, long val)
1586 {
1587         return ptrace(PTRACE_POKEUSER, tcp->pid, (char*)arg0_offset, val);
1588 }
1589
1590 static int
1591 set_arg1(struct tcb *tcp, void *cookie, long val)
1592 {
1593         return ptrace(PTRACE_POKEUSER, tcp->pid, (char*)arg1_offset, val);
1594 }
1595
1596 #  endif /* architectures */
1597
1598 #  ifndef restore_arg0
1599 #   define restore_arg0(tcp, state, val) set_arg0((tcp), (state), (val))
1600 #  endif
1601 #  ifndef restore_arg1
1602 #   define restore_arg1(tcp, state, val) set_arg1((tcp), (state), (val))
1603 #  endif
1604
1605 #  ifndef arg0_index
1606 #   define arg0_index 0
1607 #   define arg1_index 1
1608 #  endif
1609
1610 int
1611 setbpt(struct tcb *tcp)
1612 {
1613         static int clone_scno[SUPPORTED_PERSONALITIES] = { SYS_clone };
1614         arg_setup_state state;
1615
1616         if (tcp->flags & TCB_BPTSET) {
1617                 fprintf(stderr, "PANIC: TCB already set in pid %u\n", tcp->pid);
1618                 return -1;
1619         }
1620
1621         /*
1622          * It's a silly kludge to initialize this with a search at runtime.
1623          * But it's better than maintaining another magic thing in the
1624          * godforsaken tables.
1625          */
1626         if (clone_scno[current_personality] == 0) {
1627                 int i;
1628                 for (i = 0; i < nsyscalls; ++i)
1629                         if (sysent[i].sys_func == sys_clone) {
1630                                 clone_scno[current_personality] = i;
1631                                 break;
1632                         }
1633         }
1634
1635         switch (known_scno(tcp)) {
1636 #  ifdef SYS_vfork
1637         case SYS_vfork:
1638 #  endif
1639 #  ifdef SYS_fork
1640         case SYS_fork:
1641 #  endif
1642 #  if defined SYS_fork || defined SYS_vfork
1643                 if (arg_setup(tcp, &state) < 0
1644                     || get_arg0(tcp, &state, &tcp->inst[0]) < 0
1645                     || get_arg1(tcp, &state, &tcp->inst[1]) < 0
1646                     || change_syscall(tcp, clone_scno[current_personality]) < 0
1647                     || set_arg0(tcp, &state, CLONE_PTRACE|SIGCHLD) < 0
1648                     || set_arg1(tcp, &state, 0) < 0
1649                     || arg_finish_change(tcp, &state) < 0)
1650                         return -1;
1651                 tcp->u_arg[arg0_index] = CLONE_PTRACE|SIGCHLD;
1652                 tcp->u_arg[arg1_index] = 0;
1653                 tcp->flags |= TCB_BPTSET;
1654                 return 0;
1655 #  endif
1656
1657         case SYS_clone: ;
1658 #  ifdef SYS_clone2
1659         case SYS_clone2: ;
1660 #  endif
1661                 /* ia64 calls directly `clone (CLONE_VFORK | CLONE_VM)'
1662                    contrary to x86 SYS_vfork above.  Even on x86 we turn the
1663                    vfork semantics into plain fork - each application must not
1664                    depend on the vfork specifics according to POSIX.  We would
1665                    hang waiting for the parent resume otherwise.  We need to
1666                    clear also CLONE_VM but only in the CLONE_VFORK case as
1667                    otherwise we would break pthread_create.  */
1668
1669                 long new_arg0 = (tcp->u_arg[arg0_index] | CLONE_PTRACE);
1670                 if (new_arg0 & CLONE_VFORK)
1671                         new_arg0 &= ~(unsigned long)(CLONE_VFORK | CLONE_VM);
1672                 if (arg_setup(tcp, &state) < 0
1673                  || set_arg0(tcp, &state, new_arg0) < 0
1674                  || arg_finish_change(tcp, &state) < 0)
1675                         return -1;
1676                 tcp->flags |= TCB_BPTSET;
1677                 tcp->inst[0] = tcp->u_arg[arg0_index];
1678                 tcp->inst[1] = tcp->u_arg[arg1_index];
1679                 return 0;
1680
1681         default:
1682                 fprintf(stderr, "PANIC: setbpt for syscall %ld on %u???\n",
1683                         tcp->scno, tcp->pid);
1684                 break;
1685         }
1686
1687         return -1;
1688 }
1689
1690 int
1691 clearbpt(struct tcb *tcp)
1692 {
1693         arg_setup_state state;
1694         if (arg_setup(tcp, &state) < 0
1695             || restore_arg0(tcp, &state, tcp->inst[0]) < 0
1696             || restore_arg1(tcp, &state, tcp->inst[1]) < 0
1697             || arg_finish_change(tcp, &state))
1698                 if (errno != ESRCH)
1699                         return -1;
1700         tcp->flags &= ~TCB_BPTSET;
1701         return 0;
1702 }
1703
1704 # else /* !defined LINUX */
1705
1706 int
1707 setbpt(struct tcb *tcp)
1708 {
1709 #  ifdef SUNOS4
1710 #   ifdef SPARC /* This code is slightly sparc specific */
1711
1712         struct regs regs;
1713 #    define BPT 0x91d02001      /* ta   1 */
1714 #    define LOOP        0x10800000      /* ba   0 */
1715 #    define LOOPA       0x30800000      /* ba,a 0 */
1716 #    define NOP 0x01000000
1717 #    if LOOPA
1718         static int loopdeloop[1] = {LOOPA};
1719 #    else
1720         static int loopdeloop[2] = {LOOP, NOP};
1721 #    endif
1722
1723         if (tcp->flags & TCB_BPTSET) {
1724                 fprintf(stderr, "PANIC: TCB already set in pid %u\n", tcp->pid);
1725                 return -1;
1726         }
1727         if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)&regs, 0) < 0) {
1728                 perror("setbpt: ptrace(PTRACE_GETREGS, ...)");
1729                 return -1;
1730         }
1731         tcp->baddr = regs.r_o7 + 8;
1732         if (ptrace(PTRACE_READTEXT, tcp->pid, (char *)tcp->baddr,
1733                                 sizeof tcp->inst, (char *)tcp->inst) < 0) {
1734                 perror("setbpt: ptrace(PTRACE_READTEXT, ...)");
1735                 return -1;
1736         }
1737
1738         /*
1739          * XXX - BRUTAL MODE ON
1740          * We cannot set a real BPT in the child, since it will not be
1741          * traced at the moment it will reach the trap and would probably
1742          * die with a core dump.
1743          * Thus, we are force our way in by taking out two instructions
1744          * and insert an eternal loop in stead, in expectance of the SIGSTOP
1745          * generated by out PTRACE_ATTACH.
1746          * Of cause, if we evaporate ourselves in the middle of all this...
1747          */
1748         if (ptrace(PTRACE_WRITETEXT, tcp->pid, (char *) tcp->baddr,
1749                         sizeof loopdeloop, (char *) loopdeloop) < 0) {
1750                 perror("setbpt: ptrace(PTRACE_WRITETEXT, ...)");
1751                 return -1;
1752         }
1753         tcp->flags |= TCB_BPTSET;
1754
1755 #   endif /* SPARC */
1756 #  endif /* SUNOS4 */
1757
1758         return 0;
1759 }
1760
1761 int
1762 clearbpt(struct tcb *tcp)
1763 {
1764 #  ifdef SUNOS4
1765 #   ifdef SPARC
1766
1767 #    if !LOOPA
1768         struct regs regs;
1769 #    endif
1770
1771         if (!(tcp->flags & TCB_BPTSET)) {
1772                 fprintf(stderr, "PANIC: TCB not set in pid %u\n", tcp->pid);
1773                 return -1;
1774         }
1775         if (ptrace(PTRACE_WRITETEXT, tcp->pid, (char *) tcp->baddr,
1776                                 sizeof tcp->inst, (char *) tcp->inst) < 0) {
1777                 perror("clearbtp: ptrace(PTRACE_WRITETEXT, ...)");
1778                 return -1;
1779         }
1780         tcp->flags &= ~TCB_BPTSET;
1781
1782 #    if !LOOPA
1783         /*
1784          * Since we don't have a single instruction breakpoint, we may have
1785          * to adjust the program counter after removing our `breakpoint'.
1786          */
1787         if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)&regs, 0) < 0) {
1788                 perror("clearbpt: ptrace(PTRACE_GETREGS, ...)");
1789                 return -1;
1790         }
1791         if ((regs.r_pc < tcp->baddr) ||
1792                                 (regs.r_pc > tcp->baddr + 4)) {
1793                 /* The breakpoint has not been reached yet */
1794                 if (debug)
1795                         fprintf(stderr,
1796                                 "NOTE: PC not at bpt (pc %#x baddr %#x)\n",
1797                                         regs.r_pc, tcp->baddr);
1798                 return 0;
1799         }
1800         if (regs.r_pc != tcp->baddr)
1801                 if (debug)
1802                         fprintf(stderr, "NOTE: PC adjusted (%#x -> %#x\n",
1803                                 regs.r_pc, tcp->baddr);
1804
1805         regs.r_pc = tcp->baddr;
1806         if (ptrace(PTRACE_SETREGS, tcp->pid, (char *)&regs, 0) < 0) {
1807                 perror("clearbpt: ptrace(PTRACE_SETREGS, ...)");
1808                 return -1;
1809         }
1810 #    endif /* LOOPA */
1811 #   endif /* SPARC */
1812 #  endif /* SUNOS4 */
1813
1814         return 0;
1815 }
1816
1817 # endif /* !defined LINUX */
1818
1819 #endif /* !USE_PROCFS */
1820
1821
1822 #ifdef SUNOS4
1823
1824 static int
1825 getex(struct tcb *tcp, struct exec *hdr)
1826 {
1827         int n;
1828
1829         for (n = 0; n < sizeof *hdr; n += 4) {
1830                 long res;
1831                 if (upeek(tcp, uoff(u_exdata) + n, &res) < 0)
1832                         return -1;
1833                 memcpy(((char *) hdr) + n, &res, 4);
1834         }
1835         if (debug) {
1836                 fprintf(stderr, "[struct exec: magic: %o version %u Mach %o\n",
1837                         hdr->a_magic, hdr->a_toolversion, hdr->a_machtype);
1838                 fprintf(stderr, "Text %lu Data %lu Bss %lu Syms %lu Entry %#lx]\n",
1839                         hdr->a_text, hdr->a_data, hdr->a_bss, hdr->a_syms, hdr->a_entry);
1840         }
1841         return 0;
1842 }
1843
1844 int
1845 fixvfork(struct tcb *tcp)
1846 {
1847         int pid = tcp->pid;
1848         /*
1849          * Change `vfork' in a freshly exec'ed dynamically linked
1850          * executable's (internal) symbol table to plain old `fork'
1851          */
1852
1853         struct exec hdr;
1854         struct link_dynamic dyn;
1855         struct link_dynamic_2 ld;
1856         char *strtab, *cp;
1857
1858         if (getex(tcp, &hdr) < 0)
1859                 return -1;
1860         if (!hdr.a_dynamic)
1861                 return -1;
1862
1863         if (umove(tcp, (int) N_DATADDR(hdr), &dyn) < 0) {
1864                 fprintf(stderr, "Cannot read DYNAMIC\n");
1865                 return -1;
1866         }
1867         if (umove(tcp, (int) dyn.ld_un.ld_2, &ld) < 0) {
1868                 fprintf(stderr, "Cannot read link_dynamic_2\n");
1869                 return -1;
1870         }
1871         strtab = malloc((unsigned)ld.ld_symb_size);
1872         if (!strtab)
1873                 die_out_of_memory();
1874         if (umoven(tcp, (int)ld.ld_symbols+(int)N_TXTADDR(hdr),
1875                                         (int)ld.ld_symb_size, strtab) < 0)
1876                 goto err;
1877
1878         for (cp = strtab; cp < strtab + ld.ld_symb_size; ) {
1879                 if (strcmp(cp, "_vfork") == 0) {
1880                         if (debug)
1881                                 fprintf(stderr, "fixvfork: FOUND _vfork\n");
1882                         strcpy(cp, "_fork");
1883                         break;
1884                 }
1885                 cp += strlen(cp)+1;
1886         }
1887         if (cp < strtab + ld.ld_symb_size)
1888                 /*
1889                  * Write entire symbol table back to avoid
1890                  * memory alignment bugs in ptrace
1891                  */
1892                 if (tload(pid, (int)ld.ld_symbols+(int)N_TXTADDR(hdr),
1893                                         (int)ld.ld_symb_size, strtab) < 0)
1894                         goto err;
1895
1896         free(strtab);
1897         return 0;
1898
1899 err:
1900         free(strtab);
1901         return -1;
1902 }
1903
1904 #endif /* SUNOS4 */