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