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 # ifdef HAVE_STRUCT_IA64_FPREG
86 # define ia64_fpreg XXX_ia64_fpreg
88 # ifdef HAVE_STRUCT_PT_ALL_USER_REGS
89 # define pt_all_user_regs XXX_pt_all_user_regs
91 #include <linux/ptrace.h>
93 # undef pt_all_user_regs
96 #ifdef HAVE_LINUX_FUTEX_H
97 #include <linux/futex.h>
101 # define FUTEX_WAIT 0
104 # define FUTEX_WAKE 1
109 # ifndef FUTEX_REQUEUE
110 # define FUTEX_REQUEUE 3
116 #include <asm/posix_types.h>
118 #define GETGROUPS_T __kernel_gid_t
120 #define GETGROUPS32_T __kernel_gid32_t
123 #if defined(LINUX) && defined(IA64)
124 # include <asm/ptrace_offsets.h>
125 # include <asm/rse.h>
129 #include <sys/prctl.h>
133 #define WCOREDUMP(status) ((status) & 0200)
136 /* WTA: this was `&& !defined(LINUXSPARC)', this seems unneeded though? */
137 #if defined(HAVE_PRCTL)
138 static struct xlat prctl_options[] = {
140 { PR_MAXPROCS, "PR_MAXPROCS" },
143 { PR_ISBLOCKED, "PR_ISBLOCKED" },
145 #ifdef PR_SETSTACKSIZE
146 { PR_SETSTACKSIZE, "PR_SETSTACKSIZE" },
148 #ifdef PR_GETSTACKSIZE
149 { PR_GETSTACKSIZE, "PR_GETSTACKSIZE" },
152 { PR_MAXPPROCS, "PR_MAXPPROCS" },
154 #ifdef PR_UNBLKONEXEC
155 { PR_UNBLKONEXEC, "PR_UNBLKONEXEC" },
158 { PR_ATOMICSIM, "PR_ATOMICSIM" },
161 { PR_SETEXITSIG, "PR_SETEXITSIG" },
164 { PR_RESIDENT, "PR_RESIDENT" },
167 { PR_ATTACHADDR, "PR_ATTACHADDR" },
170 { PR_DETACHADDR, "PR_DETACHADDR" },
173 { PR_TERMCHILD, "PR_TERMCHILD" },
176 { PR_GETSHMASK, "PR_GETSHMASK" },
179 { PR_GETNSHARE, "PR_GETNSHARE" },
181 #if defined(PR_SET_PDEATHSIG)
182 { PR_SET_PDEATHSIG, "PR_SET_PDEATHSIG" },
185 { PR_COREPID, "PR_COREPID" },
187 #ifdef PR_ATTACHADDRPERM
188 { PR_ATTACHADDRPERM, "PR_ATTACHADDRPERM" },
190 #ifdef PR_PTHREADEXIT
191 { PR_PTHREADEXIT, "PR_PTHREADEXIT" },
193 #ifdef PR_SET_PDEATHSIG
194 { PR_SET_PDEATHSIG, "PR_SET_PDEATHSIG" },
196 #ifdef PR_GET_PDEATHSIG
197 { PR_GET_PDEATHSIG, "PR_GET_PDEATHSIG" },
199 #ifdef PR_GET_UNALIGN
200 { PR_GET_UNALIGN, "PR_GET_UNALIGN" },
202 #ifdef PR_SET_UNALIGN
203 { PR_SET_UNALIGN, "PR_SET_UNALIGN" },
205 #ifdef PR_GET_KEEPCAPS
206 { PR_GET_KEEPCAPS, "PR_GET_KEEP_CAPS" },
208 #ifdef PR_SET_KEEPCAPS
209 { PR_SET_KEEPCAPS, "PR_SET_KEEP_CAPS" },
216 unalignctl_string (unsigned int ctl)
221 #ifdef PR_UNALIGN_NOPRINT
222 case PR_UNALIGN_NOPRINT:
225 #ifdef PR_UNALIGN_SIGBUS
226 case PR_UNALIGN_SIGBUS:
232 sprintf(buf, "%x", ctl);
244 printxval(prctl_options, tcp->u_arg[0], "PR_???");
245 switch (tcp->u_arg[0]) {
250 #ifdef PR_SET_DEATHSIG
251 case PR_GET_PDEATHSIG:
254 #ifdef PR_SET_UNALIGN
256 tprintf(", %s", unalignctl_string(tcp->u_arg[1]));
259 #ifdef PR_GET_UNALIGN
261 tprintf(", %#lx", tcp->u_arg[1]);
265 for (i = 1; i < tcp->u_nargs; i++)
266 tprintf(", %#lx", tcp->u_arg[i]);
270 switch (tcp->u_arg[0]) {
271 #ifdef PR_GET_PDEATHSIG
272 case PR_GET_PDEATHSIG:
273 for (i=1; i<tcp->u_nargs; i++)
274 tprintf(", %#lx", tcp->u_arg[i]);
277 #ifdef PR_SET_UNALIGN
281 #ifdef PR_GET_UNALIGN
286 umove(tcp, tcp->u_arg[1], &ctl);
287 tcp->auxstr = unalignctl_string(ctl);
298 #endif /* HAVE_PRCTL */
314 printpathn(tcp, tcp->u_arg[0], tcp->u_arg[1]);
315 tprintf(", %lu", tcp->u_arg[1]);
326 tprintf("%#lx", tcp->u_arg[0]);
328 printpath(tcp, tcp->u_arg[0]);
329 tprintf(", %lu", tcp->u_arg[1]);
335 sys_setdomainname(tcp)
339 printpathn(tcp, tcp->u_arg[0], tcp->u_arg[1]);
340 tprintf(", %lu", tcp->u_arg[1]);
348 sys_getdomainname(tcp)
353 tprintf("%#lx", tcp->u_arg[0]);
355 printpath(tcp, tcp->u_arg[0]);
356 tprintf(", %lu", tcp->u_arg[1]);
367 fprintf(stderr, "_exit returned!\n");
370 /* special case: we stop tracing this process, finish line now */
371 tprintf("%ld) ", tcp->u_arg[0]);
383 tcp->flags |= TCB_EXITING;
384 #ifdef __NR_exit_group
387 if (tcp->scno == 252)
388 tcp->flags |= TCB_GROUP_EXITING;
391 if (tcp->scno == __NR_exit_group)
392 tcp->flags |= TCB_GROUP_EXITING;
398 /* TCP is creating a child we want to follow.
399 If there will be space in tcbtab for it, set TCB_FOLLOWFORK and return 0.
400 If not, clear TCB_FOLLOWFORK, print an error, and return 1. */
402 fork_tcb(struct tcb *tcp)
404 if (nprocs == tcbtabsize) {
405 /* Allocate some more TCBs and expand the table.
406 We don't want to relocate the TCBs because our
407 callers have pointers and it would be a pain.
408 So tcbtab is a table of pointers. Since we never
409 free the TCBs, we allocate a single chunk of many. */
410 struct tcb **newtab = (struct tcb **)
411 realloc(tcbtab, 2 * tcbtabsize * sizeof tcbtab[0]);
412 struct tcb *newtcbs = (struct tcb *) calloc(tcbtabsize,
415 if (newtab == NULL || newtcbs == NULL) {
418 tcp->flags &= ~TCB_FOLLOWFORK;
419 fprintf(stderr, "sys_fork: tcb table full\n");
422 for (i = tcbtabsize; i < 2 * tcbtabsize; ++i)
423 newtab[i] = &newtcbs[i - tcbtabsize];
428 tcp->flags |= TCB_FOLLOWFORK;
440 tcp->auxstr = "child process";
441 return RVAL_UDECIMAL | RVAL_STR;
454 tprintf ("%ld", tcp->u_arg[0]);
458 tcp->auxstr = "child process";
459 return RVAL_UDECIMAL | RVAL_STR;
471 struct tcb *tcpchild;
475 if (tcp->scno == SYS_rfork && !(tcp->u_arg[0]&RFPROC))
486 if ((tcpchild = alloctcb(tcp->u_rval)) == NULL) {
487 fprintf(stderr, "sys_fork: tcb table full\n");
490 if (proc_open(tcpchild, 2) < 0)
496 #else /* !USE_PROCFS */
500 /* defines copied from linux/sched.h since we can't include that
501 * ourselves (it conflicts with *lots* of libc includes)
503 #define CSIGNAL 0x000000ff /* signal mask to be sent at exit */
504 #define CLONE_VM 0x00000100 /* set if VM shared between processes */
505 #define CLONE_FS 0x00000200 /* set if fs info shared between processes */
506 #define CLONE_FILES 0x00000400 /* set if open files shared between processes */
507 #define CLONE_SIGHAND 0x00000800 /* set if signal handlers shared */
508 #define CLONE_IDLETASK 0x00001000 /* kernel-only flag */
509 #define CLONE_PTRACE 0x00002000 /* set if we want to let tracing continue on the child too */
510 #define CLONE_VFORK 0x00004000 /* set if the parent wants the child to wake it up on mm_release */
511 #define CLONE_PARENT 0x00008000 /* set if we want to have the same parent as the cloner */
512 #define CLONE_THREAD 0x00010000 /* Same thread group? */
513 #define CLONE_NEWNS 0x00020000 /* New namespace group? */
514 #define CLONE_SYSVSEM 0x00040000 /* share system V SEM_UNDO semantics */
515 #define CLONE_SETTLS 0x00080000 /* create a new TLS for the child */
516 #define CLONE_PARENT_SETTID 0x00100000 /* set the TID in the parent */
517 #define CLONE_CHILD_CLEARTID 0x00200000 /* clear the TID in the child */
518 #define CLONE_DETACHED 0x00400000 /* parent wants no child-exit signal */
519 #define CLONE_UNTRACED 0x00800000 /* set if the tracing process can't force CLONE_PTRACE on this clone */
520 #define CLONE_CHILD_SETTID 0x01000000 /* set the TID in the child */
522 static struct xlat clone_flags[] = {
523 { CLONE_VM, "CLONE_VM" },
524 { CLONE_FS, "CLONE_FS" },
525 { CLONE_FILES, "CLONE_FILES" },
526 { CLONE_SIGHAND, "CLONE_SIGHAND" },
527 { CLONE_IDLETASK, "CLONE_IDLETASK"},
528 { CLONE_PTRACE, "CLONE_PTRACE" },
529 { CLONE_VFORK, "CLONE_VFORK" },
530 { CLONE_PARENT, "CLONE_PARENT" },
531 { CLONE_THREAD, "CLONE_THREAD" },
532 { CLONE_NEWNS, "CLONE_NEWNS" },
533 { CLONE_SYSVSEM, "CLONE_SYSVSEM" },
534 { CLONE_SETTLS, "CLONE_SETTLS" },
535 { CLONE_PARENT_SETTID,"CLONE_PARENT_SETTID" },
536 { CLONE_CHILD_CLEARTID,"CLONE_CHILD_CLEARTID" },
537 { CLONE_DETACHED, "CLONE_DETACHED" },
538 { CLONE_UNTRACED, "CLONE_UNTRACED" },
539 { CLONE_CHILD_SETTID,"CLONE_CHILD_SETTID" },
544 # include <asm/ldt.h>
545 # ifdef HAVE_STRUCT_USER_DESC
546 # define modify_ldt_ldt_s user_desc
548 extern void print_ldt_entry();
554 # define ARG_STACKSIZE (tcp->scno == SYS_clone2 ? 2 : -1)
555 # define ARG_PTID (tcp->scno == SYS_clone2 ? 3 : 2)
556 # define ARG_CTID (tcp->scno == SYS_clone2 ? 4 : 3)
557 # define ARG_TLS (tcp->scno == SYS_clone2 ? 5 : 4)
558 # elif defined S390 || defined S390X
564 # elif defined X86_64 || defined ALPHA
583 unsigned long flags = tcp->u_arg[ARG_FLAGS];
584 tprintf("child_stack=%#lx, ", tcp->u_arg[ARG_STACK]);
585 # ifdef ARG_STACKSIZE
586 if (ARG_STACKSIZE != -1)
587 tprintf("stack_size=%#lx, ",
588 tcp->u_arg[ARG_STACKSIZE]);
591 if (printflags(clone_flags, flags &~ CSIGNAL) == 0)
593 if ((flags & CSIGNAL) != 0)
594 tprintf("|%s", signame(flags & CSIGNAL));
595 if ((flags & (CLONE_PARENT_SETTID|CLONE_CHILD_SETTID
596 |CLONE_CHILD_CLEARTID|CLONE_SETTLS)) == 0)
598 if (flags & CLONE_PARENT_SETTID)
599 tprintf(", parent_tidptr=%#lx", tcp->u_arg[ARG_PTID]);
600 if (flags & CLONE_SETTLS) {
602 struct modify_ldt_ldt_s copy;
603 if (umove(tcp, tcp->u_arg[ARG_TLS], ©) != -1) {
604 tprintf(", {entry_number:%d, ",
609 print_ldt_entry(©);
613 tprintf(", tls=%#lx", tcp->u_arg[ARG_TLS]);
615 if (flags & (CLONE_CHILD_SETTID|CLONE_CHILD_CLEARTID))
616 tprintf(", child_tidptr=%#lx", tcp->u_arg[ARG_CTID]);
627 return RVAL_UDECIMAL;
632 change_syscall(tcp, new)
638 /* Attempt to make vfork into fork, which we can follow. */
639 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(ORIG_EAX * 4), new) < 0)
642 #elif defined(X86_64)
643 /* Attempt to make vfork into fork, which we can follow. */
644 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(ORIG_RAX * 8), new) < 0)
647 #elif defined(POWERPC)
648 if (ptrace(PTRACE_POKEUSER, tcp->pid,
649 (char*)(sizeof(unsigned long)*PT_R0), new) < 0)
652 #elif defined(S390) || defined(S390X)
653 /* s390 linux after 2.4.7 has a hook in entry.S to allow this */
654 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_GPR2), new)<0)
658 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*PT_ORIG_D0), new)<0)
663 if (ptrace(PTRACE_GETREGS, tcp->pid, (char*)®s, 0)<0)
666 if (ptrace(PTRACE_SETREGS, tcp->pid, (char*)®s, 0)<0)
670 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_V0), new)<0)
674 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_A3), new)<0)
680 case 2: break; /* x86 SYS_fork */
681 case SYS_clone: new = 120; break;
683 fprintf(stderr, "%s: unexpected syscall %d\n",
687 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_R1), new)<0)
689 } else if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_R15), new)<0)
693 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_GR20), new)<0)
697 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*(REG_REG0+3)), new)<0)
701 /* Top half of reg encodes the no. of args n as 0x1n.
702 Assume 0 args as kernel never actually checks... */
703 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_SYSCALL),
708 #warning Do not know how to handle change_syscall for this architecture
709 #endif /* architecture */
721 unsigned long *bsp, *ap;
723 if (upeek(tcp->pid, PT_AR_BSP, (long *) &bsp) , 0)
726 ap = ia64_rse_skip_regs(bsp, argnum);
728 ptrace(PTRACE_POKEDATA, tcp->pid, (char *) ap, tcp->u_arg[argnum]);
735 ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*argnum), tcp->u_arg[argnum]);
739 #elif defined(X86_64)
741 ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(8*(long)argnum), tcp->u_arg[argnum]);
745 #elif defined(POWERPC)
747 #define PT_ORIG_R3 34
750 ptrace(PTRACE_POKEUSER, tcp->pid,
751 (char*)((argnum==0 ? PT_ORIG_R3 : argnum+PT_R3)*sizeof(unsigned long)),
760 ptrace(PTRACE_POKEUSER, tcp->pid,
761 (char*)(REG_A0 + argnum), tcp->u_arg[argnum]);
765 if (upeek(tcp->pid, REG_SP, (long *) &sp) , 0)
768 ptrace(PTRACE_POKEDATA, tcp->pid,
769 (char*)(sp + argnum - 4), tcp->u_arg[argnum]);
774 #elif defined(S390) || defined(S390X)
777 ptrace(PTRACE_POKEUSER, tcp->pid,
778 (char *) (argnum==0 ? PT_ORIGGPR2 :
779 PT_GPR2 + argnum*sizeof(long)),
787 # warning Sorry, setargs not implemented for this architecture.
792 #if defined SYS_clone || defined SYS_clone2
797 struct tcb *tcpchild;
807 int bpt = tcp->flags & TCB_BPTSET;
809 if (!(tcp->flags & TCB_FOLLOWFORK))
820 #ifdef CLONE_PTRACE /* See new setbpt code. */
821 tcpchild = pid2tcb(pid);
822 if (tcpchild != NULL) {
823 /* The child already reported its startup trap
824 before the parent reported its syscall return. */
826 & (TCB_STARTUP|TCB_ATTACHED|TCB_SUSPENDED))
827 != (TCB_STARTUP|TCB_ATTACHED|TCB_SUSPENDED))
829 [preattached child %d of %d in weird state!]\n",
834 if ((tcpchild = alloctcb(pid)) == NULL) {
837 fprintf(stderr, " [tcb table full]\n");
838 kill(pid, SIGKILL); /* XXX */
843 /* Attach to the new child */
844 if (ptrace(PTRACE_ATTACH, pid, (char *) 1, 0) < 0) {
847 perror("PTRACE_ATTACH");
848 fprintf(stderr, "Too late?\n");
857 tcpchild->flags |= TCB_ATTACHED;
858 /* Child has BPT too, must be removed on first occasion. */
860 tcpchild->flags |= TCB_BPTSET;
861 tcpchild->baddr = tcp->baddr;
862 memcpy(tcpchild->inst, tcp->inst,
863 sizeof tcpchild->inst);
865 tcpchild->parent = tcp;
867 if (tcpchild->flags & TCB_SUSPENDED) {
868 /* The child was born suspended, due to our having
869 forced CLONE_PTRACE. */
873 tcpchild->flags &= ~(TCB_SUSPENDED|TCB_STARTUP);
874 if (ptrace(PTRACE_SYSCALL, pid, (char *) 1, 0) < 0) {
875 perror("resume: ptrace(PTRACE_SYSCALL, ...)");
881 Process %u resumed (parent %d ready)\n",
887 fprintf(stderr, "Process %d attached\n", pid);
890 #ifdef TCB_CLONE_THREAD
893 * Save the flags used in this call,
894 * in case we point TCP to our parent below.
896 int call_flags = tcp->u_arg[ARG_FLAGS];
897 if ((tcp->flags & TCB_CLONE_THREAD) &&
898 tcp->parent != NULL) {
899 /* The parent in this clone is itself a
900 thread belonging to another process.
901 There is no meaning to the parentage
902 relationship of the new child with the
903 thread, only with the process. We
904 associate the new thread with our
905 parent. Since this is done for every
906 new thread, there will never be a
907 TCB_CLONE_THREAD process that has
911 tcpchild->parent = tcp;
914 if (call_flags & CLONE_THREAD) {
915 tcpchild->flags |= TCB_CLONE_THREAD;
916 ++tcp->nclone_threads;
918 if (call_flags & CLONE_DETACHED) {
919 tcpchild->flags |= TCB_CLONE_DETACHED;
920 ++tcp->nclone_detached;
935 /* We do special magic with clone for any clone or fork. */
936 return internal_clone(tcp);
939 struct tcb *tcpchild;
944 if (tcp->scno == SYS_vfork) {
945 /* Attempt to make vfork into fork, which we can follow. */
947 change_syscall(tcp, SYS_fork) < 0)
952 if (!followfork || dont_follow)
960 int bpt = tcp->flags & TCB_BPTSET;
962 if (!(tcp->flags & TCB_FOLLOWFORK))
971 if ((tcpchild = alloctcb(pid)) == NULL) {
972 fprintf(stderr, " [tcb table full]\n");
973 kill(pid, SIGKILL); /* XXX */
978 /* The child must have run before it can be attached. */
979 /* This must be a bug in the parisc kernel, but I havn't
980 * identified it yet. Seems to be an issue associated
981 * with attaching to a process (which sends it a signal)
982 * before that process has ever been scheduled. When
983 * debugging, I started seeing crashes in
984 * arch/parisc/kernel/signal.c:do_signal(), apparently
985 * caused by r8 getting corrupt over the dequeue_signal()
986 * call. Didn't make much sense though...
992 select(0, NULL, NULL, NULL, &tv);
995 if (ptrace(PTRACE_ATTACH, pid, (char *) 1, 0) < 0) {
996 perror("PTRACE_ATTACH");
997 fprintf(stderr, "Too late?\n");
1004 /* The child must have run before it can be attached. */
1009 select(0, NULL, NULL, NULL, &tv);
1011 if (ptrace(PTRACE_ATTACH, pid, (char *)1, 0) < 0) {
1012 perror("PTRACE_ATTACH");
1013 fprintf(stderr, "Too late?\n");
1018 /* Try to catch the new process as soon as possible. */
1021 for (i = 0; i < 1024; i++)
1022 if (ptrace(PTRACE_ATTACH, pid, (char *) 1, 0) >= 0)
1025 perror("PTRACE_ATTACH");
1026 fprintf(stderr, "Too late?\n");
1031 #endif /* !oldway */
1033 tcpchild->flags |= TCB_ATTACHED;
1034 /* Child has BPT too, must be removed on first occasion */
1036 tcpchild->flags |= TCB_BPTSET;
1037 tcpchild->baddr = tcp->baddr;
1038 memcpy(tcpchild->inst, tcp->inst,
1039 sizeof tcpchild->inst);
1042 tcpchild->parent = tcp;
1045 fprintf(stderr, "Process %d attached\n", pid);
1051 #endif /* !USE_PROCFS */
1053 #if defined(SUNOS4) || defined(LINUX) || defined(FREEBSD)
1060 return RVAL_UDECIMAL;
1064 #endif /* SUNOS4 || LINUX || FREEBSD */
1068 static char idstr[16];
1075 sprintf(idstr, "ppid %lu", getrval2(tcp));
1076 tcp->auxstr = idstr;
1087 sprintf(idstr, "euid %lu", getrval2(tcp));
1088 tcp->auxstr = idstr;
1099 sprintf(idstr, "egid %lu", getrval2(tcp));
1100 tcp->auxstr = idstr;
1114 if (entering(tcp)) {
1115 tprintf("%u", (uid_t) tcp->u_arg[0]);
1124 if (entering(tcp)) {
1125 tprintf("%u", (gid_t) tcp->u_arg[0]);
1137 tprintf("%#lx, %#lx, %#lx", tcp->u_arg[0],
1138 tcp->u_arg[1], tcp->u_arg[2]);
1140 if (umove(tcp, tcp->u_arg[0], &uid) < 0)
1141 tprintf("%#lx, ", tcp->u_arg[0]);
1143 tprintf("[%lu], ", (unsigned long) uid);
1144 if (umove(tcp, tcp->u_arg[1], &uid) < 0)
1145 tprintf("%#lx, ", tcp->u_arg[1]);
1147 tprintf("[%lu], ", (unsigned long) uid);
1148 if (umove(tcp, tcp->u_arg[2], &uid) < 0)
1149 tprintf("%#lx", tcp->u_arg[2]);
1151 tprintf("[%lu]", (unsigned long) uid);
1164 tprintf("%#lx, %#lx, %#lx", tcp->u_arg[0],
1165 tcp->u_arg[1], tcp->u_arg[2]);
1167 if (umove(tcp, tcp->u_arg[0], &gid) < 0)
1168 tprintf("%#lx, ", tcp->u_arg[0]);
1170 tprintf("[%lu], ", (unsigned long) gid);
1171 if (umove(tcp, tcp->u_arg[1], &gid) < 0)
1172 tprintf("%#lx, ", tcp->u_arg[1]);
1174 tprintf("[%lu], ", (unsigned long) gid);
1175 if (umove(tcp, tcp->u_arg[2], &gid) < 0)
1176 tprintf("%#lx", tcp->u_arg[2]);
1178 tprintf("[%lu]", (unsigned long) gid);
1190 if (entering(tcp)) {
1191 printuid("", tcp->u_arg[0]);
1192 printuid(", ", tcp->u_arg[1]);
1201 if (entering(tcp)) {
1202 printuid("", tcp->u_arg[0]);
1203 printuid(", ", tcp->u_arg[1]);
1208 #if defined(LINUX) || defined(FREEBSD)
1213 if (entering(tcp)) {
1214 printuid("", tcp->u_arg[0]);
1215 printuid(", ", tcp->u_arg[1]);
1216 printuid(", ", tcp->u_arg[2]);
1224 if (entering(tcp)) {
1225 printuid("", tcp->u_arg[0]);
1226 printuid(", ", tcp->u_arg[1]);
1227 printuid(", ", tcp->u_arg[2]);
1232 #endif /* LINUX || FREEBSD */
1239 GETGROUPS_T *gidset;
1241 if (entering(tcp)) {
1242 len = tcp->u_arg[0];
1243 tprintf("%u, ", len);
1248 gidset = (GETGROUPS_T *) malloc(len * sizeof(GETGROUPS_T));
1249 if (gidset == NULL) {
1250 fprintf(stderr, "sys_setgroups: out of memory\n");
1254 tprintf("%#lx", tcp->u_arg[1]);
1255 else if (umoven(tcp, tcp->u_arg[1],
1256 len * sizeof(GETGROUPS_T), (char *) gidset) < 0)
1260 for (i = 0; i < len; i++)
1261 tprintf("%s%lu", i ? ", " : "",
1262 (unsigned long) gidset[i]);
1265 free((char *) gidset);
1275 GETGROUPS_T *gidset;
1277 if (entering(tcp)) {
1278 len = tcp->u_arg[0];
1279 tprintf("%u, ", len);
1286 gidset = (GETGROUPS_T *) malloc(len * sizeof(GETGROUPS_T));
1287 if (gidset == NULL) {
1288 fprintf(stderr, "sys_getgroups: out of memory\n");
1293 else if (!verbose(tcp) || tcp->u_arg[0] == 0)
1294 tprintf("%#lx", tcp->u_arg[1]);
1295 else if (umoven(tcp, tcp->u_arg[1],
1296 len * sizeof(GETGROUPS_T), (char *) gidset) < 0)
1300 for (i = 0; i < len; i++)
1301 tprintf("%s%lu", i ? ", " : "",
1302 (unsigned long) gidset[i]);
1305 free((char *)gidset);
1312 sys_setgroups32(tcp)
1316 GETGROUPS32_T *gidset;
1318 if (entering(tcp)) {
1319 len = tcp->u_arg[0];
1320 tprintf("%u, ", len);
1325 gidset = (GETGROUPS32_T *) malloc(len * sizeof(GETGROUPS32_T));
1326 if (gidset == NULL) {
1327 fprintf(stderr, "sys_setgroups32: out of memory\n");
1331 tprintf("%#lx", tcp->u_arg[1]);
1332 else if (umoven(tcp, tcp->u_arg[1],
1333 len * sizeof(GETGROUPS32_T), (char *) gidset) < 0)
1337 for (i = 0; i < len; i++)
1338 tprintf("%s%lu", i ? ", " : "",
1339 (unsigned long) gidset[i]);
1342 free((char *) gidset);
1348 sys_getgroups32(tcp)
1352 GETGROUPS32_T *gidset;
1354 if (entering(tcp)) {
1355 len = tcp->u_arg[0];
1356 tprintf("%u, ", len);
1363 gidset = (GETGROUPS32_T *) malloc(len * sizeof(GETGROUPS32_T));
1364 if (gidset == NULL) {
1365 fprintf(stderr, "sys_getgroups32: out of memory\n");
1370 else if (!verbose(tcp) || tcp->u_arg[0] == 0)
1371 tprintf("%#lx", tcp->u_arg[1]);
1372 else if (umoven(tcp, tcp->u_arg[1],
1373 len * sizeof(GETGROUPS32_T), (char *) gidset) < 0)
1377 for (i = 0; i < len; i++)
1378 tprintf("%s%lu", i ? ", " : "",
1379 (unsigned long) gidset[i]);
1382 free((char *)gidset);
1392 if (entering(tcp)) {
1394 tprintf("%lu, %lu", tcp->u_arg[0], tcp->u_arg[1]);
1404 if (entering(tcp)) {
1406 tprintf("%lu", tcp->u_arg[0]);
1416 if (entering(tcp)) {
1417 tprintf("%lu", tcp->u_arg[0]);
1433 if (entering(tcp)) {
1434 tprintf("%lu", tcp->u_arg[0]);
1443 if (entering(tcp)) {
1444 tprintf("%lu, %lu", tcp->u_arg[0], tcp->u_arg[1]);
1451 #include <sys/privilege.h>
1454 static struct xlat procpriv_cmds [] = {
1455 { SETPRV, "SETPRV" },
1456 { CLRPRV, "CLRPRV" },
1457 { PUTPRV, "PUTPRV" },
1458 { GETPRV, "GETPRV" },
1459 { CNTPRV, "CNTPRV" },
1464 static struct xlat procpriv_priv [] = {
1465 { P_OWNER, "P_OWNER" },
1466 { P_AUDIT, "P_AUDIT" },
1467 { P_COMPAT, "P_COMPAT" },
1468 { P_DACREAD, "P_DACREAD" },
1469 { P_DACWRITE, "P_DACWRITE" },
1471 { P_FILESYS, "P_FILESYS" },
1472 { P_MACREAD, "P_MACREAD" },
1473 { P_MACWRITE, "P_MACWRITE" },
1474 { P_MOUNT, "P_MOUNT" },
1475 { P_MULTIDIR, "P_MULTIDIR" },
1476 { P_SETPLEVEL, "P_SETPLEVEL" },
1477 { P_SETSPRIV, "P_SETSPRIV" },
1478 { P_SETUID, "P_SETUID" },
1479 { P_SYSOPS, "P_SYSOPS" },
1480 { P_SETUPRIV, "P_SETUPRIV" },
1481 { P_DRIVER, "P_DRIVER" },
1482 { P_RTIME, "P_RTIME" },
1483 { P_MACUPGRADE, "P_MACUPGRADE" },
1484 { P_FSYSRANGE, "P_FSYSRANGE" },
1485 { P_SETFLEVEL, "P_SETFLEVEL" },
1486 { P_AUDITWR, "P_AUDITWR" },
1487 { P_TSHAR, "P_TSHAR" },
1488 { P_PLOCK, "P_PLOCK" },
1489 { P_CORE, "P_CORE" },
1490 { P_LOADMOD, "P_LOADMOD" },
1491 { P_BIND, "P_BIND" },
1492 { P_ALLPRIVS, "P_ALLPRIVS" },
1497 static struct xlat procpriv_type [] = {
1498 { PS_FIX, "PS_FIX" },
1499 { PS_INH, "PS_INH" },
1500 { PS_MAX, "PS_MAX" },
1501 { PS_WKG, "PS_WKG" },
1507 printpriv(tcp, addr, len, opt)
1514 int max = verbose (tcp) ? sizeof buf / sizeof buf [0] : 10;
1515 int dots = len > max;
1518 if (len > max) len = max;
1521 umoven (tcp, addr, len * sizeof buf[0], (char *) buf) < 0)
1523 tprintf ("%#lx", addr);
1529 for (i = 0; i < len; ++i) {
1532 if (i) tprintf (", ");
1534 if ((t = xlookup (procpriv_type, buf [i] & PS_TYPE)) &&
1535 (p = xlookup (procpriv_priv, buf [i] & ~PS_TYPE)))
1537 tprintf ("%s|%s", t, p);
1540 tprintf ("%#lx", buf [i]);
1544 if (dots) tprintf (" ...");
1554 if (entering(tcp)) {
1555 printxval(procpriv_cmds, tcp->u_arg[0], "???PRV");
1556 switch (tcp->u_arg[0]) {
1558 tprintf(", %#lx, %ld", tcp->u_arg[1], tcp->u_arg[2]);
1566 printpriv (tcp, tcp->u_arg[1], tcp->u_arg[2]);
1567 tprintf (", %ld", tcp->u_arg[2]);
1570 else if (tcp->u_arg[0] == GETPRV) {
1571 if (syserror (tcp)) {
1572 tprintf(", %#lx, %ld", tcp->u_arg[1], tcp->u_arg[2]);
1576 printpriv (tcp, tcp->u_arg[1], tcp->u_rval);
1577 tprintf (", %ld", tcp->u_arg[2]);
1588 fake_execve(tcp, program, argv, envp)
1597 if (!(qual_flags[SYS_execve - __NR_SYSCALL_BASE] & QUAL_TRACE))
1600 if (!(qual_flags[SYS_execve] & QUAL_TRACE))
1605 string_quote(program);
1607 for (i = 0; argv[i] != NULL; i++) {
1610 string_quote(argv[i]);
1612 for (i = 0; envp[i] != NULL; i++)
1614 tprintf("], [/* %d var%s */]) ", i, (i != 1) ? "s" : "");
1621 printargv(tcp, addr)
1627 int max = max_strlen / 2;
1629 for (sep = ""; --max >= 0; sep = ", ") {
1632 if (umove(tcp, addr, &cp) < 0) {
1633 tprintf("%#lx", addr);
1639 printstr(tcp, (long) cp, -1);
1640 addr += sizeof(char *);
1647 printargc(fmt, tcp, addr)
1655 for (count = 0; umove(tcp, addr, &cp) >= 0 && cp != NULL; count++) {
1656 addr += sizeof(char *);
1658 tprintf(fmt, count, count == 1 ? "" : "s");
1665 if (entering(tcp)) {
1666 printpath(tcp, tcp->u_arg[0]);
1668 tprintf(", %#lx", tcp->u_arg[1]);
1670 else if (abbrev(tcp))
1671 printargc(", [/* %d arg%s */]", tcp, tcp->u_arg[1]);
1675 printargv(tcp, tcp->u_arg[1]);
1686 if (entering(tcp)) {
1687 printpath(tcp, tcp->u_arg[0]);
1689 tprintf(", %#lx", tcp->u_arg[1]);
1691 else if (abbrev(tcp))
1692 printargc(", [/* %d arg%s */]", tcp, tcp->u_arg[1]);
1696 printargv(tcp, tcp->u_arg[1]);
1700 tprintf(", %#lx", tcp->u_arg[2]);
1701 else if (abbrev(tcp))
1702 printargc(", [/* %d var%s */]", tcp, tcp->u_arg[2]);
1705 printargv(tcp, tcp->u_arg[2]);
1709 #if defined LINUX && defined TCB_WAITEXECVE
1710 if (exiting(tcp) && syserror(tcp))
1711 tcp->flags &= ~TCB_WAITEXECVE;
1713 tcp->flags |= TCB_WAITEXECVE;
1714 #endif /* LINUX && TCB_WAITEXECVE */
1720 int sys_rexecve(tcp)
1723 if (entering (tcp)) {
1725 tprintf (", %ld", tcp->u_arg[3]);
1737 if (exiting(tcp) && !syserror(tcp) && followfork)
1745 #define __WNOTHREAD 0x20000000
1748 #define __WALL 0x40000000
1751 #define __WCLONE 0x80000000
1755 static struct xlat wait4_options[] = {
1756 { WNOHANG, "WNOHANG" },
1758 { WUNTRACED, "WUNTRACED" },
1761 { WEXITED, "WEXITED" },
1764 { WTRAPPED, "WTRAPPED" },
1767 { WSTOPPED, "WSTOPPED" },
1770 { WCONTINUED, "WCONTINUED" },
1773 { WNOWAIT, "WNOWAIT" },
1776 { __WCLONE, "__WCLONE" },
1779 { __WALL, "__WALL" },
1782 { __WNOTHREAD, "__WNOTHREAD" },
1794 * Here is a tricky presentation problem. This solution
1795 * is still not entirely satisfactory but since there
1796 * are no wait status constructors it will have to do.
1798 if (WIFSTOPPED(status)) {
1799 tprintf("[{WIFSTOPPED(s) && WSTOPSIG(s) == %s}",
1800 signame(WSTOPSIG(status)));
1801 status &= ~W_STOPCODE(WSTOPSIG(status));
1803 else if (WIFSIGNALED(status)) {
1804 tprintf("[{WIFSIGNALED(s) && WTERMSIG(s) == %s%s}",
1805 signame(WTERMSIG(status)),
1806 WCOREDUMP(status) ? " && WCOREDUMP(s)" : "");
1807 status &= ~(W_EXITCODE(0, WTERMSIG(status)) | WCOREFLAG);
1809 else if (WIFEXITED(status)) {
1810 tprintf("[{WIFEXITED(s) && WEXITSTATUS(s) == %d}",
1811 WEXITSTATUS(status));
1813 status &= ~W_EXITCODE(WEXITSTATUS(status), 0);
1816 tprintf("[%#x]", status);
1823 tprintf("| %#x]", status);
1829 printwaitn(tcp, n, bitness)
1837 if (entering(tcp)) {
1838 tprintf("%ld, ", tcp->u_arg[0]);
1843 else if (syserror(tcp) || tcp->u_rval == 0)
1844 tprintf("%#lx", tcp->u_arg[1]);
1845 else if (umove(tcp, tcp->u_arg[1], &status) < 0)
1848 exited = printstatus(status);
1851 if (!printflags(wait4_options, tcp->u_arg[2]))
1859 else if (tcp->u_rval > 0) {
1862 printrusage32(tcp, tcp->u_arg[3]);
1865 printrusage(tcp, tcp->u_arg[3]);
1869 else if (tcp->u_rval > 0 && exited)
1870 printrusage(tcp, tcp->u_arg[3]);
1873 tprintf("%#lx", tcp->u_arg[3]);
1885 #ifdef TCB_CLONE_THREAD
1886 if (tcp->flags & TCB_CLONE_THREAD)
1887 /* The children we wait for are our parent's children. */
1888 got_kids = (tcp->parent->nchildren
1889 > tcp->parent->nclone_detached);
1891 got_kids = (tcp->nchildren > tcp->nclone_detached);
1893 got_kids = tcp->nchildren > 0;
1896 if (entering(tcp) && got_kids) {
1897 /* There are children that this parent should block for.
1898 But ptrace made us the parent of the traced children
1899 and the real parent will get ECHILD from the wait call.
1901 XXX If we attached with strace -f -p PID, then there
1902 may be untraced dead children the parent could be reaping
1903 now, but we make him block. */
1905 /* ??? WTA: fix bug with hanging children */
1907 if (!(tcp->u_arg[2] & WNOHANG)) {
1909 * There are traced children. We'll make the parent
1910 * block to avoid a false ECHILD error due to our
1911 * ptrace having stolen the children. However,
1912 * we shouldn't block if there are zombies to reap.
1913 * XXX doesn't handle pgrp matches (u_arg[0]==0,<-1)
1915 struct tcb *child = NULL;
1916 if (tcp->nzombies > 0 &&
1917 (tcp->u_arg[0] == -1 ||
1918 (child = pid2tcb(tcp->u_arg[0])) == NULL))
1920 if (tcp->u_arg[0] > 0) {
1922 * If the parent waits for a specified child
1923 * PID, then it must get ECHILD right away
1924 * if that PID is not one of its children.
1925 * Make sure that the requested PID matches
1926 * one of the parent's children that we are
1927 * tracing, and don't suspend it otherwise.
1930 child = pid2tcb(tcp->u_arg[0]);
1931 if (child == NULL || child->parent != (
1932 #ifdef TCB_CLONE_THREAD
1933 (tcp->flags & TCB_CLONE_THREAD)
1939 tcp->flags |= TCB_SUSPENDED;
1940 tcp->waitpid = tcp->u_arg[0];
1941 #ifdef TCB_CLONE_THREAD
1942 if (tcp->flags & TCB_CLONE_THREAD)
1943 tcp->parent->nclone_waiting++;
1947 if (exiting(tcp) && tcp->u_error == ECHILD && got_kids) {
1948 if (tcp->u_arg[2] & WNOHANG) {
1949 /* We must force a fake result of 0 instead of
1950 the ECHILD error. */
1951 extern int force_result();
1952 return force_result(tcp, 0, 0);
1955 else if (exiting(tcp) && tcp->u_error == 0 && tcp->u_rval > 0 &&
1956 tcp->nzombies > 0 && pid2tcb(tcp->u_rval) == NULL) {
1958 * We just reaped a child we don't know about,
1959 * presumably a zombie we already droptcb'd.
1973 /* The library wrapper stuffs this into the user variable. */
1975 printstatus(getrval2(tcp));
1990 if (!syserror(tcp)) {
1991 if (umove(tcp, tcp->u_arg[0], &status) < 0)
1992 tprintf("%#lx", tcp->u_arg[0]);
1994 printstatus(status);
2005 return printwaitn(tcp, 3, 0);
2012 return printwaitn(tcp, 4, 0);
2020 return printwaitn(tcp, 4, 1);
2026 static struct xlat waitid_types[] = {
2028 { P_PPID, "P_PPID" },
2029 { P_PGID, "P_PGID" },
2036 { P_LWPID, "P_LWPID" },
2048 if (entering(tcp)) {
2049 printxval(waitid_types, tcp->u_arg[0], "P_???");
2050 tprintf(", %ld, ", tcp->u_arg[1]);
2051 if (tcp->nchildren > 0) {
2052 /* There are traced children */
2053 tcp->flags |= TCB_SUSPENDED;
2054 tcp->waitpid = tcp->u_arg[0];
2062 else if (syserror(tcp))
2063 tprintf("%#lx", tcp->u_arg[2]);
2064 else if (umove(tcp, tcp->u_arg[2], &si) < 0)
2067 printsiginfo(&si, verbose (tcp));
2070 if (!printflags(wait4_options, tcp->u_arg[3]))
2083 tprintf("%lu", tcp->u_arg[0]);
2091 struct utsname uname;
2094 if (syserror(tcp) || !verbose(tcp))
2095 tprintf("%#lx", tcp->u_arg[0]);
2096 else if (umove(tcp, tcp->u_arg[0], &uname) < 0)
2098 else if (!abbrev(tcp)) {
2100 tprintf("{sysname=\"%s\", nodename=\"%s\", ",
2101 uname.sysname, uname.nodename);
2102 tprintf("release=\"%s\", version=\"%s\", ",
2103 uname.release, uname.version);
2104 tprintf("machine=\"%s\"", uname.machine);
2107 tprintf(", domainname=\"%s\"", uname.domainname);
2108 #endif /* __GLIBC__ */
2113 tprintf("{sys=\"%s\", node=\"%s\", ...}",
2114 uname.sysname, uname.nodename);
2121 static struct xlat ptrace_cmds[] = {
2123 { PTRACE_TRACEME, "PTRACE_TRACEME" },
2124 { PTRACE_PEEKTEXT, "PTRACE_PEEKTEXT", },
2125 { PTRACE_PEEKDATA, "PTRACE_PEEKDATA", },
2126 { PTRACE_PEEKUSER, "PTRACE_PEEKUSER", },
2127 { PTRACE_POKETEXT, "PTRACE_POKETEXT", },
2128 { PTRACE_POKEDATA, "PTRACE_POKEDATA", },
2129 { PTRACE_POKEUSER, "PTRACE_POKEUSER", },
2130 { PTRACE_CONT, "PTRACE_CONT" },
2131 { PTRACE_KILL, "PTRACE_KILL" },
2132 { PTRACE_SINGLESTEP, "PTRACE_SINGLESTEP" },
2133 { PTRACE_ATTACH, "PTRACE_ATTACH" },
2134 { PTRACE_DETACH, "PTRACE_DETACH" },
2135 #ifdef PTRACE_GETREGS
2136 { PTRACE_GETREGS, "PTRACE_GETREGS" },
2138 #ifdef PTRACE_SETREGS
2139 { PTRACE_SETREGS, "PTRACE_SETREGS" },
2141 #ifdef PTRACE_GETFPREGS
2142 { PTRACE_GETFPREGS, "PTRACE_GETFPREGS", },
2144 #ifdef PTRACE_SETFPREGS
2145 { PTRACE_SETFPREGS, "PTRACE_SETFPREGS", },
2147 #ifdef PTRACE_GETFPXREGS
2148 { PTRACE_GETFPXREGS, "PTRACE_GETFPXREGS", },
2150 #ifdef PTRACE_SETFPXREGS
2151 { PTRACE_SETFPXREGS, "PTRACE_SETFPXREGS", },
2154 { PTRACE_READDATA, "PTRACE_READDATA" },
2155 { PTRACE_WRITEDATA, "PTRACE_WRITEDATA" },
2156 { PTRACE_READTEXT, "PTRACE_READTEXT" },
2157 { PTRACE_WRITETEXT, "PTRACE_WRITETEXT" },
2158 { PTRACE_GETFPAREGS, "PTRACE_GETFPAREGS" },
2159 { PTRACE_SETFPAREGS, "PTRACE_SETFPAREGS" },
2161 { PTRACE_GETWINDOW, "PTRACE_GETWINDOW" },
2162 { PTRACE_SETWINDOW, "PTRACE_SETWINDOW" },
2164 { PTRACE_22, "PTRACE_PTRACE_22" },
2165 { PTRACE_23, "PTRACE_PTRACE_23" },
2168 { PTRACE_SYSCALL, "PTRACE_SYSCALL" },
2170 { PTRACE_DUMPCORE, "PTRACE_DUMPCORE" },
2172 { PTRACE_SETWRBKPT, "PTRACE_SETWRBKPT" },
2173 { PTRACE_SETACBKPT, "PTRACE_SETACBKPT" },
2174 { PTRACE_CLRDR7, "PTRACE_CLRDR7" },
2176 { PTRACE_26, "PTRACE_26" },
2177 { PTRACE_27, "PTRACE_27" },
2178 { PTRACE_28, "PTRACE_28" },
2180 { PTRACE_GETUCODE, "PTRACE_GETUCODE" },
2183 { PT_TRACE_ME, "PT_TRACE_ME" },
2184 { PT_READ_I, "PT_READ_I" },
2185 { PT_READ_D, "PT_READ_D" },
2186 { PT_WRITE_I, "PT_WRITE_I" },
2187 { PT_WRITE_D, "PT_WRITE_D" },
2189 { PT_READ_U, "PT_READ_U" },
2191 { PT_CONTINUE, "PT_CONTINUE" },
2192 { PT_KILL, "PT_KILL" },
2193 { PT_STEP, "PT_STEP" },
2194 { PT_ATTACH, "PT_ATTACH" },
2195 { PT_DETACH, "PT_DETACH" },
2196 { PT_GETREGS, "PT_GETREGS" },
2197 { PT_SETREGS, "PT_SETREGS" },
2198 { PT_GETFPREGS, "PT_GETFPREGS" },
2199 { PT_SETFPREGS, "PT_SETFPREGS" },
2200 { PT_GETDBREGS, "PT_GETDBREGS" },
2201 { PT_SETDBREGS, "PT_SETDBREGS" },
2202 #endif /* FREEBSD */
2207 #ifndef SUNOS4_KERNEL_ARCH_KLUDGE
2209 #endif /* !SUNOS4_KERNEL_ARCH_KLUDGE */
2210 struct xlat struct_user_offsets[] = {
2212 #if defined(S390) || defined(S390X)
2213 { PT_PSWMASK, "psw_mask" },
2214 { PT_PSWADDR, "psw_addr" },
2215 { PT_GPR0, "gpr0" },
2216 { PT_GPR1, "gpr1" },
2217 { PT_GPR2, "gpr2" },
2218 { PT_GPR3, "gpr3" },
2219 { PT_GPR4, "gpr4" },
2220 { PT_GPR5, "gpr5" },
2221 { PT_GPR6, "gpr6" },
2222 { PT_GPR7, "gpr7" },
2223 { PT_GPR8, "gpr8" },
2224 { PT_GPR9, "gpr9" },
2225 { PT_GPR10, "gpr10" },
2226 { PT_GPR11, "gpr11" },
2227 { PT_GPR12, "gpr12" },
2228 { PT_GPR13, "gpr13" },
2229 { PT_GPR14, "gpr14" },
2230 { PT_GPR15, "gpr15" },
2231 { PT_ACR0, "acr0" },
2232 { PT_ACR1, "acr1" },
2233 { PT_ACR2, "acr2" },
2234 { PT_ACR3, "acr3" },
2235 { PT_ACR4, "acr4" },
2236 { PT_ACR5, "acr5" },
2237 { PT_ACR6, "acr6" },
2238 { PT_ACR7, "acr7" },
2239 { PT_ACR8, "acr8" },
2240 { PT_ACR9, "acr9" },
2241 { PT_ACR10, "acr10" },
2242 { PT_ACR11, "acr11" },
2243 { PT_ACR12, "acr12" },
2244 { PT_ACR13, "acr13" },
2245 { PT_ACR14, "acr14" },
2246 { PT_ACR15, "acr15" },
2247 { PT_ORIGGPR2, "orig_gpr2" },
2250 { PT_FPR0_HI, "fpr0.hi" },
2251 { PT_FPR0_LO, "fpr0.lo" },
2252 { PT_FPR1_HI, "fpr1.hi" },
2253 { PT_FPR1_LO, "fpr1.lo" },
2254 { PT_FPR2_HI, "fpr2.hi" },
2255 { PT_FPR2_LO, "fpr2.lo" },
2256 { PT_FPR3_HI, "fpr3.hi" },
2257 { PT_FPR3_LO, "fpr3.lo" },
2258 { PT_FPR4_HI, "fpr4.hi" },
2259 { PT_FPR4_LO, "fpr4.lo" },
2260 { PT_FPR5_HI, "fpr5.hi" },
2261 { PT_FPR5_LO, "fpr5.lo" },
2262 { PT_FPR6_HI, "fpr6.hi" },
2263 { PT_FPR6_LO, "fpr6.lo" },
2264 { PT_FPR7_HI, "fpr7.hi" },
2265 { PT_FPR7_LO, "fpr7.lo" },
2266 { PT_FPR8_HI, "fpr8.hi" },
2267 { PT_FPR8_LO, "fpr8.lo" },
2268 { PT_FPR9_HI, "fpr9.hi" },
2269 { PT_FPR9_LO, "fpr9.lo" },
2270 { PT_FPR10_HI, "fpr10.hi" },
2271 { PT_FPR10_LO, "fpr10.lo" },
2272 { PT_FPR11_HI, "fpr11.hi" },
2273 { PT_FPR11_LO, "fpr11.lo" },
2274 { PT_FPR12_HI, "fpr12.hi" },
2275 { PT_FPR12_LO, "fpr12.lo" },
2276 { PT_FPR13_HI, "fpr13.hi" },
2277 { PT_FPR13_LO, "fpr13.lo" },
2278 { PT_FPR14_HI, "fpr14.hi" },
2279 { PT_FPR14_LO, "fpr14.lo" },
2280 { PT_FPR15_HI, "fpr15.hi" },
2281 { PT_FPR15_LO, "fpr15.lo" },
2284 { PT_FPR0, "fpr0" },
2285 { PT_FPR1, "fpr1" },
2286 { PT_FPR2, "fpr2" },
2287 { PT_FPR3, "fpr3" },
2288 { PT_FPR4, "fpr4" },
2289 { PT_FPR5, "fpr5" },
2290 { PT_FPR6, "fpr6" },
2291 { PT_FPR7, "fpr7" },
2292 { PT_FPR8, "fpr8" },
2293 { PT_FPR9, "fpr9" },
2294 { PT_FPR10, "fpr10" },
2295 { PT_FPR11, "fpr11" },
2296 { PT_FPR12, "fpr12" },
2297 { PT_FPR13, "fpr13" },
2298 { PT_FPR14, "fpr14" },
2299 { PT_FPR15, "fpr15" },
2302 { PT_CR_10, "cr10" },
2303 { PT_CR_11, "cr11" },
2304 { PT_IEEE_IP, "ieee_exception_ip" },
2307 /* XXX No support for these offsets yet. */
2309 /* XXX No support for these offsets yet. */
2310 #elif defined(POWERPC)
2312 #define PT_ORIG_R3 34
2314 #define REGSIZE (sizeof(unsigned long))
2315 { REGSIZE*PT_R0, "r0" },
2316 { REGSIZE*PT_R1, "r1" },
2317 { REGSIZE*PT_R2, "r2" },
2318 { REGSIZE*PT_R3, "r3" },
2319 { REGSIZE*PT_R4, "r4" },
2320 { REGSIZE*PT_R5, "r5" },
2321 { REGSIZE*PT_R6, "r6" },
2322 { REGSIZE*PT_R7, "r7" },
2323 { REGSIZE*PT_R8, "r8" },
2324 { REGSIZE*PT_R9, "r9" },
2325 { REGSIZE*PT_R10, "r10" },
2326 { REGSIZE*PT_R11, "r11" },
2327 { REGSIZE*PT_R12, "r12" },
2328 { REGSIZE*PT_R13, "r13" },
2329 { REGSIZE*PT_R14, "r14" },
2330 { REGSIZE*PT_R15, "r15" },
2331 { REGSIZE*PT_R16, "r16" },
2332 { REGSIZE*PT_R17, "r17" },
2333 { REGSIZE*PT_R18, "r18" },
2334 { REGSIZE*PT_R19, "r19" },
2335 { REGSIZE*PT_R20, "r20" },
2336 { REGSIZE*PT_R21, "r21" },
2337 { REGSIZE*PT_R22, "r22" },
2338 { REGSIZE*PT_R23, "r23" },
2339 { REGSIZE*PT_R24, "r24" },
2340 { REGSIZE*PT_R25, "r25" },
2341 { REGSIZE*PT_R26, "r26" },
2342 { REGSIZE*PT_R27, "r27" },
2343 { REGSIZE*PT_R28, "r28" },
2344 { REGSIZE*PT_R29, "r29" },
2345 { REGSIZE*PT_R30, "r30" },
2346 { REGSIZE*PT_R31, "r31" },
2347 { REGSIZE*PT_NIP, "NIP" },
2348 { REGSIZE*PT_MSR, "MSR" },
2349 { REGSIZE*PT_ORIG_R3, "ORIG_R3" },
2350 { REGSIZE*PT_CTR, "CTR" },
2351 { REGSIZE*PT_LNK, "LNK" },
2352 { REGSIZE*PT_XER, "XER" },
2353 { REGSIZE*PT_CCR, "CCR" },
2354 { REGSIZE*PT_FPR0, "FPR0" },
2425 { PT_F32, "f32" }, { PT_F33, "f33" }, { PT_F34, "f34" },
2426 { PT_F35, "f35" }, { PT_F36, "f36" }, { PT_F37, "f37" },
2427 { PT_F38, "f38" }, { PT_F39, "f39" }, { PT_F40, "f40" },
2428 { PT_F41, "f41" }, { PT_F42, "f42" }, { PT_F43, "f43" },
2429 { PT_F44, "f44" }, { PT_F45, "f45" }, { PT_F46, "f46" },
2430 { PT_F47, "f47" }, { PT_F48, "f48" }, { PT_F49, "f49" },
2431 { PT_F50, "f50" }, { PT_F51, "f51" }, { PT_F52, "f52" },
2432 { PT_F53, "f53" }, { PT_F54, "f54" }, { PT_F55, "f55" },
2433 { PT_F56, "f56" }, { PT_F57, "f57" }, { PT_F58, "f58" },
2434 { PT_F59, "f59" }, { PT_F60, "f60" }, { PT_F61, "f61" },
2435 { PT_F62, "f62" }, { PT_F63, "f63" }, { PT_F64, "f64" },
2436 { PT_F65, "f65" }, { PT_F66, "f66" }, { PT_F67, "f67" },
2437 { PT_F68, "f68" }, { PT_F69, "f69" }, { PT_F70, "f70" },
2438 { PT_F71, "f71" }, { PT_F72, "f72" }, { PT_F73, "f73" },
2439 { PT_F74, "f74" }, { PT_F75, "f75" }, { PT_F76, "f76" },
2440 { PT_F77, "f77" }, { PT_F78, "f78" }, { PT_F79, "f79" },
2441 { PT_F80, "f80" }, { PT_F81, "f81" }, { PT_F82, "f82" },
2442 { PT_F83, "f83" }, { PT_F84, "f84" }, { PT_F85, "f85" },
2443 { PT_F86, "f86" }, { PT_F87, "f87" }, { PT_F88, "f88" },
2444 { PT_F89, "f89" }, { PT_F90, "f90" }, { PT_F91, "f91" },
2445 { PT_F92, "f92" }, { PT_F93, "f93" }, { PT_F94, "f94" },
2446 { PT_F95, "f95" }, { PT_F96, "f96" }, { PT_F97, "f97" },
2447 { PT_F98, "f98" }, { PT_F99, "f99" }, { PT_F100, "f100" },
2448 { PT_F101, "f101" }, { PT_F102, "f102" }, { PT_F103, "f103" },
2449 { PT_F104, "f104" }, { PT_F105, "f105" }, { PT_F106, "f106" },
2450 { PT_F107, "f107" }, { PT_F108, "f108" }, { PT_F109, "f109" },
2451 { PT_F110, "f110" }, { PT_F111, "f111" }, { PT_F112, "f112" },
2452 { PT_F113, "f113" }, { PT_F114, "f114" }, { PT_F115, "f115" },
2453 { PT_F116, "f116" }, { PT_F117, "f117" }, { PT_F118, "f118" },
2454 { PT_F119, "f119" }, { PT_F120, "f120" }, { PT_F121, "f121" },
2455 { PT_F122, "f122" }, { PT_F123, "f123" }, { PT_F124, "f124" },
2456 { PT_F125, "f125" }, { PT_F126, "f126" }, { PT_F127, "f127" },
2458 { PT_F2, "f2" }, { PT_F3, "f3" }, { PT_F4, "f4" },
2459 { PT_F5, "f5" }, { PT_F10, "f10" }, { PT_F11, "f11" },
2460 { PT_F12, "f12" }, { PT_F13, "f13" }, { PT_F14, "f14" },
2461 { PT_F15, "f15" }, { PT_F16, "f16" }, { PT_F17, "f17" },
2462 { PT_F18, "f18" }, { PT_F19, "f19" }, { PT_F20, "f20" },
2463 { PT_F21, "f21" }, { PT_F22, "f22" }, { PT_F23, "f23" },
2464 { PT_F24, "f24" }, { PT_F25, "f25" }, { PT_F26, "f26" },
2465 { PT_F27, "f27" }, { PT_F28, "f28" }, { PT_F29, "f29" },
2466 { PT_F30, "f30" }, { PT_F31, "f31" }, { PT_R4, "r4" },
2467 { PT_R5, "r5" }, { PT_R6, "r6" }, { PT_R7, "r7" },
2468 { PT_B1, "b1" }, { PT_B2, "b2" }, { PT_B3, "b3" },
2469 { PT_B4, "b4" }, { PT_B5, "b5" },
2470 { PT_AR_EC, "ar.ec" }, { PT_AR_LC, "ar.lc" },
2472 { PT_CR_IPSR, "psr" }, { PT_CR_IIP, "ip" },
2473 { PT_CFM, "cfm" }, { PT_AR_UNAT, "ar.unat" },
2474 { PT_AR_PFS, "ar.pfs" }, { PT_AR_RSC, "ar.rsc" },
2475 { PT_AR_RNAT, "ar.rnat" }, { PT_AR_BSPSTORE, "ar.bspstore" },
2476 { PT_PR, "pr" }, { PT_B6, "b6" }, { PT_AR_BSP, "ar.bsp" },
2477 { PT_R1, "r1" }, { PT_R2, "r2" }, { PT_R3, "r3" },
2478 { PT_R12, "r12" }, { PT_R13, "r13" }, { PT_R14, "r14" },
2479 { PT_R15, "r15" }, { PT_R8, "r8" }, { PT_R9, "r9" },
2480 { PT_R10, "r10" }, { PT_R11, "r11" }, { PT_R16, "r16" },
2481 { PT_R17, "r17" }, { PT_R18, "r18" }, { PT_R19, "r19" },
2482 { PT_R20, "r20" }, { PT_R21, "r21" }, { PT_R22, "r22" },
2483 { PT_R23, "r23" }, { PT_R24, "r24" }, { PT_R25, "r25" },
2484 { PT_R26, "r26" }, { PT_R27, "r27" }, { PT_R28, "r28" },
2485 { PT_R29, "r29" }, { PT_R30, "r30" }, { PT_R31, "r31" },
2486 { PT_AR_CCV, "ar.ccv" }, { PT_AR_FPSR, "ar.fpsr" },
2487 { PT_B0, "b0" }, { PT_B7, "b7" }, { PT_F6, "f6" },
2488 { PT_F7, "f7" }, { PT_F8, "f8" }, { PT_F9, "f9" },
2490 { PT_AR_CSD, "ar.csd" },
2493 { PT_AR_SSD, "ar.ssd" },
2495 { PT_DBR, "dbr" }, { PT_IBR, "ibr" }, { PT_PMD, "pmd" },
2509 { 4*ORIG_EAX, "4*ORIG_EAX" },
2513 { 4*UESP, "4*UESP" },
2533 { 8*ORIG_RAX, "8*ORIG_EAX" },
2536 { 8*EFLAGS, "8*EFL" },
2546 { 4*PT_D1, "4*PT_D1" },
2547 { 4*PT_D2, "4*PT_D2" },
2548 { 4*PT_D3, "4*PT_D3" },
2549 { 4*PT_D4, "4*PT_D4" },
2550 { 4*PT_D5, "4*PT_D5" },
2551 { 4*PT_D6, "4*PT_D6" },
2552 { 4*PT_D7, "4*PT_D7" },
2553 { 4*PT_A0, "4*PT_A0" },
2554 { 4*PT_A1, "4*PT_A1" },
2555 { 4*PT_A2, "4*PT_A2" },
2556 { 4*PT_A3, "4*PT_A3" },
2557 { 4*PT_A4, "4*PT_A4" },
2558 { 4*PT_A5, "4*PT_A5" },
2559 { 4*PT_A6, "4*PT_A6" },
2560 { 4*PT_D0, "4*PT_D0" },
2561 { 4*PT_USP, "4*PT_USP" },
2562 { 4*PT_ORIG_D0, "4*PT_ORIG_D0" },
2563 { 4*PT_SR, "4*PT_SR" },
2564 { 4*PT_PC, "4*PT_PC" },
2568 { 4*REG_REG0, "4*REG_REG0" },
2569 { 4*(REG_REG0+1), "4*REG_REG1" },
2570 { 4*(REG_REG0+2), "4*REG_REG2" },
2571 { 4*(REG_REG0+3), "4*REG_REG3" },
2572 { 4*(REG_REG0+4), "4*REG_REG4" },
2573 { 4*(REG_REG0+5), "4*REG_REG5" },
2574 { 4*(REG_REG0+6), "4*REG_REG6" },
2575 { 4*(REG_REG0+7), "4*REG_REG7" },
2576 { 4*(REG_REG0+8), "4*REG_REG8" },
2577 { 4*(REG_REG0+9), "4*REG_REG9" },
2578 { 4*(REG_REG0+10), "4*REG_REG10" },
2579 { 4*(REG_REG0+11), "4*REG_REG11" },
2580 { 4*(REG_REG0+12), "4*REG_REG12" },
2581 { 4*(REG_REG0+13), "4*REG_REG13" },
2582 { 4*(REG_REG0+14), "4*REG_REG14" },
2583 { 4*REG_REG15, "4*REG_REG15" },
2584 { 4*REG_PC, "4*REG_PC" },
2585 { 4*REG_PR, "4*REG_PR" },
2586 { 4*REG_SR, "4*REG_SR" },
2587 { 4*REG_GBR, "4*REG_GBR" },
2588 { 4*REG_MACH, "4*REG_MACH" },
2589 { 4*REG_MACL, "4*REG_MACL" },
2590 { 4*REG_SYSCALL, "4*REG_SYSCALL" },
2591 { 4*REG_FPUL, "4*REG_FPUL" },
2592 { 4*REG_FPREG0, "4*REG_FPREG0" },
2593 { 4*(REG_FPREG0+1), "4*REG_FPREG1" },
2594 { 4*(REG_FPREG0+2), "4*REG_FPREG2" },
2595 { 4*(REG_FPREG0+3), "4*REG_FPREG3" },
2596 { 4*(REG_FPREG0+4), "4*REG_FPREG4" },
2597 { 4*(REG_FPREG0+5), "4*REG_FPREG5" },
2598 { 4*(REG_FPREG0+6), "4*REG_FPREG6" },
2599 { 4*(REG_FPREG0+7), "4*REG_FPREG7" },
2600 { 4*(REG_FPREG0+8), "4*REG_FPREG8" },
2601 { 4*(REG_FPREG0+9), "4*REG_FPREG9" },
2602 { 4*(REG_FPREG0+10), "4*REG_FPREG10" },
2603 { 4*(REG_FPREG0+11), "4*REG_FPREG11" },
2604 { 4*(REG_FPREG0+12), "4*REG_FPREG12" },
2605 { 4*(REG_FPREG0+13), "4*REG_FPREG13" },
2606 { 4*(REG_FPREG0+14), "4*REG_FPREG14" },
2607 { 4*REG_FPREG15, "4*REG_FPREG15" },
2609 { 4*REG_XDREG0, "4*REG_XDREG0" },
2610 { 4*(REG_XDREG0+2), "4*REG_XDREG2" },
2611 { 4*(REG_XDREG0+4), "4*REG_XDREG4" },
2612 { 4*(REG_XDREG0+6), "4*REG_XDREG6" },
2613 { 4*(REG_XDREG0+8), "4*REG_XDREG8" },
2614 { 4*(REG_XDREG0+10), "4*REG_XDREG10" },
2615 { 4*(REG_XDREG0+12), "4*REG_XDREG12" },
2616 { 4*REG_XDREG14, "4*REG_XDREG14" },
2618 { 4*REG_FPSCR, "4*REG_FPSCR" },
2625 { 16, "syscall no.(L)" },
2626 { 20, "syscall_no.(U)" },
2769 /* This entry is in case pt_regs contains dregs (depends on
2770 the kernel build options). */
2771 { uoff(regs), "offsetof(struct user, regs)" },
2772 { uoff(fpu), "offsetof(struct user, fpu)" },
2775 { uoff(regs.ARM_r0), "r0" },
2776 { uoff(regs.ARM_r1), "r1" },
2777 { uoff(regs.ARM_r2), "r2" },
2778 { uoff(regs.ARM_r3), "r3" },
2779 { uoff(regs.ARM_r4), "r4" },
2780 { uoff(regs.ARM_r5), "r5" },
2781 { uoff(regs.ARM_r6), "r6" },
2782 { uoff(regs.ARM_r7), "r7" },
2783 { uoff(regs.ARM_r8), "r8" },
2784 { uoff(regs.ARM_r9), "r9" },
2785 { uoff(regs.ARM_r10), "r10" },
2786 { uoff(regs.ARM_fp), "fp" },
2787 { uoff(regs.ARM_ip), "ip" },
2788 { uoff(regs.ARM_sp), "sp" },
2789 { uoff(regs.ARM_lr), "lr" },
2790 { uoff(regs.ARM_pc), "pc" },
2791 { uoff(regs.ARM_cpsr), "cpsr" },
2794 #if !defined(S390) && !defined(S390X) && !defined(MIPS)
2795 { uoff(u_fpvalid), "offsetof(struct user, u_fpvalid)" },
2797 #if defined(I386) || defined(X86_64)
2798 { uoff(i387), "offsetof(struct user, i387)" },
2801 { uoff(m68kfp), "offsetof(struct user, m68kfp)" },
2804 { uoff(u_tsize), "offsetof(struct user, u_tsize)" },
2805 { uoff(u_dsize), "offsetof(struct user, u_dsize)" },
2806 { uoff(u_ssize), "offsetof(struct user, u_ssize)" },
2807 { uoff(start_code), "offsetof(struct user, start_code)" },
2809 { uoff(start_data), "offsetof(struct user, start_data)" },
2811 { uoff(start_stack), "offsetof(struct user, start_stack)" },
2812 { uoff(signal), "offsetof(struct user, signal)" },
2813 #if !defined(S390) && !defined(S390X) && !defined(MIPS) && !defined(SH) && !defined(SH64)
2814 { uoff(reserved), "offsetof(struct user, reserved)" },
2816 { uoff(u_ar0), "offsetof(struct user, u_ar0)" },
2817 #if !defined(ARM) && !defined(MIPS) && !defined(S390) && !defined(S390X)
2818 { uoff(u_fpstate), "offsetof(struct user, u_fpstate)" },
2820 { uoff(magic), "offsetof(struct user, magic)" },
2821 { uoff(u_comm), "offsetof(struct user, u_comm)" },
2822 #if defined(I386) || defined(X86_64)
2823 { uoff(u_debugreg), "offsetof(struct user, u_debugreg)" },
2827 #endif /* !POWERPC/!SPARC */
2830 { uoff(u_pcb), "offsetof(struct user, u_pcb)" },
2831 { uoff(u_procp), "offsetof(struct user, u_procp)" },
2832 { uoff(u_ar0), "offsetof(struct user, u_ar0)" },
2833 { uoff(u_comm[0]), "offsetof(struct user, u_comm[0])" },
2834 { uoff(u_arg[0]), "offsetof(struct user, u_arg[0])" },
2835 { uoff(u_ap), "offsetof(struct user, u_ap)" },
2836 { uoff(u_qsave), "offsetof(struct user, u_qsave)" },
2837 { uoff(u_rval1), "offsetof(struct user, u_rval1)" },
2838 { uoff(u_rval2), "offsetof(struct user, u_rval2)" },
2839 { uoff(u_error), "offsetof(struct user, u_error)" },
2840 { uoff(u_eosys), "offsetof(struct user, u_eosys)" },
2841 { uoff(u_ssave), "offsetof(struct user, u_ssave)" },
2842 { uoff(u_signal[0]), "offsetof(struct user, u_signal)" },
2843 { uoff(u_sigmask[0]), "offsetof(struct user, u_sigmask)" },
2844 { uoff(u_sigonstack), "offsetof(struct user, u_sigonstack)" },
2845 { uoff(u_sigintr), "offsetof(struct user, u_sigintr)" },
2846 { uoff(u_sigreset), "offsetof(struct user, u_sigreset)" },
2847 { uoff(u_oldmask), "offsetof(struct user, u_oldmask)" },
2848 { uoff(u_code), "offsetof(struct user, u_code)" },
2849 { uoff(u_addr), "offsetof(struct user, u_addr)" },
2850 { uoff(u_sigstack), "offsetof(struct user, u_sigstack)" },
2851 { uoff(u_ofile), "offsetof(struct user, u_ofile)" },
2852 { uoff(u_pofile), "offsetof(struct user, u_pofile)" },
2853 { uoff(u_ofile_arr[0]), "offsetof(struct user, u_ofile_arr[0])" },
2854 { uoff(u_pofile_arr[0]),"offsetof(struct user, u_pofile_arr[0])"},
2855 { uoff(u_lastfile), "offsetof(struct user, u_lastfile)" },
2856 { uoff(u_cwd), "offsetof(struct user, u_cwd)" },
2857 { uoff(u_cdir), "offsetof(struct user, u_cdir)" },
2858 { uoff(u_rdir), "offsetof(struct user, u_rdir)" },
2859 { uoff(u_cmask), "offsetof(struct user, u_cmask)" },
2860 { uoff(u_ru), "offsetof(struct user, u_ru)" },
2861 { uoff(u_cru), "offsetof(struct user, u_cru)" },
2862 { uoff(u_timer[0]), "offsetof(struct user, u_timer[0])" },
2863 { uoff(u_XXX[0]), "offsetof(struct user, u_XXX[0])" },
2864 { uoff(u_ioch), "offsetof(struct user, u_ioch)" },
2865 { uoff(u_start), "offsetof(struct user, u_start)" },
2866 { uoff(u_acflag), "offsetof(struct user, u_acflag)" },
2867 { uoff(u_prof.pr_base), "offsetof(struct user, u_prof.pr_base)" },
2868 { uoff(u_prof.pr_size), "offsetof(struct user, u_prof.pr_size)" },
2869 { uoff(u_prof.pr_off), "offsetof(struct user, u_prof.pr_off)" },
2870 { uoff(u_prof.pr_scale),"offsetof(struct user, u_prof.pr_scale)"},
2871 { uoff(u_rlimit[0]), "offsetof(struct user, u_rlimit)" },
2872 { uoff(u_exdata.Ux_A), "offsetof(struct user, u_exdata.Ux_A)" },
2873 { uoff(u_exdata.ux_shell[0]),"offsetof(struct user, u_exdata.ux_shell[0])"},
2874 { uoff(u_lofault), "offsetof(struct user, u_lofault)" },
2877 { sizeof(struct user), "sizeof(struct user)" },
2890 if (entering(tcp)) {
2891 printxval(ptrace_cmds, tcp->u_arg[0],
2898 tprintf(", %lu, ", tcp->u_arg[1]);
2899 addr = tcp->u_arg[2];
2901 if (tcp->u_arg[0] == PTRACE_PEEKUSER
2902 || tcp->u_arg[0] == PTRACE_POKEUSER) {
2903 for (x = struct_user_offsets; x->str; x++) {
2908 tprintf("%#lx, ", addr);
2909 else if (x->val > addr && x != struct_user_offsets) {
2911 tprintf("%s + %ld, ", x->str, addr - x->val);
2914 tprintf("%s, ", x->str);
2918 tprintf("%#lx, ", tcp->u_arg[2]);
2920 switch (tcp->u_arg[0]) {
2921 case PTRACE_PEEKDATA:
2922 case PTRACE_PEEKTEXT:
2923 case PTRACE_PEEKUSER:
2926 case PTRACE_SINGLESTEP:
2927 case PTRACE_SYSCALL:
2929 printsignal(tcp->u_arg[3]);
2932 tprintf("%#lx", tcp->u_arg[3]);
2936 switch (tcp->u_arg[0]) {
2937 case PTRACE_PEEKDATA:
2938 case PTRACE_PEEKTEXT:
2939 case PTRACE_PEEKUSER:
2940 printnum(tcp, tcp->u_arg[3], "%#lx");
2946 if (tcp->u_arg[0] == PTRACE_WRITEDATA ||
2947 tcp->u_arg[0] == PTRACE_WRITETEXT) {
2948 tprintf("%lu, ", tcp->u_arg[3]);
2949 printstr(tcp, tcp->u_arg[4], tcp->u_arg[3]);
2950 } else if (tcp->u_arg[0] != PTRACE_READDATA &&
2951 tcp->u_arg[0] != PTRACE_READTEXT) {
2952 tprintf("%#lx", tcp->u_arg[3]);
2955 if (tcp->u_arg[0] == PTRACE_READDATA ||
2956 tcp->u_arg[0] == PTRACE_READTEXT) {
2957 tprintf("%lu, ", tcp->u_arg[3]);
2958 printstr(tcp, tcp->u_arg[4], tcp->u_arg[3]);
2963 tprintf("%lu", tcp->u_arg[3]);
2965 #endif /* FREEBSD */
2972 static struct xlat futexops[] = {
2973 { FUTEX_WAIT, "FUTEX_WAIT" },
2974 { FUTEX_WAKE, "FUTEX_WAKE" },
2975 { FUTEX_FD, "FUTEX_FD" },
2976 { FUTEX_REQUEUE,"FUTEX_REQUEUE" },
2984 if (entering(tcp)) {
2985 tprintf("%p, ", (void *) tcp->u_arg[0]);
2986 printxval(futexops, tcp->u_arg[1], "FUTEX_???");
2987 tprintf(", %ld", tcp->u_arg[2]);
2988 if (tcp->u_arg[1] == FUTEX_WAIT) {
2990 printtv(tcp, tcp->u_arg[3]);
2991 } else if (tcp->u_arg[1] == FUTEX_REQUEUE)
2992 tprintf(", %ld, %p", tcp->u_arg[3], (void *) tcp->u_arg[4]);
2998 print_affinitylist(tcp, list, len)
3005 while (len >= sizeof (unsigned long)) {
3007 umove(tcp, list, &w);
3008 tprintf("%s %lx", first ? "" : ",", w);
3010 len -= sizeof (unsigned long);
3011 list += sizeof(unsigned long);
3017 sys_sched_setaffinity(tcp)
3020 if (entering(tcp)) {
3021 tprintf("%ld, %lu, ", tcp->u_arg[0], tcp->u_arg[1]);
3022 print_affinitylist(tcp, tcp->u_arg[2], tcp->u_arg[1]);
3028 sys_sched_getaffinity(tcp)
3031 if (entering(tcp)) {
3032 tprintf("%ld, %lu, ", tcp->u_arg[0], tcp->u_arg[1]);
3034 if (tcp->u_rval == -1)
3035 tprintf("%#lx", tcp->u_arg[2]);
3037 print_affinitylist(tcp, tcp->u_arg[2], tcp->u_rval);
3042 static struct xlat schedulers[] = {
3043 { SCHED_OTHER, "SCHED_OTHER" },
3044 { SCHED_RR, "SCHED_RR" },
3045 { SCHED_FIFO, "SCHED_FIFO" },
3050 sys_sched_getscheduler(tcp)
3053 if (entering(tcp)) {
3054 tprintf("%d", (int) tcp->u_arg[0]);
3055 } else if (! syserror(tcp)) {
3056 tcp->auxstr = xlookup (schedulers, tcp->u_rval);
3057 if (tcp->auxstr != NULL)
3064 sys_sched_setscheduler(tcp)
3067 if (entering(tcp)) {
3068 struct sched_param p;
3069 tprintf("%d, ", (int) tcp->u_arg[0]);
3070 printxval(schedulers, tcp->u_arg[1], "SCHED_???");
3071 if (umove(tcp, tcp->u_arg[2], &p) < 0)
3072 tprintf(", %lx", tcp->u_arg[2]);
3074 tprintf(", { %d }", p.__sched_priority);
3080 sys_sched_getparam(tcp)
3083 if (entering(tcp)) {
3084 tprintf("%d, ", (int) tcp->u_arg[0]);
3086 struct sched_param p;
3087 if (umove(tcp, tcp->u_arg[1], &p) < 0)
3088 tprintf("%lx", tcp->u_arg[1]);
3090 tprintf("{ %d }", p.__sched_priority);
3096 sys_sched_setparam(tcp)
3099 if (entering(tcp)) {
3100 struct sched_param p;
3101 if (umove(tcp, tcp->u_arg[1], &p) < 0)
3102 tprintf("%d, %lx", (int) tcp->u_arg[0], tcp->u_arg[1]);
3104 tprintf("%d, { %d }", (int) tcp->u_arg[0], p.__sched_priority);
3110 sys_sched_get_priority_min(tcp)
3113 if (entering(tcp)) {
3114 printxval(schedulers, tcp->u_arg[0], "SCHED_???");