2 * Copyright (c) 1991, 1992 Paul Kranenburg <pk@cs.few.eur.nl>
3 * Copyright (c) 1993 Branko Lankester <branko@hacktic.nl>
4 * Copyright (c) 1993, 1994, 1995, 1996 Rick Sladkey <jrs@world.std.com>
5 * Copyright (c) 1996-1999 Wichert Akkerman <wichert@cistron.nl>
6 * Copyright (c) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation
7 * Linux for s390 port by D.J. Barrow
8 * <barrow_dj@mail.yahoo.com,djbarrow@de.ibm.com>
9 * Copyright (c) 2000 PocketPenguins Inc. Linux for Hitachi SuperH
10 * port by Greg Banks <gbanks@pocketpenguins.com>
13 * All rights reserved.
15 * Redistribution and use in source and binary forms, with or without
16 * modification, are permitted provided that the following conditions
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.
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.
46 #include <sys/resource.h>
47 #include <sys/utsname.h>
49 #include <sys/syscall.h>
52 #include <machine/reg.h>
56 #include <sys/ptrace.h>
61 # define fpq kernel_fpq
63 # define fpu kernel_fpu
71 #endif /* HAVE_ASM_REG_H */
75 #ifndef PTRACE_PEEKUSR
76 # define PTRACE_PEEKUSR PTRACE_PEEKUSER
78 #ifndef PTRACE_POKEUSR
79 # define PTRACE_POKEUSR PTRACE_POKEUSER
83 #ifdef HAVE_LINUX_PTRACE_H
85 #include <linux/ptrace.h>
88 #ifdef HAVE_LINUX_FUTEX_H
89 #include <linux/futex.h>
104 #include <asm/posix_types.h>
106 #define GETGROUPS_T __kernel_gid_t
109 #if defined(LINUX) && defined(IA64)
110 # include <asm/ptrace_offsets.h>
111 # include <asm/rse.h>
115 #include <sys/prctl.h>
119 #define WCOREDUMP(status) ((status) & 0200)
122 /* WTA: this was `&& !defined(LINUXSPARC)', this seems unneeded though? */
123 #if defined(HAVE_PRCTL)
124 static struct xlat prctl_options[] = {
126 { PR_MAXPROCS, "PR_MAXPROCS" },
129 { PR_ISBLOCKED, "PR_ISBLOCKED" },
131 #ifdef PR_SETSTACKSIZE
132 { PR_SETSTACKSIZE, "PR_SETSTACKSIZE" },
134 #ifdef PR_GETSTACKSIZE
135 { PR_GETSTACKSIZE, "PR_GETSTACKSIZE" },
138 { PR_MAXPPROCS, "PR_MAXPPROCS" },
140 #ifdef PR_UNBLKONEXEC
141 { PR_UNBLKONEXEC, "PR_UNBLKONEXEC" },
144 { PR_ATOMICSIM, "PR_ATOMICSIM" },
147 { PR_SETEXITSIG, "PR_SETEXITSIG" },
150 { PR_RESIDENT, "PR_RESIDENT" },
153 { PR_ATTACHADDR, "PR_ATTACHADDR" },
156 { PR_DETACHADDR, "PR_DETACHADDR" },
159 { PR_TERMCHILD, "PR_TERMCHILD" },
162 { PR_GETSHMASK, "PR_GETSHMASK" },
165 { PR_GETNSHARE, "PR_GETNSHARE" },
167 #if defined(PR_SET_PDEATHSIG)
168 { PR_SET_PDEATHSIG, "PR_SET_PDEATHSIG" },
171 { PR_COREPID, "PR_COREPID" },
173 #ifdef PR_ATTACHADDRPERM
174 { PR_ATTACHADDRPERM, "PR_ATTACHADDRPERM" },
176 #ifdef PR_PTHREADEXIT
177 { PR_PTHREADEXIT, "PR_PTHREADEXIT" },
179 #ifdef PR_SET_PDEATHSIG
180 { PR_SET_PDEATHSIG, "PR_SET_PDEATHSIG" },
182 #ifdef PR_GET_PDEATHSIG
183 { PR_GET_PDEATHSIG, "PR_GET_PDEATHSIG" },
185 #ifdef PR_GET_UNALIGN
186 { PR_GET_UNALIGN, "PR_GET_UNALIGN" },
188 #ifdef PR_SET_UNALIGN
189 { PR_SET_UNALIGN, "PR_SET_UNALIGN" },
191 #ifdef PR_GET_KEEPCAPS
192 { PR_GET_KEEPCAPS, "PR_GET_KEEP_CAPS" },
194 #ifdef PR_SET_KEEPCAPS
195 { PR_SET_KEEPCAPS, "PR_SET_KEEP_CAPS" },
202 unalignctl_string (unsigned int ctl)
207 #ifdef PR_UNALIGN_NOPRINT
208 case PR_UNALIGN_NOPRINT:
211 #ifdef PR_UNALIGN_SIGBUS
212 case PR_UNALIGN_SIGBUS:
218 sprintf(buf, "%x", ctl);
230 printxval(prctl_options, tcp->u_arg[0], "PR_???");
231 switch (tcp->u_arg[0]) {
236 #ifdef PR_SET_DEATHSIG
237 case PR_GET_PDEATHSIG:
240 #ifdef PR_SET_UNALIGN
242 tprintf(", %s", unalignctl_string(tcp->u_arg[1]));
245 #ifdef PR_GET_UNALIGN
247 tprintf(", %#lx", tcp->u_arg[1]);
251 for (i = 1; i < tcp->u_nargs; i++)
252 tprintf(", %#lx", tcp->u_arg[i]);
256 switch (tcp->u_arg[0]) {
257 #ifdef PR_GET_PDEATHSIG
258 case PR_GET_PDEATHSIG:
259 for (i=1; i<tcp->u_nargs; i++)
260 tprintf(", %#lx", tcp->u_arg[i]);
263 #ifdef PR_SET_UNALIGN
267 #ifdef PR_GET_UNALIGN
272 umove(tcp, tcp->u_arg[1], &ctl);
273 tcp->auxstr = unalignctl_string(ctl);
284 #endif /* HAVE_PRCTL */
300 printpathn(tcp, tcp->u_arg[0], tcp->u_arg[1]);
301 tprintf(", %lu", tcp->u_arg[1]);
312 tprintf("%#lx", tcp->u_arg[0]);
314 printpath(tcp, tcp->u_arg[0]);
315 tprintf(", %lu", tcp->u_arg[1]);
321 sys_setdomainname(tcp)
325 printpathn(tcp, tcp->u_arg[0], tcp->u_arg[1]);
326 tprintf(", %lu", tcp->u_arg[1]);
334 sys_getdomainname(tcp)
339 tprintf("%#lx", tcp->u_arg[0]);
341 printpath(tcp, tcp->u_arg[0]);
342 tprintf(", %lu", tcp->u_arg[1]);
353 fprintf(stderr, "_exit returned!\n");
356 /* special case: we stop tracing this process, finish line now */
357 tprintf("%ld) ", tcp->u_arg[0]);
369 tcp->flags |= TCB_EXITING;
370 #ifdef __NR_exit_group
371 if (tcp->scno == __NR_exit_group)
372 tcp->flags |= TCB_GROUP_EXITING;
378 /* TCP is creating a child we want to follow.
379 If there will be space in tcbtab for it, set TCB_FOLLOWFORK and return 0.
380 If not, clear TCB_FOLLOWFORK, print an error, and return 1. */
382 fork_tcb(struct tcb *tcp)
384 if (nprocs == tcbtabsize) {
385 /* Allocate some more TCBs and expand the table.
386 We don't want to relocate the TCBs because our
387 callers have pointers and it would be a pain.
388 So tcbtab is a table of pointers. Since we never
389 free the TCBs, we allocate a single chunk of many. */
390 struct tcb **newtab = (struct tcb **)
391 realloc(tcbtab, 2 * tcbtabsize * sizeof tcbtab[0]);
392 struct tcb *newtcbs = (struct tcb *) calloc(tcbtabsize,
395 if (newtab == NULL || newtcbs == NULL) {
398 tcp->flags &= ~TCB_FOLLOWFORK;
399 fprintf(stderr, "sys_fork: tcb table full\n");
402 for (i = tcbtabsize; i < 2 * tcbtabsize; ++i)
403 newtab[i] = &newtcbs[i - tcbtabsize];
408 tcp->flags |= TCB_FOLLOWFORK;
420 tcp->auxstr = "child process";
421 return RVAL_UDECIMAL | RVAL_STR;
434 tprintf ("%ld", tcp->u_arg[0]);
438 tcp->auxstr = "child process";
439 return RVAL_UDECIMAL | RVAL_STR;
451 struct tcb *tcpchild;
455 if (tcp->scno == SYS_rfork && !(tcp->u_arg[0]&RFPROC))
466 if ((tcpchild = alloctcb(tcp->u_rval)) == NULL) {
467 fprintf(stderr, "sys_fork: tcb table full\n");
470 if (proc_open(tcpchild, 2) < 0)
476 #else /* !USE_PROCFS */
480 /* defines copied from linux/sched.h since we can't include that
481 * ourselves (it conflicts with *lots* of libc includes)
483 #define CSIGNAL 0x000000ff /* signal mask to be sent at exit */
484 #define CLONE_VM 0x00000100 /* set if VM shared between processes */
485 #define CLONE_FS 0x00000200 /* set if fs info shared between processes */
486 #define CLONE_FILES 0x00000400 /* set if open files shared between processes */
487 #define CLONE_SIGHAND 0x00000800 /* set if signal handlers shared */
488 #define CLONE_IDLETASK 0x00001000 /* kernel-only flag */
489 #define CLONE_PTRACE 0x00002000 /* set if we want to let tracing continue on the child too */
490 #define CLONE_VFORK 0x00004000 /* set if the parent wants the child to wake it up on mm_release */
491 #define CLONE_PARENT 0x00008000 /* set if we want to have the same parent as the cloner */
492 #define CLONE_THREAD 0x00010000 /* Same thread group? */
493 #define CLONE_NEWNS 0x00020000 /* New namespace group? */
494 #define CLONE_SYSVSEM 0x00040000 /* share system V SEM_UNDO semantics */
495 #define CLONE_SETTLS 0x00080000 /* create a new TLS for the child */
496 #define CLONE_PARENT_SETTID 0x00100000 /* set the TID in the parent */
497 #define CLONE_CHILD_CLEARTID 0x00200000 /* clear the TID in the child */
498 #define CLONE_DETACHED 0x00400000 /* parent wants no child-exit signal */
499 #define CLONE_UNTRACED 0x00800000 /* set if the tracing process can't force CLONE_PTRACE on this clone */
500 #define CLONE_CHILD_SETTID 0x01000000 /* set the TID in the child */
502 static struct xlat clone_flags[] = {
503 { CLONE_VM, "CLONE_VM" },
504 { CLONE_FS, "CLONE_FS" },
505 { CLONE_FILES, "CLONE_FILES" },
506 { CLONE_SIGHAND, "CLONE_SIGHAND" },
507 { CLONE_IDLETASK, "CLONE_IDLETASK"},
508 { CLONE_PTRACE, "CLONE_PTRACE" },
509 { CLONE_VFORK, "CLONE_VFORK" },
510 { CLONE_PARENT, "CLONE_PARENT" },
511 { CLONE_THREAD, "CLONE_THREAD" },
512 { CLONE_NEWNS, "CLONE_NEWNS" },
513 { CLONE_SYSVSEM, "CLONE_SYSVSEM" },
514 { CLONE_SETTLS, "CLONE_SETTLS" },
515 { CLONE_PARENT_SETTID,"CLONE_PARENT_SETTID" },
516 { CLONE_CHILD_CLEARTID,"CLONE_CHILD_CLEARTID" },
517 { CLONE_DETACHED, "CLONE_DETACHED" },
518 { CLONE_UNTRACED, "CLONE_UNTRACED" },
519 { CLONE_CHILD_SETTID,"CLONE_CHILD_SETTID" },
524 # include <asm/ldt.h>
525 extern void print_ldt_entry();
531 # define ARG_STACKSIZE (tcp->scno == SYS_clone2 ? 2 : -1)
532 # define ARG_PTID (tcp->scno == SYS_clone2 ? 3 : 2)
533 # define ARG_CTID (tcp->scno == SYS_clone2 ? 4 : 3)
534 # define ARG_TLS (tcp->scno == SYS_clone2 ? 5 : 4)
535 # elif defined S390 || defined S390X
541 # elif defined X86_64
560 unsigned long flags = tcp->u_arg[ARG_FLAGS];
561 tprintf("child_stack=%#lx, ", tcp->u_arg[ARG_STACK]);
562 # ifdef ARG_STACKSIZE
563 if (ARG_STACKSIZE != -1)
564 tprintf("stack_size=%#lx, ",
565 tcp->u_arg[ARG_STACKSIZE]);
568 if (printflags(clone_flags, flags &~ CSIGNAL) == 0)
570 if ((flags & CSIGNAL) != 0)
571 tprintf("|%s", signame(flags & CSIGNAL));
572 if ((flags & (CLONE_PARENT_SETTID|CLONE_CHILD_SETTID
573 |CLONE_CHILD_CLEARTID|CLONE_SETTLS)) == 0)
575 if (flags & CLONE_PARENT_SETTID)
576 tprintf(", parent_tidptr=%#lx", tcp->u_arg[ARG_PTID]);
577 if (flags & CLONE_SETTLS) {
579 struct modify_ldt_ldt_s copy;
580 if (umove(tcp, tcp->u_arg[ARG_TLS], ©) != -1) {
581 tprintf(", {entry_number:%d, ",
586 print_ldt_entry(©);
590 tprintf(", tls=%#lx", tcp->u_arg[ARG_TLS]);
592 if (flags & (CLONE_CHILD_SETTID|CLONE_CHILD_CLEARTID))
593 tprintf(", child_tidptr=%#lx", tcp->u_arg[ARG_CTID]);
604 return RVAL_UDECIMAL;
609 change_syscall(tcp, new)
615 /* Attempt to make vfork into fork, which we can follow. */
616 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(ORIG_EAX * 4), new) < 0)
619 #elif defined(X86_64)
620 /* Attempt to make vfork into fork, which we can follow. */
621 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(ORIG_RAX * 8), new) < 0)
624 #elif defined(POWERPC)
625 if (ptrace(PTRACE_POKEUSER, tcp->pid,
626 (char*)(sizeof(unsigned long)*PT_R0), new) < 0)
629 #elif defined(S390) || defined(S390X)
630 /* s390 linux after 2.4.7 has a hook in entry.S to allow this */
631 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_GPR2), new)<0)
635 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*PT_ORIG_D0), new)<0)
640 if (ptrace(PTRACE_GETREGS, tcp->pid, (char*)®s, 0)<0)
643 if (ptrace(PTRACE_SETREGS, tcp->pid, (char*)®s, 0)<0)
647 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_V0), new)<0)
651 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_A3), new)<0)
655 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_R15), new)<0)
659 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_GR20), new)<0)
663 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*(REG_REG0+3)), new)<0)
666 #elif defined(SHMEDIA)
667 /* Top half of reg encodes the no. of args n as 0x1n.
668 Assume 0 args as kernel never actually checks... */
669 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_SYSCALL),
674 #warning Do not know how to handle change_syscall for this architecture
675 #endif /* architecture */
687 unsigned long *bsp, *ap;
689 if (upeek(tcp->pid, PT_AR_BSP, (long *) &bsp) , 0)
692 ap = ia64_rse_skip_regs(bsp, argnum);
694 ptrace(PTRACE_POKEDATA, tcp->pid, (char *) ap, tcp->u_arg[argnum]);
701 ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*argnum), tcp->u_arg[argnum]);
705 #elif defined(X86_64)
707 ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(8*(long)argnum), tcp->u_arg[argnum]);
711 #elif defined(POWERPC)
713 #define PT_ORIG_R3 34
716 ptrace(PTRACE_POKEUSER, tcp->pid,
717 (char*)((argnum==0 ? PT_ORIG_R3 : argnum+PT_R3)*sizeof(unsigned long)),
726 ptrace(PTRACE_POKEUSER, tcp->pid,
727 (char*)(REG_A0 + argnum), tcp->u_arg[argnum]);
731 if (upeek(tcp->pid, REG_SP, (long *) &sp) , 0)
734 ptrace(PTRACE_POKEDATA, tcp->pid,
735 (char*)(sp + argnum - 4), tcp->u_arg[argnum]);
740 #elif defined(S390) || defined(S390X)
743 ptrace(PTRACE_POKEUSER, tcp->pid,
744 (char *) (argnum==0 ? PT_ORIGGPR2 :
745 PT_GPR2 + argnum*sizeof(long)),
753 # warning Sorry, setargs not implemented for this architecture.
758 #if defined SYS_clone || defined SYS_clone2
763 struct tcb *tcpchild;
773 int bpt = tcp->flags & TCB_BPTSET;
775 if (!(tcp->flags & TCB_FOLLOWFORK))
786 #ifdef CLONE_PTRACE /* See new setbpt code. */
787 tcpchild = pid2tcb(pid);
788 if (tcpchild != NULL) {
789 /* The child already reported its startup trap
790 before the parent reported its syscall return. */
792 & (TCB_STARTUP|TCB_ATTACHED|TCB_SUSPENDED))
793 != (TCB_STARTUP|TCB_ATTACHED|TCB_SUSPENDED))
795 [preattached child %d of %d in weird state!]\n",
800 if ((tcpchild = alloctcb(pid)) == NULL) {
803 fprintf(stderr, " [tcb table full]\n");
804 kill(pid, SIGKILL); /* XXX */
809 /* Attach to the new child */
810 if (ptrace(PTRACE_ATTACH, pid, (char *) 1, 0) < 0) {
813 perror("PTRACE_ATTACH");
814 fprintf(stderr, "Too late?\n");
823 tcpchild->flags |= TCB_ATTACHED;
824 /* Child has BPT too, must be removed on first occasion. */
826 tcpchild->flags |= TCB_BPTSET;
827 tcpchild->baddr = tcp->baddr;
828 memcpy(tcpchild->inst, tcp->inst,
829 sizeof tcpchild->inst);
831 tcpchild->parent = tcp;
833 if (tcpchild->flags & TCB_SUSPENDED) {
834 /* The child was born suspended, due to our having
835 forced CLONE_PTRACE. */
839 tcpchild->flags &= ~(TCB_SUSPENDED|TCB_STARTUP);
840 if (ptrace(PTRACE_SYSCALL, pid, (char *) 1, 0) < 0) {
841 perror("resume: ptrace(PTRACE_SYSCALL, ...)");
847 Process %u resumed (parent %d ready)\n",
853 fprintf(stderr, "Process %d attached\n", pid);
856 #ifdef TCB_CLONE_THREAD
859 * Save the flags used in this call,
860 * in case we point TCP to our parent below.
862 int call_flags = tcp->u_arg[ARG_FLAGS];
863 if ((tcp->flags & TCB_CLONE_THREAD) &&
864 tcp->parent != NULL) {
865 /* The parent in this clone is itself a
866 thread belonging to another process.
867 There is no meaning to the parentage
868 relationship of the new child with the
869 thread, only with the process. We
870 associate the new thread with our
871 parent. Since this is done for every
872 new thread, there will never be a
873 TCB_CLONE_THREAD process that has
877 tcpchild->parent = tcp;
880 if (call_flags & CLONE_THREAD) {
881 tcpchild->flags |= TCB_CLONE_THREAD;
882 ++tcp->nclone_threads;
884 if (call_flags & CLONE_DETACHED) {
885 tcpchild->flags |= TCB_CLONE_DETACHED;
886 ++tcp->nclone_detached;
901 /* We do special magic with clone for any clone or fork. */
902 return internal_clone(tcp);
905 struct tcb *tcpchild;
910 if (tcp->scno == SYS_vfork) {
911 /* Attempt to make vfork into fork, which we can follow. */
913 change_syscall(tcp, SYS_fork) < 0)
918 if (!followfork || dont_follow)
926 int bpt = tcp->flags & TCB_BPTSET;
928 if (!(tcp->flags & TCB_FOLLOWFORK))
937 if ((tcpchild = alloctcb(pid)) == NULL) {
938 fprintf(stderr, " [tcb table full]\n");
939 kill(pid, SIGKILL); /* XXX */
944 /* The child must have run before it can be attached. */
945 /* This must be a bug in the parisc kernel, but I havn't
946 * identified it yet. Seems to be an issue associated
947 * with attaching to a process (which sends it a signal)
948 * before that process has ever been scheduled. When
949 * debugging, I started seeing crashes in
950 * arch/parisc/kernel/signal.c:do_signal(), apparently
951 * caused by r8 getting corrupt over the dequeue_signal()
952 * call. Didn't make much sense though...
958 select(0, NULL, NULL, NULL, &tv);
961 if (ptrace(PTRACE_ATTACH, pid, (char *) 1, 0) < 0) {
962 perror("PTRACE_ATTACH");
963 fprintf(stderr, "Too late?\n");
970 /* The child must have run before it can be attached. */
975 select(0, NULL, NULL, NULL, &tv);
977 if (ptrace(PTRACE_ATTACH, pid, (char *)1, 0) < 0) {
978 perror("PTRACE_ATTACH");
979 fprintf(stderr, "Too late?\n");
984 /* Try to catch the new process as soon as possible. */
987 for (i = 0; i < 1024; i++)
988 if (ptrace(PTRACE_ATTACH, pid, (char *) 1, 0) >= 0)
991 perror("PTRACE_ATTACH");
992 fprintf(stderr, "Too late?\n");
999 tcpchild->flags |= TCB_ATTACHED;
1000 /* Child has BPT too, must be removed on first occasion */
1002 tcpchild->flags |= TCB_BPTSET;
1003 tcpchild->baddr = tcp->baddr;
1004 memcpy(tcpchild->inst, tcp->inst,
1005 sizeof tcpchild->inst);
1008 tcpchild->parent = tcp;
1011 fprintf(stderr, "Process %d attached\n", pid);
1017 #endif /* !USE_PROCFS */
1019 #if defined(SUNOS4) || defined(LINUX) || defined(FREEBSD)
1026 return RVAL_UDECIMAL;
1030 #endif /* SUNOS4 || LINUX || FREEBSD */
1034 static char idstr[16];
1041 sprintf(idstr, "ppid %lu", getrval2(tcp));
1042 tcp->auxstr = idstr;
1053 sprintf(idstr, "euid %lu", getrval2(tcp));
1054 tcp->auxstr = idstr;
1065 sprintf(idstr, "egid %lu", getrval2(tcp));
1066 tcp->auxstr = idstr;
1080 if (entering(tcp)) {
1081 tprintf("%u", (uid_t) tcp->u_arg[0]);
1090 if (entering(tcp)) {
1091 tprintf("%u", (gid_t) tcp->u_arg[0]);
1103 tprintf("%#lx, %#lx, %#lx", tcp->u_arg[0],
1104 tcp->u_arg[1], tcp->u_arg[2]);
1106 if (umove(tcp, tcp->u_arg[0], &uid) < 0)
1107 tprintf("%#lx, ", tcp->u_arg[0]);
1109 tprintf("ruid %lu, ", (unsigned long) uid);
1110 if (umove(tcp, tcp->u_arg[1], &uid) < 0)
1111 tprintf("%#lx, ", tcp->u_arg[1]);
1113 tprintf("euid %lu, ", (unsigned long) uid);
1114 if (umove(tcp, tcp->u_arg[2], &uid) < 0)
1115 tprintf("%#lx", tcp->u_arg[2]);
1117 tprintf("suid %lu", (unsigned long) uid);
1130 tprintf("%#lx, %#lx, %#lx", tcp->u_arg[0],
1131 tcp->u_arg[1], tcp->u_arg[2]);
1133 if (umove(tcp, tcp->u_arg[0], &gid) < 0)
1134 tprintf("%#lx, ", tcp->u_arg[0]);
1136 tprintf("rgid %lu, ", (unsigned long) gid);
1137 if (umove(tcp, tcp->u_arg[1], &gid) < 0)
1138 tprintf("%#lx, ", tcp->u_arg[1]);
1140 tprintf("egid %lu, ", (unsigned long) gid);
1141 if (umove(tcp, tcp->u_arg[2], &gid) < 0)
1142 tprintf("%#lx", tcp->u_arg[2]);
1144 tprintf("sgid %lu", (unsigned long) gid);
1156 if (entering(tcp)) {
1158 (unsigned long) (uid_t) tcp->u_arg[0],
1159 (unsigned long) (uid_t) tcp->u_arg[1]);
1168 if (entering(tcp)) {
1170 (unsigned long) (gid_t) tcp->u_arg[0],
1171 (unsigned long) (gid_t) tcp->u_arg[1]);
1176 #if defined(LINUX) || defined(FREEBSD)
1181 if (entering(tcp)) {
1182 tprintf("ruid %u, euid %u, suid %u",
1183 (uid_t) tcp->u_arg[0],
1184 (uid_t) tcp->u_arg[1],
1185 (uid_t) tcp->u_arg[2]);
1193 if (entering(tcp)) {
1194 tprintf("rgid %u, egid %u, sgid %u",
1195 (uid_t) tcp->u_arg[0],
1196 (uid_t) tcp->u_arg[1],
1197 (uid_t) tcp->u_arg[2]);
1202 #endif /* LINUX || FREEBSD */
1209 GETGROUPS_T *gidset;
1211 if (entering(tcp)) {
1212 len = tcp->u_arg[0];
1213 tprintf("%u, ", len);
1218 gidset = (GETGROUPS_T *) malloc(len * sizeof(GETGROUPS_T));
1219 if (gidset == NULL) {
1220 fprintf(stderr, "sys_setgroups: out of memory\n");
1224 tprintf("%#lx", tcp->u_arg[1]);
1225 else if (umoven(tcp, tcp->u_arg[1],
1226 len * sizeof(GETGROUPS_T), (char *) gidset) < 0)
1230 for (i = 0; i < len; i++)
1231 tprintf("%s%lu", i ? ", " : "",
1232 (unsigned long) gidset[i]);
1235 free((char *) gidset);
1245 GETGROUPS_T *gidset;
1247 if (entering(tcp)) {
1248 len = tcp->u_arg[0];
1249 tprintf("%u, ", len);
1256 gidset = (GETGROUPS_T *) malloc(len * sizeof(GETGROUPS_T));
1257 if (gidset == NULL) {
1258 fprintf(stderr, "sys_getgroups: out of memory\n");
1263 else if (!verbose(tcp) || tcp->u_arg[0] == 0)
1264 tprintf("%#lx", tcp->u_arg[1]);
1265 else if (umoven(tcp, tcp->u_arg[1],
1266 len * sizeof(GETGROUPS_T), (char *) gidset) < 0)
1270 for (i = 0; i < len; i++)
1271 tprintf("%s%lu", i ? ", " : "",
1272 (unsigned long) gidset[i]);
1275 free((char *)gidset);
1284 if (entering(tcp)) {
1286 tprintf("%lu, %lu", tcp->u_arg[0], tcp->u_arg[1]);
1296 if (entering(tcp)) {
1298 tprintf("%lu", tcp->u_arg[0]);
1308 if (entering(tcp)) {
1309 tprintf("%lu", tcp->u_arg[0]);
1325 if (entering(tcp)) {
1326 tprintf("%lu", tcp->u_arg[0]);
1335 if (entering(tcp)) {
1336 tprintf("%lu, %lu", tcp->u_arg[0], tcp->u_arg[1]);
1343 #include <sys/privilege.h>
1346 static struct xlat procpriv_cmds [] = {
1347 { SETPRV, "SETPRV" },
1348 { CLRPRV, "CLRPRV" },
1349 { PUTPRV, "PUTPRV" },
1350 { GETPRV, "GETPRV" },
1351 { CNTPRV, "CNTPRV" },
1356 static struct xlat procpriv_priv [] = {
1357 { P_OWNER, "P_OWNER" },
1358 { P_AUDIT, "P_AUDIT" },
1359 { P_COMPAT, "P_COMPAT" },
1360 { P_DACREAD, "P_DACREAD" },
1361 { P_DACWRITE, "P_DACWRITE" },
1363 { P_FILESYS, "P_FILESYS" },
1364 { P_MACREAD, "P_MACREAD" },
1365 { P_MACWRITE, "P_MACWRITE" },
1366 { P_MOUNT, "P_MOUNT" },
1367 { P_MULTIDIR, "P_MULTIDIR" },
1368 { P_SETPLEVEL, "P_SETPLEVEL" },
1369 { P_SETSPRIV, "P_SETSPRIV" },
1370 { P_SETUID, "P_SETUID" },
1371 { P_SYSOPS, "P_SYSOPS" },
1372 { P_SETUPRIV, "P_SETUPRIV" },
1373 { P_DRIVER, "P_DRIVER" },
1374 { P_RTIME, "P_RTIME" },
1375 { P_MACUPGRADE, "P_MACUPGRADE" },
1376 { P_FSYSRANGE, "P_FSYSRANGE" },
1377 { P_SETFLEVEL, "P_SETFLEVEL" },
1378 { P_AUDITWR, "P_AUDITWR" },
1379 { P_TSHAR, "P_TSHAR" },
1380 { P_PLOCK, "P_PLOCK" },
1381 { P_CORE, "P_CORE" },
1382 { P_LOADMOD, "P_LOADMOD" },
1383 { P_BIND, "P_BIND" },
1384 { P_ALLPRIVS, "P_ALLPRIVS" },
1389 static struct xlat procpriv_type [] = {
1390 { PS_FIX, "PS_FIX" },
1391 { PS_INH, "PS_INH" },
1392 { PS_MAX, "PS_MAX" },
1393 { PS_WKG, "PS_WKG" },
1399 printpriv(tcp, addr, len, opt)
1406 int max = verbose (tcp) ? sizeof buf / sizeof buf [0] : 10;
1407 int dots = len > max;
1410 if (len > max) len = max;
1413 umoven (tcp, addr, len * sizeof buf[0], (char *) buf) < 0)
1415 tprintf ("%#lx", addr);
1421 for (i = 0; i < len; ++i) {
1424 if (i) tprintf (", ");
1426 if ((t = xlookup (procpriv_type, buf [i] & PS_TYPE)) &&
1427 (p = xlookup (procpriv_priv, buf [i] & ~PS_TYPE)))
1429 tprintf ("%s|%s", t, p);
1432 tprintf ("%#lx", buf [i]);
1436 if (dots) tprintf (" ...");
1446 if (entering(tcp)) {
1447 printxval(procpriv_cmds, tcp->u_arg[0], "???PRV");
1448 switch (tcp->u_arg[0]) {
1450 tprintf(", %#lx, %ld", tcp->u_arg[1], tcp->u_arg[2]);
1458 printpriv (tcp, tcp->u_arg[1], tcp->u_arg[2]);
1459 tprintf (", %ld", tcp->u_arg[2]);
1462 else if (tcp->u_arg[0] == GETPRV) {
1463 if (syserror (tcp)) {
1464 tprintf(", %#lx, %ld", tcp->u_arg[1], tcp->u_arg[2]);
1468 printpriv (tcp, tcp->u_arg[1], tcp->u_rval);
1469 tprintf (", %ld", tcp->u_arg[2]);
1480 fake_execve(tcp, program, argv, envp)
1489 if (!(qual_flags[SYS_execve - __NR_SYSCALL_BASE] & QUAL_TRACE))
1492 if (!(qual_flags[SYS_execve] & QUAL_TRACE))
1497 string_quote(program);
1499 for (i = 0; argv[i] != NULL; i++) {
1502 string_quote(argv[i]);
1504 for (i = 0; envp[i] != NULL; i++)
1506 tprintf("], [/* %d var%s */]) ", i, (i != 1) ? "s" : "");
1513 printargv(tcp, addr)
1519 int max = max_strlen / 2;
1521 for (sep = ""; --max >= 0; sep = ", ") {
1524 if (umove(tcp, addr, &cp) < 0) {
1525 tprintf("%#lx", addr);
1531 printstr(tcp, (long) cp, -1);
1532 addr += sizeof(char *);
1539 printargc(fmt, tcp, addr)
1547 for (count = 0; umove(tcp, addr, &cp) >= 0 && cp != NULL; count++) {
1548 addr += sizeof(char *);
1550 tprintf(fmt, count, count == 1 ? "" : "s");
1557 if (entering(tcp)) {
1558 printpath(tcp, tcp->u_arg[0]);
1560 tprintf(", %#lx", tcp->u_arg[1]);
1562 else if (abbrev(tcp))
1563 printargc(", [/* %d arg%s */]", tcp, tcp->u_arg[1]);
1567 printargv(tcp, tcp->u_arg[1]);
1578 if (entering(tcp)) {
1579 printpath(tcp, tcp->u_arg[0]);
1581 tprintf(", %#lx", tcp->u_arg[1]);
1583 else if (abbrev(tcp))
1584 printargc(", [/* %d arg%s */]", tcp, tcp->u_arg[1]);
1588 printargv(tcp, tcp->u_arg[1]);
1592 tprintf(", %#lx", tcp->u_arg[2]);
1593 else if (abbrev(tcp))
1594 printargc(", [/* %d var%s */]", tcp, tcp->u_arg[2]);
1597 printargv(tcp, tcp->u_arg[2]);
1601 #if defined LINUX && defined TCB_WAITEXECVE
1602 tcp->flags |= TCB_WAITEXECVE;
1603 #endif /* LINUX && TCB_WAITEXECVE */
1609 int sys_rexecve(tcp)
1612 if (entering (tcp)) {
1614 tprintf (", %ld", tcp->u_arg[3]);
1626 if (exiting(tcp) && !syserror(tcp) && followfork)
1634 #define __WNOTHREAD 0x20000000
1637 #define __WALL 0x40000000
1640 #define __WCLONE 0x80000000
1644 static struct xlat wait4_options[] = {
1645 { WNOHANG, "WNOHANG" },
1647 { WUNTRACED, "WUNTRACED" },
1650 { WEXITED, "WEXITED" },
1653 { WTRAPPED, "WTRAPPED" },
1656 { WSTOPPED, "WSTOPPED" },
1659 { WCONTINUED, "WCONTINUED" },
1662 { WNOWAIT, "WNOWAIT" },
1665 { __WCLONE, "__WCLONE" },
1668 { __WALL, "__WALL" },
1671 { __WNOTHREAD, "__WNOTHREAD" },
1683 * Here is a tricky presentation problem. This solution
1684 * is still not entirely satisfactory but since there
1685 * are no wait status constructors it will have to do.
1687 if (WIFSTOPPED(status))
1688 tprintf("[WIFSTOPPED(s) && WSTOPSIG(s) == %s]",
1689 signame(WSTOPSIG(status)));
1690 else if WIFSIGNALED(status)
1691 tprintf("[WIFSIGNALED(s) && WTERMSIG(s) == %s%s]",
1692 signame(WTERMSIG(status)),
1693 WCOREDUMP(status) ? " && WCOREDUMP(s)" : "");
1694 else if WIFEXITED(status) {
1695 tprintf("[WIFEXITED(s) && WEXITSTATUS(s) == %d]",
1696 WEXITSTATUS(status));
1700 tprintf("[%#x]", status);
1705 printwaitn(tcp, n, bitness)
1713 if (entering(tcp)) {
1714 tprintf("%ld, ", tcp->u_arg[0]);
1719 else if (syserror(tcp) || tcp->u_rval == 0)
1720 tprintf("%#lx", tcp->u_arg[1]);
1721 else if (umove(tcp, tcp->u_arg[1], &status) < 0)
1724 exited = printstatus(status);
1727 if (!printflags(wait4_options, tcp->u_arg[2]))
1735 else if (tcp->u_rval > 0) {
1738 printrusage32(tcp, tcp->u_arg[3]);
1741 printrusage(tcp, tcp->u_arg[3]);
1745 else if (tcp->u_rval > 0 && exited)
1746 printrusage(tcp, tcp->u_arg[3]);
1749 tprintf("%#lx", tcp->u_arg[3]);
1761 #ifdef TCB_CLONE_THREAD
1762 if (tcp->flags & TCB_CLONE_THREAD)
1763 /* The children we wait for are our parent's children. */
1764 got_kids = (tcp->parent->nchildren
1765 > tcp->parent->nclone_detached);
1767 got_kids = (tcp->nchildren > tcp->nclone_detached);
1769 got_kids = tcp->nchildren > 0;
1772 if (entering(tcp) && got_kids) {
1773 /* There are children that this parent should block for.
1774 But ptrace made us the parent of the traced children
1775 and the real parent will get ECHILD from the wait call.
1777 XXX If we attached with strace -f -p PID, then there
1778 may be untraced dead children the parent could be reaping
1779 now, but we make him block. */
1781 /* ??? WTA: fix bug with hanging children */
1783 if (!(tcp->u_arg[2] & WNOHANG)) {
1785 * There are traced children. We'll make the parent
1786 * block to avoid a false ECHILD error due to our
1787 * ptrace having stolen the children. However,
1788 * we shouldn't block if there are zombies to reap.
1789 * XXX doesn't handle pgrp matches (u_arg[0]==0,<-1)
1791 if (tcp->nzombies > 0 &&
1792 (tcp->u_arg[0] == -1 ||
1793 pid2tcb(tcp->u_arg[0]) == NULL))
1795 tcp->flags |= TCB_SUSPENDED;
1796 tcp->waitpid = tcp->u_arg[0];
1797 #ifdef TCB_CLONE_THREAD
1798 if (tcp->flags & TCB_CLONE_THREAD)
1799 tcp->parent->nclone_waiting++;
1803 if (exiting(tcp) && tcp->u_error == ECHILD && got_kids) {
1804 if (tcp->u_arg[2] & WNOHANG) {
1805 /* We must force a fake result of 0 instead of
1806 the ECHILD error. */
1807 extern int force_result();
1808 return force_result(tcp, 0, 0);
1812 "internal_wait: should not have resumed %d\n",
1815 else if (exiting(tcp) && tcp->u_error == 0 && tcp->u_rval > 0 &&
1816 tcp->nzombies > 0 && pid2tcb(tcp->u_rval) == NULL) {
1818 * We just reaped a child we don't know about,
1819 * presumably a zombie we already droptcb'd.
1833 /* The library wrapper stuffs this into the user variable. */
1835 printstatus(getrval2(tcp));
1850 if (!syserror(tcp)) {
1851 if (umove(tcp, tcp->u_arg[0], &status) < 0)
1852 tprintf("%#lx", tcp->u_arg[0]);
1854 printstatus(status);
1865 return printwaitn(tcp, 3, 0);
1872 return printwaitn(tcp, 4, 0);
1880 return printwaitn(tcp, 4, 1);
1886 static struct xlat waitid_types[] = {
1888 { P_PPID, "P_PPID" },
1889 { P_PGID, "P_PGID" },
1896 { P_LWPID, "P_LWPID" },
1908 if (entering(tcp)) {
1909 printxval(waitid_types, tcp->u_arg[0], "P_???");
1910 tprintf(", %ld, ", tcp->u_arg[1]);
1911 if (tcp->nchildren > 0) {
1912 /* There are traced children */
1913 tcp->flags |= TCB_SUSPENDED;
1914 tcp->waitpid = tcp->u_arg[0];
1922 else if (syserror(tcp))
1923 tprintf("%#lx", tcp->u_arg[2]);
1924 else if (umove(tcp, tcp->u_arg[2], &si) < 0)
1927 printsiginfo(&si, verbose (tcp));
1930 if (!printflags(wait4_options, tcp->u_arg[3]))
1943 tprintf("%lu", tcp->u_arg[0]);
1951 struct utsname uname;
1954 if (syserror(tcp) || !verbose(tcp))
1955 tprintf("%#lx", tcp->u_arg[0]);
1956 else if (umove(tcp, tcp->u_arg[0], &uname) < 0)
1958 else if (!abbrev(tcp)) {
1960 tprintf("{sysname=\"%s\", nodename=\"%s\", ",
1961 uname.sysname, uname.nodename);
1962 tprintf("release=\"%s\", version=\"%s\", ",
1963 uname.release, uname.version);
1964 tprintf("machine=\"%s\"", uname.machine);
1967 tprintf(", domainname=\"%s\"", uname.domainname);
1968 #endif /* __GLIBC__ */
1973 tprintf("{sys=\"%s\", node=\"%s\", ...}",
1974 uname.sysname, uname.nodename);
1981 static struct xlat ptrace_cmds[] = {
1983 { PTRACE_TRACEME, "PTRACE_TRACEME" },
1984 { PTRACE_PEEKTEXT, "PTRACE_PEEKTEXT", },
1985 { PTRACE_PEEKDATA, "PTRACE_PEEKDATA", },
1986 { PTRACE_PEEKUSER, "PTRACE_PEEKUSER", },
1987 { PTRACE_POKETEXT, "PTRACE_POKETEXT", },
1988 { PTRACE_POKEDATA, "PTRACE_POKEDATA", },
1989 { PTRACE_POKEUSER, "PTRACE_POKEUSER", },
1990 { PTRACE_CONT, "PTRACE_CONT" },
1991 { PTRACE_KILL, "PTRACE_KILL" },
1992 { PTRACE_SINGLESTEP, "PTRACE_SINGLESTEP" },
1993 { PTRACE_ATTACH, "PTRACE_ATTACH" },
1994 { PTRACE_DETACH, "PTRACE_DETACH" },
1995 #ifdef PTRACE_GETREGS
1996 { PTRACE_GETREGS, "PTRACE_GETREGS" },
1998 #ifdef PTRACE_SETREGS
1999 { PTRACE_SETREGS, "PTRACE_SETREGS" },
2001 #ifdef PTRACE_GETFPREGS
2002 { PTRACE_GETFPREGS, "PTRACE_GETFPREGS", },
2004 #ifdef PTRACE_SETFPREGS
2005 { PTRACE_SETFPREGS, "PTRACE_SETFPREGS", },
2007 #ifdef PTRACE_GETFPXREGS
2008 { PTRACE_GETFPXREGS, "PTRACE_GETFPXREGS", },
2010 #ifdef PTRACE_SETFPXREGS
2011 { PTRACE_SETFPXREGS, "PTRACE_SETFPXREGS", },
2014 { PTRACE_READDATA, "PTRACE_READDATA" },
2015 { PTRACE_WRITEDATA, "PTRACE_WRITEDATA" },
2016 { PTRACE_READTEXT, "PTRACE_READTEXT" },
2017 { PTRACE_WRITETEXT, "PTRACE_WRITETEXT" },
2018 { PTRACE_GETFPAREGS, "PTRACE_GETFPAREGS" },
2019 { PTRACE_SETFPAREGS, "PTRACE_SETFPAREGS" },
2021 { PTRACE_GETWINDOW, "PTRACE_GETWINDOW" },
2022 { PTRACE_SETWINDOW, "PTRACE_SETWINDOW" },
2024 { PTRACE_22, "PTRACE_PTRACE_22" },
2025 { PTRACE_23, "PTRACE_PTRACE_23" },
2028 { PTRACE_SYSCALL, "PTRACE_SYSCALL" },
2030 { PTRACE_DUMPCORE, "PTRACE_DUMPCORE" },
2032 { PTRACE_SETWRBKPT, "PTRACE_SETWRBKPT" },
2033 { PTRACE_SETACBKPT, "PTRACE_SETACBKPT" },
2034 { PTRACE_CLRDR7, "PTRACE_CLRDR7" },
2036 { PTRACE_26, "PTRACE_26" },
2037 { PTRACE_27, "PTRACE_27" },
2038 { PTRACE_28, "PTRACE_28" },
2040 { PTRACE_GETUCODE, "PTRACE_GETUCODE" },
2043 { PT_TRACE_ME, "PT_TRACE_ME" },
2044 { PT_READ_I, "PT_READ_I" },
2045 { PT_READ_D, "PT_READ_D" },
2046 { PT_WRITE_I, "PT_WRITE_I" },
2047 { PT_WRITE_D, "PT_WRITE_D" },
2049 { PT_READ_U, "PT_READ_U" },
2051 { PT_CONTINUE, "PT_CONTINUE" },
2052 { PT_KILL, "PT_KILL" },
2053 { PT_STEP, "PT_STEP" },
2054 { PT_ATTACH, "PT_ATTACH" },
2055 { PT_DETACH, "PT_DETACH" },
2056 { PT_GETREGS, "PT_GETREGS" },
2057 { PT_SETREGS, "PT_SETREGS" },
2058 { PT_GETFPREGS, "PT_GETFPREGS" },
2059 { PT_SETFPREGS, "PT_SETFPREGS" },
2060 { PT_GETDBREGS, "PT_GETDBREGS" },
2061 { PT_SETDBREGS, "PT_SETDBREGS" },
2062 #endif /* FREEBSD */
2067 #ifndef SUNOS4_KERNEL_ARCH_KLUDGE
2069 #endif /* !SUNOS4_KERNEL_ARCH_KLUDGE */
2070 struct xlat struct_user_offsets[] = {
2072 #if defined(S390) || defined(S390X)
2073 { PT_PSWMASK, "psw_mask" },
2074 { PT_PSWADDR, "psw_addr" },
2075 { PT_GPR0, "gpr0" },
2076 { PT_GPR1, "gpr1" },
2077 { PT_GPR2, "gpr2" },
2078 { PT_GPR3, "gpr3" },
2079 { PT_GPR4, "gpr4" },
2080 { PT_GPR5, "gpr5" },
2081 { PT_GPR6, "gpr6" },
2082 { PT_GPR7, "gpr7" },
2083 { PT_GPR8, "gpr8" },
2084 { PT_GPR9, "gpr9" },
2085 { PT_GPR10, "gpr10" },
2086 { PT_GPR11, "gpr11" },
2087 { PT_GPR12, "gpr12" },
2088 { PT_GPR13, "gpr13" },
2089 { PT_GPR14, "gpr14" },
2090 { PT_GPR15, "gpr15" },
2091 { PT_ACR0, "acr0" },
2092 { PT_ACR1, "acr1" },
2093 { PT_ACR2, "acr2" },
2094 { PT_ACR3, "acr3" },
2095 { PT_ACR4, "acr4" },
2096 { PT_ACR5, "acr5" },
2097 { PT_ACR6, "acr6" },
2098 { PT_ACR7, "acr7" },
2099 { PT_ACR8, "acr8" },
2100 { PT_ACR9, "acr9" },
2101 { PT_ACR10, "acr10" },
2102 { PT_ACR11, "acr11" },
2103 { PT_ACR12, "acr12" },
2104 { PT_ACR13, "acr13" },
2105 { PT_ACR14, "acr14" },
2106 { PT_ACR15, "acr15" },
2107 { PT_ORIGGPR2, "orig_gpr2" },
2110 { PT_FPR0_HI, "fpr0.hi" },
2111 { PT_FPR0_LO, "fpr0.lo" },
2112 { PT_FPR1_HI, "fpr1.hi" },
2113 { PT_FPR1_LO, "fpr1.lo" },
2114 { PT_FPR2_HI, "fpr2.hi" },
2115 { PT_FPR2_LO, "fpr2.lo" },
2116 { PT_FPR3_HI, "fpr3.hi" },
2117 { PT_FPR3_LO, "fpr3.lo" },
2118 { PT_FPR4_HI, "fpr4.hi" },
2119 { PT_FPR4_LO, "fpr4.lo" },
2120 { PT_FPR5_HI, "fpr5.hi" },
2121 { PT_FPR5_LO, "fpr5.lo" },
2122 { PT_FPR6_HI, "fpr6.hi" },
2123 { PT_FPR6_LO, "fpr6.lo" },
2124 { PT_FPR7_HI, "fpr7.hi" },
2125 { PT_FPR7_LO, "fpr7.lo" },
2126 { PT_FPR8_HI, "fpr8.hi" },
2127 { PT_FPR8_LO, "fpr8.lo" },
2128 { PT_FPR9_HI, "fpr9.hi" },
2129 { PT_FPR9_LO, "fpr9.lo" },
2130 { PT_FPR10_HI, "fpr10.hi" },
2131 { PT_FPR10_LO, "fpr10.lo" },
2132 { PT_FPR11_HI, "fpr11.hi" },
2133 { PT_FPR11_LO, "fpr11.lo" },
2134 { PT_FPR12_HI, "fpr12.hi" },
2135 { PT_FPR12_LO, "fpr12.lo" },
2136 { PT_FPR13_HI, "fpr13.hi" },
2137 { PT_FPR13_LO, "fpr13.lo" },
2138 { PT_FPR14_HI, "fpr14.hi" },
2139 { PT_FPR14_LO, "fpr14.lo" },
2140 { PT_FPR15_HI, "fpr15.hi" },
2141 { PT_FPR15_LO, "fpr15.lo" },
2144 { PT_FPR0, "fpr0" },
2145 { PT_FPR1, "fpr1" },
2146 { PT_FPR2, "fpr2" },
2147 { PT_FPR3, "fpr3" },
2148 { PT_FPR4, "fpr4" },
2149 { PT_FPR5, "fpr5" },
2150 { PT_FPR6, "fpr6" },
2151 { PT_FPR7, "fpr7" },
2152 { PT_FPR8, "fpr8" },
2153 { PT_FPR9, "fpr9" },
2154 { PT_FPR10, "fpr10" },
2155 { PT_FPR11, "fpr11" },
2156 { PT_FPR12, "fpr12" },
2157 { PT_FPR13, "fpr13" },
2158 { PT_FPR14, "fpr14" },
2159 { PT_FPR15, "fpr15" },
2162 { PT_CR_10, "cr10" },
2163 { PT_CR_11, "cr11" },
2164 { PT_IEEE_IP, "ieee_exception_ip" },
2167 /* XXX No support for these offsets yet. */
2169 /* XXX No support for these offsets yet. */
2170 #elif defined(POWERPC)
2172 #define PT_ORIG_R3 34
2174 #define REGSIZE (sizeof(unsigned long))
2175 { REGSIZE*PT_R0, "r0" },
2176 { REGSIZE*PT_R1, "r1" },
2177 { REGSIZE*PT_R2, "r2" },
2178 { REGSIZE*PT_R3, "r3" },
2179 { REGSIZE*PT_R4, "r4" },
2180 { REGSIZE*PT_R5, "r5" },
2181 { REGSIZE*PT_R6, "r6" },
2182 { REGSIZE*PT_R7, "r7" },
2183 { REGSIZE*PT_R8, "r8" },
2184 { REGSIZE*PT_R9, "r9" },
2185 { REGSIZE*PT_R10, "r10" },
2186 { REGSIZE*PT_R11, "r11" },
2187 { REGSIZE*PT_R12, "r12" },
2188 { REGSIZE*PT_R13, "r13" },
2189 { REGSIZE*PT_R14, "r14" },
2190 { REGSIZE*PT_R15, "r15" },
2191 { REGSIZE*PT_R16, "r16" },
2192 { REGSIZE*PT_R17, "r17" },
2193 { REGSIZE*PT_R18, "r18" },
2194 { REGSIZE*PT_R19, "r19" },
2195 { REGSIZE*PT_R20, "r20" },
2196 { REGSIZE*PT_R21, "r21" },
2197 { REGSIZE*PT_R22, "r22" },
2198 { REGSIZE*PT_R23, "r23" },
2199 { REGSIZE*PT_R24, "r24" },
2200 { REGSIZE*PT_R25, "r25" },
2201 { REGSIZE*PT_R26, "r26" },
2202 { REGSIZE*PT_R27, "r27" },
2203 { REGSIZE*PT_R28, "r28" },
2204 { REGSIZE*PT_R29, "r29" },
2205 { REGSIZE*PT_R30, "r30" },
2206 { REGSIZE*PT_R31, "r31" },
2207 { REGSIZE*PT_NIP, "NIP" },
2208 { REGSIZE*PT_MSR, "MSR" },
2209 { REGSIZE*PT_ORIG_R3, "ORIG_R3" },
2210 { REGSIZE*PT_CTR, "CTR" },
2211 { REGSIZE*PT_LNK, "LNK" },
2212 { REGSIZE*PT_XER, "XER" },
2213 { REGSIZE*PT_CCR, "CCR" },
2214 { REGSIZE*PT_FPR0, "FPR0" },
2285 { PT_F32, "f32" }, { PT_F33, "f33" }, { PT_F34, "f34" },
2286 { PT_F35, "f35" }, { PT_F36, "f36" }, { PT_F37, "f37" },
2287 { PT_F38, "f38" }, { PT_F39, "f39" }, { PT_F40, "f40" },
2288 { PT_F41, "f41" }, { PT_F42, "f42" }, { PT_F43, "f43" },
2289 { PT_F44, "f44" }, { PT_F45, "f45" }, { PT_F46, "f46" },
2290 { PT_F47, "f47" }, { PT_F48, "f48" }, { PT_F49, "f49" },
2291 { PT_F50, "f50" }, { PT_F51, "f51" }, { PT_F52, "f52" },
2292 { PT_F53, "f53" }, { PT_F54, "f54" }, { PT_F55, "f55" },
2293 { PT_F56, "f56" }, { PT_F57, "f57" }, { PT_F58, "f58" },
2294 { PT_F59, "f59" }, { PT_F60, "f60" }, { PT_F61, "f61" },
2295 { PT_F62, "f62" }, { PT_F63, "f63" }, { PT_F64, "f64" },
2296 { PT_F65, "f65" }, { PT_F66, "f66" }, { PT_F67, "f67" },
2297 { PT_F68, "f68" }, { PT_F69, "f69" }, { PT_F70, "f70" },
2298 { PT_F71, "f71" }, { PT_F72, "f72" }, { PT_F73, "f73" },
2299 { PT_F74, "f74" }, { PT_F75, "f75" }, { PT_F76, "f76" },
2300 { PT_F77, "f77" }, { PT_F78, "f78" }, { PT_F79, "f79" },
2301 { PT_F80, "f80" }, { PT_F81, "f81" }, { PT_F82, "f82" },
2302 { PT_F83, "f83" }, { PT_F84, "f84" }, { PT_F85, "f85" },
2303 { PT_F86, "f86" }, { PT_F87, "f87" }, { PT_F88, "f88" },
2304 { PT_F89, "f89" }, { PT_F90, "f90" }, { PT_F91, "f91" },
2305 { PT_F92, "f92" }, { PT_F93, "f93" }, { PT_F94, "f94" },
2306 { PT_F95, "f95" }, { PT_F96, "f96" }, { PT_F97, "f97" },
2307 { PT_F98, "f98" }, { PT_F99, "f99" }, { PT_F100, "f100" },
2308 { PT_F101, "f101" }, { PT_F102, "f102" }, { PT_F103, "f103" },
2309 { PT_F104, "f104" }, { PT_F105, "f105" }, { PT_F106, "f106" },
2310 { PT_F107, "f107" }, { PT_F108, "f108" }, { PT_F109, "f109" },
2311 { PT_F110, "f110" }, { PT_F111, "f111" }, { PT_F112, "f112" },
2312 { PT_F113, "f113" }, { PT_F114, "f114" }, { PT_F115, "f115" },
2313 { PT_F116, "f116" }, { PT_F117, "f117" }, { PT_F118, "f118" },
2314 { PT_F119, "f119" }, { PT_F120, "f120" }, { PT_F121, "f121" },
2315 { PT_F122, "f122" }, { PT_F123, "f123" }, { PT_F124, "f124" },
2316 { PT_F125, "f125" }, { PT_F126, "f126" }, { PT_F127, "f127" },
2318 { PT_F2, "f2" }, { PT_F3, "f3" }, { PT_F4, "f4" },
2319 { PT_F5, "f5" }, { PT_F10, "f10" }, { PT_F11, "f11" },
2320 { PT_F12, "f12" }, { PT_F13, "f13" }, { PT_F14, "f14" },
2321 { PT_F15, "f15" }, { PT_F16, "f16" }, { PT_F17, "f17" },
2322 { PT_F18, "f18" }, { PT_F19, "f19" }, { PT_F20, "f20" },
2323 { PT_F21, "f21" }, { PT_F22, "f22" }, { PT_F23, "f23" },
2324 { PT_F24, "f24" }, { PT_F25, "f25" }, { PT_F26, "f26" },
2325 { PT_F27, "f27" }, { PT_F28, "f28" }, { PT_F29, "f29" },
2326 { PT_F30, "f30" }, { PT_F31, "f31" }, { PT_R4, "r4" },
2327 { PT_R5, "r5" }, { PT_R6, "r6" }, { PT_R7, "r7" },
2329 { PT_B1, "b1" }, { PT_B2, "b2" }, { PT_B3, "b3" },
2330 { PT_B4, "b4" }, { PT_B5, "b5" },
2331 { PT_AR_PFS, "kar.pfs" },
2332 { PT_AR_LC, "ar.lc" }, { PT_AR_UNAT, "kar.unat" },
2333 { PT_AR_RNAT, "kar.rnat" }, { PT_AR_BSPSTORE, "kar.bspstore" },
2336 { PT_CR_IPSR, "cr.ipsr" }, { PT_CR_IIP, "cr.iip" },
2337 /*{ PT_CR_IFS, "cr.ifs" },*/ { PT_AR_UNAT, "ar.unat" },
2338 { PT_AR_PFS, "ar.pfs" }, { PT_AR_RSC, "ar.rsc" },
2339 { PT_AR_RNAT, "ar.rnat" }, { PT_AR_BSPSTORE, "ar.bspstore" },
2340 { PT_PR, "pr" }, { PT_B6, "b6" }, { PT_AR_BSP, "ar.bsp" },
2341 { PT_R1, "r1" }, { PT_R2, "r2" }, { PT_R3, "r3" },
2342 { PT_R12, "r12" }, { PT_R13, "r13" }, { PT_R14, "r14" },
2343 { PT_R15, "r15" }, { PT_R8, "r8" }, { PT_R9, "r9" },
2344 { PT_R10, "r10" }, { PT_R11, "r11" }, { PT_R16, "r16" },
2345 { PT_R17, "r17" }, { PT_R18, "r18" }, { PT_R19, "r19" },
2346 { PT_R20, "r20" }, { PT_R21, "r21" }, { PT_R22, "r22" },
2347 { PT_R23, "r23" }, { PT_R24, "r24" }, { PT_R25, "r25" },
2348 { PT_R26, "r26" }, { PT_R27, "r27" }, { PT_R28, "r28" },
2349 { PT_R29, "r29" }, { PT_R30, "r30" }, { PT_R31, "r31" },
2350 { PT_AR_CCV, "ar.ccv" }, { PT_AR_FPSR, "ar.fpsr" },
2351 { PT_B0, "b0" }, { PT_B7, "b7" }, { PT_F6, "f6" },
2352 { PT_F7, "f7" }, { PT_F8, "f8" }, { PT_F9, "f9" },
2366 { 4*ORIG_EAX, "4*ORIG_EAX" },
2370 { 4*UESP, "4*UESP" },
2390 { 8*ORIG_RAX, "8*ORIG_EAX" },
2393 { 8*EFLAGS, "8*EFL" },
2403 { 4*PT_D1, "4*PT_D1" },
2404 { 4*PT_D2, "4*PT_D2" },
2405 { 4*PT_D3, "4*PT_D3" },
2406 { 4*PT_D4, "4*PT_D4" },
2407 { 4*PT_D5, "4*PT_D5" },
2408 { 4*PT_D6, "4*PT_D6" },
2409 { 4*PT_D7, "4*PT_D7" },
2410 { 4*PT_A0, "4*PT_A0" },
2411 { 4*PT_A1, "4*PT_A1" },
2412 { 4*PT_A2, "4*PT_A2" },
2413 { 4*PT_A3, "4*PT_A3" },
2414 { 4*PT_A4, "4*PT_A4" },
2415 { 4*PT_A5, "4*PT_A5" },
2416 { 4*PT_A6, "4*PT_A6" },
2417 { 4*PT_D0, "4*PT_D0" },
2418 { 4*PT_USP, "4*PT_USP" },
2419 { 4*PT_ORIG_D0, "4*PT_ORIG_D0" },
2420 { 4*PT_SR, "4*PT_SR" },
2421 { 4*PT_PC, "4*PT_PC" },
2425 { 4*REG_REG0, "4*REG_REG0" },
2426 { 4*(REG_REG0+1), "4*REG_REG1" },
2427 { 4*(REG_REG0+2), "4*REG_REG2" },
2428 { 4*(REG_REG0+3), "4*REG_REG3" },
2429 { 4*(REG_REG0+4), "4*REG_REG4" },
2430 { 4*(REG_REG0+5), "4*REG_REG5" },
2431 { 4*(REG_REG0+6), "4*REG_REG6" },
2432 { 4*(REG_REG0+7), "4*REG_REG7" },
2433 { 4*(REG_REG0+8), "4*REG_REG8" },
2434 { 4*(REG_REG0+9), "4*REG_REG9" },
2435 { 4*(REG_REG0+10), "4*REG_REG10" },
2436 { 4*(REG_REG0+11), "4*REG_REG11" },
2437 { 4*(REG_REG0+12), "4*REG_REG12" },
2438 { 4*(REG_REG0+13), "4*REG_REG13" },
2439 { 4*(REG_REG0+14), "4*REG_REG14" },
2440 { 4*REG_REG15, "4*REG_REG15" },
2441 { 4*REG_PC, "4*REG_PC" },
2442 { 4*REG_PR, "4*REG_PR" },
2443 { 4*REG_SR, "4*REG_SR" },
2444 { 4*REG_GBR, "4*REG_GBR" },
2445 { 4*REG_MACH, "4*REG_MACH" },
2446 { 4*REG_MACL, "4*REG_MACL" },
2447 { 4*REG_SYSCALL, "4*REG_SYSCALL" },
2448 { 4*REG_FPUL, "4*REG_FPUL" },
2449 { 4*REG_FPREG0, "4*REG_FPREG0" },
2450 { 4*(REG_FPREG0+1), "4*REG_FPREG1" },
2451 { 4*(REG_FPREG0+2), "4*REG_FPREG2" },
2452 { 4*(REG_FPREG0+3), "4*REG_FPREG3" },
2453 { 4*(REG_FPREG0+4), "4*REG_FPREG4" },
2454 { 4*(REG_FPREG0+5), "4*REG_FPREG5" },
2455 { 4*(REG_FPREG0+6), "4*REG_FPREG6" },
2456 { 4*(REG_FPREG0+7), "4*REG_FPREG7" },
2457 { 4*(REG_FPREG0+8), "4*REG_FPREG8" },
2458 { 4*(REG_FPREG0+9), "4*REG_FPREG9" },
2459 { 4*(REG_FPREG0+10), "4*REG_FPREG10" },
2460 { 4*(REG_FPREG0+11), "4*REG_FPREG11" },
2461 { 4*(REG_FPREG0+12), "4*REG_FPREG12" },
2462 { 4*(REG_FPREG0+13), "4*REG_FPREG13" },
2463 { 4*(REG_FPREG0+14), "4*REG_FPREG14" },
2464 { 4*REG_FPREG15, "4*REG_FPREG15" },
2465 { 4*REG_XDREG0, "4*REG_XDREG0" },
2466 { 4*(REG_XDREG0+2), "4*REG_XDREG2" },
2467 { 4*(REG_XDREG0+4), "4*REG_XDREG4" },
2468 { 4*(REG_XDREG0+6), "4*REG_XDREG6" },
2469 { 4*(REG_XDREG0+8), "4*REG_XDREG8" },
2470 { 4*(REG_XDREG0+10), "4*REG_XDREG10" },
2471 { 4*(REG_XDREG0+12), "4*REG_XDREG12" },
2472 { 4*REG_XDREG14, "4*REG_XDREG14" },
2473 { 4*REG_FPSCR, "4*REG_FPSCR" },
2480 { 16, "syscall no.(L)" },
2481 { 20, "syscall_no.(U)" },
2624 /* This entry is in case pt_regs contains dregs (depends on
2625 the kernel build options). */
2626 { uoff(regs), "offsetof(struct user, regs)" },
2627 { uoff(fpu), "offsetof(struct user, fpu)" },
2630 #if !defined(S390) && !defined(S390X) && !defined(MIPS)
2631 { uoff(u_fpvalid), "offsetof(struct user, u_fpvalid)" },
2633 #if defined(I386) || defined(X86_64)
2634 { uoff(i387), "offsetof(struct user, i387)" },
2637 { uoff(m68kfp), "offsetof(struct user, m68kfp)" },
2640 { uoff(u_tsize), "offsetof(struct user, u_tsize)" },
2641 { uoff(u_dsize), "offsetof(struct user, u_dsize)" },
2642 { uoff(u_ssize), "offsetof(struct user, u_ssize)" },
2643 { uoff(start_code), "offsetof(struct user, start_code)" },
2645 { uoff(start_data), "offsetof(struct user, start_data)" },
2647 { uoff(start_stack), "offsetof(struct user, start_stack)" },
2648 { uoff(signal), "offsetof(struct user, signal)" },
2649 #if !defined(S390) && !defined(S390X) && !defined(MIPS) && !defined(SH) && !defined(SHMEDIA)
2650 { uoff(reserved), "offsetof(struct user, reserved)" },
2652 { uoff(u_ar0), "offsetof(struct user, u_ar0)" },
2653 #if !defined(ARM) && !defined(MIPS) && !defined(S390) && !defined(S390X)
2654 { uoff(u_fpstate), "offsetof(struct user, u_fpstate)" },
2656 { uoff(magic), "offsetof(struct user, magic)" },
2657 { uoff(u_comm), "offsetof(struct user, u_comm)" },
2658 #if defined(I386) || defined(X86_64)
2659 { uoff(u_debugreg), "offsetof(struct user, u_debugreg)" },
2663 #endif /* !POWERPC/!SPARC */
2666 { uoff(u_pcb), "offsetof(struct user, u_pcb)" },
2667 { uoff(u_procp), "offsetof(struct user, u_procp)" },
2668 { uoff(u_ar0), "offsetof(struct user, u_ar0)" },
2669 { uoff(u_comm[0]), "offsetof(struct user, u_comm[0])" },
2670 { uoff(u_arg[0]), "offsetof(struct user, u_arg[0])" },
2671 { uoff(u_ap), "offsetof(struct user, u_ap)" },
2672 { uoff(u_qsave), "offsetof(struct user, u_qsave)" },
2673 { uoff(u_rval1), "offsetof(struct user, u_rval1)" },
2674 { uoff(u_rval2), "offsetof(struct user, u_rval2)" },
2675 { uoff(u_error), "offsetof(struct user, u_error)" },
2676 { uoff(u_eosys), "offsetof(struct user, u_eosys)" },
2677 { uoff(u_ssave), "offsetof(struct user, u_ssave)" },
2678 { uoff(u_signal[0]), "offsetof(struct user, u_signal)" },
2679 { uoff(u_sigmask[0]), "offsetof(struct user, u_sigmask)" },
2680 { uoff(u_sigonstack), "offsetof(struct user, u_sigonstack)" },
2681 { uoff(u_sigintr), "offsetof(struct user, u_sigintr)" },
2682 { uoff(u_sigreset), "offsetof(struct user, u_sigreset)" },
2683 { uoff(u_oldmask), "offsetof(struct user, u_oldmask)" },
2684 { uoff(u_code), "offsetof(struct user, u_code)" },
2685 { uoff(u_addr), "offsetof(struct user, u_addr)" },
2686 { uoff(u_sigstack), "offsetof(struct user, u_sigstack)" },
2687 { uoff(u_ofile), "offsetof(struct user, u_ofile)" },
2688 { uoff(u_pofile), "offsetof(struct user, u_pofile)" },
2689 { uoff(u_ofile_arr[0]), "offsetof(struct user, u_ofile_arr[0])" },
2690 { uoff(u_pofile_arr[0]),"offsetof(struct user, u_pofile_arr[0])"},
2691 { uoff(u_lastfile), "offsetof(struct user, u_lastfile)" },
2692 { uoff(u_cwd), "offsetof(struct user, u_cwd)" },
2693 { uoff(u_cdir), "offsetof(struct user, u_cdir)" },
2694 { uoff(u_rdir), "offsetof(struct user, u_rdir)" },
2695 { uoff(u_cmask), "offsetof(struct user, u_cmask)" },
2696 { uoff(u_ru), "offsetof(struct user, u_ru)" },
2697 { uoff(u_cru), "offsetof(struct user, u_cru)" },
2698 { uoff(u_timer[0]), "offsetof(struct user, u_timer[0])" },
2699 { uoff(u_XXX[0]), "offsetof(struct user, u_XXX[0])" },
2700 { uoff(u_ioch), "offsetof(struct user, u_ioch)" },
2701 { uoff(u_start), "offsetof(struct user, u_start)" },
2702 { uoff(u_acflag), "offsetof(struct user, u_acflag)" },
2703 { uoff(u_prof.pr_base), "offsetof(struct user, u_prof.pr_base)" },
2704 { uoff(u_prof.pr_size), "offsetof(struct user, u_prof.pr_size)" },
2705 { uoff(u_prof.pr_off), "offsetof(struct user, u_prof.pr_off)" },
2706 { uoff(u_prof.pr_scale),"offsetof(struct user, u_prof.pr_scale)"},
2707 { uoff(u_rlimit[0]), "offsetof(struct user, u_rlimit)" },
2708 { uoff(u_exdata.Ux_A), "offsetof(struct user, u_exdata.Ux_A)" },
2709 { uoff(u_exdata.ux_shell[0]),"offsetof(struct user, u_exdata.ux_shell[0])"},
2710 { uoff(u_lofault), "offsetof(struct user, u_lofault)" },
2713 { sizeof(struct user), "sizeof(struct user)" },
2726 if (entering(tcp)) {
2727 printxval(ptrace_cmds, tcp->u_arg[0],
2734 tprintf(", %lu, ", tcp->u_arg[1]);
2735 addr = tcp->u_arg[2];
2737 if (tcp->u_arg[0] == PTRACE_PEEKUSER
2738 || tcp->u_arg[0] == PTRACE_POKEUSER) {
2739 for (x = struct_user_offsets; x->str; x++) {
2744 tprintf("%#lx, ", addr);
2745 else if (x->val > addr && x != struct_user_offsets) {
2747 tprintf("%s + %ld, ", x->str, addr - x->val);
2750 tprintf("%s, ", x->str);
2754 tprintf("%#lx, ", tcp->u_arg[2]);
2756 switch (tcp->u_arg[0]) {
2757 case PTRACE_PEEKDATA:
2758 case PTRACE_PEEKTEXT:
2759 case PTRACE_PEEKUSER:
2762 case PTRACE_SINGLESTEP:
2763 case PTRACE_SYSCALL:
2765 printsignal(tcp->u_arg[3]);
2768 tprintf("%#lx", tcp->u_arg[3]);
2772 switch (tcp->u_arg[0]) {
2773 case PTRACE_PEEKDATA:
2774 case PTRACE_PEEKTEXT:
2775 case PTRACE_PEEKUSER:
2776 printnum(tcp, tcp->u_arg[3], "%#lx");
2782 if (tcp->u_arg[0] == PTRACE_WRITEDATA ||
2783 tcp->u_arg[0] == PTRACE_WRITETEXT) {
2784 tprintf("%lu, ", tcp->u_arg[3]);
2785 printstr(tcp, tcp->u_arg[4], tcp->u_arg[3]);
2786 } else if (tcp->u_arg[0] != PTRACE_READDATA &&
2787 tcp->u_arg[0] != PTRACE_READTEXT) {
2788 tprintf("%#lx", tcp->u_arg[3]);
2791 if (tcp->u_arg[0] == PTRACE_READDATA ||
2792 tcp->u_arg[0] == PTRACE_READTEXT) {
2793 tprintf("%lu, ", tcp->u_arg[3]);
2794 printstr(tcp, tcp->u_arg[4], tcp->u_arg[3]);
2799 tprintf("%lu", tcp->u_arg[3]);
2801 #endif /* FREEBSD */
2808 static struct xlat futexops[] = {
2809 { FUTEX_WAIT, "FUTEX_WAIT" },
2810 { FUTEX_WAKE, "FUTEX_WAKE" },
2811 { FUTEX_FD, "FUTEX_FD" },
2819 if (entering(tcp)) {
2820 tprintf("%p, ", (void *) tcp->u_arg[0]);
2821 printflags(futexops, tcp->u_arg[1]);
2822 tprintf(", %ld", tcp->u_arg[2]);
2823 if (tcp->u_arg[1] == FUTEX_WAIT) {
2825 printtv(tcp, tcp->u_arg[3]);
2832 print_affinitylist(list, len)
2833 unsigned long *list;
2838 while (len >= sizeof (unsigned long)) {
2839 tprintf("%s %lx", first ? "" : ",", *list++);
2841 len -= sizeof (unsigned long);
2847 sys_sched_setaffinity(tcp)
2850 if (entering(tcp)) {
2851 tprintf("%ld, %lu, ", tcp->u_arg[0], tcp->u_arg[1]);
2852 print_affinitylist((unsigned long *) tcp->u_arg[2], tcp->u_arg[1]);
2858 sys_sched_getaffinity(tcp)
2861 if (entering(tcp)) {
2862 tprintf("%ld, %lu, ", tcp->u_arg[0], tcp->u_arg[1]);
2864 print_affinitylist((unsigned long *) tcp->u_arg[2], tcp->u_rval);