blob: 04af6b568263ed5bc70a8ffb263d5f2d6ca9684d [file] [log] [blame]
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001/*
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>
Wichert Akkerman4dc8a2a1999-12-23 14:20:14 +00005 * Copyright (c) 1996-1999 Wichert Akkerman <wichert@cistron.nl>
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00006 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. The name of the author may not be used to endorse or promote products
17 * derived from this software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 *
30 * $Id$
31 */
32
33#include "defs.h"
34
Roland McGrath795edb12005-02-02 04:44:57 +000035#include <sys/types.h>
Denys Vlasenko3454e4b2011-05-23 21:29:03 +020036#include <stdarg.h>
Wichert Akkerman76baf7c1999-02-19 00:21:36 +000037#include <signal.h>
38#include <errno.h>
39#include <sys/param.h>
40#include <fcntl.h>
41#include <sys/resource.h>
42#include <sys/wait.h>
43#include <sys/stat.h>
44#include <pwd.h>
45#include <grp.h>
46#include <string.h>
John Hughes19e49982001-10-19 08:59:12 +000047#include <limits.h>
Roland McGrath70b08532004-04-09 00:25:21 +000048#include <dirent.h>
Wichert Akkerman76baf7c1999-02-19 00:21:36 +000049
Roland McGrath134813a2007-06-02 00:07:33 +000050#ifdef LINUX
51# include <asm/unistd.h>
Denys Vlasenko44f87ef2011-08-17 15:18:21 +020052# if defined __NR_tkill
53# define my_tkill(tid, sig) syscall(__NR_tkill, (tid), (sig))
Roland McGrath134813a2007-06-02 00:07:33 +000054# else
55 /* kill() may choose arbitrarily the target task of the process group
56 while we later wait on a that specific TID. PID process waits become
57 TID task specific waits for a process under ptrace(2). */
58# warning "Neither tkill(2) nor tgkill(2) available, risk of strace hangs!"
Denys Vlasenko44f87ef2011-08-17 15:18:21 +020059# define my_tkill(tid, sig) kill((tid), (sig))
Roland McGrath134813a2007-06-02 00:07:33 +000060# endif
61#endif
62
Wichert Akkerman7b3346b2001-10-09 23:47:38 +000063#if defined(IA64) && defined(LINUX)
64# include <asm/ptrace_offsets.h>
65#endif
66
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +000067#ifdef USE_PROCFS
68#include <poll.h>
69#endif
70
Wichert Akkerman76baf7c1999-02-19 00:21:36 +000071#ifdef SVR4
72#include <sys/stropts.h>
Wichert Akkermanea78f0f1999-11-29 15:34:02 +000073#ifdef HAVE_MP_PROCFS
John Hughes1d08dcf2001-07-10 13:48:44 +000074#ifdef HAVE_SYS_UIO_H
Wichert Akkerman9ce1a631999-08-29 23:15:07 +000075#include <sys/uio.h>
76#endif
Wichert Akkerman76baf7c1999-02-19 00:21:36 +000077#endif
John Hughes1d08dcf2001-07-10 13:48:44 +000078#endif
Denys Vlasenko96d5a762008-12-29 19:13:27 +000079extern char **environ;
Denys Vlasenko418d66a2009-01-17 01:52:54 +000080extern int optind;
81extern char *optarg;
Denys Vlasenko96d5a762008-12-29 19:13:27 +000082
Wichert Akkerman76baf7c1999-02-19 00:21:36 +000083
Roland McGrath41c48222008-07-18 00:25:10 +000084int debug = 0, followfork = 0;
Denys Vlasenkof44cce42011-06-21 14:34:10 +020085unsigned int ptrace_setoptions = 0;
Denys Vlasenko3454e4b2011-05-23 21:29:03 +020086/* Which WSTOPSIG(status) value marks syscall traps? */
Denys Vlasenko75422762011-05-27 14:36:01 +020087static unsigned int syscall_trap_sig = SIGTRAP;
Dmitry V. Levine3a7ef52010-03-28 19:24:54 +000088int dtime = 0, xflag = 0, qflag = 0;
89cflag_t cflag = CFLAG_NONE;
Dmitry V. Levinb9fe0112006-12-13 16:59:44 +000090static int iflag = 0, interactive = 0, pflag_seen = 0, rflag = 0, tflag = 0;
Denys Vlasenkoecfe2f12008-12-30 20:51:30 +000091/*
92 * daemonized_tracer supports -D option.
93 * With this option, strace forks twice.
94 * Unlike normal case, with -D *grandparent* process exec's,
95 * becoming a traced process. Child exits (this prevents traced process
96 * from having children it doesn't expect to have), and grandchild
97 * attaches to grandparent similarly to strace -p PID.
98 * This allows for more transparent interaction in cases
99 * when process and its parent are communicating via signals,
100 * wait() etc. Without -D, strace process gets lodged in between,
101 * disrupting parent<->child link.
102 */
103static bool daemonized_tracer = 0;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000104
Michal Ludvig17f8fb32002-11-06 13:17:21 +0000105/* Sometimes we want to print only succeeding syscalls. */
106int not_failing_only = 0;
107
Grant Edwards8a082772011-04-07 20:25:40 +0000108/* Show path associated with fd arguments */
109int show_fd_path = 0;
110
111/* are we filtering traces based on paths? */
112int tracing_paths = 0;
113
Dmitry V. Levina6809652008-11-10 17:14:58 +0000114static int exit_code = 0;
115static int strace_child = 0;
Denys Vlasenko75422762011-05-27 14:36:01 +0200116static int strace_tracer_pid = 0;
Roland McGratheb9e2e82009-06-02 16:49:22 -0700117
Dmitry V. Levinb9fe0112006-12-13 16:59:44 +0000118static char *username = NULL;
Denys Vlasenkoead73bd2011-06-24 22:49:58 +0200119static uid_t run_uid;
120static gid_t run_gid;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000121
122int acolumn = DEFAULT_ACOLUMN;
123int max_strlen = DEFAULT_STRLEN;
Dmitry V. Levinb9fe0112006-12-13 16:59:44 +0000124static char *outfname = NULL;
Denys Vlasenkoead73bd2011-06-24 22:49:58 +0200125static FILE *outf;
Andreas Schwabccdff482009-10-27 16:27:13 +0100126static int curcol;
Denys Vlasenkoead73bd2011-06-24 22:49:58 +0200127static struct tcb **tcbtab;
Denys Vlasenko2b60c352011-06-22 12:45:25 +0200128static unsigned int nprocs, tcbtabsize;
Denys Vlasenkoead73bd2011-06-24 22:49:58 +0200129static const char *progname;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000130
Andreas Schwabe5355de2009-10-27 16:56:43 +0100131static int detach(struct tcb *tcp, int sig);
132static int trace(void);
133static void cleanup(void);
134static void interrupt(int sig);
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000135static sigset_t empty_set, blocked_set;
136
137#ifdef HAVE_SIG_ATOMIC_T
138static volatile sig_atomic_t interrupted;
139#else /* !HAVE_SIG_ATOMIC_T */
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000140static volatile int interrupted;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000141#endif /* !HAVE_SIG_ATOMIC_T */
142
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +0000143#ifdef USE_PROCFS
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000144
Andreas Schwabe5355de2009-10-27 16:56:43 +0100145static struct tcb *pfd2tcb(int pfd);
146static void reaper(int sig);
147static void rebuild_pollv(void);
Roland McGrathee9d4352002-12-18 04:16:10 +0000148static struct pollfd *pollv;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000149
150#ifndef HAVE_POLLABLE_PROCFS
151
Andreas Schwabe5355de2009-10-27 16:56:43 +0100152static void proc_poll_open(void);
153static void proc_poller(int pfd);
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000154
155struct proc_pollfd {
156 int fd;
157 int revents;
158 int pid;
159};
160
161static int poller_pid;
162static int proc_poll_pipe[2] = { -1, -1 };
163
164#endif /* !HAVE_POLLABLE_PROCFS */
165
Wichert Akkermanea78f0f1999-11-29 15:34:02 +0000166#ifdef HAVE_MP_PROCFS
Wichert Akkerman9ce1a631999-08-29 23:15:07 +0000167#define POLLWANT POLLWRNORM
168#else
169#define POLLWANT POLLPRI
170#endif
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +0000171#endif /* USE_PROCFS */
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000172
173static void
Denys Vlasenkocb2ad002011-06-23 13:05:29 +0200174usage(FILE *ofp, int exitval)
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000175{
176 fprintf(ofp, "\
Grant Edwards8a082772011-04-07 20:25:40 +0000177usage: strace [-CdDffhiqrtttTvVxxy] [-a column] [-e expr] ... [-o file]\n\
Roland McGrathde6e5332003-01-24 04:31:23 +0000178 [-p pid] ... [-s strsize] [-u username] [-E var=val] ...\n\
Grant Edwards8a082772011-04-07 20:25:40 +0000179 [-P path] [command [arg ...]]\n\
Andreas Schwabb87d30c2010-06-11 15:49:36 +0200180 or: strace -c [-D] [-e expr] ... [-O overhead] [-S sortby] [-E var=val] ...\n\
Roland McGrathde6e5332003-01-24 04:31:23 +0000181 [command [arg ...]]\n\
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000182-c -- count time, calls, and errors for each syscall and report summary\n\
Andreas Schwabb87d30c2010-06-11 15:49:36 +0200183-C -- like -c but also print regular output while processes are running\n\
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000184-f -- follow forks, -ff -- with output into separate files\n\
185-F -- attempt to follow vforks, -h -- print help message\n\
186-i -- print instruction pointer at time of syscall\n\
187-q -- suppress messages about attaching, detaching, etc.\n\
188-r -- print relative timestamp, -t -- absolute timestamp, -tt -- with usecs\n\
189-T -- print time spent in each syscall, -V -- print version\n\
190-v -- verbose mode: print unabbreviated argv, stat, termio[s], etc. args\n\
191-x -- print non-ascii strings in hex, -xx -- print all strings in hex\n\
Grant Edwards8a082772011-04-07 20:25:40 +0000192-y -- print paths associated with file descriptor arguments\n\
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000193-a column -- alignment COLUMN for printing syscall results (default %d)\n\
194-e expr -- a qualifying expression: option=[!]all or option=[!]val1[,val2]...\n\
195 options: trace, abbrev, verbose, raw, signal, read, or write\n\
196-o file -- send trace output to FILE instead of stderr\n\
197-O overhead -- set overhead for tracing syscalls to OVERHEAD usecs\n\
198-p pid -- trace process with process id PID, may be repeated\n\
Denys Vlasenkoecfe2f12008-12-30 20:51:30 +0000199-D -- run tracer process as a detached grandchild, not as parent\n\
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000200-s strsize -- limit length of print strings to STRSIZE chars (default %d)\n\
201-S sortby -- sort syscall counts by: time, calls, name, nothing (default %s)\n\
202-u username -- run command as username handling setuid and/or setgid\n\
Roland McGrathde6e5332003-01-24 04:31:23 +0000203-E var=val -- put var=val in the environment for command\n\
204-E var -- remove var from the environment for command\n\
Grant Edwards8a082772011-04-07 20:25:40 +0000205-P path -- trace accesses to path\n\
Roland McGrathde6e5332003-01-24 04:31:23 +0000206" /* this is broken, so don't document it
Michal Ludvig17f8fb32002-11-06 13:17:21 +0000207-z -- print only succeeding syscalls\n\
Roland McGrathde6e5332003-01-24 04:31:23 +0000208 */
209, DEFAULT_ACOLUMN, DEFAULT_STRLEN, DEFAULT_SORTBY);
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000210 exit(exitval);
211}
212
Denys Vlasenko75422762011-05-27 14:36:01 +0200213static void die(void) __attribute__ ((noreturn));
214static void die(void)
215{
216 if (strace_tracer_pid == getpid()) {
217 cflag = 0;
218 cleanup();
219 }
220 exit(1);
221}
222
223static void verror_msg(int err_no, const char *fmt, va_list p)
Denys Vlasenko3454e4b2011-05-23 21:29:03 +0200224{
Dmitry V. Levin44d05322011-06-09 15:50:41 +0000225 fflush(NULL);
226 fprintf(stderr, "%s: ", progname);
227 vfprintf(stderr, fmt, p);
228 if (err_no)
229 fprintf(stderr, ": %s\n", strerror(err_no));
230 else
231 putc('\n', stderr);
232 fflush(stderr);
Denys Vlasenko75422762011-05-27 14:36:01 +0200233}
Denys Vlasenko3454e4b2011-05-23 21:29:03 +0200234
Denys Vlasenko75422762011-05-27 14:36:01 +0200235void error_msg(const char *fmt, ...)
236{
237 va_list p;
238 va_start(p, fmt);
239 verror_msg(0, fmt, p);
240 va_end(p);
241}
242
243void error_msg_and_die(const char *fmt, ...)
244{
245 va_list p;
246 va_start(p, fmt);
247 verror_msg(0, fmt, p);
248 die();
249}
250
251void perror_msg(const char *fmt, ...)
252{
253 va_list p;
254 va_start(p, fmt);
255 verror_msg(errno, fmt, p);
256 va_end(p);
257}
258
259void perror_msg_and_die(const char *fmt, ...)
260{
261 va_list p;
262 va_start(p, fmt);
263 verror_msg(errno, fmt, p);
264 die();
Denys Vlasenko3454e4b2011-05-23 21:29:03 +0200265}
266
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000267#ifdef SVR4
268#ifdef MIPS
269void
270foobar()
271{
272}
273#endif /* MIPS */
274#endif /* SVR4 */
275
Mike Frysingerc1a5b7e2009-10-07 20:41:29 -0400276/* Glue for systems without a MMU that cannot provide fork() */
277#ifdef HAVE_FORK
278# define strace_vforked 0
279#else
280# define strace_vforked 1
281# define fork() vfork()
282#endif
283
Denys Vlasenko1f532ab2011-06-22 13:11:23 +0200284static void
Dmitry V. Levin10de62b2006-12-13 21:45:31 +0000285set_cloexec_flag(int fd)
286{
Denys Vlasenko1f532ab2011-06-22 13:11:23 +0200287 int flags, newflags;
Dmitry V. Levin10de62b2006-12-13 21:45:31 +0000288
Denys Vlasenko1f532ab2011-06-22 13:11:23 +0200289 flags = fcntl(fd, F_GETFD);
290 if (flags < 0) {
291 /* Can happen only if fd is bad.
292 * Should never happen: if it does, we have a bug
293 * in the caller. Therefore we just abort
294 * instead of propagating the error.
295 */
296 perror_msg_and_die("fcntl(%d, F_GETFD)", fd);
Dmitry V. Levin10de62b2006-12-13 21:45:31 +0000297 }
298
299 newflags = flags | FD_CLOEXEC;
300 if (flags == newflags)
Denys Vlasenko1f532ab2011-06-22 13:11:23 +0200301 return;
Dmitry V. Levin10de62b2006-12-13 21:45:31 +0000302
Denys Vlasenko1f532ab2011-06-22 13:11:23 +0200303 fcntl(fd, F_SETFD, newflags); /* never fails */
Dmitry V. Levin10de62b2006-12-13 21:45:31 +0000304}
305
306/*
307 * When strace is setuid executable, we have to swap uids
308 * before and after filesystem and process management operations.
309 */
310static void
311swap_uid(void)
312{
313#ifndef SVR4
314 int euid = geteuid(), uid = getuid();
315
Denys Vlasenko7b609d52011-06-22 14:32:43 +0200316 if (euid != uid && setreuid(euid, uid) < 0) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +0200317 perror_msg_and_die("setreuid");
Dmitry V. Levin10de62b2006-12-13 21:45:31 +0000318 }
319#endif
320}
321
Roland McGrath4bfa6262007-07-05 20:03:16 +0000322#if _LFS64_LARGEFILE
323# define fopen_for_output fopen64
324#else
325# define fopen_for_output fopen
326#endif
327
Dmitry V. Levin10de62b2006-12-13 21:45:31 +0000328static FILE *
Denys Vlasenko3d5ed412011-06-22 13:17:16 +0200329strace_fopen(const char *path)
Dmitry V. Levin10de62b2006-12-13 21:45:31 +0000330{
331 FILE *fp;
332
333 swap_uid();
Denys Vlasenko3d5ed412011-06-22 13:17:16 +0200334 fp = fopen_for_output(path, "w");
335 if (!fp)
336 perror_msg_and_die("Can't fopen '%s'", path);
Dmitry V. Levin10de62b2006-12-13 21:45:31 +0000337 swap_uid();
Denys Vlasenko3d5ed412011-06-22 13:17:16 +0200338 set_cloexec_flag(fileno(fp));
Dmitry V. Levin10de62b2006-12-13 21:45:31 +0000339 return fp;
340}
341
Denys Vlasenko7dd23382011-06-22 13:03:56 +0200342static int popen_pid = 0;
Dmitry V. Levin10de62b2006-12-13 21:45:31 +0000343
344#ifndef _PATH_BSHELL
345# define _PATH_BSHELL "/bin/sh"
346#endif
347
348/*
349 * We cannot use standard popen(3) here because we have to distinguish
350 * popen child process from other processes we trace, and standard popen(3)
351 * does not export its child's pid.
352 */
353static FILE *
354strace_popen(const char *command)
355{
Denys Vlasenko7dd23382011-06-22 13:03:56 +0200356 FILE *fp;
357 int fds[2];
Dmitry V. Levin10de62b2006-12-13 21:45:31 +0000358
359 swap_uid();
360 if (pipe(fds) < 0)
Denys Vlasenko7dd23382011-06-22 13:03:56 +0200361 perror_msg_and_die("pipe");
Dmitry V. Levin10de62b2006-12-13 21:45:31 +0000362
Denys Vlasenko7dd23382011-06-22 13:03:56 +0200363 set_cloexec_flag(fds[1]); /* never fails */
Dmitry V. Levin10de62b2006-12-13 21:45:31 +0000364
Denys Vlasenko7dd23382011-06-22 13:03:56 +0200365 popen_pid = vfork();
366 if (popen_pid == -1)
367 perror_msg_and_die("vfork");
Dmitry V. Levin10de62b2006-12-13 21:45:31 +0000368
Denys Vlasenko7dd23382011-06-22 13:03:56 +0200369 if (popen_pid == 0) {
Dmitry V. Levin10de62b2006-12-13 21:45:31 +0000370 /* child */
371 close(fds[1]);
Denys Vlasenko7dd23382011-06-22 13:03:56 +0200372 if (fds[0] != 0) {
373 if (dup2(fds[0], 0))
374 perror_msg_and_die("dup2");
375 close(fds[0]);
Dmitry V. Levin10de62b2006-12-13 21:45:31 +0000376 }
377 execl(_PATH_BSHELL, "sh", "-c", command, NULL);
Denys Vlasenko7dd23382011-06-22 13:03:56 +0200378 perror_msg_and_die("Can't execute '%s'", _PATH_BSHELL);
Dmitry V. Levin10de62b2006-12-13 21:45:31 +0000379 }
Denys Vlasenko7dd23382011-06-22 13:03:56 +0200380
381 /* parent */
382 close(fds[0]);
383 swap_uid();
384 fp = fdopen(fds[1], "w");
385 if (!fp)
386 error_msg_and_die("Out of memory");
387 return fp;
Dmitry V. Levin10de62b2006-12-13 21:45:31 +0000388}
389
Denys Vlasenko3d5ed412011-06-22 13:17:16 +0200390static void
Dmitry V. Levin10de62b2006-12-13 21:45:31 +0000391newoutf(struct tcb *tcp)
392{
393 if (outfname && followfork > 1) {
Denys Vlasenko7a8bf062009-01-29 20:38:20 +0000394 char name[520 + sizeof(int) * 3];
Denys Vlasenko7a8bf062009-01-29 20:38:20 +0000395 sprintf(name, "%.512s.%u", outfname, tcp->pid);
Denys Vlasenko3d5ed412011-06-22 13:17:16 +0200396 tcp->outf = strace_fopen(name);
Dmitry V. Levin10de62b2006-12-13 21:45:31 +0000397 }
Dmitry V. Levin10de62b2006-12-13 21:45:31 +0000398}
399
Roland McGrath02203312007-06-11 22:06:31 +0000400static void
401startup_attach(void)
402{
403 int tcbi;
404 struct tcb *tcp;
405
406 /*
407 * Block user interruptions as we would leave the traced
408 * process stopped (process state T) if we would terminate in
409 * between PTRACE_ATTACH and wait4 () on SIGSTOP.
Denys Vlasenkob63256e2011-06-07 12:13:24 +0200410 * We rely on cleanup() from this point on.
Roland McGrath02203312007-06-11 22:06:31 +0000411 */
412 if (interactive)
413 sigprocmask(SIG_BLOCK, &blocked_set, NULL);
414
Denys Vlasenkoecfe2f12008-12-30 20:51:30 +0000415 if (daemonized_tracer) {
416 pid_t pid = fork();
417 if (pid < 0) {
418 _exit(1);
419 }
420 if (pid) { /* parent */
421 /*
Denys Vlasenko75422762011-05-27 14:36:01 +0200422 * Wait for grandchild to attach to straced process
423 * (grandparent). Grandchild SIGKILLs us after it attached.
424 * Grandparent's wait() is unblocked by our death,
Denys Vlasenkoecfe2f12008-12-30 20:51:30 +0000425 * it proceeds to exec the straced program.
426 */
427 pause();
428 _exit(0); /* paranoia */
429 }
Denys Vlasenko75422762011-05-27 14:36:01 +0200430 /* grandchild */
431 /* We will be the tracer process. Remember our new pid: */
432 strace_tracer_pid = getpid();
Denys Vlasenkoecfe2f12008-12-30 20:51:30 +0000433 }
434
Roland McGrath02203312007-06-11 22:06:31 +0000435 for (tcbi = 0; tcbi < tcbtabsize; tcbi++) {
436 tcp = tcbtab[tcbi];
Denys Vlasenko44f87ef2011-08-17 15:18:21 +0200437
Roland McGrath02203312007-06-11 22:06:31 +0000438 if (!(tcp->flags & TCB_INUSE) || !(tcp->flags & TCB_ATTACHED))
439 continue;
440#ifdef LINUX
Denys Vlasenko44f87ef2011-08-17 15:18:21 +0200441 if (tcp->flags & TCB_ATTACH_DONE)
Roland McGrath02203312007-06-11 22:06:31 +0000442 continue;
443#endif
444 /* Reinitialize the output since it may have changed. */
445 tcp->outf = outf;
Denys Vlasenko3d5ed412011-06-22 13:17:16 +0200446 newoutf(tcp);
Roland McGrath02203312007-06-11 22:06:31 +0000447
448#ifdef USE_PROCFS
449 if (proc_open(tcp, 1) < 0) {
450 fprintf(stderr, "trouble opening proc file\n");
451 droptcb(tcp);
452 continue;
453 }
454#else /* !USE_PROCFS */
455# ifdef LINUX
Denys Vlasenkoecfe2f12008-12-30 20:51:30 +0000456 if (followfork && !daemonized_tracer) {
Denys Vlasenko7a8bf062009-01-29 20:38:20 +0000457 char procdir[sizeof("/proc/%d/task") + sizeof(int) * 3];
Roland McGrath02203312007-06-11 22:06:31 +0000458 DIR *dir;
459
460 sprintf(procdir, "/proc/%d/task", tcp->pid);
461 dir = opendir(procdir);
462 if (dir != NULL) {
463 unsigned int ntid = 0, nerr = 0;
464 struct dirent *de;
465 int tid;
466 while ((de = readdir(dir)) != NULL) {
Denys Vlasenko7a8bf062009-01-29 20:38:20 +0000467 if (de->d_fileno == 0)
Roland McGrath02203312007-06-11 22:06:31 +0000468 continue;
469 tid = atoi(de->d_name);
470 if (tid <= 0)
471 continue;
472 ++ntid;
Denys Vlasenkof95397a2011-06-24 16:51:16 +0200473 if (ptrace(PTRACE_ATTACH, tid, (char *) 1, 0) < 0) {
Roland McGrath02203312007-06-11 22:06:31 +0000474 ++nerr;
Denys Vlasenkof95397a2011-06-24 16:51:16 +0200475 if (debug)
476 fprintf(stderr, "attach to pid %d failed\n", tid);
477 }
478 else {
479 if (debug)
480 fprintf(stderr, "attach to pid %d succeeded\n", tid);
Denys Vlasenko44f87ef2011-08-17 15:18:21 +0200481 if (tid != tcp->pid) {
482 struct tcb *new_tcp = alloctcb(tid);
483 new_tcp->flags |= TCB_ATTACHED|TCB_ATTACH_DONE;
Denys Vlasenkof95397a2011-06-24 16:51:16 +0200484 }
Roland McGrath02203312007-06-11 22:06:31 +0000485 }
Denys Vlasenkoaab52ca2009-03-17 14:46:54 +0000486 if (interactive) {
487 sigprocmask(SIG_SETMASK, &empty_set, NULL);
488 if (interrupted)
Denys Vlasenko44f87ef2011-08-17 15:18:21 +0200489 goto ret;
Denys Vlasenkoaab52ca2009-03-17 14:46:54 +0000490 sigprocmask(SIG_BLOCK, &blocked_set, NULL);
491 }
Roland McGrath02203312007-06-11 22:06:31 +0000492 }
493 closedir(dir);
Denys Vlasenko7a8bf062009-01-29 20:38:20 +0000494 ntid -= nerr;
495 if (ntid == 0) {
Roland McGrath02203312007-06-11 22:06:31 +0000496 perror("attach: ptrace(PTRACE_ATTACH, ...)");
497 droptcb(tcp);
498 continue;
499 }
500 if (!qflag) {
Denys Vlasenko7a8bf062009-01-29 20:38:20 +0000501 fprintf(stderr, ntid > 1
502? "Process %u attached with %u threads - interrupt to quit\n"
503: "Process %u attached - interrupt to quit\n",
Denys Vlasenko44f87ef2011-08-17 15:18:21 +0200504 tcp->pid, ntid);
Roland McGrath02203312007-06-11 22:06:31 +0000505 }
506 continue;
Denys Vlasenko7a8bf062009-01-29 20:38:20 +0000507 } /* if (opendir worked) */
508 } /* if (-f) */
Denys Vlasenko44f87ef2011-08-17 15:18:21 +0200509# endif /* LINUX */
Roland McGrath02203312007-06-11 22:06:31 +0000510 if (ptrace(PTRACE_ATTACH, tcp->pid, (char *) 1, 0) < 0) {
511 perror("attach: ptrace(PTRACE_ATTACH, ...)");
512 droptcb(tcp);
513 continue;
514 }
Denys Vlasenkof95397a2011-06-24 16:51:16 +0200515 if (debug)
516 fprintf(stderr, "attach to pid %d (main) succeeded\n", tcp->pid);
Denys Vlasenkoecfe2f12008-12-30 20:51:30 +0000517
518 if (daemonized_tracer) {
519 /*
520 * It is our grandparent we trace, not a -p PID.
521 * Don't want to just detach on exit, so...
522 */
523 tcp->flags &= ~TCB_ATTACHED;
524 /*
525 * Make parent go away.
526 * Also makes grandparent's wait() unblock.
527 */
528 kill(getppid(), SIGKILL);
529 }
530
Roland McGrath02203312007-06-11 22:06:31 +0000531#endif /* !USE_PROCFS */
532 if (!qflag)
533 fprintf(stderr,
534 "Process %u attached - interrupt to quit\n",
535 tcp->pid);
Denys Vlasenkof95397a2011-06-24 16:51:16 +0200536 } /* for each tcbtab[] */
Roland McGrath02203312007-06-11 22:06:31 +0000537
Denys Vlasenko44f87ef2011-08-17 15:18:21 +0200538 ret:
539#ifdef LINUX
540 /* TCB_ATTACH_DONE flag is used only in this function */
541 for (tcbi = 0; tcbi < tcbtabsize; tcbi++) {
542 tcp = tcbtab[tcbi];
543 tcp->flags &= ~TCB_ATTACH_DONE;
544 }
545#endif
546
Roland McGrath02203312007-06-11 22:06:31 +0000547 if (interactive)
548 sigprocmask(SIG_SETMASK, &empty_set, NULL);
549}
550
551static void
Denys Vlasenko12014262011-05-30 14:00:14 +0200552startup_child(char **argv)
Roland McGrath02203312007-06-11 22:06:31 +0000553{
554 struct stat statbuf;
555 const char *filename;
556 char pathname[MAXPATHLEN];
557 int pid = 0;
558 struct tcb *tcp;
559
560 filename = argv[0];
561 if (strchr(filename, '/')) {
562 if (strlen(filename) > sizeof pathname - 1) {
563 errno = ENAMETOOLONG;
Denys Vlasenkocb2ad002011-06-23 13:05:29 +0200564 perror_msg_and_die("exec");
Roland McGrath02203312007-06-11 22:06:31 +0000565 }
566 strcpy(pathname, filename);
567 }
568#ifdef USE_DEBUGGING_EXEC
569 /*
570 * Debuggers customarily check the current directory
571 * first regardless of the path but doing that gives
572 * security geeks a panic attack.
573 */
574 else if (stat(filename, &statbuf) == 0)
575 strcpy(pathname, filename);
576#endif /* USE_DEBUGGING_EXEC */
577 else {
Dmitry V. Levin30145dd2010-09-06 22:08:24 +0000578 const char *path;
Roland McGrath02203312007-06-11 22:06:31 +0000579 int m, n, len;
580
581 for (path = getenv("PATH"); path && *path; path += m) {
582 if (strchr(path, ':')) {
583 n = strchr(path, ':') - path;
584 m = n + 1;
585 }
586 else
587 m = n = strlen(path);
588 if (n == 0) {
589 if (!getcwd(pathname, MAXPATHLEN))
590 continue;
591 len = strlen(pathname);
592 }
593 else if (n > sizeof pathname - 1)
594 continue;
595 else {
596 strncpy(pathname, path, n);
597 len = n;
598 }
599 if (len && pathname[len - 1] != '/')
600 pathname[len++] = '/';
601 strcpy(pathname + len, filename);
602 if (stat(pathname, &statbuf) == 0 &&
603 /* Accept only regular files
604 with some execute bits set.
605 XXX not perfect, might still fail */
606 S_ISREG(statbuf.st_mode) &&
607 (statbuf.st_mode & 0111))
608 break;
609 }
610 }
611 if (stat(pathname, &statbuf) < 0) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +0200612 perror_msg_and_die("Can't stat '%s'", filename);
Roland McGrath02203312007-06-11 22:06:31 +0000613 }
Dmitry V. Levina6809652008-11-10 17:14:58 +0000614 strace_child = pid = fork();
Denys Vlasenkoecfe2f12008-12-30 20:51:30 +0000615 if (pid < 0) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +0200616 perror_msg_and_die("fork");
Denys Vlasenkoecfe2f12008-12-30 20:51:30 +0000617 }
Denys Vlasenko75422762011-05-27 14:36:01 +0200618 if ((pid != 0 && daemonized_tracer) /* -D: parent to become a traced process */
619 || (pid == 0 && !daemonized_tracer) /* not -D: child to become a traced process */
Denys Vlasenkoecfe2f12008-12-30 20:51:30 +0000620 ) {
621 pid = getpid();
Roland McGrath02203312007-06-11 22:06:31 +0000622#ifdef USE_PROCFS
Denys Vlasenkob63256e2011-06-07 12:13:24 +0200623 if (outf != stderr) close(fileno(outf));
Roland McGrath02203312007-06-11 22:06:31 +0000624#ifdef MIPS
625 /* Kludge for SGI, see proc_open for details. */
626 sa.sa_handler = foobar;
627 sa.sa_flags = 0;
628 sigemptyset(&sa.sa_mask);
629 sigaction(SIGINT, &sa, NULL);
630#endif /* MIPS */
631#ifndef FREEBSD
632 pause();
633#else /* FREEBSD */
Denys Vlasenkoecfe2f12008-12-30 20:51:30 +0000634 kill(pid, SIGSTOP); /* stop HERE */
Roland McGrath02203312007-06-11 22:06:31 +0000635#endif /* FREEBSD */
636#else /* !USE_PROCFS */
Denys Vlasenkob63256e2011-06-07 12:13:24 +0200637 if (outf != stderr)
638 close(fileno(outf));
Roland McGrath02203312007-06-11 22:06:31 +0000639
Denys Vlasenkoecfe2f12008-12-30 20:51:30 +0000640 if (!daemonized_tracer) {
641 if (ptrace(PTRACE_TRACEME, 0, (char *) 1, 0) < 0) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +0200642 perror_msg_and_die("ptrace(PTRACE_TRACEME, ...)");
Denys Vlasenkoecfe2f12008-12-30 20:51:30 +0000643 }
644 if (debug)
645 kill(pid, SIGSTOP);
Roland McGrath02203312007-06-11 22:06:31 +0000646 }
Roland McGrath02203312007-06-11 22:06:31 +0000647
648 if (username != NULL || geteuid() == 0) {
649 uid_t run_euid = run_uid;
650 gid_t run_egid = run_gid;
651
652 if (statbuf.st_mode & S_ISUID)
653 run_euid = statbuf.st_uid;
654 if (statbuf.st_mode & S_ISGID)
655 run_egid = statbuf.st_gid;
656
657 /*
658 * It is important to set groups before we
659 * lose privileges on setuid.
660 */
661 if (username != NULL) {
662 if (initgroups(username, run_gid) < 0) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +0200663 perror_msg_and_die("initgroups");
Roland McGrath02203312007-06-11 22:06:31 +0000664 }
665 if (setregid(run_gid, run_egid) < 0) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +0200666 perror_msg_and_die("setregid");
Roland McGrath02203312007-06-11 22:06:31 +0000667 }
668 if (setreuid(run_uid, run_euid) < 0) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +0200669 perror_msg_and_die("setreuid");
Roland McGrath02203312007-06-11 22:06:31 +0000670 }
671 }
672 }
673 else
674 setreuid(run_uid, run_uid);
675
Denys Vlasenkoecfe2f12008-12-30 20:51:30 +0000676 if (!daemonized_tracer) {
677 /*
678 * Induce an immediate stop so that the parent
679 * will resume us with PTRACE_SYSCALL and display
680 * this execve call normally.
Mike Frysingerc1a5b7e2009-10-07 20:41:29 -0400681 * Unless of course we're on a no-MMU system where
682 * we vfork()-ed, so we cannot stop the child.
Denys Vlasenkoecfe2f12008-12-30 20:51:30 +0000683 */
Mike Frysingerc1a5b7e2009-10-07 20:41:29 -0400684 if (!strace_vforked)
685 kill(getpid(), SIGSTOP);
Denys Vlasenkoecfe2f12008-12-30 20:51:30 +0000686 } else {
687 struct sigaction sv_sigchld;
688 sigaction(SIGCHLD, NULL, &sv_sigchld);
689 /*
690 * Make sure it is not SIG_IGN, otherwise wait
691 * will not block.
692 */
693 signal(SIGCHLD, SIG_DFL);
694 /*
695 * Wait for grandchild to attach to us.
696 * It kills child after that, and wait() unblocks.
697 */
698 alarm(3);
699 wait(NULL);
700 alarm(0);
701 sigaction(SIGCHLD, &sv_sigchld, NULL);
702 }
Roland McGrath02203312007-06-11 22:06:31 +0000703#endif /* !USE_PROCFS */
704
705 execv(pathname, argv);
Denys Vlasenkocb2ad002011-06-23 13:05:29 +0200706 perror_msg_and_die("exec");
Roland McGrath02203312007-06-11 22:06:31 +0000707 }
Denys Vlasenkoecfe2f12008-12-30 20:51:30 +0000708
709 /* We are the tracer. */
Denys Vlasenko75422762011-05-27 14:36:01 +0200710 /* With -D, we are *child* here, IOW: different pid. Fetch it. */
711 strace_tracer_pid = getpid();
712
Denys Vlasenkoecfe2f12008-12-30 20:51:30 +0000713 tcp = alloctcb(daemonized_tracer ? getppid() : pid);
Denys Vlasenkoecfe2f12008-12-30 20:51:30 +0000714 if (daemonized_tracer) {
715 /* We want subsequent startup_attach() to attach to it. */
716 tcp->flags |= TCB_ATTACHED;
717 }
Roland McGrath02203312007-06-11 22:06:31 +0000718#ifdef USE_PROCFS
Denys Vlasenkoecfe2f12008-12-30 20:51:30 +0000719 if (proc_open(tcp, 0) < 0) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +0200720 perror_msg_and_die("trouble opening proc file");
Roland McGrath02203312007-06-11 22:06:31 +0000721 }
Denys Vlasenkoecfe2f12008-12-30 20:51:30 +0000722#endif /* USE_PROCFS */
Roland McGrath02203312007-06-11 22:06:31 +0000723}
724
Wang Chaob13c0de2010-11-12 17:25:19 +0800725#ifdef LINUX
Dmitry V. Levin04f8b482011-08-16 18:57:29 +0000726static void kill_save_errno(pid_t pid, int sig)
727{
728 int saved_errno = errno;
729
730 (void) kill(pid, sig);
731 errno = saved_errno;
732}
733
Wang Chaob13c0de2010-11-12 17:25:19 +0800734/*
Dmitry V. Levinb1467442010-12-02 20:56:43 +0000735 * Test whether the kernel support PTRACE_O_TRACECLONE et al options.
Wang Chaob13c0de2010-11-12 17:25:19 +0800736 * First fork a new child, call ptrace with PTRACE_SETOPTIONS on it,
Dmitry V. Levinb1467442010-12-02 20:56:43 +0000737 * and then see which options are supported by the kernel.
Wang Chaob13c0de2010-11-12 17:25:19 +0800738 */
Dmitry V. Levin04f8b482011-08-16 18:57:29 +0000739static void
Denys Vlasenko3454e4b2011-05-23 21:29:03 +0200740test_ptrace_setoptions_followfork(void)
Wang Chaob13c0de2010-11-12 17:25:19 +0800741{
Dmitry V. Levin2fabd0e2011-02-19 21:33:50 +0000742 int pid, expected_grandchild = 0, found_grandchild = 0;
743 const unsigned int test_options = PTRACE_O_TRACECLONE |
744 PTRACE_O_TRACEFORK |
745 PTRACE_O_TRACEVFORK;
Wang Chaob13c0de2010-11-12 17:25:19 +0800746
Denys Vlasenko5d645812011-08-20 12:48:18 +0200747 pid = fork();
748 if (pid < 0)
Dmitry V. Levin04f8b482011-08-16 18:57:29 +0000749 perror_msg_and_die("fork");
Denys Vlasenko5d645812011-08-20 12:48:18 +0200750 if (pid == 0) {
Dmitry V. Levin04f8b482011-08-16 18:57:29 +0000751 pid = getpid();
752 if (ptrace(PTRACE_TRACEME, 0, 0, 0) < 0)
753 perror_msg_and_die("%s: PTRACE_TRACEME doesn't work",
754 __func__);
755 kill(pid, SIGSTOP);
756 if (fork() < 0)
757 perror_msg_and_die("fork");
758 _exit(0);
Wang Chaob13c0de2010-11-12 17:25:19 +0800759 }
Dmitry V. Levinb1467442010-12-02 20:56:43 +0000760
761 while (1) {
762 int status, tracee_pid;
763
Dmitry V. Levin04f8b482011-08-16 18:57:29 +0000764 errno = 0;
Dmitry V. Levinb1467442010-12-02 20:56:43 +0000765 tracee_pid = wait(&status);
Dmitry V. Levin04f8b482011-08-16 18:57:29 +0000766 if (tracee_pid <= 0) {
Dmitry V. Levinb1467442010-12-02 20:56:43 +0000767 if (errno == EINTR)
768 continue;
769 else if (errno == ECHILD)
770 break;
Dmitry V. Levin04f8b482011-08-16 18:57:29 +0000771 kill_save_errno(pid, SIGKILL);
772 perror_msg_and_die("%s: unexpected wait result %d",
773 __func__, tracee_pid);
774 }
775 if (WIFEXITED(status)) {
776 if (WEXITSTATUS(status)) {
777 if (tracee_pid != pid)
778 kill_save_errno(pid, SIGKILL);
779 error_msg_and_die("%s: unexpected exit status %u",
780 __func__, WEXITSTATUS(status));
781 }
782 continue;
783 }
784 if (WIFSIGNALED(status)) {
785 if (tracee_pid != pid)
786 kill_save_errno(pid, SIGKILL);
787 error_msg_and_die("%s: unexpected signal %u",
788 __func__, WTERMSIG(status));
789 }
790 if (!WIFSTOPPED(status)) {
791 if (tracee_pid != pid)
792 kill_save_errno(tracee_pid, SIGKILL);
793 kill(pid, SIGKILL);
794 error_msg_and_die("%s: unexpected wait status %x",
795 __func__, status);
Dmitry V. Levinb1467442010-12-02 20:56:43 +0000796 }
797 if (tracee_pid != pid) {
Dmitry V. Levin2fabd0e2011-02-19 21:33:50 +0000798 found_grandchild = tracee_pid;
Dmitry V. Levin04f8b482011-08-16 18:57:29 +0000799 if (ptrace(PTRACE_CONT, tracee_pid, 0, 0) < 0) {
800 kill_save_errno(tracee_pid, SIGKILL);
801 kill_save_errno(pid, SIGKILL);
802 perror_msg_and_die("PTRACE_CONT doesn't work");
Wang Chaob13c0de2010-11-12 17:25:19 +0800803 }
Dmitry V. Levin04f8b482011-08-16 18:57:29 +0000804 continue;
805 }
806 switch (WSTOPSIG(status)) {
807 case SIGSTOP:
808 if (ptrace(PTRACE_SETOPTIONS, pid, 0, test_options) < 0
809 && errno != EINVAL && errno != EIO)
810 perror_msg("PTRACE_SETOPTIONS");
811 break;
812 case SIGTRAP:
813 if (status >> 16 == PTRACE_EVENT_FORK) {
814 long msg = 0;
815
816 if (ptrace(PTRACE_GETEVENTMSG, pid,
817 NULL, (long) &msg) == 0)
818 expected_grandchild = msg;
819 }
820 break;
821 }
822 if (ptrace(PTRACE_SYSCALL, pid, 0, 0) < 0) {
823 kill_save_errno(pid, SIGKILL);
824 perror_msg_and_die("PTRACE_SYSCALL doesn't work");
Wang Chaob13c0de2010-11-12 17:25:19 +0800825 }
826 }
Dmitry V. Levin04f8b482011-08-16 18:57:29 +0000827 if (expected_grandchild && expected_grandchild == found_grandchild) {
Denys Vlasenkof44cce42011-06-21 14:34:10 +0200828 ptrace_setoptions |= test_options;
Dmitry V. Levin04f8b482011-08-16 18:57:29 +0000829 if (debug)
830 fprintf(stderr, "ptrace_setoptions = %#x\n",
831 ptrace_setoptions);
832 return;
833 }
834 error_msg("Test for PTRACE_O_TRACECLONE failed, "
835 "giving up using this feature.");
Wang Chaob13c0de2010-11-12 17:25:19 +0800836}
Denys Vlasenko3454e4b2011-05-23 21:29:03 +0200837
838/*
839 * Test whether the kernel support PTRACE_O_TRACESYSGOOD.
840 * First fork a new child, call ptrace(PTRACE_SETOPTIONS) on it,
841 * and then see whether it will stop with (SIGTRAP | 0x80).
842 *
843 * Use of this option enables correct handling of user-generated SIGTRAPs,
844 * and SIGTRAPs generated by special instructions such as int3 on x86:
845 * _start: .globl _start
846 * int3
847 * movl $42, %ebx
848 * movl $1, %eax
849 * int $0x80
850 * (compile with: "gcc -nostartfiles -nostdlib -o int3 int3.S")
851 */
852static void
853test_ptrace_setoptions_for_all(void)
854{
Dmitry V. Levin04f8b482011-08-16 18:57:29 +0000855 const unsigned int test_options = PTRACE_O_TRACESYSGOOD |
856 PTRACE_O_TRACEEXEC;
Denys Vlasenko3454e4b2011-05-23 21:29:03 +0200857 int pid;
858 int it_worked = 0;
859
860 pid = fork();
861 if (pid < 0)
Denys Vlasenko75422762011-05-27 14:36:01 +0200862 perror_msg_and_die("fork");
Denys Vlasenko3454e4b2011-05-23 21:29:03 +0200863
864 if (pid == 0) {
865 pid = getpid();
866 if (ptrace(PTRACE_TRACEME, 0L, 0L, 0L) < 0)
Denys Vlasenko75422762011-05-27 14:36:01 +0200867 /* Note: exits with exitcode 1 */
Dmitry V. Levin04f8b482011-08-16 18:57:29 +0000868 perror_msg_and_die("%s: PTRACE_TRACEME doesn't work",
869 __func__);
Denys Vlasenko3454e4b2011-05-23 21:29:03 +0200870 kill(pid, SIGSTOP);
871 _exit(0); /* parent should see entry into this syscall */
872 }
873
874 while (1) {
875 int status, tracee_pid;
876
877 errno = 0;
878 tracee_pid = wait(&status);
879 if (tracee_pid <= 0) {
880 if (errno == EINTR)
881 continue;
Dmitry V. Levin04f8b482011-08-16 18:57:29 +0000882 kill_save_errno(pid, SIGKILL);
883 perror_msg_and_die("%s: unexpected wait result %d",
884 __func__, tracee_pid);
Denys Vlasenko3454e4b2011-05-23 21:29:03 +0200885 }
Denys Vlasenko75422762011-05-27 14:36:01 +0200886 if (WIFEXITED(status)) {
887 if (WEXITSTATUS(status) == 0)
888 break;
Dmitry V. Levin04f8b482011-08-16 18:57:29 +0000889 error_msg_and_die("%s: unexpected exit status %u",
890 __func__, WEXITSTATUS(status));
891 }
892 if (WIFSIGNALED(status)) {
893 error_msg_and_die("%s: unexpected signal %u",
894 __func__, WTERMSIG(status));
Denys Vlasenko75422762011-05-27 14:36:01 +0200895 }
Denys Vlasenko3454e4b2011-05-23 21:29:03 +0200896 if (!WIFSTOPPED(status)) {
897 kill(pid, SIGKILL);
Dmitry V. Levin04f8b482011-08-16 18:57:29 +0000898 error_msg_and_die("%s: unexpected wait status %x",
899 __func__, status);
Denys Vlasenko3454e4b2011-05-23 21:29:03 +0200900 }
901 if (WSTOPSIG(status) == SIGSTOP) {
902 /*
903 * We don't check "options aren't accepted" error.
904 * If it happens, we'll never get (SIGTRAP | 0x80),
905 * and thus will decide to not use the option.
906 * IOW: the outcome of the test will be correct.
907 */
Dmitry V. Levin04f8b482011-08-16 18:57:29 +0000908 if (ptrace(PTRACE_SETOPTIONS, pid, 0L, test_options) < 0
909 && errno != EINVAL && errno != EIO)
910 perror_msg("PTRACE_SETOPTIONS");
Denys Vlasenko3454e4b2011-05-23 21:29:03 +0200911 }
912 if (WSTOPSIG(status) == (SIGTRAP | 0x80)) {
913 it_worked = 1;
914 }
915 if (ptrace(PTRACE_SYSCALL, pid, 0L, 0L) < 0) {
Dmitry V. Levin04f8b482011-08-16 18:57:29 +0000916 kill_save_errno(pid, SIGKILL);
Denys Vlasenko75422762011-05-27 14:36:01 +0200917 perror_msg_and_die("PTRACE_SYSCALL doesn't work");
Denys Vlasenko3454e4b2011-05-23 21:29:03 +0200918 }
919 }
920
921 if (it_worked) {
Denys Vlasenko75422762011-05-27 14:36:01 +0200922 syscall_trap_sig = (SIGTRAP | 0x80);
Denys Vlasenkof44cce42011-06-21 14:34:10 +0200923 ptrace_setoptions |= test_options;
Denys Vlasenko3454e4b2011-05-23 21:29:03 +0200924 if (debug)
Denys Vlasenkof44cce42011-06-21 14:34:10 +0200925 fprintf(stderr, "ptrace_setoptions = %#x\n",
926 ptrace_setoptions);
Denys Vlasenko3454e4b2011-05-23 21:29:03 +0200927 return;
928 }
929
Dmitry V. Levin04f8b482011-08-16 18:57:29 +0000930 error_msg("Test for PTRACE_O_TRACESYSGOOD failed, "
931 "giving up using this feature.");
Denys Vlasenko3454e4b2011-05-23 21:29:03 +0200932}
Wang Chaob13c0de2010-11-12 17:25:19 +0800933#endif
934
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000935int
Dmitry V. Levin08b623e2007-10-08 21:04:41 +0000936main(int argc, char *argv[])
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000937{
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000938 struct tcb *tcp;
939 int c, pid = 0;
Dmitry V. Levin06350db2008-07-25 15:42:34 +0000940 int optF = 0;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000941 struct sigaction sa;
942
Dmitry V. Levin08b623e2007-10-08 21:04:41 +0000943 progname = argv[0] ? argv[0] : "strace";
944
Denys Vlasenko75422762011-05-27 14:36:01 +0200945 strace_tracer_pid = getpid();
946
Roland McGrathee9d4352002-12-18 04:16:10 +0000947 /* Allocate the initial tcbtab. */
948 tcbtabsize = argc; /* Surely enough for all -p args. */
Denys Vlasenko4f12af22011-06-23 13:16:23 +0200949 tcbtab = calloc(tcbtabsize, sizeof(tcbtab[0]));
Denys Vlasenkocb2ad002011-06-23 13:05:29 +0200950 if (tcbtab == NULL)
951 error_msg_and_die("Out of memory");
Denys Vlasenko4f12af22011-06-23 13:16:23 +0200952 tcp = calloc(tcbtabsize, sizeof(*tcp));
953 if (tcp == NULL)
Denys Vlasenkocb2ad002011-06-23 13:05:29 +0200954 error_msg_and_die("Out of memory");
Denys Vlasenko4f12af22011-06-23 13:16:23 +0200955 for (c = 0; c < tcbtabsize; c++)
956 tcbtab[c] = tcp++;
Roland McGrathee9d4352002-12-18 04:16:10 +0000957
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000958 outf = stderr;
959 interactive = 1;
Roland McGrath138c6a32006-01-12 09:50:49 +0000960 set_sortby(DEFAULT_SORTBY);
961 set_personality(DEFAULT_PERSONALITY);
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000962 qualify("trace=all");
963 qualify("abbrev=all");
964 qualify("verbose=all");
965 qualify("signal=all");
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000966 while ((c = getopt(argc, argv,
Grant Edwards8a082772011-04-07 20:25:40 +0000967 "+cCdfFhiqrtTvVxyz"
Denys Vlasenkoecfe2f12008-12-30 20:51:30 +0000968#ifndef USE_PROCFS
969 "D"
970#endif
Grant Edwards8a082772011-04-07 20:25:40 +0000971 "a:e:o:O:p:s:S:u:E:P:")) != EOF) {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000972 switch (c) {
973 case 'c':
Dmitry V. Levine3a7ef52010-03-28 19:24:54 +0000974 if (cflag == CFLAG_BOTH) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +0200975 error_msg_and_die("-c and -C are mutually exclusive options");
Dmitry V. Levine3a7ef52010-03-28 19:24:54 +0000976 }
977 cflag = CFLAG_ONLY_STATS;
978 break;
979 case 'C':
980 if (cflag == CFLAG_ONLY_STATS) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +0200981 error_msg_and_die("-c and -C are mutually exclusive options");
Dmitry V. Levine3a7ef52010-03-28 19:24:54 +0000982 }
983 cflag = CFLAG_BOTH;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000984 break;
985 case 'd':
986 debug++;
987 break;
Denys Vlasenkoecfe2f12008-12-30 20:51:30 +0000988#ifndef USE_PROCFS
Denys Vlasenkoecfe2f12008-12-30 20:51:30 +0000989 case 'D':
990 daemonized_tracer = 1;
991 break;
992#endif
Roland McGrath41c48222008-07-18 00:25:10 +0000993 case 'F':
Dmitry V. Levin06350db2008-07-25 15:42:34 +0000994 optF = 1;
995 break;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000996 case 'f':
997 followfork++;
998 break;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000999 case 'h':
1000 usage(stdout, 0);
1001 break;
1002 case 'i':
1003 iflag++;
1004 break;
1005 case 'q':
1006 qflag++;
1007 break;
1008 case 'r':
1009 rflag++;
1010 tflag++;
1011 break;
1012 case 't':
1013 tflag++;
1014 break;
1015 case 'T':
1016 dtime++;
1017 break;
1018 case 'x':
1019 xflag++;
1020 break;
Grant Edwards8a082772011-04-07 20:25:40 +00001021 case 'y':
1022 show_fd_path = 1;
1023 break;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001024 case 'v':
1025 qualify("abbrev=none");
1026 break;
1027 case 'V':
Roland McGrath9c9a2532003-02-20 02:56:29 +00001028 printf("%s -- version %s\n", PACKAGE_NAME, VERSION);
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001029 exit(0);
1030 break;
Michal Ludvig17f8fb32002-11-06 13:17:21 +00001031 case 'z':
1032 not_failing_only = 1;
1033 break;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001034 case 'a':
1035 acolumn = atoi(optarg);
1036 break;
1037 case 'e':
1038 qualify(optarg);
1039 break;
1040 case 'o':
1041 outfname = strdup(optarg);
1042 break;
1043 case 'O':
1044 set_overhead(atoi(optarg));
1045 break;
1046 case 'p':
Denys Vlasenko5d645812011-08-20 12:48:18 +02001047 pid = atoi(optarg);
1048 if (pid <= 0) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +02001049 error_msg("Invalid process id: '%s'", optarg);
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001050 break;
1051 }
Denys Vlasenko75422762011-05-27 14:36:01 +02001052 if (pid == strace_tracer_pid) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +02001053 error_msg("I'm sorry, I can't let you do that, Dave.");
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001054 break;
1055 }
Denys Vlasenko418d66a2009-01-17 01:52:54 +00001056 tcp = alloc_tcb(pid, 0);
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001057 tcp->flags |= TCB_ATTACHED;
1058 pflag_seen++;
1059 break;
Grant Edwards8a082772011-04-07 20:25:40 +00001060 case 'P':
1061 tracing_paths = 1;
1062 if (pathtrace_select(optarg)) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +02001063 error_msg_and_die("Failed to select path '%s'", optarg);
Grant Edwards8a082772011-04-07 20:25:40 +00001064 }
1065 break;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001066 case 's':
1067 max_strlen = atoi(optarg);
Roland McGrathdccec722005-05-09 07:45:47 +00001068 if (max_strlen < 0) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +02001069 error_msg_and_die("Invalid -s argument: '%s'", optarg);
Roland McGrathdccec722005-05-09 07:45:47 +00001070 }
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001071 break;
1072 case 'S':
1073 set_sortby(optarg);
1074 break;
1075 case 'u':
1076 username = strdup(optarg);
1077 break;
Roland McGrathde6e5332003-01-24 04:31:23 +00001078 case 'E':
1079 if (putenv(optarg) < 0) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +02001080 error_msg_and_die("Out of memory");
Roland McGrathde6e5332003-01-24 04:31:23 +00001081 }
1082 break;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001083 default:
1084 usage(stderr, 1);
1085 break;
1086 }
1087 }
1088
Roland McGrathd0c4c0c2006-04-25 07:39:40 +00001089 if ((optind == argc) == !pflag_seen)
Roland McGrathce0d1542003-11-11 21:24:23 +00001090 usage(stderr, 1);
1091
Wang Chaod322a4b2010-08-05 14:30:11 +08001092 if (pflag_seen && daemonized_tracer) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +02001093 error_msg_and_die("-D and -p are mutually exclusive options");
Wang Chaod322a4b2010-08-05 14:30:11 +08001094 }
1095
Dmitry V. Levin06350db2008-07-25 15:42:34 +00001096 if (!followfork)
1097 followfork = optF;
1098
Roland McGrathcb9def62006-04-25 07:48:03 +00001099 if (followfork > 1 && cflag) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +02001100 error_msg_and_die("(-c or -C) and -ff are mutually exclusive options");
Roland McGrathcb9def62006-04-25 07:48:03 +00001101 }
1102
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001103 /* See if they want to run as another user. */
1104 if (username != NULL) {
1105 struct passwd *pent;
1106
1107 if (getuid() != 0 || geteuid() != 0) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +02001108 error_msg_and_die("You must be root to use the -u option");
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001109 }
Denys Vlasenko5d645812011-08-20 12:48:18 +02001110 pent = getpwnam(username);
1111 if (pent == NULL) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +02001112 error_msg_and_die("Cannot find user '%s'", username);
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001113 }
1114 run_uid = pent->pw_uid;
1115 run_gid = pent->pw_gid;
1116 }
1117 else {
1118 run_uid = getuid();
1119 run_gid = getgid();
1120 }
1121
Dmitry V. Levin8044bc12010-12-07 12:50:49 +00001122#ifdef LINUX
Dmitry V. Levin04f8b482011-08-16 18:57:29 +00001123 if (followfork)
1124 test_ptrace_setoptions_followfork();
Denys Vlasenko3454e4b2011-05-23 21:29:03 +02001125 test_ptrace_setoptions_for_all();
Dmitry V. Levin8044bc12010-12-07 12:50:49 +00001126#endif
1127
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001128 /* Check if they want to redirect the output. */
1129 if (outfname) {
Roland McGrath37b9a662003-11-07 02:26:54 +00001130 /* See if they want to pipe the output. */
1131 if (outfname[0] == '|' || outfname[0] == '!') {
1132 /*
1133 * We can't do the <outfname>.PID funny business
1134 * when using popen, so prohibit it.
1135 */
Denys Vlasenko7dd23382011-06-22 13:03:56 +02001136 if (followfork > 1)
1137 error_msg_and_die("Piping the output and -ff are mutually exclusive");
1138 outf = strace_popen(outfname + 1);
Roland McGrath37b9a662003-11-07 02:26:54 +00001139 }
Denys Vlasenko3d5ed412011-06-22 13:17:16 +02001140 else if (followfork <= 1)
1141 outf = strace_fopen(outfname);
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001142 }
1143
Denys Vlasenkocb2ad002011-06-23 13:05:29 +02001144 if (!outfname || outfname[0] == '|' || outfname[0] == '!') {
1145 static char buf[BUFSIZ];
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001146 setvbuf(outf, buf, _IOLBF, BUFSIZ);
Denys Vlasenkocb2ad002011-06-23 13:05:29 +02001147 }
Roland McGrath37b9a662003-11-07 02:26:54 +00001148 if (outfname && optind < argc) {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001149 interactive = 0;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001150 qflag = 1;
Roland McGrath36931052003-06-03 01:35:20 +00001151 }
Wang Chaob13c0de2010-11-12 17:25:19 +08001152
Roland McGrath54cc1c82007-11-03 23:34:11 +00001153 /* Valid states here:
1154 optind < argc pflag_seen outfname interactive
1155 1 0 0 1
1156 0 1 0 1
1157 1 0 1 0
1158 0 1 1 1
1159 */
1160
1161 /* STARTUP_CHILD must be called before the signal handlers get
1162 installed below as they are inherited into the spawned process.
1163 Also we do not need to be protected by them as during interruption
1164 in the STARTUP_CHILD mode we kill the spawned process anyway. */
1165 if (!pflag_seen)
1166 startup_child(&argv[optind]);
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001167
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001168 sigemptyset(&empty_set);
1169 sigemptyset(&blocked_set);
1170 sa.sa_handler = SIG_IGN;
1171 sigemptyset(&sa.sa_mask);
1172 sa.sa_flags = 0;
1173 sigaction(SIGTTOU, &sa, NULL);
1174 sigaction(SIGTTIN, &sa, NULL);
1175 if (interactive) {
1176 sigaddset(&blocked_set, SIGHUP);
1177 sigaddset(&blocked_set, SIGINT);
1178 sigaddset(&blocked_set, SIGQUIT);
1179 sigaddset(&blocked_set, SIGPIPE);
1180 sigaddset(&blocked_set, SIGTERM);
1181 sa.sa_handler = interrupt;
1182#ifdef SUNOS4
1183 /* POSIX signals on sunos4.1 are a little broken. */
1184 sa.sa_flags = SA_INTERRUPT;
1185#endif /* SUNOS4 */
1186 }
1187 sigaction(SIGHUP, &sa, NULL);
1188 sigaction(SIGINT, &sa, NULL);
1189 sigaction(SIGQUIT, &sa, NULL);
1190 sigaction(SIGPIPE, &sa, NULL);
1191 sigaction(SIGTERM, &sa, NULL);
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001192#ifdef USE_PROCFS
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001193 sa.sa_handler = reaper;
1194 sigaction(SIGCHLD, &sa, NULL);
Roland McGrath553a6092002-12-16 20:40:39 +00001195#else
1196 /* Make sure SIGCHLD has the default action so that waitpid
1197 definitely works without losing track of children. The user
1198 should not have given us a bogus state to inherit, but he might
1199 have. Arguably we should detect SIG_IGN here and pass it on
1200 to children, but probably noone really needs that. */
1201 sa.sa_handler = SIG_DFL;
1202 sigaction(SIGCHLD, &sa, NULL);
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001203#endif /* USE_PROCFS */
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001204
Denys Vlasenkoecfe2f12008-12-30 20:51:30 +00001205 if (pflag_seen || daemonized_tracer)
Roland McGrath02203312007-06-11 22:06:31 +00001206 startup_attach();
Roland McGrath02203312007-06-11 22:06:31 +00001207
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001208 if (trace() < 0)
1209 exit(1);
1210 cleanup();
Dmitry V. Levina6809652008-11-10 17:14:58 +00001211 fflush(NULL);
1212 if (exit_code > 0xff) {
1213 /* Child was killed by a signal, mimic that. */
1214 exit_code &= 0xff;
1215 signal(exit_code, SIG_DFL);
1216 raise(exit_code);
1217 /* Paranoia - what if this signal is not fatal?
1218 Exit with 128 + signo then. */
1219 exit_code += 128;
1220 }
1221 exit(exit_code);
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001222}
1223
Denys Vlasenko2b60c352011-06-22 12:45:25 +02001224static void
Denys Vlasenko418d66a2009-01-17 01:52:54 +00001225expand_tcbtab(void)
Roland McGrath7b54a7a2004-06-04 01:50:45 +00001226{
1227 /* Allocate some more TCBs and expand the table.
1228 We don't want to relocate the TCBs because our
1229 callers have pointers and it would be a pain.
1230 So tcbtab is a table of pointers. Since we never
1231 free the TCBs, we allocate a single chunk of many. */
Denys Vlasenko18da2732011-06-22 12:41:57 +02001232 int i = tcbtabsize;
1233 struct tcb *newtcbs = calloc(tcbtabsize, sizeof(newtcbs[0]));
1234 struct tcb **newtab = realloc(tcbtab, tcbtabsize * 2 * sizeof(tcbtab[0]));
1235 if (newtab == NULL || newtcbs == NULL)
Denys Vlasenkocfd364b2011-08-20 13:41:13 +02001236 error_msg_and_die("Out of memory");
Roland McGrath7b54a7a2004-06-04 01:50:45 +00001237 tcbtabsize *= 2;
1238 tcbtab = newtab;
Denys Vlasenko18da2732011-06-22 12:41:57 +02001239 while (i < tcbtabsize)
1240 tcbtab[i++] = newtcbs++;
Roland McGrath7b54a7a2004-06-04 01:50:45 +00001241}
1242
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001243struct tcb *
Dmitry V. Levin10de62b2006-12-13 21:45:31 +00001244alloc_tcb(int pid, int command_options_parsed)
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001245{
1246 int i;
1247 struct tcb *tcp;
1248
Denys Vlasenko418d66a2009-01-17 01:52:54 +00001249 if (nprocs == tcbtabsize)
1250 expand_tcbtab();
1251
Roland McGrathee9d4352002-12-18 04:16:10 +00001252 for (i = 0; i < tcbtabsize; i++) {
1253 tcp = tcbtab[i];
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001254 if ((tcp->flags & TCB_INUSE) == 0) {
Denys Vlasenko18da2732011-06-22 12:41:57 +02001255 memset(tcp, 0, sizeof(*tcp));
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001256 tcp->pid = pid;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001257 tcp->flags = TCB_INUSE | TCB_STARTUP;
1258 tcp->outf = outf; /* Initialise to current out file */
Denys Vlasenko8dc0c8c2011-08-20 13:44:56 +02001259#ifdef USE_PROCFS
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001260 tcp->pfd = -1;
Denys Vlasenko8dc0c8c2011-08-20 13:44:56 +02001261#endif
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001262 nprocs++;
Denys Vlasenko1d5f12e2011-06-24 16:41:35 +02001263 if (debug)
1264 fprintf(stderr, "new tcb for pid %d, active tcbs:%d\n", tcp->pid, nprocs);
Dmitry V. Levin10de62b2006-12-13 21:45:31 +00001265 if (command_options_parsed)
1266 newoutf(tcp);
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001267 return tcp;
1268 }
1269 }
Denys Vlasenko18da2732011-06-22 12:41:57 +02001270 error_msg_and_die("bug in alloc_tcb");
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001271}
1272
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001273#ifdef USE_PROCFS
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001274int
Denys Vlasenko418d66a2009-01-17 01:52:54 +00001275proc_open(struct tcb *tcp, int attaching)
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001276{
1277 char proc[32];
1278 long arg;
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001279#ifdef SVR4
John Hughes19e49982001-10-19 08:59:12 +00001280 int i;
1281 sysset_t syscalls;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001282 sigset_t signals;
1283 fltset_t faults;
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001284#endif
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001285#ifndef HAVE_POLLABLE_PROCFS
1286 static int last_pfd;
1287#endif
1288
Wichert Akkermanea78f0f1999-11-29 15:34:02 +00001289#ifdef HAVE_MP_PROCFS
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001290 /* Open the process pseudo-files in /proc. */
1291 sprintf(proc, "/proc/%d/ctl", tcp->pid);
Denys Vlasenko5d645812011-08-20 12:48:18 +02001292 tcp->pfd = open(proc, O_WRONLY|O_EXCL);
1293 if (tcp->pfd < 0) {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001294 perror("strace: open(\"/proc/...\", ...)");
1295 return -1;
1296 }
Denys Vlasenko1f532ab2011-06-22 13:11:23 +02001297 set_cloexec_flag(tcp->pfd);
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001298 sprintf(proc, "/proc/%d/status", tcp->pid);
Denys Vlasenko5d645812011-08-20 12:48:18 +02001299 tcp->pfd_stat = open(proc, O_RDONLY|O_EXCL);
1300 if (tcp->pfd_stat < 0) {
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001301 perror("strace: open(\"/proc/...\", ...)");
1302 return -1;
1303 }
Denys Vlasenko1f532ab2011-06-22 13:11:23 +02001304 set_cloexec_flag(tcp->pfd_stat);
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001305 sprintf(proc, "/proc/%d/as", tcp->pid);
Denys Vlasenko5d645812011-08-20 12:48:18 +02001306 tcp->pfd_as = open(proc, O_RDONLY|O_EXCL);
1307 if (tcp->pfd_as < 0) {
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001308 perror("strace: open(\"/proc/...\", ...)");
1309 return -1;
1310 }
Denys Vlasenko1f532ab2011-06-22 13:11:23 +02001311 set_cloexec_flag(tcp->pfd_as);
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001312#else
1313 /* Open the process pseudo-file in /proc. */
Denys Vlasenko0890c8a2011-08-21 00:10:45 +02001314# ifndef FREEBSD
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001315 sprintf(proc, "/proc/%d", tcp->pid);
Andreas Schwab372cc842010-07-09 11:49:27 +02001316 tcp->pfd = open(proc, O_RDWR|O_EXCL);
Denys Vlasenko0890c8a2011-08-21 00:10:45 +02001317# else
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001318 sprintf(proc, "/proc/%d/mem", tcp->pid);
Andreas Schwab372cc842010-07-09 11:49:27 +02001319 tcp->pfd = open(proc, O_RDWR);
Denys Vlasenko0890c8a2011-08-21 00:10:45 +02001320# endif
Andreas Schwab372cc842010-07-09 11:49:27 +02001321 if (tcp->pfd < 0) {
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001322 perror("strace: open(\"/proc/...\", ...)");
1323 return -1;
1324 }
Denys Vlasenko1f532ab2011-06-22 13:11:23 +02001325 set_cloexec_flag(tcp->pfd);
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001326#endif
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001327#ifdef FREEBSD
1328 sprintf(proc, "/proc/%d/regs", tcp->pid);
Denys Vlasenko5d645812011-08-20 12:48:18 +02001329 tcp->pfd_reg = open(proc, O_RDONLY);
1330 if (tcp->pfd_reg < 0) {
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001331 perror("strace: open(\"/proc/.../regs\", ...)");
1332 return -1;
1333 }
1334 if (cflag) {
1335 sprintf(proc, "/proc/%d/status", tcp->pid);
Denys Vlasenko5d645812011-08-20 12:48:18 +02001336 tcp->pfd_status = open(proc, O_RDONLY);
1337 if (tcp->pfd_status < 0) {
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001338 perror("strace: open(\"/proc/.../status\", ...)");
1339 return -1;
1340 }
1341 } else
1342 tcp->pfd_status = -1;
1343#endif /* FREEBSD */
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001344 rebuild_pollv();
1345 if (!attaching) {
1346 /*
1347 * Wait for the child to pause. Because of a race
1348 * condition we have to poll for the event.
1349 */
1350 for (;;) {
Denys Vlasenkob63256e2011-06-07 12:13:24 +02001351 if (IOCTL_STATUS(tcp) < 0) {
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001352 perror("strace: PIOCSTATUS");
1353 return -1;
1354 }
1355 if (tcp->status.PR_FLAGS & PR_ASLEEP)
Denys Vlasenkocb2ad002011-06-23 13:05:29 +02001356 break;
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001357 }
1358 }
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001359#ifndef FREEBSD
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001360 /* Stop the process so that we own the stop. */
Wichert Akkerman16a03d22000-08-10 02:14:04 +00001361 if (IOCTL(tcp->pfd, PIOCSTOP, (char *)NULL) < 0) {
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001362 perror("strace: PIOCSTOP");
1363 return -1;
1364 }
Roland McGrath553a6092002-12-16 20:40:39 +00001365#endif
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001366#ifdef PIOCSET
1367 /* Set Run-on-Last-Close. */
1368 arg = PR_RLC;
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001369 if (IOCTL(tcp->pfd, PIOCSET, &arg) < 0) {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001370 perror("PIOCSET PR_RLC");
1371 return -1;
1372 }
1373 /* Set or Reset Inherit-on-Fork. */
1374 arg = PR_FORK;
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001375 if (IOCTL(tcp->pfd, followfork ? PIOCSET : PIOCRESET, &arg) < 0) {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001376 perror("PIOC{SET,RESET} PR_FORK");
1377 return -1;
1378 }
1379#else /* !PIOCSET */
Roland McGrath553a6092002-12-16 20:40:39 +00001380#ifndef FREEBSD
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001381 if (ioctl(tcp->pfd, PIOCSRLC) < 0) {
1382 perror("PIOCSRLC");
1383 return -1;
1384 }
1385 if (ioctl(tcp->pfd, followfork ? PIOCSFORK : PIOCRFORK) < 0) {
1386 perror("PIOC{S,R}FORK");
1387 return -1;
1388 }
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001389#else /* FREEBSD */
1390 /* just unset the PF_LINGER flag for the Run-on-Last-Close. */
1391 if (ioctl(tcp->pfd, PIOCGFL, &arg) < 0) {
1392 perror("PIOCGFL");
Denys Vlasenko5ae2b7c2009-02-27 20:32:52 +00001393 return -1;
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001394 }
1395 arg &= ~PF_LINGER;
1396 if (ioctl(tcp->pfd, PIOCSFL, arg) < 0) {
Denys Vlasenko5ae2b7c2009-02-27 20:32:52 +00001397 perror("PIOCSFL");
1398 return -1;
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001399 }
1400#endif /* FREEBSD */
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001401#endif /* !PIOCSET */
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001402#ifndef FREEBSD
John Hughes19e49982001-10-19 08:59:12 +00001403 /* Enable all syscall entries we care about. */
1404 premptyset(&syscalls);
1405 for (i = 1; i < MAX_QUALS; ++i) {
1406 if (i > (sizeof syscalls) * CHAR_BIT) break;
Denys Vlasenkob63256e2011-06-07 12:13:24 +02001407 if (qual_flags[i] & QUAL_TRACE) praddset(&syscalls, i);
John Hughes19e49982001-10-19 08:59:12 +00001408 }
Denys Vlasenkob63256e2011-06-07 12:13:24 +02001409 praddset(&syscalls, SYS_execve);
John Hughes19e49982001-10-19 08:59:12 +00001410 if (followfork) {
Denys Vlasenkob63256e2011-06-07 12:13:24 +02001411 praddset(&syscalls, SYS_fork);
John Hughes19e49982001-10-19 08:59:12 +00001412#ifdef SYS_forkall
Denys Vlasenkob63256e2011-06-07 12:13:24 +02001413 praddset(&syscalls, SYS_forkall);
John Hughes19e49982001-10-19 08:59:12 +00001414#endif
Roland McGrath553a6092002-12-16 20:40:39 +00001415#ifdef SYS_fork1
Denys Vlasenkob63256e2011-06-07 12:13:24 +02001416 praddset(&syscalls, SYS_fork1);
John Hughes19e49982001-10-19 08:59:12 +00001417#endif
1418#ifdef SYS_rfork1
Denys Vlasenkob63256e2011-06-07 12:13:24 +02001419 praddset(&syscalls, SYS_rfork1);
John Hughes19e49982001-10-19 08:59:12 +00001420#endif
1421#ifdef SYS_rforkall
Denys Vlasenkob63256e2011-06-07 12:13:24 +02001422 praddset(&syscalls, SYS_rforkall);
John Hughes19e49982001-10-19 08:59:12 +00001423#endif
1424 }
1425 if (IOCTL(tcp->pfd, PIOCSENTRY, &syscalls) < 0) {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001426 perror("PIOCSENTRY");
1427 return -1;
1428 }
John Hughes19e49982001-10-19 08:59:12 +00001429 /* Enable the syscall exits. */
1430 if (IOCTL(tcp->pfd, PIOCSEXIT, &syscalls) < 0) {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001431 perror("PIOSEXIT");
1432 return -1;
1433 }
John Hughes19e49982001-10-19 08:59:12 +00001434 /* Enable signals we care about. */
1435 premptyset(&signals);
1436 for (i = 1; i < MAX_QUALS; ++i) {
1437 if (i > (sizeof signals) * CHAR_BIT) break;
Denys Vlasenkob63256e2011-06-07 12:13:24 +02001438 if (qual_flags[i] & QUAL_SIGNAL) praddset(&signals, i);
John Hughes19e49982001-10-19 08:59:12 +00001439 }
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001440 if (IOCTL(tcp->pfd, PIOCSTRACE, &signals) < 0) {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001441 perror("PIOCSTRACE");
1442 return -1;
1443 }
John Hughes19e49982001-10-19 08:59:12 +00001444 /* Enable faults we care about */
1445 premptyset(&faults);
1446 for (i = 1; i < MAX_QUALS; ++i) {
1447 if (i > (sizeof faults) * CHAR_BIT) break;
Denys Vlasenkob63256e2011-06-07 12:13:24 +02001448 if (qual_flags[i] & QUAL_FAULT) praddset(&faults, i);
John Hughes19e49982001-10-19 08:59:12 +00001449 }
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001450 if (IOCTL(tcp->pfd, PIOCSFAULT, &faults) < 0) {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001451 perror("PIOCSFAULT");
1452 return -1;
1453 }
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001454#else /* FREEBSD */
1455 /* set events flags. */
Denys Vlasenkob63256e2011-06-07 12:13:24 +02001456 arg = S_SIG | S_SCE | S_SCX;
1457 if (ioctl(tcp->pfd, PIOCBIS, arg) < 0) {
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001458 perror("PIOCBIS");
1459 return -1;
1460 }
1461#endif /* FREEBSD */
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001462 if (!attaching) {
1463#ifdef MIPS
1464 /*
1465 * The SGI PRSABORT doesn't work for pause() so
1466 * we send it a caught signal to wake it up.
1467 */
1468 kill(tcp->pid, SIGINT);
1469#else /* !MIPS */
Roland McGrath553a6092002-12-16 20:40:39 +00001470#ifdef PRSABORT
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001471 /* The child is in a pause(), abort it. */
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001472 arg = PRSABORT;
Denys Vlasenkob63256e2011-06-07 12:13:24 +02001473 if (IOCTL(tcp->pfd, PIOCRUN, &arg) < 0) {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001474 perror("PIOCRUN");
1475 return -1;
1476 }
Roland McGrath553a6092002-12-16 20:40:39 +00001477#endif
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001478#endif /* !MIPS*/
1479#ifdef FREEBSD
1480 /* wake up the child if it received the SIGSTOP */
1481 kill(tcp->pid, SIGCONT);
Roland McGrath553a6092002-12-16 20:40:39 +00001482#endif
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001483 for (;;) {
1484 /* Wait for the child to do something. */
Denys Vlasenkob63256e2011-06-07 12:13:24 +02001485 if (IOCTL_WSTOP(tcp) < 0) {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001486 perror("PIOCWSTOP");
1487 return -1;
1488 }
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001489 if (tcp->status.PR_WHY == PR_SYSENTRY) {
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001490 tcp->flags &= ~TCB_INSYSCALL;
Denys Vlasenko06602d92011-08-24 17:53:52 +02001491 get_scno(tcp);
Roland McGrath76989d72005-06-07 23:21:31 +00001492 if (known_scno(tcp) == SYS_execve)
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001493 break;
1494 }
1495 /* Set it running: maybe execve will be next. */
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001496#ifndef FREEBSD
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001497 arg = 0;
Denys Vlasenko0890c8a2011-08-21 00:10:45 +02001498 if (IOCTL(tcp->pfd, PIOCRUN, &arg) < 0)
1499#else
1500 if (IOCTL(tcp->pfd, PIOCRUN, 0) < 0)
1501#endif
1502 {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001503 perror("PIOCRUN");
1504 return -1;
1505 }
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001506#ifdef FREEBSD
1507 /* handle the case where we "opened" the child before
1508 it did the kill -STOP */
1509 if (tcp->status.PR_WHY == PR_SIGNALLED &&
1510 tcp->status.PR_WHAT == SIGSTOP)
1511 kill(tcp->pid, SIGCONT);
Roland McGrath553a6092002-12-16 20:40:39 +00001512#endif
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001513 }
1514 }
Denys Vlasenko0890c8a2011-08-21 00:10:45 +02001515#ifdef FREEBSD
1516 else {
Roland McGrath553a6092002-12-16 20:40:39 +00001517 if (attaching < 2) {
Wichert Akkerman2e4ffe52000-09-03 23:57:48 +00001518 /* We are attaching to an already running process.
1519 * Try to figure out the state of the process in syscalls,
1520 * to handle the first event well.
1521 * This is done by having a look at the "wchan" property of the
1522 * process, which tells where it is stopped (if it is). */
1523 FILE * status;
1524 char wchan[20]; /* should be enough */
Roland McGrath553a6092002-12-16 20:40:39 +00001525
Wichert Akkerman2e4ffe52000-09-03 23:57:48 +00001526 sprintf(proc, "/proc/%d/status", tcp->pid);
1527 status = fopen(proc, "r");
1528 if (status &&
1529 (fscanf(status, "%*s %*d %*d %*d %*d %*d,%*d %*s %*d,%*d"
1530 "%*d,%*d %*d,%*d %19s", wchan) == 1) &&
1531 strcmp(wchan, "nochan") && strcmp(wchan, "spread") &&
1532 strcmp(wchan, "stopevent")) {
1533 /* The process is asleep in the middle of a syscall.
1534 Fake the syscall entry event */
1535 tcp->flags &= ~(TCB_INSYSCALL|TCB_STARTUP);
1536 tcp->status.PR_WHY = PR_SYSENTRY;
1537 trace_syscall(tcp);
1538 }
1539 if (status)
1540 fclose(status);
1541 } /* otherwise it's a fork being followed */
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001542 }
1543#endif /* FREEBSD */
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001544#ifndef HAVE_POLLABLE_PROCFS
1545 if (proc_poll_pipe[0] != -1)
1546 proc_poller(tcp->pfd);
1547 else if (nprocs > 1) {
1548 proc_poll_open();
1549 proc_poller(last_pfd);
1550 proc_poller(tcp->pfd);
1551 }
1552 last_pfd = tcp->pfd;
1553#endif /* !HAVE_POLLABLE_PROCFS */
1554 return 0;
1555}
1556
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001557#endif /* USE_PROCFS */
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001558
Roland McGrathe85bbfe2003-01-09 06:53:31 +00001559struct tcb *
Roland McGrath54e931f2010-09-14 18:59:20 -07001560pid2tcb(int pid)
1561{
1562 int i;
1563
1564 if (pid <= 0)
1565 return NULL;
1566
1567 for (i = 0; i < tcbtabsize; i++) {
1568 struct tcb *tcp = tcbtab[i];
1569 if (tcp->pid == pid && (tcp->flags & TCB_INUSE))
1570 return tcp;
1571 }
1572
1573 return NULL;
1574}
1575
1576#ifdef USE_PROCFS
1577
1578static struct tcb *
1579first_used_tcb(void)
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001580{
1581 int i;
1582 struct tcb *tcp;
Roland McGrathee9d4352002-12-18 04:16:10 +00001583 for (i = 0; i < tcbtabsize; i++) {
1584 tcp = tcbtab[i];
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001585 if (tcp->flags & TCB_INUSE)
1586 return tcp;
1587 }
1588 return NULL;
1589}
1590
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001591static struct tcb *
Denys Vlasenko12014262011-05-30 14:00:14 +02001592pfd2tcb(int pfd)
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001593{
1594 int i;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001595
Roland McGrathca16be82003-01-10 19:55:28 +00001596 for (i = 0; i < tcbtabsize; i++) {
1597 struct tcb *tcp = tcbtab[i];
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001598 if (tcp->pfd != pfd)
1599 continue;
1600 if (tcp->flags & TCB_INUSE)
1601 return tcp;
1602 }
1603 return NULL;
1604}
1605
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001606#endif /* USE_PROCFS */
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001607
1608void
Denys Vlasenko12014262011-05-30 14:00:14 +02001609droptcb(struct tcb *tcp)
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001610{
1611 if (tcp->pid == 0)
1612 return;
Denys Vlasenko19cdada2011-08-17 10:45:32 +02001613
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001614 nprocs--;
Denys Vlasenko1d5f12e2011-06-24 16:41:35 +02001615 if (debug)
1616 fprintf(stderr, "dropped tcb for pid %d, %d remain\n", tcp->pid, nprocs);
Wichert Akkermaneb8ebda2002-04-01 17:48:02 +00001617
Denys Vlasenko8dc0c8c2011-08-20 13:44:56 +02001618#ifdef USE_PROCFS
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001619 if (tcp->pfd != -1) {
1620 close(tcp->pfd);
1621 tcp->pfd = -1;
Denys Vlasenko8dc0c8c2011-08-20 13:44:56 +02001622# ifdef FREEBSD
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001623 if (tcp->pfd_reg != -1) {
1624 close(tcp->pfd_reg);
1625 tcp->pfd_reg = -1;
1626 }
1627 if (tcp->pfd_status != -1) {
1628 close(tcp->pfd_status);
1629 tcp->pfd_status = -1;
1630 }
Denys Vlasenko8dc0c8c2011-08-20 13:44:56 +02001631# endif
Denys Vlasenko19cdada2011-08-17 10:45:32 +02001632 tcp->flags = 0; /* rebuild_pollv needs it */
1633 rebuild_pollv();
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001634 }
Denys Vlasenko8dc0c8c2011-08-20 13:44:56 +02001635#endif
Wichert Akkermaneb8ebda2002-04-01 17:48:02 +00001636
Wichert Akkerman822f0c92002-04-03 10:55:14 +00001637 if (outfname && followfork > 1 && tcp->outf)
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001638 fclose(tcp->outf);
Wichert Akkermaneb8ebda2002-04-01 17:48:02 +00001639
Denys Vlasenko19cdada2011-08-17 10:45:32 +02001640 memset(tcp, 0, sizeof(*tcp));
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001641}
1642
Roland McGrath0a463882007-07-05 18:43:16 +00001643/* detach traced process; continue with sig
1644 Never call DETACH twice on the same process as both unattached and
1645 attached-unstopped processes give the same ESRCH. For unattached process we
1646 would SIGSTOP it and wait for its SIGSTOP notification forever. */
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001647
1648static int
Denys Vlasenko12014262011-05-30 14:00:14 +02001649detach(struct tcb *tcp, int sig)
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001650{
1651 int error = 0;
Roland McGrathca16be82003-01-10 19:55:28 +00001652#ifdef LINUX
Roland McGrath1bfd3102007-08-03 10:02:00 +00001653 int status, catch_sigstop;
Roland McGrathca16be82003-01-10 19:55:28 +00001654#endif
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001655
1656 if (tcp->flags & TCB_BPTSET)
Andreas Schwab840d85b2010-01-12 11:16:32 +01001657 clearbpt(tcp);
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001658
1659#ifdef LINUX
1660 /*
1661 * Linux wrongly insists the child be stopped
Roland McGrath7bf10472002-12-16 20:42:50 +00001662 * before detaching. Arghh. We go through hoops
1663 * to make a clean break of things.
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001664 */
Roland McGrath7bf10472002-12-16 20:42:50 +00001665#if defined(SPARC)
1666#undef PTRACE_DETACH
1667#define PTRACE_DETACH PTRACE_SUNDETACH
1668#endif
Roland McGrath02203312007-06-11 22:06:31 +00001669 /*
1670 * On TCB_STARTUP we did PTRACE_ATTACH but still did not get the
1671 * expected SIGSTOP. We must catch exactly one as otherwise the
1672 * detached process would be left stopped (process state T).
1673 */
1674 catch_sigstop = (tcp->flags & TCB_STARTUP);
Denys Vlasenko5d645812011-08-20 12:48:18 +02001675 error = ptrace(PTRACE_DETACH, tcp->pid, (char *) 1, sig);
1676 if (error == 0) {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001677 /* On a clear day, you can see forever. */
Roland McGrath7bf10472002-12-16 20:42:50 +00001678 }
1679 else if (errno != ESRCH) {
1680 /* Shouldn't happen. */
1681 perror("detach: ptrace(PTRACE_DETACH, ...)");
1682 }
Denys Vlasenko44f87ef2011-08-17 15:18:21 +02001683 else if (my_tkill(tcp->pid, 0) < 0) {
Roland McGrath7bf10472002-12-16 20:42:50 +00001684 if (errno != ESRCH)
1685 perror("detach: checking sanity");
1686 }
Denys Vlasenko44f87ef2011-08-17 15:18:21 +02001687 else if (!catch_sigstop && my_tkill(tcp->pid, SIGSTOP) < 0) {
Roland McGrath7bf10472002-12-16 20:42:50 +00001688 if (errno != ESRCH)
1689 perror("detach: stopping child");
1690 }
Roland McGrath02203312007-06-11 22:06:31 +00001691 else
1692 catch_sigstop = 1;
Denys Vlasenkoef2fbf82009-01-06 21:45:06 +00001693 if (catch_sigstop) {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001694 for (;;) {
Roland McGrath7508cb42002-12-17 10:48:05 +00001695#ifdef __WALL
1696 if (wait4(tcp->pid, &status, __WALL, NULL) < 0) {
1697 if (errno == ECHILD) /* Already gone. */
1698 break;
1699 if (errno != EINVAL) {
Roland McGrath553a6092002-12-16 20:40:39 +00001700 perror("detach: waiting");
Roland McGrath7508cb42002-12-17 10:48:05 +00001701 break;
1702 }
1703#endif /* __WALL */
1704 /* No __WALL here. */
1705 if (waitpid(tcp->pid, &status, 0) < 0) {
1706 if (errno != ECHILD) {
1707 perror("detach: waiting");
1708 break;
1709 }
1710#ifdef __WCLONE
1711 /* If no processes, try clones. */
1712 if (wait4(tcp->pid, &status, __WCLONE,
1713 NULL) < 0) {
1714 if (errno != ECHILD)
1715 perror("detach: waiting");
1716 break;
1717 }
1718#endif /* __WCLONE */
1719 }
1720#ifdef __WALL
Roland McGrath553a6092002-12-16 20:40:39 +00001721 }
Roland McGrath7508cb42002-12-17 10:48:05 +00001722#endif
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001723 if (!WIFSTOPPED(status)) {
1724 /* Au revoir, mon ami. */
1725 break;
1726 }
1727 if (WSTOPSIG(status) == SIGSTOP) {
Denys Vlasenko732d1bf2008-12-17 19:21:59 +00001728 ptrace_restart(PTRACE_DETACH, tcp, sig);
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001729 break;
1730 }
Denys Vlasenko732d1bf2008-12-17 19:21:59 +00001731 error = ptrace_restart(PTRACE_CONT, tcp,
Denys Vlasenko75422762011-05-27 14:36:01 +02001732 WSTOPSIG(status) == syscall_trap_sig ? 0
Denys Vlasenko732d1bf2008-12-17 19:21:59 +00001733 : WSTOPSIG(status));
1734 if (error < 0)
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001735 break;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001736 }
Denys Vlasenkoef2fbf82009-01-06 21:45:06 +00001737 }
Roland McGrath7bf10472002-12-16 20:42:50 +00001738#endif /* LINUX */
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001739
1740#if defined(SUNOS4)
1741 /* PTRACE_DETACH won't respect `sig' argument, so we post it here. */
1742 if (sig && kill(tcp->pid, sig) < 0)
1743 perror("detach: kill");
1744 sig = 0;
Denys Vlasenko732d1bf2008-12-17 19:21:59 +00001745 error = ptrace_restart(PTRACE_DETACH, tcp, sig);
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001746#endif /* SUNOS4 */
1747
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001748 if (!qflag)
1749 fprintf(stderr, "Process %u detached\n", tcp->pid);
1750
1751 droptcb(tcp);
Roland McGratha08a97e2005-08-03 11:23:46 +00001752
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001753 return error;
1754}
1755
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001756#ifdef USE_PROCFS
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001757
Dmitry V. Levine5e60852009-12-31 22:50:49 +00001758static void reaper(int sig)
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001759{
1760 int pid;
1761 int status;
1762
1763 while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001764 }
1765}
1766
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001767#endif /* USE_PROCFS */
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001768
1769static void
Denys Vlasenko12014262011-05-30 14:00:14 +02001770cleanup(void)
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001771{
1772 int i;
1773 struct tcb *tcp;
1774
Roland McGrathee9d4352002-12-18 04:16:10 +00001775 for (i = 0; i < tcbtabsize; i++) {
1776 tcp = tcbtab[i];
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001777 if (!(tcp->flags & TCB_INUSE))
1778 continue;
1779 if (debug)
1780 fprintf(stderr,
1781 "cleanup: looking at pid %u\n", tcp->pid);
1782 if (tcp_last &&
1783 (!outfname || followfork < 2 || tcp_last == tcp)) {
Denys Vlasenkoef2fbf82009-01-06 21:45:06 +00001784 tprintf(" <unfinished ...>");
1785 printtrailer();
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001786 }
1787 if (tcp->flags & TCB_ATTACHED)
1788 detach(tcp, 0);
1789 else {
1790 kill(tcp->pid, SIGCONT);
1791 kill(tcp->pid, SIGTERM);
1792 }
1793 }
1794 if (cflag)
1795 call_summary(outf);
1796}
1797
1798static void
Denys Vlasenko12014262011-05-30 14:00:14 +02001799interrupt(int sig)
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001800{
1801 interrupted = 1;
1802}
1803
1804#ifndef HAVE_STRERROR
1805
Roland McGrath6d2b3492002-12-30 00:51:30 +00001806#if !HAVE_DECL_SYS_ERRLIST
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001807extern int sys_nerr;
1808extern char *sys_errlist[];
Roland McGrath6d2b3492002-12-30 00:51:30 +00001809#endif /* HAVE_DECL_SYS_ERRLIST */
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001810
1811const char *
Denys Vlasenko12014262011-05-30 14:00:14 +02001812strerror(int err_no)
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001813{
1814 static char buf[64];
1815
Denys Vlasenko35aba6a2011-05-25 15:33:26 +02001816 if (err_no < 1 || err_no >= sys_nerr) {
1817 sprintf(buf, "Unknown error %d", err_no);
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001818 return buf;
1819 }
Denys Vlasenko35aba6a2011-05-25 15:33:26 +02001820 return sys_errlist[err_no];
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001821}
1822
1823#endif /* HAVE_STERRROR */
1824
1825#ifndef HAVE_STRSIGNAL
1826
Roland McGrath8f474e02003-01-14 07:53:33 +00001827#if defined HAVE_SYS_SIGLIST && !defined HAVE_DECL_SYS_SIGLIST
Roland McGrath6d2b3492002-12-30 00:51:30 +00001828extern char *sys_siglist[];
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001829#endif
Roland McGrath8f474e02003-01-14 07:53:33 +00001830#if defined HAVE_SYS__SIGLIST && !defined HAVE_DECL__SYS_SIGLIST
1831extern char *_sys_siglist[];
1832#endif
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001833
1834const char *
Denys Vlasenko12014262011-05-30 14:00:14 +02001835strsignal(int sig)
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001836{
1837 static char buf[64];
1838
1839 if (sig < 1 || sig >= NSIG) {
1840 sprintf(buf, "Unknown signal %d", sig);
1841 return buf;
1842 }
1843#ifdef HAVE__SYS_SIGLIST
1844 return _sys_siglist[sig];
1845#else
1846 return sys_siglist[sig];
1847#endif
1848}
1849
1850#endif /* HAVE_STRSIGNAL */
1851
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001852#ifdef USE_PROCFS
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001853
1854static void
Denys Vlasenko12014262011-05-30 14:00:14 +02001855rebuild_pollv(void)
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001856{
1857 int i, j;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001858
Denys Vlasenkocfd364b2011-08-20 13:41:13 +02001859 free(pollv);
1860 pollv = malloc(nprocs * sizeof(pollv[0]));
Roland McGrathee9d4352002-12-18 04:16:10 +00001861 if (pollv == NULL) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +02001862 error_msg_and_die("Out of memory");
Roland McGrathee9d4352002-12-18 04:16:10 +00001863 }
1864
Roland McGrathca16be82003-01-10 19:55:28 +00001865 for (i = j = 0; i < tcbtabsize; i++) {
1866 struct tcb *tcp = tcbtab[i];
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001867 if (!(tcp->flags & TCB_INUSE))
1868 continue;
1869 pollv[j].fd = tcp->pfd;
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001870 pollv[j].events = POLLWANT;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001871 j++;
1872 }
1873 if (j != nprocs) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +02001874 error_msg_and_die("proc miscount");
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001875 }
1876}
1877
1878#ifndef HAVE_POLLABLE_PROCFS
1879
1880static void
Denys Vlasenko12014262011-05-30 14:00:14 +02001881proc_poll_open(void)
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001882{
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001883 int i;
1884
1885 if (pipe(proc_poll_pipe) < 0) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +02001886 perror_msg_and_die("pipe");
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001887 }
1888 for (i = 0; i < 2; i++) {
Denys Vlasenko1f532ab2011-06-22 13:11:23 +02001889 set_cloexec_flag(proc_poll_pipe[i]);
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001890 }
1891}
1892
1893static int
Denys Vlasenko12014262011-05-30 14:00:14 +02001894proc_poll(struct pollfd *pollv, int nfds, int timeout)
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001895{
1896 int i;
1897 int n;
1898 struct proc_pollfd pollinfo;
1899
Denys Vlasenko5d645812011-08-20 12:48:18 +02001900 n = read(proc_poll_pipe[0], &pollinfo, sizeof(pollinfo));
1901 if (n < 0)
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001902 return n;
1903 if (n != sizeof(struct proc_pollfd)) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +02001904 error_msg_and_die("panic: short read: %d", n);
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001905 }
1906 for (i = 0; i < nprocs; i++) {
1907 if (pollv[i].fd == pollinfo.fd)
1908 pollv[i].revents = pollinfo.revents;
1909 else
1910 pollv[i].revents = 0;
1911 }
1912 poller_pid = pollinfo.pid;
1913 return 1;
1914}
1915
1916static void
Denys Vlasenko12014262011-05-30 14:00:14 +02001917wakeup_handler(int sig)
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001918{
1919}
1920
1921static void
Denys Vlasenko12014262011-05-30 14:00:14 +02001922proc_poller(int pfd)
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001923{
1924 struct proc_pollfd pollinfo;
1925 struct sigaction sa;
1926 sigset_t blocked_set, empty_set;
1927 int i;
1928 int n;
1929 struct rlimit rl;
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001930#ifdef FREEBSD
1931 struct procfs_status pfs;
1932#endif /* FREEBSD */
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001933
1934 switch (fork()) {
1935 case -1:
Denys Vlasenkocb2ad002011-06-23 13:05:29 +02001936 perror_msg_and_die("fork");
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001937 case 0:
1938 break;
1939 default:
1940 return;
1941 }
1942
1943 sa.sa_handler = interactive ? SIG_DFL : SIG_IGN;
1944 sa.sa_flags = 0;
1945 sigemptyset(&sa.sa_mask);
1946 sigaction(SIGHUP, &sa, NULL);
1947 sigaction(SIGINT, &sa, NULL);
1948 sigaction(SIGQUIT, &sa, NULL);
1949 sigaction(SIGPIPE, &sa, NULL);
1950 sigaction(SIGTERM, &sa, NULL);
1951 sa.sa_handler = wakeup_handler;
1952 sigaction(SIGUSR1, &sa, NULL);
1953 sigemptyset(&blocked_set);
1954 sigaddset(&blocked_set, SIGUSR1);
1955 sigprocmask(SIG_BLOCK, &blocked_set, NULL);
1956 sigemptyset(&empty_set);
1957
1958 if (getrlimit(RLIMIT_NOFILE, &rl) < 0) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +02001959 perror_msg_and_die("getrlimit(RLIMIT_NOFILE, ...)");
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001960 }
1961 n = rl.rlim_cur;
1962 for (i = 0; i < n; i++) {
1963 if (i != pfd && i != proc_poll_pipe[1])
1964 close(i);
1965 }
1966
1967 pollinfo.fd = pfd;
1968 pollinfo.pid = getpid();
1969 for (;;) {
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001970#ifndef FREEBSD
Denys Vlasenko5ae2b7c2009-02-27 20:32:52 +00001971 if (ioctl(pfd, PIOCWSTOP, NULL) < 0)
1972#else
1973 if (ioctl(pfd, PIOCWSTOP, &pfs) < 0)
1974#endif
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001975 {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001976 switch (errno) {
1977 case EINTR:
1978 continue;
1979 case EBADF:
1980 pollinfo.revents = POLLERR;
1981 break;
1982 case ENOENT:
1983 pollinfo.revents = POLLHUP;
1984 break;
1985 default:
1986 perror("proc_poller: PIOCWSTOP");
1987 }
1988 write(proc_poll_pipe[1], &pollinfo, sizeof(pollinfo));
1989 _exit(0);
1990 }
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001991 pollinfo.revents = POLLWANT;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001992 write(proc_poll_pipe[1], &pollinfo, sizeof(pollinfo));
1993 sigsuspend(&empty_set);
1994 }
1995}
1996
1997#endif /* !HAVE_POLLABLE_PROCFS */
1998
1999static int
2000choose_pfd()
2001{
2002 int i, j;
2003 struct tcb *tcp;
2004
2005 static int last;
2006
2007 if (followfork < 2 &&
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00002008 last < nprocs && (pollv[last].revents & POLLWANT)) {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002009 /*
2010 * The previous process is ready to run again. We'll
2011 * let it do so if it is currently in a syscall. This
2012 * heuristic improves the readability of the trace.
2013 */
2014 tcp = pfd2tcb(pollv[last].fd);
Denys Vlasenkob88f9612011-08-21 18:03:23 +02002015 if (tcp && exiting(tcp))
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002016 return pollv[last].fd;
2017 }
2018
2019 for (i = 0; i < nprocs; i++) {
2020 /* Let competing children run round robin. */
2021 j = (i + last + 1) % nprocs;
2022 if (pollv[j].revents & (POLLHUP | POLLERR)) {
2023 tcp = pfd2tcb(pollv[j].fd);
2024 if (!tcp) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +02002025 error_msg_and_die("lost proc");
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002026 }
2027 droptcb(tcp);
2028 return -1;
2029 }
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00002030 if (pollv[j].revents & POLLWANT) {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002031 last = j;
2032 return pollv[j].fd;
2033 }
2034 }
Denys Vlasenkocb2ad002011-06-23 13:05:29 +02002035 error_msg_and_die("nothing ready");
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002036}
2037
2038static int
Denys Vlasenko12014262011-05-30 14:00:14 +02002039trace(void)
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002040{
Wichert Akkerman9dbf1541999-11-26 13:11:29 +00002041#ifdef POLL_HACK
John Hughesd870b3c2002-05-21 11:24:18 +00002042 struct tcb *in_syscall = NULL;
Wichert Akkerman9dbf1541999-11-26 13:11:29 +00002043#endif
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002044 struct tcb *tcp;
2045 int pfd;
2046 int what;
2047 int ioctl_result = 0, ioctl_errno = 0;
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00002048 long arg;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002049
2050 for (;;) {
2051 if (interactive)
2052 sigprocmask(SIG_SETMASK, &empty_set, NULL);
2053
2054 if (nprocs == 0)
2055 break;
2056
2057 switch (nprocs) {
2058 case 1:
2059#ifndef HAVE_POLLABLE_PROCFS
2060 if (proc_poll_pipe[0] == -1) {
2061#endif
Roland McGrath54e931f2010-09-14 18:59:20 -07002062 tcp = first_used_tcb();
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002063 if (!tcp)
2064 continue;
2065 pfd = tcp->pfd;
2066 if (pfd == -1)
2067 continue;
2068 break;
2069#ifndef HAVE_POLLABLE_PROCFS
2070 }
2071 /* fall through ... */
2072#endif /* !HAVE_POLLABLE_PROCFS */
2073 default:
2074#ifdef HAVE_POLLABLE_PROCFS
Wichert Akkerman9dbf1541999-11-26 13:11:29 +00002075#ifdef POLL_HACK
2076 /* On some systems (e.g. UnixWare) we get too much ugly
2077 "unfinished..." stuff when multiple proceses are in
2078 syscalls. Here's a nasty hack */
Roland McGrath553a6092002-12-16 20:40:39 +00002079
Wichert Akkerman9dbf1541999-11-26 13:11:29 +00002080 if (in_syscall) {
2081 struct pollfd pv;
2082 tcp = in_syscall;
2083 in_syscall = NULL;
2084 pv.fd = tcp->pfd;
2085 pv.events = POLLWANT;
Denys Vlasenko5d645812011-08-20 12:48:18 +02002086 what = poll(&pv, 1, 1);
2087 if (what < 0) {
Wichert Akkerman9dbf1541999-11-26 13:11:29 +00002088 if (interrupted)
2089 return 0;
2090 continue;
2091 }
2092 else if (what == 1 && pv.revents & POLLWANT) {
2093 goto FOUND;
2094 }
2095 }
2096#endif
2097
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002098 if (poll(pollv, nprocs, INFTIM) < 0) {
2099 if (interrupted)
2100 return 0;
2101 continue;
2102 }
2103#else /* !HAVE_POLLABLE_PROCFS */
2104 if (proc_poll(pollv, nprocs, INFTIM) < 0) {
2105 if (interrupted)
2106 return 0;
2107 continue;
2108 }
2109#endif /* !HAVE_POLLABLE_PROCFS */
2110 pfd = choose_pfd();
2111 if (pfd == -1)
2112 continue;
2113 break;
2114 }
2115
2116 /* Look up `pfd' in our table. */
Denys Vlasenko5d645812011-08-20 12:48:18 +02002117 tcp = pfd2tcb(pfd);
2118 if (tcp == NULL) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +02002119 error_msg_and_die("unknown pfd: %u", pfd);
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002120 }
John Hughesb6643082002-05-23 11:02:22 +00002121#ifdef POLL_HACK
Wichert Akkerman9dbf1541999-11-26 13:11:29 +00002122 FOUND:
John Hughesb6643082002-05-23 11:02:22 +00002123#endif
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002124 /* Get the status of the process. */
2125 if (!interrupted) {
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00002126#ifndef FREEBSD
Denys Vlasenkob63256e2011-06-07 12:13:24 +02002127 ioctl_result = IOCTL_WSTOP(tcp);
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00002128#else /* FREEBSD */
2129 /* Thanks to some scheduling mystery, the first poller
2130 sometimes waits for the already processed end of fork
2131 event. Doing a non blocking poll here solves the problem. */
2132 if (proc_poll_pipe[0] != -1)
Denys Vlasenkob63256e2011-06-07 12:13:24 +02002133 ioctl_result = IOCTL_STATUS(tcp);
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00002134 else
Denys Vlasenkob63256e2011-06-07 12:13:24 +02002135 ioctl_result = IOCTL_WSTOP(tcp);
Roland McGrath553a6092002-12-16 20:40:39 +00002136#endif /* FREEBSD */
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002137 ioctl_errno = errno;
2138#ifndef HAVE_POLLABLE_PROCFS
2139 if (proc_poll_pipe[0] != -1) {
2140 if (ioctl_result < 0)
2141 kill(poller_pid, SIGKILL);
2142 else
2143 kill(poller_pid, SIGUSR1);
2144 }
2145#endif /* !HAVE_POLLABLE_PROCFS */
2146 }
2147 if (interrupted)
2148 return 0;
2149
2150 if (interactive)
2151 sigprocmask(SIG_BLOCK, &blocked_set, NULL);
2152
2153 if (ioctl_result < 0) {
2154 /* Find out what happened if it failed. */
2155 switch (ioctl_errno) {
2156 case EINTR:
2157 case EBADF:
2158 continue;
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00002159#ifdef FREEBSD
2160 case ENOTTY:
Roland McGrath553a6092002-12-16 20:40:39 +00002161#endif
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002162 case ENOENT:
2163 droptcb(tcp);
2164 continue;
2165 default:
Denys Vlasenkocb2ad002011-06-23 13:05:29 +02002166 perror_msg_and_die("PIOCWSTOP");
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002167 }
2168 }
2169
Wichert Akkerman2e4ffe52000-09-03 23:57:48 +00002170#ifdef FREEBSD
2171 if ((tcp->flags & TCB_STARTUP) && (tcp->status.PR_WHY == PR_SYSEXIT)) {
2172 /* discard first event for a syscall we never entered */
Denys Vlasenkob63256e2011-06-07 12:13:24 +02002173 IOCTL(tcp->pfd, PIOCRUN, 0);
Wichert Akkerman2e4ffe52000-09-03 23:57:48 +00002174 continue;
2175 }
Roland McGrath553a6092002-12-16 20:40:39 +00002176#endif
2177
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002178 /* clear the just started flag */
2179 tcp->flags &= ~TCB_STARTUP;
2180
2181 /* set current output file */
2182 outf = tcp->outf;
Andreas Schwabccdff482009-10-27 16:27:13 +01002183 curcol = tcp->curcol;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002184
2185 if (cflag) {
2186 struct timeval stime;
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00002187#ifdef FREEBSD
2188 char buf[1024];
2189 int len;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002190
Denys Vlasenko5d645812011-08-20 12:48:18 +02002191 len = pread(tcp->pfd_status, buf, sizeof(buf) - 1, 0);
2192 if (len > 0) {
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00002193 buf[len] = '\0';
2194 sscanf(buf,
2195 "%*s %*d %*d %*d %*d %*d,%*d %*s %*d,%*d %*d,%*d %ld,%ld",
2196 &stime.tv_sec, &stime.tv_usec);
2197 } else
2198 stime.tv_sec = stime.tv_usec = 0;
Roland McGrath553a6092002-12-16 20:40:39 +00002199#else /* !FREEBSD */
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002200 stime.tv_sec = tcp->status.pr_stime.tv_sec;
2201 stime.tv_usec = tcp->status.pr_stime.tv_nsec/1000;
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00002202#endif /* !FREEBSD */
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002203 tv_sub(&tcp->dtime, &stime, &tcp->stime);
2204 tcp->stime = stime;
2205 }
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00002206 what = tcp->status.PR_WHAT;
2207 switch (tcp->status.PR_WHY) {
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00002208#ifndef FREEBSD
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002209 case PR_REQUESTED:
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00002210 if (tcp->status.PR_FLAGS & PR_ASLEEP) {
2211 tcp->status.PR_WHY = PR_SYSENTRY;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002212 if (trace_syscall(tcp) < 0) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +02002213 error_msg_and_die("syscall trouble");
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002214 }
2215 }
2216 break;
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00002217#endif /* !FREEBSD */
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002218 case PR_SYSENTRY:
Wichert Akkerman9dbf1541999-11-26 13:11:29 +00002219#ifdef POLL_HACK
2220 in_syscall = tcp;
2221#endif
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002222 case PR_SYSEXIT:
2223 if (trace_syscall(tcp) < 0) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +02002224 error_msg_and_die("syscall trouble");
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002225 }
2226 break;
2227 case PR_SIGNALLED:
Dmitry V. Levine3a7ef52010-03-28 19:24:54 +00002228 if (cflag != CFLAG_ONLY_STATS
2229 && (qual_flags[what] & QUAL_SIGNAL)) {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002230 printleader(tcp);
2231 tprintf("--- %s (%s) ---",
Nate Sammonsce780fc1999-03-29 23:23:13 +00002232 signame(what), strsignal(what));
Denys Vlasenkoef2fbf82009-01-06 21:45:06 +00002233 printtrailer();
John Hughes58265892001-10-18 15:13:53 +00002234#ifdef PR_INFO
2235 if (tcp->status.PR_INFO.si_signo == what) {
2236 printleader(tcp);
2237 tprintf(" siginfo=");
2238 printsiginfo(&tcp->status.PR_INFO, 1);
Denys Vlasenkoef2fbf82009-01-06 21:45:06 +00002239 printtrailer();
John Hughes58265892001-10-18 15:13:53 +00002240 }
2241#endif
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002242 }
2243 break;
2244 case PR_FAULTED:
Dmitry V. Levine3a7ef52010-03-28 19:24:54 +00002245 if (cflag != CFLAGS_ONLY_STATS
2246 && (qual_flags[what] & QUAL_FAULT)) {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002247 printleader(tcp);
2248 tprintf("=== FAULT %d ===", what);
Denys Vlasenkoef2fbf82009-01-06 21:45:06 +00002249 printtrailer();
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002250 }
2251 break;
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00002252#ifdef FREEBSD
2253 case 0: /* handle case we polled for nothing */
Denys Vlasenko5ae2b7c2009-02-27 20:32:52 +00002254 continue;
Roland McGrath553a6092002-12-16 20:40:39 +00002255#endif
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002256 default:
Denys Vlasenkocb2ad002011-06-23 13:05:29 +02002257 error_msg_and_die("odd stop %d", tcp->status.PR_WHY);
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002258 break;
2259 }
Andreas Schwabccdff482009-10-27 16:27:13 +01002260 /* Remember current print column before continuing. */
2261 tcp->curcol = curcol;
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00002262 arg = 0;
Roland McGrath553a6092002-12-16 20:40:39 +00002263#ifndef FREEBSD
Denys Vlasenkob63256e2011-06-07 12:13:24 +02002264 if (IOCTL(tcp->pfd, PIOCRUN, &arg) < 0)
Roland McGrath553a6092002-12-16 20:40:39 +00002265#else
Denys Vlasenkob63256e2011-06-07 12:13:24 +02002266 if (IOCTL(tcp->pfd, PIOCRUN, 0) < 0)
Roland McGrath553a6092002-12-16 20:40:39 +00002267#endif
Andreas Schwab372cc842010-07-09 11:49:27 +02002268 {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +02002269 perror_msg_and_die("PIOCRUN");
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002270 }
2271 }
2272 return 0;
2273}
2274
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00002275#else /* !USE_PROCFS */
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002276
Roland McGratheb9e2e82009-06-02 16:49:22 -07002277static int
2278trace()
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002279{
2280 int pid;
2281 int wait_errno;
2282 int status;
2283 struct tcb *tcp;
2284#ifdef LINUX
2285 struct rusage ru;
Denys Vlasenko26d1b1e2011-08-15 12:24:14 +02002286 struct rusage *rup = cflag ? &ru : NULL;
2287# ifdef __WALL
Roland McGratheb9e2e82009-06-02 16:49:22 -07002288 static int wait4_options = __WALL;
Denys Vlasenko26d1b1e2011-08-15 12:24:14 +02002289# endif
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002290#endif /* LINUX */
2291
Roland McGratheb9e2e82009-06-02 16:49:22 -07002292 while (nprocs != 0) {
Denys Vlasenko222713a2009-03-17 14:29:59 +00002293 if (interrupted)
Roland McGratheb9e2e82009-06-02 16:49:22 -07002294 return 0;
2295 if (interactive)
2296 sigprocmask(SIG_SETMASK, &empty_set, NULL);
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002297#ifdef LINUX
Denys Vlasenko26d1b1e2011-08-15 12:24:14 +02002298# ifdef __WALL
2299 pid = wait4(-1, &status, wait4_options, rup);
Roland McGrath5bc05552002-12-17 04:50:47 +00002300 if (pid < 0 && (wait4_options & __WALL) && errno == EINVAL) {
Wichert Akkerman2f1d87e2001-03-28 14:40:14 +00002301 /* this kernel does not support __WALL */
2302 wait4_options &= ~__WALL;
Denys Vlasenko26d1b1e2011-08-15 12:24:14 +02002303 pid = wait4(-1, &status, wait4_options, rup);
Wichert Akkerman2f1d87e2001-03-28 14:40:14 +00002304 }
Roland McGrath5bc05552002-12-17 04:50:47 +00002305 if (pid < 0 && !(wait4_options & __WALL) && errno == ECHILD) {
Wichert Akkerman2f1d87e2001-03-28 14:40:14 +00002306 /* most likely a "cloned" process */
Denys Vlasenko26d1b1e2011-08-15 12:24:14 +02002307 pid = wait4(-1, &status, __WCLONE, rup);
2308 if (pid < 0) {
Denys Vlasenkocb2ad002011-06-23 13:05:29 +02002309 perror_msg("wait4(__WCLONE) failed");
Wichert Akkerman2f1d87e2001-03-28 14:40:14 +00002310 }
2311 }
Denys Vlasenko26d1b1e2011-08-15 12:24:14 +02002312# else
2313 pid = wait4(-1, &status, 0, rup);
2314# endif /* __WALL */
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002315#endif /* LINUX */
2316#ifdef SUNOS4
2317 pid = wait(&status);
Denys Vlasenko26d1b1e2011-08-15 12:24:14 +02002318#endif
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002319 wait_errno = errno;
Roland McGratheb9e2e82009-06-02 16:49:22 -07002320 if (interactive)
2321 sigprocmask(SIG_BLOCK, &blocked_set, NULL);
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002322
Denys Vlasenko26d1b1e2011-08-15 12:24:14 +02002323 if (pid < 0) {
Roland McGratheb9e2e82009-06-02 16:49:22 -07002324 switch (wait_errno) {
2325 case EINTR:
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002326 continue;
Roland McGratheb9e2e82009-06-02 16:49:22 -07002327 case ECHILD:
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002328 /*
2329 * We would like to verify this case
2330 * but sometimes a race in Solbourne's
2331 * version of SunOS sometimes reports
2332 * ECHILD before sending us SIGCHILD.
2333 */
Roland McGratheb9e2e82009-06-02 16:49:22 -07002334 return 0;
2335 default:
2336 errno = wait_errno;
2337 perror("strace: wait");
2338 return -1;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002339 }
2340 }
Dmitry V. Levin10de62b2006-12-13 21:45:31 +00002341 if (pid == popen_pid) {
2342 if (WIFEXITED(status) || WIFSIGNALED(status))
Denys Vlasenko7dd23382011-06-22 13:03:56 +02002343 popen_pid = 0;
Dmitry V. Levin10de62b2006-12-13 21:45:31 +00002344 continue;
2345 }
Denys Vlasenko1d5f12e2011-06-24 16:41:35 +02002346 if (debug) {
2347 char buf[sizeof("WIFEXITED,exitcode=%u") + sizeof(int)*3 /*paranoia:*/ + 16];
2348#ifdef LINUX
2349 unsigned ev = (unsigned)status >> 16;
2350 if (ev) {
2351 static const char *const event_names[] = {
2352 [PTRACE_EVENT_CLONE] = "CLONE",
2353 [PTRACE_EVENT_FORK] = "FORK",
2354 [PTRACE_EVENT_VFORK] = "VFORK",
2355 [PTRACE_EVENT_VFORK_DONE] = "VFORK_DONE",
2356 [PTRACE_EVENT_EXEC] = "EXEC",
2357 [PTRACE_EVENT_EXIT] = "EXIT",
2358 };
2359 const char *e;
2360 if (ev < ARRAY_SIZE(event_names))
2361 e = event_names[ev];
2362 else {
2363 sprintf(buf, "?? (%u)", ev);
2364 e = buf;
2365 }
2366 fprintf(stderr, " PTRACE_EVENT_%s", e);
2367 }
2368#endif
2369 strcpy(buf, "???");
2370 if (WIFSIGNALED(status))
2371#ifdef WCOREDUMP
2372 sprintf(buf, "WIFSIGNALED,%ssig=%s",
2373 WCOREDUMP(status) ? "core," : "",
2374 signame(WTERMSIG(status)));
2375#else
2376 sprintf(buf, "WIFSIGNALED,sig=%s",
2377 signame(WTERMSIG(status)));
2378#endif
2379 if (WIFEXITED(status))
2380 sprintf(buf, "WIFEXITED,exitcode=%u", WEXITSTATUS(status));
2381 if (WIFSTOPPED(status))
2382 sprintf(buf, "WIFSTOPPED,sig=%s", signame(WSTOPSIG(status)));
Denys Vlasenko5bd67c82011-08-15 11:36:09 +02002383#ifdef WIFCONTINUED
Denys Vlasenko1d5f12e2011-06-24 16:41:35 +02002384 if (WIFCONTINUED(status))
2385 strcpy(buf, "WIFCONTINUED");
Denys Vlasenko5bd67c82011-08-15 11:36:09 +02002386#endif
Denys Vlasenko1d5f12e2011-06-24 16:41:35 +02002387 fprintf(stderr, " [wait(0x%04x) = %u] %s\n", status, pid, buf);
2388 }
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002389
2390 /* Look up `pid' in our table. */
Denys Vlasenko5d645812011-08-20 12:48:18 +02002391 tcp = pid2tcb(pid);
2392 if (tcp == NULL) {
Roland McGrathe85bbfe2003-01-09 06:53:31 +00002393#ifdef LINUX
Roland McGrath41c48222008-07-18 00:25:10 +00002394 if (followfork) {
Roland McGrathe85bbfe2003-01-09 06:53:31 +00002395 /* This is needed to go with the CLONE_PTRACE
2396 changes in process.c/util.c: we might see
2397 the child's initial trap before we see the
2398 parent return from the clone syscall.
2399 Leave the child suspended until the parent
2400 returns from its system call. Only then
2401 will we have the association of parent and
2402 child so that we know how to do clearbpt
2403 in the child. */
Denys Vlasenko418d66a2009-01-17 01:52:54 +00002404 tcp = alloctcb(pid);
Denys Vlasenko833fb132011-08-17 11:30:56 +02002405 tcp->flags |= TCB_ATTACHED;
Roland McGrathe85bbfe2003-01-09 06:53:31 +00002406 if (!qflag)
Denys Vlasenko833fb132011-08-17 11:30:56 +02002407 fprintf(stderr, "Process %d attached\n",
Roland McGrathe85bbfe2003-01-09 06:53:31 +00002408 pid);
Wichert Akkerman8b1b40c2000-02-03 21:58:30 +00002409 }
Roland McGrathe85bbfe2003-01-09 06:53:31 +00002410 else
2411 /* This can happen if a clone call used
2412 CLONE_PTRACE itself. */
Roland McGratheb9e2e82009-06-02 16:49:22 -07002413#endif
Roland McGrathe85bbfe2003-01-09 06:53:31 +00002414 {
Roland McGrathe85bbfe2003-01-09 06:53:31 +00002415 if (WIFSTOPPED(status))
2416 ptrace(PTRACE_CONT, pid, (char *) 1, 0);
Denys Vlasenkocb2ad002011-06-23 13:05:29 +02002417 error_msg_and_die("Unknown pid: %u", pid);
Roland McGrathe85bbfe2003-01-09 06:53:31 +00002418 }
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002419 }
Roland McGratheb9e2e82009-06-02 16:49:22 -07002420 /* set current output file */
2421 outf = tcp->outf;
Andreas Schwabccdff482009-10-27 16:27:13 +01002422 curcol = tcp->curcol;
Roland McGratheb9e2e82009-06-02 16:49:22 -07002423#ifdef LINUX
Denys Vlasenko13d22f12011-06-24 23:01:57 +02002424 if (cflag) {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002425 tv_sub(&tcp->dtime, &ru.ru_stime, &tcp->stime);
2426 tcp->stime = ru.ru_stime;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002427 }
Denys Vlasenko13d22f12011-06-24 23:01:57 +02002428#endif
Roland McGratheb9e2e82009-06-02 16:49:22 -07002429
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002430 if (WIFSIGNALED(status)) {
Dmitry V. Levina6809652008-11-10 17:14:58 +00002431 if (pid == strace_child)
2432 exit_code = 0x100 | WTERMSIG(status);
Dmitry V. Levine3a7ef52010-03-28 19:24:54 +00002433 if (cflag != CFLAG_ONLY_STATS
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002434 && (qual_flags[WTERMSIG(status)] & QUAL_SIGNAL)) {
2435 printleader(tcp);
Denys Vlasenko13d22f12011-06-24 23:01:57 +02002436#ifdef WCOREDUMP
Roland McGrath2efe8792004-01-13 09:59:45 +00002437 tprintf("+++ killed by %s %s+++",
2438 signame(WTERMSIG(status)),
Denys Vlasenko13d22f12011-06-24 23:01:57 +02002439 WCOREDUMP(status) ? "(core dumped) " : "");
2440#else
2441 tprintf("+++ killed by %s +++",
2442 signame(WTERMSIG(status)));
Roland McGrath2efe8792004-01-13 09:59:45 +00002443#endif
Denys Vlasenkoef2fbf82009-01-06 21:45:06 +00002444 printtrailer();
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002445 }
2446 droptcb(tcp);
2447 continue;
2448 }
2449 if (WIFEXITED(status)) {
Dmitry V. Levina6809652008-11-10 17:14:58 +00002450 if (pid == strace_child)
2451 exit_code = WEXITSTATUS(status);
Roland McGrath0a396902003-06-10 03:05:53 +00002452 if (tcp == tcp_last) {
Denys Vlasenko7a8bf062009-01-29 20:38:20 +00002453 if ((tcp->flags & (TCB_INSYSCALL|TCB_REPRINT)) == TCB_INSYSCALL)
Roland McGrath0a396902003-06-10 03:05:53 +00002454 tprintf(" <unfinished ... exit status %d>\n",
2455 WEXITSTATUS(status));
2456 tcp_last = NULL;
2457 }
Denys Vlasenko19cdada2011-08-17 10:45:32 +02002458 if (!cflag /* && (qual_flags[WTERMSIG(status)] & QUAL_SIGNAL) */ ) {
2459 printleader(tcp);
2460 tprintf("+++ exited with %d +++", WEXITSTATUS(status));
2461 printtrailer();
2462 }
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002463 droptcb(tcp);
2464 continue;
2465 }
2466 if (!WIFSTOPPED(status)) {
2467 fprintf(stderr, "PANIC: pid %u not stopped\n", pid);
2468 droptcb(tcp);
2469 continue;
2470 }
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002471
Denys Vlasenko3454e4b2011-05-23 21:29:03 +02002472 if (status >> 16) {
Denys Vlasenko833fb132011-08-17 11:30:56 +02002473 /* Ptrace event (we ignore all of them for now) */
2474 goto tracing;
Wang Chaoca8ab8d2010-11-12 17:26:08 +08002475 }
2476
Roland McGrath02203312007-06-11 22:06:31 +00002477 /*
2478 * Interestingly, the process may stop
2479 * with STOPSIG equal to some other signal
Roland McGratheb9e2e82009-06-02 16:49:22 -07002480 * than SIGSTOP if we happend to attach
Roland McGrath02203312007-06-11 22:06:31 +00002481 * just before the process takes a signal.
Mike Frysingerc1a5b7e2009-10-07 20:41:29 -04002482 * A no-MMU vforked child won't send up a signal,
2483 * so skip the first (lost) execve notification.
Roland McGrath02203312007-06-11 22:06:31 +00002484 */
Mike Frysingerc1a5b7e2009-10-07 20:41:29 -04002485 if ((tcp->flags & TCB_STARTUP) &&
2486 (WSTOPSIG(status) == SIGSTOP || strace_vforked)) {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002487 /*
2488 * This flag is there to keep us in sync.
2489 * Next time this process stops it should
2490 * really be entering a system call.
2491 */
2492 tcp->flags &= ~TCB_STARTUP;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002493 if (tcp->flags & TCB_BPTSET) {
Roland McGrath02203312007-06-11 22:06:31 +00002494 /*
2495 * One example is a breakpoint inherited from
Denys Vlasenko2ecba322011-08-21 17:35:39 +02002496 * parent through fork().
Roland McGrath02203312007-06-11 22:06:31 +00002497 */
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002498 if (clearbpt(tcp) < 0) /* Pretty fatal */ {
2499 droptcb(tcp);
2500 cleanup();
2501 return -1;
2502 }
2503 }
Wang Chaoca8ab8d2010-11-12 17:26:08 +08002504#ifdef LINUX
Denys Vlasenko44f87ef2011-08-17 15:18:21 +02002505 if (ptrace_setoptions) {
2506 if (debug)
2507 fprintf(stderr, "setting opts %x on pid %d\n", ptrace_setoptions, tcp->pid);
2508 if (ptrace(PTRACE_SETOPTIONS, tcp->pid, NULL, ptrace_setoptions) < 0) {
2509 if (errno != ESRCH) {
2510 /* Should never happen, really */
2511 perror_msg_and_die("PTRACE_SETOPTIONS");
Denys Vlasenko3454e4b2011-05-23 21:29:03 +02002512 }
2513 }
2514 }
Wang Chaoca8ab8d2010-11-12 17:26:08 +08002515#endif
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002516 goto tracing;
2517 }
2518
Denys Vlasenko75422762011-05-27 14:36:01 +02002519 if (WSTOPSIG(status) != syscall_trap_sig) {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002520 if (WSTOPSIG(status) == SIGSTOP &&
2521 (tcp->flags & TCB_SIGTRAPPED)) {
2522 /*
2523 * Trapped attempt to block SIGTRAP
2524 * Hope we are back in control now.
2525 */
2526 tcp->flags &= ~(TCB_INSYSCALL | TCB_SIGTRAPPED);
Denys Vlasenko732d1bf2008-12-17 19:21:59 +00002527 if (ptrace_restart(PTRACE_SYSCALL, tcp, 0) < 0) {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002528 cleanup();
2529 return -1;
2530 }
2531 continue;
2532 }
Dmitry V. Levine3a7ef52010-03-28 19:24:54 +00002533 if (cflag != CFLAG_ONLY_STATS
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002534 && (qual_flags[WSTOPSIG(status)] & QUAL_SIGNAL)) {
Dmitry V. Levinc15dfc72011-03-10 14:44:45 +00002535 siginfo_t si;
2536#if defined(PT_CR_IPSR) && defined(PT_CR_IIP)
Dmitry V. Levin6b7a2612011-03-10 21:20:35 +00002537 long pc = 0;
2538 long psr = 0;
Wichert Akkerman7b3346b2001-10-09 23:47:38 +00002539
Denys Vlasenko932fc7d2008-12-16 18:18:40 +00002540 upeek(tcp, PT_CR_IPSR, &psr);
2541 upeek(tcp, PT_CR_IIP, &pc);
Wichert Akkerman7b3346b2001-10-09 23:47:38 +00002542
Dmitry V. Levin6b7a2612011-03-10 21:20:35 +00002543# define PSR_RI 41
Wichert Akkerman7b3346b2001-10-09 23:47:38 +00002544 pc += (psr >> PSR_RI) & 0x3;
Dmitry V. Levin6b7a2612011-03-10 21:20:35 +00002545# define PC_FORMAT_STR " @ %lx"
Denys Vlasenko2ecba322011-08-21 17:35:39 +02002546# define PC_FORMAT_ARG , pc
Dmitry V. Levin6b7a2612011-03-10 21:20:35 +00002547#else
Denys Vlasenko2ecba322011-08-21 17:35:39 +02002548# define PC_FORMAT_STR ""
2549# define PC_FORMAT_ARG /* nothing */
Wichert Akkerman7b3346b2001-10-09 23:47:38 +00002550#endif
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002551 printleader(tcp);
Dmitry V. Levin6b7a2612011-03-10 21:20:35 +00002552 if (ptrace(PTRACE_GETSIGINFO, pid, 0, &si) == 0) {
2553 tprintf("--- ");
2554 printsiginfo(&si, verbose(tcp));
2555 tprintf(" (%s)" PC_FORMAT_STR " ---",
Denys Vlasenko2ecba322011-08-21 17:35:39 +02002556 strsignal(WSTOPSIG(status))
Dmitry V. Levin6b7a2612011-03-10 21:20:35 +00002557 PC_FORMAT_ARG);
2558 } else
2559 tprintf("--- %s by %s" PC_FORMAT_STR " ---",
2560 strsignal(WSTOPSIG(status)),
Denys Vlasenko2ecba322011-08-21 17:35:39 +02002561 signame(WSTOPSIG(status))
Dmitry V. Levin6b7a2612011-03-10 21:20:35 +00002562 PC_FORMAT_ARG);
Denys Vlasenkoef2fbf82009-01-06 21:45:06 +00002563 printtrailer();
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002564 }
Denys Vlasenko732d1bf2008-12-17 19:21:59 +00002565 if (ptrace_restart(PTRACE_SYSCALL, tcp, WSTOPSIG(status)) < 0) {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002566 cleanup();
2567 return -1;
2568 }
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002569 continue;
2570 }
Denys Vlasenko2ecba322011-08-21 17:35:39 +02002571
2572 /* We handled quick cases, we are permitted to interrupt now. */
Roland McGrath02203312007-06-11 22:06:31 +00002573 if (interrupted)
2574 return 0;
Denys Vlasenko2ecba322011-08-21 17:35:39 +02002575
2576 /* This should be syscall entry or exit.
2577 * (Or it still can be that pesky post-execve SIGTRAP!)
2578 * Handle it.
2579 */
Roland McGratheb9e2e82009-06-02 16:49:22 -07002580 if (trace_syscall(tcp) < 0 && !tcp->ptrace_errno) {
2581 /* ptrace() failed in trace_syscall() with ESRCH.
2582 * Likely a result of process disappearing mid-flight.
2583 * Observed case: exit_group() terminating
2584 * all processes in thread group. In this case, threads
2585 * "disappear" in an unpredictable moment without any
2586 * notification to strace via wait().
Denys Vlasenkoef2fbf82009-01-06 21:45:06 +00002587 */
2588 if (tcp->flags & TCB_ATTACHED) {
Roland McGratheb9e2e82009-06-02 16:49:22 -07002589 if (tcp_last) {
2590 /* Do we have dangling line "syscall(param, param"?
Denys Vlasenko178de002011-06-24 22:54:25 +02002591 * Finish the line then.
Roland McGratheb9e2e82009-06-02 16:49:22 -07002592 */
2593 tcp_last->flags |= TCB_REPRINT;
2594 tprintf(" <unfinished ...>");
2595 printtrailer();
2596 }
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002597 detach(tcp, 0);
Denys Vlasenkoef2fbf82009-01-06 21:45:06 +00002598 } else {
Roland McGratheb9e2e82009-06-02 16:49:22 -07002599 ptrace(PTRACE_KILL,
2600 tcp->pid, (char *) 1, SIGTERM);
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002601 droptcb(tcp);
2602 }
2603 continue;
2604 }
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002605 tracing:
Andreas Schwabccdff482009-10-27 16:27:13 +01002606 /* Remember current print column before continuing. */
2607 tcp->curcol = curcol;
Denys Vlasenko732d1bf2008-12-17 19:21:59 +00002608 if (ptrace_restart(PTRACE_SYSCALL, tcp, 0) < 0) {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002609 cleanup();
2610 return -1;
2611 }
2612 }
2613 return 0;
2614}
2615
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00002616#endif /* !USE_PROCFS */
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002617
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002618void
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002619tprintf(const char *fmt, ...)
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002620{
2621 va_list args;
2622
Andreas Schwabe5355de2009-10-27 16:56:43 +01002623 va_start(args, fmt);
Roland McGrathb310a0c2003-11-06 23:41:22 +00002624 if (outf) {
2625 int n = vfprintf(outf, fmt, args);
Andreas Schwabccdff482009-10-27 16:27:13 +01002626 if (n < 0) {
2627 if (outf != stderr)
2628 perror(outfname == NULL
2629 ? "<writing to pipe>" : outfname);
2630 } else
Roland McGrathb310a0c2003-11-06 23:41:22 +00002631 curcol += n;
2632 }
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002633 va_end(args);
2634 return;
2635}
2636
2637void
Denys Vlasenko12014262011-05-30 14:00:14 +02002638printleader(struct tcb *tcp)
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002639{
Denys Vlasenko732d1bf2008-12-17 19:21:59 +00002640 if (tcp_last) {
Roland McGratheb9e2e82009-06-02 16:49:22 -07002641 if (tcp_last->ptrace_errno) {
Denys Vlasenko7e0615f2009-01-28 19:00:54 +00002642 if (tcp_last->flags & TCB_INSYSCALL) {
Denys Vlasenkoe62df002011-06-08 16:15:04 +02002643 tprintf(" <unavailable>) ");
Roland McGratheb9e2e82009-06-02 16:49:22 -07002644 tabto(acolumn);
Denys Vlasenko7e0615f2009-01-28 19:00:54 +00002645 }
Roland McGratheb9e2e82009-06-02 16:49:22 -07002646 tprintf("= ? <unavailable>\n");
2647 tcp_last->ptrace_errno = 0;
Denys Vlasenko732d1bf2008-12-17 19:21:59 +00002648 } else if (!outfname || followfork < 2 || tcp_last == tcp) {
Denys Vlasenko7e0615f2009-01-28 19:00:54 +00002649 tcp_last->flags |= TCB_REPRINT;
Roland McGratheb9e2e82009-06-02 16:49:22 -07002650 tprintf(" <unfinished ...>\n");
Denys Vlasenko732d1bf2008-12-17 19:21:59 +00002651 }
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002652 }
2653 curcol = 0;
2654 if ((followfork == 1 || pflag_seen > 1) && outfname)
2655 tprintf("%-5d ", tcp->pid);
2656 else if (nprocs > 1 && !outfname)
2657 tprintf("[pid %5u] ", tcp->pid);
2658 if (tflag) {
2659 char str[sizeof("HH:MM:SS")];
2660 struct timeval tv, dtv;
2661 static struct timeval otv;
2662
2663 gettimeofday(&tv, NULL);
2664 if (rflag) {
2665 if (otv.tv_sec == 0)
2666 otv = tv;
2667 tv_sub(&dtv, &tv, &otv);
2668 tprintf("%6ld.%06ld ",
2669 (long) dtv.tv_sec, (long) dtv.tv_usec);
2670 otv = tv;
2671 }
2672 else if (tflag > 2) {
2673 tprintf("%ld.%06ld ",
2674 (long) tv.tv_sec, (long) tv.tv_usec);
2675 }
2676 else {
2677 time_t local = tv.tv_sec;
2678 strftime(str, sizeof(str), "%T", localtime(&local));
2679 if (tflag > 1)
2680 tprintf("%s.%06ld ", str, (long) tv.tv_usec);
2681 else
2682 tprintf("%s ", str);
2683 }
2684 }
2685 if (iflag)
2686 printcall(tcp);
2687}
2688
2689void
Denys Vlasenko12014262011-05-30 14:00:14 +02002690tabto(int col)
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002691{
2692 if (curcol < col)
2693 tprintf("%*s", col - curcol, "");
2694}
2695
2696void
Denys Vlasenkoef2fbf82009-01-06 21:45:06 +00002697printtrailer(void)
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00002698{
2699 tprintf("\n");
2700 tcp_last = NULL;
2701}
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00002702
Wichert Akkermanea78f0f1999-11-29 15:34:02 +00002703#ifdef HAVE_MP_PROCFS
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00002704
Denys Vlasenkoef2fbf82009-01-06 21:45:06 +00002705int
2706mp_ioctl(int fd, int cmd, void *arg, int size)
2707{
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00002708 struct iovec iov[2];
2709 int n = 1;
Roland McGrath553a6092002-12-16 20:40:39 +00002710
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00002711 iov[0].iov_base = &cmd;
2712 iov[0].iov_len = sizeof cmd;
2713 if (arg) {
2714 ++n;
2715 iov[1].iov_base = arg;
2716 iov[1].iov_len = size;
2717 }
Roland McGrath553a6092002-12-16 20:40:39 +00002718
Denys Vlasenkoef2fbf82009-01-06 21:45:06 +00002719 return writev(fd, iov, n);
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00002720}
2721
2722#endif