2 * Copyright (c) 1991, 1992 Paul Kranenburg <pk@cs.few.eur.nl>
3 * Copyright (c) 1993 Branko Lankester <branko@hacktic.nl>
4 * Copyright (c) 1993, 1994, 1995, 1996 Rick Sladkey <jrs@world.std.com>
5 * Copyright (c) 1996-1999 Wichert Akkerman <wichert@cistron.nl>
6 * Copyright (c) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation
7 * Linux for s390 port by D.J. Barrow
8 * <barrow_dj@mail.yahoo.com,djbarrow@de.ibm.com>
9 * Copyright (c) 2000 PocketPenguins Inc. Linux for Hitachi SuperH
10 * port by Greg Banks <gbanks@pocketpenguins.com>
13 * All rights reserved.
15 * Redistribution and use in source and binary forms, with or without
16 * modification, are permitted provided that the following conditions
18 * 1. Redistributions of source code must retain the above copyright
19 * notice, this list of conditions and the following disclaimer.
20 * 2. Redistributions in binary form must reproduce the above copyright
21 * notice, this list of conditions and the following disclaimer in the
22 * documentation and/or other materials provided with the distribution.
23 * 3. The name of the author may not be used to endorse or promote products
24 * derived from this software without specific prior written permission.
26 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
27 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
28 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
29 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
30 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
31 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
32 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
33 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
35 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
46 #include <sys/resource.h>
47 #include <sys/utsname.h>
49 #include <sys/syscall.h>
52 #include <machine/reg.h>
56 #include <sys/ptrace.h>
61 # define fpq kernel_fpq
63 # define fpu kernel_fpu
71 #endif /* HAVE_ASM_REG_H */
75 #ifndef PTRACE_PEEKUSR
76 # define PTRACE_PEEKUSR PTRACE_PEEKUSER
78 #ifndef PTRACE_POKEUSR
79 # define PTRACE_POKEUSR PTRACE_POKEUSER
83 #ifdef HAVE_LINUX_PTRACE_H
85 #include <linux/ptrace.h>
88 #ifdef HAVE_LINUX_FUTEX_H
89 #include <linux/futex.h>
104 #include <asm/posix_types.h>
106 #define GETGROUPS_T __kernel_gid_t
109 #if defined(LINUX) && defined(IA64)
110 # include <asm/ptrace_offsets.h>
111 # include <asm/rse.h>
115 #include <sys/prctl.h>
119 #define WCOREDUMP(status) ((status) & 0200)
122 /* WTA: this was `&& !defined(LINUXSPARC)', this seems unneeded though? */
123 #if defined(HAVE_PRCTL)
124 static struct xlat prctl_options[] = {
126 { PR_MAXPROCS, "PR_MAXPROCS" },
129 { PR_ISBLOCKED, "PR_ISBLOCKED" },
131 #ifdef PR_SETSTACKSIZE
132 { PR_SETSTACKSIZE, "PR_SETSTACKSIZE" },
134 #ifdef PR_GETSTACKSIZE
135 { PR_GETSTACKSIZE, "PR_GETSTACKSIZE" },
138 { PR_MAXPPROCS, "PR_MAXPPROCS" },
140 #ifdef PR_UNBLKONEXEC
141 { PR_UNBLKONEXEC, "PR_UNBLKONEXEC" },
144 { PR_ATOMICSIM, "PR_ATOMICSIM" },
147 { PR_SETEXITSIG, "PR_SETEXITSIG" },
150 { PR_RESIDENT, "PR_RESIDENT" },
153 { PR_ATTACHADDR, "PR_ATTACHADDR" },
156 { PR_DETACHADDR, "PR_DETACHADDR" },
159 { PR_TERMCHILD, "PR_TERMCHILD" },
162 { PR_GETSHMASK, "PR_GETSHMASK" },
165 { PR_GETNSHARE, "PR_GETNSHARE" },
167 #if defined(PR_SET_PDEATHSIG)
168 { PR_SET_PDEATHSIG, "PR_SET_PDEATHSIG" },
171 { PR_COREPID, "PR_COREPID" },
173 #ifdef PR_ATTACHADDRPERM
174 { PR_ATTACHADDRPERM, "PR_ATTACHADDRPERM" },
176 #ifdef PR_PTHREADEXIT
177 { PR_PTHREADEXIT, "PR_PTHREADEXIT" },
179 #ifdef PR_SET_PDEATHSIG
180 { PR_SET_PDEATHSIG, "PR_SET_PDEATHSIG" },
182 #ifdef PR_GET_PDEATHSIG
183 { PR_GET_PDEATHSIG, "PR_GET_PDEATHSIG" },
185 #ifdef PR_GET_UNALIGN
186 { PR_GET_UNALIGN, "PR_GET_UNALIGN" },
188 #ifdef PR_SET_UNALIGN
189 { PR_SET_UNALIGN, "PR_SET_UNALIGN" },
191 #ifdef PR_GET_KEEPCAPS
192 { PR_GET_KEEPCAPS, "PR_GET_KEEP_CAPS" },
194 #ifdef PR_SET_KEEPCAPS
195 { PR_SET_KEEPCAPS, "PR_SET_KEEP_CAPS" },
202 unalignctl_string (unsigned int ctl)
207 #ifdef PR_UNALIGN_NOPRINT
208 case PR_UNALIGN_NOPRINT:
211 #ifdef PR_UNALIGN_SIGBUS
212 case PR_UNALIGN_SIGBUS:
218 sprintf(buf, "%x", ctl);
230 printxval(prctl_options, tcp->u_arg[0], "PR_???");
231 switch (tcp->u_arg[0]) {
236 #ifdef PR_SET_DEATHSIG
237 case PR_GET_PDEATHSIG:
240 #ifdef PR_SET_UNALIGN
242 tprintf(", %s", unalignctl_string(tcp->u_arg[1]));
245 #ifdef PR_GET_UNALIGN
247 tprintf(", %#lx", tcp->u_arg[1]);
251 for (i = 1; i < tcp->u_nargs; i++)
252 tprintf(", %#lx", tcp->u_arg[i]);
256 switch (tcp->u_arg[0]) {
257 #ifdef PR_GET_PDEATHSIG
258 case PR_GET_PDEATHSIG:
259 for (i=1; i<tcp->u_nargs; i++)
260 tprintf(", %#lx", tcp->u_arg[i]);
263 #ifdef PR_SET_UNALIGN
267 #ifdef PR_GET_UNALIGN
272 umove(tcp, tcp->u_arg[1], &ctl);
273 tcp->auxstr = unalignctl_string(ctl);
284 #endif /* HAVE_PRCTL */
300 printpathn(tcp, tcp->u_arg[0], tcp->u_arg[1]);
301 tprintf(", %lu", tcp->u_arg[1]);
312 tprintf("%#lx", tcp->u_arg[0]);
314 printpath(tcp, tcp->u_arg[0]);
315 tprintf(", %lu", tcp->u_arg[1]);
321 sys_setdomainname(tcp)
325 printpathn(tcp, tcp->u_arg[0], tcp->u_arg[1]);
326 tprintf(", %lu", tcp->u_arg[1]);
334 sys_getdomainname(tcp)
339 tprintf("%#lx", tcp->u_arg[0]);
341 printpath(tcp, tcp->u_arg[0]);
342 tprintf(", %lu", tcp->u_arg[1]);
353 fprintf(stderr, "_exit returned!\n");
356 /* special case: we stop tracing this process, finish line now */
357 tprintf("%ld) ", tcp->u_arg[0]);
369 tcp->flags |= TCB_EXITING;
370 #ifdef __NR_exit_group
371 if (tcp->scno == __NR_exit_group)
372 tcp->flags |= TCB_GROUP_EXITING;
378 /* TCP is creating a child we want to follow.
379 If there will be space in tcbtab for it, set TCB_FOLLOWFORK and return 0.
380 If not, clear TCB_FOLLOWFORK, print an error, and return 1. */
382 fork_tcb(struct tcb *tcp)
384 if (nprocs == tcbtabsize) {
385 /* Allocate some more TCBs and expand the table.
386 We don't want to relocate the TCBs because our
387 callers have pointers and it would be a pain.
388 So tcbtab is a table of pointers. Since we never
389 free the TCBs, we allocate a single chunk of many. */
390 struct tcb **newtab = (struct tcb **)
391 realloc(tcbtab, 2 * tcbtabsize * sizeof tcbtab[0]);
392 struct tcb *newtcbs = (struct tcb *) calloc(tcbtabsize,
395 if (newtab == NULL || newtcbs == NULL) {
398 tcp->flags &= ~TCB_FOLLOWFORK;
399 fprintf(stderr, "sys_fork: tcb table full\n");
402 for (i = tcbtabsize; i < 2 * tcbtabsize; ++i)
403 newtab[i] = &newtcbs[i - tcbtabsize];
408 tcp->flags |= TCB_FOLLOWFORK;
420 tcp->auxstr = "child process";
421 return RVAL_UDECIMAL | RVAL_STR;
434 tprintf ("%ld", tcp->u_arg[0]);
438 tcp->auxstr = "child process";
439 return RVAL_UDECIMAL | RVAL_STR;
451 struct tcb *tcpchild;
455 if (tcp->scno == SYS_rfork && !(tcp->u_arg[0]&RFPROC))
466 if ((tcpchild = alloctcb(tcp->u_rval)) == NULL) {
467 fprintf(stderr, "sys_fork: tcb table full\n");
470 if (proc_open(tcpchild, 2) < 0)
476 #else /* !USE_PROCFS */
480 /* defines copied from linux/sched.h since we can't include that
481 * ourselves (it conflicts with *lots* of libc includes)
483 #define CSIGNAL 0x000000ff /* signal mask to be sent at exit */
484 #define CLONE_VM 0x00000100 /* set if VM shared between processes */
485 #define CLONE_FS 0x00000200 /* set if fs info shared between processes */
486 #define CLONE_FILES 0x00000400 /* set if open files shared between processes */
487 #define CLONE_SIGHAND 0x00000800 /* set if signal handlers shared */
488 #define CLONE_IDLETASK 0x00001000 /* kernel-only flag */
489 #define CLONE_PTRACE 0x00002000 /* set if we want to let tracing continue on the child too */
490 #define CLONE_VFORK 0x00004000 /* set if the parent wants the child to wake it up on mm_release */
491 #define CLONE_PARENT 0x00008000 /* set if we want to have the same parent as the cloner */
492 #define CLONE_THREAD 0x00010000 /* Same thread group? */
493 #define CLONE_NEWNS 0x00020000 /* New namespace group? */
494 #define CLONE_SYSVSEM 0x00040000 /* share system V SEM_UNDO semantics */
495 #define CLONE_SETTLS 0x00080000 /* create a new TLS for the child */
496 #define CLONE_PARENT_SETTID 0x00100000 /* set the TID in the parent */
497 #define CLONE_CHILD_CLEARTID 0x00200000 /* clear the TID in the child */
498 #define CLONE_DETACHED 0x00400000 /* parent wants no child-exit signal */
499 #define CLONE_UNTRACED 0x00800000 /* set if the tracing process can't force CLONE_PTRACE on this clone */
500 #define CLONE_CHILD_SETTID 0x01000000 /* set the TID in the child */
502 static struct xlat clone_flags[] = {
503 { CLONE_VM, "CLONE_VM" },
504 { CLONE_FS, "CLONE_FS" },
505 { CLONE_FILES, "CLONE_FILES" },
506 { CLONE_SIGHAND, "CLONE_SIGHAND" },
507 { CLONE_IDLETASK, "CLONE_IDLETASK"},
508 { CLONE_PTRACE, "CLONE_PTRACE" },
509 { CLONE_VFORK, "CLONE_VFORK" },
510 { CLONE_PARENT, "CLONE_PARENT" },
511 { CLONE_THREAD, "CLONE_THREAD" },
512 { CLONE_NEWNS, "CLONE_NEWNS" },
513 { CLONE_SYSVSEM, "CLONE_SYSVSEM" },
514 { CLONE_SETTLS, "CLONE_SETTLS" },
515 { CLONE_PARENT_SETTID,"CLONE_PARENT_SETTID" },
516 { CLONE_CHILD_CLEARTID,"CLONE_CHILD_CLEARTID" },
517 { CLONE_DETACHED, "CLONE_DETACHED" },
518 { CLONE_UNTRACED, "CLONE_UNTRACED" },
519 { CLONE_CHILD_SETTID,"CLONE_CHILD_SETTID" },
524 # include <asm/ldt.h>
525 extern void print_ldt_entry();
531 # define ARG_STACKSIZE (tcp->scno == SYS_clone2 ? 2 : -1)
532 # define ARG_PTID (tcp->scno == SYS_clone2 ? 3 : 2)
533 # define ARG_CTID (tcp->scno == SYS_clone2 ? 4 : 3)
534 # define ARG_TLS (tcp->scno == SYS_clone2 ? 5 : 4)
535 # elif defined S390 || defined S390X
541 # elif defined X86_64
560 unsigned long flags = tcp->u_arg[ARG_FLAGS];
561 tprintf("child_stack=%#lx, ", tcp->u_arg[ARG_STACK]);
562 # ifdef ARG_STACKSIZE
563 if (ARG_STACKSIZE != -1)
564 tprintf("stack_size=%#lx, ",
565 tcp->u_arg[ARG_STACKSIZE]);
568 if (printflags(clone_flags, flags &~ CSIGNAL) == 0)
570 if ((flags & CSIGNAL) != 0)
571 tprintf("|%s", signame(flags & CSIGNAL));
572 if ((flags & (CLONE_PARENT_SETTID|CLONE_CHILD_SETTID
573 |CLONE_CHILD_CLEARTID|CLONE_SETTLS)) == 0)
575 if (flags & CLONE_PARENT_SETTID)
576 tprintf(", parent_tidptr=%#lx", tcp->u_arg[ARG_PTID]);
577 if (flags & CLONE_SETTLS) {
579 struct modify_ldt_ldt_s copy;
580 if (umove(tcp, tcp->u_arg[ARG_TLS], ©) != -1) {
581 tprintf(", {entry_number:%d, ",
586 print_ldt_entry(©);
590 tprintf(", tls=%#lx", tcp->u_arg[ARG_TLS]);
592 if (flags & (CLONE_CHILD_SETTID|CLONE_CHILD_CLEARTID))
593 tprintf(", child_tidptr=%#lx", tcp->u_arg[ARG_CTID]);
604 return RVAL_UDECIMAL;
609 change_syscall(tcp, new)
615 /* Attempt to make vfork into fork, which we can follow. */
616 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(ORIG_EAX * 4), new) < 0)
619 #elif defined(X86_64)
620 /* Attempt to make vfork into fork, which we can follow. */
621 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(ORIG_RAX * 8), new) < 0)
624 #elif defined(POWERPC)
625 if (ptrace(PTRACE_POKEUSER, tcp->pid,
626 (char*)(sizeof(unsigned long)*PT_R0), new) < 0)
629 #elif defined(S390) || defined(S390X)
630 /* s390 linux after 2.4.7 has a hook in entry.S to allow this */
631 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_GPR2), new)<0)
635 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*PT_ORIG_D0), new)<0)
640 if (ptrace(PTRACE_GETREGS, tcp->pid, (char*)®s, 0)<0)
643 if (ptrace(PTRACE_SETREGS, tcp->pid, (char*)®s, 0)<0)
647 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_V0), new)<0)
651 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_A3), new)<0)
655 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_R15), new)<0)
659 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_GR20), new)<0)
663 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*(REG_REG0+3)), new)<0)
667 #warning Do not know how to handle change_syscall for this architecture
668 #endif /* architecture */
680 unsigned long *bsp, *ap;
682 if (upeek(tcp->pid, PT_AR_BSP, (long *) &bsp) , 0)
685 ap = ia64_rse_skip_regs(bsp, argnum);
687 ptrace(PTRACE_POKEDATA, tcp->pid, (char *) ap, tcp->u_arg[argnum]);
694 ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*argnum), tcp->u_arg[argnum]);
698 #elif defined(X86_64)
700 ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(8*(long)argnum), tcp->u_arg[argnum]);
704 #elif defined(POWERPC)
706 #define PT_ORIG_R3 34
709 ptrace(PTRACE_POKEUSER, tcp->pid,
710 (char*)((argnum==0 ? PT_ORIG_R3 : argnum+PT_R3)*sizeof(unsigned long)),
719 ptrace(PTRACE_POKEUSER, tcp->pid,
720 (char*)(REG_A0 + argnum), tcp->u_arg[argnum]);
724 if (upeek(tcp->pid, REG_SP, (long *) &sp) , 0)
727 ptrace(PTRACE_POKEDATA, tcp->pid,
728 (char*)(sp + argnum - 4), tcp->u_arg[argnum]);
733 #elif defined(S390) || defined(S390X)
736 ptrace(PTRACE_POKEUSER, tcp->pid,
737 (char *) (argnum==0 ? PT_ORIGGPR2 :
738 PT_GPR2 + argnum*sizeof(long)),
746 # warning Sorry, setargs not implemented for this architecture.
751 #if defined SYS_clone || defined SYS_clone2
756 struct tcb *tcpchild;
766 int bpt = tcp->flags & TCB_BPTSET;
768 if (!(tcp->flags & TCB_FOLLOWFORK))
779 #ifdef CLONE_PTRACE /* See new setbpt code. */
780 tcpchild = pid2tcb(pid);
781 if (tcpchild != NULL) {
782 /* The child already reported its startup trap
783 before the parent reported its syscall return. */
785 & (TCB_STARTUP|TCB_ATTACHED|TCB_SUSPENDED))
786 != (TCB_STARTUP|TCB_ATTACHED|TCB_SUSPENDED))
788 [preattached child %d of %d in weird state!]\n",
793 if ((tcpchild = alloctcb(pid)) == NULL) {
796 fprintf(stderr, " [tcb table full]\n");
797 kill(pid, SIGKILL); /* XXX */
802 /* Attach to the new child */
803 if (ptrace(PTRACE_ATTACH, pid, (char *) 1, 0) < 0) {
806 perror("PTRACE_ATTACH");
807 fprintf(stderr, "Too late?\n");
816 tcpchild->flags |= TCB_ATTACHED;
817 /* Child has BPT too, must be removed on first occasion. */
819 tcpchild->flags |= TCB_BPTSET;
820 tcpchild->baddr = tcp->baddr;
821 memcpy(tcpchild->inst, tcp->inst,
822 sizeof tcpchild->inst);
824 tcpchild->parent = tcp;
826 if (tcpchild->flags & TCB_SUSPENDED) {
827 /* The child was born suspended, due to our having
828 forced CLONE_PTRACE. */
832 tcpchild->flags &= ~(TCB_SUSPENDED|TCB_STARTUP);
833 if (ptrace(PTRACE_SYSCALL, pid, (char *) 1, 0) < 0) {
834 perror("resume: ptrace(PTRACE_SYSCALL, ...)");
840 Process %u resumed (parent %d ready)\n",
846 fprintf(stderr, "Process %d attached\n", pid);
849 #ifdef TCB_CLONE_THREAD
852 * Save the flags used in this call,
853 * in case we point TCP to our parent below.
855 int call_flags = tcp->u_arg[ARG_FLAGS];
856 if ((tcp->flags & TCB_CLONE_THREAD) &&
857 tcp->parent != NULL) {
858 /* The parent in this clone is itself a
859 thread belonging to another process.
860 There is no meaning to the parentage
861 relationship of the new child with the
862 thread, only with the process. We
863 associate the new thread with our
864 parent. Since this is done for every
865 new thread, there will never be a
866 TCB_CLONE_THREAD process that has
870 tcpchild->parent = tcp;
873 if (call_flags & CLONE_THREAD) {
874 tcpchild->flags |= TCB_CLONE_THREAD;
875 ++tcp->nclone_threads;
877 if (call_flags & CLONE_DETACHED) {
878 tcpchild->flags |= TCB_CLONE_DETACHED;
879 ++tcp->nclone_detached;
894 /* We do special magic with clone for any clone or fork. */
895 return internal_clone(tcp);
898 struct tcb *tcpchild;
903 if (tcp->scno == SYS_vfork) {
904 /* Attempt to make vfork into fork, which we can follow. */
906 change_syscall(tcp, SYS_fork) < 0)
911 if (!followfork || dont_follow)
919 int bpt = tcp->flags & TCB_BPTSET;
921 if (!(tcp->flags & TCB_FOLLOWFORK))
930 if ((tcpchild = alloctcb(pid)) == NULL) {
931 fprintf(stderr, " [tcb table full]\n");
932 kill(pid, SIGKILL); /* XXX */
937 /* The child must have run before it can be attached. */
938 /* This must be a bug in the parisc kernel, but I havn't
939 * identified it yet. Seems to be an issue associated
940 * with attaching to a process (which sends it a signal)
941 * before that process has ever been scheduled. When
942 * debugging, I started seeing crashes in
943 * arch/parisc/kernel/signal.c:do_signal(), apparently
944 * caused by r8 getting corrupt over the dequeue_signal()
945 * call. Didn't make much sense though...
951 select(0, NULL, NULL, NULL, &tv);
954 if (ptrace(PTRACE_ATTACH, pid, (char *) 1, 0) < 0) {
955 perror("PTRACE_ATTACH");
956 fprintf(stderr, "Too late?\n");
963 /* The child must have run before it can be attached. */
968 select(0, NULL, NULL, NULL, &tv);
970 if (ptrace(PTRACE_ATTACH, pid, (char *)1, 0) < 0) {
971 perror("PTRACE_ATTACH");
972 fprintf(stderr, "Too late?\n");
977 /* Try to catch the new process as soon as possible. */
980 for (i = 0; i < 1024; i++)
981 if (ptrace(PTRACE_ATTACH, pid, (char *) 1, 0) >= 0)
984 perror("PTRACE_ATTACH");
985 fprintf(stderr, "Too late?\n");
992 tcpchild->flags |= TCB_ATTACHED;
993 /* Child has BPT too, must be removed on first occasion */
995 tcpchild->flags |= TCB_BPTSET;
996 tcpchild->baddr = tcp->baddr;
997 memcpy(tcpchild->inst, tcp->inst,
998 sizeof tcpchild->inst);
1001 tcpchild->parent = tcp;
1004 fprintf(stderr, "Process %d attached\n", pid);
1010 #endif /* !USE_PROCFS */
1012 #if defined(SUNOS4) || defined(LINUX) || defined(FREEBSD)
1019 return RVAL_UDECIMAL;
1023 #endif /* SUNOS4 || LINUX || FREEBSD */
1027 static char idstr[16];
1034 sprintf(idstr, "ppid %lu", getrval2(tcp));
1035 tcp->auxstr = idstr;
1046 sprintf(idstr, "euid %lu", getrval2(tcp));
1047 tcp->auxstr = idstr;
1058 sprintf(idstr, "egid %lu", getrval2(tcp));
1059 tcp->auxstr = idstr;
1073 if (entering(tcp)) {
1074 tprintf("%u", (uid_t) tcp->u_arg[0]);
1083 if (entering(tcp)) {
1084 tprintf("%u", (gid_t) tcp->u_arg[0]);
1096 tprintf("%#lx, %#lx, %#lx", tcp->u_arg[0],
1097 tcp->u_arg[1], tcp->u_arg[2]);
1099 if (umove(tcp, tcp->u_arg[0], &uid) < 0)
1100 tprintf("%#lx, ", tcp->u_arg[0]);
1102 tprintf("ruid %lu, ", (unsigned long) uid);
1103 if (umove(tcp, tcp->u_arg[1], &uid) < 0)
1104 tprintf("%#lx, ", tcp->u_arg[1]);
1106 tprintf("euid %lu, ", (unsigned long) uid);
1107 if (umove(tcp, tcp->u_arg[2], &uid) < 0)
1108 tprintf("%#lx", tcp->u_arg[2]);
1110 tprintf("suid %lu", (unsigned long) uid);
1123 tprintf("%#lx, %#lx, %#lx", tcp->u_arg[0],
1124 tcp->u_arg[1], tcp->u_arg[2]);
1126 if (umove(tcp, tcp->u_arg[0], &gid) < 0)
1127 tprintf("%#lx, ", tcp->u_arg[0]);
1129 tprintf("rgid %lu, ", (unsigned long) gid);
1130 if (umove(tcp, tcp->u_arg[1], &gid) < 0)
1131 tprintf("%#lx, ", tcp->u_arg[1]);
1133 tprintf("egid %lu, ", (unsigned long) gid);
1134 if (umove(tcp, tcp->u_arg[2], &gid) < 0)
1135 tprintf("%#lx", tcp->u_arg[2]);
1137 tprintf("sgid %lu", (unsigned long) gid);
1149 if (entering(tcp)) {
1151 (unsigned long) (uid_t) tcp->u_arg[0],
1152 (unsigned long) (uid_t) tcp->u_arg[1]);
1161 if (entering(tcp)) {
1163 (unsigned long) (gid_t) tcp->u_arg[0],
1164 (unsigned long) (gid_t) tcp->u_arg[1]);
1169 #if defined(LINUX) || defined(FREEBSD)
1174 if (entering(tcp)) {
1175 tprintf("ruid %u, euid %u, suid %u",
1176 (uid_t) tcp->u_arg[0],
1177 (uid_t) tcp->u_arg[1],
1178 (uid_t) tcp->u_arg[2]);
1186 if (entering(tcp)) {
1187 tprintf("rgid %u, egid %u, sgid %u",
1188 (uid_t) tcp->u_arg[0],
1189 (uid_t) tcp->u_arg[1],
1190 (uid_t) tcp->u_arg[2]);
1195 #endif /* LINUX || FREEBSD */
1202 GETGROUPS_T *gidset;
1204 if (entering(tcp)) {
1205 len = tcp->u_arg[0];
1206 tprintf("%u, ", len);
1211 gidset = (GETGROUPS_T *) malloc(len * sizeof(GETGROUPS_T));
1212 if (gidset == NULL) {
1213 fprintf(stderr, "sys_setgroups: out of memory\n");
1217 tprintf("%#lx", tcp->u_arg[1]);
1218 else if (umoven(tcp, tcp->u_arg[1],
1219 len * sizeof(GETGROUPS_T), (char *) gidset) < 0)
1223 for (i = 0; i < len; i++)
1224 tprintf("%s%lu", i ? ", " : "",
1225 (unsigned long) gidset[i]);
1228 free((char *) gidset);
1238 GETGROUPS_T *gidset;
1240 if (entering(tcp)) {
1241 len = tcp->u_arg[0];
1242 tprintf("%u, ", len);
1249 gidset = (GETGROUPS_T *) malloc(len * sizeof(GETGROUPS_T));
1250 if (gidset == NULL) {
1251 fprintf(stderr, "sys_getgroups: out of memory\n");
1256 else if (!verbose(tcp) || tcp->u_arg[0] == 0)
1257 tprintf("%#lx", tcp->u_arg[1]);
1258 else if (umoven(tcp, tcp->u_arg[1],
1259 len * sizeof(GETGROUPS_T), (char *) gidset) < 0)
1263 for (i = 0; i < len; i++)
1264 tprintf("%s%lu", i ? ", " : "",
1265 (unsigned long) gidset[i]);
1268 free((char *)gidset);
1277 if (entering(tcp)) {
1279 tprintf("%lu, %lu", tcp->u_arg[0], tcp->u_arg[1]);
1289 if (entering(tcp)) {
1291 tprintf("%lu", tcp->u_arg[0]);
1301 if (entering(tcp)) {
1302 tprintf("%lu", tcp->u_arg[0]);
1318 if (entering(tcp)) {
1319 tprintf("%lu", tcp->u_arg[0]);
1328 if (entering(tcp)) {
1329 tprintf("%lu, %lu", tcp->u_arg[0], tcp->u_arg[1]);
1336 #include <sys/privilege.h>
1339 static struct xlat procpriv_cmds [] = {
1340 { SETPRV, "SETPRV" },
1341 { CLRPRV, "CLRPRV" },
1342 { PUTPRV, "PUTPRV" },
1343 { GETPRV, "GETPRV" },
1344 { CNTPRV, "CNTPRV" },
1349 static struct xlat procpriv_priv [] = {
1350 { P_OWNER, "P_OWNER" },
1351 { P_AUDIT, "P_AUDIT" },
1352 { P_COMPAT, "P_COMPAT" },
1353 { P_DACREAD, "P_DACREAD" },
1354 { P_DACWRITE, "P_DACWRITE" },
1356 { P_FILESYS, "P_FILESYS" },
1357 { P_MACREAD, "P_MACREAD" },
1358 { P_MACWRITE, "P_MACWRITE" },
1359 { P_MOUNT, "P_MOUNT" },
1360 { P_MULTIDIR, "P_MULTIDIR" },
1361 { P_SETPLEVEL, "P_SETPLEVEL" },
1362 { P_SETSPRIV, "P_SETSPRIV" },
1363 { P_SETUID, "P_SETUID" },
1364 { P_SYSOPS, "P_SYSOPS" },
1365 { P_SETUPRIV, "P_SETUPRIV" },
1366 { P_DRIVER, "P_DRIVER" },
1367 { P_RTIME, "P_RTIME" },
1368 { P_MACUPGRADE, "P_MACUPGRADE" },
1369 { P_FSYSRANGE, "P_FSYSRANGE" },
1370 { P_SETFLEVEL, "P_SETFLEVEL" },
1371 { P_AUDITWR, "P_AUDITWR" },
1372 { P_TSHAR, "P_TSHAR" },
1373 { P_PLOCK, "P_PLOCK" },
1374 { P_CORE, "P_CORE" },
1375 { P_LOADMOD, "P_LOADMOD" },
1376 { P_BIND, "P_BIND" },
1377 { P_ALLPRIVS, "P_ALLPRIVS" },
1382 static struct xlat procpriv_type [] = {
1383 { PS_FIX, "PS_FIX" },
1384 { PS_INH, "PS_INH" },
1385 { PS_MAX, "PS_MAX" },
1386 { PS_WKG, "PS_WKG" },
1392 printpriv(tcp, addr, len, opt)
1399 int max = verbose (tcp) ? sizeof buf / sizeof buf [0] : 10;
1400 int dots = len > max;
1403 if (len > max) len = max;
1406 umoven (tcp, addr, len * sizeof buf[0], (char *) buf) < 0)
1408 tprintf ("%#lx", addr);
1414 for (i = 0; i < len; ++i) {
1417 if (i) tprintf (", ");
1419 if ((t = xlookup (procpriv_type, buf [i] & PS_TYPE)) &&
1420 (p = xlookup (procpriv_priv, buf [i] & ~PS_TYPE)))
1422 tprintf ("%s|%s", t, p);
1425 tprintf ("%#lx", buf [i]);
1429 if (dots) tprintf (" ...");
1439 if (entering(tcp)) {
1440 printxval(procpriv_cmds, tcp->u_arg[0], "???PRV");
1441 switch (tcp->u_arg[0]) {
1443 tprintf(", %#lx, %ld", tcp->u_arg[1], tcp->u_arg[2]);
1451 printpriv (tcp, tcp->u_arg[1], tcp->u_arg[2]);
1452 tprintf (", %ld", tcp->u_arg[2]);
1455 else if (tcp->u_arg[0] == GETPRV) {
1456 if (syserror (tcp)) {
1457 tprintf(", %#lx, %ld", tcp->u_arg[1], tcp->u_arg[2]);
1461 printpriv (tcp, tcp->u_arg[1], tcp->u_rval);
1462 tprintf (", %ld", tcp->u_arg[2]);
1473 fake_execve(tcp, program, argv, envp)
1482 if (!(qual_flags[SYS_execve - __NR_SYSCALL_BASE] & QUAL_TRACE))
1485 if (!(qual_flags[SYS_execve] & QUAL_TRACE))
1490 string_quote(program);
1492 for (i = 0; argv[i] != NULL; i++) {
1495 string_quote(argv[i]);
1497 for (i = 0; envp[i] != NULL; i++)
1499 tprintf("], [/* %d var%s */]) ", i, (i != 1) ? "s" : "");
1506 printargv(tcp, addr)
1512 int max = max_strlen / 2;
1514 for (sep = ""; --max >= 0; sep = ", ") {
1517 if (umove(tcp, addr, &cp) < 0) {
1518 tprintf("%#lx", addr);
1524 printstr(tcp, (long) cp, -1);
1525 addr += sizeof(char *);
1532 printargc(fmt, tcp, addr)
1540 for (count = 0; umove(tcp, addr, &cp) >= 0 && cp != NULL; count++) {
1541 addr += sizeof(char *);
1543 tprintf(fmt, count, count == 1 ? "" : "s");
1550 if (entering(tcp)) {
1551 printpath(tcp, tcp->u_arg[0]);
1553 tprintf(", %#lx", tcp->u_arg[1]);
1555 else if (abbrev(tcp))
1556 printargc(", [/* %d arg%s */]", tcp, tcp->u_arg[1]);
1560 printargv(tcp, tcp->u_arg[1]);
1571 if (entering(tcp)) {
1572 printpath(tcp, tcp->u_arg[0]);
1574 tprintf(", %#lx", tcp->u_arg[1]);
1576 else if (abbrev(tcp))
1577 printargc(", [/* %d arg%s */]", tcp, tcp->u_arg[1]);
1581 printargv(tcp, tcp->u_arg[1]);
1585 tprintf(", %#lx", tcp->u_arg[2]);
1586 else if (abbrev(tcp))
1587 printargc(", [/* %d var%s */]", tcp, tcp->u_arg[2]);
1590 printargv(tcp, tcp->u_arg[2]);
1594 #if defined LINUX && defined TCB_WAITEXECVE
1595 tcp->flags |= TCB_WAITEXECVE;
1596 #endif /* LINUX && TCB_WAITEXECVE */
1602 int sys_rexecve(tcp)
1605 if (entering (tcp)) {
1607 tprintf (", %ld", tcp->u_arg[3]);
1619 if (exiting(tcp) && !syserror(tcp) && followfork)
1627 #define __WNOTHREAD 0x20000000
1630 #define __WALL 0x40000000
1633 #define __WCLONE 0x80000000
1637 static struct xlat wait4_options[] = {
1638 { WNOHANG, "WNOHANG" },
1640 { WUNTRACED, "WUNTRACED" },
1643 { WEXITED, "WEXITED" },
1646 { WTRAPPED, "WTRAPPED" },
1649 { WSTOPPED, "WSTOPPED" },
1652 { WCONTINUED, "WCONTINUED" },
1655 { WNOWAIT, "WNOWAIT" },
1658 { __WCLONE, "__WCLONE" },
1661 { __WALL, "__WALL" },
1664 { __WNOTHREAD, "__WNOTHREAD" },
1676 * Here is a tricky presentation problem. This solution
1677 * is still not entirely satisfactory but since there
1678 * are no wait status constructors it will have to do.
1680 if (WIFSTOPPED(status))
1681 tprintf("[WIFSTOPPED(s) && WSTOPSIG(s) == %s]",
1682 signame(WSTOPSIG(status)));
1683 else if WIFSIGNALED(status)
1684 tprintf("[WIFSIGNALED(s) && WTERMSIG(s) == %s%s]",
1685 signame(WTERMSIG(status)),
1686 WCOREDUMP(status) ? " && WCOREDUMP(s)" : "");
1687 else if WIFEXITED(status) {
1688 tprintf("[WIFEXITED(s) && WEXITSTATUS(s) == %d]",
1689 WEXITSTATUS(status));
1693 tprintf("[%#x]", status);
1698 printwaitn(tcp, n, bitness)
1706 if (entering(tcp)) {
1707 tprintf("%ld, ", tcp->u_arg[0]);
1712 else if (syserror(tcp) || tcp->u_rval == 0)
1713 tprintf("%#lx", tcp->u_arg[1]);
1714 else if (umove(tcp, tcp->u_arg[1], &status) < 0)
1717 exited = printstatus(status);
1720 if (!printflags(wait4_options, tcp->u_arg[2]))
1728 else if (tcp->u_rval > 0) {
1731 printrusage32(tcp, tcp->u_arg[3]);
1734 printrusage(tcp, tcp->u_arg[3]);
1738 else if (tcp->u_rval > 0 && exited)
1739 printrusage(tcp, tcp->u_arg[3]);
1742 tprintf("%#lx", tcp->u_arg[3]);
1754 #ifdef TCB_CLONE_THREAD
1755 if (tcp->flags & TCB_CLONE_THREAD)
1756 /* The children we wait for are our parent's children. */
1757 got_kids = (tcp->parent->nchildren
1758 > tcp->parent->nclone_detached);
1760 got_kids = (tcp->nchildren > tcp->nclone_detached);
1762 got_kids = tcp->nchildren > 0;
1765 if (entering(tcp) && got_kids) {
1766 /* There are children that this parent should block for.
1767 But ptrace made us the parent of the traced children
1768 and the real parent will get ECHILD from the wait call.
1770 XXX If we attached with strace -f -p PID, then there
1771 may be untraced dead children the parent could be reaping
1772 now, but we make him block. */
1774 /* ??? WTA: fix bug with hanging children */
1776 if (!(tcp->u_arg[2] & WNOHANG)) {
1778 * There are traced children. We'll make the parent
1779 * block to avoid a false ECHILD error due to our
1780 * ptrace having stolen the children. However,
1781 * we shouldn't block if there are zombies to reap.
1782 * XXX doesn't handle pgrp matches (u_arg[0]==0,<-1)
1784 if (tcp->nzombies > 0 &&
1785 (tcp->u_arg[0] == -1 ||
1786 pid2tcb(tcp->u_arg[0]) == NULL))
1788 tcp->flags |= TCB_SUSPENDED;
1789 tcp->waitpid = tcp->u_arg[0];
1790 #ifdef TCB_CLONE_THREAD
1791 if (tcp->flags & TCB_CLONE_THREAD)
1792 tcp->parent->nclone_waiting++;
1796 if (exiting(tcp) && tcp->u_error == ECHILD && got_kids) {
1797 if (tcp->u_arg[2] & WNOHANG) {
1798 /* We must force a fake result of 0 instead of
1799 the ECHILD error. */
1800 extern int force_result();
1801 return force_result(tcp, 0, 0);
1805 "internal_wait: should not have resumed %d\n",
1808 else if (exiting(tcp) && tcp->u_error == 0 && tcp->u_rval > 0 &&
1809 tcp->nzombies > 0 && pid2tcb(tcp->u_rval) == NULL) {
1811 * We just reaped a child we don't know about,
1812 * presumably a zombie we already droptcb'd.
1826 /* The library wrapper stuffs this into the user variable. */
1828 printstatus(getrval2(tcp));
1843 if (!syserror(tcp)) {
1844 if (umove(tcp, tcp->u_arg[0], &status) < 0)
1845 tprintf("%#lx", tcp->u_arg[0]);
1847 printstatus(status);
1858 return printwaitn(tcp, 3, 0);
1865 return printwaitn(tcp, 4, 0);
1873 return printwaitn(tcp, 4, 1);
1879 static struct xlat waitid_types[] = {
1881 { P_PPID, "P_PPID" },
1882 { P_PGID, "P_PGID" },
1889 { P_LWPID, "P_LWPID" },
1901 if (entering(tcp)) {
1902 printxval(waitid_types, tcp->u_arg[0], "P_???");
1903 tprintf(", %ld, ", tcp->u_arg[1]);
1904 if (tcp->nchildren > 0) {
1905 /* There are traced children */
1906 tcp->flags |= TCB_SUSPENDED;
1907 tcp->waitpid = tcp->u_arg[0];
1915 else if (syserror(tcp))
1916 tprintf("%#lx", tcp->u_arg[2]);
1917 else if (umove(tcp, tcp->u_arg[2], &si) < 0)
1920 printsiginfo(&si, verbose (tcp));
1923 if (!printflags(wait4_options, tcp->u_arg[3]))
1936 tprintf("%lu", tcp->u_arg[0]);
1944 struct utsname uname;
1947 if (syserror(tcp) || !verbose(tcp))
1948 tprintf("%#lx", tcp->u_arg[0]);
1949 else if (umove(tcp, tcp->u_arg[0], &uname) < 0)
1951 else if (!abbrev(tcp)) {
1953 tprintf("{sysname=\"%s\", nodename=\"%s\", ",
1954 uname.sysname, uname.nodename);
1955 tprintf("release=\"%s\", version=\"%s\", ",
1956 uname.release, uname.version);
1957 tprintf("machine=\"%s\"", uname.machine);
1960 tprintf(", domainname=\"%s\"", uname.domainname);
1961 #endif /* __GLIBC__ */
1966 tprintf("{sys=\"%s\", node=\"%s\", ...}",
1967 uname.sysname, uname.nodename);
1974 static struct xlat ptrace_cmds[] = {
1976 { PTRACE_TRACEME, "PTRACE_TRACEME" },
1977 { PTRACE_PEEKTEXT, "PTRACE_PEEKTEXT", },
1978 { PTRACE_PEEKDATA, "PTRACE_PEEKDATA", },
1979 { PTRACE_PEEKUSER, "PTRACE_PEEKUSER", },
1980 { PTRACE_POKETEXT, "PTRACE_POKETEXT", },
1981 { PTRACE_POKEDATA, "PTRACE_POKEDATA", },
1982 { PTRACE_POKEUSER, "PTRACE_POKEUSER", },
1983 { PTRACE_CONT, "PTRACE_CONT" },
1984 { PTRACE_KILL, "PTRACE_KILL" },
1985 { PTRACE_SINGLESTEP, "PTRACE_SINGLESTEP" },
1986 { PTRACE_ATTACH, "PTRACE_ATTACH" },
1987 { PTRACE_DETACH, "PTRACE_DETACH" },
1988 #ifdef PTRACE_GETREGS
1989 { PTRACE_GETREGS, "PTRACE_GETREGS" },
1991 #ifdef PTRACE_SETREGS
1992 { PTRACE_SETREGS, "PTRACE_SETREGS" },
1994 #ifdef PTRACE_GETFPREGS
1995 { PTRACE_GETFPREGS, "PTRACE_GETFPREGS", },
1997 #ifdef PTRACE_SETFPREGS
1998 { PTRACE_SETFPREGS, "PTRACE_SETFPREGS", },
2000 #ifdef PTRACE_GETFPXREGS
2001 { PTRACE_GETFPXREGS, "PTRACE_GETFPXREGS", },
2003 #ifdef PTRACE_SETFPXREGS
2004 { PTRACE_SETFPXREGS, "PTRACE_SETFPXREGS", },
2007 { PTRACE_READDATA, "PTRACE_READDATA" },
2008 { PTRACE_WRITEDATA, "PTRACE_WRITEDATA" },
2009 { PTRACE_READTEXT, "PTRACE_READTEXT" },
2010 { PTRACE_WRITETEXT, "PTRACE_WRITETEXT" },
2011 { PTRACE_GETFPAREGS, "PTRACE_GETFPAREGS" },
2012 { PTRACE_SETFPAREGS, "PTRACE_SETFPAREGS" },
2014 { PTRACE_GETWINDOW, "PTRACE_GETWINDOW" },
2015 { PTRACE_SETWINDOW, "PTRACE_SETWINDOW" },
2017 { PTRACE_22, "PTRACE_PTRACE_22" },
2018 { PTRACE_23, "PTRACE_PTRACE_23" },
2021 { PTRACE_SYSCALL, "PTRACE_SYSCALL" },
2023 { PTRACE_DUMPCORE, "PTRACE_DUMPCORE" },
2025 { PTRACE_SETWRBKPT, "PTRACE_SETWRBKPT" },
2026 { PTRACE_SETACBKPT, "PTRACE_SETACBKPT" },
2027 { PTRACE_CLRDR7, "PTRACE_CLRDR7" },
2029 { PTRACE_26, "PTRACE_26" },
2030 { PTRACE_27, "PTRACE_27" },
2031 { PTRACE_28, "PTRACE_28" },
2033 { PTRACE_GETUCODE, "PTRACE_GETUCODE" },
2036 { PT_TRACE_ME, "PT_TRACE_ME" },
2037 { PT_READ_I, "PT_READ_I" },
2038 { PT_READ_D, "PT_READ_D" },
2039 { PT_WRITE_I, "PT_WRITE_I" },
2040 { PT_WRITE_D, "PT_WRITE_D" },
2042 { PT_READ_U, "PT_READ_U" },
2044 { PT_CONTINUE, "PT_CONTINUE" },
2045 { PT_KILL, "PT_KILL" },
2046 { PT_STEP, "PT_STEP" },
2047 { PT_ATTACH, "PT_ATTACH" },
2048 { PT_DETACH, "PT_DETACH" },
2049 { PT_GETREGS, "PT_GETREGS" },
2050 { PT_SETREGS, "PT_SETREGS" },
2051 { PT_GETFPREGS, "PT_GETFPREGS" },
2052 { PT_SETFPREGS, "PT_SETFPREGS" },
2053 { PT_GETDBREGS, "PT_GETDBREGS" },
2054 { PT_SETDBREGS, "PT_SETDBREGS" },
2055 #endif /* FREEBSD */
2060 #ifndef SUNOS4_KERNEL_ARCH_KLUDGE
2062 #endif /* !SUNOS4_KERNEL_ARCH_KLUDGE */
2063 struct xlat struct_user_offsets[] = {
2065 #if defined(S390) || defined(S390X)
2066 { PT_PSWMASK, "psw_mask" },
2067 { PT_PSWADDR, "psw_addr" },
2068 { PT_GPR0, "gpr0" },
2069 { PT_GPR1, "gpr1" },
2070 { PT_GPR2, "gpr2" },
2071 { PT_GPR3, "gpr3" },
2072 { PT_GPR4, "gpr4" },
2073 { PT_GPR5, "gpr5" },
2074 { PT_GPR6, "gpr6" },
2075 { PT_GPR7, "gpr7" },
2076 { PT_GPR8, "gpr8" },
2077 { PT_GPR9, "gpr9" },
2078 { PT_GPR10, "gpr10" },
2079 { PT_GPR11, "gpr11" },
2080 { PT_GPR12, "gpr12" },
2081 { PT_GPR13, "gpr13" },
2082 { PT_GPR14, "gpr14" },
2083 { PT_GPR15, "gpr15" },
2084 { PT_ACR0, "acr0" },
2085 { PT_ACR1, "acr1" },
2086 { PT_ACR2, "acr2" },
2087 { PT_ACR3, "acr3" },
2088 { PT_ACR4, "acr4" },
2089 { PT_ACR5, "acr5" },
2090 { PT_ACR6, "acr6" },
2091 { PT_ACR7, "acr7" },
2092 { PT_ACR8, "acr8" },
2093 { PT_ACR9, "acr9" },
2094 { PT_ACR10, "acr10" },
2095 { PT_ACR11, "acr11" },
2096 { PT_ACR12, "acr12" },
2097 { PT_ACR13, "acr13" },
2098 { PT_ACR14, "acr14" },
2099 { PT_ACR15, "acr15" },
2100 { PT_ORIGGPR2, "orig_gpr2" },
2103 { PT_FPR0_HI, "fpr0.hi" },
2104 { PT_FPR0_LO, "fpr0.lo" },
2105 { PT_FPR1_HI, "fpr1.hi" },
2106 { PT_FPR1_LO, "fpr1.lo" },
2107 { PT_FPR2_HI, "fpr2.hi" },
2108 { PT_FPR2_LO, "fpr2.lo" },
2109 { PT_FPR3_HI, "fpr3.hi" },
2110 { PT_FPR3_LO, "fpr3.lo" },
2111 { PT_FPR4_HI, "fpr4.hi" },
2112 { PT_FPR4_LO, "fpr4.lo" },
2113 { PT_FPR5_HI, "fpr5.hi" },
2114 { PT_FPR5_LO, "fpr5.lo" },
2115 { PT_FPR6_HI, "fpr6.hi" },
2116 { PT_FPR6_LO, "fpr6.lo" },
2117 { PT_FPR7_HI, "fpr7.hi" },
2118 { PT_FPR7_LO, "fpr7.lo" },
2119 { PT_FPR8_HI, "fpr8.hi" },
2120 { PT_FPR8_LO, "fpr8.lo" },
2121 { PT_FPR9_HI, "fpr9.hi" },
2122 { PT_FPR9_LO, "fpr9.lo" },
2123 { PT_FPR10_HI, "fpr10.hi" },
2124 { PT_FPR10_LO, "fpr10.lo" },
2125 { PT_FPR11_HI, "fpr11.hi" },
2126 { PT_FPR11_LO, "fpr11.lo" },
2127 { PT_FPR12_HI, "fpr12.hi" },
2128 { PT_FPR12_LO, "fpr12.lo" },
2129 { PT_FPR13_HI, "fpr13.hi" },
2130 { PT_FPR13_LO, "fpr13.lo" },
2131 { PT_FPR14_HI, "fpr14.hi" },
2132 { PT_FPR14_LO, "fpr14.lo" },
2133 { PT_FPR15_HI, "fpr15.hi" },
2134 { PT_FPR15_LO, "fpr15.lo" },
2137 { PT_FPR0, "fpr0" },
2138 { PT_FPR1, "fpr1" },
2139 { PT_FPR2, "fpr2" },
2140 { PT_FPR3, "fpr3" },
2141 { PT_FPR4, "fpr4" },
2142 { PT_FPR5, "fpr5" },
2143 { PT_FPR6, "fpr6" },
2144 { PT_FPR7, "fpr7" },
2145 { PT_FPR8, "fpr8" },
2146 { PT_FPR9, "fpr9" },
2147 { PT_FPR10, "fpr10" },
2148 { PT_FPR11, "fpr11" },
2149 { PT_FPR12, "fpr12" },
2150 { PT_FPR13, "fpr13" },
2151 { PT_FPR14, "fpr14" },
2152 { PT_FPR15, "fpr15" },
2155 { PT_CR_10, "cr10" },
2156 { PT_CR_11, "cr11" },
2157 { PT_IEEE_IP, "ieee_exception_ip" },
2160 /* XXX No support for these offsets yet. */
2162 /* XXX No support for these offsets yet. */
2163 #elif defined(POWERPC)
2165 #define PT_ORIG_R3 34
2167 #define REGSIZE (sizeof(unsigned long))
2168 { REGSIZE*PT_R0, "r0" },
2169 { REGSIZE*PT_R1, "r1" },
2170 { REGSIZE*PT_R2, "r2" },
2171 { REGSIZE*PT_R3, "r3" },
2172 { REGSIZE*PT_R4, "r4" },
2173 { REGSIZE*PT_R5, "r5" },
2174 { REGSIZE*PT_R6, "r6" },
2175 { REGSIZE*PT_R7, "r7" },
2176 { REGSIZE*PT_R8, "r8" },
2177 { REGSIZE*PT_R9, "r9" },
2178 { REGSIZE*PT_R10, "r10" },
2179 { REGSIZE*PT_R11, "r11" },
2180 { REGSIZE*PT_R12, "r12" },
2181 { REGSIZE*PT_R13, "r13" },
2182 { REGSIZE*PT_R14, "r14" },
2183 { REGSIZE*PT_R15, "r15" },
2184 { REGSIZE*PT_R16, "r16" },
2185 { REGSIZE*PT_R17, "r17" },
2186 { REGSIZE*PT_R18, "r18" },
2187 { REGSIZE*PT_R19, "r19" },
2188 { REGSIZE*PT_R20, "r20" },
2189 { REGSIZE*PT_R21, "r21" },
2190 { REGSIZE*PT_R22, "r22" },
2191 { REGSIZE*PT_R23, "r23" },
2192 { REGSIZE*PT_R24, "r24" },
2193 { REGSIZE*PT_R25, "r25" },
2194 { REGSIZE*PT_R26, "r26" },
2195 { REGSIZE*PT_R27, "r27" },
2196 { REGSIZE*PT_R28, "r28" },
2197 { REGSIZE*PT_R29, "r29" },
2198 { REGSIZE*PT_R30, "r30" },
2199 { REGSIZE*PT_R31, "r31" },
2200 { REGSIZE*PT_NIP, "NIP" },
2201 { REGSIZE*PT_MSR, "MSR" },
2202 { REGSIZE*PT_ORIG_R3, "ORIG_R3" },
2203 { REGSIZE*PT_CTR, "CTR" },
2204 { REGSIZE*PT_LNK, "LNK" },
2205 { REGSIZE*PT_XER, "XER" },
2206 { REGSIZE*PT_CCR, "CCR" },
2207 { REGSIZE*PT_FPR0, "FPR0" },
2278 { PT_F32, "f32" }, { PT_F33, "f33" }, { PT_F34, "f34" },
2279 { PT_F35, "f35" }, { PT_F36, "f36" }, { PT_F37, "f37" },
2280 { PT_F38, "f38" }, { PT_F39, "f39" }, { PT_F40, "f40" },
2281 { PT_F41, "f41" }, { PT_F42, "f42" }, { PT_F43, "f43" },
2282 { PT_F44, "f44" }, { PT_F45, "f45" }, { PT_F46, "f46" },
2283 { PT_F47, "f47" }, { PT_F48, "f48" }, { PT_F49, "f49" },
2284 { PT_F50, "f50" }, { PT_F51, "f51" }, { PT_F52, "f52" },
2285 { PT_F53, "f53" }, { PT_F54, "f54" }, { PT_F55, "f55" },
2286 { PT_F56, "f56" }, { PT_F57, "f57" }, { PT_F58, "f58" },
2287 { PT_F59, "f59" }, { PT_F60, "f60" }, { PT_F61, "f61" },
2288 { PT_F62, "f62" }, { PT_F63, "f63" }, { PT_F64, "f64" },
2289 { PT_F65, "f65" }, { PT_F66, "f66" }, { PT_F67, "f67" },
2290 { PT_F68, "f68" }, { PT_F69, "f69" }, { PT_F70, "f70" },
2291 { PT_F71, "f71" }, { PT_F72, "f72" }, { PT_F73, "f73" },
2292 { PT_F74, "f74" }, { PT_F75, "f75" }, { PT_F76, "f76" },
2293 { PT_F77, "f77" }, { PT_F78, "f78" }, { PT_F79, "f79" },
2294 { PT_F80, "f80" }, { PT_F81, "f81" }, { PT_F82, "f82" },
2295 { PT_F83, "f83" }, { PT_F84, "f84" }, { PT_F85, "f85" },
2296 { PT_F86, "f86" }, { PT_F87, "f87" }, { PT_F88, "f88" },
2297 { PT_F89, "f89" }, { PT_F90, "f90" }, { PT_F91, "f91" },
2298 { PT_F92, "f92" }, { PT_F93, "f93" }, { PT_F94, "f94" },
2299 { PT_F95, "f95" }, { PT_F96, "f96" }, { PT_F97, "f97" },
2300 { PT_F98, "f98" }, { PT_F99, "f99" }, { PT_F100, "f100" },
2301 { PT_F101, "f101" }, { PT_F102, "f102" }, { PT_F103, "f103" },
2302 { PT_F104, "f104" }, { PT_F105, "f105" }, { PT_F106, "f106" },
2303 { PT_F107, "f107" }, { PT_F108, "f108" }, { PT_F109, "f109" },
2304 { PT_F110, "f110" }, { PT_F111, "f111" }, { PT_F112, "f112" },
2305 { PT_F113, "f113" }, { PT_F114, "f114" }, { PT_F115, "f115" },
2306 { PT_F116, "f116" }, { PT_F117, "f117" }, { PT_F118, "f118" },
2307 { PT_F119, "f119" }, { PT_F120, "f120" }, { PT_F121, "f121" },
2308 { PT_F122, "f122" }, { PT_F123, "f123" }, { PT_F124, "f124" },
2309 { PT_F125, "f125" }, { PT_F126, "f126" }, { PT_F127, "f127" },
2311 { PT_F2, "f2" }, { PT_F3, "f3" }, { PT_F4, "f4" },
2312 { PT_F5, "f5" }, { PT_F10, "f10" }, { PT_F11, "f11" },
2313 { PT_F12, "f12" }, { PT_F13, "f13" }, { PT_F14, "f14" },
2314 { PT_F15, "f15" }, { PT_F16, "f16" }, { PT_F17, "f17" },
2315 { PT_F18, "f18" }, { PT_F19, "f19" }, { PT_F20, "f20" },
2316 { PT_F21, "f21" }, { PT_F22, "f22" }, { PT_F23, "f23" },
2317 { PT_F24, "f24" }, { PT_F25, "f25" }, { PT_F26, "f26" },
2318 { PT_F27, "f27" }, { PT_F28, "f28" }, { PT_F29, "f29" },
2319 { PT_F30, "f30" }, { PT_F31, "f31" }, { PT_R4, "r4" },
2320 { PT_R5, "r5" }, { PT_R6, "r6" }, { PT_R7, "r7" },
2322 { PT_B1, "b1" }, { PT_B2, "b2" }, { PT_B3, "b3" },
2323 { PT_B4, "b4" }, { PT_B5, "b5" },
2324 { PT_AR_PFS, "kar.pfs" },
2325 { PT_AR_LC, "ar.lc" }, { PT_AR_UNAT, "kar.unat" },
2326 { PT_AR_RNAT, "kar.rnat" }, { PT_AR_BSPSTORE, "kar.bspstore" },
2329 { PT_CR_IPSR, "cr.ipsr" }, { PT_CR_IIP, "cr.iip" },
2330 /*{ PT_CR_IFS, "cr.ifs" },*/ { PT_AR_UNAT, "ar.unat" },
2331 { PT_AR_PFS, "ar.pfs" }, { PT_AR_RSC, "ar.rsc" },
2332 { PT_AR_RNAT, "ar.rnat" }, { PT_AR_BSPSTORE, "ar.bspstore" },
2333 { PT_PR, "pr" }, { PT_B6, "b6" }, { PT_AR_BSP, "ar.bsp" },
2334 { PT_R1, "r1" }, { PT_R2, "r2" }, { PT_R3, "r3" },
2335 { PT_R12, "r12" }, { PT_R13, "r13" }, { PT_R14, "r14" },
2336 { PT_R15, "r15" }, { PT_R8, "r8" }, { PT_R9, "r9" },
2337 { PT_R10, "r10" }, { PT_R11, "r11" }, { PT_R16, "r16" },
2338 { PT_R17, "r17" }, { PT_R18, "r18" }, { PT_R19, "r19" },
2339 { PT_R20, "r20" }, { PT_R21, "r21" }, { PT_R22, "r22" },
2340 { PT_R23, "r23" }, { PT_R24, "r24" }, { PT_R25, "r25" },
2341 { PT_R26, "r26" }, { PT_R27, "r27" }, { PT_R28, "r28" },
2342 { PT_R29, "r29" }, { PT_R30, "r30" }, { PT_R31, "r31" },
2343 { PT_AR_CCV, "ar.ccv" }, { PT_AR_FPSR, "ar.fpsr" },
2344 { PT_B0, "b0" }, { PT_B7, "b7" }, { PT_F6, "f6" },
2345 { PT_F7, "f7" }, { PT_F8, "f8" }, { PT_F9, "f9" },
2359 { 4*ORIG_EAX, "4*ORIG_EAX" },
2363 { 4*UESP, "4*UESP" },
2383 { 8*ORIG_RAX, "8*ORIG_EAX" },
2386 { 8*EFLAGS, "8*EFL" },
2396 { 4*PT_D1, "4*PT_D1" },
2397 { 4*PT_D2, "4*PT_D2" },
2398 { 4*PT_D3, "4*PT_D3" },
2399 { 4*PT_D4, "4*PT_D4" },
2400 { 4*PT_D5, "4*PT_D5" },
2401 { 4*PT_D6, "4*PT_D6" },
2402 { 4*PT_D7, "4*PT_D7" },
2403 { 4*PT_A0, "4*PT_A0" },
2404 { 4*PT_A1, "4*PT_A1" },
2405 { 4*PT_A2, "4*PT_A2" },
2406 { 4*PT_A3, "4*PT_A3" },
2407 { 4*PT_A4, "4*PT_A4" },
2408 { 4*PT_A5, "4*PT_A5" },
2409 { 4*PT_A6, "4*PT_A6" },
2410 { 4*PT_D0, "4*PT_D0" },
2411 { 4*PT_USP, "4*PT_USP" },
2412 { 4*PT_ORIG_D0, "4*PT_ORIG_D0" },
2413 { 4*PT_SR, "4*PT_SR" },
2414 { 4*PT_PC, "4*PT_PC" },
2418 { 4*REG_REG0, "4*REG_REG0" },
2419 { 4*(REG_REG0+1), "4*REG_REG1" },
2420 { 4*(REG_REG0+2), "4*REG_REG2" },
2421 { 4*(REG_REG0+3), "4*REG_REG3" },
2422 { 4*(REG_REG0+4), "4*REG_REG4" },
2423 { 4*(REG_REG0+5), "4*REG_REG5" },
2424 { 4*(REG_REG0+6), "4*REG_REG6" },
2425 { 4*(REG_REG0+7), "4*REG_REG7" },
2426 { 4*(REG_REG0+8), "4*REG_REG8" },
2427 { 4*(REG_REG0+9), "4*REG_REG9" },
2428 { 4*(REG_REG0+10), "4*REG_REG10" },
2429 { 4*(REG_REG0+11), "4*REG_REG11" },
2430 { 4*(REG_REG0+12), "4*REG_REG12" },
2431 { 4*(REG_REG0+13), "4*REG_REG13" },
2432 { 4*(REG_REG0+14), "4*REG_REG14" },
2433 { 4*REG_REG15, "4*REG_REG15" },
2434 { 4*REG_PC, "4*REG_PC" },
2435 { 4*REG_PR, "4*REG_PR" },
2436 { 4*REG_SR, "4*REG_SR" },
2437 { 4*REG_GBR, "4*REG_GBR" },
2438 { 4*REG_MACH, "4*REG_MACH" },
2439 { 4*REG_MACL, "4*REG_MACL" },
2440 { 4*REG_SYSCALL, "4*REG_SYSCALL" },
2441 { 4*REG_FPUL, "4*REG_FPUL" },
2442 { 4*REG_FPREG0, "4*REG_FPREG0" },
2443 { 4*(REG_FPREG0+1), "4*REG_FPREG1" },
2444 { 4*(REG_FPREG0+2), "4*REG_FPREG2" },
2445 { 4*(REG_FPREG0+3), "4*REG_FPREG3" },
2446 { 4*(REG_FPREG0+4), "4*REG_FPREG4" },
2447 { 4*(REG_FPREG0+5), "4*REG_FPREG5" },
2448 { 4*(REG_FPREG0+6), "4*REG_FPREG6" },
2449 { 4*(REG_FPREG0+7), "4*REG_FPREG7" },
2450 { 4*(REG_FPREG0+8), "4*REG_FPREG8" },
2451 { 4*(REG_FPREG0+9), "4*REG_FPREG9" },
2452 { 4*(REG_FPREG0+10), "4*REG_FPREG10" },
2453 { 4*(REG_FPREG0+11), "4*REG_FPREG11" },
2454 { 4*(REG_FPREG0+12), "4*REG_FPREG12" },
2455 { 4*(REG_FPREG0+13), "4*REG_FPREG13" },
2456 { 4*(REG_FPREG0+14), "4*REG_FPREG14" },
2457 { 4*REG_FPREG15, "4*REG_FPREG15" },
2458 { 4*REG_XDREG0, "4*REG_XDREG0" },
2459 { 4*(REG_XDREG0+2), "4*REG_XDREG2" },
2460 { 4*(REG_XDREG0+4), "4*REG_XDREG4" },
2461 { 4*(REG_XDREG0+6), "4*REG_XDREG6" },
2462 { 4*(REG_XDREG0+8), "4*REG_XDREG8" },
2463 { 4*(REG_XDREG0+10), "4*REG_XDREG10" },
2464 { 4*(REG_XDREG0+12), "4*REG_XDREG12" },
2465 { 4*REG_XDREG14, "4*REG_XDREG14" },
2466 { 4*REG_FPSCR, "4*REG_FPSCR" },
2469 #if !defined(S390) && !defined(S390X) && !defined(MIPS)
2470 { uoff(u_fpvalid), "offsetof(struct user, u_fpvalid)" },
2472 #if defined(I386) || defined(X86_64)
2473 { uoff(i387), "offsetof(struct user, i387)" },
2476 { uoff(m68kfp), "offsetof(struct user, m68kfp)" },
2479 { uoff(u_tsize), "offsetof(struct user, u_tsize)" },
2480 { uoff(u_dsize), "offsetof(struct user, u_dsize)" },
2481 { uoff(u_ssize), "offsetof(struct user, u_ssize)" },
2482 { uoff(start_code), "offsetof(struct user, start_code)" },
2483 { uoff(start_stack), "offsetof(struct user, start_stack)" },
2484 { uoff(signal), "offsetof(struct user, signal)" },
2485 #if !defined(S390) && !defined(S390X) && !defined(MIPS) && !defined(SH)
2486 { uoff(reserved), "offsetof(struct user, reserved)" },
2488 { uoff(u_ar0), "offsetof(struct user, u_ar0)" },
2489 #if !defined(ARM) && !defined(MIPS) && !defined(S390) && !defined(S390X)
2490 { uoff(u_fpstate), "offsetof(struct user, u_fpstate)" },
2492 { uoff(magic), "offsetof(struct user, magic)" },
2493 { uoff(u_comm), "offsetof(struct user, u_comm)" },
2494 #if defined(I386) || defined(X86_64)
2495 { uoff(u_debugreg), "offsetof(struct user, u_debugreg)" },
2499 #endif /* !POWERPC/!SPARC */
2502 { uoff(u_pcb), "offsetof(struct user, u_pcb)" },
2503 { uoff(u_procp), "offsetof(struct user, u_procp)" },
2504 { uoff(u_ar0), "offsetof(struct user, u_ar0)" },
2505 { uoff(u_comm[0]), "offsetof(struct user, u_comm[0])" },
2506 { uoff(u_arg[0]), "offsetof(struct user, u_arg[0])" },
2507 { uoff(u_ap), "offsetof(struct user, u_ap)" },
2508 { uoff(u_qsave), "offsetof(struct user, u_qsave)" },
2509 { uoff(u_rval1), "offsetof(struct user, u_rval1)" },
2510 { uoff(u_rval2), "offsetof(struct user, u_rval2)" },
2511 { uoff(u_error), "offsetof(struct user, u_error)" },
2512 { uoff(u_eosys), "offsetof(struct user, u_eosys)" },
2513 { uoff(u_ssave), "offsetof(struct user, u_ssave)" },
2514 { uoff(u_signal[0]), "offsetof(struct user, u_signal)" },
2515 { uoff(u_sigmask[0]), "offsetof(struct user, u_sigmask)" },
2516 { uoff(u_sigonstack), "offsetof(struct user, u_sigonstack)" },
2517 { uoff(u_sigintr), "offsetof(struct user, u_sigintr)" },
2518 { uoff(u_sigreset), "offsetof(struct user, u_sigreset)" },
2519 { uoff(u_oldmask), "offsetof(struct user, u_oldmask)" },
2520 { uoff(u_code), "offsetof(struct user, u_code)" },
2521 { uoff(u_addr), "offsetof(struct user, u_addr)" },
2522 { uoff(u_sigstack), "offsetof(struct user, u_sigstack)" },
2523 { uoff(u_ofile), "offsetof(struct user, u_ofile)" },
2524 { uoff(u_pofile), "offsetof(struct user, u_pofile)" },
2525 { uoff(u_ofile_arr[0]), "offsetof(struct user, u_ofile_arr[0])" },
2526 { uoff(u_pofile_arr[0]),"offsetof(struct user, u_pofile_arr[0])"},
2527 { uoff(u_lastfile), "offsetof(struct user, u_lastfile)" },
2528 { uoff(u_cwd), "offsetof(struct user, u_cwd)" },
2529 { uoff(u_cdir), "offsetof(struct user, u_cdir)" },
2530 { uoff(u_rdir), "offsetof(struct user, u_rdir)" },
2531 { uoff(u_cmask), "offsetof(struct user, u_cmask)" },
2532 { uoff(u_ru), "offsetof(struct user, u_ru)" },
2533 { uoff(u_cru), "offsetof(struct user, u_cru)" },
2534 { uoff(u_timer[0]), "offsetof(struct user, u_timer[0])" },
2535 { uoff(u_XXX[0]), "offsetof(struct user, u_XXX[0])" },
2536 { uoff(u_ioch), "offsetof(struct user, u_ioch)" },
2537 { uoff(u_start), "offsetof(struct user, u_start)" },
2538 { uoff(u_acflag), "offsetof(struct user, u_acflag)" },
2539 { uoff(u_prof.pr_base), "offsetof(struct user, u_prof.pr_base)" },
2540 { uoff(u_prof.pr_size), "offsetof(struct user, u_prof.pr_size)" },
2541 { uoff(u_prof.pr_off), "offsetof(struct user, u_prof.pr_off)" },
2542 { uoff(u_prof.pr_scale),"offsetof(struct user, u_prof.pr_scale)"},
2543 { uoff(u_rlimit[0]), "offsetof(struct user, u_rlimit)" },
2544 { uoff(u_exdata.Ux_A), "offsetof(struct user, u_exdata.Ux_A)" },
2545 { uoff(u_exdata.ux_shell[0]),"offsetof(struct user, u_exdata.ux_shell[0])"},
2546 { uoff(u_lofault), "offsetof(struct user, u_lofault)" },
2549 { sizeof(struct user), "sizeof(struct user)" },
2562 if (entering(tcp)) {
2563 printxval(ptrace_cmds, tcp->u_arg[0],
2570 tprintf(", %lu, ", tcp->u_arg[1]);
2571 addr = tcp->u_arg[2];
2573 if (tcp->u_arg[0] == PTRACE_PEEKUSER
2574 || tcp->u_arg[0] == PTRACE_POKEUSER) {
2575 for (x = struct_user_offsets; x->str; x++) {
2580 tprintf("%#lx, ", addr);
2581 else if (x->val > addr && x != struct_user_offsets) {
2583 tprintf("%s + %ld, ", x->str, addr - x->val);
2586 tprintf("%s, ", x->str);
2590 tprintf("%#lx, ", tcp->u_arg[2]);
2592 switch (tcp->u_arg[0]) {
2593 case PTRACE_PEEKDATA:
2594 case PTRACE_PEEKTEXT:
2595 case PTRACE_PEEKUSER:
2598 case PTRACE_SINGLESTEP:
2599 case PTRACE_SYSCALL:
2601 printsignal(tcp->u_arg[3]);
2604 tprintf("%#lx", tcp->u_arg[3]);
2608 switch (tcp->u_arg[0]) {
2609 case PTRACE_PEEKDATA:
2610 case PTRACE_PEEKTEXT:
2611 case PTRACE_PEEKUSER:
2612 printnum(tcp, tcp->u_arg[3], "%#lx");
2618 if (tcp->u_arg[0] == PTRACE_WRITEDATA ||
2619 tcp->u_arg[0] == PTRACE_WRITETEXT) {
2620 tprintf("%lu, ", tcp->u_arg[3]);
2621 printstr(tcp, tcp->u_arg[4], tcp->u_arg[3]);
2622 } else if (tcp->u_arg[0] != PTRACE_READDATA &&
2623 tcp->u_arg[0] != PTRACE_READTEXT) {
2624 tprintf("%#lx", tcp->u_arg[3]);
2627 if (tcp->u_arg[0] == PTRACE_READDATA ||
2628 tcp->u_arg[0] == PTRACE_READTEXT) {
2629 tprintf("%lu, ", tcp->u_arg[3]);
2630 printstr(tcp, tcp->u_arg[4], tcp->u_arg[3]);
2635 tprintf("%lu", tcp->u_arg[3]);
2637 #endif /* FREEBSD */
2644 static struct xlat futexops[] = {
2645 { FUTEX_WAIT, "FUTEX_WAIT" },
2646 { FUTEX_WAKE, "FUTEX_WAKE" },
2647 { FUTEX_FD, "FUTEX_FD" },
2655 if (entering(tcp)) {
2656 tprintf("%p, ", (void *) tcp->u_arg[0]);
2657 printflags(futexops, tcp->u_arg[1]);
2658 tprintf(", %ld", tcp->u_arg[2]);
2659 if (tcp->u_arg[1] == FUTEX_WAIT) {
2661 printtv(tcp, tcp->u_arg[3]);
2668 print_affinitylist(list, len)
2669 unsigned long *list;
2674 while (len >= sizeof (unsigned long)) {
2675 tprintf("%s %lx", first ? "" : ",", *list++);
2677 len -= sizeof (unsigned long);
2683 sys_sched_setaffinity(tcp)
2686 if (entering(tcp)) {
2687 tprintf("%ld, %lu, ", tcp->u_arg[0], tcp->u_arg[1]);
2688 print_affinitylist((unsigned long *) tcp->u_arg[2], tcp->u_arg[1]);
2694 sys_sched_getaffinity(tcp)
2697 if (entering(tcp)) {
2698 tprintf("%ld, %lu, ", tcp->u_arg[0], tcp->u_arg[1]);
2700 print_affinitylist((unsigned long *) tcp->u_arg[2], tcp->u_rval);