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;
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)
479 if (proc_open(tcpchild, 2) < 0)
485 #else /* !USE_PROCFS */
489 /* defines copied from linux/sched.h since we can't include that
490 * ourselves (it conflicts with *lots* of libc includes)
492 #define CSIGNAL 0x000000ff /* signal mask to be sent at exit */
493 #define CLONE_VM 0x00000100 /* set if VM shared between processes */
494 #define CLONE_FS 0x00000200 /* set if fs info shared between processes */
495 #define CLONE_FILES 0x00000400 /* set if open files shared between processes */
496 #define CLONE_SIGHAND 0x00000800 /* set if signal handlers shared */
497 #define CLONE_IDLETASK 0x00001000 /* kernel-only flag */
498 #define CLONE_PTRACE 0x00002000 /* set if we want to let tracing continue on the child too */
499 #define CLONE_VFORK 0x00004000 /* set if the parent wants the child to wake it up on mm_release */
500 #define CLONE_PARENT 0x00008000 /* set if we want to have the same parent as the cloner */
501 #define CLONE_THREAD 0x00010000 /* Same thread group? */
502 #define CLONE_NEWNS 0x00020000 /* New namespace group? */
503 #define CLONE_SYSVSEM 0x00040000 /* share system V SEM_UNDO semantics */
504 #define CLONE_SETTLS 0x00080000 /* create a new TLS for the child */
505 #define CLONE_PARENT_SETTID 0x00100000 /* set the TID in the parent */
506 #define CLONE_CHILD_CLEARTID 0x00200000 /* clear the TID in the child */
507 #define CLONE_DETACHED 0x00400000 /* parent wants no child-exit signal */
508 #define CLONE_UNTRACED 0x00800000 /* set if the tracing process can't force CLONE_PTRACE on this clone */
509 #define CLONE_CHILD_SETTID 0x01000000 /* set the TID in the child */
511 static const struct xlat clone_flags[] = {
512 { CLONE_VM, "CLONE_VM" },
513 { CLONE_FS, "CLONE_FS" },
514 { CLONE_FILES, "CLONE_FILES" },
515 { CLONE_SIGHAND, "CLONE_SIGHAND" },
516 { CLONE_IDLETASK, "CLONE_IDLETASK"},
517 { CLONE_PTRACE, "CLONE_PTRACE" },
518 { CLONE_VFORK, "CLONE_VFORK" },
519 { CLONE_PARENT, "CLONE_PARENT" },
520 { CLONE_THREAD, "CLONE_THREAD" },
521 { CLONE_NEWNS, "CLONE_NEWNS" },
522 { CLONE_SYSVSEM, "CLONE_SYSVSEM" },
523 { CLONE_SETTLS, "CLONE_SETTLS" },
524 { CLONE_PARENT_SETTID,"CLONE_PARENT_SETTID" },
525 { CLONE_CHILD_CLEARTID,"CLONE_CHILD_CLEARTID" },
526 { CLONE_DETACHED, "CLONE_DETACHED" },
527 { CLONE_UNTRACED, "CLONE_UNTRACED" },
528 { CLONE_CHILD_SETTID,"CLONE_CHILD_SETTID" },
533 # include <asm/ldt.h>
534 # ifdef HAVE_STRUCT_USER_DESC
535 # define modify_ldt_ldt_s user_desc
537 extern void print_ldt_entry();
543 # define ARG_STACKSIZE (known_scno(tcp) == SYS_clone2 ? 2 : -1)
544 # define ARG_PTID (known_scno(tcp) == SYS_clone2 ? 3 : 2)
545 # define ARG_CTID (known_scno(tcp) == SYS_clone2 ? 4 : 3)
546 # define ARG_TLS (known_scno(tcp) == SYS_clone2 ? 5 : 4)
547 # elif defined S390 || defined S390X
553 # elif defined X86_64 || defined ALPHA
572 unsigned long flags = tcp->u_arg[ARG_FLAGS];
573 tprintf("child_stack=%#lx, ", tcp->u_arg[ARG_STACK]);
574 # ifdef ARG_STACKSIZE
575 if (ARG_STACKSIZE != -1)
576 tprintf("stack_size=%#lx, ",
577 tcp->u_arg[ARG_STACKSIZE]);
580 printflags(clone_flags, flags &~ CSIGNAL, NULL);
581 if ((flags & CSIGNAL) != 0)
582 tprintf("|%s", signame(flags & CSIGNAL));
583 if ((flags & (CLONE_PARENT_SETTID|CLONE_CHILD_SETTID
584 |CLONE_CHILD_CLEARTID|CLONE_SETTLS)) == 0)
586 if (flags & CLONE_PARENT_SETTID)
587 tprintf(", parent_tidptr=%#lx", tcp->u_arg[ARG_PTID]);
588 if (flags & CLONE_SETTLS) {
590 struct modify_ldt_ldt_s copy;
591 if (umove(tcp, tcp->u_arg[ARG_TLS], ©) != -1) {
592 tprintf(", {entry_number:%d, ",
597 print_ldt_entry(©);
601 tprintf(", tls=%#lx", tcp->u_arg[ARG_TLS]);
603 if (flags & (CLONE_CHILD_SETTID|CLONE_CHILD_CLEARTID))
604 tprintf(", child_tidptr=%#lx", tcp->u_arg[ARG_CTID]);
610 sys_unshare(struct tcb *tcp)
613 printflags(clone_flags, tcp->u_arg[0], "CLONE_???");
623 return RVAL_UDECIMAL;
628 change_syscall(tcp, new)
634 /* Attempt to make vfork into fork, which we can follow. */
635 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(ORIG_EAX * 4), new) < 0)
638 #elif defined(X86_64)
639 /* Attempt to make vfork into fork, which we can follow. */
640 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(ORIG_RAX * 8), new) < 0)
643 #elif defined(POWERPC)
644 if (ptrace(PTRACE_POKEUSER, tcp->pid,
645 (char*)(sizeof(unsigned long)*PT_R0), new) < 0)
648 #elif defined(S390) || defined(S390X)
649 /* s390 linux after 2.4.7 has a hook in entry.S to allow this */
650 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_GPR2), new)<0)
654 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*PT_ORIG_D0), new)<0)
657 #elif defined(SPARC) || defined(SPARC64)
659 if (ptrace(PTRACE_GETREGS, tcp->pid, (char*)®s, 0)<0)
662 if (ptrace(PTRACE_SETREGS, tcp->pid, (char*)®s, 0)<0)
666 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_V0), new)<0)
670 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_A3), new)<0)
676 case 2: break; /* x86 SYS_fork */
677 case SYS_clone: new = 120; break;
679 fprintf(stderr, "%s: unexpected syscall %d\n",
683 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_R1), new)<0)
685 } else if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_R15), new)<0)
689 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_GR20), new)<0)
693 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*(REG_REG0+3)), new)<0)
697 /* Top half of reg encodes the no. of args n as 0x1n.
698 Assume 0 args as kernel never actually checks... */
699 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_SYSCALL),
704 /* Some kernels support this, some (pre-2.6.16 or so) don't. */
705 # ifndef PTRACE_SET_SYSCALL
706 # define PTRACE_SET_SYSCALL 23
709 if (ptrace (PTRACE_SET_SYSCALL, tcp->pid, 0, new) != 0)
714 #warning Do not know how to handle change_syscall for this architecture
715 #endif /* architecture */
728 unsigned long *bsp, *ap;
730 if (upeek(tcp->pid, PT_AR_BSP, (long *) &bsp) , 0)
733 ap = ia64_rse_skip_regs(bsp, argnum);
735 ptrace(PTRACE_POKEDATA, tcp->pid, (char *) ap, tcp->u_arg[argnum]);
742 ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*argnum), tcp->u_arg[argnum]);
746 #elif defined(X86_64)
748 ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(8*(long)argnum), tcp->u_arg[argnum]);
752 #elif defined(POWERPC)
754 #define PT_ORIG_R3 34
757 ptrace(PTRACE_POKEUSER, tcp->pid,
758 (char*)((argnum==0 ? PT_ORIG_R3 : argnum+PT_R3)*sizeof(unsigned long)),
767 ptrace(PTRACE_POKEUSER, tcp->pid,
768 (char*)(REG_A0 + argnum), tcp->u_arg[argnum]);
772 if (upeek(tcp->pid, REG_SP, (long *) &sp) , 0)
775 ptrace(PTRACE_POKEDATA, tcp->pid,
776 (char*)(sp + argnum - 4), tcp->u_arg[argnum]);
781 #elif defined(S390) || defined(S390X)
784 ptrace(PTRACE_POKEUSER, tcp->pid,
785 (char *) (argnum==0 ? PT_ORIGGPR2 :
786 PT_GPR2 + argnum*sizeof(long)),
794 # warning Sorry, setargs not implemented for this architecture.
800 #if defined SYS_clone || defined SYS_clone2
805 struct tcb *tcpchild;
815 int bpt = tcp->flags & TCB_BPTSET;
817 if (!(tcp->flags & TCB_FOLLOWFORK))
828 #ifdef CLONE_PTRACE /* See new setbpt code. */
829 tcpchild = pid2tcb(pid);
830 if (tcpchild != NULL) {
831 /* The child already reported its startup trap
832 before the parent reported its syscall return. */
834 & (TCB_STARTUP|TCB_ATTACHED|TCB_SUSPENDED))
835 != (TCB_STARTUP|TCB_ATTACHED|TCB_SUSPENDED))
837 [preattached child %d of %d in weird state!]\n",
842 if (fork_tcb(tcp) || (tcpchild = alloctcb(pid)) == NULL) {
845 kill(pid, SIGKILL); /* XXX */
850 /* Attach to the new child */
851 if (ptrace(PTRACE_ATTACH, pid, (char *) 1, 0) < 0) {
854 perror("PTRACE_ATTACH");
855 fprintf(stderr, "Too late?\n");
864 tcpchild->flags |= TCB_ATTACHED;
865 /* Child has BPT too, must be removed on first occasion. */
867 tcpchild->flags |= TCB_BPTSET;
868 tcpchild->baddr = tcp->baddr;
869 memcpy(tcpchild->inst, tcp->inst,
870 sizeof tcpchild->inst);
872 tcpchild->parent = tcp;
874 if (tcpchild->flags & TCB_SUSPENDED) {
875 /* The child was born suspended, due to our having
876 forced CLONE_PTRACE. */
880 tcpchild->flags &= ~(TCB_SUSPENDED|TCB_STARTUP);
881 if (ptrace(PTRACE_SYSCALL, pid, (char *) 1, 0) < 0) {
882 perror("resume: ptrace(PTRACE_SYSCALL, ...)");
888 Process %u resumed (parent %d ready)\n",
894 fprintf(stderr, "Process %d attached\n", pid);
897 #ifdef TCB_CLONE_THREAD
900 * Save the flags used in this call,
901 * in case we point TCP to our parent below.
903 int call_flags = tcp->u_arg[ARG_FLAGS];
904 if ((tcp->flags & TCB_CLONE_THREAD) &&
905 tcp->parent != NULL) {
906 /* The parent in this clone is itself a
907 thread belonging to another process.
908 There is no meaning to the parentage
909 relationship of the new child with the
910 thread, only with the process. We
911 associate the new thread with our
912 parent. Since this is done for every
913 new thread, there will never be a
914 TCB_CLONE_THREAD process that has
918 tcpchild->parent = tcp;
921 if (call_flags & CLONE_THREAD) {
922 tcpchild->flags |= TCB_CLONE_THREAD;
923 ++tcp->nclone_threads;
925 if (call_flags & CLONE_DETACHED) {
926 tcpchild->flags |= TCB_CLONE_DETACHED;
927 ++tcp->nclone_detached;
942 /* We do special magic with clone for any clone or fork. */
943 return internal_clone(tcp);
946 struct tcb *tcpchild;
951 if (known_scno(tcp) == SYS_vfork) {
952 /* Attempt to make vfork into fork, which we can follow. */
954 change_syscall(tcp, SYS_fork) < 0)
959 if (!followfork || dont_follow)
967 int bpt = tcp->flags & TCB_BPTSET;
969 if (!(tcp->flags & TCB_FOLLOWFORK))
978 if (fork_tcb(tcp) || (tcpchild = alloctcb(pid)) == NULL) {
979 kill(pid, SIGKILL); /* XXX */
984 /* The child must have run before it can be attached. */
985 /* This must be a bug in the parisc kernel, but I havn't
986 * identified it yet. Seems to be an issue associated
987 * with attaching to a process (which sends it a signal)
988 * before that process has ever been scheduled. When
989 * debugging, I started seeing crashes in
990 * arch/parisc/kernel/signal.c:do_signal(), apparently
991 * caused by r8 getting corrupt over the dequeue_signal()
992 * call. Didn't make much sense though...
998 select(0, NULL, NULL, NULL, &tv);
1001 if (ptrace(PTRACE_ATTACH, pid, (char *) 1, 0) < 0) {
1002 perror("PTRACE_ATTACH");
1003 fprintf(stderr, "Too late?\n");
1010 /* The child must have run before it can be attached. */
1015 select(0, NULL, NULL, NULL, &tv);
1017 if (ptrace(PTRACE_ATTACH, pid, (char *)1, 0) < 0) {
1018 perror("PTRACE_ATTACH");
1019 fprintf(stderr, "Too late?\n");
1024 /* Try to catch the new process as soon as possible. */
1027 for (i = 0; i < 1024; i++)
1028 if (ptrace(PTRACE_ATTACH, pid, (char *) 1, 0) >= 0)
1031 perror("PTRACE_ATTACH");
1032 fprintf(stderr, "Too late?\n");
1037 #endif /* !oldway */
1039 tcpchild->flags |= TCB_ATTACHED;
1040 /* Child has BPT too, must be removed on first occasion */
1042 tcpchild->flags |= TCB_BPTSET;
1043 tcpchild->baddr = tcp->baddr;
1044 memcpy(tcpchild->inst, tcp->inst,
1045 sizeof tcpchild->inst);
1048 tcpchild->parent = tcp;
1051 fprintf(stderr, "Process %d attached\n", pid);
1057 #endif /* !USE_PROCFS */
1059 #if defined(SUNOS4) || defined(LINUX) || defined(FREEBSD)
1066 return RVAL_UDECIMAL;
1070 #endif /* SUNOS4 || LINUX || FREEBSD */
1074 static char idstr[16];
1081 sprintf(idstr, "ppid %lu", getrval2(tcp));
1082 tcp->auxstr = idstr;
1093 sprintf(idstr, "euid %lu", getrval2(tcp));
1094 tcp->auxstr = idstr;
1105 sprintf(idstr, "egid %lu", getrval2(tcp));
1106 tcp->auxstr = idstr;
1120 if (entering(tcp)) {
1121 tprintf("%u", (uid_t) tcp->u_arg[0]);
1130 if (entering(tcp)) {
1131 tprintf("%u", (gid_t) tcp->u_arg[0]);
1143 tprintf("%#lx, %#lx, %#lx", tcp->u_arg[0],
1144 tcp->u_arg[1], tcp->u_arg[2]);
1146 if (umove(tcp, tcp->u_arg[0], &uid) < 0)
1147 tprintf("%#lx, ", tcp->u_arg[0]);
1149 tprintf("[%lu], ", (unsigned long) uid);
1150 if (umove(tcp, tcp->u_arg[1], &uid) < 0)
1151 tprintf("%#lx, ", tcp->u_arg[1]);
1153 tprintf("[%lu], ", (unsigned long) uid);
1154 if (umove(tcp, tcp->u_arg[2], &uid) < 0)
1155 tprintf("%#lx", tcp->u_arg[2]);
1157 tprintf("[%lu]", (unsigned long) uid);
1170 tprintf("%#lx, %#lx, %#lx", tcp->u_arg[0],
1171 tcp->u_arg[1], tcp->u_arg[2]);
1173 if (umove(tcp, tcp->u_arg[0], &gid) < 0)
1174 tprintf("%#lx, ", tcp->u_arg[0]);
1176 tprintf("[%lu], ", (unsigned long) gid);
1177 if (umove(tcp, tcp->u_arg[1], &gid) < 0)
1178 tprintf("%#lx, ", tcp->u_arg[1]);
1180 tprintf("[%lu], ", (unsigned long) gid);
1181 if (umove(tcp, tcp->u_arg[2], &gid) < 0)
1182 tprintf("%#lx", tcp->u_arg[2]);
1184 tprintf("[%lu]", (unsigned long) gid);
1196 if (entering(tcp)) {
1197 printuid("", tcp->u_arg[0]);
1198 printuid(", ", tcp->u_arg[1]);
1207 if (entering(tcp)) {
1208 printuid("", tcp->u_arg[0]);
1209 printuid(", ", tcp->u_arg[1]);
1214 #if defined(LINUX) || defined(FREEBSD)
1219 if (entering(tcp)) {
1220 printuid("", tcp->u_arg[0]);
1221 printuid(", ", tcp->u_arg[1]);
1222 printuid(", ", tcp->u_arg[2]);
1230 if (entering(tcp)) {
1231 printuid("", tcp->u_arg[0]);
1232 printuid(", ", tcp->u_arg[1]);
1233 printuid(", ", tcp->u_arg[2]);
1238 #endif /* LINUX || FREEBSD */
1244 if (entering(tcp)) {
1245 unsigned long len, size, start, cur, end, abbrev_end;
1249 len = tcp->u_arg[0];
1250 tprintf("%lu, ", len);
1255 start = tcp->u_arg[1];
1260 size = len * sizeof(gid);
1262 if (!verbose(tcp) || size / sizeof(gid) != len || end < start) {
1263 tprintf("%#lx", start);
1267 abbrev_end = start + max_strlen * sizeof(gid);
1268 if (abbrev_end < start)
1274 for (cur = start; cur < end; cur += sizeof(gid)) {
1277 if (cur >= abbrev_end) {
1281 if (umoven(tcp, cur, sizeof(gid), (char *) &gid) < 0) {
1286 tprintf("%lu", (unsigned long) gid);
1290 tprintf(" %#lx", tcp->u_arg[1]);
1301 if (entering(tcp)) {
1302 len = tcp->u_arg[0];
1303 tprintf("%lu, ", len);
1305 unsigned long size, start, cur, end, abbrev_end;
1314 start = tcp->u_arg[1];
1319 if (tcp->u_arg[0] == 0) {
1320 tprintf("%#lx", start);
1323 size = len * sizeof(gid);
1325 if (!verbose(tcp) || tcp->u_arg[0] == 0 ||
1326 size / sizeof(gid) != len || end < start) {
1327 tprintf("%#lx", start);
1331 abbrev_end = start + max_strlen * sizeof(gid);
1332 if (abbrev_end < start)
1338 for (cur = start; cur < end; cur += sizeof(gid)) {
1341 if (cur >= abbrev_end) {
1345 if (umoven(tcp, cur, sizeof(gid), (char *) &gid) < 0) {
1350 tprintf("%lu", (unsigned long) gid);
1354 tprintf(" %#lx", tcp->u_arg[1]);
1361 sys_setgroups32(tcp)
1364 if (entering(tcp)) {
1365 unsigned long len, size, start, cur, end, abbrev_end;
1369 len = tcp->u_arg[0];
1370 tprintf("%lu, ", len);
1375 start = tcp->u_arg[1];
1380 size = len * sizeof(gid);
1382 if (!verbose(tcp) || size / sizeof(gid) != len || end < start) {
1383 tprintf("%#lx", start);
1387 abbrev_end = start + max_strlen * sizeof(gid);
1388 if (abbrev_end < start)
1394 for (cur = start; cur < end; cur += sizeof(gid)) {
1397 if (cur >= abbrev_end) {
1401 if (umoven(tcp, cur, sizeof(gid), (char *) &gid) < 0) {
1406 tprintf("%lu", (unsigned long) gid);
1410 tprintf(" %#lx", tcp->u_arg[1]);
1416 sys_getgroups32(tcp)
1421 if (entering(tcp)) {
1422 len = tcp->u_arg[0];
1423 tprintf("%lu, ", len);
1425 unsigned long size, start, cur, end, abbrev_end;
1434 start = tcp->u_arg[1];
1439 size = len * sizeof(gid);
1441 if (!verbose(tcp) || tcp->u_arg[0] == 0 ||
1442 size / sizeof(gid) != len || end < start) {
1443 tprintf("%#lx", start);
1447 abbrev_end = start + max_strlen * sizeof(gid);
1448 if (abbrev_end < start)
1454 for (cur = start; cur < end; cur += sizeof(gid)) {
1457 if (cur >= abbrev_end) {
1461 if (umoven(tcp, cur, sizeof(gid), (char *) &gid) < 0) {
1466 tprintf("%lu", (unsigned long) gid);
1470 tprintf(" %#lx", tcp->u_arg[1]);
1480 if (entering(tcp)) {
1482 tprintf("%lu, %lu", tcp->u_arg[0], tcp->u_arg[1]);
1492 if (entering(tcp)) {
1494 tprintf("%lu", tcp->u_arg[0]);
1504 if (entering(tcp)) {
1505 tprintf("%lu", tcp->u_arg[0]);
1521 if (entering(tcp)) {
1522 tprintf("%lu", tcp->u_arg[0]);
1531 if (entering(tcp)) {
1532 tprintf("%lu, %lu", tcp->u_arg[0], tcp->u_arg[1]);
1539 #include <sys/privilege.h>
1542 static const struct xlat procpriv_cmds [] = {
1543 { SETPRV, "SETPRV" },
1544 { CLRPRV, "CLRPRV" },
1545 { PUTPRV, "PUTPRV" },
1546 { GETPRV, "GETPRV" },
1547 { CNTPRV, "CNTPRV" },
1552 static const struct xlat procpriv_priv [] = {
1553 { P_OWNER, "P_OWNER" },
1554 { P_AUDIT, "P_AUDIT" },
1555 { P_COMPAT, "P_COMPAT" },
1556 { P_DACREAD, "P_DACREAD" },
1557 { P_DACWRITE, "P_DACWRITE" },
1559 { P_FILESYS, "P_FILESYS" },
1560 { P_MACREAD, "P_MACREAD" },
1561 { P_MACWRITE, "P_MACWRITE" },
1562 { P_MOUNT, "P_MOUNT" },
1563 { P_MULTIDIR, "P_MULTIDIR" },
1564 { P_SETPLEVEL, "P_SETPLEVEL" },
1565 { P_SETSPRIV, "P_SETSPRIV" },
1566 { P_SETUID, "P_SETUID" },
1567 { P_SYSOPS, "P_SYSOPS" },
1568 { P_SETUPRIV, "P_SETUPRIV" },
1569 { P_DRIVER, "P_DRIVER" },
1570 { P_RTIME, "P_RTIME" },
1571 { P_MACUPGRADE, "P_MACUPGRADE" },
1572 { P_FSYSRANGE, "P_FSYSRANGE" },
1573 { P_SETFLEVEL, "P_SETFLEVEL" },
1574 { P_AUDITWR, "P_AUDITWR" },
1575 { P_TSHAR, "P_TSHAR" },
1576 { P_PLOCK, "P_PLOCK" },
1577 { P_CORE, "P_CORE" },
1578 { P_LOADMOD, "P_LOADMOD" },
1579 { P_BIND, "P_BIND" },
1580 { P_ALLPRIVS, "P_ALLPRIVS" },
1585 static const struct xlat procpriv_type [] = {
1586 { PS_FIX, "PS_FIX" },
1587 { PS_INH, "PS_INH" },
1588 { PS_MAX, "PS_MAX" },
1589 { PS_WKG, "PS_WKG" },
1595 printpriv(tcp, addr, len, opt)
1599 const struct xlat *opt;
1602 int max = verbose (tcp) ? sizeof buf / sizeof buf [0] : 10;
1603 int dots = len > max;
1606 if (len > max) len = max;
1609 umoven (tcp, addr, len * sizeof buf[0], (char *) buf) < 0)
1611 tprintf ("%#lx", addr);
1617 for (i = 0; i < len; ++i) {
1620 if (i) tprintf (", ");
1622 if ((t = xlookup (procpriv_type, buf [i] & PS_TYPE)) &&
1623 (p = xlookup (procpriv_priv, buf [i] & ~PS_TYPE)))
1625 tprintf ("%s|%s", t, p);
1628 tprintf ("%#lx", buf [i]);
1632 if (dots) tprintf (" ...");
1642 if (entering(tcp)) {
1643 printxval(procpriv_cmds, tcp->u_arg[0], "???PRV");
1644 switch (tcp->u_arg[0]) {
1646 tprintf(", %#lx, %ld", tcp->u_arg[1], tcp->u_arg[2]);
1654 printpriv (tcp, tcp->u_arg[1], tcp->u_arg[2]);
1655 tprintf (", %ld", tcp->u_arg[2]);
1658 else if (tcp->u_arg[0] == GETPRV) {
1659 if (syserror (tcp)) {
1660 tprintf(", %#lx, %ld", tcp->u_arg[1], tcp->u_arg[2]);
1664 printpriv (tcp, tcp->u_arg[1], tcp->u_rval);
1665 tprintf (", %ld", tcp->u_arg[2]);
1676 printargv(tcp, addr)
1682 int max = max_strlen / 2;
1684 for (sep = ""; --max >= 0; sep = ", ") {
1687 if (umove(tcp, addr, &cp) < 0) {
1688 tprintf("%#lx", addr);
1694 printstr(tcp, (long) cp, -1);
1695 addr += sizeof(char *);
1702 printargc(fmt, tcp, addr)
1710 for (count = 0; umove(tcp, addr, &cp) >= 0 && cp != NULL; count++) {
1711 addr += sizeof(char *);
1713 tprintf(fmt, count, count == 1 ? "" : "s");
1720 if (entering(tcp)) {
1721 printpath(tcp, tcp->u_arg[0]);
1723 tprintf(", %#lx", tcp->u_arg[1]);
1725 else if (abbrev(tcp))
1726 printargc(", [/* %d arg%s */]", tcp, tcp->u_arg[1]);
1730 printargv(tcp, tcp->u_arg[1]);
1741 if (entering(tcp)) {
1742 printpath(tcp, tcp->u_arg[0]);
1744 tprintf(", %#lx", tcp->u_arg[1]);
1746 else if (abbrev(tcp))
1747 printargc(", [/* %d arg%s */]", tcp, tcp->u_arg[1]);
1751 printargv(tcp, tcp->u_arg[1]);
1755 tprintf(", %#lx", tcp->u_arg[2]);
1756 else if (abbrev(tcp))
1757 printargc(", [/* %d var%s */]", tcp, tcp->u_arg[2]);
1760 printargv(tcp, tcp->u_arg[2]);
1769 int sys_rexecve(tcp)
1772 if (entering (tcp)) {
1774 tprintf (", %ld", tcp->u_arg[3]);
1786 if (exiting(tcp) && !syserror(tcp) && followfork)
1789 #if defined LINUX && defined TCB_WAITEXECVE
1790 if (exiting(tcp) && syserror(tcp))
1791 tcp->flags &= ~TCB_WAITEXECVE;
1793 tcp->flags |= TCB_WAITEXECVE;
1794 #endif /* LINUX && TCB_WAITEXECVE */
1800 #define __WNOTHREAD 0x20000000
1803 #define __WALL 0x40000000
1806 #define __WCLONE 0x80000000
1810 static const struct xlat wait4_options[] = {
1811 { WNOHANG, "WNOHANG" },
1813 { WUNTRACED, "WUNTRACED" },
1816 { WEXITED, "WEXITED" },
1819 { WTRAPPED, "WTRAPPED" },
1822 { WSTOPPED, "WSTOPPED" },
1825 { WCONTINUED, "WCONTINUED" },
1828 { WNOWAIT, "WNOWAIT" },
1831 { __WCLONE, "__WCLONE" },
1834 { __WALL, "__WALL" },
1837 { __WNOTHREAD, "__WNOTHREAD" },
1842 #if !defined WCOREFLAG && defined WCOREFLG
1843 # define WCOREFLAG WCOREFLG
1846 #define WCOREFLAG 0x80
1850 #define W_STOPCODE(sig) ((sig) << 8 | 0x7f)
1853 #define W_EXITCODE(ret, sig) ((ret) << 8 | (sig))
1863 * Here is a tricky presentation problem. This solution
1864 * is still not entirely satisfactory but since there
1865 * are no wait status constructors it will have to do.
1867 if (WIFSTOPPED(status)) {
1868 tprintf("[{WIFSTOPPED(s) && WSTOPSIG(s) == %s}",
1869 signame(WSTOPSIG(status)));
1870 status &= ~W_STOPCODE(WSTOPSIG(status));
1872 else if (WIFSIGNALED(status)) {
1873 tprintf("[{WIFSIGNALED(s) && WTERMSIG(s) == %s%s}",
1874 signame(WTERMSIG(status)),
1875 WCOREDUMP(status) ? " && WCOREDUMP(s)" : "");
1876 status &= ~(W_EXITCODE(0, WTERMSIG(status)) | WCOREFLAG);
1878 else if (WIFEXITED(status)) {
1879 tprintf("[{WIFEXITED(s) && WEXITSTATUS(s) == %d}",
1880 WEXITSTATUS(status));
1882 status &= ~W_EXITCODE(WEXITSTATUS(status), 0);
1885 tprintf("[%#x]", status);
1892 tprintf(" | %#x]", status);
1898 printwaitn(tcp, n, bitness)
1906 if (entering(tcp)) {
1907 tprintf("%ld, ", tcp->u_arg[0]);
1912 else if (syserror(tcp) || tcp->u_rval == 0)
1913 tprintf("%#lx", tcp->u_arg[1]);
1914 else if (umove(tcp, tcp->u_arg[1], &status) < 0)
1917 exited = printstatus(status);
1920 printflags(wait4_options, tcp->u_arg[2], "W???");
1927 else if (tcp->u_rval > 0) {
1930 printrusage32(tcp, tcp->u_arg[3]);
1933 printrusage(tcp, tcp->u_arg[3]);
1937 else if (tcp->u_rval > 0 && exited)
1938 printrusage(tcp, tcp->u_arg[3]);
1941 tprintf("%#lx", tcp->u_arg[3]);
1948 internal_wait(tcp, flagarg)
1954 #ifdef TCB_CLONE_THREAD
1955 if (tcp->flags & TCB_CLONE_THREAD)
1956 /* The children we wait for are our parent's children. */
1957 got_kids = (tcp->parent->nchildren
1958 > tcp->parent->nclone_detached);
1960 got_kids = (tcp->nchildren > tcp->nclone_detached);
1962 got_kids = tcp->nchildren > 0;
1965 if (entering(tcp) && got_kids) {
1966 /* There are children that this parent should block for.
1967 But ptrace made us the parent of the traced children
1968 and the real parent will get ECHILD from the wait call.
1970 XXX If we attached with strace -f -p PID, then there
1971 may be untraced dead children the parent could be reaping
1972 now, but we make him block. */
1974 /* ??? WTA: fix bug with hanging children */
1976 if (!(tcp->u_arg[flagarg] & WNOHANG)) {
1978 * There are traced children. We'll make the parent
1979 * block to avoid a false ECHILD error due to our
1980 * ptrace having stolen the children. However,
1981 * we shouldn't block if there are zombies to reap.
1982 * XXX doesn't handle pgrp matches (u_arg[0]==0,<-1)
1984 struct tcb *child = NULL;
1985 if (tcp->nzombies > 0 &&
1986 (tcp->u_arg[0] == -1 ||
1987 (child = pid2tcb(tcp->u_arg[0])) == NULL))
1989 if (tcp->u_arg[0] > 0) {
1991 * If the parent waits for a specified child
1992 * PID, then it must get ECHILD right away
1993 * if that PID is not one of its children.
1994 * Make sure that the requested PID matches
1995 * one of the parent's children that we are
1996 * tracing, and don't suspend it otherwise.
1999 child = pid2tcb(tcp->u_arg[0]);
2000 if (child == NULL || child->parent != (
2001 #ifdef TCB_CLONE_THREAD
2002 (tcp->flags & TCB_CLONE_THREAD)
2006 (child->flags & TCB_EXITING))
2009 tcp->flags |= TCB_SUSPENDED;
2010 tcp->waitpid = tcp->u_arg[0];
2011 #ifdef TCB_CLONE_THREAD
2012 if (tcp->flags & TCB_CLONE_THREAD)
2013 tcp->parent->nclone_waiting++;
2017 if (exiting(tcp) && tcp->u_error == ECHILD && got_kids) {
2018 if (tcp->u_arg[flagarg] & WNOHANG) {
2019 /* We must force a fake result of 0 instead of
2020 the ECHILD error. */
2021 extern int force_result();
2022 return force_result(tcp, 0, 0);
2025 else if (exiting(tcp) && tcp->u_error == 0 && tcp->u_rval > 0 &&
2026 tcp->nzombies > 0 && pid2tcb(tcp->u_rval) == NULL) {
2028 * We just reaped a child we don't know about,
2029 * presumably a zombie we already droptcb'd.
2043 /* The library wrapper stuffs this into the user variable. */
2045 printstatus(getrval2(tcp));
2060 if (!syserror(tcp)) {
2061 if (umove(tcp, tcp->u_arg[0], &status) < 0)
2062 tprintf("%#lx", tcp->u_arg[0]);
2064 printstatus(status);
2075 return printwaitn(tcp, 3, 0);
2082 return printwaitn(tcp, 4, 0);
2090 return printwaitn(tcp, 4, 1);
2094 #if defined SVR4 || defined LINUX
2096 static const struct xlat waitid_types[] = {
2099 { P_PPID, "P_PPID" },
2101 { P_PGID, "P_PGID" },
2116 { P_LWPID, "P_LWPID" },
2128 if (entering(tcp)) {
2129 printxval(waitid_types, tcp->u_arg[0], "P_???");
2130 tprintf(", %ld, ", tcp->u_arg[1]);
2137 else if (syserror(tcp))
2138 tprintf("%#lx", tcp->u_arg[2]);
2139 else if (umove(tcp, tcp->u_arg[2], &si) < 0)
2142 printsiginfo(&si, verbose (tcp));
2145 printflags(wait4_options, tcp->u_arg[3], "W???");
2146 if (tcp->u_nargs > 4) {
2151 else if (tcp->u_error)
2152 tprintf("%#lx", tcp->u_arg[4]);
2154 printrusage(tcp, tcp->u_arg[4]);
2160 #endif /* SVR4 or LINUX */
2167 tprintf("%lu", tcp->u_arg[0]);
2175 struct utsname uname;
2178 if (syserror(tcp) || !verbose(tcp))
2179 tprintf("%#lx", tcp->u_arg[0]);
2180 else if (umove(tcp, tcp->u_arg[0], &uname) < 0)
2182 else if (!abbrev(tcp)) {
2184 tprintf("{sysname=\"%s\", nodename=\"%s\", ",
2185 uname.sysname, uname.nodename);
2186 tprintf("release=\"%s\", version=\"%s\", ",
2187 uname.release, uname.version);
2188 tprintf("machine=\"%s\"", uname.machine);
2191 tprintf(", domainname=\"%s\"", uname.domainname);
2192 #endif /* __GLIBC__ */
2197 tprintf("{sys=\"%s\", node=\"%s\", ...}",
2198 uname.sysname, uname.nodename);
2205 static const struct xlat ptrace_cmds[] = {
2207 { PTRACE_TRACEME, "PTRACE_TRACEME" },
2208 { PTRACE_PEEKTEXT, "PTRACE_PEEKTEXT", },
2209 { PTRACE_PEEKDATA, "PTRACE_PEEKDATA", },
2210 { PTRACE_PEEKUSER, "PTRACE_PEEKUSER", },
2211 { PTRACE_POKETEXT, "PTRACE_POKETEXT", },
2212 { PTRACE_POKEDATA, "PTRACE_POKEDATA", },
2213 { PTRACE_POKEUSER, "PTRACE_POKEUSER", },
2214 { PTRACE_CONT, "PTRACE_CONT" },
2215 { PTRACE_KILL, "PTRACE_KILL" },
2216 { PTRACE_SINGLESTEP, "PTRACE_SINGLESTEP" },
2217 { PTRACE_ATTACH, "PTRACE_ATTACH" },
2218 { PTRACE_DETACH, "PTRACE_DETACH" },
2219 #ifdef PTRACE_GETREGS
2220 { PTRACE_GETREGS, "PTRACE_GETREGS" },
2222 #ifdef PTRACE_SETREGS
2223 { PTRACE_SETREGS, "PTRACE_SETREGS" },
2225 #ifdef PTRACE_GETFPREGS
2226 { PTRACE_GETFPREGS, "PTRACE_GETFPREGS", },
2228 #ifdef PTRACE_SETFPREGS
2229 { PTRACE_SETFPREGS, "PTRACE_SETFPREGS", },
2231 #ifdef PTRACE_GETFPXREGS
2232 { PTRACE_GETFPXREGS, "PTRACE_GETFPXREGS", },
2234 #ifdef PTRACE_SETFPXREGS
2235 { PTRACE_SETFPXREGS, "PTRACE_SETFPXREGS", },
2237 #ifdef PTRACE_GETVRREGS
2238 { PTRACE_GETVRREGS, "PTRACE_GETVRREGS", },
2240 #ifdef PTRACE_SETVRREGS
2241 { PTRACE_SETVRREGS, "PTRACE_SETVRREGS", },
2244 { PTRACE_READDATA, "PTRACE_READDATA" },
2245 { PTRACE_WRITEDATA, "PTRACE_WRITEDATA" },
2246 { PTRACE_READTEXT, "PTRACE_READTEXT" },
2247 { PTRACE_WRITETEXT, "PTRACE_WRITETEXT" },
2248 { PTRACE_GETFPAREGS, "PTRACE_GETFPAREGS" },
2249 { PTRACE_SETFPAREGS, "PTRACE_SETFPAREGS" },
2251 { PTRACE_GETWINDOW, "PTRACE_GETWINDOW" },
2252 { PTRACE_SETWINDOW, "PTRACE_SETWINDOW" },
2254 { PTRACE_22, "PTRACE_PTRACE_22" },
2255 { PTRACE_23, "PTRACE_PTRACE_23" },
2258 { PTRACE_SYSCALL, "PTRACE_SYSCALL" },
2260 { PTRACE_DUMPCORE, "PTRACE_DUMPCORE" },
2262 { PTRACE_SETWRBKPT, "PTRACE_SETWRBKPT" },
2263 { PTRACE_SETACBKPT, "PTRACE_SETACBKPT" },
2264 { PTRACE_CLRDR7, "PTRACE_CLRDR7" },
2266 { PTRACE_26, "PTRACE_26" },
2267 { PTRACE_27, "PTRACE_27" },
2268 { PTRACE_28, "PTRACE_28" },
2270 { PTRACE_GETUCODE, "PTRACE_GETUCODE" },
2273 { PT_TRACE_ME, "PT_TRACE_ME" },
2274 { PT_READ_I, "PT_READ_I" },
2275 { PT_READ_D, "PT_READ_D" },
2276 { PT_WRITE_I, "PT_WRITE_I" },
2277 { PT_WRITE_D, "PT_WRITE_D" },
2279 { PT_READ_U, "PT_READ_U" },
2281 { PT_CONTINUE, "PT_CONTINUE" },
2282 { PT_KILL, "PT_KILL" },
2283 { PT_STEP, "PT_STEP" },
2284 { PT_ATTACH, "PT_ATTACH" },
2285 { PT_DETACH, "PT_DETACH" },
2286 { PT_GETREGS, "PT_GETREGS" },
2287 { PT_SETREGS, "PT_SETREGS" },
2288 { PT_GETFPREGS, "PT_GETFPREGS" },
2289 { PT_SETFPREGS, "PT_SETFPREGS" },
2290 { PT_GETDBREGS, "PT_GETDBREGS" },
2291 { PT_SETDBREGS, "PT_SETDBREGS" },
2292 #endif /* FREEBSD */
2297 #ifndef SUNOS4_KERNEL_ARCH_KLUDGE
2299 #endif /* !SUNOS4_KERNEL_ARCH_KLUDGE */
2300 const struct xlat struct_user_offsets[] = {
2302 #if defined(S390) || defined(S390X)
2303 { PT_PSWMASK, "psw_mask" },
2304 { PT_PSWADDR, "psw_addr" },
2305 { PT_GPR0, "gpr0" },
2306 { PT_GPR1, "gpr1" },
2307 { PT_GPR2, "gpr2" },
2308 { PT_GPR3, "gpr3" },
2309 { PT_GPR4, "gpr4" },
2310 { PT_GPR5, "gpr5" },
2311 { PT_GPR6, "gpr6" },
2312 { PT_GPR7, "gpr7" },
2313 { PT_GPR8, "gpr8" },
2314 { PT_GPR9, "gpr9" },
2315 { PT_GPR10, "gpr10" },
2316 { PT_GPR11, "gpr11" },
2317 { PT_GPR12, "gpr12" },
2318 { PT_GPR13, "gpr13" },
2319 { PT_GPR14, "gpr14" },
2320 { PT_GPR15, "gpr15" },
2321 { PT_ACR0, "acr0" },
2322 { PT_ACR1, "acr1" },
2323 { PT_ACR2, "acr2" },
2324 { PT_ACR3, "acr3" },
2325 { PT_ACR4, "acr4" },
2326 { PT_ACR5, "acr5" },
2327 { PT_ACR6, "acr6" },
2328 { PT_ACR7, "acr7" },
2329 { PT_ACR8, "acr8" },
2330 { PT_ACR9, "acr9" },
2331 { PT_ACR10, "acr10" },
2332 { PT_ACR11, "acr11" },
2333 { PT_ACR12, "acr12" },
2334 { PT_ACR13, "acr13" },
2335 { PT_ACR14, "acr14" },
2336 { PT_ACR15, "acr15" },
2337 { PT_ORIGGPR2, "orig_gpr2" },
2340 { PT_FPR0_HI, "fpr0.hi" },
2341 { PT_FPR0_LO, "fpr0.lo" },
2342 { PT_FPR1_HI, "fpr1.hi" },
2343 { PT_FPR1_LO, "fpr1.lo" },
2344 { PT_FPR2_HI, "fpr2.hi" },
2345 { PT_FPR2_LO, "fpr2.lo" },
2346 { PT_FPR3_HI, "fpr3.hi" },
2347 { PT_FPR3_LO, "fpr3.lo" },
2348 { PT_FPR4_HI, "fpr4.hi" },
2349 { PT_FPR4_LO, "fpr4.lo" },
2350 { PT_FPR5_HI, "fpr5.hi" },
2351 { PT_FPR5_LO, "fpr5.lo" },
2352 { PT_FPR6_HI, "fpr6.hi" },
2353 { PT_FPR6_LO, "fpr6.lo" },
2354 { PT_FPR7_HI, "fpr7.hi" },
2355 { PT_FPR7_LO, "fpr7.lo" },
2356 { PT_FPR8_HI, "fpr8.hi" },
2357 { PT_FPR8_LO, "fpr8.lo" },
2358 { PT_FPR9_HI, "fpr9.hi" },
2359 { PT_FPR9_LO, "fpr9.lo" },
2360 { PT_FPR10_HI, "fpr10.hi" },
2361 { PT_FPR10_LO, "fpr10.lo" },
2362 { PT_FPR11_HI, "fpr11.hi" },
2363 { PT_FPR11_LO, "fpr11.lo" },
2364 { PT_FPR12_HI, "fpr12.hi" },
2365 { PT_FPR12_LO, "fpr12.lo" },
2366 { PT_FPR13_HI, "fpr13.hi" },
2367 { PT_FPR13_LO, "fpr13.lo" },
2368 { PT_FPR14_HI, "fpr14.hi" },
2369 { PT_FPR14_LO, "fpr14.lo" },
2370 { PT_FPR15_HI, "fpr15.hi" },
2371 { PT_FPR15_LO, "fpr15.lo" },
2374 { PT_FPR0, "fpr0" },
2375 { PT_FPR1, "fpr1" },
2376 { PT_FPR2, "fpr2" },
2377 { PT_FPR3, "fpr3" },
2378 { PT_FPR4, "fpr4" },
2379 { PT_FPR5, "fpr5" },
2380 { PT_FPR6, "fpr6" },
2381 { PT_FPR7, "fpr7" },
2382 { PT_FPR8, "fpr8" },
2383 { PT_FPR9, "fpr9" },
2384 { PT_FPR10, "fpr10" },
2385 { PT_FPR11, "fpr11" },
2386 { PT_FPR12, "fpr12" },
2387 { PT_FPR13, "fpr13" },
2388 { PT_FPR14, "fpr14" },
2389 { PT_FPR15, "fpr15" },
2392 { PT_CR_10, "cr10" },
2393 { PT_CR_11, "cr11" },
2394 { PT_IEEE_IP, "ieee_exception_ip" },
2397 /* XXX No support for these offsets yet. */
2399 /* XXX No support for these offsets yet. */
2400 #elif defined(POWERPC)
2402 #define PT_ORIG_R3 34
2404 #define REGSIZE (sizeof(unsigned long))
2405 { REGSIZE*PT_R0, "r0" },
2406 { REGSIZE*PT_R1, "r1" },
2407 { REGSIZE*PT_R2, "r2" },
2408 { REGSIZE*PT_R3, "r3" },
2409 { REGSIZE*PT_R4, "r4" },
2410 { REGSIZE*PT_R5, "r5" },
2411 { REGSIZE*PT_R6, "r6" },
2412 { REGSIZE*PT_R7, "r7" },
2413 { REGSIZE*PT_R8, "r8" },
2414 { REGSIZE*PT_R9, "r9" },
2415 { REGSIZE*PT_R10, "r10" },
2416 { REGSIZE*PT_R11, "r11" },
2417 { REGSIZE*PT_R12, "r12" },
2418 { REGSIZE*PT_R13, "r13" },
2419 { REGSIZE*PT_R14, "r14" },
2420 { REGSIZE*PT_R15, "r15" },
2421 { REGSIZE*PT_R16, "r16" },
2422 { REGSIZE*PT_R17, "r17" },
2423 { REGSIZE*PT_R18, "r18" },
2424 { REGSIZE*PT_R19, "r19" },
2425 { REGSIZE*PT_R20, "r20" },
2426 { REGSIZE*PT_R21, "r21" },
2427 { REGSIZE*PT_R22, "r22" },
2428 { REGSIZE*PT_R23, "r23" },
2429 { REGSIZE*PT_R24, "r24" },
2430 { REGSIZE*PT_R25, "r25" },
2431 { REGSIZE*PT_R26, "r26" },
2432 { REGSIZE*PT_R27, "r27" },
2433 { REGSIZE*PT_R28, "r28" },
2434 { REGSIZE*PT_R29, "r29" },
2435 { REGSIZE*PT_R30, "r30" },
2436 { REGSIZE*PT_R31, "r31" },
2437 { REGSIZE*PT_NIP, "NIP" },
2438 { REGSIZE*PT_MSR, "MSR" },
2439 { REGSIZE*PT_ORIG_R3, "ORIG_R3" },
2440 { REGSIZE*PT_CTR, "CTR" },
2441 { REGSIZE*PT_LNK, "LNK" },
2442 { REGSIZE*PT_XER, "XER" },
2443 { REGSIZE*PT_CCR, "CCR" },
2444 { REGSIZE*PT_FPR0, "FPR0" },
2515 { PT_F32, "f32" }, { PT_F33, "f33" }, { PT_F34, "f34" },
2516 { PT_F35, "f35" }, { PT_F36, "f36" }, { PT_F37, "f37" },
2517 { PT_F38, "f38" }, { PT_F39, "f39" }, { PT_F40, "f40" },
2518 { PT_F41, "f41" }, { PT_F42, "f42" }, { PT_F43, "f43" },
2519 { PT_F44, "f44" }, { PT_F45, "f45" }, { PT_F46, "f46" },
2520 { PT_F47, "f47" }, { PT_F48, "f48" }, { PT_F49, "f49" },
2521 { PT_F50, "f50" }, { PT_F51, "f51" }, { PT_F52, "f52" },
2522 { PT_F53, "f53" }, { PT_F54, "f54" }, { PT_F55, "f55" },
2523 { PT_F56, "f56" }, { PT_F57, "f57" }, { PT_F58, "f58" },
2524 { PT_F59, "f59" }, { PT_F60, "f60" }, { PT_F61, "f61" },
2525 { PT_F62, "f62" }, { PT_F63, "f63" }, { PT_F64, "f64" },
2526 { PT_F65, "f65" }, { PT_F66, "f66" }, { PT_F67, "f67" },
2527 { PT_F68, "f68" }, { PT_F69, "f69" }, { PT_F70, "f70" },
2528 { PT_F71, "f71" }, { PT_F72, "f72" }, { PT_F73, "f73" },
2529 { PT_F74, "f74" }, { PT_F75, "f75" }, { PT_F76, "f76" },
2530 { PT_F77, "f77" }, { PT_F78, "f78" }, { PT_F79, "f79" },
2531 { PT_F80, "f80" }, { PT_F81, "f81" }, { PT_F82, "f82" },
2532 { PT_F83, "f83" }, { PT_F84, "f84" }, { PT_F85, "f85" },
2533 { PT_F86, "f86" }, { PT_F87, "f87" }, { PT_F88, "f88" },
2534 { PT_F89, "f89" }, { PT_F90, "f90" }, { PT_F91, "f91" },
2535 { PT_F92, "f92" }, { PT_F93, "f93" }, { PT_F94, "f94" },
2536 { PT_F95, "f95" }, { PT_F96, "f96" }, { PT_F97, "f97" },
2537 { PT_F98, "f98" }, { PT_F99, "f99" }, { PT_F100, "f100" },
2538 { PT_F101, "f101" }, { PT_F102, "f102" }, { PT_F103, "f103" },
2539 { PT_F104, "f104" }, { PT_F105, "f105" }, { PT_F106, "f106" },
2540 { PT_F107, "f107" }, { PT_F108, "f108" }, { PT_F109, "f109" },
2541 { PT_F110, "f110" }, { PT_F111, "f111" }, { PT_F112, "f112" },
2542 { PT_F113, "f113" }, { PT_F114, "f114" }, { PT_F115, "f115" },
2543 { PT_F116, "f116" }, { PT_F117, "f117" }, { PT_F118, "f118" },
2544 { PT_F119, "f119" }, { PT_F120, "f120" }, { PT_F121, "f121" },
2545 { PT_F122, "f122" }, { PT_F123, "f123" }, { PT_F124, "f124" },
2546 { PT_F125, "f125" }, { PT_F126, "f126" }, { PT_F127, "f127" },
2548 { PT_F2, "f2" }, { PT_F3, "f3" }, { PT_F4, "f4" },
2549 { PT_F5, "f5" }, { PT_F10, "f10" }, { PT_F11, "f11" },
2550 { PT_F12, "f12" }, { PT_F13, "f13" }, { PT_F14, "f14" },
2551 { PT_F15, "f15" }, { PT_F16, "f16" }, { PT_F17, "f17" },
2552 { PT_F18, "f18" }, { PT_F19, "f19" }, { PT_F20, "f20" },
2553 { PT_F21, "f21" }, { PT_F22, "f22" }, { PT_F23, "f23" },
2554 { PT_F24, "f24" }, { PT_F25, "f25" }, { PT_F26, "f26" },
2555 { PT_F27, "f27" }, { PT_F28, "f28" }, { PT_F29, "f29" },
2556 { PT_F30, "f30" }, { PT_F31, "f31" }, { PT_R4, "r4" },
2557 { PT_R5, "r5" }, { PT_R6, "r6" }, { PT_R7, "r7" },
2558 { PT_B1, "b1" }, { PT_B2, "b2" }, { PT_B3, "b3" },
2559 { PT_B4, "b4" }, { PT_B5, "b5" },
2560 { PT_AR_EC, "ar.ec" }, { PT_AR_LC, "ar.lc" },
2562 { PT_CR_IPSR, "psr" }, { PT_CR_IIP, "ip" },
2563 { PT_CFM, "cfm" }, { PT_AR_UNAT, "ar.unat" },
2564 { PT_AR_PFS, "ar.pfs" }, { PT_AR_RSC, "ar.rsc" },
2565 { PT_AR_RNAT, "ar.rnat" }, { PT_AR_BSPSTORE, "ar.bspstore" },
2566 { PT_PR, "pr" }, { PT_B6, "b6" }, { PT_AR_BSP, "ar.bsp" },
2567 { PT_R1, "r1" }, { PT_R2, "r2" }, { PT_R3, "r3" },
2568 { PT_R12, "r12" }, { PT_R13, "r13" }, { PT_R14, "r14" },
2569 { PT_R15, "r15" }, { PT_R8, "r8" }, { PT_R9, "r9" },
2570 { PT_R10, "r10" }, { PT_R11, "r11" }, { PT_R16, "r16" },
2571 { PT_R17, "r17" }, { PT_R18, "r18" }, { PT_R19, "r19" },
2572 { PT_R20, "r20" }, { PT_R21, "r21" }, { PT_R22, "r22" },
2573 { PT_R23, "r23" }, { PT_R24, "r24" }, { PT_R25, "r25" },
2574 { PT_R26, "r26" }, { PT_R27, "r27" }, { PT_R28, "r28" },
2575 { PT_R29, "r29" }, { PT_R30, "r30" }, { PT_R31, "r31" },
2576 { PT_AR_CCV, "ar.ccv" }, { PT_AR_FPSR, "ar.fpsr" },
2577 { PT_B0, "b0" }, { PT_B7, "b7" }, { PT_F6, "f6" },
2578 { PT_F7, "f7" }, { PT_F8, "f8" }, { PT_F9, "f9" },
2580 { PT_AR_CSD, "ar.csd" },
2583 { PT_AR_SSD, "ar.ssd" },
2585 { PT_DBR, "dbr" }, { PT_IBR, "ibr" }, { PT_PMD, "pmd" },
2599 { 4*ORIG_EAX, "4*ORIG_EAX" },
2603 { 4*UESP, "4*UESP" },
2628 { 8*ORIG_RAX, "8*ORIG_RAX" },
2631 { 8*EFLAGS, "8*EFL" },
2636 { 4*PT_D1, "4*PT_D1" },
2637 { 4*PT_D2, "4*PT_D2" },
2638 { 4*PT_D3, "4*PT_D3" },
2639 { 4*PT_D4, "4*PT_D4" },
2640 { 4*PT_D5, "4*PT_D5" },
2641 { 4*PT_D6, "4*PT_D6" },
2642 { 4*PT_D7, "4*PT_D7" },
2643 { 4*PT_A0, "4*PT_A0" },
2644 { 4*PT_A1, "4*PT_A1" },
2645 { 4*PT_A2, "4*PT_A2" },
2646 { 4*PT_A3, "4*PT_A3" },
2647 { 4*PT_A4, "4*PT_A4" },
2648 { 4*PT_A5, "4*PT_A5" },
2649 { 4*PT_A6, "4*PT_A6" },
2650 { 4*PT_D0, "4*PT_D0" },
2651 { 4*PT_USP, "4*PT_USP" },
2652 { 4*PT_ORIG_D0, "4*PT_ORIG_D0" },
2653 { 4*PT_SR, "4*PT_SR" },
2654 { 4*PT_PC, "4*PT_PC" },
2658 { 4*REG_REG0, "4*REG_REG0" },
2659 { 4*(REG_REG0+1), "4*REG_REG1" },
2660 { 4*(REG_REG0+2), "4*REG_REG2" },
2661 { 4*(REG_REG0+3), "4*REG_REG3" },
2662 { 4*(REG_REG0+4), "4*REG_REG4" },
2663 { 4*(REG_REG0+5), "4*REG_REG5" },
2664 { 4*(REG_REG0+6), "4*REG_REG6" },
2665 { 4*(REG_REG0+7), "4*REG_REG7" },
2666 { 4*(REG_REG0+8), "4*REG_REG8" },
2667 { 4*(REG_REG0+9), "4*REG_REG9" },
2668 { 4*(REG_REG0+10), "4*REG_REG10" },
2669 { 4*(REG_REG0+11), "4*REG_REG11" },
2670 { 4*(REG_REG0+12), "4*REG_REG12" },
2671 { 4*(REG_REG0+13), "4*REG_REG13" },
2672 { 4*(REG_REG0+14), "4*REG_REG14" },
2673 { 4*REG_REG15, "4*REG_REG15" },
2674 { 4*REG_PC, "4*REG_PC" },
2675 { 4*REG_PR, "4*REG_PR" },
2676 { 4*REG_SR, "4*REG_SR" },
2677 { 4*REG_GBR, "4*REG_GBR" },
2678 { 4*REG_MACH, "4*REG_MACH" },
2679 { 4*REG_MACL, "4*REG_MACL" },
2680 { 4*REG_SYSCALL, "4*REG_SYSCALL" },
2681 { 4*REG_FPUL, "4*REG_FPUL" },
2682 { 4*REG_FPREG0, "4*REG_FPREG0" },
2683 { 4*(REG_FPREG0+1), "4*REG_FPREG1" },
2684 { 4*(REG_FPREG0+2), "4*REG_FPREG2" },
2685 { 4*(REG_FPREG0+3), "4*REG_FPREG3" },
2686 { 4*(REG_FPREG0+4), "4*REG_FPREG4" },
2687 { 4*(REG_FPREG0+5), "4*REG_FPREG5" },
2688 { 4*(REG_FPREG0+6), "4*REG_FPREG6" },
2689 { 4*(REG_FPREG0+7), "4*REG_FPREG7" },
2690 { 4*(REG_FPREG0+8), "4*REG_FPREG8" },
2691 { 4*(REG_FPREG0+9), "4*REG_FPREG9" },
2692 { 4*(REG_FPREG0+10), "4*REG_FPREG10" },
2693 { 4*(REG_FPREG0+11), "4*REG_FPREG11" },
2694 { 4*(REG_FPREG0+12), "4*REG_FPREG12" },
2695 { 4*(REG_FPREG0+13), "4*REG_FPREG13" },
2696 { 4*(REG_FPREG0+14), "4*REG_FPREG14" },
2697 { 4*REG_FPREG15, "4*REG_FPREG15" },
2699 { 4*REG_XDREG0, "4*REG_XDREG0" },
2700 { 4*(REG_XDREG0+2), "4*REG_XDREG2" },
2701 { 4*(REG_XDREG0+4), "4*REG_XDREG4" },
2702 { 4*(REG_XDREG0+6), "4*REG_XDREG6" },
2703 { 4*(REG_XDREG0+8), "4*REG_XDREG8" },
2704 { 4*(REG_XDREG0+10), "4*REG_XDREG10" },
2705 { 4*(REG_XDREG0+12), "4*REG_XDREG12" },
2706 { 4*REG_XDREG14, "4*REG_XDREG14" },
2708 { 4*REG_FPSCR, "4*REG_FPSCR" },
2715 { 16, "syscall no.(L)" },
2716 { 20, "syscall_no.(U)" },
2859 /* This entry is in case pt_regs contains dregs (depends on
2860 the kernel build options). */
2861 { uoff(regs), "offsetof(struct user, regs)" },
2862 { uoff(fpu), "offsetof(struct user, fpu)" },
2865 { uoff(regs.ARM_r0), "r0" },
2866 { uoff(regs.ARM_r1), "r1" },
2867 { uoff(regs.ARM_r2), "r2" },
2868 { uoff(regs.ARM_r3), "r3" },
2869 { uoff(regs.ARM_r4), "r4" },
2870 { uoff(regs.ARM_r5), "r5" },
2871 { uoff(regs.ARM_r6), "r6" },
2872 { uoff(regs.ARM_r7), "r7" },
2873 { uoff(regs.ARM_r8), "r8" },
2874 { uoff(regs.ARM_r9), "r9" },
2875 { uoff(regs.ARM_r10), "r10" },
2876 { uoff(regs.ARM_fp), "fp" },
2877 { uoff(regs.ARM_ip), "ip" },
2878 { uoff(regs.ARM_sp), "sp" },
2879 { uoff(regs.ARM_lr), "lr" },
2880 { uoff(regs.ARM_pc), "pc" },
2881 { uoff(regs.ARM_cpsr), "cpsr" },
2884 #if !defined(S390) && !defined(S390X) && !defined(MIPS) && !defined(SPARC64)
2885 { uoff(u_fpvalid), "offsetof(struct user, u_fpvalid)" },
2887 #if defined(I386) || defined(X86_64)
2888 { uoff(i387), "offsetof(struct user, i387)" },
2891 { uoff(m68kfp), "offsetof(struct user, m68kfp)" },
2894 { uoff(u_tsize), "offsetof(struct user, u_tsize)" },
2895 { uoff(u_dsize), "offsetof(struct user, u_dsize)" },
2896 { uoff(u_ssize), "offsetof(struct user, u_ssize)" },
2897 #if !defined(SPARC64)
2898 { uoff(start_code), "offsetof(struct user, start_code)" },
2901 { uoff(start_data), "offsetof(struct user, start_data)" },
2903 #if !defined(SPARC64)
2904 { uoff(start_stack), "offsetof(struct user, start_stack)" },
2906 { uoff(signal), "offsetof(struct user, signal)" },
2907 #if !defined(S390) && !defined(S390X) && !defined(MIPS) && !defined(SH) && !defined(SH64) && !defined(SPARC64)
2908 { uoff(reserved), "offsetof(struct user, reserved)" },
2910 #if !defined(SPARC64)
2911 { uoff(u_ar0), "offsetof(struct user, u_ar0)" },
2913 #if !defined(ARM) && !defined(MIPS) && !defined(S390) && !defined(S390X) && !defined(SPARC64)
2914 { uoff(u_fpstate), "offsetof(struct user, u_fpstate)" },
2916 { uoff(magic), "offsetof(struct user, magic)" },
2917 { uoff(u_comm), "offsetof(struct user, u_comm)" },
2918 #if defined(I386) || defined(X86_64)
2919 { uoff(u_debugreg), "offsetof(struct user, u_debugreg)" },
2923 #endif /* !POWERPC/!SPARC */
2926 { uoff(u_pcb), "offsetof(struct user, u_pcb)" },
2927 { uoff(u_procp), "offsetof(struct user, u_procp)" },
2928 { uoff(u_ar0), "offsetof(struct user, u_ar0)" },
2929 { uoff(u_comm[0]), "offsetof(struct user, u_comm[0])" },
2930 { uoff(u_arg[0]), "offsetof(struct user, u_arg[0])" },
2931 { uoff(u_ap), "offsetof(struct user, u_ap)" },
2932 { uoff(u_qsave), "offsetof(struct user, u_qsave)" },
2933 { uoff(u_rval1), "offsetof(struct user, u_rval1)" },
2934 { uoff(u_rval2), "offsetof(struct user, u_rval2)" },
2935 { uoff(u_error), "offsetof(struct user, u_error)" },
2936 { uoff(u_eosys), "offsetof(struct user, u_eosys)" },
2937 { uoff(u_ssave), "offsetof(struct user, u_ssave)" },
2938 { uoff(u_signal[0]), "offsetof(struct user, u_signal)" },
2939 { uoff(u_sigmask[0]), "offsetof(struct user, u_sigmask)" },
2940 { uoff(u_sigonstack), "offsetof(struct user, u_sigonstack)" },
2941 { uoff(u_sigintr), "offsetof(struct user, u_sigintr)" },
2942 { uoff(u_sigreset), "offsetof(struct user, u_sigreset)" },
2943 { uoff(u_oldmask), "offsetof(struct user, u_oldmask)" },
2944 { uoff(u_code), "offsetof(struct user, u_code)" },
2945 { uoff(u_addr), "offsetof(struct user, u_addr)" },
2946 { uoff(u_sigstack), "offsetof(struct user, u_sigstack)" },
2947 { uoff(u_ofile), "offsetof(struct user, u_ofile)" },
2948 { uoff(u_pofile), "offsetof(struct user, u_pofile)" },
2949 { uoff(u_ofile_arr[0]), "offsetof(struct user, u_ofile_arr[0])" },
2950 { uoff(u_pofile_arr[0]),"offsetof(struct user, u_pofile_arr[0])"},
2951 { uoff(u_lastfile), "offsetof(struct user, u_lastfile)" },
2952 { uoff(u_cwd), "offsetof(struct user, u_cwd)" },
2953 { uoff(u_cdir), "offsetof(struct user, u_cdir)" },
2954 { uoff(u_rdir), "offsetof(struct user, u_rdir)" },
2955 { uoff(u_cmask), "offsetof(struct user, u_cmask)" },
2956 { uoff(u_ru), "offsetof(struct user, u_ru)" },
2957 { uoff(u_cru), "offsetof(struct user, u_cru)" },
2958 { uoff(u_timer[0]), "offsetof(struct user, u_timer[0])" },
2959 { uoff(u_XXX[0]), "offsetof(struct user, u_XXX[0])" },
2960 { uoff(u_ioch), "offsetof(struct user, u_ioch)" },
2961 { uoff(u_start), "offsetof(struct user, u_start)" },
2962 { uoff(u_acflag), "offsetof(struct user, u_acflag)" },
2963 { uoff(u_prof.pr_base), "offsetof(struct user, u_prof.pr_base)" },
2964 { uoff(u_prof.pr_size), "offsetof(struct user, u_prof.pr_size)" },
2965 { uoff(u_prof.pr_off), "offsetof(struct user, u_prof.pr_off)" },
2966 { uoff(u_prof.pr_scale),"offsetof(struct user, u_prof.pr_scale)"},
2967 { uoff(u_rlimit[0]), "offsetof(struct user, u_rlimit)" },
2968 { uoff(u_exdata.Ux_A), "offsetof(struct user, u_exdata.Ux_A)" },
2969 { uoff(u_exdata.ux_shell[0]),"offsetof(struct user, u_exdata.ux_shell[0])"},
2970 { uoff(u_lofault), "offsetof(struct user, u_lofault)" },
2973 { sizeof(struct user), "sizeof(struct user)" },
2983 const struct xlat *x;
2986 if (entering(tcp)) {
2987 printxval(ptrace_cmds, tcp->u_arg[0],
2994 tprintf(", %lu, ", tcp->u_arg[1]);
2995 addr = tcp->u_arg[2];
2997 if (tcp->u_arg[0] == PTRACE_PEEKUSER
2998 || tcp->u_arg[0] == PTRACE_POKEUSER) {
2999 for (x = struct_user_offsets; x->str; x++) {
3004 tprintf("%#lx, ", addr);
3005 else if (x->val > addr && x != struct_user_offsets) {
3007 tprintf("%s + %ld, ", x->str, addr - x->val);
3010 tprintf("%s, ", x->str);
3014 tprintf("%#lx, ", tcp->u_arg[2]);
3016 switch (tcp->u_arg[0]) {
3017 case PTRACE_PEEKDATA:
3018 case PTRACE_PEEKTEXT:
3019 case PTRACE_PEEKUSER:
3022 case PTRACE_SINGLESTEP:
3023 case PTRACE_SYSCALL:
3025 printsignal(tcp->u_arg[3]);
3028 tprintf("%#lx", tcp->u_arg[3]);
3032 switch (tcp->u_arg[0]) {
3033 case PTRACE_PEEKDATA:
3034 case PTRACE_PEEKTEXT:
3035 case PTRACE_PEEKUSER:
3036 printnum(tcp, tcp->u_arg[3], "%#lx");
3042 if (tcp->u_arg[0] == PTRACE_WRITEDATA ||
3043 tcp->u_arg[0] == PTRACE_WRITETEXT) {
3044 tprintf("%lu, ", tcp->u_arg[3]);
3045 printstr(tcp, tcp->u_arg[4], tcp->u_arg[3]);
3046 } else if (tcp->u_arg[0] != PTRACE_READDATA &&
3047 tcp->u_arg[0] != PTRACE_READTEXT) {
3048 tprintf("%#lx", tcp->u_arg[3]);
3051 if (tcp->u_arg[0] == PTRACE_READDATA ||
3052 tcp->u_arg[0] == PTRACE_READTEXT) {
3053 tprintf("%lu, ", tcp->u_arg[3]);
3054 printstr(tcp, tcp->u_arg[4], tcp->u_arg[3]);
3059 tprintf("%lu", tcp->u_arg[3]);
3061 #endif /* FREEBSD */
3068 static const struct xlat futexops[] = {
3069 { FUTEX_WAIT, "FUTEX_WAIT" },
3070 { FUTEX_WAKE, "FUTEX_WAKE" },
3071 { FUTEX_FD, "FUTEX_FD" },
3072 { FUTEX_REQUEUE,"FUTEX_REQUEUE" },
3080 if (entering(tcp)) {
3081 tprintf("%p, ", (void *) tcp->u_arg[0]);
3082 printxval(futexops, tcp->u_arg[1], "FUTEX_???");
3083 tprintf(", %ld", tcp->u_arg[2]);
3084 if (tcp->u_arg[1] == FUTEX_WAIT) {
3086 printtv(tcp, tcp->u_arg[3]);
3087 } else if (tcp->u_arg[1] == FUTEX_REQUEUE)
3088 tprintf(", %ld, %p", tcp->u_arg[3], (void *) tcp->u_arg[4]);
3094 print_affinitylist(tcp, list, len)
3101 while (len >= sizeof (unsigned long)) {
3103 umove(tcp, list, &w);
3104 tprintf("%s %lx", first ? "" : ",", w);
3106 len -= sizeof (unsigned long);
3107 list += sizeof(unsigned long);
3113 sys_sched_setaffinity(tcp)
3116 if (entering(tcp)) {
3117 tprintf("%ld, %lu, ", tcp->u_arg[0], tcp->u_arg[1]);
3118 print_affinitylist(tcp, tcp->u_arg[2], tcp->u_arg[1]);
3124 sys_sched_getaffinity(tcp)
3127 if (entering(tcp)) {
3128 tprintf("%ld, %lu, ", tcp->u_arg[0], tcp->u_arg[1]);
3130 if (tcp->u_rval == -1)
3131 tprintf("%#lx", tcp->u_arg[2]);
3133 print_affinitylist(tcp, tcp->u_arg[2], tcp->u_rval);
3138 static const struct xlat schedulers[] = {
3139 { SCHED_OTHER, "SCHED_OTHER" },
3140 { SCHED_RR, "SCHED_RR" },
3141 { SCHED_FIFO, "SCHED_FIFO" },
3146 sys_sched_getscheduler(tcp)
3149 if (entering(tcp)) {
3150 tprintf("%d", (int) tcp->u_arg[0]);
3151 } else if (! syserror(tcp)) {
3152 tcp->auxstr = xlookup (schedulers, tcp->u_rval);
3153 if (tcp->auxstr != NULL)
3160 sys_sched_setscheduler(tcp)
3163 if (entering(tcp)) {
3164 struct sched_param p;
3165 tprintf("%d, ", (int) tcp->u_arg[0]);
3166 printxval(schedulers, tcp->u_arg[1], "SCHED_???");
3167 if (umove(tcp, tcp->u_arg[2], &p) < 0)
3168 tprintf(", %#lx", tcp->u_arg[2]);
3170 tprintf(", { %d }", p.__sched_priority);
3176 sys_sched_getparam(tcp)
3179 if (entering(tcp)) {
3180 tprintf("%d, ", (int) tcp->u_arg[0]);
3182 struct sched_param p;
3183 if (umove(tcp, tcp->u_arg[1], &p) < 0)
3184 tprintf("%#lx", tcp->u_arg[1]);
3186 tprintf("{ %d }", p.__sched_priority);
3192 sys_sched_setparam(tcp)
3195 if (entering(tcp)) {
3196 struct sched_param p;
3197 if (umove(tcp, tcp->u_arg[1], &p) < 0)
3198 tprintf("%d, %#lx", (int) tcp->u_arg[0], tcp->u_arg[1]);
3200 tprintf("%d, { %d }", (int) tcp->u_arg[0], p.__sched_priority);
3206 sys_sched_get_priority_min(tcp)
3209 if (entering(tcp)) {
3210 printxval(schedulers, tcp->u_arg[0], "SCHED_???");
3216 #include <asm/prctl.h>
3218 static const struct xlat archvals[] = {
3219 { ARCH_SET_GS, "ARCH_SET_GS" },
3220 { ARCH_SET_FS, "ARCH_SET_FS" },
3221 { ARCH_GET_FS, "ARCH_GET_FS" },
3222 { ARCH_GET_GS, "ARCH_GET_GS" },
3230 if (entering(tcp)) {
3231 printxval(archvals, tcp->u_arg[0], "ARCH_???");
3232 if (tcp->u_arg[0] == ARCH_SET_GS
3233 || tcp->u_arg[0] == ARCH_SET_FS)
3234 tprintf(", %#lx", tcp->u_arg[1]);
3236 if (tcp->u_arg[0] == ARCH_GET_GS
3237 || tcp->u_arg[0] == ARCH_GET_FS) {
3239 if (!syserror(tcp) && umove(tcp, tcp->u_arg[1], &v) != -1)
3240 tprintf(", [%#lx]", v);
3242 tprintf(", %#lx", tcp->u_arg[1]);