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>
101 # ifndef FUTEX_REQUEUE
102 # define FUTEX_REQUEUE 3
107 #include <asm/posix_types.h>
109 #define GETGROUPS_T __kernel_gid_t
112 #if defined(LINUX) && defined(IA64)
113 # include <asm/ptrace_offsets.h>
114 # include <asm/rse.h>
118 #include <sys/prctl.h>
122 #define WCOREDUMP(status) ((status) & 0200)
125 /* WTA: this was `&& !defined(LINUXSPARC)', this seems unneeded though? */
126 #if defined(HAVE_PRCTL)
127 static struct xlat prctl_options[] = {
129 { PR_MAXPROCS, "PR_MAXPROCS" },
132 { PR_ISBLOCKED, "PR_ISBLOCKED" },
134 #ifdef PR_SETSTACKSIZE
135 { PR_SETSTACKSIZE, "PR_SETSTACKSIZE" },
137 #ifdef PR_GETSTACKSIZE
138 { PR_GETSTACKSIZE, "PR_GETSTACKSIZE" },
141 { PR_MAXPPROCS, "PR_MAXPPROCS" },
143 #ifdef PR_UNBLKONEXEC
144 { PR_UNBLKONEXEC, "PR_UNBLKONEXEC" },
147 { PR_ATOMICSIM, "PR_ATOMICSIM" },
150 { PR_SETEXITSIG, "PR_SETEXITSIG" },
153 { PR_RESIDENT, "PR_RESIDENT" },
156 { PR_ATTACHADDR, "PR_ATTACHADDR" },
159 { PR_DETACHADDR, "PR_DETACHADDR" },
162 { PR_TERMCHILD, "PR_TERMCHILD" },
165 { PR_GETSHMASK, "PR_GETSHMASK" },
168 { PR_GETNSHARE, "PR_GETNSHARE" },
170 #if defined(PR_SET_PDEATHSIG)
171 { PR_SET_PDEATHSIG, "PR_SET_PDEATHSIG" },
174 { PR_COREPID, "PR_COREPID" },
176 #ifdef PR_ATTACHADDRPERM
177 { PR_ATTACHADDRPERM, "PR_ATTACHADDRPERM" },
179 #ifdef PR_PTHREADEXIT
180 { PR_PTHREADEXIT, "PR_PTHREADEXIT" },
182 #ifdef PR_SET_PDEATHSIG
183 { PR_SET_PDEATHSIG, "PR_SET_PDEATHSIG" },
185 #ifdef PR_GET_PDEATHSIG
186 { PR_GET_PDEATHSIG, "PR_GET_PDEATHSIG" },
188 #ifdef PR_GET_UNALIGN
189 { PR_GET_UNALIGN, "PR_GET_UNALIGN" },
191 #ifdef PR_SET_UNALIGN
192 { PR_SET_UNALIGN, "PR_SET_UNALIGN" },
194 #ifdef PR_GET_KEEPCAPS
195 { PR_GET_KEEPCAPS, "PR_GET_KEEP_CAPS" },
197 #ifdef PR_SET_KEEPCAPS
198 { PR_SET_KEEPCAPS, "PR_SET_KEEP_CAPS" },
205 unalignctl_string (unsigned int ctl)
210 #ifdef PR_UNALIGN_NOPRINT
211 case PR_UNALIGN_NOPRINT:
214 #ifdef PR_UNALIGN_SIGBUS
215 case PR_UNALIGN_SIGBUS:
221 sprintf(buf, "%x", ctl);
233 printxval(prctl_options, tcp->u_arg[0], "PR_???");
234 switch (tcp->u_arg[0]) {
239 #ifdef PR_SET_DEATHSIG
240 case PR_GET_PDEATHSIG:
243 #ifdef PR_SET_UNALIGN
245 tprintf(", %s", unalignctl_string(tcp->u_arg[1]));
248 #ifdef PR_GET_UNALIGN
250 tprintf(", %#lx", tcp->u_arg[1]);
254 for (i = 1; i < tcp->u_nargs; i++)
255 tprintf(", %#lx", tcp->u_arg[i]);
259 switch (tcp->u_arg[0]) {
260 #ifdef PR_GET_PDEATHSIG
261 case PR_GET_PDEATHSIG:
262 for (i=1; i<tcp->u_nargs; i++)
263 tprintf(", %#lx", tcp->u_arg[i]);
266 #ifdef PR_SET_UNALIGN
270 #ifdef PR_GET_UNALIGN
275 umove(tcp, tcp->u_arg[1], &ctl);
276 tcp->auxstr = unalignctl_string(ctl);
287 #endif /* HAVE_PRCTL */
303 printpathn(tcp, tcp->u_arg[0], tcp->u_arg[1]);
304 tprintf(", %lu", tcp->u_arg[1]);
315 tprintf("%#lx", tcp->u_arg[0]);
317 printpath(tcp, tcp->u_arg[0]);
318 tprintf(", %lu", tcp->u_arg[1]);
324 sys_setdomainname(tcp)
328 printpathn(tcp, tcp->u_arg[0], tcp->u_arg[1]);
329 tprintf(", %lu", tcp->u_arg[1]);
337 sys_getdomainname(tcp)
342 tprintf("%#lx", tcp->u_arg[0]);
344 printpath(tcp, tcp->u_arg[0]);
345 tprintf(", %lu", tcp->u_arg[1]);
356 fprintf(stderr, "_exit returned!\n");
359 /* special case: we stop tracing this process, finish line now */
360 tprintf("%ld) ", tcp->u_arg[0]);
372 tcp->flags |= TCB_EXITING;
373 #ifdef __NR_exit_group
374 if (tcp->scno == __NR_exit_group)
375 tcp->flags |= TCB_GROUP_EXITING;
381 /* TCP is creating a child we want to follow.
382 If there will be space in tcbtab for it, set TCB_FOLLOWFORK and return 0.
383 If not, clear TCB_FOLLOWFORK, print an error, and return 1. */
385 fork_tcb(struct tcb *tcp)
387 if (nprocs == tcbtabsize) {
388 /* Allocate some more TCBs and expand the table.
389 We don't want to relocate the TCBs because our
390 callers have pointers and it would be a pain.
391 So tcbtab is a table of pointers. Since we never
392 free the TCBs, we allocate a single chunk of many. */
393 struct tcb **newtab = (struct tcb **)
394 realloc(tcbtab, 2 * tcbtabsize * sizeof tcbtab[0]);
395 struct tcb *newtcbs = (struct tcb *) calloc(tcbtabsize,
398 if (newtab == NULL || newtcbs == NULL) {
401 tcp->flags &= ~TCB_FOLLOWFORK;
402 fprintf(stderr, "sys_fork: tcb table full\n");
405 for (i = tcbtabsize; i < 2 * tcbtabsize; ++i)
406 newtab[i] = &newtcbs[i - tcbtabsize];
411 tcp->flags |= TCB_FOLLOWFORK;
423 tcp->auxstr = "child process";
424 return RVAL_UDECIMAL | RVAL_STR;
437 tprintf ("%ld", tcp->u_arg[0]);
441 tcp->auxstr = "child process";
442 return RVAL_UDECIMAL | RVAL_STR;
454 struct tcb *tcpchild;
458 if (tcp->scno == SYS_rfork && !(tcp->u_arg[0]&RFPROC))
469 if ((tcpchild = alloctcb(tcp->u_rval)) == NULL) {
470 fprintf(stderr, "sys_fork: tcb table full\n");
473 if (proc_open(tcpchild, 2) < 0)
479 #else /* !USE_PROCFS */
483 /* defines copied from linux/sched.h since we can't include that
484 * ourselves (it conflicts with *lots* of libc includes)
486 #define CSIGNAL 0x000000ff /* signal mask to be sent at exit */
487 #define CLONE_VM 0x00000100 /* set if VM shared between processes */
488 #define CLONE_FS 0x00000200 /* set if fs info shared between processes */
489 #define CLONE_FILES 0x00000400 /* set if open files shared between processes */
490 #define CLONE_SIGHAND 0x00000800 /* set if signal handlers shared */
491 #define CLONE_IDLETASK 0x00001000 /* kernel-only flag */
492 #define CLONE_PTRACE 0x00002000 /* set if we want to let tracing continue on the child too */
493 #define CLONE_VFORK 0x00004000 /* set if the parent wants the child to wake it up on mm_release */
494 #define CLONE_PARENT 0x00008000 /* set if we want to have the same parent as the cloner */
495 #define CLONE_THREAD 0x00010000 /* Same thread group? */
496 #define CLONE_NEWNS 0x00020000 /* New namespace group? */
497 #define CLONE_SYSVSEM 0x00040000 /* share system V SEM_UNDO semantics */
498 #define CLONE_SETTLS 0x00080000 /* create a new TLS for the child */
499 #define CLONE_PARENT_SETTID 0x00100000 /* set the TID in the parent */
500 #define CLONE_CHILD_CLEARTID 0x00200000 /* clear the TID in the child */
501 #define CLONE_DETACHED 0x00400000 /* parent wants no child-exit signal */
502 #define CLONE_UNTRACED 0x00800000 /* set if the tracing process can't force CLONE_PTRACE on this clone */
503 #define CLONE_CHILD_SETTID 0x01000000 /* set the TID in the child */
505 static struct xlat clone_flags[] = {
506 { CLONE_VM, "CLONE_VM" },
507 { CLONE_FS, "CLONE_FS" },
508 { CLONE_FILES, "CLONE_FILES" },
509 { CLONE_SIGHAND, "CLONE_SIGHAND" },
510 { CLONE_IDLETASK, "CLONE_IDLETASK"},
511 { CLONE_PTRACE, "CLONE_PTRACE" },
512 { CLONE_VFORK, "CLONE_VFORK" },
513 { CLONE_PARENT, "CLONE_PARENT" },
514 { CLONE_THREAD, "CLONE_THREAD" },
515 { CLONE_NEWNS, "CLONE_NEWNS" },
516 { CLONE_SYSVSEM, "CLONE_SYSVSEM" },
517 { CLONE_SETTLS, "CLONE_SETTLS" },
518 { CLONE_PARENT_SETTID,"CLONE_PARENT_SETTID" },
519 { CLONE_CHILD_CLEARTID,"CLONE_CHILD_CLEARTID" },
520 { CLONE_DETACHED, "CLONE_DETACHED" },
521 { CLONE_UNTRACED, "CLONE_UNTRACED" },
522 { CLONE_CHILD_SETTID,"CLONE_CHILD_SETTID" },
527 # include <asm/ldt.h>
528 extern void print_ldt_entry();
534 # define ARG_STACKSIZE (tcp->scno == SYS_clone2 ? 2 : -1)
535 # define ARG_PTID (tcp->scno == SYS_clone2 ? 3 : 2)
536 # define ARG_CTID (tcp->scno == SYS_clone2 ? 4 : 3)
537 # define ARG_TLS (tcp->scno == SYS_clone2 ? 5 : 4)
538 # elif defined S390 || defined S390X
544 # elif defined X86_64
563 unsigned long flags = tcp->u_arg[ARG_FLAGS];
564 tprintf("child_stack=%#lx, ", tcp->u_arg[ARG_STACK]);
565 # ifdef ARG_STACKSIZE
566 if (ARG_STACKSIZE != -1)
567 tprintf("stack_size=%#lx, ",
568 tcp->u_arg[ARG_STACKSIZE]);
571 if (printflags(clone_flags, flags &~ CSIGNAL) == 0)
573 if ((flags & CSIGNAL) != 0)
574 tprintf("|%s", signame(flags & CSIGNAL));
575 if ((flags & (CLONE_PARENT_SETTID|CLONE_CHILD_SETTID
576 |CLONE_CHILD_CLEARTID|CLONE_SETTLS)) == 0)
578 if (flags & CLONE_PARENT_SETTID)
579 tprintf(", parent_tidptr=%#lx", tcp->u_arg[ARG_PTID]);
580 if (flags & CLONE_SETTLS) {
582 struct modify_ldt_ldt_s copy;
583 if (umove(tcp, tcp->u_arg[ARG_TLS], ©) != -1) {
584 tprintf(", {entry_number:%d, ",
589 print_ldt_entry(©);
593 tprintf(", tls=%#lx", tcp->u_arg[ARG_TLS]);
595 if (flags & (CLONE_CHILD_SETTID|CLONE_CHILD_CLEARTID))
596 tprintf(", child_tidptr=%#lx", tcp->u_arg[ARG_CTID]);
607 return RVAL_UDECIMAL;
612 change_syscall(tcp, new)
618 /* Attempt to make vfork into fork, which we can follow. */
619 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(ORIG_EAX * 4), new) < 0)
622 #elif defined(X86_64)
623 /* Attempt to make vfork into fork, which we can follow. */
624 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(ORIG_RAX * 8), new) < 0)
627 #elif defined(POWERPC)
628 if (ptrace(PTRACE_POKEUSER, tcp->pid,
629 (char*)(sizeof(unsigned long)*PT_R0), new) < 0)
632 #elif defined(S390) || defined(S390X)
633 /* s390 linux after 2.4.7 has a hook in entry.S to allow this */
634 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_GPR2), new)<0)
638 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*PT_ORIG_D0), new)<0)
643 if (ptrace(PTRACE_GETREGS, tcp->pid, (char*)®s, 0)<0)
646 if (ptrace(PTRACE_SETREGS, tcp->pid, (char*)®s, 0)<0)
650 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_V0), new)<0)
654 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_A3), new)<0)
658 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_R15), new)<0)
662 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_GR20), new)<0)
666 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*(REG_REG0+3)), new)<0)
670 /* Top half of reg encodes the no. of args n as 0x1n.
671 Assume 0 args as kernel never actually checks... */
672 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_SYSCALL),
677 #warning Do not know how to handle change_syscall for this architecture
678 #endif /* architecture */
690 unsigned long *bsp, *ap;
692 if (upeek(tcp->pid, PT_AR_BSP, (long *) &bsp) , 0)
695 ap = ia64_rse_skip_regs(bsp, argnum);
697 ptrace(PTRACE_POKEDATA, tcp->pid, (char *) ap, tcp->u_arg[argnum]);
704 ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*argnum), tcp->u_arg[argnum]);
708 #elif defined(X86_64)
710 ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(8*(long)argnum), tcp->u_arg[argnum]);
714 #elif defined(POWERPC)
716 #define PT_ORIG_R3 34
719 ptrace(PTRACE_POKEUSER, tcp->pid,
720 (char*)((argnum==0 ? PT_ORIG_R3 : argnum+PT_R3)*sizeof(unsigned long)),
729 ptrace(PTRACE_POKEUSER, tcp->pid,
730 (char*)(REG_A0 + argnum), tcp->u_arg[argnum]);
734 if (upeek(tcp->pid, REG_SP, (long *) &sp) , 0)
737 ptrace(PTRACE_POKEDATA, tcp->pid,
738 (char*)(sp + argnum - 4), tcp->u_arg[argnum]);
743 #elif defined(S390) || defined(S390X)
746 ptrace(PTRACE_POKEUSER, tcp->pid,
747 (char *) (argnum==0 ? PT_ORIGGPR2 :
748 PT_GPR2 + argnum*sizeof(long)),
756 # warning Sorry, setargs not implemented for this architecture.
761 #if defined SYS_clone || defined SYS_clone2
766 struct tcb *tcpchild;
776 int bpt = tcp->flags & TCB_BPTSET;
778 if (!(tcp->flags & TCB_FOLLOWFORK))
789 #ifdef CLONE_PTRACE /* See new setbpt code. */
790 tcpchild = pid2tcb(pid);
791 if (tcpchild != NULL) {
792 /* The child already reported its startup trap
793 before the parent reported its syscall return. */
795 & (TCB_STARTUP|TCB_ATTACHED|TCB_SUSPENDED))
796 != (TCB_STARTUP|TCB_ATTACHED|TCB_SUSPENDED))
798 [preattached child %d of %d in weird state!]\n",
803 if ((tcpchild = alloctcb(pid)) == NULL) {
806 fprintf(stderr, " [tcb table full]\n");
807 kill(pid, SIGKILL); /* XXX */
812 /* Attach to the new child */
813 if (ptrace(PTRACE_ATTACH, pid, (char *) 1, 0) < 0) {
816 perror("PTRACE_ATTACH");
817 fprintf(stderr, "Too late?\n");
826 tcpchild->flags |= TCB_ATTACHED;
827 /* Child has BPT too, must be removed on first occasion. */
829 tcpchild->flags |= TCB_BPTSET;
830 tcpchild->baddr = tcp->baddr;
831 memcpy(tcpchild->inst, tcp->inst,
832 sizeof tcpchild->inst);
834 tcpchild->parent = tcp;
836 if (tcpchild->flags & TCB_SUSPENDED) {
837 /* The child was born suspended, due to our having
838 forced CLONE_PTRACE. */
842 tcpchild->flags &= ~(TCB_SUSPENDED|TCB_STARTUP);
843 if (ptrace(PTRACE_SYSCALL, pid, (char *) 1, 0) < 0) {
844 perror("resume: ptrace(PTRACE_SYSCALL, ...)");
850 Process %u resumed (parent %d ready)\n",
856 fprintf(stderr, "Process %d attached\n", pid);
859 #ifdef TCB_CLONE_THREAD
862 * Save the flags used in this call,
863 * in case we point TCP to our parent below.
865 int call_flags = tcp->u_arg[ARG_FLAGS];
866 if ((tcp->flags & TCB_CLONE_THREAD) &&
867 tcp->parent != NULL) {
868 /* The parent in this clone is itself a
869 thread belonging to another process.
870 There is no meaning to the parentage
871 relationship of the new child with the
872 thread, only with the process. We
873 associate the new thread with our
874 parent. Since this is done for every
875 new thread, there will never be a
876 TCB_CLONE_THREAD process that has
880 tcpchild->parent = tcp;
883 if (call_flags & CLONE_THREAD) {
884 tcpchild->flags |= TCB_CLONE_THREAD;
885 ++tcp->nclone_threads;
887 if (call_flags & CLONE_DETACHED) {
888 tcpchild->flags |= TCB_CLONE_DETACHED;
889 ++tcp->nclone_detached;
904 /* We do special magic with clone for any clone or fork. */
905 return internal_clone(tcp);
908 struct tcb *tcpchild;
913 if (tcp->scno == SYS_vfork) {
914 /* Attempt to make vfork into fork, which we can follow. */
916 change_syscall(tcp, SYS_fork) < 0)
921 if (!followfork || dont_follow)
929 int bpt = tcp->flags & TCB_BPTSET;
931 if (!(tcp->flags & TCB_FOLLOWFORK))
940 if ((tcpchild = alloctcb(pid)) == NULL) {
941 fprintf(stderr, " [tcb table full]\n");
942 kill(pid, SIGKILL); /* XXX */
947 /* The child must have run before it can be attached. */
948 /* This must be a bug in the parisc kernel, but I havn't
949 * identified it yet. Seems to be an issue associated
950 * with attaching to a process (which sends it a signal)
951 * before that process has ever been scheduled. When
952 * debugging, I started seeing crashes in
953 * arch/parisc/kernel/signal.c:do_signal(), apparently
954 * caused by r8 getting corrupt over the dequeue_signal()
955 * call. Didn't make much sense though...
961 select(0, NULL, NULL, NULL, &tv);
964 if (ptrace(PTRACE_ATTACH, pid, (char *) 1, 0) < 0) {
965 perror("PTRACE_ATTACH");
966 fprintf(stderr, "Too late?\n");
973 /* The child must have run before it can be attached. */
978 select(0, NULL, NULL, NULL, &tv);
980 if (ptrace(PTRACE_ATTACH, pid, (char *)1, 0) < 0) {
981 perror("PTRACE_ATTACH");
982 fprintf(stderr, "Too late?\n");
987 /* Try to catch the new process as soon as possible. */
990 for (i = 0; i < 1024; i++)
991 if (ptrace(PTRACE_ATTACH, pid, (char *) 1, 0) >= 0)
994 perror("PTRACE_ATTACH");
995 fprintf(stderr, "Too late?\n");
1000 #endif /* !oldway */
1002 tcpchild->flags |= TCB_ATTACHED;
1003 /* Child has BPT too, must be removed on first occasion */
1005 tcpchild->flags |= TCB_BPTSET;
1006 tcpchild->baddr = tcp->baddr;
1007 memcpy(tcpchild->inst, tcp->inst,
1008 sizeof tcpchild->inst);
1011 tcpchild->parent = tcp;
1014 fprintf(stderr, "Process %d attached\n", pid);
1020 #endif /* !USE_PROCFS */
1022 #if defined(SUNOS4) || defined(LINUX) || defined(FREEBSD)
1029 return RVAL_UDECIMAL;
1033 #endif /* SUNOS4 || LINUX || FREEBSD */
1037 static char idstr[16];
1044 sprintf(idstr, "ppid %lu", getrval2(tcp));
1045 tcp->auxstr = idstr;
1056 sprintf(idstr, "euid %lu", getrval2(tcp));
1057 tcp->auxstr = idstr;
1068 sprintf(idstr, "egid %lu", getrval2(tcp));
1069 tcp->auxstr = idstr;
1083 if (entering(tcp)) {
1084 tprintf("%u", (uid_t) tcp->u_arg[0]);
1093 if (entering(tcp)) {
1094 tprintf("%u", (gid_t) tcp->u_arg[0]);
1106 tprintf("%#lx, %#lx, %#lx", tcp->u_arg[0],
1107 tcp->u_arg[1], tcp->u_arg[2]);
1109 if (umove(tcp, tcp->u_arg[0], &uid) < 0)
1110 tprintf("%#lx, ", tcp->u_arg[0]);
1112 tprintf("ruid %lu, ", (unsigned long) uid);
1113 if (umove(tcp, tcp->u_arg[1], &uid) < 0)
1114 tprintf("%#lx, ", tcp->u_arg[1]);
1116 tprintf("euid %lu, ", (unsigned long) uid);
1117 if (umove(tcp, tcp->u_arg[2], &uid) < 0)
1118 tprintf("%#lx", tcp->u_arg[2]);
1120 tprintf("suid %lu", (unsigned long) uid);
1133 tprintf("%#lx, %#lx, %#lx", tcp->u_arg[0],
1134 tcp->u_arg[1], tcp->u_arg[2]);
1136 if (umove(tcp, tcp->u_arg[0], &gid) < 0)
1137 tprintf("%#lx, ", tcp->u_arg[0]);
1139 tprintf("rgid %lu, ", (unsigned long) gid);
1140 if (umove(tcp, tcp->u_arg[1], &gid) < 0)
1141 tprintf("%#lx, ", tcp->u_arg[1]);
1143 tprintf("egid %lu, ", (unsigned long) gid);
1144 if (umove(tcp, tcp->u_arg[2], &gid) < 0)
1145 tprintf("%#lx", tcp->u_arg[2]);
1147 tprintf("sgid %lu", (unsigned long) gid);
1159 if (entering(tcp)) {
1161 (unsigned long) (uid_t) tcp->u_arg[0],
1162 (unsigned long) (uid_t) tcp->u_arg[1]);
1171 if (entering(tcp)) {
1173 (unsigned long) (gid_t) tcp->u_arg[0],
1174 (unsigned long) (gid_t) tcp->u_arg[1]);
1179 #if defined(LINUX) || defined(FREEBSD)
1184 if (entering(tcp)) {
1185 tprintf("ruid %u, euid %u, suid %u",
1186 (uid_t) tcp->u_arg[0],
1187 (uid_t) tcp->u_arg[1],
1188 (uid_t) tcp->u_arg[2]);
1196 if (entering(tcp)) {
1197 tprintf("rgid %u, egid %u, sgid %u",
1198 (uid_t) tcp->u_arg[0],
1199 (uid_t) tcp->u_arg[1],
1200 (uid_t) tcp->u_arg[2]);
1205 #endif /* LINUX || FREEBSD */
1212 GETGROUPS_T *gidset;
1214 if (entering(tcp)) {
1215 len = tcp->u_arg[0];
1216 tprintf("%u, ", len);
1221 gidset = (GETGROUPS_T *) malloc(len * sizeof(GETGROUPS_T));
1222 if (gidset == NULL) {
1223 fprintf(stderr, "sys_setgroups: out of memory\n");
1227 tprintf("%#lx", tcp->u_arg[1]);
1228 else if (umoven(tcp, tcp->u_arg[1],
1229 len * sizeof(GETGROUPS_T), (char *) gidset) < 0)
1233 for (i = 0; i < len; i++)
1234 tprintf("%s%lu", i ? ", " : "",
1235 (unsigned long) gidset[i]);
1238 free((char *) gidset);
1248 GETGROUPS_T *gidset;
1250 if (entering(tcp)) {
1251 len = tcp->u_arg[0];
1252 tprintf("%u, ", len);
1259 gidset = (GETGROUPS_T *) malloc(len * sizeof(GETGROUPS_T));
1260 if (gidset == NULL) {
1261 fprintf(stderr, "sys_getgroups: out of memory\n");
1266 else if (!verbose(tcp) || tcp->u_arg[0] == 0)
1267 tprintf("%#lx", tcp->u_arg[1]);
1268 else if (umoven(tcp, tcp->u_arg[1],
1269 len * sizeof(GETGROUPS_T), (char *) gidset) < 0)
1273 for (i = 0; i < len; i++)
1274 tprintf("%s%lu", i ? ", " : "",
1275 (unsigned long) gidset[i]);
1278 free((char *)gidset);
1287 if (entering(tcp)) {
1289 tprintf("%lu, %lu", tcp->u_arg[0], tcp->u_arg[1]);
1299 if (entering(tcp)) {
1301 tprintf("%lu", tcp->u_arg[0]);
1311 if (entering(tcp)) {
1312 tprintf("%lu", tcp->u_arg[0]);
1328 if (entering(tcp)) {
1329 tprintf("%lu", tcp->u_arg[0]);
1338 if (entering(tcp)) {
1339 tprintf("%lu, %lu", tcp->u_arg[0], tcp->u_arg[1]);
1346 #include <sys/privilege.h>
1349 static struct xlat procpriv_cmds [] = {
1350 { SETPRV, "SETPRV" },
1351 { CLRPRV, "CLRPRV" },
1352 { PUTPRV, "PUTPRV" },
1353 { GETPRV, "GETPRV" },
1354 { CNTPRV, "CNTPRV" },
1359 static struct xlat procpriv_priv [] = {
1360 { P_OWNER, "P_OWNER" },
1361 { P_AUDIT, "P_AUDIT" },
1362 { P_COMPAT, "P_COMPAT" },
1363 { P_DACREAD, "P_DACREAD" },
1364 { P_DACWRITE, "P_DACWRITE" },
1366 { P_FILESYS, "P_FILESYS" },
1367 { P_MACREAD, "P_MACREAD" },
1368 { P_MACWRITE, "P_MACWRITE" },
1369 { P_MOUNT, "P_MOUNT" },
1370 { P_MULTIDIR, "P_MULTIDIR" },
1371 { P_SETPLEVEL, "P_SETPLEVEL" },
1372 { P_SETSPRIV, "P_SETSPRIV" },
1373 { P_SETUID, "P_SETUID" },
1374 { P_SYSOPS, "P_SYSOPS" },
1375 { P_SETUPRIV, "P_SETUPRIV" },
1376 { P_DRIVER, "P_DRIVER" },
1377 { P_RTIME, "P_RTIME" },
1378 { P_MACUPGRADE, "P_MACUPGRADE" },
1379 { P_FSYSRANGE, "P_FSYSRANGE" },
1380 { P_SETFLEVEL, "P_SETFLEVEL" },
1381 { P_AUDITWR, "P_AUDITWR" },
1382 { P_TSHAR, "P_TSHAR" },
1383 { P_PLOCK, "P_PLOCK" },
1384 { P_CORE, "P_CORE" },
1385 { P_LOADMOD, "P_LOADMOD" },
1386 { P_BIND, "P_BIND" },
1387 { P_ALLPRIVS, "P_ALLPRIVS" },
1392 static struct xlat procpriv_type [] = {
1393 { PS_FIX, "PS_FIX" },
1394 { PS_INH, "PS_INH" },
1395 { PS_MAX, "PS_MAX" },
1396 { PS_WKG, "PS_WKG" },
1402 printpriv(tcp, addr, len, opt)
1409 int max = verbose (tcp) ? sizeof buf / sizeof buf [0] : 10;
1410 int dots = len > max;
1413 if (len > max) len = max;
1416 umoven (tcp, addr, len * sizeof buf[0], (char *) buf) < 0)
1418 tprintf ("%#lx", addr);
1424 for (i = 0; i < len; ++i) {
1427 if (i) tprintf (", ");
1429 if ((t = xlookup (procpriv_type, buf [i] & PS_TYPE)) &&
1430 (p = xlookup (procpriv_priv, buf [i] & ~PS_TYPE)))
1432 tprintf ("%s|%s", t, p);
1435 tprintf ("%#lx", buf [i]);
1439 if (dots) tprintf (" ...");
1449 if (entering(tcp)) {
1450 printxval(procpriv_cmds, tcp->u_arg[0], "???PRV");
1451 switch (tcp->u_arg[0]) {
1453 tprintf(", %#lx, %ld", tcp->u_arg[1], tcp->u_arg[2]);
1461 printpriv (tcp, tcp->u_arg[1], tcp->u_arg[2]);
1462 tprintf (", %ld", tcp->u_arg[2]);
1465 else if (tcp->u_arg[0] == GETPRV) {
1466 if (syserror (tcp)) {
1467 tprintf(", %#lx, %ld", tcp->u_arg[1], tcp->u_arg[2]);
1471 printpriv (tcp, tcp->u_arg[1], tcp->u_rval);
1472 tprintf (", %ld", tcp->u_arg[2]);
1483 fake_execve(tcp, program, argv, envp)
1492 if (!(qual_flags[SYS_execve - __NR_SYSCALL_BASE] & QUAL_TRACE))
1495 if (!(qual_flags[SYS_execve] & QUAL_TRACE))
1500 string_quote(program);
1502 for (i = 0; argv[i] != NULL; i++) {
1505 string_quote(argv[i]);
1507 for (i = 0; envp[i] != NULL; i++)
1509 tprintf("], [/* %d var%s */]) ", i, (i != 1) ? "s" : "");
1516 printargv(tcp, addr)
1522 int max = max_strlen / 2;
1524 for (sep = ""; --max >= 0; sep = ", ") {
1527 if (umove(tcp, addr, &cp) < 0) {
1528 tprintf("%#lx", addr);
1534 printstr(tcp, (long) cp, -1);
1535 addr += sizeof(char *);
1542 printargc(fmt, tcp, addr)
1550 for (count = 0; umove(tcp, addr, &cp) >= 0 && cp != NULL; count++) {
1551 addr += sizeof(char *);
1553 tprintf(fmt, count, count == 1 ? "" : "s");
1560 if (entering(tcp)) {
1561 printpath(tcp, tcp->u_arg[0]);
1563 tprintf(", %#lx", tcp->u_arg[1]);
1565 else if (abbrev(tcp))
1566 printargc(", [/* %d arg%s */]", tcp, tcp->u_arg[1]);
1570 printargv(tcp, tcp->u_arg[1]);
1581 if (entering(tcp)) {
1582 printpath(tcp, tcp->u_arg[0]);
1584 tprintf(", %#lx", tcp->u_arg[1]);
1586 else if (abbrev(tcp))
1587 printargc(", [/* %d arg%s */]", tcp, tcp->u_arg[1]);
1591 printargv(tcp, tcp->u_arg[1]);
1595 tprintf(", %#lx", tcp->u_arg[2]);
1596 else if (abbrev(tcp))
1597 printargc(", [/* %d var%s */]", tcp, tcp->u_arg[2]);
1600 printargv(tcp, tcp->u_arg[2]);
1604 #if defined LINUX && defined TCB_WAITEXECVE
1605 tcp->flags |= TCB_WAITEXECVE;
1606 #endif /* LINUX && TCB_WAITEXECVE */
1612 int sys_rexecve(tcp)
1615 if (entering (tcp)) {
1617 tprintf (", %ld", tcp->u_arg[3]);
1629 if (exiting(tcp) && !syserror(tcp) && followfork)
1637 #define __WNOTHREAD 0x20000000
1640 #define __WALL 0x40000000
1643 #define __WCLONE 0x80000000
1647 static struct xlat wait4_options[] = {
1648 { WNOHANG, "WNOHANG" },
1650 { WUNTRACED, "WUNTRACED" },
1653 { WEXITED, "WEXITED" },
1656 { WTRAPPED, "WTRAPPED" },
1659 { WSTOPPED, "WSTOPPED" },
1662 { WCONTINUED, "WCONTINUED" },
1665 { WNOWAIT, "WNOWAIT" },
1668 { __WCLONE, "__WCLONE" },
1671 { __WALL, "__WALL" },
1674 { __WNOTHREAD, "__WNOTHREAD" },
1686 * Here is a tricky presentation problem. This solution
1687 * is still not entirely satisfactory but since there
1688 * are no wait status constructors it will have to do.
1690 if (WIFSTOPPED(status))
1691 tprintf("[WIFSTOPPED(s) && WSTOPSIG(s) == %s]",
1692 signame(WSTOPSIG(status)));
1693 else if WIFSIGNALED(status)
1694 tprintf("[WIFSIGNALED(s) && WTERMSIG(s) == %s%s]",
1695 signame(WTERMSIG(status)),
1696 WCOREDUMP(status) ? " && WCOREDUMP(s)" : "");
1697 else if WIFEXITED(status) {
1698 tprintf("[WIFEXITED(s) && WEXITSTATUS(s) == %d]",
1699 WEXITSTATUS(status));
1703 tprintf("[%#x]", status);
1708 printwaitn(tcp, n, bitness)
1716 if (entering(tcp)) {
1717 tprintf("%ld, ", tcp->u_arg[0]);
1722 else if (syserror(tcp) || tcp->u_rval == 0)
1723 tprintf("%#lx", tcp->u_arg[1]);
1724 else if (umove(tcp, tcp->u_arg[1], &status) < 0)
1727 exited = printstatus(status);
1730 if (!printflags(wait4_options, tcp->u_arg[2]))
1738 else if (tcp->u_rval > 0) {
1741 printrusage32(tcp, tcp->u_arg[3]);
1744 printrusage(tcp, tcp->u_arg[3]);
1748 else if (tcp->u_rval > 0 && exited)
1749 printrusage(tcp, tcp->u_arg[3]);
1752 tprintf("%#lx", tcp->u_arg[3]);
1764 #ifdef TCB_CLONE_THREAD
1765 if (tcp->flags & TCB_CLONE_THREAD)
1766 /* The children we wait for are our parent's children. */
1767 got_kids = (tcp->parent->nchildren
1768 > tcp->parent->nclone_detached);
1770 got_kids = (tcp->nchildren > tcp->nclone_detached);
1772 got_kids = tcp->nchildren > 0;
1775 if (entering(tcp) && got_kids) {
1776 /* There are children that this parent should block for.
1777 But ptrace made us the parent of the traced children
1778 and the real parent will get ECHILD from the wait call.
1780 XXX If we attached with strace -f -p PID, then there
1781 may be untraced dead children the parent could be reaping
1782 now, but we make him block. */
1784 /* ??? WTA: fix bug with hanging children */
1786 if (!(tcp->u_arg[2] & WNOHANG)) {
1788 * There are traced children. We'll make the parent
1789 * block to avoid a false ECHILD error due to our
1790 * ptrace having stolen the children. However,
1791 * we shouldn't block if there are zombies to reap.
1792 * XXX doesn't handle pgrp matches (u_arg[0]==0,<-1)
1794 if (tcp->nzombies > 0 &&
1795 (tcp->u_arg[0] == -1 ||
1796 pid2tcb(tcp->u_arg[0]) == NULL))
1798 tcp->flags |= TCB_SUSPENDED;
1799 tcp->waitpid = tcp->u_arg[0];
1800 #ifdef TCB_CLONE_THREAD
1801 if (tcp->flags & TCB_CLONE_THREAD)
1802 tcp->parent->nclone_waiting++;
1806 if (exiting(tcp) && tcp->u_error == ECHILD && got_kids) {
1807 if (tcp->u_arg[2] & WNOHANG) {
1808 /* We must force a fake result of 0 instead of
1809 the ECHILD error. */
1810 extern int force_result();
1811 return force_result(tcp, 0, 0);
1815 "internal_wait: should not have resumed %d\n",
1818 else if (exiting(tcp) && tcp->u_error == 0 && tcp->u_rval > 0 &&
1819 tcp->nzombies > 0 && pid2tcb(tcp->u_rval) == NULL) {
1821 * We just reaped a child we don't know about,
1822 * presumably a zombie we already droptcb'd.
1836 /* The library wrapper stuffs this into the user variable. */
1838 printstatus(getrval2(tcp));
1853 if (!syserror(tcp)) {
1854 if (umove(tcp, tcp->u_arg[0], &status) < 0)
1855 tprintf("%#lx", tcp->u_arg[0]);
1857 printstatus(status);
1868 return printwaitn(tcp, 3, 0);
1875 return printwaitn(tcp, 4, 0);
1883 return printwaitn(tcp, 4, 1);
1889 static struct xlat waitid_types[] = {
1891 { P_PPID, "P_PPID" },
1892 { P_PGID, "P_PGID" },
1899 { P_LWPID, "P_LWPID" },
1911 if (entering(tcp)) {
1912 printxval(waitid_types, tcp->u_arg[0], "P_???");
1913 tprintf(", %ld, ", tcp->u_arg[1]);
1914 if (tcp->nchildren > 0) {
1915 /* There are traced children */
1916 tcp->flags |= TCB_SUSPENDED;
1917 tcp->waitpid = tcp->u_arg[0];
1925 else if (syserror(tcp))
1926 tprintf("%#lx", tcp->u_arg[2]);
1927 else if (umove(tcp, tcp->u_arg[2], &si) < 0)
1930 printsiginfo(&si, verbose (tcp));
1933 if (!printflags(wait4_options, tcp->u_arg[3]))
1946 tprintf("%lu", tcp->u_arg[0]);
1954 struct utsname uname;
1957 if (syserror(tcp) || !verbose(tcp))
1958 tprintf("%#lx", tcp->u_arg[0]);
1959 else if (umove(tcp, tcp->u_arg[0], &uname) < 0)
1961 else if (!abbrev(tcp)) {
1963 tprintf("{sysname=\"%s\", nodename=\"%s\", ",
1964 uname.sysname, uname.nodename);
1965 tprintf("release=\"%s\", version=\"%s\", ",
1966 uname.release, uname.version);
1967 tprintf("machine=\"%s\"", uname.machine);
1970 tprintf(", domainname=\"%s\"", uname.domainname);
1971 #endif /* __GLIBC__ */
1976 tprintf("{sys=\"%s\", node=\"%s\", ...}",
1977 uname.sysname, uname.nodename);
1984 static struct xlat ptrace_cmds[] = {
1986 { PTRACE_TRACEME, "PTRACE_TRACEME" },
1987 { PTRACE_PEEKTEXT, "PTRACE_PEEKTEXT", },
1988 { PTRACE_PEEKDATA, "PTRACE_PEEKDATA", },
1989 { PTRACE_PEEKUSER, "PTRACE_PEEKUSER", },
1990 { PTRACE_POKETEXT, "PTRACE_POKETEXT", },
1991 { PTRACE_POKEDATA, "PTRACE_POKEDATA", },
1992 { PTRACE_POKEUSER, "PTRACE_POKEUSER", },
1993 { PTRACE_CONT, "PTRACE_CONT" },
1994 { PTRACE_KILL, "PTRACE_KILL" },
1995 { PTRACE_SINGLESTEP, "PTRACE_SINGLESTEP" },
1996 { PTRACE_ATTACH, "PTRACE_ATTACH" },
1997 { PTRACE_DETACH, "PTRACE_DETACH" },
1998 #ifdef PTRACE_GETREGS
1999 { PTRACE_GETREGS, "PTRACE_GETREGS" },
2001 #ifdef PTRACE_SETREGS
2002 { PTRACE_SETREGS, "PTRACE_SETREGS" },
2004 #ifdef PTRACE_GETFPREGS
2005 { PTRACE_GETFPREGS, "PTRACE_GETFPREGS", },
2007 #ifdef PTRACE_SETFPREGS
2008 { PTRACE_SETFPREGS, "PTRACE_SETFPREGS", },
2010 #ifdef PTRACE_GETFPXREGS
2011 { PTRACE_GETFPXREGS, "PTRACE_GETFPXREGS", },
2013 #ifdef PTRACE_SETFPXREGS
2014 { PTRACE_SETFPXREGS, "PTRACE_SETFPXREGS", },
2017 { PTRACE_READDATA, "PTRACE_READDATA" },
2018 { PTRACE_WRITEDATA, "PTRACE_WRITEDATA" },
2019 { PTRACE_READTEXT, "PTRACE_READTEXT" },
2020 { PTRACE_WRITETEXT, "PTRACE_WRITETEXT" },
2021 { PTRACE_GETFPAREGS, "PTRACE_GETFPAREGS" },
2022 { PTRACE_SETFPAREGS, "PTRACE_SETFPAREGS" },
2024 { PTRACE_GETWINDOW, "PTRACE_GETWINDOW" },
2025 { PTRACE_SETWINDOW, "PTRACE_SETWINDOW" },
2027 { PTRACE_22, "PTRACE_PTRACE_22" },
2028 { PTRACE_23, "PTRACE_PTRACE_23" },
2031 { PTRACE_SYSCALL, "PTRACE_SYSCALL" },
2033 { PTRACE_DUMPCORE, "PTRACE_DUMPCORE" },
2035 { PTRACE_SETWRBKPT, "PTRACE_SETWRBKPT" },
2036 { PTRACE_SETACBKPT, "PTRACE_SETACBKPT" },
2037 { PTRACE_CLRDR7, "PTRACE_CLRDR7" },
2039 { PTRACE_26, "PTRACE_26" },
2040 { PTRACE_27, "PTRACE_27" },
2041 { PTRACE_28, "PTRACE_28" },
2043 { PTRACE_GETUCODE, "PTRACE_GETUCODE" },
2046 { PT_TRACE_ME, "PT_TRACE_ME" },
2047 { PT_READ_I, "PT_READ_I" },
2048 { PT_READ_D, "PT_READ_D" },
2049 { PT_WRITE_I, "PT_WRITE_I" },
2050 { PT_WRITE_D, "PT_WRITE_D" },
2052 { PT_READ_U, "PT_READ_U" },
2054 { PT_CONTINUE, "PT_CONTINUE" },
2055 { PT_KILL, "PT_KILL" },
2056 { PT_STEP, "PT_STEP" },
2057 { PT_ATTACH, "PT_ATTACH" },
2058 { PT_DETACH, "PT_DETACH" },
2059 { PT_GETREGS, "PT_GETREGS" },
2060 { PT_SETREGS, "PT_SETREGS" },
2061 { PT_GETFPREGS, "PT_GETFPREGS" },
2062 { PT_SETFPREGS, "PT_SETFPREGS" },
2063 { PT_GETDBREGS, "PT_GETDBREGS" },
2064 { PT_SETDBREGS, "PT_SETDBREGS" },
2065 #endif /* FREEBSD */
2070 #ifndef SUNOS4_KERNEL_ARCH_KLUDGE
2072 #endif /* !SUNOS4_KERNEL_ARCH_KLUDGE */
2073 struct xlat struct_user_offsets[] = {
2075 #if defined(S390) || defined(S390X)
2076 { PT_PSWMASK, "psw_mask" },
2077 { PT_PSWADDR, "psw_addr" },
2078 { PT_GPR0, "gpr0" },
2079 { PT_GPR1, "gpr1" },
2080 { PT_GPR2, "gpr2" },
2081 { PT_GPR3, "gpr3" },
2082 { PT_GPR4, "gpr4" },
2083 { PT_GPR5, "gpr5" },
2084 { PT_GPR6, "gpr6" },
2085 { PT_GPR7, "gpr7" },
2086 { PT_GPR8, "gpr8" },
2087 { PT_GPR9, "gpr9" },
2088 { PT_GPR10, "gpr10" },
2089 { PT_GPR11, "gpr11" },
2090 { PT_GPR12, "gpr12" },
2091 { PT_GPR13, "gpr13" },
2092 { PT_GPR14, "gpr14" },
2093 { PT_GPR15, "gpr15" },
2094 { PT_ACR0, "acr0" },
2095 { PT_ACR1, "acr1" },
2096 { PT_ACR2, "acr2" },
2097 { PT_ACR3, "acr3" },
2098 { PT_ACR4, "acr4" },
2099 { PT_ACR5, "acr5" },
2100 { PT_ACR6, "acr6" },
2101 { PT_ACR7, "acr7" },
2102 { PT_ACR8, "acr8" },
2103 { PT_ACR9, "acr9" },
2104 { PT_ACR10, "acr10" },
2105 { PT_ACR11, "acr11" },
2106 { PT_ACR12, "acr12" },
2107 { PT_ACR13, "acr13" },
2108 { PT_ACR14, "acr14" },
2109 { PT_ACR15, "acr15" },
2110 { PT_ORIGGPR2, "orig_gpr2" },
2113 { PT_FPR0_HI, "fpr0.hi" },
2114 { PT_FPR0_LO, "fpr0.lo" },
2115 { PT_FPR1_HI, "fpr1.hi" },
2116 { PT_FPR1_LO, "fpr1.lo" },
2117 { PT_FPR2_HI, "fpr2.hi" },
2118 { PT_FPR2_LO, "fpr2.lo" },
2119 { PT_FPR3_HI, "fpr3.hi" },
2120 { PT_FPR3_LO, "fpr3.lo" },
2121 { PT_FPR4_HI, "fpr4.hi" },
2122 { PT_FPR4_LO, "fpr4.lo" },
2123 { PT_FPR5_HI, "fpr5.hi" },
2124 { PT_FPR5_LO, "fpr5.lo" },
2125 { PT_FPR6_HI, "fpr6.hi" },
2126 { PT_FPR6_LO, "fpr6.lo" },
2127 { PT_FPR7_HI, "fpr7.hi" },
2128 { PT_FPR7_LO, "fpr7.lo" },
2129 { PT_FPR8_HI, "fpr8.hi" },
2130 { PT_FPR8_LO, "fpr8.lo" },
2131 { PT_FPR9_HI, "fpr9.hi" },
2132 { PT_FPR9_LO, "fpr9.lo" },
2133 { PT_FPR10_HI, "fpr10.hi" },
2134 { PT_FPR10_LO, "fpr10.lo" },
2135 { PT_FPR11_HI, "fpr11.hi" },
2136 { PT_FPR11_LO, "fpr11.lo" },
2137 { PT_FPR12_HI, "fpr12.hi" },
2138 { PT_FPR12_LO, "fpr12.lo" },
2139 { PT_FPR13_HI, "fpr13.hi" },
2140 { PT_FPR13_LO, "fpr13.lo" },
2141 { PT_FPR14_HI, "fpr14.hi" },
2142 { PT_FPR14_LO, "fpr14.lo" },
2143 { PT_FPR15_HI, "fpr15.hi" },
2144 { PT_FPR15_LO, "fpr15.lo" },
2147 { PT_FPR0, "fpr0" },
2148 { PT_FPR1, "fpr1" },
2149 { PT_FPR2, "fpr2" },
2150 { PT_FPR3, "fpr3" },
2151 { PT_FPR4, "fpr4" },
2152 { PT_FPR5, "fpr5" },
2153 { PT_FPR6, "fpr6" },
2154 { PT_FPR7, "fpr7" },
2155 { PT_FPR8, "fpr8" },
2156 { PT_FPR9, "fpr9" },
2157 { PT_FPR10, "fpr10" },
2158 { PT_FPR11, "fpr11" },
2159 { PT_FPR12, "fpr12" },
2160 { PT_FPR13, "fpr13" },
2161 { PT_FPR14, "fpr14" },
2162 { PT_FPR15, "fpr15" },
2165 { PT_CR_10, "cr10" },
2166 { PT_CR_11, "cr11" },
2167 { PT_IEEE_IP, "ieee_exception_ip" },
2170 /* XXX No support for these offsets yet. */
2172 /* XXX No support for these offsets yet. */
2173 #elif defined(POWERPC)
2175 #define PT_ORIG_R3 34
2177 #define REGSIZE (sizeof(unsigned long))
2178 { REGSIZE*PT_R0, "r0" },
2179 { REGSIZE*PT_R1, "r1" },
2180 { REGSIZE*PT_R2, "r2" },
2181 { REGSIZE*PT_R3, "r3" },
2182 { REGSIZE*PT_R4, "r4" },
2183 { REGSIZE*PT_R5, "r5" },
2184 { REGSIZE*PT_R6, "r6" },
2185 { REGSIZE*PT_R7, "r7" },
2186 { REGSIZE*PT_R8, "r8" },
2187 { REGSIZE*PT_R9, "r9" },
2188 { REGSIZE*PT_R10, "r10" },
2189 { REGSIZE*PT_R11, "r11" },
2190 { REGSIZE*PT_R12, "r12" },
2191 { REGSIZE*PT_R13, "r13" },
2192 { REGSIZE*PT_R14, "r14" },
2193 { REGSIZE*PT_R15, "r15" },
2194 { REGSIZE*PT_R16, "r16" },
2195 { REGSIZE*PT_R17, "r17" },
2196 { REGSIZE*PT_R18, "r18" },
2197 { REGSIZE*PT_R19, "r19" },
2198 { REGSIZE*PT_R20, "r20" },
2199 { REGSIZE*PT_R21, "r21" },
2200 { REGSIZE*PT_R22, "r22" },
2201 { REGSIZE*PT_R23, "r23" },
2202 { REGSIZE*PT_R24, "r24" },
2203 { REGSIZE*PT_R25, "r25" },
2204 { REGSIZE*PT_R26, "r26" },
2205 { REGSIZE*PT_R27, "r27" },
2206 { REGSIZE*PT_R28, "r28" },
2207 { REGSIZE*PT_R29, "r29" },
2208 { REGSIZE*PT_R30, "r30" },
2209 { REGSIZE*PT_R31, "r31" },
2210 { REGSIZE*PT_NIP, "NIP" },
2211 { REGSIZE*PT_MSR, "MSR" },
2212 { REGSIZE*PT_ORIG_R3, "ORIG_R3" },
2213 { REGSIZE*PT_CTR, "CTR" },
2214 { REGSIZE*PT_LNK, "LNK" },
2215 { REGSIZE*PT_XER, "XER" },
2216 { REGSIZE*PT_CCR, "CCR" },
2217 { REGSIZE*PT_FPR0, "FPR0" },
2288 { PT_F32, "f32" }, { PT_F33, "f33" }, { PT_F34, "f34" },
2289 { PT_F35, "f35" }, { PT_F36, "f36" }, { PT_F37, "f37" },
2290 { PT_F38, "f38" }, { PT_F39, "f39" }, { PT_F40, "f40" },
2291 { PT_F41, "f41" }, { PT_F42, "f42" }, { PT_F43, "f43" },
2292 { PT_F44, "f44" }, { PT_F45, "f45" }, { PT_F46, "f46" },
2293 { PT_F47, "f47" }, { PT_F48, "f48" }, { PT_F49, "f49" },
2294 { PT_F50, "f50" }, { PT_F51, "f51" }, { PT_F52, "f52" },
2295 { PT_F53, "f53" }, { PT_F54, "f54" }, { PT_F55, "f55" },
2296 { PT_F56, "f56" }, { PT_F57, "f57" }, { PT_F58, "f58" },
2297 { PT_F59, "f59" }, { PT_F60, "f60" }, { PT_F61, "f61" },
2298 { PT_F62, "f62" }, { PT_F63, "f63" }, { PT_F64, "f64" },
2299 { PT_F65, "f65" }, { PT_F66, "f66" }, { PT_F67, "f67" },
2300 { PT_F68, "f68" }, { PT_F69, "f69" }, { PT_F70, "f70" },
2301 { PT_F71, "f71" }, { PT_F72, "f72" }, { PT_F73, "f73" },
2302 { PT_F74, "f74" }, { PT_F75, "f75" }, { PT_F76, "f76" },
2303 { PT_F77, "f77" }, { PT_F78, "f78" }, { PT_F79, "f79" },
2304 { PT_F80, "f80" }, { PT_F81, "f81" }, { PT_F82, "f82" },
2305 { PT_F83, "f83" }, { PT_F84, "f84" }, { PT_F85, "f85" },
2306 { PT_F86, "f86" }, { PT_F87, "f87" }, { PT_F88, "f88" },
2307 { PT_F89, "f89" }, { PT_F90, "f90" }, { PT_F91, "f91" },
2308 { PT_F92, "f92" }, { PT_F93, "f93" }, { PT_F94, "f94" },
2309 { PT_F95, "f95" }, { PT_F96, "f96" }, { PT_F97, "f97" },
2310 { PT_F98, "f98" }, { PT_F99, "f99" }, { PT_F100, "f100" },
2311 { PT_F101, "f101" }, { PT_F102, "f102" }, { PT_F103, "f103" },
2312 { PT_F104, "f104" }, { PT_F105, "f105" }, { PT_F106, "f106" },
2313 { PT_F107, "f107" }, { PT_F108, "f108" }, { PT_F109, "f109" },
2314 { PT_F110, "f110" }, { PT_F111, "f111" }, { PT_F112, "f112" },
2315 { PT_F113, "f113" }, { PT_F114, "f114" }, { PT_F115, "f115" },
2316 { PT_F116, "f116" }, { PT_F117, "f117" }, { PT_F118, "f118" },
2317 { PT_F119, "f119" }, { PT_F120, "f120" }, { PT_F121, "f121" },
2318 { PT_F122, "f122" }, { PT_F123, "f123" }, { PT_F124, "f124" },
2319 { PT_F125, "f125" }, { PT_F126, "f126" }, { PT_F127, "f127" },
2321 { PT_F2, "f2" }, { PT_F3, "f3" }, { PT_F4, "f4" },
2322 { PT_F5, "f5" }, { PT_F10, "f10" }, { PT_F11, "f11" },
2323 { PT_F12, "f12" }, { PT_F13, "f13" }, { PT_F14, "f14" },
2324 { PT_F15, "f15" }, { PT_F16, "f16" }, { PT_F17, "f17" },
2325 { PT_F18, "f18" }, { PT_F19, "f19" }, { PT_F20, "f20" },
2326 { PT_F21, "f21" }, { PT_F22, "f22" }, { PT_F23, "f23" },
2327 { PT_F24, "f24" }, { PT_F25, "f25" }, { PT_F26, "f26" },
2328 { PT_F27, "f27" }, { PT_F28, "f28" }, { PT_F29, "f29" },
2329 { PT_F30, "f30" }, { PT_F31, "f31" }, { PT_R4, "r4" },
2330 { PT_R5, "r5" }, { PT_R6, "r6" }, { PT_R7, "r7" },
2332 { PT_B1, "b1" }, { PT_B2, "b2" }, { PT_B3, "b3" },
2333 { PT_B4, "b4" }, { PT_B5, "b5" },
2334 { PT_AR_PFS, "kar.pfs" },
2335 { PT_AR_LC, "ar.lc" }, { PT_AR_UNAT, "kar.unat" },
2336 { PT_AR_RNAT, "kar.rnat" }, { PT_AR_BSPSTORE, "kar.bspstore" },
2339 { PT_CR_IPSR, "cr.ipsr" }, { PT_CR_IIP, "cr.iip" },
2340 /*{ PT_CR_IFS, "cr.ifs" },*/ { PT_AR_UNAT, "ar.unat" },
2341 { PT_AR_PFS, "ar.pfs" }, { PT_AR_RSC, "ar.rsc" },
2342 { PT_AR_RNAT, "ar.rnat" }, { PT_AR_BSPSTORE, "ar.bspstore" },
2343 { PT_PR, "pr" }, { PT_B6, "b6" }, { PT_AR_BSP, "ar.bsp" },
2344 { PT_R1, "r1" }, { PT_R2, "r2" }, { PT_R3, "r3" },
2345 { PT_R12, "r12" }, { PT_R13, "r13" }, { PT_R14, "r14" },
2346 { PT_R15, "r15" }, { PT_R8, "r8" }, { PT_R9, "r9" },
2347 { PT_R10, "r10" }, { PT_R11, "r11" }, { PT_R16, "r16" },
2348 { PT_R17, "r17" }, { PT_R18, "r18" }, { PT_R19, "r19" },
2349 { PT_R20, "r20" }, { PT_R21, "r21" }, { PT_R22, "r22" },
2350 { PT_R23, "r23" }, { PT_R24, "r24" }, { PT_R25, "r25" },
2351 { PT_R26, "r26" }, { PT_R27, "r27" }, { PT_R28, "r28" },
2352 { PT_R29, "r29" }, { PT_R30, "r30" }, { PT_R31, "r31" },
2353 { PT_AR_CCV, "ar.ccv" }, { PT_AR_FPSR, "ar.fpsr" },
2354 { PT_B0, "b0" }, { PT_B7, "b7" }, { PT_F6, "f6" },
2355 { PT_F7, "f7" }, { PT_F8, "f8" }, { PT_F9, "f9" },
2369 { 4*ORIG_EAX, "4*ORIG_EAX" },
2373 { 4*UESP, "4*UESP" },
2393 { 8*ORIG_RAX, "8*ORIG_EAX" },
2396 { 8*EFLAGS, "8*EFL" },
2406 { 4*PT_D1, "4*PT_D1" },
2407 { 4*PT_D2, "4*PT_D2" },
2408 { 4*PT_D3, "4*PT_D3" },
2409 { 4*PT_D4, "4*PT_D4" },
2410 { 4*PT_D5, "4*PT_D5" },
2411 { 4*PT_D6, "4*PT_D6" },
2412 { 4*PT_D7, "4*PT_D7" },
2413 { 4*PT_A0, "4*PT_A0" },
2414 { 4*PT_A1, "4*PT_A1" },
2415 { 4*PT_A2, "4*PT_A2" },
2416 { 4*PT_A3, "4*PT_A3" },
2417 { 4*PT_A4, "4*PT_A4" },
2418 { 4*PT_A5, "4*PT_A5" },
2419 { 4*PT_A6, "4*PT_A6" },
2420 { 4*PT_D0, "4*PT_D0" },
2421 { 4*PT_USP, "4*PT_USP" },
2422 { 4*PT_ORIG_D0, "4*PT_ORIG_D0" },
2423 { 4*PT_SR, "4*PT_SR" },
2424 { 4*PT_PC, "4*PT_PC" },
2428 { 4*REG_REG0, "4*REG_REG0" },
2429 { 4*(REG_REG0+1), "4*REG_REG1" },
2430 { 4*(REG_REG0+2), "4*REG_REG2" },
2431 { 4*(REG_REG0+3), "4*REG_REG3" },
2432 { 4*(REG_REG0+4), "4*REG_REG4" },
2433 { 4*(REG_REG0+5), "4*REG_REG5" },
2434 { 4*(REG_REG0+6), "4*REG_REG6" },
2435 { 4*(REG_REG0+7), "4*REG_REG7" },
2436 { 4*(REG_REG0+8), "4*REG_REG8" },
2437 { 4*(REG_REG0+9), "4*REG_REG9" },
2438 { 4*(REG_REG0+10), "4*REG_REG10" },
2439 { 4*(REG_REG0+11), "4*REG_REG11" },
2440 { 4*(REG_REG0+12), "4*REG_REG12" },
2441 { 4*(REG_REG0+13), "4*REG_REG13" },
2442 { 4*(REG_REG0+14), "4*REG_REG14" },
2443 { 4*REG_REG15, "4*REG_REG15" },
2444 { 4*REG_PC, "4*REG_PC" },
2445 { 4*REG_PR, "4*REG_PR" },
2446 { 4*REG_SR, "4*REG_SR" },
2447 { 4*REG_GBR, "4*REG_GBR" },
2448 { 4*REG_MACH, "4*REG_MACH" },
2449 { 4*REG_MACL, "4*REG_MACL" },
2450 { 4*REG_SYSCALL, "4*REG_SYSCALL" },
2451 { 4*REG_FPUL, "4*REG_FPUL" },
2452 { 4*REG_FPREG0, "4*REG_FPREG0" },
2453 { 4*(REG_FPREG0+1), "4*REG_FPREG1" },
2454 { 4*(REG_FPREG0+2), "4*REG_FPREG2" },
2455 { 4*(REG_FPREG0+3), "4*REG_FPREG3" },
2456 { 4*(REG_FPREG0+4), "4*REG_FPREG4" },
2457 { 4*(REG_FPREG0+5), "4*REG_FPREG5" },
2458 { 4*(REG_FPREG0+6), "4*REG_FPREG6" },
2459 { 4*(REG_FPREG0+7), "4*REG_FPREG7" },
2460 { 4*(REG_FPREG0+8), "4*REG_FPREG8" },
2461 { 4*(REG_FPREG0+9), "4*REG_FPREG9" },
2462 { 4*(REG_FPREG0+10), "4*REG_FPREG10" },
2463 { 4*(REG_FPREG0+11), "4*REG_FPREG11" },
2464 { 4*(REG_FPREG0+12), "4*REG_FPREG12" },
2465 { 4*(REG_FPREG0+13), "4*REG_FPREG13" },
2466 { 4*(REG_FPREG0+14), "4*REG_FPREG14" },
2467 { 4*REG_FPREG15, "4*REG_FPREG15" },
2468 { 4*REG_XDREG0, "4*REG_XDREG0" },
2469 { 4*(REG_XDREG0+2), "4*REG_XDREG2" },
2470 { 4*(REG_XDREG0+4), "4*REG_XDREG4" },
2471 { 4*(REG_XDREG0+6), "4*REG_XDREG6" },
2472 { 4*(REG_XDREG0+8), "4*REG_XDREG8" },
2473 { 4*(REG_XDREG0+10), "4*REG_XDREG10" },
2474 { 4*(REG_XDREG0+12), "4*REG_XDREG12" },
2475 { 4*REG_XDREG14, "4*REG_XDREG14" },
2476 { 4*REG_FPSCR, "4*REG_FPSCR" },
2483 { 16, "syscall no.(L)" },
2484 { 20, "syscall_no.(U)" },
2627 /* This entry is in case pt_regs contains dregs (depends on
2628 the kernel build options). */
2629 { uoff(regs), "offsetof(struct user, regs)" },
2630 { uoff(fpu), "offsetof(struct user, fpu)" },
2633 { uoff(regs.ARM_r0), "r0" },
2634 { uoff(regs.ARM_r1), "r1" },
2635 { uoff(regs.ARM_r2), "r2" },
2636 { uoff(regs.ARM_r3), "r3" },
2637 { uoff(regs.ARM_r4), "r4" },
2638 { uoff(regs.ARM_r5), "r5" },
2639 { uoff(regs.ARM_r6), "r6" },
2640 { uoff(regs.ARM_r7), "r7" },
2641 { uoff(regs.ARM_r8), "r8" },
2642 { uoff(regs.ARM_r9), "r9" },
2643 { uoff(regs.ARM_r10), "r10" },
2644 { uoff(regs.ARM_fp), "fp" },
2645 { uoff(regs.ARM_ip), "ip" },
2646 { uoff(regs.ARM_sp), "sp" },
2647 { uoff(regs.ARM_lr), "lr" },
2648 { uoff(regs.ARM_pc), "pc" },
2649 { uoff(regs.ARM_cpsr), "cpsr" },
2652 #if !defined(S390) && !defined(S390X) && !defined(MIPS)
2653 { uoff(u_fpvalid), "offsetof(struct user, u_fpvalid)" },
2655 #if defined(I386) || defined(X86_64)
2656 { uoff(i387), "offsetof(struct user, i387)" },
2659 { uoff(m68kfp), "offsetof(struct user, m68kfp)" },
2662 { uoff(u_tsize), "offsetof(struct user, u_tsize)" },
2663 { uoff(u_dsize), "offsetof(struct user, u_dsize)" },
2664 { uoff(u_ssize), "offsetof(struct user, u_ssize)" },
2665 { uoff(start_code), "offsetof(struct user, start_code)" },
2667 { uoff(start_data), "offsetof(struct user, start_data)" },
2669 { uoff(start_stack), "offsetof(struct user, start_stack)" },
2670 { uoff(signal), "offsetof(struct user, signal)" },
2671 #if !defined(S390) && !defined(S390X) && !defined(MIPS) && !defined(SH) && !defined(SH64)
2672 { uoff(reserved), "offsetof(struct user, reserved)" },
2674 { uoff(u_ar0), "offsetof(struct user, u_ar0)" },
2675 #if !defined(ARM) && !defined(MIPS) && !defined(S390) && !defined(S390X)
2676 { uoff(u_fpstate), "offsetof(struct user, u_fpstate)" },
2678 { uoff(magic), "offsetof(struct user, magic)" },
2679 { uoff(u_comm), "offsetof(struct user, u_comm)" },
2680 #if defined(I386) || defined(X86_64)
2681 { uoff(u_debugreg), "offsetof(struct user, u_debugreg)" },
2685 #endif /* !POWERPC/!SPARC */
2688 { uoff(u_pcb), "offsetof(struct user, u_pcb)" },
2689 { uoff(u_procp), "offsetof(struct user, u_procp)" },
2690 { uoff(u_ar0), "offsetof(struct user, u_ar0)" },
2691 { uoff(u_comm[0]), "offsetof(struct user, u_comm[0])" },
2692 { uoff(u_arg[0]), "offsetof(struct user, u_arg[0])" },
2693 { uoff(u_ap), "offsetof(struct user, u_ap)" },
2694 { uoff(u_qsave), "offsetof(struct user, u_qsave)" },
2695 { uoff(u_rval1), "offsetof(struct user, u_rval1)" },
2696 { uoff(u_rval2), "offsetof(struct user, u_rval2)" },
2697 { uoff(u_error), "offsetof(struct user, u_error)" },
2698 { uoff(u_eosys), "offsetof(struct user, u_eosys)" },
2699 { uoff(u_ssave), "offsetof(struct user, u_ssave)" },
2700 { uoff(u_signal[0]), "offsetof(struct user, u_signal)" },
2701 { uoff(u_sigmask[0]), "offsetof(struct user, u_sigmask)" },
2702 { uoff(u_sigonstack), "offsetof(struct user, u_sigonstack)" },
2703 { uoff(u_sigintr), "offsetof(struct user, u_sigintr)" },
2704 { uoff(u_sigreset), "offsetof(struct user, u_sigreset)" },
2705 { uoff(u_oldmask), "offsetof(struct user, u_oldmask)" },
2706 { uoff(u_code), "offsetof(struct user, u_code)" },
2707 { uoff(u_addr), "offsetof(struct user, u_addr)" },
2708 { uoff(u_sigstack), "offsetof(struct user, u_sigstack)" },
2709 { uoff(u_ofile), "offsetof(struct user, u_ofile)" },
2710 { uoff(u_pofile), "offsetof(struct user, u_pofile)" },
2711 { uoff(u_ofile_arr[0]), "offsetof(struct user, u_ofile_arr[0])" },
2712 { uoff(u_pofile_arr[0]),"offsetof(struct user, u_pofile_arr[0])"},
2713 { uoff(u_lastfile), "offsetof(struct user, u_lastfile)" },
2714 { uoff(u_cwd), "offsetof(struct user, u_cwd)" },
2715 { uoff(u_cdir), "offsetof(struct user, u_cdir)" },
2716 { uoff(u_rdir), "offsetof(struct user, u_rdir)" },
2717 { uoff(u_cmask), "offsetof(struct user, u_cmask)" },
2718 { uoff(u_ru), "offsetof(struct user, u_ru)" },
2719 { uoff(u_cru), "offsetof(struct user, u_cru)" },
2720 { uoff(u_timer[0]), "offsetof(struct user, u_timer[0])" },
2721 { uoff(u_XXX[0]), "offsetof(struct user, u_XXX[0])" },
2722 { uoff(u_ioch), "offsetof(struct user, u_ioch)" },
2723 { uoff(u_start), "offsetof(struct user, u_start)" },
2724 { uoff(u_acflag), "offsetof(struct user, u_acflag)" },
2725 { uoff(u_prof.pr_base), "offsetof(struct user, u_prof.pr_base)" },
2726 { uoff(u_prof.pr_size), "offsetof(struct user, u_prof.pr_size)" },
2727 { uoff(u_prof.pr_off), "offsetof(struct user, u_prof.pr_off)" },
2728 { uoff(u_prof.pr_scale),"offsetof(struct user, u_prof.pr_scale)"},
2729 { uoff(u_rlimit[0]), "offsetof(struct user, u_rlimit)" },
2730 { uoff(u_exdata.Ux_A), "offsetof(struct user, u_exdata.Ux_A)" },
2731 { uoff(u_exdata.ux_shell[0]),"offsetof(struct user, u_exdata.ux_shell[0])"},
2732 { uoff(u_lofault), "offsetof(struct user, u_lofault)" },
2735 { sizeof(struct user), "sizeof(struct user)" },
2748 if (entering(tcp)) {
2749 printxval(ptrace_cmds, tcp->u_arg[0],
2756 tprintf(", %lu, ", tcp->u_arg[1]);
2757 addr = tcp->u_arg[2];
2759 if (tcp->u_arg[0] == PTRACE_PEEKUSER
2760 || tcp->u_arg[0] == PTRACE_POKEUSER) {
2761 for (x = struct_user_offsets; x->str; x++) {
2766 tprintf("%#lx, ", addr);
2767 else if (x->val > addr && x != struct_user_offsets) {
2769 tprintf("%s + %ld, ", x->str, addr - x->val);
2772 tprintf("%s, ", x->str);
2776 tprintf("%#lx, ", tcp->u_arg[2]);
2778 switch (tcp->u_arg[0]) {
2779 case PTRACE_PEEKDATA:
2780 case PTRACE_PEEKTEXT:
2781 case PTRACE_PEEKUSER:
2784 case PTRACE_SINGLESTEP:
2785 case PTRACE_SYSCALL:
2787 printsignal(tcp->u_arg[3]);
2790 tprintf("%#lx", tcp->u_arg[3]);
2794 switch (tcp->u_arg[0]) {
2795 case PTRACE_PEEKDATA:
2796 case PTRACE_PEEKTEXT:
2797 case PTRACE_PEEKUSER:
2798 printnum(tcp, tcp->u_arg[3], "%#lx");
2804 if (tcp->u_arg[0] == PTRACE_WRITEDATA ||
2805 tcp->u_arg[0] == PTRACE_WRITETEXT) {
2806 tprintf("%lu, ", tcp->u_arg[3]);
2807 printstr(tcp, tcp->u_arg[4], tcp->u_arg[3]);
2808 } else if (tcp->u_arg[0] != PTRACE_READDATA &&
2809 tcp->u_arg[0] != PTRACE_READTEXT) {
2810 tprintf("%#lx", tcp->u_arg[3]);
2813 if (tcp->u_arg[0] == PTRACE_READDATA ||
2814 tcp->u_arg[0] == PTRACE_READTEXT) {
2815 tprintf("%lu, ", tcp->u_arg[3]);
2816 printstr(tcp, tcp->u_arg[4], tcp->u_arg[3]);
2821 tprintf("%lu", tcp->u_arg[3]);
2823 #endif /* FREEBSD */
2830 static struct xlat futexops[] = {
2831 { FUTEX_WAIT, "FUTEX_WAIT" },
2832 { FUTEX_WAKE, "FUTEX_WAKE" },
2833 { FUTEX_FD, "FUTEX_FD" },
2834 { FUTEX_REQUEUE,"FUTEX_REQUEUE" },
2842 if (entering(tcp)) {
2843 tprintf("%p, ", (void *) tcp->u_arg[0]);
2844 printxval(futexops, tcp->u_arg[1], "FUTEX_???");
2845 tprintf(", %ld", tcp->u_arg[2]);
2846 if (tcp->u_arg[1] == FUTEX_WAIT) {
2848 printtv(tcp, tcp->u_arg[3]);
2849 } else if (tcp->u_arg[1] == FUTEX_REQUEUE)
2850 tprintf(", %ld, %p", tcp->u_arg[3], (void *) tcp->u_arg[4]);
2856 print_affinitylist(list, len)
2857 unsigned long *list;
2862 while (len >= sizeof (unsigned long)) {
2863 tprintf("%s %lx", first ? "" : ",", *list++);
2865 len -= sizeof (unsigned long);
2871 sys_sched_setaffinity(tcp)
2874 if (entering(tcp)) {
2875 tprintf("%ld, %lu, ", tcp->u_arg[0], tcp->u_arg[1]);
2876 print_affinitylist((unsigned long *) tcp->u_arg[2], tcp->u_arg[1]);
2882 sys_sched_getaffinity(tcp)
2885 if (entering(tcp)) {
2886 tprintf("%ld, %lu, ", tcp->u_arg[0], tcp->u_arg[1]);
2888 print_affinitylist((unsigned long *) tcp->u_arg[2], tcp->u_rval);