granicus.if.org Git - strace/blob - process.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  * Copyright (c) 2000 PocketPenguins Inc.  Linux for Hitachi SuperH
  10  *                    port by Greg Banks <gbanks@pocketpenguins.com>
  11
  12  *
  13  * All rights reserved.
  14  *
  15  * Redistribution and use in source and binary forms, with or without
  16  * modification, are permitted provided that the following conditions
  17  * are met:
  18  * 1. Redistributions of source code must retain the above copyright
  19  *    notice, this list of conditions and the following disclaimer.
  20  * 2. Redistributions in binary form must reproduce the above copyright
  21  *    notice, this list of conditions and the following disclaimer in the
  22  *    documentation and/or other materials provided with the distribution.
  23  * 3. The name of the author may not be used to endorse or promote products
  24  *    derived from this software without specific prior written permission.
  25  *
  26  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  27  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  28  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  29  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  30  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  31  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  32  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  33  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  34  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  35  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36  *
  37  *      $Id$
  38  */
  39
  40 #include "defs.h"
  41
  42 #include <fcntl.h>
  43 #include <sys/stat.h>
  44 #include <sys/time.h>
  45 #include <sys/wait.h>
  46 #include <sys/resource.h>
  47 #include <sys/utsname.h>
  48 #include <sys/user.h>
  49 #include <sys/syscall.h>
  50 #include <signal.h>
  51 #ifdef SUNOS4
  52 #include <machine/reg.h>
  53 #endif /* SUNOS4 */
  54
  55 #ifdef FREEBSD
  56 #include <sys/ptrace.h>
  57 #endif
  58
  59 #ifdef HAVE_SYS_REG_H
  60 # include <sys/reg.h>
  61 #ifndef PTRACE_PEEKUSR
  62 # define PTRACE_PEEKUSR PTRACE_PEEKUSER
  63 #endif
  64 #ifndef PTRACE_POKEUSR
  65 # define PTRACE_POKEUSR PTRACE_POKEUSER
  66 #endif
  67 #endif
  68
  69 #ifdef HAVE_LINUX_PTRACE_H
  70 #undef PTRACE_SYSCALL
  71 # ifdef HAVE_STRUCT_IA64_FPREG
  72 #  define ia64_fpreg XXX_ia64_fpreg
  73 # endif
  74 # ifdef HAVE_STRUCT_PT_ALL_USER_REGS
  75 #  define pt_all_user_regs XXX_pt_all_user_regs
  76 # endif
  77 #include <linux/ptrace.h>
  78 # undef ia64_fpreg
  79 # undef pt_all_user_regs
  80 #endif
  81
  82 #if defined (LINUX) && defined (SPARC64)
  83 # define r_pc r_tpc
  84 # undef PTRACE_GETREGS
  85 # define PTRACE_GETREGS PTRACE_GETREGS64
  86 # undef PTRACE_SETREGS
  87 # define PTRACE_SETREGS PTRACE_SETREGS64
  88 #endif /* LINUX && SPARC64 */
  89
  90 #ifdef HAVE_LINUX_FUTEX_H
  91 # include <linux/futex.h>
  92 #endif
  93 #ifdef LINUX
  94 # ifndef FUTEX_WAIT
  95 #  define FUTEX_WAIT 0
  96 # endif
  97 # ifndef FUTEX_WAKE
  98 #  define FUTEX_WAKE 1
  99 # endif
 100 # ifndef FUTEX_FD
 101 #  define FUTEX_FD 2
 102 # endif
 103 # ifndef FUTEX_REQUEUE
 104 #  define FUTEX_REQUEUE 3
 105 # endif
 106 #endif /* LINUX */
 107
 108 #ifdef LINUX
 109 #include <sched.h>
 110 #include <asm/posix_types.h>
 111 #undef GETGROUPS_T
 112 #define GETGROUPS_T __kernel_gid_t
 113 #undef GETGROUPS32_T
 114 #define GETGROUPS32_T __kernel_gid32_t
 115 #endif /* LINUX */
 116
 117 #if defined(LINUX) && defined(IA64)
 118 # include <asm/ptrace_offsets.h>
 119 # include <asm/rse.h>
 120 #endif
 121
 122 #ifdef HAVE_PRCTL
 123 # include <sys/prctl.h>
 124
 125 static const struct xlat prctl_options[] = {
 126 #ifdef PR_MAXPROCS
 127         { PR_MAXPROCS,          "PR_MAXPROCS"           },
 128 #endif
 129 #ifdef PR_ISBLOCKED
 130         { PR_ISBLOCKED,         "PR_ISBLOCKED"          },
 131 #endif
 132 #ifdef PR_SETSTACKSIZE
 133         { PR_SETSTACKSIZE,      "PR_SETSTACKSIZE"       },
 134 #endif
 135 #ifdef PR_GETSTACKSIZE
 136         { PR_GETSTACKSIZE,      "PR_GETSTACKSIZE"       },
 137 #endif
 138 #ifdef PR_MAXPPROCS
 139         { PR_MAXPPROCS,         "PR_MAXPPROCS"          },
 140 #endif
 141 #ifdef PR_UNBLKONEXEC
 142         { PR_UNBLKONEXEC,       "PR_UNBLKONEXEC"        },
 143 #endif
 144 #ifdef PR_ATOMICSIM
 145         { PR_ATOMICSIM,         "PR_ATOMICSIM"          },
 146 #endif
 147 #ifdef PR_SETEXITSIG
 148         { PR_SETEXITSIG,        "PR_SETEXITSIG"         },
 149 #endif
 150 #ifdef PR_RESIDENT
 151         { PR_RESIDENT,          "PR_RESIDENT"           },
 152 #endif
 153 #ifdef PR_ATTACHADDR
 154         { PR_ATTACHADDR,        "PR_ATTACHADDR"         },
 155 #endif
 156 #ifdef PR_DETACHADDR
 157         { PR_DETACHADDR,        "PR_DETACHADDR"         },
 158 #endif
 159 #ifdef PR_TERMCHILD
 160         { PR_TERMCHILD,         "PR_TERMCHILD"          },
 161 #endif
 162 #ifdef PR_GETSHMASK
 163         { PR_GETSHMASK,         "PR_GETSHMASK"          },
 164 #endif
 165 #ifdef PR_GETNSHARE
 166         { PR_GETNSHARE,         "PR_GETNSHARE"          },
 167 #endif
 168 #ifdef PR_COREPID
 169         { PR_COREPID,           "PR_COREPID"            },
 170 #endif
 171 #ifdef PR_ATTACHADDRPERM
 172         { PR_ATTACHADDRPERM,    "PR_ATTACHADDRPERM"     },
 173 #endif
 174 #ifdef PR_PTHREADEXIT
 175         { PR_PTHREADEXIT,       "PR_PTHREADEXIT"        },
 176 #endif
 177 #ifdef PR_SET_PDEATHSIG
 178         { PR_SET_PDEATHSIG,     "PR_SET_PDEATHSIG"      },
 179 #endif
 180 #ifdef PR_GET_PDEATHSIG
 181         { PR_GET_PDEATHSIG,     "PR_GET_PDEATHSIG"      },
 182 #endif
 183 #ifdef PR_GET_DUMPABLE
 184         { PR_GET_DUMPABLE,      "PR_GET_DUMPABLE"       },
 185 #endif
 186 #ifdef PR_SET_DUMPABLE
 187         { PR_SET_DUMPABLE,      "PR_SET_DUMPABLE"       },
 188 #endif
 189 #ifdef PR_GET_UNALIGN
 190         { PR_GET_UNALIGN,       "PR_GET_UNALIGN"        },
 191 #endif
 192 #ifdef PR_SET_UNALIGN
 193         { PR_SET_UNALIGN,       "PR_SET_UNALIGN"        },
 194 #endif
 195 #ifdef PR_GET_KEEPCAPS
 196         { PR_GET_KEEPCAPS,      "PR_GET_KEEPCAPS"       },
 197 #endif
 198 #ifdef PR_SET_KEEPCAPS
 199         { PR_SET_KEEPCAPS,      "PR_SET_KEEPCAPS"       },
 200 #endif
 201 #ifdef PR_GET_FPEMU
 202         { PR_GET_FPEMU,         "PR_GET_FPEMU"          },
 203 #endif
 204 #ifdef PR_SET_FPEMU
 205         { PR_SET_FPEMU,         "PR_SET_FPEMU"          },
 206 #endif
 207 #ifdef PR_GET_FPEXC
 208         { PR_GET_FPEXC,         "PR_GET_FPEXC"          },
 209 #endif
 210 #ifdef PR_SET_FPEXC
 211         { PR_SET_FPEXC,         "PR_SET_FPEXC"          },
 212 #endif
 213 #ifdef PR_GET_TIMING
 214         { PR_GET_TIMING,        "PR_GET_TIMING"         },
 215 #endif
 216 #ifdef PR_SET_TIMING
 217         { PR_SET_TIMING,        "PR_SET_TIMING"         },
 218 #endif
 219 #ifdef PR_SET_NAME
 220         { PR_SET_NAME,          "PR_SET_NAME"           },
 221 #endif
 222 #ifdef PR_GET_NAME
 223         { PR_GET_NAME,          "PR_GET_NAME"           },
 224 #endif
 225 #ifdef PR_GET_ENDIAN
 226         { PR_GET_ENDIAN,        "PR_GET_ENDIAN"         },
 227 #endif
 228 #ifdef PR_SET_ENDIAN
 229         { PR_SET_ENDIAN,        "PR_SET_ENDIAN"         },
 230 #endif
 231 #ifdef PR_GET_SECCOMP
 232         { PR_GET_SECCOMP,       "PR_GET_SECCOMP"        },
 233 #endif
 234 #ifdef PR_SET_SECCOMP
 235         { PR_SET_SECCOMP,       "PR_SET_SECCOMP"        },
 236 #endif
 237 #ifdef PR_GET_TSC
 238         { PR_GET_TSC,           "PR_GET_TSC"            },
 239 #endif
 240 #ifdef PR_SET_TSC
 241         { PR_SET_TSC,           "PR_SET_TSC"            },
 242 #endif
 243 #ifdef PR_GET_SECUREBITS
 244         { PR_GET_SECUREBITS,    "PR_GET_SECUREBITS"     },
 245 #endif
 246 #ifdef PR_SET_SECUREBITS
 247         { PR_SET_SECUREBITS,    "PR_SET_SECUREBITS"     },
 248 #endif
 249         { 0,                    NULL                    },
 250 };
 251
 252
 253 static const char *
 254 unalignctl_string(unsigned int ctl)
 255 {
 256         static char buf[16];
 257
 258         switch (ctl) {
 259 #ifdef PR_UNALIGN_NOPRINT
 260               case PR_UNALIGN_NOPRINT:
 261                 return "NOPRINT";
 262 #endif
 263 #ifdef PR_UNALIGN_SIGBUS
 264               case PR_UNALIGN_SIGBUS:
 265                 return "SIGBUS";
 266 #endif
 267               default:
 268                 break;
 269         }
 270         sprintf(buf, "%x", ctl);
 271         return buf;
 272 }
 273
 274
 275 int
 276 sys_prctl(struct tcb *tcp)
 277 {
 278         int i;
 279
 280         if (entering(tcp)) {
 281                 printxval(prctl_options, tcp->u_arg[0], "PR_???");
 282                 switch (tcp->u_arg[0]) {
 283 #ifdef PR_GETNSHARE
 284                 case PR_GETNSHARE:
 285                         break;
 286 #endif
 287 #ifdef PR_SET_PDEATHSIG
 288                 case PR_SET_PDEATHSIG:
 289                         tprintf(", %lu", tcp->u_arg[1]);
 290                         break;
 291 #endif
 292 #ifdef PR_GET_PDEATHSIG
 293                 case PR_GET_PDEATHSIG:
 294                         break;
 295 #endif
 296 #ifdef PR_SET_DUMPABLE
 297                 case PR_SET_DUMPABLE:
 298                         tprintf(", %lu", tcp->u_arg[1]);
 299                         break;
 300 #endif
 301 #ifdef PR_GET_DUMPABLE
 302                 case PR_GET_DUMPABLE:
 303                         break;
 304 #endif
 305 #ifdef PR_SET_UNALIGN
 306                 case PR_SET_UNALIGN:
 307                         tprintf(", %s", unalignctl_string(tcp->u_arg[1]));
 308                         break;
 309 #endif
 310 #ifdef PR_GET_UNALIGN
 311                 case PR_GET_UNALIGN:
 312                         tprintf(", %#lx", tcp->u_arg[1]);
 313                         break;
 314 #endif
 315 #ifdef PR_SET_KEEPCAPS
 316                 case PR_SET_KEEPCAPS:
 317                         tprintf(", %lu", tcp->u_arg[1]);
 318                         break;
 319 #endif
 320 #ifdef PR_GET_KEEPCAPS
 321                 case PR_GET_KEEPCAPS:
 322                         break;
 323 #endif
 324                 default:
 325                         for (i = 1; i < tcp->u_nargs; i++)
 326                                 tprintf(", %#lx", tcp->u_arg[i]);
 327                         break;
 328                 }
 329         } else {
 330                 switch (tcp->u_arg[0]) {
 331 #ifdef PR_GET_PDEATHSIG
 332                 case PR_GET_PDEATHSIG:
 333                         if (umove(tcp, tcp->u_arg[1], &i) < 0)
 334                                 tprintf(", %#lx", tcp->u_arg[1]);
 335                         else
 336                                 tprintf(", {%u}", i);
 337                         break;
 338 #endif
 339 #ifdef PR_GET_DUMPABLE
 340                 case PR_GET_DUMPABLE:
 341                         return RVAL_UDECIMAL;
 342 #endif
 343 #ifdef PR_GET_UNALIGN
 344                 case PR_GET_UNALIGN:
 345                         if (syserror(tcp) || umove(tcp, tcp->u_arg[1], &i) < 0)
 346                                 break;
 347                         tcp->auxstr = unalignctl_string(i);
 348                         return RVAL_STR;
 349 #endif
 350 #ifdef PR_GET_KEEPCAPS
 351                 case PR_GET_KEEPCAPS:
 352                         return RVAL_UDECIMAL;
 353 #endif
 354                 default:
 355                         break;
 356                 }
 357         }
 358         return 0;
 359 }
 360 #endif /* HAVE_PRCTL */
 361
 362 #if defined(FREEBSD) || defined(SUNOS4) || defined(SVR4)
 363 int
 364 sys_gethostid(struct tcb *tcp)
 365 {
 366         if (exiting(tcp))
 367                 return RVAL_HEX;
 368         return 0;
 369 }
 370 #endif /* FREEBSD || SUNOS4 || SVR4 */
 371
 372 int
 373 sys_sethostname(struct tcb *tcp)
 374 {
 375         if (entering(tcp)) {
 376                 printpathn(tcp, tcp->u_arg[0], tcp->u_arg[1]);
 377                 tprintf(", %lu", tcp->u_arg[1]);
 378         }
 379         return 0;
 380 }
 381
 382 #if defined(ALPHA) || defined(FREEBSD) || defined(SUNOS4) || defined(SVR4)
 383 int
 384 sys_gethostname(struct tcb *tcp)
 385 {
 386         if (exiting(tcp)) {
 387                 if (syserror(tcp))
 388                         tprintf("%#lx", tcp->u_arg[0]);
 389                 else
 390                         printpath(tcp, tcp->u_arg[0]);
 391                 tprintf(", %lu", tcp->u_arg[1]);
 392         }
 393         return 0;
 394 }
 395 #endif /* ALPHA || FREEBSD || SUNOS4 || SVR4 */
 396
 397 int
 398 sys_setdomainname(struct tcb *tcp)
 399 {
 400         if (entering(tcp)) {
 401                 printpathn(tcp, tcp->u_arg[0], tcp->u_arg[1]);
 402                 tprintf(", %lu", tcp->u_arg[1]);
 403         }
 404         return 0;
 405 }
 406
 407 #if !defined(LINUX)
 408
 409 int
 410 sys_getdomainname(struct tcb *tcp)
 411 {
 412         if (exiting(tcp)) {
 413                 if (syserror(tcp))
 414                         tprintf("%#lx", tcp->u_arg[0]);
 415                 else
 416                         printpath(tcp, tcp->u_arg[0]);
 417                 tprintf(", %lu", tcp->u_arg[1]);
 418         }
 419         return 0;
 420 }
 421 #endif /* !LINUX */
 422
 423 int
 424 sys_exit(struct tcb *tcp)
 425 {
 426         if (exiting(tcp)) {
 427                 fprintf(stderr, "_exit returned!\n");
 428                 return -1;
 429         }
 430         /* special case: we stop tracing this process, finish line now */
 431         tprintf("%ld) ", tcp->u_arg[0]);
 432         tabto();
 433         tprints("= ?\n");
 434         printing_tcp = NULL;
 435         return 0;
 436 }
 437
 438 #ifdef USE_PROCFS
 439
 440 int
 441 sys_fork(struct tcb *tcp)
 442 {
 443         if (exiting(tcp) && !syserror(tcp)) {
 444                 if (getrval2(tcp)) {
 445                         tcp->auxstr = "child process";
 446                         return RVAL_UDECIMAL | RVAL_STR;
 447                 }
 448         }
 449         return 0;
 450 }
 451
 452 #if UNIXWARE > 2
 453
 454 int
 455 sys_rfork(struct tcb *tcp)
 456 {
 457         if (entering(tcp)) {
 458                 tprintf("%ld", tcp->u_arg[0]);
 459         }
 460         else if (!syserror(tcp)) {
 461                 if (getrval2(tcp)) {
 462                         tcp->auxstr = "child process";
 463                         return RVAL_UDECIMAL | RVAL_STR;
 464                 }
 465         }
 466         return 0;
 467 }
 468
 469 #endif
 470
 471 int
 472 internal_fork(struct tcb *tcp)
 473 {
 474         struct tcb *tcpchild;
 475
 476         if (exiting(tcp)) {
 477 #ifdef SYS_rfork
 478                 if (known_scno(tcp) == SYS_rfork && !(tcp->u_arg[0]&RFPROC))
 479                         return 0;
 480 #endif
 481                 if (getrval2(tcp))
 482                         return 0;
 483                 if (!followfork)
 484                         return 0;
 485                 if (syserror(tcp))
 486                         return 0;
 487                 tcpchild = alloctcb(tcp->u_rval);
 488                 if (proc_open(tcpchild, 2) < 0)
 489                         droptcb(tcpchild);
 490                 tcpchild->flags |= TCB_STARTUP;
 491         }
 492         return 0;
 493 }
 494
 495 #else /* !USE_PROCFS */
 496
 497 #ifdef LINUX
 498
 499 /* defines copied from linux/sched.h since we can't include that
 500  * ourselves (it conflicts with *lots* of libc includes)
 501  */
 502 #define CSIGNAL         0x000000ff      /* signal mask to be sent at exit */
 503 #define CLONE_VM        0x00000100      /* set if VM shared between processes */
 504 #define CLONE_FS        0x00000200      /* set if fs info shared between processes */
 505 #define CLONE_FILES     0x00000400      /* set if open files shared between processes */
 506 #define CLONE_SIGHAND   0x00000800      /* set if signal handlers shared */
 507 #define CLONE_IDLETASK  0x00001000      /* kernel-only flag */
 508 #define CLONE_PTRACE    0x00002000      /* set if we want to let tracing continue on the child too */
 509 #define CLONE_VFORK     0x00004000      /* set if the parent wants the child to wake it up on mm_release */
 510 #define CLONE_PARENT    0x00008000      /* set if we want to have the same parent as the cloner */
 511 #define CLONE_THREAD    0x00010000      /* Same thread group? */
 512 #define CLONE_NEWNS     0x00020000      /* New namespace group? */
 513 #define CLONE_SYSVSEM   0x00040000      /* share system V SEM_UNDO semantics */
 514 #define CLONE_SETTLS    0x00080000      /* create a new TLS for the child */
 515 #define CLONE_PARENT_SETTID     0x00100000      /* set the TID in the parent */
 516 #define CLONE_CHILD_CLEARTID    0x00200000      /* clear the TID in the child */
 517 #define CLONE_UNTRACED          0x00800000      /* set if the tracing process can't force CLONE_PTRACE on this clone */
 518 #define CLONE_CHILD_SETTID      0x01000000      /* set the TID in the child */
 519 #define CLONE_STOPPED           0x02000000      /* Start in stopped state */
 520 #define CLONE_NEWUTS            0x04000000      /* New utsname group? */
 521 #define CLONE_NEWIPC            0x08000000      /* New ipcs */
 522 #define CLONE_NEWUSER           0x10000000      /* New user namespace */
 523 #define CLONE_NEWPID            0x20000000      /* New pid namespace */
 524 #define CLONE_NEWNET            0x40000000      /* New network namespace */
 525 #define CLONE_IO                0x80000000      /* Clone io context */
 526
 527 static const struct xlat clone_flags[] = {
 528     { CLONE_VM,         "CLONE_VM"      },
 529     { CLONE_FS,         "CLONE_FS"      },
 530     { CLONE_FILES,      "CLONE_FILES"   },
 531     { CLONE_SIGHAND,    "CLONE_SIGHAND" },
 532     { CLONE_IDLETASK,   "CLONE_IDLETASK"},
 533     { CLONE_PTRACE,     "CLONE_PTRACE"  },
 534     { CLONE_VFORK,      "CLONE_VFORK"   },
 535     { CLONE_PARENT,     "CLONE_PARENT"  },
 536     { CLONE_THREAD,     "CLONE_THREAD" },
 537     { CLONE_NEWNS,      "CLONE_NEWNS" },
 538     { CLONE_SYSVSEM,    "CLONE_SYSVSEM" },
 539     { CLONE_SETTLS,     "CLONE_SETTLS" },
 540     { CLONE_PARENT_SETTID,"CLONE_PARENT_SETTID" },
 541     { CLONE_CHILD_CLEARTID,"CLONE_CHILD_CLEARTID" },
 542     { CLONE_UNTRACED,   "CLONE_UNTRACED" },
 543     { CLONE_CHILD_SETTID,"CLONE_CHILD_SETTID" },
 544     { CLONE_STOPPED,    "CLONE_STOPPED" },
 545     { CLONE_NEWUTS,     "CLONE_NEWUTS" },
 546     { CLONE_NEWIPC,     "CLONE_NEWIPC" },
 547     { CLONE_NEWUSER,    "CLONE_NEWUSER" },
 548     { CLONE_NEWPID,     "CLONE_NEWPID" },
 549     { CLONE_NEWNET,     "CLONE_NEWNET" },
 550     { CLONE_IO,         "CLONE_IO" },
 551     { 0,                NULL            },
 552 };
 553
 554 # ifdef I386
 555 #  include <asm/ldt.h>
 556 #   ifdef HAVE_STRUCT_USER_DESC
 557 #    define modify_ldt_ldt_s user_desc
 558 #   endif
 559 extern void print_ldt_entry();
 560 # endif
 561
 562 # if defined IA64
 563 #  define ARG_FLAGS     0
 564 #  define ARG_STACK     1
 565 #  define ARG_STACKSIZE (known_scno(tcp) == SYS_clone2 ? 2 : -1)
 566 #  define ARG_PTID      (known_scno(tcp) == SYS_clone2 ? 3 : 2)
 567 #  define ARG_CTID      (known_scno(tcp) == SYS_clone2 ? 4 : 3)
 568 #  define ARG_TLS       (known_scno(tcp) == SYS_clone2 ? 5 : 4)
 569 # elif defined S390 || defined S390X || defined CRISV10 || defined CRISV32
 570 #  define ARG_STACK     0
 571 #  define ARG_FLAGS     1
 572 #  define ARG_PTID      2
 573 #  define ARG_CTID      3
 574 #  define ARG_TLS       4
 575 # elif defined X86_64 || defined ALPHA
 576 #  define ARG_FLAGS     0
 577 #  define ARG_STACK     1
 578 #  define ARG_PTID      2
 579 #  define ARG_CTID      3
 580 #  define ARG_TLS       4
 581 # else
 582 #  define ARG_FLAGS     0
 583 #  define ARG_STACK     1
 584 #  define ARG_PTID      2
 585 #  define ARG_TLS       3
 586 #  define ARG_CTID      4
 587 # endif
 588
 589 int
 590 sys_clone(struct tcb *tcp)
 591 {
 592         if (exiting(tcp)) {
 593                 const char *sep = "|";
 594                 unsigned long flags = tcp->u_arg[ARG_FLAGS];
 595                 tprintf("child_stack=%#lx, ", tcp->u_arg[ARG_STACK]);
 596 # ifdef ARG_STACKSIZE
 597                 if (ARG_STACKSIZE != -1)
 598                         tprintf("stack_size=%#lx, ",
 599                                 tcp->u_arg[ARG_STACKSIZE]);
 600 # endif
 601                 tprints("flags=");
 602                 if (!printflags(clone_flags, flags &~ CSIGNAL, NULL))
 603                         sep = "";
 604                 if ((flags & CSIGNAL) != 0)
 605                         tprintf("%s%s", sep, signame(flags & CSIGNAL));
 606                 if ((flags & (CLONE_PARENT_SETTID|CLONE_CHILD_SETTID
 607                               |CLONE_CHILD_CLEARTID|CLONE_SETTLS)) == 0)
 608                         return 0;
 609                 if (flags & CLONE_PARENT_SETTID)
 610                         tprintf(", parent_tidptr=%#lx", tcp->u_arg[ARG_PTID]);
 611                 if (flags & CLONE_SETTLS) {
 612 # ifdef I386
 613                         struct modify_ldt_ldt_s copy;
 614                         if (umove(tcp, tcp->u_arg[ARG_TLS], &copy) != -1) {
 615                                 tprintf(", {entry_number:%d, ",
 616                                         copy.entry_number);
 617                                 if (!verbose(tcp))
 618                                         tprints("...}");
 619                                 else
 620                                         print_ldt_entry(&copy);
 621                         }
 622                         else
 623 # endif
 624                                 tprintf(", tls=%#lx", tcp->u_arg[ARG_TLS]);
 625                 }
 626                 if (flags & (CLONE_CHILD_SETTID|CLONE_CHILD_CLEARTID))
 627                         tprintf(", child_tidptr=%#lx", tcp->u_arg[ARG_CTID]);
 628         }
 629         return 0;
 630 }
 631
 632 int
 633 sys_unshare(struct tcb *tcp)
 634 {
 635         if (entering(tcp))
 636                 printflags(clone_flags, tcp->u_arg[0], "CLONE_???");
 637         return 0;
 638 }
 639 #endif /* LINUX */
 640
 641 int
 642 sys_fork(struct tcb *tcp)
 643 {
 644         if (exiting(tcp))
 645                 return RVAL_UDECIMAL;
 646         return 0;
 647 }
 648
 649 int
 650 change_syscall(struct tcb *tcp, int new)
 651 {
 652 #ifdef LINUX
 653 #if defined(I386)
 654         /* Attempt to make vfork into fork, which we can follow. */
 655         if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(ORIG_EAX * 4), new) < 0)
 656                 return -1;
 657         return 0;
 658 #elif defined(X86_64)
 659         /* Attempt to make vfork into fork, which we can follow. */
 660         if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(ORIG_RAX * 8), new) < 0)
 661                 return -1;
 662         return 0;
 663 #elif defined(POWERPC)
 664         if (ptrace(PTRACE_POKEUSER, tcp->pid,
 665                    (char*)(sizeof(unsigned long)*PT_R0), new) < 0)
 666                 return -1;
 667         return 0;
 668 #elif defined(S390) || defined(S390X)
 669         /* s390 linux after 2.4.7 has a hook in entry.S to allow this */
 670         if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_GPR2), new) < 0)
 671                 return -1;
 672         return 0;
 673 #elif defined(M68K)
 674         if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*PT_ORIG_D0), new) < 0)
 675                 return -1;
 676         return 0;
 677 #elif defined(SPARC) || defined(SPARC64)
 678         struct pt_regs regs;
 679         if (ptrace(PTRACE_GETREGS, tcp->pid, (char*)&regs, 0) < 0)
 680                 return -1;
 681         regs.u_regs[U_REG_G1] = new;
 682         if (ptrace(PTRACE_SETREGS, tcp->pid, (char*)&regs, 0) < 0)
 683                 return -1;
 684         return 0;
 685 #elif defined(MIPS)
 686         if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_V0), new) < 0)
 687                 return -1;
 688         return 0;
 689 #elif defined(ALPHA)
 690         if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_A3), new) < 0)
 691                 return -1;
 692         return 0;
 693 #elif defined(AVR32)
 694         if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_R8), new) < 0)
 695                 return -1;
 696         return 0;
 697 #elif defined(BFIN)
 698         if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_P0), new) < 0)
 699                 return -1;
 700         return 0;
 701 #elif defined(IA64)
 702         if (ia32) {
 703                 switch (new) {
 704                 case 2:
 705                         break;  /* x86 SYS_fork */
 706                 case SYS_clone:
 707                         new = 120;
 708                         break;
 709                 default:
 710                         fprintf(stderr, "%s: unexpected syscall %d\n",
 711                                 __FUNCTION__, new);
 712                         return -1;
 713                 }
 714                 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_R1), new) < 0)
 715                         return -1;
 716         } else if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_R15), new) < 0)
 717                 return -1;
 718         return 0;
 719 #elif defined(HPPA)
 720         if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_GR20), new) < 0)
 721                 return -1;
 722         return 0;
 723 #elif defined(SH)
 724         if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*(REG_REG0+3)), new) < 0)
 725                 return -1;
 726         return 0;
 727 #elif defined(SH64)
 728         /* Top half of reg encodes the no. of args n as 0x1n.
 729            Assume 0 args as kernel never actually checks... */
 730         if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_SYSCALL),
 731                                 0x100000 | new) < 0)
 732                 return -1;
 733         return 0;
 734 #elif defined(CRISV10) || defined(CRISV32)
 735         if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*PT_R9), new) < 0)
 736                 return -1;
 737         return 0;
 738 #elif defined(ARM)
 739         /* Some kernels support this, some (pre-2.6.16 or so) don't.  */
 740 # ifndef PTRACE_SET_SYSCALL
 741 #  define PTRACE_SET_SYSCALL 23
 742 # endif
 743
 744         if (ptrace(PTRACE_SET_SYSCALL, tcp->pid, 0, new & 0xffff) != 0)
 745                 return -1;
 746
 747         return 0;
 748 #elif defined(TILE)
 749         if (ptrace(PTRACE_POKEUSER, tcp->pid,
 750                    (char*)PTREGS_OFFSET_REG(0),
 751                    new) != 0)
 752                 return -1;
 753         return 0;
 754 #elif defined(MICROBLAZE)
 755         if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_GPR(0)), new) < 0)
 756                 return -1;
 757         return 0;
 758 #else
 759 #warning Do not know how to handle change_syscall for this architecture
 760 #endif /* architecture */
 761 #endif /* LINUX */
 762         return -1;
 763 }
 764
 765 #ifdef LINUX
 766
 767 int
 768 internal_fork(struct tcb *tcp)
 769 {
 770         if ((ptrace_setoptions
 771             & (PTRACE_O_TRACECLONE | PTRACE_O_TRACEFORK | PTRACE_O_TRACEVFORK))
 772            == (PTRACE_O_TRACECLONE | PTRACE_O_TRACEFORK | PTRACE_O_TRACEVFORK))
 773                 return 0;
 774
 775         if (!followfork)
 776                 return 0;
 777
 778         if (entering(tcp)) {
 779                 /*
 780                  * We won't see the new child if clone is called with
 781                  * CLONE_UNTRACED, so we keep the same logic with that option
 782                  * and don't trace it.
 783                  */
 784                 if ((sysent[tcp->scno].sys_func == sys_clone) &&
 785                     (tcp->u_arg[ARG_FLAGS] & CLONE_UNTRACED))
 786                         return 0;
 787                 setbpt(tcp);
 788         } else {
 789                 if (tcp->flags & TCB_BPTSET)
 790                         clearbpt(tcp);
 791         }
 792         return 0;
 793 }
 794
 795 #else /* !LINUX */
 796
 797 int
 798 internal_fork(struct tcb *tcp)
 799 {
 800         struct tcb *tcpchild;
 801         int pid;
 802         int dont_follow = 0;
 803
 804 #ifdef SYS_vfork
 805         if (known_scno(tcp) == SYS_vfork) {
 806                 /* Attempt to make vfork into fork, which we can follow. */
 807                 if (change_syscall(tcp, SYS_fork) < 0)
 808                         dont_follow = 1;
 809         }
 810 #endif
 811
 812         if (!followfork)
 813                 return 0;
 814
 815         if (entering(tcp)) {
 816                 if (dont_follow)
 817                         return 0;
 818                 setbpt(tcp);
 819         }
 820         else {
 821                 int bpt = tcp->flags & TCB_BPTSET;
 822
 823                 if (bpt)
 824                         clearbpt(tcp);
 825
 826                 if (syserror(tcp))
 827                         return 0;
 828
 829                 pid = tcp->u_rval;
 830                 tcpchild = alloctcb(pid);
 831 #ifdef SUNOS4
 832 #ifdef oldway
 833                 /* The child must have run before it can be attached. */
 834                 {
 835                         struct timeval tv;
 836                         tv.tv_sec = 0;
 837                         tv.tv_usec = 10000;
 838                         select(0, NULL, NULL, NULL, &tv);
 839                 }
 840                 if (ptrace(PTRACE_ATTACH, pid, (char *)1, 0) < 0) {
 841                         perror("PTRACE_ATTACH");
 842                         fprintf(stderr, "Too late?\n");
 843                         droptcb(tcpchild);
 844                         return 0;
 845                 }
 846 #else /* !oldway */
 847                 /* Try to catch the new process as soon as possible. */
 848                 {
 849                         int i;
 850                         for (i = 0; i < 1024; i++)
 851                                 if (ptrace(PTRACE_ATTACH, pid, (char *) 1, 0) >= 0)
 852                                         break;
 853                         if (i == 1024) {
 854                                 perror("PTRACE_ATTACH");
 855                                 fprintf(stderr, "Too late?\n");
 856                                 droptcb(tcpchild);
 857                                 return 0;
 858                         }
 859                 }
 860 #endif /* !oldway */
 861 #endif /* SUNOS4 */
 862                 tcpchild->flags |= TCB_ATTACHED | TCB_STARTUP | TCB_IGNORE_ONE_SIGSTOP;
 863                 /* Child has BPT too, must be removed on first occasion */
 864                 if (bpt) {
 865                         tcpchild->flags |= TCB_BPTSET;
 866                         tcpchild->baddr = tcp->baddr;
 867                         memcpy(tcpchild->inst, tcp->inst,
 868                                 sizeof tcpchild->inst);
 869                 }
 870                 if (!qflag)
 871                         fprintf(stderr, "Process %d attached\n", pid);
 872         }
 873         return 0;
 874 }
 875
 876 #endif /* !LINUX */
 877
 878 #endif /* !USE_PROCFS */
 879
 880 #if defined(SUNOS4) || defined(LINUX) || defined(FREEBSD)
 881
 882 int
 883 sys_vfork(struct tcb *tcp)
 884 {
 885         if (exiting(tcp))
 886                 return RVAL_UDECIMAL;
 887         return 0;
 888 }
 889
 890 #endif /* SUNOS4 || LINUX || FREEBSD */
 891
 892 #ifndef LINUX
 893
 894 static char idstr[16];
 895
 896 int
 897 sys_getpid(struct tcb *tcp)
 898 {
 899         if (exiting(tcp)) {
 900                 sprintf(idstr, "ppid %lu", getrval2(tcp));
 901                 tcp->auxstr = idstr;
 902                 return RVAL_STR;
 903         }
 904         return 0;
 905 }
 906
 907 int
 908 sys_getuid(struct tcb *tcp)
 909 {
 910         if (exiting(tcp)) {
 911                 sprintf(idstr, "euid %lu", getrval2(tcp));
 912                 tcp->auxstr = idstr;
 913                 return RVAL_STR;
 914         }
 915         return 0;
 916 }
 917
 918 int
 919 sys_getgid(struct tcb *tcp)
 920 {
 921         if (exiting(tcp)) {
 922                 sprintf(idstr, "egid %lu", getrval2(tcp));
 923                 tcp->auxstr = idstr;
 924                 return RVAL_STR;
 925         }
 926         return 0;
 927 }
 928
 929 #endif /* !LINUX */
 930
 931 #ifdef LINUX
 932
 933 int sys_getuid(struct tcb *tcp)
 934 {
 935         if (exiting(tcp))
 936                 tcp->u_rval = (uid_t) tcp->u_rval;
 937         return RVAL_UDECIMAL;
 938 }
 939
 940 int sys_setfsuid(struct tcb *tcp)
 941 {
 942         if (entering(tcp))
 943                 tprintf("%u", (uid_t) tcp->u_arg[0]);
 944         else
 945                 tcp->u_rval = (uid_t) tcp->u_rval;
 946         return RVAL_UDECIMAL;
 947 }
 948
 949 int
 950 sys_setuid(struct tcb *tcp)
 951 {
 952         if (entering(tcp)) {
 953                 tprintf("%u", (uid_t) tcp->u_arg[0]);
 954         }
 955         return 0;
 956 }
 957
 958 int
 959 sys_setgid(struct tcb *tcp)
 960 {
 961         if (entering(tcp)) {
 962                 tprintf("%u", (gid_t) tcp->u_arg[0]);
 963         }
 964         return 0;
 965 }
 966
 967 int
 968 sys_getresuid(struct tcb *tcp)
 969 {
 970         if (exiting(tcp)) {
 971                 __kernel_uid_t uid;
 972                 if (syserror(tcp))
 973                         tprintf("%#lx, %#lx, %#lx", tcp->u_arg[0],
 974                                 tcp->u_arg[1], tcp->u_arg[2]);
 975                 else {
 976                         if (umove(tcp, tcp->u_arg[0], &uid) < 0)
 977                                 tprintf("%#lx, ", tcp->u_arg[0]);
 978                         else
 979                                 tprintf("[%lu], ", (unsigned long) uid);
 980                         if (umove(tcp, tcp->u_arg[1], &uid) < 0)
 981                                 tprintf("%#lx, ", tcp->u_arg[1]);
 982                         else
 983                                 tprintf("[%lu], ", (unsigned long) uid);
 984                         if (umove(tcp, tcp->u_arg[2], &uid) < 0)
 985                                 tprintf("%#lx", tcp->u_arg[2]);
 986                         else
 987                                 tprintf("[%lu]", (unsigned long) uid);
 988                 }
 989         }
 990         return 0;
 991 }
 992
 993 int
 994 sys_getresgid(struct tcb *tcp)
 995 {
 996         if (exiting(tcp)) {
 997                 __kernel_gid_t gid;
 998                 if (syserror(tcp))
 999                         tprintf("%#lx, %#lx, %#lx", tcp->u_arg[0],
1000                                 tcp->u_arg[1], tcp->u_arg[2]);
1001                 else {
1002                         if (umove(tcp, tcp->u_arg[0], &gid) < 0)
1003                                 tprintf("%#lx, ", tcp->u_arg[0]);
1004                         else
1005                                 tprintf("[%lu], ", (unsigned long) gid);
1006                         if (umove(tcp, tcp->u_arg[1], &gid) < 0)
1007                                 tprintf("%#lx, ", tcp->u_arg[1]);
1008                         else
1009                                 tprintf("[%lu], ", (unsigned long) gid);
1010                         if (umove(tcp, tcp->u_arg[2], &gid) < 0)
1011                                 tprintf("%#lx", tcp->u_arg[2]);
1012                         else
1013                                 tprintf("[%lu]", (unsigned long) gid);
1014                 }
1015         }
1016         return 0;
1017 }
1018
1019 #endif /* LINUX */
1020
1021 int
1022 sys_setreuid(struct tcb *tcp)
1023 {
1024         if (entering(tcp)) {
1025                 printuid("", tcp->u_arg[0]);
1026                 printuid(", ", tcp->u_arg[1]);
1027         }
1028         return 0;
1029 }
1030
1031 int
1032 sys_setregid(struct tcb *tcp)
1033 {
1034         if (entering(tcp)) {
1035                 printuid("", tcp->u_arg[0]);
1036                 printuid(", ", tcp->u_arg[1]);
1037         }
1038         return 0;
1039 }
1040
1041 #if defined(LINUX) || defined(FREEBSD)
1042 int
1043 sys_setresuid(struct tcb *tcp)
1044 {
1045         if (entering(tcp)) {
1046                 printuid("", tcp->u_arg[0]);
1047                 printuid(", ", tcp->u_arg[1]);
1048                 printuid(", ", tcp->u_arg[2]);
1049         }
1050         return 0;
1051 }
1052 int
1053 sys_setresgid(struct tcb *tcp)
1054 {
1055         if (entering(tcp)) {
1056                 printuid("", tcp->u_arg[0]);
1057                 printuid(", ", tcp->u_arg[1]);
1058                 printuid(", ", tcp->u_arg[2]);
1059         }
1060         return 0;
1061 }
1062
1063 #endif /* LINUX || FREEBSD */
1064
1065 int
1066 sys_setgroups(struct tcb *tcp)
1067 {
1068         if (entering(tcp)) {
1069                 unsigned long len, size, start, cur, end, abbrev_end;
1070                 GETGROUPS_T gid;
1071                 int failed = 0;
1072
1073                 len = tcp->u_arg[0];
1074                 tprintf("%lu, ", len);
1075                 if (len == 0) {
1076                         tprints("[]");
1077                         return 0;
1078                 }
1079                 start = tcp->u_arg[1];
1080                 if (start == 0) {
1081                         tprints("NULL");
1082                         return 0;
1083                 }
1084                 size = len * sizeof(gid);
1085                 end = start + size;
1086                 if (!verbose(tcp) || size / sizeof(gid) != len || end < start) {
1087                         tprintf("%#lx", start);
1088                         return 0;
1089                 }
1090                 if (abbrev(tcp)) {
1091                         abbrev_end = start + max_strlen * sizeof(gid);
1092                         if (abbrev_end < start)
1093                                 abbrev_end = end;
1094                 } else {
1095                         abbrev_end = end;
1096                 }
1097                 tprints("[");
1098                 for (cur = start; cur < end; cur += sizeof(gid)) {
1099                         if (cur > start)
1100                                 tprints(", ");
1101                         if (cur >= abbrev_end) {
1102                                 tprints("...");
1103                                 break;
1104                         }
1105                         if (umoven(tcp, cur, sizeof(gid), (char *) &gid) < 0) {
1106                                 tprints("?");
1107                                 failed = 1;
1108                                 break;
1109                         }
1110                         tprintf("%lu", (unsigned long) gid);
1111                 }
1112                 tprints("]");
1113                 if (failed)
1114                         tprintf(" %#lx", tcp->u_arg[1]);
1115         }
1116         return 0;
1117 }
1118
1119 int
1120 sys_getgroups(struct tcb *tcp)
1121 {
1122         unsigned long len;
1123
1124         if (entering(tcp)) {
1125                 len = tcp->u_arg[0];
1126                 tprintf("%lu, ", len);
1127         } else {
1128                 unsigned long size, start, cur, end, abbrev_end;
1129                 GETGROUPS_T gid;
1130                 int failed = 0;
1131
1132                 len = tcp->u_rval;
1133                 if (len == 0) {
1134                         tprints("[]");
1135                         return 0;
1136                 }
1137                 start = tcp->u_arg[1];
1138                 if (start == 0) {
1139                         tprints("NULL");
1140                         return 0;
1141                 }
1142                 if (tcp->u_arg[0] == 0) {
1143                         tprintf("%#lx", start);
1144                         return 0;
1145                 }
1146                 size = len * sizeof(gid);
1147                 end = start + size;
1148                 if (!verbose(tcp) || tcp->u_arg[0] == 0 ||
1149                     size / sizeof(gid) != len || end < start) {
1150                         tprintf("%#lx", start);
1151                         return 0;
1152                 }
1153                 if (abbrev(tcp)) {
1154                         abbrev_end = start + max_strlen * sizeof(gid);
1155                         if (abbrev_end < start)
1156                                 abbrev_end = end;
1157                 } else {
1158                         abbrev_end = end;
1159                 }
1160                 tprints("[");
1161                 for (cur = start; cur < end; cur += sizeof(gid)) {
1162                         if (cur > start)
1163                                 tprints(", ");
1164                         if (cur >= abbrev_end) {
1165                                 tprints("...");
1166                                 break;
1167                         }
1168                         if (umoven(tcp, cur, sizeof(gid), (char *) &gid) < 0) {
1169                                 tprints("?");
1170                                 failed = 1;
1171                                 break;
1172                         }
1173                         tprintf("%lu", (unsigned long) gid);
1174                 }
1175                 tprints("]");
1176                 if (failed)
1177                         tprintf(" %#lx", tcp->u_arg[1]);
1178         }
1179         return 0;
1180 }
1181
1182 #ifdef LINUX
1183 int
1184 sys_setgroups32(struct tcb *tcp)
1185 {
1186         if (entering(tcp)) {
1187                 unsigned long len, size, start, cur, end, abbrev_end;
1188                 GETGROUPS32_T gid;
1189                 int failed = 0;
1190
1191                 len = tcp->u_arg[0];
1192                 tprintf("%lu, ", len);
1193                 if (len == 0) {
1194                         tprints("[]");
1195                         return 0;
1196                 }
1197                 start = tcp->u_arg[1];
1198                 if (start == 0) {
1199                         tprints("NULL");
1200                         return 0;
1201                 }
1202                 size = len * sizeof(gid);
1203                 end = start + size;
1204                 if (!verbose(tcp) || size / sizeof(gid) != len || end < start) {
1205                         tprintf("%#lx", start);
1206                         return 0;
1207                 }
1208                 if (abbrev(tcp)) {
1209                         abbrev_end = start + max_strlen * sizeof(gid);
1210                         if (abbrev_end < start)
1211                                 abbrev_end = end;
1212                 } else {
1213                         abbrev_end = end;
1214                 }
1215                 tprints("[");
1216                 for (cur = start; cur < end; cur += sizeof(gid)) {
1217                         if (cur > start)
1218                                 tprints(", ");
1219                         if (cur >= abbrev_end) {
1220                                 tprints("...");
1221                                 break;
1222                         }
1223                         if (umoven(tcp, cur, sizeof(gid), (char *) &gid) < 0) {
1224                                 tprints("?");
1225                                 failed = 1;
1226                                 break;
1227                         }
1228                         tprintf("%lu", (unsigned long) gid);
1229                 }
1230                 tprints("]");
1231                 if (failed)
1232                         tprintf(" %#lx", tcp->u_arg[1]);
1233         }
1234         return 0;
1235 }
1236
1237 int
1238 sys_getgroups32(struct tcb *tcp)
1239 {
1240         unsigned long len;
1241
1242         if (entering(tcp)) {
1243                 len = tcp->u_arg[0];
1244                 tprintf("%lu, ", len);
1245         } else {
1246                 unsigned long size, start, cur, end, abbrev_end;
1247                 GETGROUPS32_T gid;
1248                 int failed = 0;
1249
1250                 len = tcp->u_rval;
1251                 if (len == 0) {
1252                         tprints("[]");
1253                         return 0;
1254                 }
1255                 start = tcp->u_arg[1];
1256                 if (start == 0) {
1257                         tprints("NULL");
1258                         return 0;
1259                 }
1260                 size = len * sizeof(gid);
1261                 end = start + size;
1262                 if (!verbose(tcp) || tcp->u_arg[0] == 0 ||
1263                     size / sizeof(gid) != len || end < start) {
1264                         tprintf("%#lx", start);
1265                         return 0;
1266                 }
1267                 if (abbrev(tcp)) {
1268                         abbrev_end = start + max_strlen * sizeof(gid);
1269                         if (abbrev_end < start)
1270                                 abbrev_end = end;
1271                 } else {
1272                         abbrev_end = end;
1273                 }
1274                 tprints("[");
1275                 for (cur = start; cur < end; cur += sizeof(gid)) {
1276                         if (cur > start)
1277                                 tprints(", ");
1278                         if (cur >= abbrev_end) {
1279                                 tprints("...");
1280                                 break;
1281                         }
1282                         if (umoven(tcp, cur, sizeof(gid), (char *) &gid) < 0) {
1283                                 tprints("?");
1284                                 failed = 1;
1285                                 break;
1286                         }
1287                         tprintf("%lu", (unsigned long) gid);
1288                 }
1289                 tprints("]");
1290                 if (failed)
1291                         tprintf(" %#lx", tcp->u_arg[1]);
1292         }
1293         return 0;
1294 }
1295 #endif /* LINUX */
1296
1297 #if defined(ALPHA) || defined(SUNOS4) || defined(SVR4)
1298 int
1299 sys_setpgrp(struct tcb *tcp)
1300 {
1301         if (entering(tcp)) {
1302 #ifndef SVR4
1303                 tprintf("%lu, %lu", tcp->u_arg[0], tcp->u_arg[1]);
1304 #endif /* !SVR4 */
1305         }
1306         return 0;
1307 }
1308 #endif /* ALPHA || SUNOS4 || SVR4 */
1309
1310 int
1311 sys_getpgrp(struct tcb *tcp)
1312 {
1313         if (entering(tcp)) {
1314 #ifndef SVR4
1315                 tprintf("%lu", tcp->u_arg[0]);
1316 #endif /* !SVR4 */
1317         }
1318         return 0;
1319 }
1320
1321 int
1322 sys_getsid(struct tcb *tcp)
1323 {
1324         if (entering(tcp)) {
1325                 tprintf("%lu", tcp->u_arg[0]);
1326         }
1327         return 0;
1328 }
1329
1330 int
1331 sys_setsid(struct tcb *tcp)
1332 {
1333         return 0;
1334 }
1335
1336 int
1337 sys_getpgid(struct tcb *tcp)
1338 {
1339         if (entering(tcp)) {
1340                 tprintf("%lu", tcp->u_arg[0]);
1341         }
1342         return 0;
1343 }
1344
1345 int
1346 sys_setpgid(struct tcb *tcp)
1347 {
1348         if (entering(tcp)) {
1349                 tprintf("%lu, %lu", tcp->u_arg[0], tcp->u_arg[1]);
1350         }
1351         return 0;
1352 }
1353
1354 #if UNIXWARE >= 2
1355
1356 #include <sys/privilege.h>
1357
1358
1359 static const struct xlat procpriv_cmds[] = {
1360         { SETPRV,       "SETPRV"        },
1361         { CLRPRV,       "CLRPRV"        },
1362         { PUTPRV,       "PUTPRV"        },
1363         { GETPRV,       "GETPRV"        },
1364         { CNTPRV,       "CNTPRV"        },
1365         { 0,            NULL            },
1366 };
1367
1368
1369 static const struct xlat procpriv_priv[] = {
1370         { P_OWNER,      "P_OWNER"       },
1371         { P_AUDIT,      "P_AUDIT"       },
1372         { P_COMPAT,     "P_COMPAT"      },
1373         { P_DACREAD,    "P_DACREAD"     },
1374         { P_DACWRITE,   "P_DACWRITE"    },
1375         { P_DEV,        "P_DEV"         },
1376         { P_FILESYS,    "P_FILESYS"     },
1377         { P_MACREAD,    "P_MACREAD"     },
1378         { P_MACWRITE,   "P_MACWRITE"    },
1379         { P_MOUNT,      "P_MOUNT"       },
1380         { P_MULTIDIR,   "P_MULTIDIR"    },
1381         { P_SETPLEVEL,  "P_SETPLEVEL"   },
1382         { P_SETSPRIV,   "P_SETSPRIV"    },
1383         { P_SETUID,     "P_SETUID"      },
1384         { P_SYSOPS,     "P_SYSOPS"      },
1385         { P_SETUPRIV,   "P_SETUPRIV"    },
1386         { P_DRIVER,     "P_DRIVER"      },
1387         { P_RTIME,      "P_RTIME"       },
1388         { P_MACUPGRADE, "P_MACUPGRADE"  },
1389         { P_FSYSRANGE,  "P_FSYSRANGE"   },
1390         { P_SETFLEVEL,  "P_SETFLEVEL"   },
1391         { P_AUDITWR,    "P_AUDITWR"     },
1392         { P_TSHAR,      "P_TSHAR"       },
1393         { P_PLOCK,      "P_PLOCK"       },
1394         { P_CORE,       "P_CORE"        },
1395         { P_LOADMOD,    "P_LOADMOD"     },
1396         { P_BIND,       "P_BIND"        },
1397         { P_ALLPRIVS,   "P_ALLPRIVS"    },
1398         { 0,            NULL            },
1399 };
1400
1401
1402 static const struct xlat procpriv_type[] = {
1403         { PS_FIX,       "PS_FIX"        },
1404         { PS_INH,       "PS_INH"        },
1405         { PS_MAX,       "PS_MAX"        },
1406         { PS_WKG,       "PS_WKG"        },
1407         { 0,            NULL            },
1408 };
1409
1410
1411 static void
1412 printpriv(struct tcb *tcp, long addr, int len, const struct xlat *opt)
1413 {
1414         priv_t buf[128];
1415         int max = verbose(tcp) ? ARRAY_SIZE(buf) : 10;
1416         int dots = len > max;
1417         int i;
1418
1419         if (len > max) len = max;
1420
1421         if (len <= 0 ||
1422             umoven(tcp, addr, len * sizeof buf[0], (char *) buf) < 0)
1423         {
1424                 tprintf("%#lx", addr);
1425                 return;
1426         }
1427
1428         tprints("[");
1429
1430         for (i = 0; i < len; ++i) {
1431                 const char *t, *p;
1432
1433                 if (i) tprints(", ");
1434
1435                 if ((t = xlookup(procpriv_type, buf[i] & PS_TYPE)) &&
1436                     (p = xlookup(procpriv_priv, buf[i] & ~PS_TYPE)))
1437                 {
1438                         tprintf("%s|%s", t, p);
1439                 }
1440                 else {
1441                         tprintf("%#lx", buf[i]);
1442                 }
1443         }
1444
1445         if (dots) tprints(" ...");
1446
1447         tprints("]");
1448 }
1449
1450
1451 int
1452 sys_procpriv(struct tcb *tcp)
1453 {
1454         if (entering(tcp)) {
1455                 printxval(procpriv_cmds, tcp->u_arg[0], "???PRV");
1456                 switch (tcp->u_arg[0]) {
1457                     case CNTPRV:
1458                         tprintf(", %#lx, %ld", tcp->u_arg[1], tcp->u_arg[2]);
1459                         break;
1460
1461                     case GETPRV:
1462                         break;
1463
1464                     default:
1465                         tprints(", ");
1466                         printpriv(tcp, tcp->u_arg[1], tcp->u_arg[2]);
1467                         tprintf(", %ld", tcp->u_arg[2]);
1468                 }
1469         }
1470         else if (tcp->u_arg[0] == GETPRV) {
1471                 if (syserror(tcp)) {
1472                         tprintf(", %#lx, %ld", tcp->u_arg[1], tcp->u_arg[2]);
1473                 }
1474                 else {
1475                         tprints(", ");
1476                         printpriv(tcp, tcp->u_arg[1], tcp->u_rval);
1477                         tprintf(", %ld", tcp->u_arg[2]);
1478                 }
1479         }
1480
1481         return 0;
1482 }
1483
1484 #endif /* UNIXWARE */
1485
1486
1487 static void
1488 printargv(struct tcb *tcp, long addr)
1489 {
1490         union {
1491                 unsigned int p32;
1492                 unsigned long p64;
1493                 char data[sizeof(long)];
1494         } cp;
1495         const char *sep;
1496         int n = 0;
1497
1498         cp.p64 = 1;
1499         for (sep = ""; !abbrev(tcp) || n < max_strlen / 2; sep = ", ", ++n) {
1500                 if (umoven(tcp, addr, personality_wordsize[current_personality],
1501                            cp.data) < 0) {
1502                         tprintf("%#lx", addr);
1503                         return;
1504                 }
1505                 if (personality_wordsize[current_personality] == 4)
1506                         cp.p64 = cp.p32;
1507                 if (cp.p64 == 0)
1508                         break;
1509                 tprints(sep);
1510                 printstr(tcp, cp.p64, -1);
1511                 addr += personality_wordsize[current_personality];
1512         }
1513         if (cp.p64)
1514                 tprintf("%s...", sep);
1515 }
1516
1517 static void
1518 printargc(const char *fmt, struct tcb *tcp, long addr)
1519 {
1520         int count;
1521         char *cp;
1522
1523         for (count = 0; umove(tcp, addr, &cp) >= 0 && cp != NULL; count++) {
1524                 addr += sizeof(char *);
1525         }
1526         tprintf(fmt, count, count == 1 ? "" : "s");
1527 }
1528
1529 #if defined(SPARC) || defined(SPARC64) || defined(SUNOS4)
1530 int
1531 sys_execv(struct tcb *tcp)
1532 {
1533         if (entering(tcp)) {
1534                 printpath(tcp, tcp->u_arg[0]);
1535                 if (!verbose(tcp))
1536                         tprintf(", %#lx", tcp->u_arg[1]);
1537                 else {
1538                         tprints(", [");
1539                         printargv(tcp, tcp->u_arg[1]);
1540                         tprints("]");
1541                 }
1542         }
1543         return 0;
1544 }
1545 #endif /* SPARC || SPARC64 || SUNOS4 */
1546
1547 int
1548 sys_execve(struct tcb *tcp)
1549 {
1550         if (entering(tcp)) {
1551                 printpath(tcp, tcp->u_arg[0]);
1552                 if (!verbose(tcp))
1553                         tprintf(", %#lx", tcp->u_arg[1]);
1554                 else {
1555                         tprints(", [");
1556                         printargv(tcp, tcp->u_arg[1]);
1557                         tprints("]");
1558                 }
1559                 if (!verbose(tcp))
1560                         tprintf(", %#lx", tcp->u_arg[2]);
1561                 else if (abbrev(tcp))
1562                         printargc(", [/* %d var%s */]", tcp, tcp->u_arg[2]);
1563                 else {
1564                         tprints(", [");
1565                         printargv(tcp, tcp->u_arg[2]);
1566                         tprints("]");
1567                 }
1568         }
1569         return 0;
1570 }
1571
1572 #if UNIXWARE > 2
1573
1574 int sys_rexecve(struct tcb *tcp)
1575 {
1576         if (entering(tcp)) {
1577                 sys_execve(tcp);
1578                 tprintf(", %ld", tcp->u_arg[3]);
1579         }
1580         return 0;
1581 }
1582
1583 #endif
1584
1585 #if defined SUNOS4 || (defined LINUX && defined TCB_WAITEXECVE)
1586 int
1587 internal_exec(struct tcb *tcp)
1588 {
1589 # if defined SUNOS4
1590         if (exiting(tcp) && !syserror(tcp) && followfork)
1591                 fixvfork(tcp);
1592 # endif
1593 # if defined LINUX && defined TCB_WAITEXECVE
1594         if (exiting(tcp) && syserror(tcp))
1595                 tcp->flags &= ~TCB_WAITEXECVE;
1596         else {
1597                 /* Maybe we have post-execve SIGTRAP suppressed? */
1598                 if (!(ptrace_setoptions & PTRACE_O_TRACEEXEC))
1599                         tcp->flags |= TCB_WAITEXECVE; /* no */
1600         }
1601 # endif
1602         return 0;
1603 }
1604 #endif
1605
1606 #ifdef LINUX
1607 #ifndef __WNOTHREAD
1608 #define __WNOTHREAD     0x20000000
1609 #endif
1610 #ifndef __WALL
1611 #define __WALL          0x40000000
1612 #endif
1613 #ifndef __WCLONE
1614 #define __WCLONE        0x80000000
1615 #endif
1616 #endif /* LINUX */
1617
1618 static const struct xlat wait4_options[] = {
1619         { WNOHANG,      "WNOHANG"       },
1620 #ifndef WSTOPPED
1621         { WUNTRACED,    "WUNTRACED"     },
1622 #endif
1623 #ifdef WEXITED
1624         { WEXITED,      "WEXITED"       },
1625 #endif
1626 #ifdef WTRAPPED
1627         { WTRAPPED,     "WTRAPPED"      },
1628 #endif
1629 #ifdef WSTOPPED
1630         { WSTOPPED,     "WSTOPPED"      },
1631 #endif
1632 #ifdef WCONTINUED
1633         { WCONTINUED,   "WCONTINUED"    },
1634 #endif
1635 #ifdef WNOWAIT
1636         { WNOWAIT,      "WNOWAIT"       },
1637 #endif
1638 #ifdef __WCLONE
1639         { __WCLONE,     "__WCLONE"      },
1640 #endif
1641 #ifdef __WALL
1642         { __WALL,       "__WALL"        },
1643 #endif
1644 #ifdef __WNOTHREAD
1645         { __WNOTHREAD,  "__WNOTHREAD"   },
1646 #endif
1647         { 0,            NULL            },
1648 };
1649
1650 #if !defined WCOREFLAG && defined WCOREFLG
1651 # define WCOREFLAG WCOREFLG
1652 #endif
1653 #ifndef WCOREFLAG
1654 # define WCOREFLAG 0x80
1655 #endif
1656 #ifndef WCOREDUMP
1657 # define WCOREDUMP(status) ((status) & 0200)
1658 #endif
1659
1660
1661 #ifndef W_STOPCODE
1662 #define W_STOPCODE(sig)         ((sig) << 8 | 0x7f)
1663 #endif
1664 #ifndef W_EXITCODE
1665 #define W_EXITCODE(ret, sig)    ((ret) << 8 | (sig))
1666 #endif
1667
1668 static int
1669 printstatus(int status)
1670 {
1671         int exited = 0;
1672
1673         /*
1674          * Here is a tricky presentation problem.  This solution
1675          * is still not entirely satisfactory but since there
1676          * are no wait status constructors it will have to do.
1677          */
1678         if (WIFSTOPPED(status)) {
1679                 tprintf("[{WIFSTOPPED(s) && WSTOPSIG(s) == %s}",
1680                         signame(WSTOPSIG(status)));
1681                 status &= ~W_STOPCODE(WSTOPSIG(status));
1682         }
1683         else if (WIFSIGNALED(status)) {
1684                 tprintf("[{WIFSIGNALED(s) && WTERMSIG(s) == %s%s}",
1685                         signame(WTERMSIG(status)),
1686                         WCOREDUMP(status) ? " && WCOREDUMP(s)" : "");
1687                 status &= ~(W_EXITCODE(0, WTERMSIG(status)) | WCOREFLAG);
1688         }
1689         else if (WIFEXITED(status)) {
1690                 tprintf("[{WIFEXITED(s) && WEXITSTATUS(s) == %d}",
1691                         WEXITSTATUS(status));
1692                 exited = 1;
1693                 status &= ~W_EXITCODE(WEXITSTATUS(status), 0);
1694         }
1695         else {
1696                 tprintf("[%#x]", status);
1697                 return 0;
1698         }
1699
1700         if (status == 0)
1701                 tprints("]");
1702         else
1703                 tprintf(" | %#x]", status);
1704
1705         return exited;
1706 }
1707
1708 static int
1709 printwaitn(struct tcb *tcp, int n, int bitness)
1710 {
1711         int status;
1712 #ifdef SUNOS4
1713         int exited = 0;
1714 #endif
1715
1716         if (entering(tcp)) {
1717 #ifdef LINUX
1718                 /* On Linux, kernel-side pid_t is typedef'ed to int
1719                  * on all arches. Also, glibc-2.8 truncates wait3 and wait4
1720                  * pid argument to int on 64bit arches, producing,
1721                  * for example, wait4(4294967295, ...) instead of -1
1722                  * in strace. We have to use int here, not long.
1723                  */
1724                 int pid = tcp->u_arg[0];
1725                 tprintf("%d, ", pid);
1726 #else
1727                 long pid = tcp->u_arg[0];
1728 # if SUPPORTED_PERSONALITIES > 1
1729                 /* Sign-extend a 32-bit value when that's what it is. */
1730                 if (personality_wordsize[current_personality] < sizeof pid)
1731                         pid = (long) (int) pid;
1732 # endif
1733                 tprintf("%ld, ", pid);
1734 #endif
1735         } else {
1736                 /* status */
1737                 if (!tcp->u_arg[1])
1738                         tprints("NULL");
1739                 else if (syserror(tcp) || tcp->u_rval == 0)
1740                         tprintf("%#lx", tcp->u_arg[1]);
1741                 else if (umove(tcp, tcp->u_arg[1], &status) < 0)
1742                         tprints("[?]");
1743                 else
1744 #ifdef SUNOS4
1745                         exited =
1746 #endif
1747                         printstatus(status);
1748                 /* options */
1749                 tprints(", ");
1750                 printflags(wait4_options, tcp->u_arg[2], "W???");
1751                 if (n == 4) {
1752                         tprints(", ");
1753                         /* usage */
1754                         if (!tcp->u_arg[3])
1755                                 tprints("NULL");
1756 #ifdef LINUX
1757                         else if (tcp->u_rval > 0) {
1758 #ifdef ALPHA
1759                                 if (bitness)
1760                                         printrusage32(tcp, tcp->u_arg[3]);
1761                                 else
1762 #endif
1763                                         printrusage(tcp, tcp->u_arg[3]);
1764                         }
1765 #endif /* LINUX */
1766 #ifdef SUNOS4
1767                         else if (tcp->u_rval > 0 && exited)
1768                                 printrusage(tcp, tcp->u_arg[3]);
1769 #endif /* SUNOS4 */
1770                         else
1771                                 tprintf("%#lx", tcp->u_arg[3]);
1772                 }
1773         }
1774         return 0;
1775 }
1776
1777 #ifdef SVR4
1778
1779 int
1780 sys_wait(struct tcb *tcp)
1781 {
1782         if (exiting(tcp)) {
1783                 /* The library wrapper stuffs this into the user variable. */
1784                 if (!syserror(tcp))
1785                         printstatus(getrval2(tcp));
1786         }
1787         return 0;
1788 }
1789
1790 #endif /* SVR4 */
1791
1792 #ifdef FREEBSD
1793 int
1794 sys_wait(struct tcb *tcp)
1795 {
1796         int status;
1797
1798         if (exiting(tcp)) {
1799                 if (!syserror(tcp)) {
1800                         if (umove(tcp, tcp->u_arg[0], &status) < 0)
1801                                 tprintf("%#lx", tcp->u_arg[0]);
1802                         else
1803                                 printstatus(status);
1804                 }
1805         }
1806         return 0;
1807 }
1808 #endif
1809
1810 int
1811 sys_waitpid(struct tcb *tcp)
1812 {
1813         return printwaitn(tcp, 3, 0);
1814 }
1815
1816 int
1817 sys_wait4(struct tcb *tcp)
1818 {
1819         return printwaitn(tcp, 4, 0);
1820 }
1821
1822 #ifdef ALPHA
1823 int
1824 sys_osf_wait4(struct tcb *tcp)
1825 {
1826         return printwaitn(tcp, 4, 1);
1827 }
1828 #endif
1829
1830 #if defined SVR4 || defined LINUX
1831
1832 static const struct xlat waitid_types[] = {
1833         { P_PID,        "P_PID"         },
1834 #ifdef P_PPID
1835         { P_PPID,       "P_PPID"        },
1836 #endif
1837         { P_PGID,       "P_PGID"        },
1838 #ifdef P_SID
1839         { P_SID,        "P_SID"         },
1840 #endif
1841 #ifdef P_CID
1842         { P_CID,        "P_CID"         },
1843 #endif
1844 #ifdef P_UID
1845         { P_UID,        "P_UID"         },
1846 #endif
1847 #ifdef P_GID
1848         { P_GID,        "P_GID"         },
1849 #endif
1850         { P_ALL,        "P_ALL"         },
1851 #ifdef P_LWPID
1852         { P_LWPID,      "P_LWPID"       },
1853 #endif
1854         { 0,            NULL            },
1855 };
1856
1857 int
1858 sys_waitid(struct tcb *tcp)
1859 {
1860         siginfo_t si;
1861
1862         if (entering(tcp)) {
1863                 printxval(waitid_types, tcp->u_arg[0], "P_???");
1864                 tprintf(", %ld, ", tcp->u_arg[1]);
1865         }
1866         else {
1867                 /* siginfo */
1868                 if (!tcp->u_arg[2])
1869                         tprints("NULL");
1870                 else if (syserror(tcp))
1871                         tprintf("%#lx", tcp->u_arg[2]);
1872                 else if (umove(tcp, tcp->u_arg[2], &si) < 0)
1873                         tprints("{???}");
1874                 else
1875                         printsiginfo(&si, verbose(tcp));
1876                 /* options */
1877                 tprints(", ");
1878                 printflags(wait4_options, tcp->u_arg[3], "W???");
1879                 if (tcp->u_nargs > 4) {
1880                         /* usage */
1881                         tprints(", ");
1882                         if (!tcp->u_arg[4])
1883                                 tprints("NULL");
1884                         else if (tcp->u_error)
1885                                 tprintf("%#lx", tcp->u_arg[4]);
1886                         else
1887                                 printrusage(tcp, tcp->u_arg[4]);
1888                 }
1889         }
1890         return 0;
1891 }
1892
1893 #endif /* SVR4 or LINUX */
1894
1895 int
1896 sys_alarm(struct tcb *tcp)
1897 {
1898         if (entering(tcp))
1899                 tprintf("%lu", tcp->u_arg[0]);
1900         return 0;
1901 }
1902
1903 int
1904 sys_uname(struct tcb *tcp)
1905 {
1906         struct utsname uname;
1907
1908         if (exiting(tcp)) {
1909                 if (syserror(tcp) || !verbose(tcp))
1910                         tprintf("%#lx", tcp->u_arg[0]);
1911                 else if (umove(tcp, tcp->u_arg[0], &uname) < 0)
1912                         tprints("{...}");
1913                 else if (!abbrev(tcp)) {
1914
1915                         tprintf("{sysname=\"%s\", nodename=\"%s\", ",
1916                                 uname.sysname, uname.nodename);
1917                         tprintf("release=\"%s\", version=\"%s\", ",
1918                                 uname.release, uname.version);
1919                         tprintf("machine=\"%s\"", uname.machine);
1920 #ifdef LINUX
1921 #ifndef __GLIBC__
1922                         tprintf(", domainname=\"%s\"", uname.domainname);
1923 #endif
1924 #endif
1925                         tprints("}");
1926                 }
1927                 else
1928                         tprintf("{sys=\"%s\", node=\"%s\", ...}",
1929                                 uname.sysname, uname.nodename);
1930         }
1931         return 0;
1932 }
1933
1934 #ifndef SVR4
1935
1936 static const struct xlat ptrace_cmds[] = {
1937 # ifndef FREEBSD
1938         { PTRACE_TRACEME,       "PTRACE_TRACEME"        },
1939         { PTRACE_PEEKTEXT,      "PTRACE_PEEKTEXT"       },
1940         { PTRACE_PEEKDATA,      "PTRACE_PEEKDATA"       },
1941         { PTRACE_PEEKUSER,      "PTRACE_PEEKUSER"       },
1942         { PTRACE_POKETEXT,      "PTRACE_POKETEXT"       },
1943         { PTRACE_POKEDATA,      "PTRACE_POKEDATA"       },
1944         { PTRACE_POKEUSER,      "PTRACE_POKEUSER"       },
1945         { PTRACE_CONT,          "PTRACE_CONT"           },
1946         { PTRACE_KILL,          "PTRACE_KILL"           },
1947         { PTRACE_SINGLESTEP,    "PTRACE_SINGLESTEP"     },
1948         { PTRACE_ATTACH,        "PTRACE_ATTACH"         },
1949         { PTRACE_DETACH,        "PTRACE_DETACH"         },
1950 #  ifdef PTRACE_GETREGS
1951         { PTRACE_GETREGS,       "PTRACE_GETREGS"        },
1952 #  endif
1953 #  ifdef PTRACE_SETREGS
1954         { PTRACE_SETREGS,       "PTRACE_SETREGS"        },
1955 #  endif
1956 #  ifdef PTRACE_GETFPREGS
1957         { PTRACE_GETFPREGS,     "PTRACE_GETFPREGS"      },
1958 #  endif
1959 #  ifdef PTRACE_SETFPREGS
1960         { PTRACE_SETFPREGS,     "PTRACE_SETFPREGS"      },
1961 #  endif
1962 #  ifdef PTRACE_GETFPXREGS
1963         { PTRACE_GETFPXREGS,    "PTRACE_GETFPXREGS"     },
1964 #  endif
1965 #  ifdef PTRACE_SETFPXREGS
1966         { PTRACE_SETFPXREGS,    "PTRACE_SETFPXREGS"     },
1967 #  endif
1968 #  ifdef PTRACE_GETVRREGS
1969         { PTRACE_GETVRREGS,     "PTRACE_GETVRREGS"      },
1970 #  endif
1971 #  ifdef PTRACE_SETVRREGS
1972         { PTRACE_SETVRREGS,     "PTRACE_SETVRREGS"      },
1973 #  endif
1974 #  ifdef PTRACE_SETOPTIONS
1975         { PTRACE_SETOPTIONS,    "PTRACE_SETOPTIONS"     },
1976 #  endif
1977 #  ifdef PTRACE_GETEVENTMSG
1978         { PTRACE_GETEVENTMSG,   "PTRACE_GETEVENTMSG"    },
1979 #  endif
1980 #  ifdef PTRACE_GETSIGINFO
1981         { PTRACE_GETSIGINFO,    "PTRACE_GETSIGINFO"     },
1982 #  endif
1983 #  ifdef PTRACE_SETSIGINFO
1984         { PTRACE_SETSIGINFO,    "PTRACE_SETSIGINFO"     },
1985 #  endif
1986 #  ifdef PTRACE_GETREGSET
1987         { PTRACE_GETREGSET,     "PTRACE_GETREGSET"      },
1988 #  endif
1989 #  ifdef PTRACE_SETREGSET
1990         { PTRACE_SETREGSET,     "PTRACE_SETREGSET"      },
1991 #  endif
1992 #  ifdef PTRACE_SET_SYSCALL
1993         { PTRACE_SET_SYSCALL,   "PTRACE_SET_SYSCALL"    },
1994 #  endif
1995 #  ifdef PTRACE_SEIZE
1996         { PTRACE_SEIZE,         "PTRACE_SEIZE"          },
1997 #  endif
1998 #  ifdef PTRACE_INTERRUPT
1999         { PTRACE_INTERRUPT,     "PTRACE_INTERRUPT"      },
2000 #  endif
2001 #  ifdef PTRACE_LISTEN
2002         { PTRACE_LISTEN,        "PTRACE_LISTEN"         },
2003 #  endif
2004 #  ifdef SUNOS4
2005         { PTRACE_READDATA,      "PTRACE_READDATA"       },
2006         { PTRACE_WRITEDATA,     "PTRACE_WRITEDATA"      },
2007         { PTRACE_READTEXT,      "PTRACE_READTEXT"       },
2008         { PTRACE_WRITETEXT,     "PTRACE_WRITETEXT"      },
2009         { PTRACE_GETFPAREGS,    "PTRACE_GETFPAREGS"     },
2010         { PTRACE_SETFPAREGS,    "PTRACE_SETFPAREGS"     },
2011 #   ifdef SPARC
2012         { PTRACE_GETWINDOW,     "PTRACE_GETWINDOW"      },
2013         { PTRACE_SETWINDOW,     "PTRACE_SETWINDOW"      },
2014 #   else /* !SPARC */
2015         { PTRACE_22,            "PTRACE_22"             },
2016         { PTRACE_23,            "PTRACE_3"              },
2017 #   endif /* !SPARC */
2018 #  endif /* SUNOS4 */
2019         { PTRACE_SYSCALL,       "PTRACE_SYSCALL"        },
2020 #  ifdef SUNOS4
2021         { PTRACE_DUMPCORE,      "PTRACE_DUMPCORE"       },
2022 #   ifdef I386
2023         { PTRACE_SETWRBKPT,     "PTRACE_SETWRBKPT"      },
2024         { PTRACE_SETACBKPT,     "PTRACE_SETACBKPT"      },
2025         { PTRACE_CLRDR7,        "PTRACE_CLRDR7"         },
2026 #   else /* !I386 */
2027         { PTRACE_26,            "PTRACE_26"             },
2028         { PTRACE_27,            "PTRACE_27"             },
2029         { PTRACE_28,            "PTRACE_28"             },
2030 #   endif /* !I386 */
2031         { PTRACE_GETUCODE,      "PTRACE_GETUCODE"       },
2032 #  endif /* SUNOS4 */
2033
2034 # else /* FREEBSD */
2035
2036         { PT_TRACE_ME,          "PT_TRACE_ME"           },
2037         { PT_READ_I,            "PT_READ_I"             },
2038         { PT_READ_D,            "PT_READ_D"             },
2039         { PT_WRITE_I,           "PT_WRITE_I"            },
2040         { PT_WRITE_D,           "PT_WRITE_D"            },
2041 #  ifdef PT_READ_U
2042         { PT_READ_U,            "PT_READ_U"             },
2043 #  endif
2044         { PT_CONTINUE,          "PT_CONTINUE"           },
2045         { PT_KILL,              "PT_KILL"               },
2046         { PT_STEP,              "PT_STEP"               },
2047         { PT_ATTACH,            "PT_ATTACH"             },
2048         { PT_DETACH,            "PT_DETACH"             },
2049         { PT_GETREGS,           "PT_GETREGS"            },
2050         { PT_SETREGS,           "PT_SETREGS"            },
2051         { PT_GETFPREGS,         "PT_GETFPREGS"          },
2052         { PT_SETFPREGS,         "PT_SETFPREGS"          },
2053         { PT_GETDBREGS,         "PT_GETDBREGS"          },
2054         { PT_SETDBREGS,         "PT_SETDBREGS"          },
2055 # endif /* FREEBSD */
2056         { 0,                    NULL                    },
2057 };
2058
2059 # ifndef FREEBSD
2060 #  ifdef PTRACE_SETOPTIONS
2061 static const struct xlat ptrace_setoptions_flags[] = {
2062 #   ifdef PTRACE_O_TRACESYSGOOD
2063         { PTRACE_O_TRACESYSGOOD,"PTRACE_O_TRACESYSGOOD" },
2064 #   endif
2065 #   ifdef PTRACE_O_TRACEFORK
2066         { PTRACE_O_TRACEFORK,   "PTRACE_O_TRACEFORK"    },
2067 #   endif
2068 #   ifdef PTRACE_O_TRACEVFORK
2069         { PTRACE_O_TRACEVFORK,  "PTRACE_O_TRACEVFORK"   },
2070 #   endif
2071 #   ifdef PTRACE_O_TRACECLONE
2072         { PTRACE_O_TRACECLONE,  "PTRACE_O_TRACECLONE"   },
2073 #   endif
2074 #   ifdef PTRACE_O_TRACEEXEC
2075         { PTRACE_O_TRACEEXEC,   "PTRACE_O_TRACEEXEC"    },
2076 #   endif
2077 #   ifdef PTRACE_O_TRACEVFORKDONE
2078         { PTRACE_O_TRACEVFORKDONE,"PTRACE_O_TRACEVFORKDONE"},
2079 #   endif
2080 #   ifdef PTRACE_O_TRACEEXIT
2081         { PTRACE_O_TRACEEXIT,   "PTRACE_O_TRACEEXIT"    },
2082 #   endif
2083         { 0,                    NULL                    },
2084 };
2085 #  endif /* PTRACE_SETOPTIONS */
2086 # endif /* !FREEBSD */
2087
2088 # ifndef FREEBSD
2089 const struct xlat struct_user_offsets[] = {
2090 #  ifdef LINUX
2091 #   if defined(S390) || defined(S390X)
2092         { PT_PSWMASK,           "psw_mask"                              },
2093         { PT_PSWADDR,           "psw_addr"                              },
2094         { PT_GPR0,              "gpr0"                                  },
2095         { PT_GPR1,              "gpr1"                                  },
2096         { PT_GPR2,              "gpr2"                                  },
2097         { PT_GPR3,              "gpr3"                                  },
2098         { PT_GPR4,              "gpr4"                                  },
2099         { PT_GPR5,              "gpr5"                                  },
2100         { PT_GPR6,              "gpr6"                                  },
2101         { PT_GPR7,              "gpr7"                                  },
2102         { PT_GPR8,              "gpr8"                                  },
2103         { PT_GPR9,              "gpr9"                                  },
2104         { PT_GPR10,             "gpr10"                                 },
2105         { PT_GPR11,             "gpr11"                                 },
2106         { PT_GPR12,             "gpr12"                                 },
2107         { PT_GPR13,             "gpr13"                                 },
2108         { PT_GPR14,             "gpr14"                                 },
2109         { PT_GPR15,             "gpr15"                                 },
2110         { PT_ACR0,              "acr0"                                  },
2111         { PT_ACR1,              "acr1"                                  },
2112         { PT_ACR2,              "acr2"                                  },
2113         { PT_ACR3,              "acr3"                                  },
2114         { PT_ACR4,              "acr4"                                  },
2115         { PT_ACR5,              "acr5"                                  },
2116         { PT_ACR6,              "acr6"                                  },
2117         { PT_ACR7,              "acr7"                                  },
2118         { PT_ACR8,              "acr8"                                  },
2119         { PT_ACR9,              "acr9"                                  },
2120         { PT_ACR10,             "acr10"                                 },
2121         { PT_ACR11,             "acr11"                                 },
2122         { PT_ACR12,             "acr12"                                 },
2123         { PT_ACR13,             "acr13"                                 },
2124         { PT_ACR14,             "acr14"                                 },
2125         { PT_ACR15,             "acr15"                                 },
2126         { PT_ORIGGPR2,          "orig_gpr2"                             },
2127         { PT_FPC,               "fpc"                                   },
2128 #    if defined(S390)
2129         { PT_FPR0_HI,           "fpr0.hi"                               },
2130         { PT_FPR0_LO,           "fpr0.lo"                               },
2131         { PT_FPR1_HI,           "fpr1.hi"                               },
2132         { PT_FPR1_LO,           "fpr1.lo"                               },
2133         { PT_FPR2_HI,           "fpr2.hi"                               },
2134         { PT_FPR2_LO,           "fpr2.lo"                               },
2135         { PT_FPR3_HI,           "fpr3.hi"                               },
2136         { PT_FPR3_LO,           "fpr3.lo"                               },
2137         { PT_FPR4_HI,           "fpr4.hi"                               },
2138         { PT_FPR4_LO,           "fpr4.lo"                               },
2139         { PT_FPR5_HI,           "fpr5.hi"                               },
2140         { PT_FPR5_LO,           "fpr5.lo"                               },
2141         { PT_FPR6_HI,           "fpr6.hi"                               },
2142         { PT_FPR6_LO,           "fpr6.lo"                               },
2143         { PT_FPR7_HI,           "fpr7.hi"                               },
2144         { PT_FPR7_LO,           "fpr7.lo"                               },
2145         { PT_FPR8_HI,           "fpr8.hi"                               },
2146         { PT_FPR8_LO,           "fpr8.lo"                               },
2147         { PT_FPR9_HI,           "fpr9.hi"                               },
2148         { PT_FPR9_LO,           "fpr9.lo"                               },
2149         { PT_FPR10_HI,          "fpr10.hi"                              },
2150         { PT_FPR10_LO,          "fpr10.lo"                              },
2151         { PT_FPR11_HI,          "fpr11.hi"                              },
2152         { PT_FPR11_LO,          "fpr11.lo"                              },
2153         { PT_FPR12_HI,          "fpr12.hi"                              },
2154         { PT_FPR12_LO,          "fpr12.lo"                              },
2155         { PT_FPR13_HI,          "fpr13.hi"                              },
2156         { PT_FPR13_LO,          "fpr13.lo"                              },
2157         { PT_FPR14_HI,          "fpr14.hi"                              },
2158         { PT_FPR14_LO,          "fpr14.lo"                              },
2159         { PT_FPR15_HI,          "fpr15.hi"                              },
2160         { PT_FPR15_LO,          "fpr15.lo"                              },
2161 #    endif
2162 #    if defined(S390X)
2163         { PT_FPR0,              "fpr0"                                  },
2164         { PT_FPR1,              "fpr1"                                  },
2165         { PT_FPR2,              "fpr2"                                  },
2166         { PT_FPR3,              "fpr3"                                  },
2167         { PT_FPR4,              "fpr4"                                  },
2168         { PT_FPR5,              "fpr5"                                  },
2169         { PT_FPR6,              "fpr6"                                  },
2170         { PT_FPR7,              "fpr7"                                  },
2171         { PT_FPR8,              "fpr8"                                  },
2172         { PT_FPR9,              "fpr9"                                  },
2173         { PT_FPR10,             "fpr10"                                 },
2174         { PT_FPR11,             "fpr11"                                 },
2175         { PT_FPR12,             "fpr12"                                 },
2176         { PT_FPR13,             "fpr13"                                 },
2177         { PT_FPR14,             "fpr14"                                 },
2178         { PT_FPR15,             "fpr15"                                 },
2179 #    endif
2180         { PT_CR_9,              "cr9"                                   },
2181         { PT_CR_10,             "cr10"                                  },
2182         { PT_CR_11,             "cr11"                                  },
2183         { PT_IEEE_IP,           "ieee_exception_ip"                     },
2184 #   elif defined(SPARC)
2185         /* XXX No support for these offsets yet. */
2186 #   elif defined(HPPA)
2187         /* XXX No support for these offsets yet. */
2188 #   elif defined(POWERPC)
2189 #    ifndef PT_ORIG_R3
2190 #     define PT_ORIG_R3 34
2191 #    endif
2192 #    define REGSIZE (sizeof(unsigned long))
2193         { REGSIZE*PT_R0,                "r0"                            },
2194         { REGSIZE*PT_R1,                "r1"                            },
2195         { REGSIZE*PT_R2,                "r2"                            },
2196         { REGSIZE*PT_R3,                "r3"                            },
2197         { REGSIZE*PT_R4,                "r4"                            },
2198         { REGSIZE*PT_R5,                "r5"                            },
2199         { REGSIZE*PT_R6,                "r6"                            },
2200         { REGSIZE*PT_R7,                "r7"                            },
2201         { REGSIZE*PT_R8,                "r8"                            },
2202         { REGSIZE*PT_R9,                "r9"                            },
2203         { REGSIZE*PT_R10,               "r10"                           },
2204         { REGSIZE*PT_R11,               "r11"                           },
2205         { REGSIZE*PT_R12,               "r12"                           },
2206         { REGSIZE*PT_R13,               "r13"                           },
2207         { REGSIZE*PT_R14,               "r14"                           },
2208         { REGSIZE*PT_R15,               "r15"                           },
2209         { REGSIZE*PT_R16,               "r16"                           },
2210         { REGSIZE*PT_R17,               "r17"                           },
2211         { REGSIZE*PT_R18,               "r18"                           },
2212         { REGSIZE*PT_R19,               "r19"                           },
2213         { REGSIZE*PT_R20,               "r20"                           },
2214         { REGSIZE*PT_R21,               "r21"                           },
2215         { REGSIZE*PT_R22,               "r22"                           },
2216         { REGSIZE*PT_R23,               "r23"                           },
2217         { REGSIZE*PT_R24,               "r24"                           },
2218         { REGSIZE*PT_R25,               "r25"                           },
2219         { REGSIZE*PT_R26,               "r26"                           },
2220         { REGSIZE*PT_R27,               "r27"                           },
2221         { REGSIZE*PT_R28,               "r28"                           },
2222         { REGSIZE*PT_R29,               "r29"                           },
2223         { REGSIZE*PT_R30,               "r30"                           },
2224         { REGSIZE*PT_R31,               "r31"                           },
2225         { REGSIZE*PT_NIP,               "NIP"                           },
2226         { REGSIZE*PT_MSR,               "MSR"                           },
2227         { REGSIZE*PT_ORIG_R3,           "ORIG_R3"                       },
2228         { REGSIZE*PT_CTR,               "CTR"                           },
2229         { REGSIZE*PT_LNK,               "LNK"                           },
2230         { REGSIZE*PT_XER,               "XER"                           },
2231         { REGSIZE*PT_CCR,               "CCR"                           },
2232         { REGSIZE*PT_FPR0,              "FPR0"                          },
2233 #    undef REGSIZE
2234 #   elif defined(ALPHA)
2235         { 0,                    "r0"                                    },
2236         { 1,                    "r1"                                    },
2237         { 2,                    "r2"                                    },
2238         { 3,                    "r3"                                    },
2239         { 4,                    "r4"                                    },
2240         { 5,                    "r5"                                    },
2241         { 6,                    "r6"                                    },
2242         { 7,                    "r7"                                    },
2243         { 8,                    "r8"                                    },
2244         { 9,                    "r9"                                    },
2245         { 10,                   "r10"                                   },
2246         { 11,                   "r11"                                   },
2247         { 12,                   "r12"                                   },
2248         { 13,                   "r13"                                   },
2249         { 14,                   "r14"                                   },
2250         { 15,                   "r15"                                   },
2251         { 16,                   "r16"                                   },
2252         { 17,                   "r17"                                   },
2253         { 18,                   "r18"                                   },
2254         { 19,                   "r19"                                   },
2255         { 20,                   "r20"                                   },
2256         { 21,                   "r21"                                   },
2257         { 22,                   "r22"                                   },
2258         { 23,                   "r23"                                   },
2259         { 24,                   "r24"                                   },
2260         { 25,                   "r25"                                   },
2261         { 26,                   "r26"                                   },
2262         { 27,                   "r27"                                   },
2263         { 28,                   "r28"                                   },
2264         { 29,                   "gp"                                    },
2265         { 30,                   "fp"                                    },
2266         { 31,                   "zero"                                  },
2267         { 32,                   "fp0"                                   },
2268         { 33,                   "fp"                                    },
2269         { 34,                   "fp2"                                   },
2270         { 35,                   "fp3"                                   },
2271         { 36,                   "fp4"                                   },
2272         { 37,                   "fp5"                                   },
2273         { 38,                   "fp6"                                   },
2274         { 39,                   "fp7"                                   },
2275         { 40,                   "fp8"                                   },
2276         { 41,                   "fp9"                                   },
2277         { 42,                   "fp10"                                  },
2278         { 43,                   "fp11"                                  },
2279         { 44,                   "fp12"                                  },
2280         { 45,                   "fp13"                                  },
2281         { 46,                   "fp14"                                  },
2282         { 47,                   "fp15"                                  },
2283         { 48,                   "fp16"                                  },
2284         { 49,                   "fp17"                                  },
2285         { 50,                   "fp18"                                  },
2286         { 51,                   "fp19"                                  },
2287         { 52,                   "fp20"                                  },
2288         { 53,                   "fp21"                                  },
2289         { 54,                   "fp22"                                  },
2290         { 55,                   "fp23"                                  },
2291         { 56,                   "fp24"                                  },
2292         { 57,                   "fp25"                                  },
2293         { 58,                   "fp26"                                  },
2294         { 59,                   "fp27"                                  },
2295         { 60,                   "fp28"                                  },
2296         { 61,                   "fp29"                                  },
2297         { 62,                   "fp30"                                  },
2298         { 63,                   "fp31"                                  },
2299         { 64,                   "pc"                                    },
2300 #   elif defined(IA64)
2301         { PT_F32, "f32" }, { PT_F33, "f33" }, { PT_F34, "f34" },
2302         { PT_F35, "f35" }, { PT_F36, "f36" }, { PT_F37, "f37" },
2303         { PT_F38, "f38" }, { PT_F39, "f39" }, { PT_F40, "f40" },
2304         { PT_F41, "f41" }, { PT_F42, "f42" }, { PT_F43, "f43" },
2305         { PT_F44, "f44" }, { PT_F45, "f45" }, { PT_F46, "f46" },
2306         { PT_F47, "f47" }, { PT_F48, "f48" }, { PT_F49, "f49" },
2307         { PT_F50, "f50" }, { PT_F51, "f51" }, { PT_F52, "f52" },
2308         { PT_F53, "f53" }, { PT_F54, "f54" }, { PT_F55, "f55" },
2309         { PT_F56, "f56" }, { PT_F57, "f57" }, { PT_F58, "f58" },
2310         { PT_F59, "f59" }, { PT_F60, "f60" }, { PT_F61, "f61" },
2311         { PT_F62, "f62" }, { PT_F63, "f63" }, { PT_F64, "f64" },
2312         { PT_F65, "f65" }, { PT_F66, "f66" }, { PT_F67, "f67" },
2313         { PT_F68, "f68" }, { PT_F69, "f69" }, { PT_F70, "f70" },
2314         { PT_F71, "f71" }, { PT_F72, "f72" }, { PT_F73, "f73" },
2315         { PT_F74, "f74" }, { PT_F75, "f75" }, { PT_F76, "f76" },
2316         { PT_F77, "f77" }, { PT_F78, "f78" }, { PT_F79, "f79" },
2317         { PT_F80, "f80" }, { PT_F81, "f81" }, { PT_F82, "f82" },
2318         { PT_F83, "f83" }, { PT_F84, "f84" }, { PT_F85, "f85" },
2319         { PT_F86, "f86" }, { PT_F87, "f87" }, { PT_F88, "f88" },
2320         { PT_F89, "f89" }, { PT_F90, "f90" }, { PT_F91, "f91" },
2321         { PT_F92, "f92" }, { PT_F93, "f93" }, { PT_F94, "f94" },
2322         { PT_F95, "f95" }, { PT_F96, "f96" }, { PT_F97, "f97" },
2323         { PT_F98, "f98" }, { PT_F99, "f99" }, { PT_F100, "f100" },
2324         { PT_F101, "f101" }, { PT_F102, "f102" }, { PT_F103, "f103" },
2325         { PT_F104, "f104" }, { PT_F105, "f105" }, { PT_F106, "f106" },
2326         { PT_F107, "f107" }, { PT_F108, "f108" }, { PT_F109, "f109" },
2327         { PT_F110, "f110" }, { PT_F111, "f111" }, { PT_F112, "f112" },
2328         { PT_F113, "f113" }, { PT_F114, "f114" }, { PT_F115, "f115" },
2329         { PT_F116, "f116" }, { PT_F117, "f117" }, { PT_F118, "f118" },
2330         { PT_F119, "f119" }, { PT_F120, "f120" }, { PT_F121, "f121" },
2331         { PT_F122, "f122" }, { PT_F123, "f123" }, { PT_F124, "f124" },
2332         { PT_F125, "f125" }, { PT_F126, "f126" }, { PT_F127, "f127" },
2333         /* switch stack: */
2334         { PT_F2, "f2" }, { PT_F3, "f3" }, { PT_F4, "f4" },
2335         { PT_F5, "f5" }, { PT_F10, "f10" }, { PT_F11, "f11" },
2336         { PT_F12, "f12" }, { PT_F13, "f13" }, { PT_F14, "f14" },
2337         { PT_F15, "f15" }, { PT_F16, "f16" }, { PT_F17, "f17" },
2338         { PT_F18, "f18" }, { PT_F19, "f19" }, { PT_F20, "f20" },
2339         { PT_F21, "f21" }, { PT_F22, "f22" }, { PT_F23, "f23" },
2340         { PT_F24, "f24" }, { PT_F25, "f25" }, { PT_F26, "f26" },
2341         { PT_F27, "f27" }, { PT_F28, "f28" }, { PT_F29, "f29" },
2342         { PT_F30, "f30" }, { PT_F31, "f31" }, { PT_R4, "r4" },
2343         { PT_R5, "r5" }, { PT_R6, "r6" }, { PT_R7, "r7" },
2344         { PT_B1, "b1" }, { PT_B2, "b2" }, { PT_B3, "b3" },
2345         { PT_B4, "b4" }, { PT_B5, "b5" },
2346         { PT_AR_EC, "ar.ec" }, { PT_AR_LC, "ar.lc" },
2347         /* pt_regs */
2348         { PT_CR_IPSR, "psr" }, { PT_CR_IIP, "ip" },
2349         { PT_CFM, "cfm" }, { PT_AR_UNAT, "ar.unat" },
2350         { PT_AR_PFS, "ar.pfs" }, { PT_AR_RSC, "ar.rsc" },
2351         { PT_AR_RNAT, "ar.rnat" }, { PT_AR_BSPSTORE, "ar.bspstore" },
2352         { PT_PR, "pr" }, { PT_B6, "b6" }, { PT_AR_BSP, "ar.bsp" },
2353         { PT_R1, "r1" }, { PT_R2, "r2" }, { PT_R3, "r3" },
2354         { PT_R12, "r12" }, { PT_R13, "r13" }, { PT_R14, "r14" },
2355         { PT_R15, "r15" }, { PT_R8, "r8" }, { PT_R9, "r9" },
2356         { PT_R10, "r10" }, { PT_R11, "r11" }, { PT_R16, "r16" },
2357         { PT_R17, "r17" }, { PT_R18, "r18" }, { PT_R19, "r19" },
2358         { PT_R20, "r20" }, { PT_R21, "r21" }, { PT_R22, "r22" },
2359         { PT_R23, "r23" }, { PT_R24, "r24" }, { PT_R25, "r25" },
2360         { PT_R26, "r26" }, { PT_R27, "r27" }, { PT_R28, "r28" },
2361         { PT_R29, "r29" }, { PT_R30, "r30" }, { PT_R31, "r31" },
2362         { PT_AR_CCV, "ar.ccv" }, { PT_AR_FPSR, "ar.fpsr" },
2363         { PT_B0, "b0" }, { PT_B7, "b7" }, { PT_F6, "f6" },
2364         { PT_F7, "f7" }, { PT_F8, "f8" }, { PT_F9, "f9" },
2365 #    ifdef PT_AR_CSD
2366         { PT_AR_CSD, "ar.csd" },
2367 #    endif
2368 #    ifdef PT_AR_SSD
2369         { PT_AR_SSD, "ar.ssd" },
2370 #    endif
2371         { PT_DBR, "dbr" }, { PT_IBR, "ibr" }, { PT_PMD, "pmd" },
2372 #   elif defined(I386)
2373         { 4*EBX,                "4*EBX"                                 },
2374         { 4*ECX,                "4*ECX"                                 },
2375         { 4*EDX,                "4*EDX"                                 },
2376         { 4*ESI,                "4*ESI"                                 },
2377         { 4*EDI,                "4*EDI"                                 },
2378         { 4*EBP,                "4*EBP"                                 },
2379         { 4*EAX,                "4*EAX"                                 },
2380         { 4*DS,                 "4*DS"                                  },
2381         { 4*ES,                 "4*ES"                                  },
2382         { 4*FS,                 "4*FS"                                  },
2383         { 4*GS,                 "4*GS"                                  },
2384         { 4*ORIG_EAX,           "4*ORIG_EAX"                            },
2385         { 4*EIP,                "4*EIP"                                 },
2386         { 4*CS,                 "4*CS"                                  },
2387         { 4*EFL,                "4*EFL"                                 },
2388         { 4*UESP,               "4*UESP"                                },
2389         { 4*SS,                 "4*SS"                                  },
2390 #   elif defined(X86_64)
2391         { 8*R15,                "8*R15"                                 },
2392         { 8*R14,                "8*R14"                                 },
2393         { 8*R13,                "8*R13"                                 },
2394         { 8*R12,                "8*R12"                                 },
2395         { 8*RBP,                "8*RBP"                                 },
2396         { 8*RBX,                "8*RBX"                                 },
2397         { 8*R11,                "8*R11"                                 },
2398         { 8*R10,                "8*R10"                                 },
2399         { 8*R9,                 "8*R9"                                  },
2400         { 8*R8,                 "8*R8"                                  },
2401         { 8*RAX,                "8*RAX"                                 },
2402         { 8*RCX,                "8*RCX"                                 },
2403         { 8*RDX,                "8*RDX"                                 },
2404         { 8*RSI,                "8*RSI"                                 },
2405         { 8*RDI,                "8*RDI"                                 },
2406         { 8*ORIG_RAX,           "8*ORIG_RAX"                            },
2407         { 8*RIP,                "8*RIP"                                 },
2408         { 8*CS,                 "8*CS"                                  },
2409         { 8*EFLAGS,             "8*EFL"                                 },
2410         { 8*RSP,                "8*RSP"                                 },
2411         { 8*SS,                 "8*SS"                                  },
2412 #   elif defined(M68K)
2413         { 4*PT_D1,              "4*PT_D1"                               },
2414         { 4*PT_D2,              "4*PT_D2"                               },
2415         { 4*PT_D3,              "4*PT_D3"                               },
2416         { 4*PT_D4,              "4*PT_D4"                               },
2417         { 4*PT_D5,              "4*PT_D5"                               },
2418         { 4*PT_D6,              "4*PT_D6"                               },
2419         { 4*PT_D7,              "4*PT_D7"                               },
2420         { 4*PT_A0,              "4*PT_A0"                               },
2421         { 4*PT_A1,              "4*PT_A1"                               },
2422         { 4*PT_A2,              "4*PT_A2"                               },
2423         { 4*PT_A3,              "4*PT_A3"                               },
2424         { 4*PT_A4,              "4*PT_A4"                               },
2425         { 4*PT_A5,              "4*PT_A5"                               },
2426         { 4*PT_A6,              "4*PT_A6"                               },
2427         { 4*PT_D0,              "4*PT_D0"                               },
2428         { 4*PT_USP,             "4*PT_USP"                              },
2429         { 4*PT_ORIG_D0,         "4*PT_ORIG_D0"                          },
2430         { 4*PT_SR,              "4*PT_SR"                               },
2431         { 4*PT_PC,              "4*PT_PC"                               },
2432 #   elif defined(SH)
2433         { 4*REG_REG0,           "4*REG_REG0"                            },
2434         { 4*(REG_REG0+1),       "4*REG_REG1"                            },
2435         { 4*(REG_REG0+2),       "4*REG_REG2"                            },
2436         { 4*(REG_REG0+3),       "4*REG_REG3"                            },
2437         { 4*(REG_REG0+4),       "4*REG_REG4"                            },
2438         { 4*(REG_REG0+5),       "4*REG_REG5"                            },
2439         { 4*(REG_REG0+6),       "4*REG_REG6"                            },
2440         { 4*(REG_REG0+7),       "4*REG_REG7"                            },
2441         { 4*(REG_REG0+8),       "4*REG_REG8"                            },
2442         { 4*(REG_REG0+9),       "4*REG_REG9"                            },
2443         { 4*(REG_REG0+10),      "4*REG_REG10"                           },
2444         { 4*(REG_REG0+11),      "4*REG_REG11"                           },
2445         { 4*(REG_REG0+12),      "4*REG_REG12"                           },
2446         { 4*(REG_REG0+13),      "4*REG_REG13"                           },
2447         { 4*(REG_REG0+14),      "4*REG_REG14"                           },
2448         { 4*REG_REG15,          "4*REG_REG15"                           },
2449         { 4*REG_PC,             "4*REG_PC"                              },
2450         { 4*REG_PR,             "4*REG_PR"                              },
2451         { 4*REG_SR,             "4*REG_SR"                              },
2452         { 4*REG_GBR,            "4*REG_GBR"                             },
2453         { 4*REG_MACH,           "4*REG_MACH"                            },
2454         { 4*REG_MACL,           "4*REG_MACL"                            },
2455         { 4*REG_SYSCALL,        "4*REG_SYSCALL"                         },
2456         { 4*REG_FPUL,           "4*REG_FPUL"                            },
2457         { 4*REG_FPREG0,         "4*REG_FPREG0"                          },
2458         { 4*(REG_FPREG0+1),     "4*REG_FPREG1"                          },
2459         { 4*(REG_FPREG0+2),     "4*REG_FPREG2"                          },
2460         { 4*(REG_FPREG0+3),     "4*REG_FPREG3"                          },
2461         { 4*(REG_FPREG0+4),     "4*REG_FPREG4"                          },
2462         { 4*(REG_FPREG0+5),     "4*REG_FPREG5"                          },
2463         { 4*(REG_FPREG0+6),     "4*REG_FPREG6"                          },
2464         { 4*(REG_FPREG0+7),     "4*REG_FPREG7"                          },
2465         { 4*(REG_FPREG0+8),     "4*REG_FPREG8"                          },
2466         { 4*(REG_FPREG0+9),     "4*REG_FPREG9"                          },
2467         { 4*(REG_FPREG0+10),    "4*REG_FPREG10"                         },
2468         { 4*(REG_FPREG0+11),    "4*REG_FPREG11"                         },
2469         { 4*(REG_FPREG0+12),    "4*REG_FPREG12"                         },
2470         { 4*(REG_FPREG0+13),    "4*REG_FPREG13"                         },
2471         { 4*(REG_FPREG0+14),    "4*REG_FPREG14"                         },
2472         { 4*REG_FPREG15,        "4*REG_FPREG15"                         },
2473 #    ifdef REG_XDREG0
2474         { 4*REG_XDREG0,         "4*REG_XDREG0"                          },
2475         { 4*(REG_XDREG0+2),     "4*REG_XDREG2"                          },
2476         { 4*(REG_XDREG0+4),     "4*REG_XDREG4"                          },
2477         { 4*(REG_XDREG0+6),     "4*REG_XDREG6"                          },
2478         { 4*(REG_XDREG0+8),     "4*REG_XDREG8"                          },
2479         { 4*(REG_XDREG0+10),    "4*REG_XDREG10"                         },
2480         { 4*(REG_XDREG0+12),    "4*REG_XDREG12"                         },
2481         { 4*REG_XDREG14,        "4*REG_XDREG14"                         },
2482 #    endif
2483         { 4*REG_FPSCR,          "4*REG_FPSCR"                           },
2484 #   elif defined(SH64)
2485         { 0,                    "PC(L)"                                 },
2486         { 4,                    "PC(U)"                                 },
2487         { 8,                    "SR(L)"                                 },
2488         { 12,                   "SR(U)"                                 },
2489         { 16,                   "syscall no.(L)"                        },
2490         { 20,                   "syscall_no.(U)"                        },
2491         { 24,                   "R0(L)"                                 },
2492         { 28,                   "R0(U)"                                 },
2493         { 32,                   "R1(L)"                                 },
2494         { 36,                   "R1(U)"                                 },
2495         { 40,                   "R2(L)"                                 },
2496         { 44,                   "R2(U)"                                 },
2497         { 48,                   "R3(L)"                                 },
2498         { 52,                   "R3(U)"                                 },
2499         { 56,                   "R4(L)"                                 },
2500         { 60,                   "R4(U)"                                 },
2501         { 64,                   "R5(L)"                                 },
2502         { 68,                   "R5(U)"                                 },
2503         { 72,                   "R6(L)"                                 },
2504         { 76,                   "R6(U)"                                 },
2505         { 80,                   "R7(L)"                                 },
2506         { 84,                   "R7(U)"                                 },
2507         { 88,                   "R8(L)"                                 },
2508         { 92,                   "R8(U)"                                 },
2509         { 96,                   "R9(L)"                                 },
2510         { 100,                  "R9(U)"                                 },
2511         { 104,                  "R10(L)"                                },
2512         { 108,                  "R10(U)"                                },
2513         { 112,                  "R11(L)"                                },
2514         { 116,                  "R11(U)"                                },
2515         { 120,                  "R12(L)"                                },
2516         { 124,                  "R12(U)"                                },
2517         { 128,                  "R13(L)"                                },
2518         { 132,                  "R13(U)"                                },
2519         { 136,                  "R14(L)"                                },
2520         { 140,                  "R14(U)"                                },
2521         { 144,                  "R15(L)"                                },
2522         { 148,                  "R15(U)"                                },
2523         { 152,                  "R16(L)"                                },
2524         { 156,                  "R16(U)"                                },
2525         { 160,                  "R17(L)"                                },
2526         { 164,                  "R17(U)"                                },
2527         { 168,                  "R18(L)"                                },
2528         { 172,                  "R18(U)"                                },
2529         { 176,                  "R19(L)"                                },
2530         { 180,                  "R19(U)"                                },
2531         { 184,                  "R20(L)"                                },
2532         { 188,                  "R20(U)"                                },
2533         { 192,                  "R21(L)"                                },
2534         { 196,                  "R21(U)"                                },
2535         { 200,                  "R22(L)"                                },
2536         { 204,                  "R22(U)"                                },
2537         { 208,                  "R23(L)"                                },
2538         { 212,                  "R23(U)"                                },
2539         { 216,                  "R24(L)"                                },
2540         { 220,                  "R24(U)"                                },
2541         { 224,                  "R25(L)"                                },
2542         { 228,                  "R25(U)"                                },
2543         { 232,                  "R26(L)"                                },
2544         { 236,                  "R26(U)"                                },
2545         { 240,                  "R27(L)"                                },
2546         { 244,                  "R27(U)"                                },
2547         { 248,                  "R28(L)"                                },
2548         { 252,                  "R28(U)"                                },
2549         { 256,                  "R29(L)"                                },
2550         { 260,                  "R29(U)"                                },
2551         { 264,                  "R30(L)"                                },
2552         { 268,                  "R30(U)"                                },
2553         { 272,                  "R31(L)"                                },
2554         { 276,                  "R31(U)"                                },
2555         { 280,                  "R32(L)"                                },
2556         { 284,                  "R32(U)"                                },
2557         { 288,                  "R33(L)"                                },
2558         { 292,                  "R33(U)"                                },
2559         { 296,                  "R34(L)"                                },
2560         { 300,                  "R34(U)"                                },
2561         { 304,                  "R35(L)"                                },
2562         { 308,                  "R35(U)"                                },
2563         { 312,                  "R36(L)"                                },
2564         { 316,                  "R36(U)"                                },
2565         { 320,                  "R37(L)"                                },
2566         { 324,                  "R37(U)"                                },
2567         { 328,                  "R38(L)"                                },
2568         { 332,                  "R38(U)"                                },
2569         { 336,                  "R39(L)"                                },
2570         { 340,                  "R39(U)"                                },
2571         { 344,                  "R40(L)"                                },
2572         { 348,                  "R40(U)"                                },
2573         { 352,                  "R41(L)"                                },
2574         { 356,                  "R41(U)"                                },
2575         { 360,                  "R42(L)"                                },
2576         { 364,                  "R42(U)"                                },
2577         { 368,                  "R43(L)"                                },
2578         { 372,                  "R43(U)"                                },
2579         { 376,                  "R44(L)"                                },
2580         { 380,                  "R44(U)"                                },
2581         { 384,                  "R45(L)"                                },
2582         { 388,                  "R45(U)"                                },
2583         { 392,                  "R46(L)"                                },
2584         { 396,                  "R46(U)"                                },
2585         { 400,                  "R47(L)"                                },
2586         { 404,                  "R47(U)"                                },
2587         { 408,                  "R48(L)"                                },
2588         { 412,                  "R48(U)"                                },
2589         { 416,                  "R49(L)"                                },
2590         { 420,                  "R49(U)"                                },
2591         { 424,                  "R50(L)"                                },
2592         { 428,                  "R50(U)"                                },
2593         { 432,                  "R51(L)"                                },
2594         { 436,                  "R51(U)"                                },
2595         { 440,                  "R52(L)"                                },
2596         { 444,                  "R52(U)"                                },
2597         { 448,                  "R53(L)"                                },
2598         { 452,                  "R53(U)"                                },
2599         { 456,                  "R54(L)"                                },
2600         { 460,                  "R54(U)"                                },
2601         { 464,                  "R55(L)"                                },
2602         { 468,                  "R55(U)"                                },
2603         { 472,                  "R56(L)"                                },
2604         { 476,                  "R56(U)"                                },
2605         { 480,                  "R57(L)"                                },
2606         { 484,                  "R57(U)"                                },
2607         { 488,                  "R58(L)"                                },
2608         { 492,                  "R58(U)"                                },
2609         { 496,                  "R59(L)"                                },
2610         { 500,                  "R59(U)"                                },
2611         { 504,                  "R60(L)"                                },
2612         { 508,                  "R60(U)"                                },
2613         { 512,                  "R61(L)"                                },
2614         { 516,                  "R61(U)"                                },
2615         { 520,                  "R62(L)"                                },
2616         { 524,                  "R62(U)"                                },
2617         { 528,                  "TR0(L)"                                },
2618         { 532,                  "TR0(U)"                                },
2619         { 536,                  "TR1(L)"                                },
2620         { 540,                  "TR1(U)"                                },
2621         { 544,                  "TR2(L)"                                },
2622         { 548,                  "TR2(U)"                                },
2623         { 552,                  "TR3(L)"                                },
2624         { 556,                  "TR3(U)"                                },
2625         { 560,                  "TR4(L)"                                },
2626         { 564,                  "TR4(U)"                                },
2627         { 568,                  "TR5(L)"                                },
2628         { 572,                  "TR5(U)"                                },
2629         { 576,                  "TR6(L)"                                },
2630         { 580,                  "TR6(U)"                                },
2631         { 584,                  "TR7(L)"                                },
2632         { 588,                  "TR7(U)"                                },
2633         /* This entry is in case pt_regs contains dregs (depends on
2634            the kernel build options). */
2635         { uoff(regs),           "offsetof(struct user, regs)"           },
2636         { uoff(fpu),            "offsetof(struct user, fpu)"            },
2637 #   elif defined(ARM)
2638         { uoff(regs.ARM_r0),    "r0"                                    },
2639         { uoff(regs.ARM_r1),    "r1"                                    },
2640         { uoff(regs.ARM_r2),    "r2"                                    },
2641         { uoff(regs.ARM_r3),    "r3"                                    },
2642         { uoff(regs.ARM_r4),    "r4"                                    },
2643         { uoff(regs.ARM_r5),    "r5"                                    },
2644         { uoff(regs.ARM_r6),    "r6"                                    },
2645         { uoff(regs.ARM_r7),    "r7"                                    },
2646         { uoff(regs.ARM_r8),    "r8"                                    },
2647         { uoff(regs.ARM_r9),    "r9"                                    },
2648         { uoff(regs.ARM_r10),   "r10"                                   },
2649         { uoff(regs.ARM_fp),    "fp"                                    },
2650         { uoff(regs.ARM_ip),    "ip"                                    },
2651         { uoff(regs.ARM_sp),    "sp"                                    },
2652         { uoff(regs.ARM_lr),    "lr"                                    },
2653         { uoff(regs.ARM_pc),    "pc"                                    },
2654         { uoff(regs.ARM_cpsr),  "cpsr"                                  },
2655 #   elif defined(AVR32)
2656         { uoff(regs.sr),        "sr"                                    },
2657         { uoff(regs.pc),        "pc"                                    },
2658         { uoff(regs.lr),        "lr"                                    },
2659         { uoff(regs.sp),        "sp"                                    },
2660         { uoff(regs.r12),       "r12"                                   },
2661         { uoff(regs.r11),       "r11"                                   },
2662         { uoff(regs.r10),       "r10"                                   },
2663         { uoff(regs.r9),        "r9"                                    },
2664         { uoff(regs.r8),        "r8"                                    },
2665         { uoff(regs.r7),        "r7"                                    },
2666         { uoff(regs.r6),        "r6"                                    },
2667         { uoff(regs.r5),        "r5"                                    },
2668         { uoff(regs.r4),        "r4"                                    },
2669         { uoff(regs.r3),        "r3"                                    },
2670         { uoff(regs.r2),        "r2"                                    },
2671         { uoff(regs.r1),        "r1"                                    },
2672         { uoff(regs.r0),        "r0"                                    },
2673         { uoff(regs.r12_orig),  "orig_r12"                              },
2674 #   elif defined(MIPS)
2675         { 0,                    "r0"                                    },
2676         { 1,                    "r1"                                    },
2677         { 2,                    "r2"                                    },
2678         { 3,                    "r3"                                    },
2679         { 4,                    "r4"                                    },
2680         { 5,                    "r5"                                    },
2681         { 6,                    "r6"                                    },
2682         { 7,                    "r7"                                    },
2683         { 8,                    "r8"                                    },
2684         { 9,                    "r9"                                    },
2685         { 10,                   "r10"                                   },
2686         { 11,                   "r11"                                   },
2687         { 12,                   "r12"                                   },
2688         { 13,                   "r13"                                   },
2689         { 14,                   "r14"                                   },
2690         { 15,                   "r15"                                   },
2691         { 16,                   "r16"                                   },
2692         { 17,                   "r17"                                   },
2693         { 18,                   "r18"                                   },
2694         { 19,                   "r19"                                   },
2695         { 20,                   "r20"                                   },
2696         { 21,                   "r21"                                   },
2697         { 22,                   "r22"                                   },
2698         { 23,                   "r23"                                   },
2699         { 24,                   "r24"                                   },
2700         { 25,                   "r25"                                   },
2701         { 26,                   "r26"                                   },
2702         { 27,                   "r27"                                   },
2703         { 28,                   "r28"                                   },
2704         { 29,                   "r29"                                   },
2705         { 30,                   "r30"                                   },
2706         { 31,                   "r31"                                   },
2707         { 32,                   "f0"                                    },
2708         { 33,                   "f1"                                    },
2709         { 34,                   "f2"                                    },
2710         { 35,                   "f3"                                    },
2711         { 36,                   "f4"                                    },
2712         { 37,                   "f5"                                    },
2713         { 38,                   "f6"                                    },
2714         { 39,                   "f7"                                    },
2715         { 40,                   "f8"                                    },
2716         { 41,                   "f9"                                    },
2717         { 42,                   "f10"                                   },
2718         { 43,                   "f11"                                   },
2719         { 44,                   "f12"                                   },
2720         { 45,                   "f13"                                   },
2721         { 46,                   "f14"                                   },
2722         { 47,                   "f15"                                   },
2723         { 48,                   "f16"                                   },
2724         { 49,                   "f17"                                   },
2725         { 50,                   "f18"                                   },
2726         { 51,                   "f19"                                   },
2727         { 52,                   "f20"                                   },
2728         { 53,                   "f21"                                   },
2729         { 54,                   "f22"                                   },
2730         { 55,                   "f23"                                   },
2731         { 56,                   "f24"                                   },
2732         { 57,                   "f25"                                   },
2733         { 58,                   "f26"                                   },
2734         { 59,                   "f27"                                   },
2735         { 60,                   "f28"                                   },
2736         { 61,                   "f29"                                   },
2737         { 62,                   "f30"                                   },
2738         { 63,                   "f31"                                   },
2739         { 64,                   "pc"                                    },
2740         { 65,                   "cause"                                 },
2741         { 66,                   "badvaddr"                              },
2742         { 67,                   "mmhi"                                  },
2743         { 68,                   "mmlo"                                  },
2744         { 69,                   "fpcsr"                                 },
2745         { 70,                   "fpeir"                                 },
2746 #   elif defined(TILE)
2747         { PTREGS_OFFSET_REG(0),  "r0"  },
2748         { PTREGS_OFFSET_REG(1),  "r1"  },
2749         { PTREGS_OFFSET_REG(2),  "r2"  },
2750         { PTREGS_OFFSET_REG(3),  "r3"  },
2751         { PTREGS_OFFSET_REG(4),  "r4"  },
2752         { PTREGS_OFFSET_REG(5),  "r5"  },
2753         { PTREGS_OFFSET_REG(6),  "r6"  },
2754         { PTREGS_OFFSET_REG(7),  "r7"  },
2755         { PTREGS_OFFSET_REG(8),  "r8"  },
2756         { PTREGS_OFFSET_REG(9),  "r9"  },
2757         { PTREGS_OFFSET_REG(10), "r10" },
2758         { PTREGS_OFFSET_REG(11), "r11" },
2759         { PTREGS_OFFSET_REG(12), "r12" },
2760         { PTREGS_OFFSET_REG(13), "r13" },
2761         { PTREGS_OFFSET_REG(14), "r14" },
2762         { PTREGS_OFFSET_REG(15), "r15" },
2763         { PTREGS_OFFSET_REG(16), "r16" },
2764         { PTREGS_OFFSET_REG(17), "r17" },
2765         { PTREGS_OFFSET_REG(18), "r18" },
2766         { PTREGS_OFFSET_REG(19), "r19" },
2767         { PTREGS_OFFSET_REG(20), "r20" },
2768         { PTREGS_OFFSET_REG(21), "r21" },
2769         { PTREGS_OFFSET_REG(22), "r22" },
2770         { PTREGS_OFFSET_REG(23), "r23" },
2771         { PTREGS_OFFSET_REG(24), "r24" },
2772         { PTREGS_OFFSET_REG(25), "r25" },
2773         { PTREGS_OFFSET_REG(26), "r26" },
2774         { PTREGS_OFFSET_REG(27), "r27" },
2775         { PTREGS_OFFSET_REG(28), "r28" },
2776         { PTREGS_OFFSET_REG(29), "r29" },
2777         { PTREGS_OFFSET_REG(30), "r30" },
2778         { PTREGS_OFFSET_REG(31), "r31" },
2779         { PTREGS_OFFSET_REG(32), "r32" },
2780         { PTREGS_OFFSET_REG(33), "r33" },
2781         { PTREGS_OFFSET_REG(34), "r34" },
2782         { PTREGS_OFFSET_REG(35), "r35" },
2783         { PTREGS_OFFSET_REG(36), "r36" },
2784         { PTREGS_OFFSET_REG(37), "r37" },
2785         { PTREGS_OFFSET_REG(38), "r38" },
2786         { PTREGS_OFFSET_REG(39), "r39" },
2787         { PTREGS_OFFSET_REG(40), "r40" },
2788         { PTREGS_OFFSET_REG(41), "r41" },
2789         { PTREGS_OFFSET_REG(42), "r42" },
2790         { PTREGS_OFFSET_REG(43), "r43" },
2791         { PTREGS_OFFSET_REG(44), "r44" },
2792         { PTREGS_OFFSET_REG(45), "r45" },
2793         { PTREGS_OFFSET_REG(46), "r46" },
2794         { PTREGS_OFFSET_REG(47), "r47" },
2795         { PTREGS_OFFSET_REG(48), "r48" },
2796         { PTREGS_OFFSET_REG(49), "r49" },
2797         { PTREGS_OFFSET_REG(50), "r50" },
2798         { PTREGS_OFFSET_REG(51), "r51" },
2799         { PTREGS_OFFSET_REG(52), "r52" },
2800         { PTREGS_OFFSET_TP, "tp" },
2801         { PTREGS_OFFSET_SP, "sp" },
2802         { PTREGS_OFFSET_LR, "lr" },
2803         { PTREGS_OFFSET_PC, "pc" },
2804         { PTREGS_OFFSET_EX1, "ex1" },
2805         { PTREGS_OFFSET_FAULTNUM, "faultnum" },
2806         { PTREGS_OFFSET_ORIG_R0, "orig_r0" },
2807         { PTREGS_OFFSET_FLAGS, "flags" },
2808 #   endif
2809 #   ifdef CRISV10
2810         { 4*PT_FRAMETYPE, "4*PT_FRAMETYPE" },
2811         { 4*PT_ORIG_R10, "4*PT_ORIG_R10" },
2812         { 4*PT_R13, "4*PT_R13" },
2813         { 4*PT_R12, "4*PT_R12" },
2814         { 4*PT_R11, "4*PT_R11" },
2815         { 4*PT_R10, "4*PT_R10" },
2816         { 4*PT_R9, "4*PT_R9" },
2817         { 4*PT_R8, "4*PT_R8" },
2818         { 4*PT_R7, "4*PT_R7" },
2819         { 4*PT_R6, "4*PT_R6" },
2820         { 4*PT_R5, "4*PT_R5" },
2821         { 4*PT_R4, "4*PT_R4" },
2822         { 4*PT_R3, "4*PT_R3" },
2823         { 4*PT_R2, "4*PT_R2" },
2824         { 4*PT_R1, "4*PT_R1" },
2825         { 4*PT_R0, "4*PT_R0" },
2826         { 4*PT_MOF, "4*PT_MOF" },
2827         { 4*PT_DCCR, "4*PT_DCCR" },
2828         { 4*PT_SRP, "4*PT_SRP" },
2829         { 4*PT_IRP, "4*PT_IRP" },
2830         { 4*PT_CSRINSTR, "4*PT_CSRINSTR" },
2831         { 4*PT_CSRADDR, "4*PT_CSRADDR" },
2832         { 4*PT_CSRDATA, "4*PT_CSRDATA" },
2833         { 4*PT_USP, "4*PT_USP" },
2834 #   endif
2835 #   ifdef CRISV32
2836         { 4*PT_ORIG_R10, "4*PT_ORIG_R10" },
2837         { 4*PT_R0, "4*PT_R0" },
2838         { 4*PT_R1, "4*PT_R1" },
2839         { 4*PT_R2, "4*PT_R2" },
2840         { 4*PT_R3, "4*PT_R3" },
2841         { 4*PT_R4, "4*PT_R4" },
2842         { 4*PT_R5, "4*PT_R5" },
2843         { 4*PT_R6, "4*PT_R6" },
2844         { 4*PT_R7, "4*PT_R7" },
2845         { 4*PT_R8, "4*PT_R8" },
2846         { 4*PT_R9, "4*PT_R9" },
2847         { 4*PT_R10, "4*PT_R10" },
2848         { 4*PT_R11, "4*PT_R11" },
2849         { 4*PT_R12, "4*PT_R12" },
2850         { 4*PT_R13, "4*PT_R13" },
2851         { 4*PT_ACR, "4*PT_ACR" },
2852         { 4*PT_SRS, "4*PT_SRS" },
2853         { 4*PT_MOF, "4*PT_MOF" },
2854         { 4*PT_SPC, "4*PT_SPC" },
2855         { 4*PT_CCS, "4*PT_CCS" },
2856         { 4*PT_SRP, "4*PT_SRP" },
2857         { 4*PT_ERP, "4*PT_ERP" },
2858         { 4*PT_EXS, "4*PT_EXS" },
2859         { 4*PT_EDA, "4*PT_EDA" },
2860         { 4*PT_USP, "4*PT_USP" },
2861         { 4*PT_PPC, "4*PT_PPC" },
2862         { 4*PT_BP_CTRL, "4*PT_BP_CTRL" },
2863         { 4*PT_BP+4, "4*PT_BP+4" },
2864         { 4*PT_BP+8, "4*PT_BP+8" },
2865         { 4*PT_BP+12, "4*PT_BP+12" },
2866         { 4*PT_BP+16, "4*PT_BP+16" },
2867         { 4*PT_BP+20, "4*PT_BP+20" },
2868         { 4*PT_BP+24, "4*PT_BP+24" },
2869         { 4*PT_BP+28, "4*PT_BP+28" },
2870         { 4*PT_BP+32, "4*PT_BP+32" },
2871         { 4*PT_BP+36, "4*PT_BP+36" },
2872         { 4*PT_BP+40, "4*PT_BP+40" },
2873         { 4*PT_BP+44, "4*PT_BP+44" },
2874         { 4*PT_BP+48, "4*PT_BP+48" },
2875         { 4*PT_BP+52, "4*PT_BP+52" },
2876         { 4*PT_BP+56, "4*PT_BP+56" },
2877 #   endif
2878 #   ifdef MICROBLAZE
2879         { PT_GPR(0),            "r0"                                    },
2880         { PT_GPR(1),            "r1"                                    },
2881         { PT_GPR(2),            "r2"                                    },
2882         { PT_GPR(3),            "r3"                                    },
2883         { PT_GPR(4),            "r4"                                    },
2884         { PT_GPR(5),            "r5"                                    },
2885         { PT_GPR(6),            "r6"                                    },
2886         { PT_GPR(7),            "r7"                                    },
2887         { PT_GPR(8),            "r8"                                    },
2888         { PT_GPR(9),            "r9"                                    },
2889         { PT_GPR(10),           "r10"                                   },
2890         { PT_GPR(11),           "r11"                                   },
2891         { PT_GPR(12),           "r12"                                   },
2892         { PT_GPR(13),           "r13"                                   },
2893         { PT_GPR(14),           "r14"                                   },
2894         { PT_GPR(15),           "r15"                                   },
2895         { PT_GPR(16),           "r16"                                   },
2896         { PT_GPR(17),           "r17"                                   },
2897         { PT_GPR(18),           "r18"                                   },
2898         { PT_GPR(19),           "r19"                                   },
2899         { PT_GPR(20),           "r20"                                   },
2900         { PT_GPR(21),           "r21"                                   },
2901         { PT_GPR(22),           "r22"                                   },
2902         { PT_GPR(23),           "r23"                                   },
2903         { PT_GPR(24),           "r24"                                   },
2904         { PT_GPR(25),           "r25"                                   },
2905         { PT_GPR(26),           "r26"                                   },
2906         { PT_GPR(27),           "r27"                                   },
2907         { PT_GPR(28),           "r28"                                   },
2908         { PT_GPR(29),           "r29"                                   },
2909         { PT_GPR(30),           "r30"                                   },
2910         { PT_GPR(31),           "r31"                                   },
2911         { PT_PC,                "rpc",                                  },
2912         { PT_MSR,               "rmsr",                                 },
2913         { PT_EAR,               "rear",                                 },
2914         { PT_ESR,               "resr",                                 },
2915         { PT_FSR,               "rfsr",                                 },
2916         { PT_KERNEL_MODE,       "kernel_mode",                          },
2917 #   endif
2918
2919 #   if !defined(SPARC) && !defined(HPPA) && !defined(POWERPC) \
2920                 && !defined(ALPHA) && !defined(IA64) \
2921                 && !defined(CRISV10) && !defined(CRISV32) && !defined(MICROBLAZE)
2922 #    if !defined(S390) && !defined(S390X) && !defined(MIPS) && !defined(SPARC64) && !defined(AVR32) && !defined(BFIN) && !defined(TILE)
2923         { uoff(u_fpvalid),      "offsetof(struct user, u_fpvalid)"      },
2924 #    endif
2925 #    if defined(I386) || defined(X86_64)
2926         { uoff(i387),           "offsetof(struct user, i387)"           },
2927 #    endif
2928 #    if defined(M68K)
2929         { uoff(m68kfp),         "offsetof(struct user, m68kfp)"         },
2930 #    endif
2931         { uoff(u_tsize),        "offsetof(struct user, u_tsize)"        },
2932         { uoff(u_dsize),        "offsetof(struct user, u_dsize)"        },
2933         { uoff(u_ssize),        "offsetof(struct user, u_ssize)"        },
2934 #    if !defined(SPARC64)
2935         { uoff(start_code),     "offsetof(struct user, start_code)"     },
2936 #    endif
2937 #    if defined(AVR32) || defined(SH64)
2938         { uoff(start_data),     "offsetof(struct user, start_data)"     },
2939 #    endif
2940 #    if !defined(SPARC64)
2941         { uoff(start_stack),    "offsetof(struct user, start_stack)"    },
2942 #    endif
2943         { uoff(signal),         "offsetof(struct user, signal)"         },
2944 #    if !defined(AVR32) && !defined(S390) && !defined(S390X) && !defined(MIPS) && !defined(SH) && !defined(SH64) && !defined(SPARC64) && !defined(TILE)
2945         { uoff(reserved),       "offsetof(struct user, reserved)"       },
2946 #    endif
2947 #    if !defined(SPARC64)
2948         { uoff(u_ar0),          "offsetof(struct user, u_ar0)"          },
2949 #    endif
2950 #    if !defined(ARM) && !defined(AVR32) && !defined(MIPS) && !defined(S390) && !defined(S390X) && !defined(SPARC64) && !defined(BFIN) && !defined(TILE)
2951         { uoff(u_fpstate),      "offsetof(struct user, u_fpstate)"      },
2952 #    endif
2953         { uoff(magic),          "offsetof(struct user, magic)"          },
2954         { uoff(u_comm),         "offsetof(struct user, u_comm)"         },
2955 #    if defined(I386) || defined(X86_64)
2956         { uoff(u_debugreg),     "offsetof(struct user, u_debugreg)"     },
2957 #    endif
2958 #   endif /* !defined(many arches) */
2959
2960 #  endif /* LINUX */
2961
2962 #  ifdef SUNOS4
2963         { uoff(u_pcb),          "offsetof(struct user, u_pcb)"          },
2964         { uoff(u_procp),        "offsetof(struct user, u_procp)"        },
2965         { uoff(u_ar0),          "offsetof(struct user, u_ar0)"          },
2966         { uoff(u_comm[0]),      "offsetof(struct user, u_comm[0])"      },
2967         { uoff(u_arg[0]),       "offsetof(struct user, u_arg[0])"       },
2968         { uoff(u_ap),           "offsetof(struct user, u_ap)"           },
2969         { uoff(u_qsave),        "offsetof(struct user, u_qsave)"        },
2970         { uoff(u_rval1),        "offsetof(struct user, u_rval1)"        },
2971         { uoff(u_rval2),        "offsetof(struct user, u_rval2)"        },
2972         { uoff(u_error),        "offsetof(struct user, u_error)"        },
2973         { uoff(u_eosys),        "offsetof(struct user, u_eosys)"        },
2974         { uoff(u_ssave),        "offsetof(struct user, u_ssave)"        },
2975         { uoff(u_signal[0]),    "offsetof(struct user, u_signal)"       },
2976         { uoff(u_sigmask[0]),   "offsetof(struct user, u_sigmask)"      },
2977         { uoff(u_sigonstack),   "offsetof(struct user, u_sigonstack)"   },
2978         { uoff(u_sigintr),      "offsetof(struct user, u_sigintr)"      },
2979         { uoff(u_sigreset),     "offsetof(struct user, u_sigreset)"     },
2980         { uoff(u_oldmask),      "offsetof(struct user, u_oldmask)"      },
2981         { uoff(u_code),         "offsetof(struct user, u_code)"         },
2982         { uoff(u_addr),         "offsetof(struct user, u_addr)"         },
2983         { uoff(u_sigstack),     "offsetof(struct user, u_sigstack)"     },
2984         { uoff(u_ofile),        "offsetof(struct user, u_ofile)"        },
2985         { uoff(u_pofile),       "offsetof(struct user, u_pofile)"       },
2986         { uoff(u_ofile_arr[0]), "offsetof(struct user, u_ofile_arr[0])" },
2987         { uoff(u_pofile_arr[0]),"offsetof(struct user, u_pofile_arr[0])"},
2988         { uoff(u_lastfile),     "offsetof(struct user, u_lastfile)"     },
2989         { uoff(u_cwd),          "offsetof(struct user, u_cwd)"          },
2990         { uoff(u_cdir),         "offsetof(struct user, u_cdir)"         },
2991         { uoff(u_rdir),         "offsetof(struct user, u_rdir)"         },
2992         { uoff(u_cmask),        "offsetof(struct user, u_cmask)"        },
2993         { uoff(u_ru),           "offsetof(struct user, u_ru)"           },
2994         { uoff(u_cru),          "offsetof(struct user, u_cru)"          },
2995         { uoff(u_timer[0]),     "offsetof(struct user, u_timer[0])"     },
2996         { uoff(u_XXX[0]),       "offsetof(struct user, u_XXX[0])"       },
2997         { uoff(u_ioch),         "offsetof(struct user, u_ioch)"         },
2998         { uoff(u_start),        "offsetof(struct user, u_start)"        },
2999         { uoff(u_acflag),       "offsetof(struct user, u_acflag)"       },
3000         { uoff(u_prof.pr_base), "offsetof(struct user, u_prof.pr_base)" },
3001         { uoff(u_prof.pr_size), "offsetof(struct user, u_prof.pr_size)" },
3002         { uoff(u_prof.pr_off),  "offsetof(struct user, u_prof.pr_off)"  },
3003         { uoff(u_prof.pr_scale),"offsetof(struct user, u_prof.pr_scale)"},
3004         { uoff(u_rlimit[0]),    "offsetof(struct user, u_rlimit)"       },
3005         { uoff(u_exdata.Ux_A),  "offsetof(struct user, u_exdata.Ux_A)"  },
3006         { uoff(u_exdata.ux_shell[0]),"offsetof(struct user, u_exdata.ux_shell[0])"},
3007         { uoff(u_lofault),      "offsetof(struct user, u_lofault)"      },
3008 #  endif /* SUNOS4 */
3009 #  ifndef HPPA
3010         { sizeof(struct user),  "sizeof(struct user)"                   },
3011 #  endif
3012         { 0,                    NULL                                    },
3013 };
3014 # endif /* !FREEBSD */
3015
3016 int
3017 sys_ptrace(struct tcb *tcp)
3018 {
3019         const struct xlat *x;
3020         long addr;
3021
3022         if (entering(tcp)) {
3023                 printxval(ptrace_cmds, tcp->u_arg[0],
3024 # ifndef FREEBSD
3025                           "PTRACE_???"
3026 # else
3027                           "PT_???"
3028 # endif
3029                         );
3030                 tprintf(", %lu, ", tcp->u_arg[1]);
3031                 addr = tcp->u_arg[2];
3032 # ifndef FREEBSD
3033                 if (tcp->u_arg[0] == PTRACE_PEEKUSER
3034                         || tcp->u_arg[0] == PTRACE_POKEUSER) {
3035                         for (x = struct_user_offsets; x->str; x++) {
3036                                 if (x->val >= addr)
3037                                         break;
3038                         }
3039                         if (!x->str)
3040                                 tprintf("%#lx, ", addr);
3041                         else if (x->val > addr && x != struct_user_offsets) {
3042                                 x--;
3043                                 tprintf("%s + %ld, ", x->str, addr - x->val);
3044                         }
3045                         else
3046                                 tprintf("%s, ", x->str);
3047                 }
3048                 else
3049 # endif
3050                         tprintf("%#lx, ", tcp->u_arg[2]);
3051 # ifdef LINUX
3052                 switch (tcp->u_arg[0]) {
3053 #  ifndef IA64
3054                 case PTRACE_PEEKDATA:
3055                 case PTRACE_PEEKTEXT:
3056                 case PTRACE_PEEKUSER:
3057                         break;
3058 #  endif
3059                 case PTRACE_CONT:
3060                 case PTRACE_SINGLESTEP:
3061                 case PTRACE_SYSCALL:
3062                 case PTRACE_DETACH:
3063                         printsignal(tcp->u_arg[3]);
3064                         break;
3065 #  ifdef PTRACE_SETOPTIONS
3066                 case PTRACE_SETOPTIONS:
3067                         printflags(ptrace_setoptions_flags, tcp->u_arg[3], "PTRACE_O_???");
3068                         break;
3069 #  endif
3070 #  ifdef PTRACE_SETSIGINFO
3071                 case PTRACE_SETSIGINFO: {
3072                         siginfo_t si;
3073                         if (!tcp->u_arg[3])
3074                                 tprints("NULL");
3075                         else if (syserror(tcp))
3076                                 tprintf("%#lx", tcp->u_arg[3]);
3077                         else if (umove(tcp, tcp->u_arg[3], &si) < 0)
3078                                 tprints("{???}");
3079                         else
3080                                 printsiginfo(&si, verbose(tcp));
3081                         break;
3082                 }
3083 #  endif
3084 #  ifdef PTRACE_GETSIGINFO
3085                 case PTRACE_GETSIGINFO:
3086                         /* Don't print anything, do it at syscall return. */
3087                         break;
3088 #  endif
3089                 default:
3090                         tprintf("%#lx", tcp->u_arg[3]);
3091                         break;
3092                 }
3093         } else {
3094                 switch (tcp->u_arg[0]) {
3095                 case PTRACE_PEEKDATA:
3096                 case PTRACE_PEEKTEXT:
3097                 case PTRACE_PEEKUSER:
3098 #  ifdef IA64
3099                         return RVAL_HEX;
3100 #  else
3101                         printnum(tcp, tcp->u_arg[3], "%#lx");
3102                         break;
3103 #  endif
3104 #  ifdef PTRACE_GETSIGINFO
3105                 case PTRACE_GETSIGINFO: {
3106                         siginfo_t si;
3107                         if (!tcp->u_arg[3])
3108                                 tprints("NULL");
3109                         else if (syserror(tcp))
3110                                 tprintf("%#lx", tcp->u_arg[3]);
3111                         else if (umove(tcp, tcp->u_arg[3], &si) < 0)
3112                                 tprints("{???}");
3113                         else
3114                                 printsiginfo(&si, verbose(tcp));
3115                         break;
3116                 }
3117 #  endif
3118                 }
3119         }
3120 # endif /* LINUX */
3121 # ifdef SUNOS4
3122                 if (tcp->u_arg[0] == PTRACE_WRITEDATA ||
3123                         tcp->u_arg[0] == PTRACE_WRITETEXT) {
3124                         tprintf("%lu, ", tcp->u_arg[3]);
3125                         printstr(tcp, tcp->u_arg[4], tcp->u_arg[3]);
3126                 } else if (tcp->u_arg[0] != PTRACE_READDATA &&
3127                                 tcp->u_arg[0] != PTRACE_READTEXT) {
3128                         tprintf("%#lx", tcp->u_arg[3]);
3129                 }
3130         } else {
3131                 if (tcp->u_arg[0] == PTRACE_READDATA ||
3132                         tcp->u_arg[0] == PTRACE_READTEXT) {
3133                         tprintf("%lu, ", tcp->u_arg[3]);
3134                         printstr(tcp, tcp->u_arg[4], tcp->u_arg[3]);
3135                 }
3136         }
3137 # endif /* SUNOS4 */
3138 # ifdef FREEBSD
3139                 tprintf("%lu", tcp->u_arg[3]);
3140         }
3141 # endif /* FREEBSD */
3142         return 0;
3143 }
3144
3145 #endif /* !SVR4 */
3146
3147 #ifdef LINUX
3148 # ifndef FUTEX_CMP_REQUEUE
3149 #  define FUTEX_CMP_REQUEUE 4
3150 # endif
3151 # ifndef FUTEX_WAKE_OP
3152 #  define FUTEX_WAKE_OP 5
3153 # endif
3154 # ifndef FUTEX_LOCK_PI
3155 #  define FUTEX_LOCK_PI 6
3156 #  define FUTEX_UNLOCK_PI 7
3157 #  define FUTEX_TRYLOCK_PI 8
3158 # endif
3159 # ifndef FUTEX_WAIT_BITSET
3160 #  define FUTEX_WAIT_BITSET 9
3161 # endif
3162 # ifndef FUTEX_WAKE_BITSET
3163 #  define FUTEX_WAKE_BITSET 10
3164 # endif
3165 # ifndef FUTEX_WAIT_REQUEUE_PI
3166 #  define FUTEX_WAIT_REQUEUE_PI 11
3167 # endif
3168 # ifndef FUTEX_CMP_REQUEUE_PI
3169 #  define FUTEX_CMP_REQUEUE_PI 12
3170 # endif
3171 # ifndef FUTEX_PRIVATE_FLAG
3172 #  define FUTEX_PRIVATE_FLAG 128
3173 # endif
3174 # ifndef FUTEX_CLOCK_REALTIME
3175 #  define FUTEX_CLOCK_REALTIME 256
3176 # endif
3177 static const struct xlat futexops[] = {
3178         { FUTEX_WAIT,                                   "FUTEX_WAIT" },
3179         { FUTEX_WAKE,                                   "FUTEX_WAKE" },
3180         { FUTEX_FD,                                     "FUTEX_FD" },
3181         { FUTEX_REQUEUE,                                "FUTEX_REQUEUE" },
3182         { FUTEX_CMP_REQUEUE,                            "FUTEX_CMP_REQUEUE" },
3183         { FUTEX_WAKE_OP,                                "FUTEX_WAKE_OP" },
3184         { FUTEX_LOCK_PI,                                "FUTEX_LOCK_PI" },
3185         { FUTEX_UNLOCK_PI,                              "FUTEX_UNLOCK_PI" },
3186         { FUTEX_TRYLOCK_PI,                             "FUTEX_TRYLOCK_PI" },
3187         { FUTEX_WAIT_BITSET,                            "FUTEX_WAIT_BITSET" },
3188         { FUTEX_WAKE_BITSET,                            "FUTEX_WAKE_BITSET" },
3189         { FUTEX_WAIT_REQUEUE_PI,                        "FUTEX_WAIT_REQUEUE_PI" },
3190         { FUTEX_CMP_REQUEUE_PI,                         "FUTEX_CMP_REQUEUE_PI" },
3191         { FUTEX_WAIT|FUTEX_PRIVATE_FLAG,                "FUTEX_WAIT_PRIVATE" },
3192         { FUTEX_WAKE|FUTEX_PRIVATE_FLAG,                "FUTEX_WAKE_PRIVATE" },
3193         { FUTEX_FD|FUTEX_PRIVATE_FLAG,                  "FUTEX_FD_PRIVATE" },
3194         { FUTEX_REQUEUE|FUTEX_PRIVATE_FLAG,             "FUTEX_REQUEUE_PRIVATE" },
3195         { FUTEX_CMP_REQUEUE|FUTEX_PRIVATE_FLAG,         "FUTEX_CMP_REQUEUE_PRIVATE" },
3196         { FUTEX_WAKE_OP|FUTEX_PRIVATE_FLAG,             "FUTEX_WAKE_OP_PRIVATE" },
3197         { FUTEX_LOCK_PI|FUTEX_PRIVATE_FLAG,             "FUTEX_LOCK_PI_PRIVATE" },
3198         { FUTEX_UNLOCK_PI|FUTEX_PRIVATE_FLAG,           "FUTEX_UNLOCK_PI_PRIVATE" },
3199         { FUTEX_TRYLOCK_PI|FUTEX_PRIVATE_FLAG,          "FUTEX_TRYLOCK_PI_PRIVATE" },
3200         { FUTEX_WAIT_BITSET|FUTEX_PRIVATE_FLAG,         "FUTEX_WAIT_BITSET_PRIVATE" },
3201         { FUTEX_WAKE_BITSET|FUTEX_PRIVATE_FLAG,         "FUTEX_WAKE_BITSET_PRIVATE" },
3202         { FUTEX_WAIT_REQUEUE_PI|FUTEX_PRIVATE_FLAG,     "FUTEX_WAIT_REQUEUE_PI_PRIVATE" },
3203         { FUTEX_CMP_REQUEUE_PI|FUTEX_PRIVATE_FLAG,      "FUTEX_CMP_REQUEUE_PI_PRIVATE" },
3204         { FUTEX_WAIT_BITSET|FUTEX_CLOCK_REALTIME,       "FUTEX_WAIT_BITSET|FUTEX_CLOCK_REALTIME" },
3205         { FUTEX_WAIT_BITSET|FUTEX_PRIVATE_FLAG|FUTEX_CLOCK_REALTIME,    "FUTEX_WAIT_BITSET_PRIVATE|FUTEX_CLOCK_REALTIME" },
3206         { FUTEX_WAIT_REQUEUE_PI|FUTEX_CLOCK_REALTIME,   "FUTEX_WAIT_REQUEUE_PI|FUTEX_CLOCK_REALTIME" },
3207         { FUTEX_WAIT_REQUEUE_PI|FUTEX_PRIVATE_FLAG|FUTEX_CLOCK_REALTIME,        "FUTEX_WAIT_REQUEUE_PI_PRIVATE|FUTEX_CLOCK_REALTIME" },
3208         { 0,                                            NULL }
3209 };
3210 # ifndef FUTEX_OP_SET
3211 #  define FUTEX_OP_SET          0
3212 #  define FUTEX_OP_ADD          1
3213 #  define FUTEX_OP_OR           2
3214 #  define FUTEX_OP_ANDN         3
3215 #  define FUTEX_OP_XOR          4
3216 #  define FUTEX_OP_CMP_EQ       0
3217 #  define FUTEX_OP_CMP_NE       1
3218 #  define FUTEX_OP_CMP_LT       2
3219 #  define FUTEX_OP_CMP_LE       3
3220 #  define FUTEX_OP_CMP_GT       4
3221 #  define FUTEX_OP_CMP_GE       5
3222 # endif
3223 static const struct xlat futexwakeops[] = {
3224         { FUTEX_OP_SET,         "FUTEX_OP_SET" },
3225         { FUTEX_OP_ADD,         "FUTEX_OP_ADD" },
3226         { FUTEX_OP_OR,          "FUTEX_OP_OR" },
3227         { FUTEX_OP_ANDN,        "FUTEX_OP_ANDN" },
3228         { FUTEX_OP_XOR,         "FUTEX_OP_XOR" },
3229         { 0,                    NULL }
3230 };
3231 static const struct xlat futexwakecmps[] = {
3232         { FUTEX_OP_CMP_EQ,      "FUTEX_OP_CMP_EQ" },
3233         { FUTEX_OP_CMP_NE,      "FUTEX_OP_CMP_NE" },
3234         { FUTEX_OP_CMP_LT,      "FUTEX_OP_CMP_LT" },
3235         { FUTEX_OP_CMP_LE,      "FUTEX_OP_CMP_LE" },
3236         { FUTEX_OP_CMP_GT,      "FUTEX_OP_CMP_GT" },
3237         { FUTEX_OP_CMP_GE,      "FUTEX_OP_CMP_GE" },
3238         { 0,                    NULL }
3239 };
3240
3241 int
3242 sys_futex(struct tcb *tcp)
3243 {
3244         if (entering(tcp)) {
3245                 long int cmd = tcp->u_arg[1] & 127;
3246                 tprintf("%p, ", (void *) tcp->u_arg[0]);
3247                 printxval(futexops, tcp->u_arg[1], "FUTEX_???");
3248                 tprintf(", %ld", tcp->u_arg[2]);
3249                 if (cmd == FUTEX_WAKE_BITSET)
3250                         tprintf(", %lx", tcp->u_arg[5]);
3251                 else if (cmd == FUTEX_WAIT) {
3252                         tprints(", ");
3253                         printtv(tcp, tcp->u_arg[3]);
3254                 } else if (cmd == FUTEX_WAIT_BITSET) {
3255                         tprints(", ");
3256                         printtv(tcp, tcp->u_arg[3]);
3257                         tprintf(", %lx", tcp->u_arg[5]);
3258                 } else if (cmd == FUTEX_REQUEUE)
3259                         tprintf(", %ld, %p", tcp->u_arg[3], (void *) tcp->u_arg[4]);
3260                 else if (cmd == FUTEX_CMP_REQUEUE || cmd == FUTEX_CMP_REQUEUE_PI)
3261                         tprintf(", %ld, %p, %ld", tcp->u_arg[3], (void *) tcp->u_arg[4], tcp->u_arg[5]);
3262                 else if (cmd == FUTEX_WAKE_OP) {
3263                         tprintf(", %ld, %p, {", tcp->u_arg[3], (void *) tcp->u_arg[4]);
3264                         if ((tcp->u_arg[5] >> 28) & 8)
3265                                 tprints("FUTEX_OP_OPARG_SHIFT|");
3266                         printxval(futexwakeops, (tcp->u_arg[5] >> 28) & 0x7, "FUTEX_OP_???");
3267                         tprintf(", %ld, ", (tcp->u_arg[5] >> 12) & 0xfff);
3268                         if ((tcp->u_arg[5] >> 24) & 8)
3269                                 tprints("FUTEX_OP_OPARG_SHIFT|");
3270                         printxval(futexwakecmps, (tcp->u_arg[5] >> 24) & 0x7, "FUTEX_OP_CMP_???");
3271                         tprintf(", %ld}", tcp->u_arg[5] & 0xfff);
3272                 } else if (cmd == FUTEX_WAIT_REQUEUE_PI) {
3273                         tprints(", ");
3274                         printtv(tcp, tcp->u_arg[3]);
3275                         tprintf(", %p", (void *) tcp->u_arg[4]);
3276                 }
3277         }
3278         return 0;
3279 }
3280
3281 static void
3282 print_affinitylist(struct tcb *tcp, long list, unsigned int len)
3283 {
3284         int first = 1;
3285         unsigned long w, min_len;
3286
3287         if (abbrev(tcp) && len / sizeof(w) > max_strlen)
3288                 min_len = len - max_strlen * sizeof(w);
3289         else
3290                 min_len = 0;
3291         for (; len >= sizeof(w) && len > min_len;
3292              len -= sizeof(w), list += sizeof(w)) {
3293                 if (umove(tcp, list, &w) < 0)
3294                         break;
3295                 if (first)
3296                         tprints("{");
3297                 else
3298                         tprints(", ");
3299                 first = 0;
3300                 tprintf("%lx", w);
3301         }
3302         if (len) {
3303                 if (first)
3304                         tprintf("%#lx", list);
3305                 else
3306                         tprintf(", %s}", (len >= sizeof(w) && len > min_len ?
3307                                 "???" : "..."));
3308         } else {
3309                 tprints(first ? "{}" : "}");
3310         }
3311 }
3312
3313 int
3314 sys_sched_setaffinity(struct tcb *tcp)
3315 {
3316         if (entering(tcp)) {
3317                 tprintf("%ld, %lu, ", tcp->u_arg[0], tcp->u_arg[1]);
3318                 print_affinitylist(tcp, tcp->u_arg[2], tcp->u_arg[1]);
3319         }
3320         return 0;
3321 }
3322
3323 int
3324 sys_sched_getaffinity(struct tcb *tcp)
3325 {
3326         if (entering(tcp)) {
3327                 tprintf("%ld, %lu, ", tcp->u_arg[0], tcp->u_arg[1]);
3328         } else {
3329                 if (tcp->u_rval == -1)
3330                         tprintf("%#lx", tcp->u_arg[2]);
3331                 else
3332                         print_affinitylist(tcp, tcp->u_arg[2], tcp->u_rval);
3333         }
3334         return 0;
3335 }
3336
3337 static const struct xlat schedulers[] = {
3338         { SCHED_OTHER,  "SCHED_OTHER" },
3339         { SCHED_RR,     "SCHED_RR" },
3340         { SCHED_FIFO,   "SCHED_FIFO" },
3341         { 0,            NULL }
3342 };
3343
3344 int
3345 sys_sched_getscheduler(struct tcb *tcp)
3346 {
3347         if (entering(tcp)) {
3348                 tprintf("%d", (int) tcp->u_arg[0]);
3349         } else if (! syserror(tcp)) {
3350                 tcp->auxstr = xlookup(schedulers, tcp->u_rval);
3351                 if (tcp->auxstr != NULL)
3352                         return RVAL_STR;
3353         }
3354         return 0;
3355 }
3356
3357 int
3358 sys_sched_setscheduler(struct tcb *tcp)
3359 {
3360         if (entering(tcp)) {
3361                 struct sched_param p;
3362                 tprintf("%d, ", (int) tcp->u_arg[0]);
3363                 printxval(schedulers, tcp->u_arg[1], "SCHED_???");
3364                 if (umove(tcp, tcp->u_arg[2], &p) < 0)
3365                         tprintf(", %#lx", tcp->u_arg[2]);
3366                 else
3367                         tprintf(", { %d }", p.__sched_priority);
3368         }
3369         return 0;
3370 }
3371
3372 int
3373 sys_sched_getparam(struct tcb *tcp)
3374 {
3375         if (entering(tcp)) {
3376                 tprintf("%d, ", (int) tcp->u_arg[0]);
3377         } else {
3378                 struct sched_param p;
3379                 if (umove(tcp, tcp->u_arg[1], &p) < 0)
3380                         tprintf("%#lx", tcp->u_arg[1]);
3381                 else
3382                         tprintf("{ %d }", p.__sched_priority);
3383         }
3384         return 0;
3385 }
3386
3387 int
3388 sys_sched_setparam(struct tcb *tcp)
3389 {
3390         if (entering(tcp)) {
3391                 struct sched_param p;
3392                 if (umove(tcp, tcp->u_arg[1], &p) < 0)
3393                         tprintf("%d, %#lx", (int) tcp->u_arg[0], tcp->u_arg[1]);
3394                 else
3395                         tprintf("%d, { %d }", (int) tcp->u_arg[0], p.__sched_priority);
3396         }
3397         return 0;
3398 }
3399
3400 int
3401 sys_sched_get_priority_min(struct tcb *tcp)
3402 {
3403         if (entering(tcp)) {
3404                 printxval(schedulers, tcp->u_arg[0], "SCHED_???");
3405         }
3406         return 0;
3407 }
3408
3409 # ifdef X86_64
3410 # include <asm/prctl.h>
3411
3412 static const struct xlat archvals[] = {
3413         { ARCH_SET_GS,          "ARCH_SET_GS"           },
3414         { ARCH_SET_FS,          "ARCH_SET_FS"           },
3415         { ARCH_GET_FS,          "ARCH_GET_FS"           },
3416         { ARCH_GET_GS,          "ARCH_GET_GS"           },
3417         { 0,                    NULL                    },
3418 };
3419
3420 int
3421 sys_arch_prctl(struct tcb *tcp)
3422 {
3423         if (entering(tcp)) {
3424                 printxval(archvals, tcp->u_arg[0], "ARCH_???");
3425                 if (tcp->u_arg[0] == ARCH_SET_GS
3426                  || tcp->u_arg[0] == ARCH_SET_FS
3427                 ) {
3428                         tprintf(", %#lx", tcp->u_arg[1]);
3429                 }
3430         } else {
3431                 if (tcp->u_arg[0] == ARCH_GET_GS
3432                  || tcp->u_arg[0] == ARCH_GET_FS
3433                 ) {
3434                         long int v;
3435                         if (!syserror(tcp) && umove(tcp, tcp->u_arg[1], &v) != -1)
3436                                 tprintf(", [%#lx]", v);
3437                         else
3438                                 tprintf(", %#lx", tcp->u_arg[1]);
3439                 }
3440         }
3441         return 0;
3442 }
3443 # endif /* X86_64 */
3444
3445
3446 int
3447 sys_getcpu(struct tcb *tcp)
3448 {
3449         if (exiting(tcp)) {
3450                 unsigned u;
3451                 if (tcp->u_arg[0] == 0)
3452                         tprints("NULL, ");
3453                 else if (umove(tcp, tcp->u_arg[0], &u) < 0)
3454                         tprintf("%#lx, ", tcp->u_arg[0]);
3455                 else
3456                         tprintf("[%u], ", u);
3457                 if (tcp->u_arg[1] == 0)
3458                         tprints("NULL, ");
3459                 else if (umove(tcp, tcp->u_arg[1], &u) < 0)
3460                         tprintf("%#lx, ", tcp->u_arg[1]);
3461                 else
3462                         tprintf("[%u], ", u);
3463                 tprintf("%#lx", tcp->u_arg[2]);
3464         }
3465         return 0;
3466 }
3467
3468 int
3469 sys_process_vm_readv(struct tcb *tcp)
3470 {
3471         if (entering(tcp)) {
3472                 /* arg 1: pid */
3473                 tprintf("%ld, ", tcp->u_arg[0]);
3474         } else {
3475                 /* args 2,3: local iov,cnt */
3476                 if (syserror(tcp)) {
3477                         tprintf("%#lx, %lu",
3478                                         tcp->u_arg[1], tcp->u_arg[2]);
3479                 } else {
3480                         tprint_iov(tcp, tcp->u_arg[2], tcp->u_arg[1], 1);
3481                 }
3482                 tprints(", ");
3483                 /* args 4,5: remote iov,cnt */
3484                 if (syserror(tcp)) {
3485                         tprintf("%#lx, %lu", tcp->u_arg[3], tcp->u_arg[4]);
3486                 } else {
3487                         tprint_iov(tcp, tcp->u_arg[4], tcp->u_arg[3], 0);
3488                 }
3489                 /* arg 6: flags */
3490                 tprintf(", %lu", tcp->u_arg[5]);
3491         }
3492         return 0;
3493 }
3494 #endif /* LINUX */