2009-06-01 Dmitry V. Levin <ldv@altlinux.org>
- * strace.c (handle_stopped_tcbs): Fix cast for 4th argument
- passed to ptrace().
-
* bjm.c (sys_query_module): Fix format warning reported by
gcc -Wformat-security.
* file.c (tprint_open_modes): Likewise.
Move NULL/error check for addr parameter
so that it happens before printstatsol/printstat_sparc64 calls.
-2009-04-20 Denys Vlasenko <dvlasenk@redhat.com>
-
- * strace.c (collect_stopped_tcbs): Do not enable/disable signals
- multiple times, do it just once per collecting pass.
-
2009-04-16 Denys Vlasenko <dvlasenk@redhat.com>
* file.c (print_dirfd): Use int for file descriptor, not a long.
* net.c (printcmsghdr): Fix improperly used %zu:
struct cmsghdr::cmsg_len is not a size_t.
-2009-03-17 Denys Vlasenko <dvlasenk@redhat.com>
-
- * strace.c (collect_stopped_tcbs): Check for ^C here too,
- not only in trace().
- (trace): Tweak check for ^C to not set mask (not needed).
-
2009-03-10 Denys Vlasenko <dvlasenk@redhat.com>
Decode fcntl's F_{GET,SET}LEASE, F_NOTIFY, and F_DUPFD_CLOEXEC.
(force_result): While at it, fix cpp directives indentation.
* util.c (printcall): Add support for cris.
-2009-02-24 Denys Vlasenko <dvlasenk@redhat.com>
-
- Replace many more bare ptrace calls with calls to wrappers
- which do proper error-checking and set tcp->ptrace_errno.
- In some cases, missing error checking is added.
- Error handling for trace_syscall() failures and other cases
- where tcp->ptrace_errno is nonzero is cleaned up a bit
- and made more verbose if we see error other than ESRCH.
- Some comments are added or expanded.
- * defs.h: Declare ptrace_cmds[]. Modify do_ptrace
- declaration (last parameter is long, not void *).
- * process.c: Make ptrace_cmds[] non-static.
- (change_syscall): Use do_ptrace() instead of bare ptrace().
- * signal.c: Use do_ptrace() instead of bare ptrace().
- * strace.c: Update trace_syscall() failure handling.
- * syscall.c: Use do_ptrace() instead of bare ptrace().
- * util.c: Use do_ptrace() instead of bare ptrace().
- Update do_ptrace() wrapper.
- (str_PTRACE_xxx): New function - helper returning "PTRACE_xxx".
- (do_ptrace_peekdata): New function - wrapper for PTRACE_PEEKDATA
- (do_ptrace5): New function - wrapper for 5-argument ptrace calls.
-
2009-02-24 Denys Vlasenko <dvlasenk@redhat.com>
* process.c: Indent preprocessor directives so that nesting
[HAVE_STRUCT_SIGCONTEXT].
From Muttley Meen <muttley.meen@gmail.com>.
-2009-02-10 Denys Vlasenko <dvlasenk@redhat.com>
-
- Cleanup after tcb table expansion simplification.
- There was code which was trying to continue tracing
- even if table expansion fails. Now we treat it as fatal
- failure, so this code is removed by this change.
- * defs.h: Delete TCB_FOLLOWFORK constant.
- * process.c: Delete fork_tcb() and all calls of it.
- * strace.c (startup_attach): Remove usage of TCB_FOLLOWFORK.
- * syscall.c: Indent preprocessor directives.
-
2009-02-09 Denys Vlasenko <dvlasenk@redhat.com>
* defs.h: Correct the comment about TCB_SUSPENDED.
right before its death, it can legitimately happen.
(handle_stopped_tcbs): Ditto.
-2009-01-28 Denys Vlasenko <dvlasenk@redhat.com>
-
- * process.c (internal_clone): Check and complain if pid value
- looks insane.
- * strace.c (alloc_tcb): Clear *all* fields in reused tcb.
- (main): Query and remember uname() info on startup.
- (handle_stopped_tcbs): Do not use PTRACE_SETOPTIONS on Linux < 2.6.29.
- (printleader): Correct printing of "<unavailable>" markers.
-
-2009-01-27 Denys Vlasenko <dvlasenk@redhat.com>
-
- * strace.c (collect_stopped_tcbs): Guard against the case when
- waitpid() reports the same task multiple times.
-
2009-01-26 Denys Vlasenko <dvlasenk@redhat.com>
* process.c (printwaitn): Add comment about wait4() pid expansion.
Format '%#08lx' expects type 'long unsigned int', but
argument 2 was type 'unsigned int'.
-2009-01-21 Denys Vlasenko <dvlasenk@redhat.com>
-
- * strace.c (collect_stopped_tcbs): Do not return NULL when ECHILD
- is detected, return collected list instead. Fixes symptom when
- the last "+++ killed by SIGxxx +++" is not printed.
-
2009-01-17 Denys Vlasenko <dvlasenk@redhat.com>
Two cleanups: tcb table expansion failure is not really a survivable
(alloc_tcb): On failure to expand, print a message, clean up, and exit.
* util.c (setbpt): Remove extern declaration from function body.
-2009-01-17 Denys Vlasenko <dvlasenk@redhat.com>
-
- * defs.h: Update a comment. No code changes.
- * strace.c (handle_stopped_tcbs): Discard all execve stops
- and clear TCB_WAITEXECVE bit.
- * syscall.c (get_scno): Add the code to not mistakenly
- treat ptrace stop as execve stop (execve stops can be blocked
- by traced program).
- Fixes RH#477775 "strace hangs if the target process blocks SIGTRAP".
-
-2009-01-17 Denys Vlasenko <dvlasenk@redhat.com>
-
- * process.c: Add a comment. No code changes.
- * strace.c (collect_stopped_tcbs): Stop reversing list of stopped
- tcp's. I'm not totally convinced it is crucial, but this is surely
- fits the concept of "least surprise".
- Do not collect TCB_SUSPENDED tcp's (this is closer to how
- it was before).
- (handle_stopped_tcbs): Remove the code to reject TCB_SUSPENDED tcp's,
- it's done earlier now. In an unobvious way, this was causing
- SIGSTOPs from freshly attached children to be misinterpreted.
-
2009-01-14 Denys Vlasenko <dvlasenk@redhat.com>
* linux/bfin/syscallent.h: sys_futex has 6 parameters, not 5.
Fixes for ptrace() argument parsing.
* process.c: Add parsing of PTRACE_SETOPTIONS, PTRACE_GETEVENTMSG,
PTRACE_GETSIGINFO, PTRACE_SETSIGINFO.
- * strace.c (handle_stopped_tcbs): Make PTRACE_SETOPTIONS
- define check more robust.
* defs.h: Declare several "extern const struct xlat" arrays here.
* desc.c: Remove open_mode_flags[] and open_access_modes[]
extern declarations.
* util.c: Remove struct_user_offsets[] extern declaration.
* signal.c: Remove open_mode_flags[] extern declaration.
-2009-01-09 Denys Vlasenko <dvlasenk@redhat.com>
-
- * defs.h: Add new struct tcb fields: wait_status, next_need_service.
- make flags field wider (ints are easier to work with on many CPUs).
- * strace.c (trace): Split this function into two:
- collect_stopped_tcbs() and handle_stopped_tcbs().
- Now we collect *all* waitable tasks, then handle them all,
- then repeat.
- Fixes RH#478419 "Some threads stop when strace with -f option
- is executed on a multi-thread process"
- * test/many_looping_threads.c: example program which cna't be straced
- successfully without this fix.
-
2009-01-06 Denys Vlasenko <dvlasenk@redhat.com>
Output format fixes, improving the situation after recent
convert all remaining old style C parameter declarations
in this file.
-2009-01-02 Denys Vlasenko <dvlasenk@redhat.com>
-
- * strace.c: Fix compile failure: on some systems PTRACE_O_xxx
- and PTRACE_EVENT_xxx constants are not defined because
- those system have old kernel headers.
- OTOH, if PT_SETOPTIONS is not defined too,
- I don't risk using ptrace options, the kernel is too old.
- I've seen problems on RHEL4 ia64 when I tried to.
-
2008-11-13 Kirill A. Shutemov <kirill@shutemov.name>
* linux/arm/syscallent.h: Update syscalls.
* linux/syscallent.h: Mark sendfile(2) as network syscall.
* linux/*/syscallent.h: Same, for all architectures.
-2008-12-29 Denys Vlasenko <dvlasenk@redhat.com>
-
- * defs.h: Remove sigtrap80 field from struct tcb.
- * strace.c: Add ptrace_stop_sig static variable
- and use it in place of tcp->sigtrap80.
- Add ptrace_opts_set static flag variable.
- (trace): Set ptrace options once, not per-process.
- If unexpected SIGTRAP is later received,
- revert back to using SIGTRAP
- (assume old, broken kernel).
-
-2008-12-22 Denys Vlasenko <dvlasenk@redhat.com>
-
- Make strace correctly handle SIGTRAP produced by e.g.
- kill(2) and by trapping instruction.
- * defs.h: Add sigtrap80 field to struct tcb.
- * strace.c (alloc_tcb): Initialize it to SIGTRAP.
- (detach): Use tcp->sigtrap80 instead of SIGTRAP constant.
- (trace): Attempt to set PTRACE_O_TRACESYSGOOD and
- PTRACE_O_TRACEEXEC options on each newly attached process,
- distinquish between SIGTRAP and (SIGTRAP | 0x80) stops.
- Fixes RH#162774 "strace ignores int3 SIGTRAP".
-
2008-12-17 Denys Vlasenko <dvlasenk@redhat.com>
Make strace detect when traced process suddenly disappeared
/* Trace Control Block */
struct tcb {
- int flags; /* See below for TCB_ values */
+ short flags; /* See below for TCB_ values */
int pid; /* Process Id of this entry */
- int wait_status; /* Status from last wait() */
- struct tcb *next_need_service;
- /* Linked list of tracees found by wait()s */
long scno; /* System call number */
int u_nargs; /* System call arguments */
long u_arg[MAX_ARGS]; /* System call arguments */
int nclone_threads; /* # of nchildren with CLONE_THREAD */
int nclone_detached; /* # of nchildren with CLONE_DETACHED */
int nclone_waiting; /* clone threads in wait4 (TCB_SUSPENDED) */
- /* (1st arg of wait4()) */
#endif
+ /* (1st arg of wait4()) */
long baddr; /* `Breakpoint' address */
long inst[2]; /* Instructions on above */
int pfd; /* proc file descriptor */
#define TCB_SUSPENDED 00040 /* Process can not be allowed to resume just now */
#define TCB_BPTSET 00100 /* "Breakpoint" set after fork(2) */
#define TCB_SIGTRAPPED 00200 /* Process wanted to block SIGTRAP */
+#define TCB_FOLLOWFORK 00400 /* Process should have forks followed */
#define TCB_REPRINT 01000 /* We should reprint this syscall on exit */
#ifdef LINUX
-/* TCB_WAITEXECVE bit means "ignore next SIGTRAP, it's execve exit stop".
- * it is not reliable if traced program masks SIGTRAP.
- *
- * x86 does not need TCB_WAITEXECVE.
+/* x86 does not need TCB_WAITEXECVE.
* It can detect execve's SIGTRAP by looking at eax/rax.
* See "stray syscall exit: eax = " message in syscall_fixup().
- *
- * Note that on newer kernels, we use ptrace options and therefore
- * can filter out execve stops reliably on any architecture,
- * without using TCB_WAITEXECVE flag.
- * I guess we can remove it from the source somewhere around year 2010 :)
*/
# if defined(ALPHA) || defined(AVR32) || defined(SPARC) || defined(SPARC64) \
|| defined(POWERPC) || defined(IA64) || defined(HPPA) \
extern const struct xlat addrfams[];
extern const struct xlat struct_user_offsets[];
extern const struct xlat open_access_modes[];
-extern const struct xlat ptrace_cmds[];
/* Format of syscall return values */
#define RVAL_DECIMAL 000 /* decimal format */
extern void qualify P((char *));
extern int get_scno P((struct tcb *));
extern long known_scno P((struct tcb *));
-extern long do_ptrace P((int request, struct tcb *tcp, void *addr, long data));
+extern long do_ptrace P((int request, struct tcb *tcp, void *addr, void *data));
extern int ptrace_restart P((int request, struct tcb *tcp, int sig));
extern int trace_syscall P((struct tcb *));
extern int count_syscall P((struct tcb *, struct timeval *));
tprintf("{%p, %p, %ld, %ld}",
event.data, event.obj,
event.res, event.res2);
- else
+ else
#endif
tprintf("{...}");
}
return 0;
}
+/* TCP is creating a child we want to follow.
+ If there will be space in tcbtab for it, set TCB_FOLLOWFORK and return 0.
+ If not, clear TCB_FOLLOWFORK, print an error, and return 1. */
+static void
+fork_tcb(struct tcb *tcp)
+{
+ if (nprocs == tcbtabsize)
+ expand_tcbtab();
+
+ tcp->flags |= TCB_FOLLOWFORK;
+}
+
#ifdef USE_PROCFS
int
return 0;
if (!followfork)
return 0;
+ fork_tcb(tcp);
if (syserror(tcp))
return 0;
tcpchild = alloctcb(tcp->u_rval);
# define PTRACE_SET_SYSCALL 23
# endif
- if (do_ptrace(PTRACE_SET_SYSCALL, tcp, NULL, new) != 0)
+ if (ptrace (PTRACE_SET_SYSCALL, tcp->pid, 0, new) != 0)
return -1;
return 0;
#if defined SYS_clone || defined SYS_clone2
int
-internal_clone(struct tcb *tcp)
+internal_clone(tcp)
+struct tcb *tcp;
{
struct tcb *tcpchild;
- int pid, bpt;
-
- if (!followfork)
- return 0;
+ int pid;
if (entering(tcp)) {
- setbpt(tcp);
- return 0;
+ if (!followfork)
+ return 0;
+ fork_tcb(tcp);
+ if (setbpt(tcp) < 0)
+ return 0;
} else {
- bpt = tcp->flags & TCB_BPTSET;
+ int bpt = tcp->flags & TCB_BPTSET;
+
+ if (!(tcp->flags & TCB_FOLLOWFORK))
+ return 0;
if (syserror(tcp)) {
if (bpt)
}
pid = tcp->u_rval;
- /* Should not happen, but bugs often cause bogus value here. */
- if (pid <= 1
- || (sizeof(pid) != sizeof(tcp->u_rval) && pid != tcp->u_rval)
- ) {
- if (bpt)
- clearbpt(tcp);
- fprintf(stderr, "bogus clone() return value %lx!\n", tcp->u_rval);
- return 0;
- }
#ifdef CLONE_PTRACE /* See new setbpt code. */
tcpchild = pid2tcb(pid);
else
#endif
{
+ fork_tcb(tcp);
tcpchild = alloctcb(pid);
}
clearbpt(tcpchild);
tcpchild->flags &= ~(TCB_SUSPENDED|TCB_STARTUP);
- /* TCB_SUSPENDED tasks are not collected by waitpid
- * loop, and left stopped. Restart it:
- */
if (ptrace_restart(PTRACE_SYSCALL, tcpchild, 0) < 0)
return -1;
struct tcb *tcpchild;
int pid;
- int follow = 1;
+ int dont_follow = 0;
#ifdef SYS_vfork
if (known_scno(tcp) == SYS_vfork) {
/* Attempt to make vfork into fork, which we can follow. */
if (change_syscall(tcp, SYS_fork) < 0)
- follow = 0;
+ dont_follow = 1;
}
#endif
- if (!followfork || !follow)
- return 0;
-
if (entering(tcp)) {
+ if (!followfork || dont_follow)
+ return 0;
+ fork_tcb(tcp);
if (setbpt(tcp) < 0)
return 0;
}
else {
int bpt = tcp->flags & TCB_BPTSET;
+ if (!(tcp->flags & TCB_FOLLOWFORK))
+ return 0;
if (bpt)
clearbpt(tcp);
return 0;
pid = tcp->u_rval;
+ fork_tcb(tcp);
tcpchild = alloctcb(pid);
#ifdef LINUX
#ifdef HPPA
#ifndef SVR4
-const struct xlat ptrace_cmds[] = {
+static const struct xlat ptrace_cmds[] = {
# ifndef FREEBSD
{ PTRACE_TRACEME, "PTRACE_TRACEME" },
{ PTRACE_PEEKTEXT, "PTRACE_PEEKTEXT", },
struct regs regs;
m_siginfo_t si;
- if (do_ptrace(PTRACE_GETREGS, tcp, (char *)®s, 0) < 0) {
+ if(ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) {
+ perror("sigreturn: PTRACE_GETREGS ");
return 0;
}
- if (entering(tcp)) {
+ if(entering(tcp)) {
tcp->u_arg[0] = 0;
i1 = regs.r_o1;
- if (umove(tcp, i1, &si) < 0) {
+ if(umove(tcp, i1, &si) < 0) {
perror("sigreturn: umove ");
return 0;
}
#include <sys/resource.h>
#include <sys/wait.h>
#include <sys/stat.h>
-#include <sys/utsname.h>
#include <pwd.h>
#include <grp.h>
#include <string.h>
*/
static bool daemonized_tracer = 0;
-static struct utsname utsname_buf;
-
/* Sometimes we want to print only succeeding syscalls. */
int not_failing_only = 0;
static int exit_code = 0;
static int strace_child = 0;
-static int ptrace_stop_sig = SIGTRAP;
-#if defined LINUX && (defined PTRACE_SETOPTIONS || defined PT_SETOPTIONS)
-static bool ptrace_opts_set;
-#endif
+
static char *username = NULL;
uid_t run_uid;
gid_t run_gid;
struct tcb **tcbtab;
unsigned int nprocs, tcbtabsize;
char *progname;
+extern char **environ;
static int detach P((struct tcb *tcp, int sig));
static int trace P((void));
++nerr;
else if (tid != tcbtab[tcbi]->pid) {
tcp = alloctcb(tid);
- tcp->flags |= TCB_ATTACHED|TCB_CLONE_THREAD|TCB_CLONE_DETACHED;
+ tcp->flags |= TCB_ATTACHED|TCB_CLONE_THREAD|TCB_CLONE_DETACHED|TCB_FOLLOWFORK;
tcbtab[tcbi]->nchildren++;
tcbtab[tcbi]->nclone_threads++;
tcbtab[tcbi]->nclone_detached++;
progname = argv[0] ? argv[0] : "strace";
- uname(&utsname_buf);
-
/* Allocate the initial tcbtab. */
tcbtabsize = argc; /* Surely enough for all -p args. */
if ((tcbtab = calloc(tcbtabsize, sizeof tcbtab[0])) == NULL) {
for (i = 0; i < tcbtabsize; i++) {
tcp = tcbtab[i];
if ((tcp->flags & TCB_INUSE) == 0) {
- memset(tcp, 0, sizeof(*tcp));
tcp->pid = pid;
+ tcp->parent = NULL;
+ tcp->nchildren = 0;
+ tcp->nzombies = 0;
+#ifdef TCB_CLONE_THREAD
+ tcp->nclone_threads = tcp->nclone_detached = 0;
+ tcp->nclone_waiting = 0;
+#endif
tcp->flags = TCB_INUSE | TCB_STARTUP;
tcp->outf = outf; /* Initialise to current out file */
+ tcp->stime.tv_sec = 0;
+ tcp->stime.tv_usec = 0;
tcp->pfd = -1;
nprocs++;
if (command_options_parsed)
break;
}
error = ptrace_restart(PTRACE_CONT, tcp,
- WSTOPSIG(status) == ptrace_stop_sig ? 0
+ WSTOPSIG(status) == SIGTRAP ? 0
: WSTOPSIG(status));
if (error < 0)
break;
}
#endif
-static struct tcb *
-collect_stopped_tcbs(void)
+static int
+trace()
{
-#ifdef LINUX
- static int remembered_pid;
- static int remembered_status;
-#endif
int pid;
int wait_errno;
int status;
struct tcb *tcp;
- struct tcb *found_tcps;
#ifdef LINUX
- struct tcb **nextp;
struct rusage ru;
- struct rusage* ru_ptr = cflag ? &ru : NULL;
- int wnohang = 0;
#ifdef __WALL
- int wait4_options = __WALL;
+ static int wait4_options = __WALL;
#endif
-
- if (remembered_pid > 0) {
- pid = remembered_pid;
- remembered_pid = 0;
- if (debug)
- fprintf(stderr, " [remembered wait(%#x) = %u]\n",
- remembered_status, pid);
- tcp = pid2tcb(pid); /* can't be NULL */
- tcp->wait_status = remembered_status;
- tcp->next_need_service = NULL;
- return tcp;
- }
- nextp = &found_tcps;
#endif /* LINUX */
- /* Make it possible to ^C strace while we wait */
- if (interactive)
- sigprocmask(SIG_SETMASK, &empty_set, NULL);
-
- found_tcps = NULL;
- while (1) {
+ while (nprocs != 0) {
if (interrupted)
- break;
+ return 0;
+ if (interactive)
+ sigprocmask(SIG_SETMASK, &empty_set, NULL);
#ifdef LINUX
#ifdef __WALL
- pid = wait4(-1, &status, wait4_options | wnohang, ru_ptr);
+ pid = wait4(-1, &status, wait4_options, cflag ? &ru : NULL);
if (pid < 0 && (wait4_options & __WALL) && errno == EINVAL) {
/* this kernel does not support __WALL */
wait4_options &= ~__WALL;
errno = 0;
- pid = wait4(-1, &status, wait4_options | wnohang, ru_ptr);
+ pid = wait4(-1, &status, wait4_options,
+ cflag ? &ru : NULL);
}
if (pid < 0 && !(wait4_options & __WALL) && errno == ECHILD) {
/* most likely a "cloned" process */
- pid = wait4(-1, &status, __WCLONE | wnohang, ru_ptr);
- if (pid < 0 && errno != ECHILD) {
- fprintf(stderr, "strace: wait4(WCLONE) "
+ pid = wait4(-1, &status, __WCLONE,
+ cflag ? &ru : NULL);
+ if (pid == -1) {
+ fprintf(stderr, "strace: clone wait4 "
"failed: %s\n", strerror(errno));
}
}
-#else /* !__WALL */
- pid = wait4(-1, &status, wnohang, ru_ptr);
-#endif
+#else
+ pid = wait4(-1, &status, 0, cflag ? &ru : NULL);
+#endif /* __WALL */
#endif /* LINUX */
#ifdef SUNOS4
pid = wait(&status);
#endif /* SUNOS4 */
wait_errno = errno;
+ if (interactive)
+ sigprocmask(SIG_BLOCK, &blocked_set, NULL);
- if (pid == 0 && wnohang) {
- /* We had at least one successful
- * wait() before. We waited
- * with WNOHANG second time.
- * Stop collecting more tracees,
- * process what we already have.
- */
- break;
- }
if (pid == -1) {
- if (wait_errno == EINTR)
+ switch (wait_errno) {
+ case EINTR:
continue;
- if (wait_errno == ECHILD) {
+ case ECHILD:
/*
* We would like to verify this case
* but sometimes a race in Solbourne's
* ECHILD before sending us SIGCHILD.
*/
#if 0
- if (nprocs != 0) {
- fprintf(stderr, "strace: proc miscount\n");
- exit(1);
- }
+ if (nprocs == 0)
+ return 0;
+ fprintf(stderr, "strace: proc miscount\n");
+ exit(1);
#endif
- break;
+ return 0;
+ default:
+ errno = wait_errno;
+ perror("strace: wait");
+ return -1;
}
- errno = wait_errno;
- perror("strace: wait");
- exit(1);
}
if (pid == popen_pid) {
if (WIFEXITED(status) || WIFSIGNALED(status))
if (debug)
fprintf(stderr, " [wait(%#x) = %u]\n", status, pid);
- /* RHEL5 bug workaround.
- * It can re-report stopped tasks. Happens on SIGSTOPs here.
- * Second (bogus) report has signal# set to 0.
- * Stop collecting and process what we have.
- */
- if (WIFSTOPPED(status) && WSTOPSIG(status) == 0)
- break;
-
/* Look up `pid' in our table. */
if ((tcp = pid2tcb(pid)) == NULL) {
#ifdef LINUX
else
/* This can happen if a clone call used
CLONE_PTRACE itself. */
-#endif /* LINUX */
+#endif
{
fprintf(stderr, "unknown pid: %u\n", pid);
if (WIFSTOPPED(status))
exit(1);
}
}
-
-#ifdef LINUX
+ /* set current output file */
+ outf = tcp->outf;
if (cflag) {
+#ifdef LINUX
tv_sub(&tcp->dtime, &ru.ru_stime, &tcp->stime);
tcp->stime = ru.ru_stime;
+#endif /* !LINUX */
}
-#endif
+
if (tcp->flags & TCB_SUSPENDED) {
/*
* Apparently, doing any ptrace() call on a stopped
* process has not been actually restarted.
* Since we have inspected the arguments of suspended
* processes we end up here testing for this case.
- *
- * We also end up here when we catch new pid of
- * CLONE_PTRACEd process. Do not process/restart it
- * until we see corresponding clone() syscall exit
- * in its parent.
*/
continue;
}
-
-#ifdef LINUX
- /* So far observed only on RHEL5 ia64, but I imagine this
- * can legitimately happen elsewhere.
- * If we waited and got a stopped task notification,
- * subsequent wait may return the same pid again, for example,
- * with SIGKILL notification. SIGKILL kills even stopped tasks.
- * We must not add it to the list
- * (one task can't be inserted twice in the list).
- */
- {
- struct tcb *f = found_tcps;
- while (f) {
- if (f == tcp) {
- remembered_pid = pid;
- remembered_status = status;
- goto ret;
- }
- f = f->next_need_service;
- }
- }
- /* It is important to not invert the order of tasks
- * to process. For one, alloc_tcb() above picks newly forked
- * threads in some order, processing of them and their parent
- * should be in the same order, otherwise bad things happen
- * (misinterpreted SIGSTOPs and such).
- */
- tcp->wait_status = status;
- *nextp = tcp;
- nextp = &tcp->next_need_service;
- *nextp = NULL;
- wnohang = WNOHANG;
-#endif
-#ifdef SUNOS4
- /* Probably need to replace wait with waitpid
- * and loop on Sun too, but I can't test it. Volunteers?
- */
- tcp->wait_status = status;
- tcp->next_need_service = NULL;
- found_tcps = tcp;
- break;
-#endif
- } /* while (1) - collecting all stopped/exited tracees */
- ret:
- /* Disable ^C etc */
- if (interactive)
- sigprocmask(SIG_BLOCK, &blocked_set, NULL);
-
- return found_tcps;
-}
-
-static int
-handle_stopped_tcbs(struct tcb *tcp)
-{
- for (; tcp; tcp = tcp->next_need_service) {
- int pid;
- int status;
-
- outf = tcp->outf;
- status = tcp->wait_status;
- pid = tcp->pid;
-
if (WIFSIGNALED(status)) {
if (pid == strace_child)
exit_code = 0x100 | WTERMSIG(status);
/*
* Interestingly, the process may stop
* with STOPSIG equal to some other signal
- * than SIGSTOP if we happen to attach
+ * than SIGSTOP if we happend to attach
* just before the process takes a signal.
*/
if ((tcp->flags & TCB_STARTUP) && WSTOPSIG(status) == SIGSTOP) {
return -1;
}
}
-/* Add more OSes after you verified it works for them. */
-/* PTRACE_SETOPTIONS may be an enum, not a #define.
- * But sometimes we can test for it by checking PT_SETOPTIONS.
- */
-#if defined LINUX && (defined PTRACE_SETOPTIONS || defined PT_SETOPTIONS)
-# ifndef PTRACE_O_TRACESYSGOOD
-# define PTRACE_O_TRACESYSGOOD 0x00000001
-# endif
-# ifndef PTRACE_O_TRACEEXEC
-# define PTRACE_O_TRACEEXEC 0x00000010
-# endif
-# ifndef PTRACE_EVENT_EXEC
-# define PTRACE_EVENT_EXEC 4
-# endif
- /*
- * Ask kernel to set signo to SIGTRAP | 0x80
- * on ptrace-generated SIGTRAPs, and mark
- * execve's SIGTRAP with PTRACE_EVENT_EXEC.
- */
- if (!ptrace_opts_set) {
- char *p;
- ptrace_opts_set = 1;
-
- /* RHEL 2.6.18 definitely has crippling bugs */
- /* Vanilla and Fedora 2.6.29 seems to work */
- p = utsname_buf.release;
- if (strtoul(p, &p, 10) < 2 || *p != '.')
- goto tracing;
- if (strtoul(++p, &p, 10) < 6 || *p != '.')
- goto tracing;
- if (strtoul(++p, &p, 10) < 29)
- goto tracing;
- /*
- * NB: even if this "succeeds", we can
- * revert back to SIGTRAP if we later see
- * that it didnt really work.
- * Old kernels are known to lie here.
- */
- if (ptrace(PTRACE_SETOPTIONS, pid, (char *) 0,
- (long) (PTRACE_O_TRACESYSGOOD | PTRACE_O_TRACEEXEC)) == 0)
- ptrace_stop_sig = SIGTRAP | 0x80;
- }
-#endif
goto tracing;
}
-#if defined LINUX && (defined PTRACE_SETOPTIONS || defined PT_SETOPTIONS)
- if (ptrace_stop_sig != SIGTRAP && WSTOPSIG(status) == SIGTRAP) {
- /*
- * We told ptrace to report SIGTRAP | 0x80 on this process
- * but got bare SIGTRAP. This can be a genuine SIGTRAP:
- * kill(pid, SIGTRAP), trap insn, etc;
- * but be paranoid about it.
- */
- if (((unsigned)status >> 16) == PTRACE_EVENT_EXEC) {
- /* It's post-exec ptrace stop. Ignore it,
- * we will get syscall exit ptrace stop later.
- */
-#ifdef TCB_WAITEXECVE
- tcp->flags &= ~TCB_WAITEXECVE;
-#endif
- goto tracing;
- } else {
- /* Take a better look... */
- siginfo_t si;
- si.si_signo = 0;
- ptrace(PTRACE_GETSIGINFO, pid, (void*) 0, (long) &si);
- /*
- * Check some fields to make sure we see
- * real SIGTRAP.
- * Otherwise interpret it as ptrace stop.
- * Real SIGTRAPs (int3 insn on x86, kill() etc)
- * have these values:
- * int3: kill -TRAP $pid:
- * si_signo:5 (SIGTRAP) si_signo:5 (SIGTRAP)
- * si_errno:0 si_errno:(?)
- * si_code:128 (SI_KERNEL) si_code:0 (SI_USER)
- * si_pid:0 si_pid:(>0?)
- * si_band:0 si_band:(?)
- * Ptrace stops have garbage there instead.
- */
- if (si.si_signo != SIGTRAP
- || (si.si_code != SI_KERNEL && si.si_code != SI_USER)
- ) {
- fprintf(stderr, "bogus SIGTRAP (si_code:%x), assuming old kernel\n", si.si_code);
- ptrace_stop_sig = SIGTRAP;
- }
- }
- }
-#endif
-
- if (WSTOPSIG(status) != ptrace_stop_sig) {
- /* This isn't a ptrace stop. */
-
+ if (WSTOPSIG(status) != SIGTRAP) {
if (WSTOPSIG(status) == SIGSTOP &&
(tcp->flags & TCB_SIGTRAPPED)) {
/*
/* we handled the STATUS, we are permitted to interrupt now. */
if (interrupted)
return 0;
- if (trace_syscall(tcp) < 0) {
- /* trace_syscall printed incompletely decoded syscall,
- * add error indicator.
- * NB: modulo bugs, errno must be nonzero, do not add
- * "if (err != 0)", this will hide bugs.
+ if (trace_syscall(tcp) < 0 && !tcp->ptrace_errno) {
+ /* ptrace() failed in trace_syscall() with ESRCH.
+ * Likely a result of process disappearing mid-flight.
+ * Observed case: exit_group() terminating
+ * all processes in thread group. In this case, threads
+ * "disappear" in an unpredictable moment without any
+ * notification to strace via wait().
*/
- int err = tcp->ptrace_errno;
- tcp->ptrace_errno = 0;
- if (err == ESRCH)
- tprintf(" <unavailable>");
- else
- tprintf(" <ptrace error %d (%s)>", err, strerror(err));
- printtrailer();
- if (err == ESRCH)
- /* Want to get death report anyway. */
- goto tracing;
- /* Strange error, we dare not continue. */
if (tcp->flags & TCB_ATTACHED) {
+ if (tcp_last) {
+ /* Do we have dangling line "syscall(param, param"?
+ * Finish the line then. We cannot
+ */
+ tcp_last->flags |= TCB_REPRINT;
+ tprintf(" <unfinished ...>");
+ printtrailer();
+ }
detach(tcp, 0);
} else {
- ptrace(PTRACE_KILL, tcp->pid, (char *) 1, SIGTERM);
- /* [why SIGTERM? why not also kill(SIGKILL)?] */
+ ptrace(PTRACE_KILL,
+ tcp->pid, (char *) 1, SIGTERM);
droptcb(tcp);
}
continue;
cleanup();
return -1;
}
- } /* for each tcp */
-
- return 0;
-}
-
-static int
-trace()
-{
- int rc;
- struct tcb *tcbs;
-
- while (nprocs != 0) {
- /* The loop of "wait for one tracee, serve it, repeat"
- * may leave some tracees never served.
- * Kernel provides no guarantees of fairness when you have
- * many waitable tasks.
- * Try strace -f with test/many_looping_threads.c example.
- * To fix it, we collect *all* waitable tasks, then handle
- * them all, then repeat.
- */
- if (interrupted)
- return 0;
- tcbs = collect_stopped_tcbs();
- if (!tcbs)
- break;
- rc = handle_stopped_tcbs(tcbs);
- if (rc)
- return rc;
}
return 0;
}
}
void
-printleader(struct tcb *tcp)
+printleader(tcp)
+struct tcb *tcp;
{
if (tcp_last) {
- int err = tcp_last->ptrace_errno;
- if (err) {
- tcp_last->ptrace_errno = 0;
+ if (tcp_last->ptrace_errno) {
if (tcp_last->flags & TCB_INSYSCALL) {
- if (err == ESRCH)
- tprintf(" <unavailable ...>\n");
- else
- tprintf(" <ptrace error %d (%s) ...>\n", err, strerror(err));
- tcp_last->flags |= TCB_REPRINT;
- } else {
- /* Not sure this branch can ever be reached.
- * Oh well. Using subtly different format
- * (without "?" after "=") to make it
- * noticeable (grep for '= <' in straces).
- */
- if (err == ESRCH)
- tprintf("= <unavailable>\n");
- else
- tprintf("= <ptrace error %d (%s)>\n", err, strerror(err));
+ tprintf(" <unavailable>)");
+ tabto(acolumn);
}
+ tprintf("= ? <unavailable>\n");
+ tcp_last->ptrace_errno = 0;
} else if (!outfname || followfork < 2 || tcp_last == tcp) {
- tprintf(" <unfinished ...>\n");
tcp_last->flags |= TCB_REPRINT;
+ tprintf(" <unfinished ...>\n");
}
}
curcol = 0;
{ -1, TF, sys_aioaread64, "aioaread64" }, /* 417 */
{ -1, TF, sys_aioawrite64, "aioawrite64" }, /* 418 */
{ -1, TF, sys_aiocancel64, "aiocancel64" }, /* 419 */
- { -1, TF, sys_aiofsync, "aiofsync" }, /* 420 */
+ { -1, TF, sys_aiofsync, "aiofsync" }, /* 420 */
#endif
#include <signal.h>
#include <time.h>
#include <errno.h>
-#include <sched.h>
#include <sys/user.h>
#include <sys/syscall.h>
#include <sys/param.h>
#if HAVE_ASM_REG_H
-# if defined (SPARC) || defined (SPARC64)
+#if defined (SPARC) || defined (SPARC64)
# define fpq kernel_fpq
# define fq kernel_fq
# define fpu kernel_fpu
-# endif
-# if defined (SPARC) || defined (SPARC64)
+#endif
+#include <asm/reg.h>
+#if defined (SPARC) || defined (SPARC64)
# undef fpq
# undef fq
# undef fpu
-# endif
+#endif
#endif
#ifdef HAVE_SYS_REG_H
-# include <sys/reg.h>
-# ifndef PTRACE_PEEKUSR
-# define PTRACE_PEEKUSR PTRACE_PEEKUSER
-# endif
+#include <sys/reg.h>
+#ifndef PTRACE_PEEKUSR
+# define PTRACE_PEEKUSR PTRACE_PEEKUSER
+#endif
#elif defined(HAVE_LINUX_PTRACE_H)
-# undef PTRACE_SYSCALL
+#undef PTRACE_SYSCALL
# ifdef HAVE_STRUCT_IA64_FPREG
# define ia64_fpreg XXX_ia64_fpreg
# endif
# ifdef HAVE_STRUCT_PT_ALL_USER_REGS
# define pt_all_user_regs XXX_pt_all_user_regs
# endif
-# include <linux/ptrace.h>
+#include <linux/ptrace.h>
# undef ia64_fpreg
# undef pt_all_user_regs
#endif
}
# elif defined(IA64)
# define IA64_PSR_IS ((long)1 << 34)
- if (upeek(tcp, PT_CR_IPSR, &psr) >= 0)
+ if (upeek (tcp, PT_CR_IPSR, &psr) >= 0)
ia32 = (psr & IA64_PSR_IS) != 0;
if (!(tcp->flags & TCB_INSYSCALL)) {
if (ia32) {
if (upeek(tcp, PT_R1, &scno) < 0) /* orig eax */
return -1;
} else {
- if (upeek(tcp, PT_R15, &scno) < 0)
+ if (upeek (tcp, PT_R15, &scno) < 0)
return -1;
}
/* Check if we return from execve. */
if (tcp->flags & TCB_WAITEXECVE) {
-# if defined PTRACE_GETSIGINFO
- siginfo_t si;
-
- tcp->flags &= ~TCB_WAITEXECVE;
- /* If SIGTRAP is masked, execve's magic SIGTRAP
- * is not delivered. We end up here on a subsequent
- * ptrace stop instead. Luckily, we can check
- * for the type of this SIGTRAP. execve's magic one
- * has 0 (SI_USER) in si.si_code, ptrace stop has 5.
- * (I don't know why 5).
- */
- si.si_code = SI_USER;
- /* If PTRACE_GETSIGINFO fails, we assume it's
- * magic SIGTRAP. Moot anyway, PTRACE_GETSIGINFO
- * doesn't fail.
- */
- ptrace(PTRACE_GETSIGINFO, tcp->pid, (void*) 0, (void*) &si);
- if (si.si_code == SI_USER)
- return 0;
-# else
tcp->flags &= ~TCB_WAITEXECVE;
return 0;
-# endif
}
} else {
/* syscall in progress */
- if (upeek(tcp, PT_R8, &r8) < 0)
+ if (upeek (tcp, PT_R8, &r8) < 0)
return -1;
- if (upeek(tcp, PT_R10, &r10) < 0)
+ if (upeek (tcp, PT_R10, &r10) < 0)
return -1;
}
# elif defined (ARM)
# elif defined (LINUX_MIPSN32)
unsigned long long regs[38];
- if (do_ptrace(PTRACE_GETREGS, tcp, NULL, (long) ®s) < 0)
+ if (ptrace (PTRACE_GETREGS, tcp->pid, NULL, (long) ®s) < 0)
return -1;
a3 = regs[REG_A3];
r2 = regs[REG_V0];
return scno;
}
-/* Called in trace_syscall at each syscall entry and exit.
+/* Called in trace_syscall() at each syscall entry and exit.
* Returns:
- * 0: "ignore this syscall", bail out of trace_syscall silently.
- * 1: ok, continue in trace_syscall.
- * other: error, trace_syscall should print error indicator
+ * 0: "ignore this syscall", bail out of trace_syscall() silently.
+ * 1: ok, continue in trace_syscall().
+ * other: error, trace_syscall() should print error indicator
* ("????" etc) and bail out.
*/
static int
#endif /* LINUX */
#ifdef SUNOS4
- if (do_ptrace(PTRACE_POKEUSER, tcp->pid, (char*)uoff(u_error), error << 24) < 0
- || do_ptrace(PTRACE_POKEUSER, tcp->pid, (char*)uoff(u_rval1), rval) < 0
- ) {
+ if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)uoff(u_error),
+ error << 24) < 0 ||
+ ptrace(PTRACE_POKEUSER, tcp->pid, (char*)uoff(u_rval1), rval) < 0)
return -1;
- }
#endif /* SUNOS4 */
#ifdef SVR4
else
nargs = tcp->u_nargs = MAX_ARGS;
- if (do_ptrace(PTRACE_GETREGS, tcp, NULL, (long) ®s) < 0)
+ if (ptrace (PTRACE_GETREGS, pid, NULL, (long) ®s) < 0)
return -1;
- for (i = 0; i < nargs; i++) {
+ for(i = 0; i < nargs; i++) {
tcp->u_arg[i] = regs[REG_A0 + i];
# if defined (LINUX_MIPSN32)
tcp->ext_arg[i] = regs[REG_A0 + i];
if (tcp->scno >= 0 && tcp->scno < nsyscalls && sysent[tcp->scno].nargs != -1)
nargs = tcp->u_nargs = sysent[tcp->scno].nargs;
else
- nargs = tcp->u_nargs = MAX_ARGS;
- if (nargs > 4) {
- if (upeek(tcp, REG_SP, &sp) < 0)
- return -1;
- for (i = 0; i < 4; i++) {
- if (upeek(tcp, REG_A0 + i, &tcp->u_arg[i])<0)
- return -1;
+ nargs = tcp->u_nargs = MAX_ARGS;
+ if(nargs > 4) {
+ if(upeek(tcp, REG_SP, &sp) < 0)
+ return -1;
+ for(i = 0; i < 4; i++) {
+ if (upeek(tcp, REG_A0 + i, &tcp->u_arg[i])<0)
+ return -1;
}
umoven(tcp, sp+16, (nargs-4) * sizeof(tcp->u_arg[0]),
(char *)(tcp->u_arg + 4));
} else {
- for (i = 0; i < nargs; i++) {
- if (upeek(tcp, REG_A0 + i, &tcp->u_arg[i]) < 0)
- return -1;
+ for(i = 0; i < nargs; i++) {
+ if (upeek(tcp, REG_A0 + i, &tcp->u_arg[i]) < 0)
+ return -1;
}
}
}
if (dtime)
gettimeofday(&tv, NULL);
- /* In code below,
- * res = 1: no error, continue
- * res = 0: return 0 at once (not an error)
- * any other value: error, complain and return the value
- *
- * BTW, why we don't just memorize syscall no. on entry
+ /* BTW, why we don't just memorize syscall no. on entry
* in tcp->something?
*/
scno_good = res = get_scno(tcp);
if (tcp->flags & TCB_REPRINT) {
printleader(tcp);
- if (scno_good != 1) {
- tprintf("<... syscall_?? resumed> ");
- } else {
- if (tcp->scno >= nsyscalls || tcp->scno < 0)
- tprintf("<... syscall_%lu resumed> ", tcp->scno);
- else
- tprintf("<... %s resumed> ", sysent[tcp->scno].sys_name);
- }
- /* [do we need to clear TCB_REPRINT?...] */
+ tprintf("<... ");
+ if (scno_good != 1)
+ tprintf("????");
+ else if (tcp->scno >= nsyscalls || tcp->scno < 0)
+ tprintf("syscall_%lu", tcp->scno);
+ else
+ tprintf("%s", sysent[tcp->scno].sys_name);
+ tprintf(" resumed> ");
}
if (cflag)
if (res != 1) {
tprintf(") ");
tabto(acolumn);
- tprintf("= ?");
- /* line will be finished by error handling code */
+ tprintf("= ? <unavailable>");
+ printtrailer();
tcp->flags &= ~TCB_INSYSCALL;
return res;
}
if (res != 1) {
printleader(tcp);
- tcp->flags &= ~TCB_REPRINT; /* why? */
+ tcp->flags &= ~TCB_REPRINT;
tcp_last = tcp;
if (scno_good != 1)
- tprintf("syscall_??" /* anti-trigraph gap */ "(");
+ tprintf("????" /* anti-trigraph gap */ "(");
else if (tcp->scno >= nsyscalls || tcp->scno < 0)
tprintf("syscall_%lu(", tcp->scno);
else
tprintf("%s(", sysent[tcp->scno].sys_name);
- /* Line will be finished by error handling code. */
+ /*
+ * " <unavailable>" will be added later by the code which
+ * detects ptrace errors.
+ */
tcp->flags |= TCB_INSYSCALL;
return res;
}
#ifdef LINUX
#if defined (SPARC) || defined (SPARC64)
struct regs regs;
- if (do_ptrace(PTRACE_GETREGS, tcp, (char *)®s, 0) < 0)
+ if (ptrace(PTRACE_GETREGS,tcp->pid,(char *)®s,0) < 0)
return -1;
val = regs.r_o1;
#elif defined(SH)
/* Test exit of a child of a TCB_EXITING child where the toplevel process starts
* waiting on it. The middle one gets detached and strace must update the
* toplevel process'es number of attached children to 0.
- *
+ *
* gcc -o test/childthread test/childthread.c -Wall -ggdb2 -pthread;./strace -f ./test/childthread
* It must print: write(1, "OK\n", ...
*/
/* Test handle_group_exit () handling of a thread leader still alive with its
* thread child calling exit_group () and proper passing of the process exit
* code to the process parent of this whole thread group.
- *
+ *
* gcc -o test/leaderkill test/leaderkill.c -Wall -ggdb2 -pthread;./test/leaderkill & pid=$!;sleep 1;strace -o x -q ./strace -f -p $pid
* It must print: write(1, "OK\n", ...
*/
+++ /dev/null
-/* This test is not yet added to Makefile */
-
-#include <stdio.h>
-#include <pthread.h>
-#include <unistd.h>
-#include <sys/types.h>
-#include <signal.h>
-#include <stdlib.h>
-
-static int thd_no;
-
-static void *sub_thd(void *c)
-{
- fprintf(stderr, "sub-thread %d created\n", ++thd_no);
- for (;;)
- getuid();
- return NULL;
-}
-
-int main(int argc, char *argv[])
-{
- int i;
- pthread_t *thd;
- int num_threads = 1;
-
- if (argv[1])
- num_threads = atoi(argv[1]);
-
- thd = malloc(num_threads * sizeof(thd[0]));
- fprintf(stderr, "test start, num_threads:%d...\n", num_threads);
-
- for (i = 0; i < num_threads; i++) {
- pthread_create(&thd[i], NULL, sub_thd, NULL);
- fprintf(stderr, "after pthread_create\n");
- }
-
- /* Exit. This kills all threads */
- return 0;
-}
}
/*
- * Generic ptrace wrapper which tracks ptrace errors
- * by setting tcp->ptrace_errno.
+ * Generic ptrace wrapper which tracks ESRCH errors
+ * by setting tcp->ptrace_errno to ESRCH.
*
* We assume that ESRCH indicates likely process death (SIGKILL?),
* modulo bugs where process somehow ended up not stopped.
* Unfortunately kernel uses ESRCH for that case too. Oh well.
+ *
+ * Currently used by upeek() only.
+ * TODO: use this in all other ptrace() calls while decoding.
*/
-static const char *
-str_PTRACE_xxx(int request)
-{
- const char *s;
- static char msg[sizeof(int) * 3 + sizeof("PTRACE_<%d>")];
-
- s = xlookup(ptrace_cmds, request);
- if (s)
- return s;
- sprintf(msg, "PTRACE_<%d>", request);
- return msg;
-}
-
long
-do_ptrace(int request, struct tcb *tcp, void *addr, long data)
+do_ptrace(int request, struct tcb *tcp, void *addr, void *data)
{
- int err;
long l;
errno = 0;
l = ptrace(request, tcp->pid, addr, data);
- err = errno;
- if (err) {
- tcp->ptrace_errno = err;
- if (err != ESRCH) {
- fprintf(stderr, "strace: ptrace(%s,%u,%p,%lu): %s\n",
- str_PTRACE_xxx(request),
- (int) tcp->pid, addr, data, strerror(err));
- errno = err; /* fprintf can clobber it, restore */
- }
- return -1;
- }
- return l;
-}
-
-static long
-do_ptrace_peekdata(struct tcb *tcp, void *addr, int started)
-{
- int err;
- long l;
-
- errno = 0;
- l = ptrace(PTRACE_PEEKDATA, tcp->pid, addr, 0);
- err = errno;
- if (err) {
- if (started && (err == EPERM || err == EIO)) {
- /* Ran into 'end of memory' - not an error.
- * NB: errno is nonzero, caller uses this to detect
- * "end of string" condition.
- */
- return 0;
- }
- /* If error happens at first call, we have a bogus address. */
- if (addr != NULL && err != EIO) {
- if (err != ESRCH) {
- fprintf(stderr, "strace: ptrace(PTRACE_PEEKDATA,%u,%p,0): %s\n",
- (int) tcp->pid, addr, strerror(err));
- errno = err; /* fprintf can clobber it, restore */
- }
- tcp->ptrace_errno = err;
- return -1;
- }
- }
+ /* Non-ESRCH errors might be our invalid reg/mem accesses,
+ * we do not record them. */
+ if (errno == ESRCH)
+ tcp->ptrace_errno = ESRCH;
return l;
}
-#ifdef SUNOS4
-static long
-do_ptrace5(int request, struct tcb *tcp, void *addr, long data, char *data2)
-{
- int err;
- long l;
-
- errno = 0;
- l = ptrace(request, tcp->pid, addr, data, data2);
- err = errno;
- if (err) {
- tcp->ptrace_errno = err;
- if (err != ESRCH) {
- fprintf(stderr, "strace: ptrace(%s,%u,%p,%lu,%p): %s\n",
- str_PTRACE_xxx(request),
- (int) tcp->pid, addr, data, data2, strerror(err));
- errno = err; /* fprintf can clobber it, restore */
- }
- return -1;
- }
- return l;
-}
-#endif
-
/*
* Used when we want to unblock stopped traced process.
* Should be only used with PTRACE_CONT, PTRACE_DETACH and PTRACE_SYSCALL.
* Otherwise prints error message and returns -1.
*/
int
-ptrace_restart(int request, struct tcb *tcp, int sig)
+ptrace_restart(int op, struct tcb *tcp, int sig)
{
int err;
+ const char *msg;
errno = 0;
- ptrace(request, tcp->pid, (void *) 1, (long) sig);
+ ptrace(op, tcp->pid, (void *) 1, (void *) (long) sig);
err = errno;
if (!err || err == ESRCH)
return 0;
tcp->ptrace_errno = err;
- fprintf(stderr, "strace: ptrace(%s,%u,1,%d): %s\n",
- str_PTRACE_xxx(request),
- (int)tcp->pid, sig, strerror(err));
- errno = err; /* fprintf can clobber it, restore */
+ msg = "SYSCALL";
+ if (op == PTRACE_CONT)
+ msg = "CONT";
+ if (op == PTRACE_DETACH)
+ msg = "DETACH";
+ fprintf(stderr, "strace: ptrace(PTRACE_%s,1,%d): %s\n",
+ msg, sig, strerror(err));
return -1;
}
umoven(struct tcb *tcp, long addr, int len, char *laddr)
{
#ifdef LINUX
+ int pid = tcp->pid;
int n, m;
int started = 0;
union {
/* addr not a multiple of sizeof(long) */
n = addr - (addr & -sizeof(long)); /* residue */
addr &= -sizeof(long); /* residue */
- u.val = do_ptrace_peekdata(tcp, (char *) addr, started);
- if (errno)
- return u.val; /* 0 or -1 */
+ errno = 0;
+ u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
+ if (errno) {
+ if (started && (errno==EPERM || errno==EIO)) {
+ /* Ran into 'end of memory' - stupid "printpath" */
+ return 0;
+ }
+ /* But if not started, we had a bogus address. */
+ if (addr != 0 && errno != EIO && errno != ESRCH)
+ perror("ptrace: umoven");
+ return -1;
+ }
started = 1;
memcpy(laddr, &u.x[n], m = MIN(sizeof(long) - n, len));
addr += sizeof(long), laddr += m, len -= m;
}
while (len) {
- u.val = do_ptrace_peekdata(tcp, (char *) addr, started);
- if (errno)
- return u.val; /* 0 or -1 */
+ errno = 0;
+ u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
+ if (errno) {
+ if (started && (errno==EPERM || errno==EIO)) {
+ /* Ran into 'end of memory' - stupid "printpath" */
+ return 0;
+ }
+ if (addr != 0 && errno != EIO && errno != ESRCH)
+ perror("ptrace: umoven");
+ return -1;
+ }
started = 1;
memcpy(laddr, u.x, m = MIN(sizeof(long), len));
addr += sizeof(long), laddr += m, len -= m;
/* addr not a multiple of sizeof(long) */
n = addr - (addr & -sizeof(long)); /* residue */
addr &= -sizeof(long); /* residue */
- u.val = do_ptrace(PTRACE_PEEKDATA, tcp, (char *) addr, 0);
- if (errno)
+ errno = 0;
+ u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
+ if (errno) {
+ if (errno != ESRCH)
+ perror("umoven");
return -1;
+ }
memcpy(laddr, &u.x[n], m = MIN(sizeof(long) - n, len));
addr += sizeof(long), laddr += m, len -= m;
}
while (len) {
- u.val = do_ptrace(PTRACE_PEEKDATA, tcp, (char *) addr, 0);
- if (errno)
+ errno = 0;
+ u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
+ if (errno) {
+ if (errno != ESRCH)
+ perror("umoven");
return -1;
+ }
memcpy(laddr, u.x, m = MIN(sizeof(long), len));
addr += sizeof(long), laddr += m, len -= m;
}
while (len) {
n = MIN(len, PAGSIZ);
n = MIN(n, ((addr + PAGSIZ) & PAGMASK) - addr);
- if (do_ptrace5(PTRACE_READDATA, tcp, (char *) addr, len, laddr) < 0) {
+ if (ptrace(PTRACE_READDATA, pid,
+ (char *) addr, len, laddr) < 0) {
+ if (errno != ESRCH) {
+ perror("umoven: ptrace(PTRACE_READDATA, ...)");
+ abort();
+ }
return -1;
}
len -= n;
}
#else /* !USE_PROCFS */
int started = 0;
+ int pid = tcp->pid;
int i, n, m;
union {
long val;
/* addr not a multiple of sizeof(long) */
n = addr - (addr & -sizeof(long)); /* residue */
addr &= -sizeof(long); /* residue */
- u.val = do_ptrace_peekdata(tcp, (char *)addr, started);
- if (errno)
- return u.val; /* 0 or -1 */
+ errno = 0;
+ u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
+ if (errno) {
+ if (started && (errno==EPERM || errno==EIO)) {
+ /* Ran into 'end of memory' - stupid "printpath" */
+ return 0;
+ }
+ if (addr != 0 && errno != EIO && errno != ESRCH)
+ perror("umovestr");
+ return -1;
+ }
started = 1;
memcpy(laddr, &u.x[n], m = MIN(sizeof(long)-n,len));
while (n & (sizeof(long) - 1))
addr += sizeof(long), laddr += m, len -= m;
}
while (len) {
- u.val = do_ptrace_peekdata(tcp, (char *)addr, started);
- if (errno)
- return u.val; /* 0 or -1 */
+ errno = 0;
+ u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
+ if (errno) {
+ if (started && (errno==EPERM || errno==EIO)) {
+ /* Ran into 'end of memory' - stupid "printpath" */
+ return 0;
+ }
+ if (addr != 0 && errno != EIO && errno != ESRCH)
+ perror("umovestr");
+ return -1;
+ }
started = 1;
memcpy(laddr, u.x, m = MIN(sizeof(long), len));
for (i = 0; i < sizeof(long); i++)
#ifdef SUNOS4
static int
-uload(int cmd, struct tcb *tcp, long addr, int len, char *laddr)
+uload(cmd, pid, addr, len, laddr)
+int cmd;
+int pid;
+long addr;
+int len;
+char *laddr;
{
# if 0
int n;
while (len) {
n = MIN(len, PAGSIZ);
n = MIN(n, ((addr + PAGSIZ) & PAGMASK) - addr);
- if (do_ptrace5(cmd, tcp, (char *)addr, n, laddr) < 0) {
+ if (ptrace(cmd, pid, (char *)addr, n, laddr) < 0) {
+ perror("uload: ptrace(PTRACE_WRITE, ...)");
return -1;
}
len -= n;
/* addr not a multiple of sizeof(long) */
n = addr - (addr & -sizeof(long)); /* residue */
addr &= -sizeof(long);
- u.val = do_ptrace(peek, tcp, (char *) addr, 0);
- if (errno)
+ errno = 0;
+ u.val = ptrace(peek, pid, (char *) addr, 0);
+ if (errno) {
+ perror("uload: POKE");
return -1;
- m = MIN(sizeof(long) - n;
- memcpy(&u.x[n], laddr, m, len));
- if (do_ptrace(poke, tcp, (char *)addr, u.val) < 0) {
+ }
+ memcpy(&u.x[n], laddr, m = MIN(sizeof(long) - n, len));
+ if (ptrace(poke, pid, (char *)addr, u.val) < 0) {
+ perror("uload: POKE");
return -1;
}
- addr += sizeof(long);
- laddr += m;
- len -= m;
+ addr += sizeof(long), laddr += m, len -= m;
}
- errno = 0;
while (len) {
if (len < sizeof(long))
- u.val = do_ptrace(peek, tcp, (char *) addr, 0);
- m = MIN(sizeof(long), len);
- memcpy(u.x, laddr, m);
- if (errno || do_ptrace(poke, tcp, (char *) addr, u.val) < 0) {
+ u.val = ptrace(peek, pid, (char *) addr, 0);
+ memcpy(u.x, laddr, m = MIN(sizeof(long), len));
+ if (ptrace(poke, pid, (char *) addr, u.val) < 0) {
+ perror("uload: POKE");
return -1;
}
- addr += sizeof(long);
- laddr += m;
- len -= m;
+ addr += sizeof(long), laddr += m, len -= m;
}
# endif
return 0;
}
-static int
-tload(struct tcb *tcp, int addr, int len, char *laddr)
+int
+tload(pid, addr, len, laddr)
+int pid;
+int addr, len;
+char *laddr;
+{
+ return uload(PTRACE_WRITETEXT, pid, addr, len, laddr);
+}
+
+int
+dload(pid, addr, len, laddr)
+int pid;
+int addr;
+int len;
+char *laddr;
{
- return uload(PTRACE_WRITETEXT, tcp, addr, len, laddr);
+ return uload(PTRACE_WRITEDATA, pid, addr, len, laddr);
}
#endif /* SUNOS4 */
#ifndef USE_PROCFS
int
-upeek(struct tcb *tcp, long off, long *res)
+upeek(tcp, off, res)
+struct tcb *tcp;
+long off;
+long *res;
{
long val;
off += 1024;
}
# endif /* SUNOS4_KERNEL_ARCH_KLUDGE */
+ errno = 0;
val = do_ptrace(PTRACE_PEEKUSER, tcp, (char *) off, 0);
- if (errno)
+ if (val == -1 && errno) {
+ if (errno != ESRCH) {
+ char buf[60];
+ sprintf(buf,"upeek: ptrace(PTRACE_PEEKUSER,%d,%lu,0)", tcp->pid, off);
+ perror(buf);
+ }
return -1;
+ }
*res = val;
return 0;
}
return -1;
# elif defined(SPARC) || defined(SPARC64)
struct regs regs;
- if (do_ptrace(PTRACE_GETREGS, tcp, (char *) ®s, 0) < 0)
+ if (ptrace(PTRACE_GETREGS,tcp->pid,(char *)®s,0) < 0)
return -1;
pc = regs.r_pc;
# elif defined(S390) || defined(S390X)
- if (upeek(tcp, PT_PSWADDR, &pc) < 0)
+ if(upeek(tcp,PT_PSWADDR,&pc) < 0)
return -1;
# elif defined(HPPA)
- if (upeek(tcp, PT_IAOQ0, &pc) < 0)
+ if(upeek(tcp,PT_IAOQ0,&pc) < 0)
return -1;
# elif defined(SH)
- if (upeek(tcp, 4*REG_PC, &pc) < 0)
+ if (upeek(tcp, 4*REG_PC ,&pc) < 0)
return -1;
# elif defined(SH64)
if (upeek(tcp, REG_PC ,&pc) < 0)
*/
struct regs regs;
- if (do_ptrace(PTRACE_GETREGS, tcp, (char *) ®s, 0) < 0)
+ if (ptrace(PTRACE_GETREGS, tcp->pid, (char *) ®s, 0) < 0) {
+ perror("getpc: ptrace(PTRACE_GETREGS, ...)");
return -1;
+ }
return regs.r_pc;
#endif /* SUNOS4 */
# elif defined(S390) || defined(S390X)
long psw;
- if (upeek(tcp, PT_PSWADDR, &psw) < 0) {
+ if(upeek(tcp,PT_PSWADDR,&psw) < 0) {
PRINTBADPC;
return;
}
tprintf("[%08lx] ", pc);
# elif defined(SPARC) || defined(SPARC64)
struct regs regs;
- if (do_ptrace(PTRACE_GETREGS, tcp, (char *) ®s, 0) < 0) {
+ if (ptrace(PTRACE_GETREGS,tcp->pid,(char *)®s,0) < 0) {
PRINTBADPC;
return;
}
# elif defined(HPPA)
long pc;
- if (upeek(tcp, PT_IAOQ0, &pc) < 0) {
+ if(upeek(tcp,PT_IAOQ0,&pc) < 0) {
tprintf ("[????????] ");
return;
}
#ifdef SUNOS4
struct regs regs;
- if (do_ptrace(PTRACE_GETREGS, tcp, (char *) ®s, 0) < 0) {
+ if (ptrace(PTRACE_GETREGS, tcp->pid, (char *) ®s, 0) < 0) {
+ perror("printcall: ptrace(PTRACE_GETREGS, ...)");
PRINTBADPC;
return;
}
req = PTRACE_POKEUSER;
} else
ap = ia64_rse_skip_regs(*state, 0);
- if (do_ptrace(req, tcp, ap, val) < 0)
- return -1;
- return 0;
+ errno = 0;
+ ptrace(req, tcp->pid, ap, val);
+ return errno ? -1 : 0;
}
static int
req = PTRACE_POKEUSER;
} else
ap = ia64_rse_skip_regs(*state, 1);
- if (do_ptrace(req, tcp, ap, val) < 0)
- return -1;
- return 0;
+ errno = 0;
+ ptrace(req, tcp->pid, ap, val);
+ return errno ? -1 : 0;
}
/* ia64 does not return the input arguments from functions (and syscalls)
typedef struct regs arg_setup_state;
# define arg_setup(tcp, state) \
- (do_ptrace(PTRACE_GETREGS, tcp, (char *) (state), 0))
+ (ptrace (PTRACE_GETREGS, tcp->pid, (char *) (state), 0))
# define arg_finish_change(tcp, state) \
- (do_ptrace(PTRACE_SETREGS, tcp, (char *) (state), 0))
+ (ptrace (PTRACE_SETREGS, tcp->pid, (char *) (state), 0))
# define get_arg0(tcp, state, valp) (*(valp) = (state)->r_o0, 0)
# define get_arg1(tcp, state, valp) (*(valp) = (state)->r_o1, 0)
(upeek ((tcp), arg1_offset, (valp)))
static int
-set_arg0(struct tcb *tcp, void *cookie, long val)
+set_arg0 (struct tcb *tcp, void *cookie, long val)
{
- return do_ptrace(PTRACE_POKEUSER, tcp, (char*)arg0_offset, val);
+ return ptrace (PTRACE_POKEUSER, tcp->pid, (char*)arg0_offset, val);
}
static int
-set_arg1(struct tcb *tcp, void *cookie, long val)
+set_arg1 (struct tcb *tcp, void *cookie, long val)
{
- return do_ptrace(PTRACE_POKEUSER, tcp, (char*)arg1_offset, val);
+ return ptrace (PTRACE_POKEUSER, tcp->pid, (char*)arg1_offset, val);
}
# endif /* architectures */
fprintf(stderr, "PANIC: TCB already set in pid %u\n", tcp->pid);
return -1;
}
- if (do_ptrace(PTRACE_GETREGS, tcp, (char *)®s, 0) < 0) {
+ if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) {
+ perror("setbpt: ptrace(PTRACE_GETREGS, ...)");
return -1;
}
tcp->baddr = regs.r_o7 + 8;
- tcp->inst[0] = do_ptrace(PTRACE_PEEKTEXT, tcp, (char *)tcp->baddr, 0);
- if (errno)
+ errno = 0;
+ tcp->inst[0] = ptrace(PTRACE_PEEKTEXT, tcp->pid, (char *)tcp->baddr, 0);
+ if(errno) {
+ perror("setbpt: ptrace(PTRACE_PEEKTEXT, ...)");
return -1;
+ }
/*
* XXX - BRUTAL MODE ON
inst <<= 32;
inst |= (tcp->inst[0] & 0xffffffffUL);
# endif
- if (do_ptrace(PTRACE_POKETEXT, tcp, (char *) tcp->baddr, inst) < 0)
+ ptrace(PTRACE_POKETEXT, tcp->pid, (char *) tcp->baddr, inst);
+ if(errno) {
+ perror("setbpt: ptrace(PTRACE_POKETEXT, ...)");
return -1;
+ }
tcp->flags |= TCB_BPTSET;
# else /* !SPARC && !SPARC64 */
if (debug)
fprintf(stderr, "[%d] setting bpt at %lx\n",
tcp->pid, tcp->baddr);
- tcp->inst[0] = do_ptrace(PTRACE_PEEKTEXT, tcp, (char *) tcp->baddr, 0);
- if (errno)
+ tcp->inst[0] = ptrace(PTRACE_PEEKTEXT, tcp->pid,
+ (char *) tcp->baddr, 0);
+ if (errno) {
+ perror("setbpt: ptrace(PTRACE_PEEKTEXT, ...)");
return -1;
- if (do_ptrace(PTRACE_POKETEXT, tcp, (char *) tcp->baddr, LOOP) < 0)
+ }
+ ptrace(PTRACE_POKETEXT, tcp->pid, (char *) tcp->baddr, LOOP);
+ if (errno) {
+ perror("setbpt: ptrace(PTRACE_POKETEXT, ...)");
return -1;
+ }
tcp->flags |= TCB_BPTSET;
} else {
/*
/* store "ri" in low two bits */
tcp->baddr = addr | ((ipsr >> 41) & 0x3);
- tcp->inst[0] = do_ptrace(PTRACE_PEEKTEXT, tcp, (char *) addr + 0, 0);
- if (!errno)
- tcp->inst[1] = do_ptrace(PTRACE_PEEKTEXT, tcp, (char *) addr + 8, 0);
- if (errno)
+ errno = 0;
+ tcp->inst[0] = ptrace(PTRACE_PEEKTEXT, pid, (char *) addr + 0,
+ 0);
+ tcp->inst[1] = ptrace(PTRACE_PEEKTEXT, pid, (char *) addr + 8,
+ 0);
+ if (errno) {
+ perror("setbpt: ptrace(PTRACE_PEEKTEXT, ...)");
return -1;
+ }
- if (do_ptrace(PTRACE_POKETEXT, tcp, (char *) addr + 0, LOOP0) < 0
- || do_ptrace(PTRACE_POKETEXT, tcp, (char *) addr + 8, LOOP1) < 0
- ) {
+ errno = 0;
+ ptrace(PTRACE_POKETEXT, pid, (char *) addr + 0, LOOP0);
+ ptrace(PTRACE_POKETEXT, pid, (char *) addr + 8, LOOP1);
+ if (errno) {
+ perror("setbpt: ptrace(PTRACE_POKETEXT, ...)");
return -1;
}
tcp->flags |= TCB_BPTSET;
# endif
if (debug)
fprintf(stderr, "[%d] setting bpt at %lx\n", tcp->pid, tcp->baddr);
- tcp->inst[0] = do_ptrace(PTRACE_PEEKTEXT, tcp, (char *) tcp->baddr, 0);
- if (errno)
+ tcp->inst[0] = ptrace(PTRACE_PEEKTEXT, tcp->pid, (char *) tcp->baddr, 0);
+ if (errno) {
+ perror("setbpt: ptrace(PTRACE_PEEKTEXT, ...)");
return -1;
- if (do_ptrace(PTRACE_POKETEXT, tcp, (char *) tcp->baddr, LOOP) < 0) {
+ }
+ ptrace(PTRACE_POKETEXT, tcp->pid, (char *) tcp->baddr, LOOP);
+ if (errno) {
+ perror("setbpt: ptrace(PTRACE_POKETEXT, ...)");
return -1;
}
tcp->flags |= TCB_BPTSET;
fprintf(stderr, "PANIC: TCB already set in pid %u\n", tcp->pid);
return -1;
}
- if (do_ptrace(PTRACE_GETREGS, tcp, (char *)®s, 0) < 0) {
+ if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) {
+ perror("setbpt: ptrace(PTRACE_GETREGS, ...)");
return -1;
}
tcp->baddr = regs.r_o7 + 8;
- if (do_ptrace5(PTRACE_READTEXT, tcp, (char *)tcp->baddr,
- sizeof tcp->inst, (char *)tcp->inst, "READTEXT") < 0) {
+ if (ptrace(PTRACE_READTEXT, tcp->pid, (char *)tcp->baddr,
+ sizeof tcp->inst, (char *)tcp->inst) < 0) {
+ perror("setbpt: ptrace(PTRACE_READTEXT, ...)");
return -1;
}
* generated by out PTRACE_ATTACH.
* Of cause, if we evaporate ourselves in the middle of all this...
*/
- if (do_ptrace5(PTRACE_WRITETEXT, tcp, (char *) tcp->baddr,
+ if (ptrace(PTRACE_WRITETEXT, tcp->pid, (char *) tcp->baddr,
sizeof loopdeloop, (char *) loopdeloop) < 0) {
+ perror("setbpt: ptrace(PTRACE_WRITETEXT, ...)");
return -1;
}
tcp->flags |= TCB_BPTSET;
fprintf(stderr, "PANIC: TCB not set in pid %u\n", tcp->pid);
return -1;
}
- if (do_ptrace(PTRACE_POKETEXT, tcp, (char *) tcp->baddr, tcp->inst[0]) < 0) {
+ errno = 0;
+ ptrace(PTRACE_POKETEXT, tcp->pid, (char *) tcp->baddr, tcp->inst[0]);
+ if(errno) {
+ perror("clearbtp: ptrace(PTRACE_POKETEXT, ...)");
return -1;
}
tcp->flags &= ~TCB_BPTSET;
fprintf(stderr, "PANIC: TCB not set in pid %u\n", tcp->pid);
return -1;
}
- if (do_ptrace(PTRACE_POKETEXT, tcp, (char *) tcp->baddr, tcp->inst[0]) < 0) {
+ errno = 0;
+ ptrace(PTRACE_POKETEXT, tcp->pid, (char *) tcp->baddr, tcp->inst[0]);
+ if (errno) {
+ perror("clearbtp: ptrace(PTRACE_POKETEXT, ...)");
return -1;
}
tcp->flags &= ~TCB_BPTSET;
return -1;
/* restore original bundle: */
- if (do_ptrace(PTRACE_POKETEXT, tcp, (char *) addr + 0, tcp->inst[0]) < 0
- || do_ptrace(PTRACE_POKETEXT, tcp, (char *) addr + 8, tcp->inst[1]) < 0
- ) {
+ errno = 0;
+ ptrace(PTRACE_POKETEXT, pid, (char *) addr + 0, tcp->inst[0]);
+ ptrace(PTRACE_POKETEXT, pid, (char *) addr + 8, tcp->inst[1]);
+ if (errno) {
+ perror("clearbpt: ptrace(PTRACE_POKETEXT, ...)");
return -1;
}
/* restore original "ri" in ipsr: */
ipsr = (ipsr & ~(0x3ul << 41)) | ((tcp->baddr & 0x3) << 41);
- if (do_ptrace(PTRACE_POKEUSER, tcp, (char *) PT_CR_IPSR, ipsr) < 0) {
+ errno = 0;
+ ptrace(PTRACE_POKEUSER, pid, (char *) PT_CR_IPSR, ipsr);
+ if (errno) {
+ perror("clrbpt: ptrace(PTRACE_POKEUSER, ...)");
return -1;
}
fprintf(stderr, "PANIC: TCB not set in pid %u\n", tcp->pid);
return -1;
}
- if (do_ptrace(PTRACE_POKETEXT, tcp, (char *) tcp->baddr, tcp->inst[0]) < 0) {
+ errno = 0;
+ ptrace(PTRACE_POKETEXT, tcp->pid, (char *) tcp->baddr, tcp->inst[0]);
+ if (errno) {
+ perror("clearbtp: ptrace(PTRACE_POKETEXT, ...)");
return -1;
}
tcp->flags &= ~TCB_BPTSET;
* safe to set both IAOQ0 and IAOQ1 to that so the PSW N bit
* has no significant effect.
*/
- if (do_ptrace(PTRACE_POKEUSER, tcp, (void *)PT_IAOQ0, iaoq) < 0
- || do_ptrace(PTRACE_POKEUSER, tcp, (void *)PT_IAOQ1, iaoq) < 0
- ) {
- return -1;
- }
+ ptrace(PTRACE_POKEUSER, tcp->pid, (void *)PT_IAOQ0, iaoq);
+ ptrace(PTRACE_POKEUSER, tcp->pid, (void *)PT_IAOQ1, iaoq);
# elif defined(SH)
if (upeek(tcp, 4*REG_PC, &pc) < 0)
return -1;
fprintf(stderr, "PANIC: TCB not set in pid %u\n", tcp->pid);
return -1;
}
- if (do_ptrace5(PTRACE_WRITETEXT, tcp, (char *) tcp->baddr,
+ if (ptrace(PTRACE_WRITETEXT, tcp->pid, (char *) tcp->baddr,
sizeof tcp->inst, (char *) tcp->inst) < 0) {
+ perror("clearbtp: ptrace(PTRACE_WRITETEXT, ...)");
return -1;
}
tcp->flags &= ~TCB_BPTSET;
* Since we don't have a single instruction breakpoint, we may have
* to adjust the program counter after removing our `breakpoint'.
*/
- if (do_ptrace(PTRACE_GETREGS, tcp, (char *)®s, 0) < 0) {
+ if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) {
+ perror("clearbpt: ptrace(PTRACE_GETREGS, ...)");
return -1;
}
- if ((regs.r_pc < tcp->baddr) || (regs.r_pc > tcp->baddr + 4)) {
+ if ((regs.r_pc < tcp->baddr) ||
+ (regs.r_pc > tcp->baddr + 4)) {
/* The breakpoint has not been reached yet */
if (debug)
fprintf(stderr,
regs.r_pc, tcp->baddr);
regs.r_pc = tcp->baddr;
- if (do_ptrace(PTRACE_SETREGS, tcp, (char *)®s, 0) < 0) {
+ if (ptrace(PTRACE_SETREGS, tcp->pid, (char *)®s, 0) < 0) {
+ perror("clearbpt: ptrace(PTRACE_SETREGS, ...)");
return -1;
}
# endif /* LOOPA */
fprintf(stderr, "out of memory\n");
return -1;
}
- if (umoven(tcp, (int)ld.ld_symbols + (int)N_TXTADDR(hdr),
+ if (umoven(tcp, (int)ld.ld_symbols+(int)N_TXTADDR(hdr),
(int)ld.ld_symb_size, strtab) < 0)
goto err;
* Write entire symbol table back to avoid
* memory alignment bugs in ptrace
*/
- if (tload(tcp, (int)ld.ld_symbols + (int)N_TXTADDR(hdr),
+ if (tload(pid, (int)ld.ld_symbols+(int)N_TXTADDR(hdr),
(int)ld.ld_symb_size, strtab) < 0)
goto err;
projects / strace / commitdiff