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>
60 #if defined (SPARC) || defined (SPARC64)
61 # define fpq kernel_fpq
63 # define fpu kernel_fpu
64 #endif /* SPARC || SPARC64 */
66 #if defined (SPARC) || defined (SPARC64)
70 #endif /* SPARC || SPARC64 */
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 #if defined (LINUX) && defined (SPARC64)
98 # undef PTRACE_GETREGS
99 # define PTRACE_GETREGS PTRACE_GETREGS64
100 # undef PTRACE_SETREGS
101 # define PTRACE_SETREGS PTRACE_SETREGS64
102 #endif /* LINUX && SPARC64 */
104 #ifdef HAVE_LINUX_FUTEX_H
105 #include <linux/futex.h>
109 # define FUTEX_WAIT 0
112 # define FUTEX_WAKE 1
117 # ifndef FUTEX_REQUEUE
118 # define FUTEX_REQUEUE 3
124 #include <asm/posix_types.h>
126 #define GETGROUPS_T __kernel_gid_t
128 #define GETGROUPS32_T __kernel_gid32_t
131 #if defined(LINUX) && defined(IA64)
132 # include <asm/ptrace_offsets.h>
133 # include <asm/rse.h>
137 #include <sys/prctl.h>
141 #define WCOREDUMP(status) ((status) & 0200)
144 /* WTA: this was `&& !defined(LINUXSPARC)', this seems unneeded though? */
145 #if defined(HAVE_PRCTL)
146 static const struct xlat prctl_options[] = {
148 { PR_MAXPROCS, "PR_MAXPROCS" },
151 { PR_ISBLOCKED, "PR_ISBLOCKED" },
153 #ifdef PR_SETSTACKSIZE
154 { PR_SETSTACKSIZE, "PR_SETSTACKSIZE" },
156 #ifdef PR_GETSTACKSIZE
157 { PR_GETSTACKSIZE, "PR_GETSTACKSIZE" },
160 { PR_MAXPPROCS, "PR_MAXPPROCS" },
162 #ifdef PR_UNBLKONEXEC
163 { PR_UNBLKONEXEC, "PR_UNBLKONEXEC" },
166 { PR_ATOMICSIM, "PR_ATOMICSIM" },
169 { PR_SETEXITSIG, "PR_SETEXITSIG" },
172 { PR_RESIDENT, "PR_RESIDENT" },
175 { PR_ATTACHADDR, "PR_ATTACHADDR" },
178 { PR_DETACHADDR, "PR_DETACHADDR" },
181 { PR_TERMCHILD, "PR_TERMCHILD" },
184 { PR_GETSHMASK, "PR_GETSHMASK" },
187 { PR_GETNSHARE, "PR_GETNSHARE" },
189 #if defined(PR_SET_PDEATHSIG)
190 { PR_SET_PDEATHSIG, "PR_SET_PDEATHSIG" },
193 { PR_COREPID, "PR_COREPID" },
195 #ifdef PR_ATTACHADDRPERM
196 { PR_ATTACHADDRPERM, "PR_ATTACHADDRPERM" },
198 #ifdef PR_PTHREADEXIT
199 { PR_PTHREADEXIT, "PR_PTHREADEXIT" },
201 #ifdef PR_SET_PDEATHSIG
202 { PR_SET_PDEATHSIG, "PR_SET_PDEATHSIG" },
204 #ifdef PR_GET_PDEATHSIG
205 { PR_GET_PDEATHSIG, "PR_GET_PDEATHSIG" },
207 #ifdef PR_GET_UNALIGN
208 { PR_GET_UNALIGN, "PR_GET_UNALIGN" },
210 #ifdef PR_SET_UNALIGN
211 { PR_SET_UNALIGN, "PR_SET_UNALIGN" },
213 #ifdef PR_GET_KEEPCAPS
214 { PR_GET_KEEPCAPS, "PR_GET_KEEP_CAPS" },
216 #ifdef PR_SET_KEEPCAPS
217 { PR_SET_KEEPCAPS, "PR_SET_KEEP_CAPS" },
224 unalignctl_string (unsigned int ctl)
229 #ifdef PR_UNALIGN_NOPRINT
230 case PR_UNALIGN_NOPRINT:
233 #ifdef PR_UNALIGN_SIGBUS
234 case PR_UNALIGN_SIGBUS:
240 sprintf(buf, "%x", ctl);
252 printxval(prctl_options, tcp->u_arg[0], "PR_???");
253 switch (tcp->u_arg[0]) {
258 #ifdef PR_SET_DEATHSIG
259 case PR_GET_PDEATHSIG:
262 #ifdef PR_SET_UNALIGN
264 tprintf(", %s", unalignctl_string(tcp->u_arg[1]));
267 #ifdef PR_GET_UNALIGN
269 tprintf(", %#lx", tcp->u_arg[1]);
273 for (i = 1; i < tcp->u_nargs; i++)
274 tprintf(", %#lx", tcp->u_arg[i]);
278 switch (tcp->u_arg[0]) {
279 #ifdef PR_GET_PDEATHSIG
280 case PR_GET_PDEATHSIG:
281 for (i=1; i<tcp->u_nargs; i++)
282 tprintf(", %#lx", tcp->u_arg[i]);
285 #ifdef PR_SET_UNALIGN
289 #ifdef PR_GET_UNALIGN
294 umove(tcp, tcp->u_arg[1], &ctl);
295 tcp->auxstr = unalignctl_string(ctl);
306 #endif /* HAVE_PRCTL */
322 printpathn(tcp, tcp->u_arg[0], tcp->u_arg[1]);
323 tprintf(", %lu", tcp->u_arg[1]);
334 tprintf("%#lx", tcp->u_arg[0]);
336 printpath(tcp, tcp->u_arg[0]);
337 tprintf(", %lu", tcp->u_arg[1]);
343 sys_setdomainname(tcp)
347 printpathn(tcp, tcp->u_arg[0], tcp->u_arg[1]);
348 tprintf(", %lu", tcp->u_arg[1]);
356 sys_getdomainname(tcp)
361 tprintf("%#lx", tcp->u_arg[0]);
363 printpath(tcp, tcp->u_arg[0]);
364 tprintf(", %lu", tcp->u_arg[1]);
375 fprintf(stderr, "_exit returned!\n");
378 /* special case: we stop tracing this process, finish line now */
379 tprintf("%ld) ", tcp->u_arg[0]);
391 tcp->flags |= TCB_EXITING;
392 #ifdef __NR_exit_group
395 if (tcp->scno == 252)
396 tcp->flags |= TCB_GROUP_EXITING;
399 if (known_scno(tcp) == __NR_exit_group)
400 tcp->flags |= TCB_GROUP_EXITING;
406 /* TCP is creating a child we want to follow.
407 If there will be space in tcbtab for it, set TCB_FOLLOWFORK and return 0.
408 If not, clear TCB_FOLLOWFORK, print an error, and return 1. */
410 fork_tcb(struct tcb *tcp)
412 if (nprocs == tcbtabsize) {
413 if (expand_tcbtab()) {
414 tcp->flags &= ~TCB_FOLLOWFORK;
415 fprintf(stderr, "sys_fork: tcb table full\n");
419 tcp->flags |= TCB_FOLLOWFORK;
431 tcp->auxstr = "child process";
432 return RVAL_UDECIMAL | RVAL_STR;
445 tprintf ("%ld", tcp->u_arg[0]);
449 tcp->auxstr = "child process";
450 return RVAL_UDECIMAL | RVAL_STR;
462 struct tcb *tcpchild;
466 if (known_scno(tcp) == SYS_rfork && !(tcp->u_arg[0]&RFPROC))
477 if ((tcpchild = alloctcb(tcp->u_rval)) == NULL) {
478 fprintf(stderr, "sys_fork: tcb table full\n");
481 if (proc_open(tcpchild, 2) < 0)
487 #else /* !USE_PROCFS */
491 /* defines copied from linux/sched.h since we can't include that
492 * ourselves (it conflicts with *lots* of libc includes)
494 #define CSIGNAL 0x000000ff /* signal mask to be sent at exit */
495 #define CLONE_VM 0x00000100 /* set if VM shared between processes */
496 #define CLONE_FS 0x00000200 /* set if fs info shared between processes */
497 #define CLONE_FILES 0x00000400 /* set if open files shared between processes */
498 #define CLONE_SIGHAND 0x00000800 /* set if signal handlers shared */
499 #define CLONE_IDLETASK 0x00001000 /* kernel-only flag */
500 #define CLONE_PTRACE 0x00002000 /* set if we want to let tracing continue on the child too */
501 #define CLONE_VFORK 0x00004000 /* set if the parent wants the child to wake it up on mm_release */
502 #define CLONE_PARENT 0x00008000 /* set if we want to have the same parent as the cloner */
503 #define CLONE_THREAD 0x00010000 /* Same thread group? */
504 #define CLONE_NEWNS 0x00020000 /* New namespace group? */
505 #define CLONE_SYSVSEM 0x00040000 /* share system V SEM_UNDO semantics */
506 #define CLONE_SETTLS 0x00080000 /* create a new TLS for the child */
507 #define CLONE_PARENT_SETTID 0x00100000 /* set the TID in the parent */
508 #define CLONE_CHILD_CLEARTID 0x00200000 /* clear the TID in the child */
509 #define CLONE_DETACHED 0x00400000 /* parent wants no child-exit signal */
510 #define CLONE_UNTRACED 0x00800000 /* set if the tracing process can't force CLONE_PTRACE on this clone */
511 #define CLONE_CHILD_SETTID 0x01000000 /* set the TID in the child */
513 static const struct xlat clone_flags[] = {
514 { CLONE_VM, "CLONE_VM" },
515 { CLONE_FS, "CLONE_FS" },
516 { CLONE_FILES, "CLONE_FILES" },
517 { CLONE_SIGHAND, "CLONE_SIGHAND" },
518 { CLONE_IDLETASK, "CLONE_IDLETASK"},
519 { CLONE_PTRACE, "CLONE_PTRACE" },
520 { CLONE_VFORK, "CLONE_VFORK" },
521 { CLONE_PARENT, "CLONE_PARENT" },
522 { CLONE_THREAD, "CLONE_THREAD" },
523 { CLONE_NEWNS, "CLONE_NEWNS" },
524 { CLONE_SYSVSEM, "CLONE_SYSVSEM" },
525 { CLONE_SETTLS, "CLONE_SETTLS" },
526 { CLONE_PARENT_SETTID,"CLONE_PARENT_SETTID" },
527 { CLONE_CHILD_CLEARTID,"CLONE_CHILD_CLEARTID" },
528 { CLONE_DETACHED, "CLONE_DETACHED" },
529 { CLONE_UNTRACED, "CLONE_UNTRACED" },
530 { CLONE_CHILD_SETTID,"CLONE_CHILD_SETTID" },
535 # include <asm/ldt.h>
536 # ifdef HAVE_STRUCT_USER_DESC
537 # define modify_ldt_ldt_s user_desc
539 extern void print_ldt_entry();
545 # define ARG_STACKSIZE (known_scno(tcp) == SYS_clone2 ? 2 : -1)
546 # define ARG_PTID (known_scno(tcp) == SYS_clone2 ? 3 : 2)
547 # define ARG_CTID (known_scno(tcp) == SYS_clone2 ? 4 : 3)
548 # define ARG_TLS (known_scno(tcp) == SYS_clone2 ? 5 : 4)
549 # elif defined S390 || defined S390X
555 # elif defined X86_64 || defined ALPHA
574 unsigned long flags = tcp->u_arg[ARG_FLAGS];
575 tprintf("child_stack=%#lx, ", tcp->u_arg[ARG_STACK]);
576 # ifdef ARG_STACKSIZE
577 if (ARG_STACKSIZE != -1)
578 tprintf("stack_size=%#lx, ",
579 tcp->u_arg[ARG_STACKSIZE]);
582 printflags(clone_flags, flags &~ CSIGNAL, NULL);
583 if ((flags & CSIGNAL) != 0)
584 tprintf("|%s", signame(flags & CSIGNAL));
585 if ((flags & (CLONE_PARENT_SETTID|CLONE_CHILD_SETTID
586 |CLONE_CHILD_CLEARTID|CLONE_SETTLS)) == 0)
588 if (flags & CLONE_PARENT_SETTID)
589 tprintf(", parent_tidptr=%#lx", tcp->u_arg[ARG_PTID]);
590 if (flags & CLONE_SETTLS) {
592 struct modify_ldt_ldt_s copy;
593 if (umove(tcp, tcp->u_arg[ARG_TLS], ©) != -1) {
594 tprintf(", {entry_number:%d, ",
599 print_ldt_entry(©);
603 tprintf(", tls=%#lx", tcp->u_arg[ARG_TLS]);
605 if (flags & (CLONE_CHILD_SETTID|CLONE_CHILD_CLEARTID))
606 tprintf(", child_tidptr=%#lx", tcp->u_arg[ARG_CTID]);
617 return RVAL_UDECIMAL;
622 change_syscall(tcp, new)
628 /* Attempt to make vfork into fork, which we can follow. */
629 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(ORIG_EAX * 4), new) < 0)
632 #elif defined(X86_64)
633 /* Attempt to make vfork into fork, which we can follow. */
634 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(ORIG_RAX * 8), new) < 0)
637 #elif defined(POWERPC)
638 if (ptrace(PTRACE_POKEUSER, tcp->pid,
639 (char*)(sizeof(unsigned long)*PT_R0), new) < 0)
642 #elif defined(S390) || defined(S390X)
643 /* s390 linux after 2.4.7 has a hook in entry.S to allow this */
644 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_GPR2), new)<0)
648 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*PT_ORIG_D0), new)<0)
651 #elif defined(SPARC) || defined(SPARC64)
653 if (ptrace(PTRACE_GETREGS, tcp->pid, (char*)®s, 0)<0)
656 if (ptrace(PTRACE_SETREGS, tcp->pid, (char*)®s, 0)<0)
660 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_V0), new)<0)
664 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_A3), new)<0)
670 case 2: break; /* x86 SYS_fork */
671 case SYS_clone: new = 120; break;
673 fprintf(stderr, "%s: unexpected syscall %d\n",
677 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_R1), new)<0)
679 } else if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_R15), new)<0)
683 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_GR20), new)<0)
687 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*(REG_REG0+3)), new)<0)
691 /* Top half of reg encodes the no. of args n as 0x1n.
692 Assume 0 args as kernel never actually checks... */
693 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_SYSCALL),
698 #warning Do not know how to handle change_syscall for this architecture
699 #endif /* architecture */
712 unsigned long *bsp, *ap;
714 if (upeek(tcp->pid, PT_AR_BSP, (long *) &bsp) , 0)
717 ap = ia64_rse_skip_regs(bsp, argnum);
719 ptrace(PTRACE_POKEDATA, tcp->pid, (char *) ap, tcp->u_arg[argnum]);
726 ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*argnum), tcp->u_arg[argnum]);
730 #elif defined(X86_64)
732 ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(8*(long)argnum), tcp->u_arg[argnum]);
736 #elif defined(POWERPC)
738 #define PT_ORIG_R3 34
741 ptrace(PTRACE_POKEUSER, tcp->pid,
742 (char*)((argnum==0 ? PT_ORIG_R3 : argnum+PT_R3)*sizeof(unsigned long)),
751 ptrace(PTRACE_POKEUSER, tcp->pid,
752 (char*)(REG_A0 + argnum), tcp->u_arg[argnum]);
756 if (upeek(tcp->pid, REG_SP, (long *) &sp) , 0)
759 ptrace(PTRACE_POKEDATA, tcp->pid,
760 (char*)(sp + argnum - 4), tcp->u_arg[argnum]);
765 #elif defined(S390) || defined(S390X)
768 ptrace(PTRACE_POKEUSER, tcp->pid,
769 (char *) (argnum==0 ? PT_ORIGGPR2 :
770 PT_GPR2 + argnum*sizeof(long)),
778 # warning Sorry, setargs not implemented for this architecture.
784 #if defined SYS_clone || defined SYS_clone2
789 struct tcb *tcpchild;
799 int bpt = tcp->flags & TCB_BPTSET;
801 if (!(tcp->flags & TCB_FOLLOWFORK))
812 #ifdef CLONE_PTRACE /* See new setbpt code. */
813 tcpchild = pid2tcb(pid);
814 if (tcpchild != NULL) {
815 /* The child already reported its startup trap
816 before the parent reported its syscall return. */
818 & (TCB_STARTUP|TCB_ATTACHED|TCB_SUSPENDED))
819 != (TCB_STARTUP|TCB_ATTACHED|TCB_SUSPENDED))
821 [preattached child %d of %d in weird state!]\n",
826 if ((tcpchild = alloctcb(pid)) == NULL) {
829 fprintf(stderr, " [tcb table full]\n");
830 kill(pid, SIGKILL); /* XXX */
835 /* Attach to the new child */
836 if (ptrace(PTRACE_ATTACH, pid, (char *) 1, 0) < 0) {
839 perror("PTRACE_ATTACH");
840 fprintf(stderr, "Too late?\n");
849 tcpchild->flags |= TCB_ATTACHED;
850 /* Child has BPT too, must be removed on first occasion. */
852 tcpchild->flags |= TCB_BPTSET;
853 tcpchild->baddr = tcp->baddr;
854 memcpy(tcpchild->inst, tcp->inst,
855 sizeof tcpchild->inst);
857 tcpchild->parent = tcp;
859 if (tcpchild->flags & TCB_SUSPENDED) {
860 /* The child was born suspended, due to our having
861 forced CLONE_PTRACE. */
865 tcpchild->flags &= ~(TCB_SUSPENDED|TCB_STARTUP);
866 if (ptrace(PTRACE_SYSCALL, pid, (char *) 1, 0) < 0) {
867 perror("resume: ptrace(PTRACE_SYSCALL, ...)");
873 Process %u resumed (parent %d ready)\n",
879 fprintf(stderr, "Process %d attached\n", pid);
882 #ifdef TCB_CLONE_THREAD
885 * Save the flags used in this call,
886 * in case we point TCP to our parent below.
888 int call_flags = tcp->u_arg[ARG_FLAGS];
889 if ((tcp->flags & TCB_CLONE_THREAD) &&
890 tcp->parent != NULL) {
891 /* The parent in this clone is itself a
892 thread belonging to another process.
893 There is no meaning to the parentage
894 relationship of the new child with the
895 thread, only with the process. We
896 associate the new thread with our
897 parent. Since this is done for every
898 new thread, there will never be a
899 TCB_CLONE_THREAD process that has
903 tcpchild->parent = tcp;
906 if (call_flags & CLONE_THREAD) {
907 tcpchild->flags |= TCB_CLONE_THREAD;
908 ++tcp->nclone_threads;
910 if (call_flags & CLONE_DETACHED) {
911 tcpchild->flags |= TCB_CLONE_DETACHED;
912 ++tcp->nclone_detached;
927 /* We do special magic with clone for any clone or fork. */
928 return internal_clone(tcp);
931 struct tcb *tcpchild;
936 if (known_scno(tcp) == SYS_vfork) {
937 /* Attempt to make vfork into fork, which we can follow. */
939 change_syscall(tcp, SYS_fork) < 0)
944 if (!followfork || dont_follow)
952 int bpt = tcp->flags & TCB_BPTSET;
954 if (!(tcp->flags & TCB_FOLLOWFORK))
963 if ((tcpchild = alloctcb(pid)) == NULL) {
964 fprintf(stderr, " [tcb table full]\n");
965 kill(pid, SIGKILL); /* XXX */
970 /* The child must have run before it can be attached. */
971 /* This must be a bug in the parisc kernel, but I havn't
972 * identified it yet. Seems to be an issue associated
973 * with attaching to a process (which sends it a signal)
974 * before that process has ever been scheduled. When
975 * debugging, I started seeing crashes in
976 * arch/parisc/kernel/signal.c:do_signal(), apparently
977 * caused by r8 getting corrupt over the dequeue_signal()
978 * call. Didn't make much sense though...
984 select(0, NULL, NULL, NULL, &tv);
987 if (ptrace(PTRACE_ATTACH, pid, (char *) 1, 0) < 0) {
988 perror("PTRACE_ATTACH");
989 fprintf(stderr, "Too late?\n");
996 /* The child must have run before it can be attached. */
1001 select(0, NULL, NULL, NULL, &tv);
1003 if (ptrace(PTRACE_ATTACH, pid, (char *)1, 0) < 0) {
1004 perror("PTRACE_ATTACH");
1005 fprintf(stderr, "Too late?\n");
1010 /* Try to catch the new process as soon as possible. */
1013 for (i = 0; i < 1024; i++)
1014 if (ptrace(PTRACE_ATTACH, pid, (char *) 1, 0) >= 0)
1017 perror("PTRACE_ATTACH");
1018 fprintf(stderr, "Too late?\n");
1023 #endif /* !oldway */
1025 tcpchild->flags |= TCB_ATTACHED;
1026 /* Child has BPT too, must be removed on first occasion */
1028 tcpchild->flags |= TCB_BPTSET;
1029 tcpchild->baddr = tcp->baddr;
1030 memcpy(tcpchild->inst, tcp->inst,
1031 sizeof tcpchild->inst);
1034 tcpchild->parent = tcp;
1037 fprintf(stderr, "Process %d attached\n", pid);
1043 #endif /* !USE_PROCFS */
1045 #if defined(SUNOS4) || defined(LINUX) || defined(FREEBSD)
1052 return RVAL_UDECIMAL;
1056 #endif /* SUNOS4 || LINUX || FREEBSD */
1060 static char idstr[16];
1067 sprintf(idstr, "ppid %lu", getrval2(tcp));
1068 tcp->auxstr = idstr;
1079 sprintf(idstr, "euid %lu", getrval2(tcp));
1080 tcp->auxstr = idstr;
1091 sprintf(idstr, "egid %lu", getrval2(tcp));
1092 tcp->auxstr = idstr;
1106 if (entering(tcp)) {
1107 tprintf("%u", (uid_t) tcp->u_arg[0]);
1116 if (entering(tcp)) {
1117 tprintf("%u", (gid_t) tcp->u_arg[0]);
1129 tprintf("%#lx, %#lx, %#lx", tcp->u_arg[0],
1130 tcp->u_arg[1], tcp->u_arg[2]);
1132 if (umove(tcp, tcp->u_arg[0], &uid) < 0)
1133 tprintf("%#lx, ", tcp->u_arg[0]);
1135 tprintf("[%lu], ", (unsigned long) uid);
1136 if (umove(tcp, tcp->u_arg[1], &uid) < 0)
1137 tprintf("%#lx, ", tcp->u_arg[1]);
1139 tprintf("[%lu], ", (unsigned long) uid);
1140 if (umove(tcp, tcp->u_arg[2], &uid) < 0)
1141 tprintf("%#lx", tcp->u_arg[2]);
1143 tprintf("[%lu]", (unsigned long) uid);
1156 tprintf("%#lx, %#lx, %#lx", tcp->u_arg[0],
1157 tcp->u_arg[1], tcp->u_arg[2]);
1159 if (umove(tcp, tcp->u_arg[0], &gid) < 0)
1160 tprintf("%#lx, ", tcp->u_arg[0]);
1162 tprintf("[%lu], ", (unsigned long) gid);
1163 if (umove(tcp, tcp->u_arg[1], &gid) < 0)
1164 tprintf("%#lx, ", tcp->u_arg[1]);
1166 tprintf("[%lu], ", (unsigned long) gid);
1167 if (umove(tcp, tcp->u_arg[2], &gid) < 0)
1168 tprintf("%#lx", tcp->u_arg[2]);
1170 tprintf("[%lu]", (unsigned long) gid);
1182 if (entering(tcp)) {
1183 printuid("", tcp->u_arg[0]);
1184 printuid(", ", tcp->u_arg[1]);
1193 if (entering(tcp)) {
1194 printuid("", tcp->u_arg[0]);
1195 printuid(", ", tcp->u_arg[1]);
1200 #if defined(LINUX) || defined(FREEBSD)
1205 if (entering(tcp)) {
1206 printuid("", tcp->u_arg[0]);
1207 printuid(", ", tcp->u_arg[1]);
1208 printuid(", ", tcp->u_arg[2]);
1216 if (entering(tcp)) {
1217 printuid("", tcp->u_arg[0]);
1218 printuid(", ", tcp->u_arg[1]);
1219 printuid(", ", tcp->u_arg[2]);
1224 #endif /* LINUX || FREEBSD */
1230 if (entering(tcp)) {
1231 unsigned long len, size, start, cur, end, abbrev_end;
1235 len = tcp->u_arg[0];
1236 tprintf("%lu, ", len);
1241 start = tcp->u_arg[1];
1246 size = len * sizeof(gid);
1248 if (!verbose(tcp) || size / sizeof(gid) != len || end < start) {
1249 tprintf("%#lx", start);
1253 abbrev_end = start + max_strlen * sizeof(gid);
1254 if (abbrev_end < start)
1260 for (cur = start; cur < end; cur += sizeof(gid)) {
1263 if (cur >= abbrev_end) {
1267 if (umoven(tcp, cur, sizeof(gid), (char *) &gid) < 0) {
1272 tprintf("%lu", (unsigned long) gid);
1276 tprintf(" %#lx", tcp->u_arg[1]);
1287 if (entering(tcp)) {
1288 len = tcp->u_arg[0];
1289 tprintf("%lu, ", len);
1291 unsigned long size, start, cur, end, abbrev_end;
1300 start = tcp->u_arg[1];
1305 if (tcp->u_arg[0] == 0) {
1306 tprintf("%#lx", start);
1309 size = len * sizeof(gid);
1311 if (!verbose(tcp) || tcp->u_arg[0] == 0 ||
1312 size / sizeof(gid) != len || end < start) {
1313 tprintf("%#lx", start);
1317 abbrev_end = start + max_strlen * sizeof(gid);
1318 if (abbrev_end < start)
1324 for (cur = start; cur < end; cur += sizeof(gid)) {
1327 if (cur >= abbrev_end) {
1331 if (umoven(tcp, cur, sizeof(gid), (char *) &gid) < 0) {
1336 tprintf("%lu", (unsigned long) gid);
1340 tprintf(" %#lx", tcp->u_arg[1]);
1347 sys_setgroups32(tcp)
1350 if (entering(tcp)) {
1351 unsigned long len, size, start, cur, end, abbrev_end;
1355 len = tcp->u_arg[0];
1356 tprintf("%lu, ", len);
1361 start = tcp->u_arg[1];
1366 size = len * sizeof(gid);
1368 if (!verbose(tcp) || size / sizeof(gid) != len || end < start) {
1369 tprintf("%#lx", start);
1373 abbrev_end = start + max_strlen * sizeof(gid);
1374 if (abbrev_end < start)
1380 for (cur = start; cur < end; cur += sizeof(gid)) {
1383 if (cur >= abbrev_end) {
1387 if (umoven(tcp, cur, sizeof(gid), (char *) &gid) < 0) {
1392 tprintf("%lu", (unsigned long) gid);
1396 tprintf(" %#lx", tcp->u_arg[1]);
1402 sys_getgroups32(tcp)
1407 if (entering(tcp)) {
1408 len = tcp->u_arg[0];
1409 tprintf("%lu, ", len);
1411 unsigned long size, start, cur, end, abbrev_end;
1420 start = tcp->u_arg[1];
1425 size = len * sizeof(gid);
1427 if (!verbose(tcp) || tcp->u_arg[0] == 0 ||
1428 size / sizeof(gid) != len || end < start) {
1429 tprintf("%#lx", start);
1433 abbrev_end = start + max_strlen * sizeof(gid);
1434 if (abbrev_end < start)
1440 for (cur = start; cur < end; cur += sizeof(gid)) {
1443 if (cur >= abbrev_end) {
1447 if (umoven(tcp, cur, sizeof(gid), (char *) &gid) < 0) {
1452 tprintf("%lu", (unsigned long) gid);
1456 tprintf(" %#lx", tcp->u_arg[1]);
1466 if (entering(tcp)) {
1468 tprintf("%lu, %lu", tcp->u_arg[0], tcp->u_arg[1]);
1478 if (entering(tcp)) {
1480 tprintf("%lu", tcp->u_arg[0]);
1490 if (entering(tcp)) {
1491 tprintf("%lu", tcp->u_arg[0]);
1507 if (entering(tcp)) {
1508 tprintf("%lu", tcp->u_arg[0]);
1517 if (entering(tcp)) {
1518 tprintf("%lu, %lu", tcp->u_arg[0], tcp->u_arg[1]);
1525 #include <sys/privilege.h>
1528 static const struct xlat procpriv_cmds [] = {
1529 { SETPRV, "SETPRV" },
1530 { CLRPRV, "CLRPRV" },
1531 { PUTPRV, "PUTPRV" },
1532 { GETPRV, "GETPRV" },
1533 { CNTPRV, "CNTPRV" },
1538 static const struct xlat procpriv_priv [] = {
1539 { P_OWNER, "P_OWNER" },
1540 { P_AUDIT, "P_AUDIT" },
1541 { P_COMPAT, "P_COMPAT" },
1542 { P_DACREAD, "P_DACREAD" },
1543 { P_DACWRITE, "P_DACWRITE" },
1545 { P_FILESYS, "P_FILESYS" },
1546 { P_MACREAD, "P_MACREAD" },
1547 { P_MACWRITE, "P_MACWRITE" },
1548 { P_MOUNT, "P_MOUNT" },
1549 { P_MULTIDIR, "P_MULTIDIR" },
1550 { P_SETPLEVEL, "P_SETPLEVEL" },
1551 { P_SETSPRIV, "P_SETSPRIV" },
1552 { P_SETUID, "P_SETUID" },
1553 { P_SYSOPS, "P_SYSOPS" },
1554 { P_SETUPRIV, "P_SETUPRIV" },
1555 { P_DRIVER, "P_DRIVER" },
1556 { P_RTIME, "P_RTIME" },
1557 { P_MACUPGRADE, "P_MACUPGRADE" },
1558 { P_FSYSRANGE, "P_FSYSRANGE" },
1559 { P_SETFLEVEL, "P_SETFLEVEL" },
1560 { P_AUDITWR, "P_AUDITWR" },
1561 { P_TSHAR, "P_TSHAR" },
1562 { P_PLOCK, "P_PLOCK" },
1563 { P_CORE, "P_CORE" },
1564 { P_LOADMOD, "P_LOADMOD" },
1565 { P_BIND, "P_BIND" },
1566 { P_ALLPRIVS, "P_ALLPRIVS" },
1571 static const struct xlat procpriv_type [] = {
1572 { PS_FIX, "PS_FIX" },
1573 { PS_INH, "PS_INH" },
1574 { PS_MAX, "PS_MAX" },
1575 { PS_WKG, "PS_WKG" },
1581 printpriv(tcp, addr, len, opt)
1585 const struct xlat *opt;
1588 int max = verbose (tcp) ? sizeof buf / sizeof buf [0] : 10;
1589 int dots = len > max;
1592 if (len > max) len = max;
1595 umoven (tcp, addr, len * sizeof buf[0], (char *) buf) < 0)
1597 tprintf ("%#lx", addr);
1603 for (i = 0; i < len; ++i) {
1606 if (i) tprintf (", ");
1608 if ((t = xlookup (procpriv_type, buf [i] & PS_TYPE)) &&
1609 (p = xlookup (procpriv_priv, buf [i] & ~PS_TYPE)))
1611 tprintf ("%s|%s", t, p);
1614 tprintf ("%#lx", buf [i]);
1618 if (dots) tprintf (" ...");
1628 if (entering(tcp)) {
1629 printxval(procpriv_cmds, tcp->u_arg[0], "???PRV");
1630 switch (tcp->u_arg[0]) {
1632 tprintf(", %#lx, %ld", tcp->u_arg[1], tcp->u_arg[2]);
1640 printpriv (tcp, tcp->u_arg[1], tcp->u_arg[2]);
1641 tprintf (", %ld", tcp->u_arg[2]);
1644 else if (tcp->u_arg[0] == GETPRV) {
1645 if (syserror (tcp)) {
1646 tprintf(", %#lx, %ld", tcp->u_arg[1], tcp->u_arg[2]);
1650 printpriv (tcp, tcp->u_arg[1], tcp->u_rval);
1651 tprintf (", %ld", tcp->u_arg[2]);
1662 printargv(tcp, addr)
1668 int max = max_strlen / 2;
1670 for (sep = ""; --max >= 0; sep = ", ") {
1673 if (umove(tcp, addr, &cp) < 0) {
1674 tprintf("%#lx", addr);
1680 printstr(tcp, (long) cp, -1);
1681 addr += sizeof(char *);
1688 printargc(fmt, tcp, addr)
1696 for (count = 0; umove(tcp, addr, &cp) >= 0 && cp != NULL; count++) {
1697 addr += sizeof(char *);
1699 tprintf(fmt, count, count == 1 ? "" : "s");
1706 if (entering(tcp)) {
1707 printpath(tcp, tcp->u_arg[0]);
1709 tprintf(", %#lx", tcp->u_arg[1]);
1711 else if (abbrev(tcp))
1712 printargc(", [/* %d arg%s */]", tcp, tcp->u_arg[1]);
1716 printargv(tcp, tcp->u_arg[1]);
1727 if (entering(tcp)) {
1728 printpath(tcp, tcp->u_arg[0]);
1730 tprintf(", %#lx", tcp->u_arg[1]);
1732 else if (abbrev(tcp))
1733 printargc(", [/* %d arg%s */]", tcp, tcp->u_arg[1]);
1737 printargv(tcp, tcp->u_arg[1]);
1741 tprintf(", %#lx", tcp->u_arg[2]);
1742 else if (abbrev(tcp))
1743 printargc(", [/* %d var%s */]", tcp, tcp->u_arg[2]);
1746 printargv(tcp, tcp->u_arg[2]);
1755 int sys_rexecve(tcp)
1758 if (entering (tcp)) {
1760 tprintf (", %ld", tcp->u_arg[3]);
1772 if (exiting(tcp) && !syserror(tcp) && followfork)
1775 #if defined LINUX && defined TCB_WAITEXECVE
1776 if (exiting(tcp) && syserror(tcp))
1777 tcp->flags &= ~TCB_WAITEXECVE;
1779 tcp->flags |= TCB_WAITEXECVE;
1780 #endif /* LINUX && TCB_WAITEXECVE */
1786 #define __WNOTHREAD 0x20000000
1789 #define __WALL 0x40000000
1792 #define __WCLONE 0x80000000
1796 static const struct xlat wait4_options[] = {
1797 { WNOHANG, "WNOHANG" },
1799 { WUNTRACED, "WUNTRACED" },
1802 { WEXITED, "WEXITED" },
1805 { WTRAPPED, "WTRAPPED" },
1808 { WSTOPPED, "WSTOPPED" },
1811 { WCONTINUED, "WCONTINUED" },
1814 { WNOWAIT, "WNOWAIT" },
1817 { __WCLONE, "__WCLONE" },
1820 { __WALL, "__WALL" },
1823 { __WNOTHREAD, "__WNOTHREAD" },
1828 #if !defined WCOREFLAG && defined WCOREFLG
1829 # define WCOREFLAG WCOREFLG
1832 #define WCOREFLAG 0x80
1836 #define W_STOPCODE(sig) ((sig) << 8 | 0x7f)
1839 #define W_EXITCODE(ret, sig) ((ret) << 8 | (sig))
1849 * Here is a tricky presentation problem. This solution
1850 * is still not entirely satisfactory but since there
1851 * are no wait status constructors it will have to do.
1853 if (WIFSTOPPED(status)) {
1854 tprintf("[{WIFSTOPPED(s) && WSTOPSIG(s) == %s}",
1855 signame(WSTOPSIG(status)));
1856 status &= ~W_STOPCODE(WSTOPSIG(status));
1858 else if (WIFSIGNALED(status)) {
1859 tprintf("[{WIFSIGNALED(s) && WTERMSIG(s) == %s%s}",
1860 signame(WTERMSIG(status)),
1861 WCOREDUMP(status) ? " && WCOREDUMP(s)" : "");
1862 status &= ~(W_EXITCODE(0, WTERMSIG(status)) | WCOREFLAG);
1864 else if (WIFEXITED(status)) {
1865 tprintf("[{WIFEXITED(s) && WEXITSTATUS(s) == %d}",
1866 WEXITSTATUS(status));
1868 status &= ~W_EXITCODE(WEXITSTATUS(status), 0);
1871 tprintf("[%#x]", status);
1878 tprintf(" | %#x]", status);
1884 printwaitn(tcp, n, bitness)
1892 if (entering(tcp)) {
1893 tprintf("%ld, ", tcp->u_arg[0]);
1898 else if (syserror(tcp) || tcp->u_rval == 0)
1899 tprintf("%#lx", tcp->u_arg[1]);
1900 else if (umove(tcp, tcp->u_arg[1], &status) < 0)
1903 exited = printstatus(status);
1906 printflags(wait4_options, tcp->u_arg[2], "W???");
1913 else if (tcp->u_rval > 0) {
1916 printrusage32(tcp, tcp->u_arg[3]);
1919 printrusage(tcp, tcp->u_arg[3]);
1923 else if (tcp->u_rval > 0 && exited)
1924 printrusage(tcp, tcp->u_arg[3]);
1927 tprintf("%#lx", tcp->u_arg[3]);
1934 internal_wait(tcp, flagarg)
1940 #ifdef TCB_CLONE_THREAD
1941 if (tcp->flags & TCB_CLONE_THREAD)
1942 /* The children we wait for are our parent's children. */
1943 got_kids = (tcp->parent->nchildren
1944 > tcp->parent->nclone_detached);
1946 got_kids = (tcp->nchildren > tcp->nclone_detached);
1948 got_kids = tcp->nchildren > 0;
1951 if (entering(tcp) && got_kids) {
1952 /* There are children that this parent should block for.
1953 But ptrace made us the parent of the traced children
1954 and the real parent will get ECHILD from the wait call.
1956 XXX If we attached with strace -f -p PID, then there
1957 may be untraced dead children the parent could be reaping
1958 now, but we make him block. */
1960 /* ??? WTA: fix bug with hanging children */
1962 if (!(tcp->u_arg[flagarg] & WNOHANG)) {
1964 * There are traced children. We'll make the parent
1965 * block to avoid a false ECHILD error due to our
1966 * ptrace having stolen the children. However,
1967 * we shouldn't block if there are zombies to reap.
1968 * XXX doesn't handle pgrp matches (u_arg[0]==0,<-1)
1970 struct tcb *child = NULL;
1971 if (tcp->nzombies > 0 &&
1972 (tcp->u_arg[0] == -1 ||
1973 (child = pid2tcb(tcp->u_arg[0])) == NULL))
1975 if (tcp->u_arg[0] > 0) {
1977 * If the parent waits for a specified child
1978 * PID, then it must get ECHILD right away
1979 * if that PID is not one of its children.
1980 * Make sure that the requested PID matches
1981 * one of the parent's children that we are
1982 * tracing, and don't suspend it otherwise.
1985 child = pid2tcb(tcp->u_arg[0]);
1986 if (child == NULL || child->parent != (
1987 #ifdef TCB_CLONE_THREAD
1988 (tcp->flags & TCB_CLONE_THREAD)
1992 (child->flags & TCB_EXITING))
1995 tcp->flags |= TCB_SUSPENDED;
1996 tcp->waitpid = tcp->u_arg[0];
1997 #ifdef TCB_CLONE_THREAD
1998 if (tcp->flags & TCB_CLONE_THREAD)
1999 tcp->parent->nclone_waiting++;
2003 if (exiting(tcp) && tcp->u_error == ECHILD && got_kids) {
2004 if (tcp->u_arg[flagarg] & WNOHANG) {
2005 /* We must force a fake result of 0 instead of
2006 the ECHILD error. */
2007 extern int force_result();
2008 return force_result(tcp, 0, 0);
2011 else if (exiting(tcp) && tcp->u_error == 0 && tcp->u_rval > 0 &&
2012 tcp->nzombies > 0 && pid2tcb(tcp->u_rval) == NULL) {
2014 * We just reaped a child we don't know about,
2015 * presumably a zombie we already droptcb'd.
2029 /* The library wrapper stuffs this into the user variable. */
2031 printstatus(getrval2(tcp));
2046 if (!syserror(tcp)) {
2047 if (umove(tcp, tcp->u_arg[0], &status) < 0)
2048 tprintf("%#lx", tcp->u_arg[0]);
2050 printstatus(status);
2061 return printwaitn(tcp, 3, 0);
2068 return printwaitn(tcp, 4, 0);
2076 return printwaitn(tcp, 4, 1);
2080 #if defined SVR4 || defined LINUX
2082 static const struct xlat waitid_types[] = {
2085 { P_PPID, "P_PPID" },
2087 { P_PGID, "P_PGID" },
2102 { P_LWPID, "P_LWPID" },
2114 if (entering(tcp)) {
2115 printxval(waitid_types, tcp->u_arg[0], "P_???");
2116 tprintf(", %ld, ", tcp->u_arg[1]);
2123 else if (syserror(tcp))
2124 tprintf("%#lx", tcp->u_arg[2]);
2125 else if (umove(tcp, tcp->u_arg[2], &si) < 0)
2128 printsiginfo(&si, verbose (tcp));
2131 printflags(wait4_options, tcp->u_arg[3], "W???");
2132 if (tcp->u_nargs > 4) {
2137 else if (tcp->u_error)
2138 tprintf("%#lx", tcp->u_arg[4]);
2140 printrusage(tcp, tcp->u_arg[4]);
2146 #endif /* SVR4 or LINUX */
2153 tprintf("%lu", tcp->u_arg[0]);
2161 struct utsname uname;
2164 if (syserror(tcp) || !verbose(tcp))
2165 tprintf("%#lx", tcp->u_arg[0]);
2166 else if (umove(tcp, tcp->u_arg[0], &uname) < 0)
2168 else if (!abbrev(tcp)) {
2170 tprintf("{sysname=\"%s\", nodename=\"%s\", ",
2171 uname.sysname, uname.nodename);
2172 tprintf("release=\"%s\", version=\"%s\", ",
2173 uname.release, uname.version);
2174 tprintf("machine=\"%s\"", uname.machine);
2177 tprintf(", domainname=\"%s\"", uname.domainname);
2178 #endif /* __GLIBC__ */
2183 tprintf("{sys=\"%s\", node=\"%s\", ...}",
2184 uname.sysname, uname.nodename);
2191 static const struct xlat ptrace_cmds[] = {
2193 { PTRACE_TRACEME, "PTRACE_TRACEME" },
2194 { PTRACE_PEEKTEXT, "PTRACE_PEEKTEXT", },
2195 { PTRACE_PEEKDATA, "PTRACE_PEEKDATA", },
2196 { PTRACE_PEEKUSER, "PTRACE_PEEKUSER", },
2197 { PTRACE_POKETEXT, "PTRACE_POKETEXT", },
2198 { PTRACE_POKEDATA, "PTRACE_POKEDATA", },
2199 { PTRACE_POKEUSER, "PTRACE_POKEUSER", },
2200 { PTRACE_CONT, "PTRACE_CONT" },
2201 { PTRACE_KILL, "PTRACE_KILL" },
2202 { PTRACE_SINGLESTEP, "PTRACE_SINGLESTEP" },
2203 { PTRACE_ATTACH, "PTRACE_ATTACH" },
2204 { PTRACE_DETACH, "PTRACE_DETACH" },
2205 #ifdef PTRACE_GETREGS
2206 { PTRACE_GETREGS, "PTRACE_GETREGS" },
2208 #ifdef PTRACE_SETREGS
2209 { PTRACE_SETREGS, "PTRACE_SETREGS" },
2211 #ifdef PTRACE_GETFPREGS
2212 { PTRACE_GETFPREGS, "PTRACE_GETFPREGS", },
2214 #ifdef PTRACE_SETFPREGS
2215 { PTRACE_SETFPREGS, "PTRACE_SETFPREGS", },
2217 #ifdef PTRACE_GETFPXREGS
2218 { PTRACE_GETFPXREGS, "PTRACE_GETFPXREGS", },
2220 #ifdef PTRACE_SETFPXREGS
2221 { PTRACE_SETFPXREGS, "PTRACE_SETFPXREGS", },
2223 #ifdef PTRACE_GETVRREGS
2224 { PTRACE_GETVRREGS, "PTRACE_GETVRREGS", },
2226 #ifdef PTRACE_SETVRREGS
2227 { PTRACE_SETVRREGS, "PTRACE_SETVRREGS", },
2230 { PTRACE_READDATA, "PTRACE_READDATA" },
2231 { PTRACE_WRITEDATA, "PTRACE_WRITEDATA" },
2232 { PTRACE_READTEXT, "PTRACE_READTEXT" },
2233 { PTRACE_WRITETEXT, "PTRACE_WRITETEXT" },
2234 { PTRACE_GETFPAREGS, "PTRACE_GETFPAREGS" },
2235 { PTRACE_SETFPAREGS, "PTRACE_SETFPAREGS" },
2237 { PTRACE_GETWINDOW, "PTRACE_GETWINDOW" },
2238 { PTRACE_SETWINDOW, "PTRACE_SETWINDOW" },
2240 { PTRACE_22, "PTRACE_PTRACE_22" },
2241 { PTRACE_23, "PTRACE_PTRACE_23" },
2244 { PTRACE_SYSCALL, "PTRACE_SYSCALL" },
2246 { PTRACE_DUMPCORE, "PTRACE_DUMPCORE" },
2248 { PTRACE_SETWRBKPT, "PTRACE_SETWRBKPT" },
2249 { PTRACE_SETACBKPT, "PTRACE_SETACBKPT" },
2250 { PTRACE_CLRDR7, "PTRACE_CLRDR7" },
2252 { PTRACE_26, "PTRACE_26" },
2253 { PTRACE_27, "PTRACE_27" },
2254 { PTRACE_28, "PTRACE_28" },
2256 { PTRACE_GETUCODE, "PTRACE_GETUCODE" },
2259 { PT_TRACE_ME, "PT_TRACE_ME" },
2260 { PT_READ_I, "PT_READ_I" },
2261 { PT_READ_D, "PT_READ_D" },
2262 { PT_WRITE_I, "PT_WRITE_I" },
2263 { PT_WRITE_D, "PT_WRITE_D" },
2265 { PT_READ_U, "PT_READ_U" },
2267 { PT_CONTINUE, "PT_CONTINUE" },
2268 { PT_KILL, "PT_KILL" },
2269 { PT_STEP, "PT_STEP" },
2270 { PT_ATTACH, "PT_ATTACH" },
2271 { PT_DETACH, "PT_DETACH" },
2272 { PT_GETREGS, "PT_GETREGS" },
2273 { PT_SETREGS, "PT_SETREGS" },
2274 { PT_GETFPREGS, "PT_GETFPREGS" },
2275 { PT_SETFPREGS, "PT_SETFPREGS" },
2276 { PT_GETDBREGS, "PT_GETDBREGS" },
2277 { PT_SETDBREGS, "PT_SETDBREGS" },
2278 #endif /* FREEBSD */
2283 #ifndef SUNOS4_KERNEL_ARCH_KLUDGE
2285 #endif /* !SUNOS4_KERNEL_ARCH_KLUDGE */
2286 const struct xlat struct_user_offsets[] = {
2288 #if defined(S390) || defined(S390X)
2289 { PT_PSWMASK, "psw_mask" },
2290 { PT_PSWADDR, "psw_addr" },
2291 { PT_GPR0, "gpr0" },
2292 { PT_GPR1, "gpr1" },
2293 { PT_GPR2, "gpr2" },
2294 { PT_GPR3, "gpr3" },
2295 { PT_GPR4, "gpr4" },
2296 { PT_GPR5, "gpr5" },
2297 { PT_GPR6, "gpr6" },
2298 { PT_GPR7, "gpr7" },
2299 { PT_GPR8, "gpr8" },
2300 { PT_GPR9, "gpr9" },
2301 { PT_GPR10, "gpr10" },
2302 { PT_GPR11, "gpr11" },
2303 { PT_GPR12, "gpr12" },
2304 { PT_GPR13, "gpr13" },
2305 { PT_GPR14, "gpr14" },
2306 { PT_GPR15, "gpr15" },
2307 { PT_ACR0, "acr0" },
2308 { PT_ACR1, "acr1" },
2309 { PT_ACR2, "acr2" },
2310 { PT_ACR3, "acr3" },
2311 { PT_ACR4, "acr4" },
2312 { PT_ACR5, "acr5" },
2313 { PT_ACR6, "acr6" },
2314 { PT_ACR7, "acr7" },
2315 { PT_ACR8, "acr8" },
2316 { PT_ACR9, "acr9" },
2317 { PT_ACR10, "acr10" },
2318 { PT_ACR11, "acr11" },
2319 { PT_ACR12, "acr12" },
2320 { PT_ACR13, "acr13" },
2321 { PT_ACR14, "acr14" },
2322 { PT_ACR15, "acr15" },
2323 { PT_ORIGGPR2, "orig_gpr2" },
2326 { PT_FPR0_HI, "fpr0.hi" },
2327 { PT_FPR0_LO, "fpr0.lo" },
2328 { PT_FPR1_HI, "fpr1.hi" },
2329 { PT_FPR1_LO, "fpr1.lo" },
2330 { PT_FPR2_HI, "fpr2.hi" },
2331 { PT_FPR2_LO, "fpr2.lo" },
2332 { PT_FPR3_HI, "fpr3.hi" },
2333 { PT_FPR3_LO, "fpr3.lo" },
2334 { PT_FPR4_HI, "fpr4.hi" },
2335 { PT_FPR4_LO, "fpr4.lo" },
2336 { PT_FPR5_HI, "fpr5.hi" },
2337 { PT_FPR5_LO, "fpr5.lo" },
2338 { PT_FPR6_HI, "fpr6.hi" },
2339 { PT_FPR6_LO, "fpr6.lo" },
2340 { PT_FPR7_HI, "fpr7.hi" },
2341 { PT_FPR7_LO, "fpr7.lo" },
2342 { PT_FPR8_HI, "fpr8.hi" },
2343 { PT_FPR8_LO, "fpr8.lo" },
2344 { PT_FPR9_HI, "fpr9.hi" },
2345 { PT_FPR9_LO, "fpr9.lo" },
2346 { PT_FPR10_HI, "fpr10.hi" },
2347 { PT_FPR10_LO, "fpr10.lo" },
2348 { PT_FPR11_HI, "fpr11.hi" },
2349 { PT_FPR11_LO, "fpr11.lo" },
2350 { PT_FPR12_HI, "fpr12.hi" },
2351 { PT_FPR12_LO, "fpr12.lo" },
2352 { PT_FPR13_HI, "fpr13.hi" },
2353 { PT_FPR13_LO, "fpr13.lo" },
2354 { PT_FPR14_HI, "fpr14.hi" },
2355 { PT_FPR14_LO, "fpr14.lo" },
2356 { PT_FPR15_HI, "fpr15.hi" },
2357 { PT_FPR15_LO, "fpr15.lo" },
2360 { PT_FPR0, "fpr0" },
2361 { PT_FPR1, "fpr1" },
2362 { PT_FPR2, "fpr2" },
2363 { PT_FPR3, "fpr3" },
2364 { PT_FPR4, "fpr4" },
2365 { PT_FPR5, "fpr5" },
2366 { PT_FPR6, "fpr6" },
2367 { PT_FPR7, "fpr7" },
2368 { PT_FPR8, "fpr8" },
2369 { PT_FPR9, "fpr9" },
2370 { PT_FPR10, "fpr10" },
2371 { PT_FPR11, "fpr11" },
2372 { PT_FPR12, "fpr12" },
2373 { PT_FPR13, "fpr13" },
2374 { PT_FPR14, "fpr14" },
2375 { PT_FPR15, "fpr15" },
2378 { PT_CR_10, "cr10" },
2379 { PT_CR_11, "cr11" },
2380 { PT_IEEE_IP, "ieee_exception_ip" },
2383 /* XXX No support for these offsets yet. */
2385 /* XXX No support for these offsets yet. */
2386 #elif defined(POWERPC)
2388 #define PT_ORIG_R3 34
2390 #define REGSIZE (sizeof(unsigned long))
2391 { REGSIZE*PT_R0, "r0" },
2392 { REGSIZE*PT_R1, "r1" },
2393 { REGSIZE*PT_R2, "r2" },
2394 { REGSIZE*PT_R3, "r3" },
2395 { REGSIZE*PT_R4, "r4" },
2396 { REGSIZE*PT_R5, "r5" },
2397 { REGSIZE*PT_R6, "r6" },
2398 { REGSIZE*PT_R7, "r7" },
2399 { REGSIZE*PT_R8, "r8" },
2400 { REGSIZE*PT_R9, "r9" },
2401 { REGSIZE*PT_R10, "r10" },
2402 { REGSIZE*PT_R11, "r11" },
2403 { REGSIZE*PT_R12, "r12" },
2404 { REGSIZE*PT_R13, "r13" },
2405 { REGSIZE*PT_R14, "r14" },
2406 { REGSIZE*PT_R15, "r15" },
2407 { REGSIZE*PT_R16, "r16" },
2408 { REGSIZE*PT_R17, "r17" },
2409 { REGSIZE*PT_R18, "r18" },
2410 { REGSIZE*PT_R19, "r19" },
2411 { REGSIZE*PT_R20, "r20" },
2412 { REGSIZE*PT_R21, "r21" },
2413 { REGSIZE*PT_R22, "r22" },
2414 { REGSIZE*PT_R23, "r23" },
2415 { REGSIZE*PT_R24, "r24" },
2416 { REGSIZE*PT_R25, "r25" },
2417 { REGSIZE*PT_R26, "r26" },
2418 { REGSIZE*PT_R27, "r27" },
2419 { REGSIZE*PT_R28, "r28" },
2420 { REGSIZE*PT_R29, "r29" },
2421 { REGSIZE*PT_R30, "r30" },
2422 { REGSIZE*PT_R31, "r31" },
2423 { REGSIZE*PT_NIP, "NIP" },
2424 { REGSIZE*PT_MSR, "MSR" },
2425 { REGSIZE*PT_ORIG_R3, "ORIG_R3" },
2426 { REGSIZE*PT_CTR, "CTR" },
2427 { REGSIZE*PT_LNK, "LNK" },
2428 { REGSIZE*PT_XER, "XER" },
2429 { REGSIZE*PT_CCR, "CCR" },
2430 { REGSIZE*PT_FPR0, "FPR0" },
2501 { PT_F32, "f32" }, { PT_F33, "f33" }, { PT_F34, "f34" },
2502 { PT_F35, "f35" }, { PT_F36, "f36" }, { PT_F37, "f37" },
2503 { PT_F38, "f38" }, { PT_F39, "f39" }, { PT_F40, "f40" },
2504 { PT_F41, "f41" }, { PT_F42, "f42" }, { PT_F43, "f43" },
2505 { PT_F44, "f44" }, { PT_F45, "f45" }, { PT_F46, "f46" },
2506 { PT_F47, "f47" }, { PT_F48, "f48" }, { PT_F49, "f49" },
2507 { PT_F50, "f50" }, { PT_F51, "f51" }, { PT_F52, "f52" },
2508 { PT_F53, "f53" }, { PT_F54, "f54" }, { PT_F55, "f55" },
2509 { PT_F56, "f56" }, { PT_F57, "f57" }, { PT_F58, "f58" },
2510 { PT_F59, "f59" }, { PT_F60, "f60" }, { PT_F61, "f61" },
2511 { PT_F62, "f62" }, { PT_F63, "f63" }, { PT_F64, "f64" },
2512 { PT_F65, "f65" }, { PT_F66, "f66" }, { PT_F67, "f67" },
2513 { PT_F68, "f68" }, { PT_F69, "f69" }, { PT_F70, "f70" },
2514 { PT_F71, "f71" }, { PT_F72, "f72" }, { PT_F73, "f73" },
2515 { PT_F74, "f74" }, { PT_F75, "f75" }, { PT_F76, "f76" },
2516 { PT_F77, "f77" }, { PT_F78, "f78" }, { PT_F79, "f79" },
2517 { PT_F80, "f80" }, { PT_F81, "f81" }, { PT_F82, "f82" },
2518 { PT_F83, "f83" }, { PT_F84, "f84" }, { PT_F85, "f85" },
2519 { PT_F86, "f86" }, { PT_F87, "f87" }, { PT_F88, "f88" },
2520 { PT_F89, "f89" }, { PT_F90, "f90" }, { PT_F91, "f91" },
2521 { PT_F92, "f92" }, { PT_F93, "f93" }, { PT_F94, "f94" },
2522 { PT_F95, "f95" }, { PT_F96, "f96" }, { PT_F97, "f97" },
2523 { PT_F98, "f98" }, { PT_F99, "f99" }, { PT_F100, "f100" },
2524 { PT_F101, "f101" }, { PT_F102, "f102" }, { PT_F103, "f103" },
2525 { PT_F104, "f104" }, { PT_F105, "f105" }, { PT_F106, "f106" },
2526 { PT_F107, "f107" }, { PT_F108, "f108" }, { PT_F109, "f109" },
2527 { PT_F110, "f110" }, { PT_F111, "f111" }, { PT_F112, "f112" },
2528 { PT_F113, "f113" }, { PT_F114, "f114" }, { PT_F115, "f115" },
2529 { PT_F116, "f116" }, { PT_F117, "f117" }, { PT_F118, "f118" },
2530 { PT_F119, "f119" }, { PT_F120, "f120" }, { PT_F121, "f121" },
2531 { PT_F122, "f122" }, { PT_F123, "f123" }, { PT_F124, "f124" },
2532 { PT_F125, "f125" }, { PT_F126, "f126" }, { PT_F127, "f127" },
2534 { PT_F2, "f2" }, { PT_F3, "f3" }, { PT_F4, "f4" },
2535 { PT_F5, "f5" }, { PT_F10, "f10" }, { PT_F11, "f11" },
2536 { PT_F12, "f12" }, { PT_F13, "f13" }, { PT_F14, "f14" },
2537 { PT_F15, "f15" }, { PT_F16, "f16" }, { PT_F17, "f17" },
2538 { PT_F18, "f18" }, { PT_F19, "f19" }, { PT_F20, "f20" },
2539 { PT_F21, "f21" }, { PT_F22, "f22" }, { PT_F23, "f23" },
2540 { PT_F24, "f24" }, { PT_F25, "f25" }, { PT_F26, "f26" },
2541 { PT_F27, "f27" }, { PT_F28, "f28" }, { PT_F29, "f29" },
2542 { PT_F30, "f30" }, { PT_F31, "f31" }, { PT_R4, "r4" },
2543 { PT_R5, "r5" }, { PT_R6, "r6" }, { PT_R7, "r7" },
2544 { PT_B1, "b1" }, { PT_B2, "b2" }, { PT_B3, "b3" },
2545 { PT_B4, "b4" }, { PT_B5, "b5" },
2546 { PT_AR_EC, "ar.ec" }, { PT_AR_LC, "ar.lc" },
2548 { PT_CR_IPSR, "psr" }, { PT_CR_IIP, "ip" },
2549 { PT_CFM, "cfm" }, { PT_AR_UNAT, "ar.unat" },
2550 { PT_AR_PFS, "ar.pfs" }, { PT_AR_RSC, "ar.rsc" },
2551 { PT_AR_RNAT, "ar.rnat" }, { PT_AR_BSPSTORE, "ar.bspstore" },
2552 { PT_PR, "pr" }, { PT_B6, "b6" }, { PT_AR_BSP, "ar.bsp" },
2553 { PT_R1, "r1" }, { PT_R2, "r2" }, { PT_R3, "r3" },
2554 { PT_R12, "r12" }, { PT_R13, "r13" }, { PT_R14, "r14" },
2555 { PT_R15, "r15" }, { PT_R8, "r8" }, { PT_R9, "r9" },
2556 { PT_R10, "r10" }, { PT_R11, "r11" }, { PT_R16, "r16" },
2557 { PT_R17, "r17" }, { PT_R18, "r18" }, { PT_R19, "r19" },
2558 { PT_R20, "r20" }, { PT_R21, "r21" }, { PT_R22, "r22" },
2559 { PT_R23, "r23" }, { PT_R24, "r24" }, { PT_R25, "r25" },
2560 { PT_R26, "r26" }, { PT_R27, "r27" }, { PT_R28, "r28" },
2561 { PT_R29, "r29" }, { PT_R30, "r30" }, { PT_R31, "r31" },
2562 { PT_AR_CCV, "ar.ccv" }, { PT_AR_FPSR, "ar.fpsr" },
2563 { PT_B0, "b0" }, { PT_B7, "b7" }, { PT_F6, "f6" },
2564 { PT_F7, "f7" }, { PT_F8, "f8" }, { PT_F9, "f9" },
2566 { PT_AR_CSD, "ar.csd" },
2569 { PT_AR_SSD, "ar.ssd" },
2571 { PT_DBR, "dbr" }, { PT_IBR, "ibr" }, { PT_PMD, "pmd" },
2585 { 4*ORIG_EAX, "4*ORIG_EAX" },
2589 { 4*UESP, "4*UESP" },
2614 { 8*ORIG_RAX, "8*ORIG_RAX" },
2617 { 8*EFLAGS, "8*EFL" },
2622 { 4*PT_D1, "4*PT_D1" },
2623 { 4*PT_D2, "4*PT_D2" },
2624 { 4*PT_D3, "4*PT_D3" },
2625 { 4*PT_D4, "4*PT_D4" },
2626 { 4*PT_D5, "4*PT_D5" },
2627 { 4*PT_D6, "4*PT_D6" },
2628 { 4*PT_D7, "4*PT_D7" },
2629 { 4*PT_A0, "4*PT_A0" },
2630 { 4*PT_A1, "4*PT_A1" },
2631 { 4*PT_A2, "4*PT_A2" },
2632 { 4*PT_A3, "4*PT_A3" },
2633 { 4*PT_A4, "4*PT_A4" },
2634 { 4*PT_A5, "4*PT_A5" },
2635 { 4*PT_A6, "4*PT_A6" },
2636 { 4*PT_D0, "4*PT_D0" },
2637 { 4*PT_USP, "4*PT_USP" },
2638 { 4*PT_ORIG_D0, "4*PT_ORIG_D0" },
2639 { 4*PT_SR, "4*PT_SR" },
2640 { 4*PT_PC, "4*PT_PC" },
2644 { 4*REG_REG0, "4*REG_REG0" },
2645 { 4*(REG_REG0+1), "4*REG_REG1" },
2646 { 4*(REG_REG0+2), "4*REG_REG2" },
2647 { 4*(REG_REG0+3), "4*REG_REG3" },
2648 { 4*(REG_REG0+4), "4*REG_REG4" },
2649 { 4*(REG_REG0+5), "4*REG_REG5" },
2650 { 4*(REG_REG0+6), "4*REG_REG6" },
2651 { 4*(REG_REG0+7), "4*REG_REG7" },
2652 { 4*(REG_REG0+8), "4*REG_REG8" },
2653 { 4*(REG_REG0+9), "4*REG_REG9" },
2654 { 4*(REG_REG0+10), "4*REG_REG10" },
2655 { 4*(REG_REG0+11), "4*REG_REG11" },
2656 { 4*(REG_REG0+12), "4*REG_REG12" },
2657 { 4*(REG_REG0+13), "4*REG_REG13" },
2658 { 4*(REG_REG0+14), "4*REG_REG14" },
2659 { 4*REG_REG15, "4*REG_REG15" },
2660 { 4*REG_PC, "4*REG_PC" },
2661 { 4*REG_PR, "4*REG_PR" },
2662 { 4*REG_SR, "4*REG_SR" },
2663 { 4*REG_GBR, "4*REG_GBR" },
2664 { 4*REG_MACH, "4*REG_MACH" },
2665 { 4*REG_MACL, "4*REG_MACL" },
2666 { 4*REG_SYSCALL, "4*REG_SYSCALL" },
2667 { 4*REG_FPUL, "4*REG_FPUL" },
2668 { 4*REG_FPREG0, "4*REG_FPREG0" },
2669 { 4*(REG_FPREG0+1), "4*REG_FPREG1" },
2670 { 4*(REG_FPREG0+2), "4*REG_FPREG2" },
2671 { 4*(REG_FPREG0+3), "4*REG_FPREG3" },
2672 { 4*(REG_FPREG0+4), "4*REG_FPREG4" },
2673 { 4*(REG_FPREG0+5), "4*REG_FPREG5" },
2674 { 4*(REG_FPREG0+6), "4*REG_FPREG6" },
2675 { 4*(REG_FPREG0+7), "4*REG_FPREG7" },
2676 { 4*(REG_FPREG0+8), "4*REG_FPREG8" },
2677 { 4*(REG_FPREG0+9), "4*REG_FPREG9" },
2678 { 4*(REG_FPREG0+10), "4*REG_FPREG10" },
2679 { 4*(REG_FPREG0+11), "4*REG_FPREG11" },
2680 { 4*(REG_FPREG0+12), "4*REG_FPREG12" },
2681 { 4*(REG_FPREG0+13), "4*REG_FPREG13" },
2682 { 4*(REG_FPREG0+14), "4*REG_FPREG14" },
2683 { 4*REG_FPREG15, "4*REG_FPREG15" },
2685 { 4*REG_XDREG0, "4*REG_XDREG0" },
2686 { 4*(REG_XDREG0+2), "4*REG_XDREG2" },
2687 { 4*(REG_XDREG0+4), "4*REG_XDREG4" },
2688 { 4*(REG_XDREG0+6), "4*REG_XDREG6" },
2689 { 4*(REG_XDREG0+8), "4*REG_XDREG8" },
2690 { 4*(REG_XDREG0+10), "4*REG_XDREG10" },
2691 { 4*(REG_XDREG0+12), "4*REG_XDREG12" },
2692 { 4*REG_XDREG14, "4*REG_XDREG14" },
2694 { 4*REG_FPSCR, "4*REG_FPSCR" },
2701 { 16, "syscall no.(L)" },
2702 { 20, "syscall_no.(U)" },
2845 /* This entry is in case pt_regs contains dregs (depends on
2846 the kernel build options). */
2847 { uoff(regs), "offsetof(struct user, regs)" },
2848 { uoff(fpu), "offsetof(struct user, fpu)" },
2851 { uoff(regs.ARM_r0), "r0" },
2852 { uoff(regs.ARM_r1), "r1" },
2853 { uoff(regs.ARM_r2), "r2" },
2854 { uoff(regs.ARM_r3), "r3" },
2855 { uoff(regs.ARM_r4), "r4" },
2856 { uoff(regs.ARM_r5), "r5" },
2857 { uoff(regs.ARM_r6), "r6" },
2858 { uoff(regs.ARM_r7), "r7" },
2859 { uoff(regs.ARM_r8), "r8" },
2860 { uoff(regs.ARM_r9), "r9" },
2861 { uoff(regs.ARM_r10), "r10" },
2862 { uoff(regs.ARM_fp), "fp" },
2863 { uoff(regs.ARM_ip), "ip" },
2864 { uoff(regs.ARM_sp), "sp" },
2865 { uoff(regs.ARM_lr), "lr" },
2866 { uoff(regs.ARM_pc), "pc" },
2867 { uoff(regs.ARM_cpsr), "cpsr" },
2870 #if !defined(S390) && !defined(S390X) && !defined(MIPS) && !defined(SPARC64)
2871 { uoff(u_fpvalid), "offsetof(struct user, u_fpvalid)" },
2873 #if defined(I386) || defined(X86_64)
2874 { uoff(i387), "offsetof(struct user, i387)" },
2877 { uoff(m68kfp), "offsetof(struct user, m68kfp)" },
2880 { uoff(u_tsize), "offsetof(struct user, u_tsize)" },
2881 { uoff(u_dsize), "offsetof(struct user, u_dsize)" },
2882 { uoff(u_ssize), "offsetof(struct user, u_ssize)" },
2883 #if !defined(SPARC64)
2884 { uoff(start_code), "offsetof(struct user, start_code)" },
2887 { uoff(start_data), "offsetof(struct user, start_data)" },
2889 #if !defined(SPARC64)
2890 { uoff(start_stack), "offsetof(struct user, start_stack)" },
2892 { uoff(signal), "offsetof(struct user, signal)" },
2893 #if !defined(S390) && !defined(S390X) && !defined(MIPS) && !defined(SH) && !defined(SH64) && !defined(SPARC64)
2894 { uoff(reserved), "offsetof(struct user, reserved)" },
2896 #if !defined(SPARC64)
2897 { uoff(u_ar0), "offsetof(struct user, u_ar0)" },
2899 #if !defined(ARM) && !defined(MIPS) && !defined(S390) && !defined(S390X) && !defined(SPARC64)
2900 { uoff(u_fpstate), "offsetof(struct user, u_fpstate)" },
2902 { uoff(magic), "offsetof(struct user, magic)" },
2903 { uoff(u_comm), "offsetof(struct user, u_comm)" },
2904 #if defined(I386) || defined(X86_64)
2905 { uoff(u_debugreg), "offsetof(struct user, u_debugreg)" },
2909 #endif /* !POWERPC/!SPARC */
2912 { uoff(u_pcb), "offsetof(struct user, u_pcb)" },
2913 { uoff(u_procp), "offsetof(struct user, u_procp)" },
2914 { uoff(u_ar0), "offsetof(struct user, u_ar0)" },
2915 { uoff(u_comm[0]), "offsetof(struct user, u_comm[0])" },
2916 { uoff(u_arg[0]), "offsetof(struct user, u_arg[0])" },
2917 { uoff(u_ap), "offsetof(struct user, u_ap)" },
2918 { uoff(u_qsave), "offsetof(struct user, u_qsave)" },
2919 { uoff(u_rval1), "offsetof(struct user, u_rval1)" },
2920 { uoff(u_rval2), "offsetof(struct user, u_rval2)" },
2921 { uoff(u_error), "offsetof(struct user, u_error)" },
2922 { uoff(u_eosys), "offsetof(struct user, u_eosys)" },
2923 { uoff(u_ssave), "offsetof(struct user, u_ssave)" },
2924 { uoff(u_signal[0]), "offsetof(struct user, u_signal)" },
2925 { uoff(u_sigmask[0]), "offsetof(struct user, u_sigmask)" },
2926 { uoff(u_sigonstack), "offsetof(struct user, u_sigonstack)" },
2927 { uoff(u_sigintr), "offsetof(struct user, u_sigintr)" },
2928 { uoff(u_sigreset), "offsetof(struct user, u_sigreset)" },
2929 { uoff(u_oldmask), "offsetof(struct user, u_oldmask)" },
2930 { uoff(u_code), "offsetof(struct user, u_code)" },
2931 { uoff(u_addr), "offsetof(struct user, u_addr)" },
2932 { uoff(u_sigstack), "offsetof(struct user, u_sigstack)" },
2933 { uoff(u_ofile), "offsetof(struct user, u_ofile)" },
2934 { uoff(u_pofile), "offsetof(struct user, u_pofile)" },
2935 { uoff(u_ofile_arr[0]), "offsetof(struct user, u_ofile_arr[0])" },
2936 { uoff(u_pofile_arr[0]),"offsetof(struct user, u_pofile_arr[0])"},
2937 { uoff(u_lastfile), "offsetof(struct user, u_lastfile)" },
2938 { uoff(u_cwd), "offsetof(struct user, u_cwd)" },
2939 { uoff(u_cdir), "offsetof(struct user, u_cdir)" },
2940 { uoff(u_rdir), "offsetof(struct user, u_rdir)" },
2941 { uoff(u_cmask), "offsetof(struct user, u_cmask)" },
2942 { uoff(u_ru), "offsetof(struct user, u_ru)" },
2943 { uoff(u_cru), "offsetof(struct user, u_cru)" },
2944 { uoff(u_timer[0]), "offsetof(struct user, u_timer[0])" },
2945 { uoff(u_XXX[0]), "offsetof(struct user, u_XXX[0])" },
2946 { uoff(u_ioch), "offsetof(struct user, u_ioch)" },
2947 { uoff(u_start), "offsetof(struct user, u_start)" },
2948 { uoff(u_acflag), "offsetof(struct user, u_acflag)" },
2949 { uoff(u_prof.pr_base), "offsetof(struct user, u_prof.pr_base)" },
2950 { uoff(u_prof.pr_size), "offsetof(struct user, u_prof.pr_size)" },
2951 { uoff(u_prof.pr_off), "offsetof(struct user, u_prof.pr_off)" },
2952 { uoff(u_prof.pr_scale),"offsetof(struct user, u_prof.pr_scale)"},
2953 { uoff(u_rlimit[0]), "offsetof(struct user, u_rlimit)" },
2954 { uoff(u_exdata.Ux_A), "offsetof(struct user, u_exdata.Ux_A)" },
2955 { uoff(u_exdata.ux_shell[0]),"offsetof(struct user, u_exdata.ux_shell[0])"},
2956 { uoff(u_lofault), "offsetof(struct user, u_lofault)" },
2959 { sizeof(struct user), "sizeof(struct user)" },
2969 const struct xlat *x;
2972 if (entering(tcp)) {
2973 printxval(ptrace_cmds, tcp->u_arg[0],
2980 tprintf(", %lu, ", tcp->u_arg[1]);
2981 addr = tcp->u_arg[2];
2983 if (tcp->u_arg[0] == PTRACE_PEEKUSER
2984 || tcp->u_arg[0] == PTRACE_POKEUSER) {
2985 for (x = struct_user_offsets; x->str; x++) {
2990 tprintf("%#lx, ", addr);
2991 else if (x->val > addr && x != struct_user_offsets) {
2993 tprintf("%s + %ld, ", x->str, addr - x->val);
2996 tprintf("%s, ", x->str);
3000 tprintf("%#lx, ", tcp->u_arg[2]);
3002 switch (tcp->u_arg[0]) {
3003 case PTRACE_PEEKDATA:
3004 case PTRACE_PEEKTEXT:
3005 case PTRACE_PEEKUSER:
3008 case PTRACE_SINGLESTEP:
3009 case PTRACE_SYSCALL:
3011 printsignal(tcp->u_arg[3]);
3014 tprintf("%#lx", tcp->u_arg[3]);
3018 switch (tcp->u_arg[0]) {
3019 case PTRACE_PEEKDATA:
3020 case PTRACE_PEEKTEXT:
3021 case PTRACE_PEEKUSER:
3022 printnum(tcp, tcp->u_arg[3], "%#lx");
3028 if (tcp->u_arg[0] == PTRACE_WRITEDATA ||
3029 tcp->u_arg[0] == PTRACE_WRITETEXT) {
3030 tprintf("%lu, ", tcp->u_arg[3]);
3031 printstr(tcp, tcp->u_arg[4], tcp->u_arg[3]);
3032 } else if (tcp->u_arg[0] != PTRACE_READDATA &&
3033 tcp->u_arg[0] != PTRACE_READTEXT) {
3034 tprintf("%#lx", tcp->u_arg[3]);
3037 if (tcp->u_arg[0] == PTRACE_READDATA ||
3038 tcp->u_arg[0] == PTRACE_READTEXT) {
3039 tprintf("%lu, ", tcp->u_arg[3]);
3040 printstr(tcp, tcp->u_arg[4], tcp->u_arg[3]);
3045 tprintf("%lu", tcp->u_arg[3]);
3047 #endif /* FREEBSD */
3054 static const struct xlat futexops[] = {
3055 { FUTEX_WAIT, "FUTEX_WAIT" },
3056 { FUTEX_WAKE, "FUTEX_WAKE" },
3057 { FUTEX_FD, "FUTEX_FD" },
3058 { FUTEX_REQUEUE,"FUTEX_REQUEUE" },
3066 if (entering(tcp)) {
3067 tprintf("%p, ", (void *) tcp->u_arg[0]);
3068 printxval(futexops, tcp->u_arg[1], "FUTEX_???");
3069 tprintf(", %ld", tcp->u_arg[2]);
3070 if (tcp->u_arg[1] == FUTEX_WAIT) {
3072 printtv(tcp, tcp->u_arg[3]);
3073 } else if (tcp->u_arg[1] == FUTEX_REQUEUE)
3074 tprintf(", %ld, %p", tcp->u_arg[3], (void *) tcp->u_arg[4]);
3080 print_affinitylist(tcp, list, len)
3087 while (len >= sizeof (unsigned long)) {
3089 umove(tcp, list, &w);
3090 tprintf("%s %lx", first ? "" : ",", w);
3092 len -= sizeof (unsigned long);
3093 list += sizeof(unsigned long);
3099 sys_sched_setaffinity(tcp)
3102 if (entering(tcp)) {
3103 tprintf("%ld, %lu, ", tcp->u_arg[0], tcp->u_arg[1]);
3104 print_affinitylist(tcp, tcp->u_arg[2], tcp->u_arg[1]);
3110 sys_sched_getaffinity(tcp)
3113 if (entering(tcp)) {
3114 tprintf("%ld, %lu, ", tcp->u_arg[0], tcp->u_arg[1]);
3116 if (tcp->u_rval == -1)
3117 tprintf("%#lx", tcp->u_arg[2]);
3119 print_affinitylist(tcp, tcp->u_arg[2], tcp->u_rval);
3124 static const struct xlat schedulers[] = {
3125 { SCHED_OTHER, "SCHED_OTHER" },
3126 { SCHED_RR, "SCHED_RR" },
3127 { SCHED_FIFO, "SCHED_FIFO" },
3132 sys_sched_getscheduler(tcp)
3135 if (entering(tcp)) {
3136 tprintf("%d", (int) tcp->u_arg[0]);
3137 } else if (! syserror(tcp)) {
3138 tcp->auxstr = xlookup (schedulers, tcp->u_rval);
3139 if (tcp->auxstr != NULL)
3146 sys_sched_setscheduler(tcp)
3149 if (entering(tcp)) {
3150 struct sched_param p;
3151 tprintf("%d, ", (int) tcp->u_arg[0]);
3152 printxval(schedulers, tcp->u_arg[1], "SCHED_???");
3153 if (umove(tcp, tcp->u_arg[2], &p) < 0)
3154 tprintf(", %#lx", tcp->u_arg[2]);
3156 tprintf(", { %d }", p.__sched_priority);
3162 sys_sched_getparam(tcp)
3165 if (entering(tcp)) {
3166 tprintf("%d, ", (int) tcp->u_arg[0]);
3168 struct sched_param p;
3169 if (umove(tcp, tcp->u_arg[1], &p) < 0)
3170 tprintf("%#lx", tcp->u_arg[1]);
3172 tprintf("{ %d }", p.__sched_priority);
3178 sys_sched_setparam(tcp)
3181 if (entering(tcp)) {
3182 struct sched_param p;
3183 if (umove(tcp, tcp->u_arg[1], &p) < 0)
3184 tprintf("%d, %#lx", (int) tcp->u_arg[0], tcp->u_arg[1]);
3186 tprintf("%d, { %d }", (int) tcp->u_arg[0], p.__sched_priority);
3192 sys_sched_get_priority_min(tcp)
3195 if (entering(tcp)) {
3196 printxval(schedulers, tcp->u_arg[0], "SCHED_???");
3202 #include <asm/prctl.h>
3204 static const struct xlat archvals[] = {
3205 { ARCH_SET_GS, "ARCH_SET_GS" },
3206 { ARCH_SET_FS, "ARCH_SET_FS" },
3207 { ARCH_GET_FS, "ARCH_GET_FS" },
3208 { ARCH_GET_GS, "ARCH_GET_GS" },
3216 if (entering(tcp)) {
3217 printxval(archvals, tcp->u_arg[0], "ARCH_???");
3218 if (tcp->u_arg[0] == ARCH_SET_GS
3219 || tcp->u_arg[0] == ARCH_SET_FS)
3220 tprintf(", %#lx", tcp->u_arg[1]);
3222 if (tcp->u_arg[0] == ARCH_GET_GS
3223 || tcp->u_arg[0] == ARCH_GET_FS) {
3225 if (!syserror(tcp) && umove(tcp, tcp->u_arg[1], &v) != -1)
3226 tprintf(", [%#lx]", v);
3228 tprintf(", %#lx", tcp->u_arg[1]);