granicus.if.org Git - strace/blob - strace.c

   1 /*
   2  * Copyright (c) 1991, 1992 Paul Kranenburg <pk@cs.few.eur.nl>
   3  * Copyright (c) 1993 Branko Lankester <branko@hacktic.nl>
   4  * Copyright (c) 1993, 1994, 1995, 1996 Rick Sladkey <jrs@world.std.com>
   5  * Copyright (c) 1996-1999 Wichert Akkerman <wichert@cistron.nl>
   6  * 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
  35 #include <sys/types.h>
  36 #include <signal.h>
  37 #include <errno.h>
  38 #include <sys/param.h>
  39 #include <fcntl.h>
  40 #include <sys/resource.h>
  41 #include <sys/wait.h>
  42 #include <sys/stat.h>
  43 #include <pwd.h>
  44 #include <grp.h>
  45 #include <string.h>
  46 #include <limits.h>
  47 #include <dirent.h>
  48
  49 #ifdef LINUX
  50 # include <asm/unistd.h>
  51 # if defined __NR_tgkill
  52 #  define my_tgkill(pid, tid, sig) syscall (__NR_tgkill, (pid), (tid), (sig))
  53 # elif defined __NR_tkill
  54 #  define my_tgkill(pid, tid, sig) syscall (__NR_tkill, (tid), (sig))
  55 # else
  56    /* kill() may choose arbitrarily the target task of the process group
  57       while we later wait on a that specific TID.  PID process waits become
  58       TID task specific waits for a process under ptrace(2).  */
  59 #  warning "Neither tkill(2) nor tgkill(2) available, risk of strace hangs!"
  60 #  define my_tgkill(pid, tid, sig) kill ((tid), (sig))
  61 # endif
  62 #endif
  63
  64 #if defined(IA64) && defined(LINUX)
  65 # include <asm/ptrace_offsets.h>
  66 #endif
  67
  68 #ifdef USE_PROCFS
  69 #include <poll.h>
  70 #endif
  71
  72 #ifdef SVR4
  73 #include <sys/stropts.h>
  74 #ifdef HAVE_MP_PROCFS
  75 #ifdef HAVE_SYS_UIO_H
  76 #include <sys/uio.h>
  77 #endif
  78 #endif
  79 #endif
  80 extern char **environ;
  81 extern int optind;
  82 extern char *optarg;
  83
  84
  85 int debug = 0, followfork = 0;
  86 unsigned int ptrace_setoptions = 0;
  87 int dtime = 0, xflag = 0, qflag = 0;
  88 cflag_t cflag = CFLAG_NONE;
  89 static int iflag = 0, interactive = 0, pflag_seen = 0, rflag = 0, tflag = 0;
  90 /*
  91  * daemonized_tracer supports -D option.
  92  * With this option, strace forks twice.
  93  * Unlike normal case, with -D *grandparent* process exec's,
  94  * becoming a traced process. Child exits (this prevents traced process
  95  * from having children it doesn't expect to have), and grandchild
  96  * attaches to grandparent similarly to strace -p PID.
  97  * This allows for more transparent interaction in cases
  98  * when process and its parent are communicating via signals,
  99  * wait() etc. Without -D, strace process gets lodged in between,
 100  * disrupting parent<->child link.
 101  */
 102 static bool daemonized_tracer = 0;
 103
 104 /* Sometimes we want to print only succeeding syscalls. */
 105 int not_failing_only = 0;
 106
 107 static int exit_code = 0;
 108 static int strace_child = 0;
 109
 110 static char *username = NULL;
 111 uid_t run_uid;
 112 gid_t run_gid;
 113
 114 int acolumn = DEFAULT_ACOLUMN;
 115 int max_strlen = DEFAULT_STRLEN;
 116 static char *outfname = NULL;
 117 FILE *outf;
 118 static int curcol;
 119 struct tcb **tcbtab;
 120 unsigned int nprocs, tcbtabsize;
 121 const char *progname;
 122 extern char **environ;
 123
 124 static int detach(struct tcb *tcp, int sig);
 125 static int trace(void);
 126 static void cleanup(void);
 127 static void interrupt(int sig);
 128 static sigset_t empty_set, blocked_set;
 129
 130 #ifdef HAVE_SIG_ATOMIC_T
 131 static volatile sig_atomic_t interrupted;
 132 #else /* !HAVE_SIG_ATOMIC_T */
 133 static volatile int interrupted;
 134 #endif /* !HAVE_SIG_ATOMIC_T */
 135
 136 #ifdef USE_PROCFS
 137
 138 static struct tcb *pfd2tcb(int pfd);
 139 static void reaper(int sig);
 140 static void rebuild_pollv(void);
 141 static struct pollfd *pollv;
 142
 143 #ifndef HAVE_POLLABLE_PROCFS
 144
 145 static void proc_poll_open(void);
 146 static void proc_poller(int pfd);
 147
 148 struct proc_pollfd {
 149         int fd;
 150         int revents;
 151         int pid;
 152 };
 153
 154 static int poller_pid;
 155 static int proc_poll_pipe[2] = { -1, -1 };
 156
 157 #endif /* !HAVE_POLLABLE_PROCFS */
 158
 159 #ifdef HAVE_MP_PROCFS
 160 #define POLLWANT        POLLWRNORM
 161 #else
 162 #define POLLWANT        POLLPRI
 163 #endif
 164 #endif /* USE_PROCFS */
 165
 166 static void
 167 usage(ofp, exitval)
 168 FILE *ofp;
 169 int exitval;
 170 {
 171         fprintf(ofp, "\
 172 usage: strace [-CdDffhiqrtttTvVxx] [-a column] [-e expr] ... [-o file]\n\
 173               [-p pid] ... [-s strsize] [-u username] [-E var=val] ...\n\
 174               [command [arg ...]]\n\
 175    or: strace -c [-D] [-e expr] ... [-O overhead] [-S sortby] [-E var=val] ...\n\
 176               [command [arg ...]]\n\
 177 -c -- count time, calls, and errors for each syscall and report summary\n\
 178 -C -- like -c but also print regular output while processes are running\n\
 179 -f -- follow forks, -ff -- with output into separate files\n\
 180 -F -- attempt to follow vforks, -h -- print help message\n\
 181 -i -- print instruction pointer at time of syscall\n\
 182 -q -- suppress messages about attaching, detaching, etc.\n\
 183 -r -- print relative timestamp, -t -- absolute timestamp, -tt -- with usecs\n\
 184 -T -- print time spent in each syscall, -V -- print version\n\
 185 -v -- verbose mode: print unabbreviated argv, stat, termio[s], etc. args\n\
 186 -x -- print non-ascii strings in hex, -xx -- print all strings in hex\n\
 187 -a column -- alignment COLUMN for printing syscall results (default %d)\n\
 188 -e expr -- a qualifying expression: option=[!]all or option=[!]val1[,val2]...\n\
 189    options: trace, abbrev, verbose, raw, signal, read, or write\n\
 190 -o file -- send trace output to FILE instead of stderr\n\
 191 -O overhead -- set overhead for tracing syscalls to OVERHEAD usecs\n\
 192 -p pid -- trace process with process id PID, may be repeated\n\
 193 -D -- run tracer process as a detached grandchild, not as parent\n\
 194 -s strsize -- limit length of print strings to STRSIZE chars (default %d)\n\
 195 -S sortby -- sort syscall counts by: time, calls, name, nothing (default %s)\n\
 196 -u username -- run command as username handling setuid and/or setgid\n\
 197 -E var=val -- put var=val in the environment for command\n\
 198 -E var -- remove var from the environment for command\n\
 199 " /* this is broken, so don't document it
 200 -z -- print only succeeding syscalls\n\
 201   */
 202 , DEFAULT_ACOLUMN, DEFAULT_STRLEN, DEFAULT_SORTBY);
 203         exit(exitval);
 204 }
 205
 206 #ifdef SVR4
 207 #ifdef MIPS
 208 void
 209 foobar()
 210 {
 211 }
 212 #endif /* MIPS */
 213 #endif /* SVR4 */
 214
 215 /* Glue for systems without a MMU that cannot provide fork() */
 216 #ifdef HAVE_FORK
 217 # define strace_vforked 0
 218 #else
 219 # define strace_vforked 1
 220 # define fork()         vfork()
 221 #endif
 222
 223 static int
 224 set_cloexec_flag(int fd)
 225 {
 226         int     flags, newflags;
 227
 228         if ((flags = fcntl(fd, F_GETFD, 0)) < 0)
 229         {
 230                 fprintf(stderr, "%s: fcntl F_GETFD: %s\n",
 231                         progname, strerror(errno));
 232                 return -1;
 233         }
 234
 235         newflags = flags | FD_CLOEXEC;
 236         if (flags == newflags)
 237                 return 0;
 238
 239         if (fcntl(fd, F_SETFD, newflags) < 0)
 240         {
 241                 fprintf(stderr, "%s: fcntl F_SETFD: %s\n",
 242                         progname, strerror(errno));
 243                 return -1;
 244         }
 245
 246         return 0;
 247 }
 248
 249 /*
 250  * When strace is setuid executable, we have to swap uids
 251  * before and after filesystem and process management operations.
 252  */
 253 static void
 254 swap_uid(void)
 255 {
 256 #ifndef SVR4
 257         int euid = geteuid(), uid = getuid();
 258
 259         if (euid != uid && setreuid(euid, uid) < 0)
 260         {
 261                 fprintf(stderr, "%s: setreuid: %s\n",
 262                         progname, strerror(errno));
 263                 exit(1);
 264         }
 265 #endif
 266 }
 267
 268 #if _LFS64_LARGEFILE
 269 # define fopen_for_output fopen64
 270 #else
 271 # define fopen_for_output fopen
 272 #endif
 273
 274 static FILE *
 275 strace_fopen(const char *path, const char *mode)
 276 {
 277         FILE *fp;
 278
 279         swap_uid();
 280         if ((fp = fopen_for_output(path, mode)) == NULL)
 281                 fprintf(stderr, "%s: can't fopen '%s': %s\n",
 282                         progname, path, strerror(errno));
 283         swap_uid();
 284         if (fp && set_cloexec_flag(fileno(fp)) < 0)
 285         {
 286                 fclose(fp);
 287                 fp = NULL;
 288         }
 289         return fp;
 290 }
 291
 292 static int popen_pid = -1;
 293
 294 #ifndef _PATH_BSHELL
 295 # define _PATH_BSHELL "/bin/sh"
 296 #endif
 297
 298 /*
 299  * We cannot use standard popen(3) here because we have to distinguish
 300  * popen child process from other processes we trace, and standard popen(3)
 301  * does not export its child's pid.
 302  */
 303 static FILE *
 304 strace_popen(const char *command)
 305 {
 306         int     fds[2];
 307
 308         swap_uid();
 309         if (pipe(fds) < 0)
 310         {
 311                 fprintf(stderr, "%s: pipe: %s\n",
 312                         progname, strerror(errno));
 313                 swap_uid();
 314                 return NULL;
 315         }
 316
 317         if (set_cloexec_flag(fds[1]) < 0)
 318         {
 319                 close(fds[0]);
 320                 close(fds[1]);
 321                 swap_uid();
 322                 return NULL;
 323         }
 324
 325         if ((popen_pid = fork()) == -1)
 326         {
 327                 fprintf(stderr, "%s: fork: %s\n",
 328                         progname, strerror(errno));
 329                 close(fds[0]);
 330                 close(fds[1]);
 331                 swap_uid();
 332                 return NULL;
 333         }
 334
 335         if (popen_pid)
 336         {
 337                 /* parent */
 338                 close(fds[0]);
 339                 swap_uid();
 340                 return fdopen(fds[1], "w");
 341         } else
 342         {
 343                 /* child */
 344                 close(fds[1]);
 345                 if (fds[0] && (dup2(fds[0], 0) || close(fds[0])))
 346                 {
 347                         fprintf(stderr, "%s: dup2: %s\n",
 348                                 progname, strerror(errno));
 349                         _exit(1);
 350                 }
 351                 execl(_PATH_BSHELL, "sh", "-c", command, NULL);
 352                 fprintf(stderr, "%s: execl: %s: %s\n",
 353                         progname, _PATH_BSHELL, strerror(errno));
 354                 _exit(1);
 355         }
 356 }
 357
 358 static int
 359 newoutf(struct tcb *tcp)
 360 {
 361         if (outfname && followfork > 1) {
 362                 char name[520 + sizeof(int) * 3];
 363                 FILE *fp;
 364
 365                 sprintf(name, "%.512s.%u", outfname, tcp->pid);
 366                 if ((fp = strace_fopen(name, "w")) == NULL)
 367                         return -1;
 368                 tcp->outf = fp;
 369         }
 370         return 0;
 371 }
 372
 373 static void
 374 startup_attach(void)
 375 {
 376         int tcbi;
 377         struct tcb *tcp;
 378
 379         /*
 380          * Block user interruptions as we would leave the traced
 381          * process stopped (process state T) if we would terminate in
 382          * between PTRACE_ATTACH and wait4 () on SIGSTOP.
 383          * We rely on cleanup () from this point on.
 384          */
 385         if (interactive)
 386                 sigprocmask(SIG_BLOCK, &blocked_set, NULL);
 387
 388         if (daemonized_tracer) {
 389                 pid_t pid = fork();
 390                 if (pid < 0) {
 391                         _exit(1);
 392                 }
 393                 if (pid) { /* parent */
 394                         /*
 395                          * Wait for child to attach to straced process
 396                          * (our parent). Child SIGKILLs us after it attached.
 397                          * Parent's wait() is unblocked by our death,
 398                          * it proceeds to exec the straced program.
 399                          */
 400                         pause();
 401                         _exit(0); /* paranoia */
 402                 }
 403         }
 404
 405         for (tcbi = 0; tcbi < tcbtabsize; tcbi++) {
 406                 tcp = tcbtab[tcbi];
 407                 if (!(tcp->flags & TCB_INUSE) || !(tcp->flags & TCB_ATTACHED))
 408                         continue;
 409 #ifdef LINUX
 410                 if (tcp->flags & TCB_CLONE_THREAD)
 411                         continue;
 412 #endif
 413                 /* Reinitialize the output since it may have changed. */
 414                 tcp->outf = outf;
 415                 if (newoutf(tcp) < 0)
 416                         exit(1);
 417
 418 #ifdef USE_PROCFS
 419                 if (proc_open(tcp, 1) < 0) {
 420                         fprintf(stderr, "trouble opening proc file\n");
 421                         droptcb(tcp);
 422                         continue;
 423                 }
 424 #else /* !USE_PROCFS */
 425 # ifdef LINUX
 426                 if (followfork && !daemonized_tracer) {
 427                         char procdir[sizeof("/proc/%d/task") + sizeof(int) * 3];
 428                         DIR *dir;
 429
 430                         sprintf(procdir, "/proc/%d/task", tcp->pid);
 431                         dir = opendir(procdir);
 432                         if (dir != NULL) {
 433                                 unsigned int ntid = 0, nerr = 0;
 434                                 struct dirent *de;
 435                                 int tid;
 436                                 while ((de = readdir(dir)) != NULL) {
 437                                         if (de->d_fileno == 0)
 438                                                 continue;
 439                                         tid = atoi(de->d_name);
 440                                         if (tid <= 0)
 441                                                 continue;
 442                                         ++ntid;
 443                                         if (ptrace(PTRACE_ATTACH, tid, (char *) 1, 0) < 0)
 444                                                 ++nerr;
 445                                         else if (tid != tcbtab[tcbi]->pid) {
 446                                                 tcp = alloctcb(tid);
 447                                                 tcp->flags |= TCB_ATTACHED|TCB_CLONE_THREAD|TCB_FOLLOWFORK;
 448                                                 tcbtab[tcbi]->nchildren++;
 449                                                 tcbtab[tcbi]->nclone_threads++;
 450                                                 tcp->parent = tcbtab[tcbi];
 451                                         }
 452                                         if (interactive) {
 453                                                 sigprocmask(SIG_SETMASK, &empty_set, NULL);
 454                                                 if (interrupted)
 455                                                         return;
 456                                                 sigprocmask(SIG_BLOCK, &blocked_set, NULL);
 457                                         }
 458                                 }
 459                                 closedir(dir);
 460                                 ntid -= nerr;
 461                                 if (ntid == 0) {
 462                                         perror("attach: ptrace(PTRACE_ATTACH, ...)");
 463                                         droptcb(tcp);
 464                                         continue;
 465                                 }
 466                                 if (!qflag) {
 467                                         fprintf(stderr, ntid > 1
 468 ? "Process %u attached with %u threads - interrupt to quit\n"
 469 : "Process %u attached - interrupt to quit\n",
 470                                                 tcbtab[tcbi]->pid, ntid);
 471                                 }
 472                                 continue;
 473                         } /* if (opendir worked) */
 474                 } /* if (-f) */
 475 # endif
 476                 if (ptrace(PTRACE_ATTACH, tcp->pid, (char *) 1, 0) < 0) {
 477                         perror("attach: ptrace(PTRACE_ATTACH, ...)");
 478                         droptcb(tcp);
 479                         continue;
 480                 }
 481                 /* INTERRUPTED is going to be checked at the top of TRACE.  */
 482
 483                 if (daemonized_tracer) {
 484                         /*
 485                          * It is our grandparent we trace, not a -p PID.
 486                          * Don't want to just detach on exit, so...
 487                          */
 488                         tcp->flags &= ~TCB_ATTACHED;
 489                         /*
 490                          * Make parent go away.
 491                          * Also makes grandparent's wait() unblock.
 492                          */
 493                         kill(getppid(), SIGKILL);
 494                 }
 495
 496 #endif /* !USE_PROCFS */
 497                 if (!qflag)
 498                         fprintf(stderr,
 499                                 "Process %u attached - interrupt to quit\n",
 500                                 tcp->pid);
 501         }
 502
 503         if (interactive)
 504                 sigprocmask(SIG_SETMASK, &empty_set, NULL);
 505 }
 506
 507 static void
 508 startup_child (char **argv)
 509 {
 510         struct stat statbuf;
 511         const char *filename;
 512         char pathname[MAXPATHLEN];
 513         int pid = 0;
 514         struct tcb *tcp;
 515
 516         filename = argv[0];
 517         if (strchr(filename, '/')) {
 518                 if (strlen(filename) > sizeof pathname - 1) {
 519                         errno = ENAMETOOLONG;
 520                         perror("strace: exec");
 521                         exit(1);
 522                 }
 523                 strcpy(pathname, filename);
 524         }
 525 #ifdef USE_DEBUGGING_EXEC
 526         /*
 527          * Debuggers customarily check the current directory
 528          * first regardless of the path but doing that gives
 529          * security geeks a panic attack.
 530          */
 531         else if (stat(filename, &statbuf) == 0)
 532                 strcpy(pathname, filename);
 533 #endif /* USE_DEBUGGING_EXEC */
 534         else {
 535                 const char *path;
 536                 int m, n, len;
 537
 538                 for (path = getenv("PATH"); path && *path; path += m) {
 539                         if (strchr(path, ':')) {
 540                                 n = strchr(path, ':') - path;
 541                                 m = n + 1;
 542                         }
 543                         else
 544                                 m = n = strlen(path);
 545                         if (n == 0) {
 546                                 if (!getcwd(pathname, MAXPATHLEN))
 547                                         continue;
 548                                 len = strlen(pathname);
 549                         }
 550                         else if (n > sizeof pathname - 1)
 551                                 continue;
 552                         else {
 553                                 strncpy(pathname, path, n);
 554                                 len = n;
 555                         }
 556                         if (len && pathname[len - 1] != '/')
 557                                 pathname[len++] = '/';
 558                         strcpy(pathname + len, filename);
 559                         if (stat(pathname, &statbuf) == 0 &&
 560                             /* Accept only regular files
 561                                with some execute bits set.
 562                                XXX not perfect, might still fail */
 563                             S_ISREG(statbuf.st_mode) &&
 564                             (statbuf.st_mode & 0111))
 565                                 break;
 566                 }
 567         }
 568         if (stat(pathname, &statbuf) < 0) {
 569                 fprintf(stderr, "%s: %s: command not found\n",
 570                         progname, filename);
 571                 exit(1);
 572         }
 573         strace_child = pid = fork();
 574         if (pid < 0) {
 575                 perror("strace: fork");
 576                 cleanup();
 577                 exit(1);
 578         }
 579         if ((pid != 0 && daemonized_tracer) /* parent: to become a traced process */
 580          || (pid == 0 && !daemonized_tracer) /* child: to become a traced process */
 581         ) {
 582                 pid = getpid();
 583 #ifdef USE_PROCFS
 584                 if (outf != stderr) close (fileno (outf));
 585 #ifdef MIPS
 586                 /* Kludge for SGI, see proc_open for details. */
 587                 sa.sa_handler = foobar;
 588                 sa.sa_flags = 0;
 589                 sigemptyset(&sa.sa_mask);
 590                 sigaction(SIGINT, &sa, NULL);
 591 #endif /* MIPS */
 592 #ifndef FREEBSD
 593                 pause();
 594 #else /* FREEBSD */
 595                 kill(pid, SIGSTOP); /* stop HERE */
 596 #endif /* FREEBSD */
 597 #else /* !USE_PROCFS */
 598                 if (outf!=stderr)
 599                         close(fileno (outf));
 600
 601                 if (!daemonized_tracer) {
 602                         if (ptrace(PTRACE_TRACEME, 0, (char *) 1, 0) < 0) {
 603                                 perror("strace: ptrace(PTRACE_TRACEME, ...)");
 604                                 exit(1);
 605                         }
 606                         if (debug)
 607                                 kill(pid, SIGSTOP);
 608                 }
 609
 610                 if (username != NULL || geteuid() == 0) {
 611                         uid_t run_euid = run_uid;
 612                         gid_t run_egid = run_gid;
 613
 614                         if (statbuf.st_mode & S_ISUID)
 615                                 run_euid = statbuf.st_uid;
 616                         if (statbuf.st_mode & S_ISGID)
 617                                 run_egid = statbuf.st_gid;
 618
 619                         /*
 620                          * It is important to set groups before we
 621                          * lose privileges on setuid.
 622                          */
 623                         if (username != NULL) {
 624                                 if (initgroups(username, run_gid) < 0) {
 625                                         perror("initgroups");
 626                                         exit(1);
 627                                 }
 628                                 if (setregid(run_gid, run_egid) < 0) {
 629                                         perror("setregid");
 630                                         exit(1);
 631                                 }
 632                                 if (setreuid(run_uid, run_euid) < 0) {
 633                                         perror("setreuid");
 634                                         exit(1);
 635                                 }
 636                         }
 637                 }
 638                 else
 639                         setreuid(run_uid, run_uid);
 640
 641                 if (!daemonized_tracer) {
 642                         /*
 643                          * Induce an immediate stop so that the parent
 644                          * will resume us with PTRACE_SYSCALL and display
 645                          * this execve call normally.
 646                          * Unless of course we're on a no-MMU system where
 647                          * we vfork()-ed, so we cannot stop the child.
 648                          */
 649                         if (!strace_vforked)
 650                                 kill(getpid(), SIGSTOP);
 651                 } else {
 652                         struct sigaction sv_sigchld;
 653                         sigaction(SIGCHLD, NULL, &sv_sigchld);
 654                         /*
 655                          * Make sure it is not SIG_IGN, otherwise wait
 656                          * will not block.
 657                          */
 658                         signal(SIGCHLD, SIG_DFL);
 659                         /*
 660                          * Wait for grandchild to attach to us.
 661                          * It kills child after that, and wait() unblocks.
 662                          */
 663                         alarm(3);
 664                         wait(NULL);
 665                         alarm(0);
 666                         sigaction(SIGCHLD, &sv_sigchld, NULL);
 667                 }
 668 #endif /* !USE_PROCFS */
 669
 670                 execv(pathname, argv);
 671                 perror("strace: exec");
 672                 _exit(1);
 673         }
 674
 675         /* We are the tracer.  */
 676         tcp = alloctcb(daemonized_tracer ? getppid() : pid);
 677         if (daemonized_tracer) {
 678                 /* We want subsequent startup_attach() to attach to it.  */
 679                 tcp->flags |= TCB_ATTACHED;
 680         }
 681 #ifdef USE_PROCFS
 682         if (proc_open(tcp, 0) < 0) {
 683                 fprintf(stderr, "trouble opening proc file\n");
 684                 cleanup();
 685                 exit(1);
 686         }
 687 #endif /* USE_PROCFS */
 688 }
 689
 690 #ifdef LINUX
 691 /*
 692  * Test whether the kernel support PTRACE_O_TRACECLONE et al options.
 693  * First fork a new child, call ptrace with PTRACE_SETOPTIONS on it,
 694  * and then see which options are supported by the kernel.
 695  */
 696 static int
 697 test_ptrace_setoptions(void)
 698 {
 699         int pid;
 700
 701         if ((pid = fork()) < 0)
 702                 return -1;
 703         else if (pid == 0) {
 704                 if (ptrace(PTRACE_TRACEME, 0, (char *)1, 0) < 0)
 705                         _exit(1);
 706                 kill(getpid(), SIGSTOP);
 707                 _exit(fork() < 0);
 708         }
 709
 710         while (1) {
 711                 int status, tracee_pid;
 712
 713                 tracee_pid = wait(&status);
 714                 if (tracee_pid == -1) {
 715                         if (errno == EINTR)
 716                                 continue;
 717                         else if (errno == ECHILD)
 718                                 break;
 719                         perror("test_ptrace_setoptions");
 720                         return -1;
 721                 }
 722                 if (tracee_pid != pid) {
 723                         /* the grandchild */
 724                         if (ptrace(PTRACE_CONT, tracee_pid, 0, 0) < 0 &&
 725                             errno != ESRCH)
 726                                 kill(tracee_pid, SIGKILL);
 727                 }
 728                 else if (WIFSTOPPED(status)) {
 729                         const unsigned int test_options = PTRACE_O_TRACECLONE |
 730                                                           PTRACE_O_TRACEFORK |
 731                                                           PTRACE_O_TRACEVFORK;
 732                         if (status >> 16 == PTRACE_EVENT_FORK)
 733                                 ptrace_setoptions |= test_options;
 734                         if (WSTOPSIG(status) == SIGSTOP) {
 735                                 if (ptrace(PTRACE_SETOPTIONS, pid, NULL,
 736                                            test_options) < 0) {
 737                                         kill(pid, SIGKILL);
 738                                         return -1;
 739                                 }
 740                         }
 741                         if (ptrace(PTRACE_SYSCALL, pid, 0, 0) < 0 &&
 742                             errno != ESRCH)
 743                                 kill(pid, SIGKILL);
 744                 }
 745         }
 746         return 0;
 747 }
 748 #endif
 749
 750 int
 751 main(int argc, char *argv[])
 752 {
 753         struct tcb *tcp;
 754         int c, pid = 0;
 755         int optF = 0;
 756         struct sigaction sa;
 757
 758         static char buf[BUFSIZ];
 759
 760         progname = argv[0] ? argv[0] : "strace";
 761
 762         /* Allocate the initial tcbtab.  */
 763         tcbtabsize = argc;      /* Surely enough for all -p args.  */
 764         if ((tcbtab = calloc(tcbtabsize, sizeof tcbtab[0])) == NULL) {
 765                 fprintf(stderr, "%s: out of memory\n", progname);
 766                 exit(1);
 767         }
 768         if ((tcbtab[0] = calloc(tcbtabsize, sizeof tcbtab[0][0])) == NULL) {
 769                 fprintf(stderr, "%s: out of memory\n", progname);
 770                 exit(1);
 771         }
 772         for (tcp = tcbtab[0]; tcp < &tcbtab[0][tcbtabsize]; ++tcp)
 773                 tcbtab[tcp - tcbtab[0]] = &tcbtab[0][tcp - tcbtab[0]];
 774
 775         outf = stderr;
 776         interactive = 1;
 777         set_sortby(DEFAULT_SORTBY);
 778         set_personality(DEFAULT_PERSONALITY);
 779         qualify("trace=all");
 780         qualify("abbrev=all");
 781         qualify("verbose=all");
 782         qualify("signal=all");
 783         while ((c = getopt(argc, argv,
 784                 "+cCdfFhiqrtTvVxz"
 785 #ifndef USE_PROCFS
 786                 "D"
 787 #endif
 788                 "a:e:o:O:p:s:S:u:E:")) != EOF) {
 789                 switch (c) {
 790                 case 'c':
 791                         if (cflag == CFLAG_BOTH) {
 792                                 fprintf(stderr, "%s: -c and -C are mutually exclusive options\n",
 793                                         progname);
 794                                 exit(1);
 795                         }
 796                         cflag = CFLAG_ONLY_STATS;
 797                         break;
 798                 case 'C':
 799                         if (cflag == CFLAG_ONLY_STATS) {
 800                                 fprintf(stderr, "%s: -c and -C are mutually exclusive options\n",
 801                                         progname);
 802                                 exit(1);
 803                         }
 804                         cflag = CFLAG_BOTH;
 805                         break;
 806                 case 'd':
 807                         debug++;
 808                         break;
 809 #ifndef USE_PROCFS
 810                 case 'D':
 811                         daemonized_tracer = 1;
 812                         break;
 813 #endif
 814                 case 'F':
 815                         optF = 1;
 816                         break;
 817                 case 'f':
 818                         followfork++;
 819                         break;
 820                 case 'h':
 821                         usage(stdout, 0);
 822                         break;
 823                 case 'i':
 824                         iflag++;
 825                         break;
 826                 case 'q':
 827                         qflag++;
 828                         break;
 829                 case 'r':
 830                         rflag++;
 831                         tflag++;
 832                         break;
 833                 case 't':
 834                         tflag++;
 835                         break;
 836                 case 'T':
 837                         dtime++;
 838                         break;
 839                 case 'x':
 840                         xflag++;
 841                         break;
 842                 case 'v':
 843                         qualify("abbrev=none");
 844                         break;
 845                 case 'V':
 846                         printf("%s -- version %s\n", PACKAGE_NAME, VERSION);
 847                         exit(0);
 848                         break;
 849                 case 'z':
 850                         not_failing_only = 1;
 851                         break;
 852                 case 'a':
 853                         acolumn = atoi(optarg);
 854                         break;
 855                 case 'e':
 856                         qualify(optarg);
 857                         break;
 858                 case 'o':
 859                         outfname = strdup(optarg);
 860                         break;
 861                 case 'O':
 862                         set_overhead(atoi(optarg));
 863                         break;
 864                 case 'p':
 865                         if ((pid = atoi(optarg)) <= 0) {
 866                                 fprintf(stderr, "%s: Invalid process id: %s\n",
 867                                         progname, optarg);
 868                                 break;
 869                         }
 870                         if (pid == getpid()) {
 871                                 fprintf(stderr, "%s: I'm sorry, I can't let you do that, Dave.\n", progname);
 872                                 break;
 873                         }
 874                         tcp = alloc_tcb(pid, 0);
 875                         tcp->flags |= TCB_ATTACHED;
 876                         pflag_seen++;
 877                         break;
 878                 case 's':
 879                         max_strlen = atoi(optarg);
 880                         if (max_strlen < 0) {
 881                                 fprintf(stderr,
 882                                         "%s: invalid -s argument: %s\n",
 883                                         progname, optarg);
 884                                 exit(1);
 885                         }
 886                         break;
 887                 case 'S':
 888                         set_sortby(optarg);
 889                         break;
 890                 case 'u':
 891                         username = strdup(optarg);
 892                         break;
 893                 case 'E':
 894                         if (putenv(optarg) < 0) {
 895                                 fprintf(stderr, "%s: out of memory\n",
 896                                         progname);
 897                                 exit(1);
 898                         }
 899                         break;
 900                 default:
 901                         usage(stderr, 1);
 902                         break;
 903                 }
 904         }
 905
 906         if ((optind == argc) == !pflag_seen)
 907                 usage(stderr, 1);
 908
 909         if (pflag_seen && daemonized_tracer) {
 910                 fprintf(stderr,
 911                         "%s: -D and -p are mutually exclusive options\n",
 912                         progname);
 913                 exit(1);
 914         }
 915
 916         if (!followfork)
 917                 followfork = optF;
 918
 919         if (followfork > 1 && cflag) {
 920                 fprintf(stderr,
 921                         "%s: (-c or -C) and -ff are mutually exclusive options\n",
 922                         progname);
 923                 exit(1);
 924         }
 925
 926         /* See if they want to run as another user. */
 927         if (username != NULL) {
 928                 struct passwd *pent;
 929
 930                 if (getuid() != 0 || geteuid() != 0) {
 931                         fprintf(stderr,
 932                                 "%s: you must be root to use the -u option\n",
 933                                 progname);
 934                         exit(1);
 935                 }
 936                 if ((pent = getpwnam(username)) == NULL) {
 937                         fprintf(stderr, "%s: cannot find user `%s'\n",
 938                                 progname, username);
 939                         exit(1);
 940                 }
 941                 run_uid = pent->pw_uid;
 942                 run_gid = pent->pw_gid;
 943         }
 944         else {
 945                 run_uid = getuid();
 946                 run_gid = getgid();
 947         }
 948
 949 #ifdef LINUX
 950         if (followfork) {
 951                 if (test_ptrace_setoptions() < 0) {
 952                         fprintf(stderr,
 953                                 "Test for options supported by PTRACE_SETOPTIONS "
 954                                 "failed, giving up using this feature.\n");
 955                         ptrace_setoptions = 0;
 956                 }
 957                 if (debug)
 958                         fprintf(stderr, "ptrace_setoptions = %#x\n",
 959                                 ptrace_setoptions);
 960         }
 961 #endif
 962
 963         /* Check if they want to redirect the output. */
 964         if (outfname) {
 965                 /* See if they want to pipe the output. */
 966                 if (outfname[0] == '|' || outfname[0] == '!') {
 967                         /*
 968                          * We can't do the <outfname>.PID funny business
 969                          * when using popen, so prohibit it.
 970                          */
 971                         if (followfork > 1) {
 972                                 fprintf(stderr, "\
 973 %s: piping the output and -ff are mutually exclusive options\n",
 974                                         progname);
 975                                 exit(1);
 976                         }
 977
 978                         if ((outf = strace_popen(outfname + 1)) == NULL)
 979                                 exit(1);
 980                 }
 981                 else if (followfork <= 1 &&
 982                          (outf = strace_fopen(outfname, "w")) == NULL)
 983                         exit(1);
 984         }
 985
 986         if (!outfname || outfname[0] == '|' || outfname[0] == '!')
 987                 setvbuf(outf, buf, _IOLBF, BUFSIZ);
 988         if (outfname && optind < argc) {
 989                 interactive = 0;
 990                 qflag = 1;
 991         }
 992
 993         /* Valid states here:
 994            optind < argc        pflag_seen      outfname        interactive
 995            1                    0               0               1
 996            0                    1               0               1
 997            1                    0               1               0
 998            0                    1               1               1
 999          */
1000
1001         /* STARTUP_CHILD must be called before the signal handlers get
1002            installed below as they are inherited into the spawned process.
1003            Also we do not need to be protected by them as during interruption
1004            in the STARTUP_CHILD mode we kill the spawned process anyway.  */
1005         if (!pflag_seen)
1006                 startup_child(&argv[optind]);
1007
1008         sigemptyset(&empty_set);
1009         sigemptyset(&blocked_set);
1010         sa.sa_handler = SIG_IGN;
1011         sigemptyset(&sa.sa_mask);
1012         sa.sa_flags = 0;
1013         sigaction(SIGTTOU, &sa, NULL);
1014         sigaction(SIGTTIN, &sa, NULL);
1015         if (interactive) {
1016                 sigaddset(&blocked_set, SIGHUP);
1017                 sigaddset(&blocked_set, SIGINT);
1018                 sigaddset(&blocked_set, SIGQUIT);
1019                 sigaddset(&blocked_set, SIGPIPE);
1020                 sigaddset(&blocked_set, SIGTERM);
1021                 sa.sa_handler = interrupt;
1022 #ifdef SUNOS4
1023                 /* POSIX signals on sunos4.1 are a little broken. */
1024                 sa.sa_flags = SA_INTERRUPT;
1025 #endif /* SUNOS4 */
1026         }
1027         sigaction(SIGHUP, &sa, NULL);
1028         sigaction(SIGINT, &sa, NULL);
1029         sigaction(SIGQUIT, &sa, NULL);
1030         sigaction(SIGPIPE, &sa, NULL);
1031         sigaction(SIGTERM, &sa, NULL);
1032 #ifdef USE_PROCFS
1033         sa.sa_handler = reaper;
1034         sigaction(SIGCHLD, &sa, NULL);
1035 #else
1036         /* Make sure SIGCHLD has the default action so that waitpid
1037            definitely works without losing track of children.  The user
1038            should not have given us a bogus state to inherit, but he might
1039            have.  Arguably we should detect SIG_IGN here and pass it on
1040            to children, but probably noone really needs that.  */
1041         sa.sa_handler = SIG_DFL;
1042         sigaction(SIGCHLD, &sa, NULL);
1043 #endif /* USE_PROCFS */
1044
1045         if (pflag_seen || daemonized_tracer)
1046                 startup_attach();
1047
1048         if (trace() < 0)
1049                 exit(1);
1050         cleanup();
1051         fflush(NULL);
1052         if (exit_code > 0xff) {
1053                 /* Child was killed by a signal, mimic that.  */
1054                 exit_code &= 0xff;
1055                 signal(exit_code, SIG_DFL);
1056                 raise(exit_code);
1057                 /* Paranoia - what if this signal is not fatal?
1058                    Exit with 128 + signo then.  */
1059                 exit_code += 128;
1060         }
1061         exit(exit_code);
1062 }
1063
1064 void
1065 expand_tcbtab(void)
1066 {
1067         /* Allocate some more TCBs and expand the table.
1068            We don't want to relocate the TCBs because our
1069            callers have pointers and it would be a pain.
1070            So tcbtab is a table of pointers.  Since we never
1071            free the TCBs, we allocate a single chunk of many.  */
1072         struct tcb **newtab = (struct tcb **)
1073                 realloc(tcbtab, 2 * tcbtabsize * sizeof tcbtab[0]);
1074         struct tcb *newtcbs = (struct tcb *) calloc(tcbtabsize,
1075                                                     sizeof *newtcbs);
1076         int i;
1077         if (newtab == NULL || newtcbs == NULL) {
1078                 fprintf(stderr, "%s: expand_tcbtab: out of memory\n",
1079                         progname);
1080                 cleanup();
1081                 exit(1);
1082         }
1083         for (i = tcbtabsize; i < 2 * tcbtabsize; ++i)
1084                 newtab[i] = &newtcbs[i - tcbtabsize];
1085         tcbtabsize *= 2;
1086         tcbtab = newtab;
1087 }
1088
1089 struct tcb *
1090 alloc_tcb(int pid, int command_options_parsed)
1091 {
1092         int i;
1093         struct tcb *tcp;
1094
1095         if (nprocs == tcbtabsize)
1096                 expand_tcbtab();
1097
1098         for (i = 0; i < tcbtabsize; i++) {
1099                 tcp = tcbtab[i];
1100                 if ((tcp->flags & TCB_INUSE) == 0) {
1101                         tcp->pid = pid;
1102                         tcp->parent = NULL;
1103                         tcp->nchildren = 0;
1104                         tcp->nzombies = 0;
1105 #ifdef TCB_CLONE_THREAD
1106                         tcp->nclone_threads = 0;
1107                         tcp->nclone_waiting = 0;
1108 #endif
1109                         tcp->flags = TCB_INUSE | TCB_STARTUP;
1110                         tcp->outf = outf; /* Initialise to current out file */
1111                         tcp->curcol = 0;
1112                         tcp->stime.tv_sec = 0;
1113                         tcp->stime.tv_usec = 0;
1114                         tcp->pfd = -1;
1115                         nprocs++;
1116                         if (command_options_parsed)
1117                                 newoutf(tcp);
1118                         return tcp;
1119                 }
1120         }
1121         fprintf(stderr, "%s: bug in alloc_tcb\n", progname);
1122         cleanup();
1123         exit(1);
1124 }
1125
1126 #ifdef USE_PROCFS
1127 int
1128 proc_open(struct tcb *tcp, int attaching)
1129 {
1130         char proc[32];
1131         long arg;
1132 #ifdef SVR4
1133         int i;
1134         sysset_t syscalls;
1135         sigset_t signals;
1136         fltset_t faults;
1137 #endif
1138 #ifndef HAVE_POLLABLE_PROCFS
1139         static int last_pfd;
1140 #endif
1141
1142 #ifdef HAVE_MP_PROCFS
1143         /* Open the process pseudo-files in /proc. */
1144         sprintf(proc, "/proc/%d/ctl", tcp->pid);
1145         if ((tcp->pfd = open(proc, O_WRONLY|O_EXCL)) < 0) {
1146                 perror("strace: open(\"/proc/...\", ...)");
1147                 return -1;
1148         }
1149         if (set_cloexec_flag(tcp->pfd) < 0) {
1150                 return -1;
1151         }
1152         sprintf(proc, "/proc/%d/status", tcp->pid);
1153         if ((tcp->pfd_stat = open(proc, O_RDONLY|O_EXCL)) < 0) {
1154                 perror("strace: open(\"/proc/...\", ...)");
1155                 return -1;
1156         }
1157         if (set_cloexec_flag(tcp->pfd_stat) < 0) {
1158                 return -1;
1159         }
1160         sprintf(proc, "/proc/%d/as", tcp->pid);
1161         if ((tcp->pfd_as = open(proc, O_RDONLY|O_EXCL)) < 0) {
1162                 perror("strace: open(\"/proc/...\", ...)");
1163                 return -1;
1164         }
1165         if (set_cloexec_flag(tcp->pfd_as) < 0) {
1166                 return -1;
1167         }
1168 #else
1169         /* Open the process pseudo-file in /proc. */
1170 #ifndef FREEBSD
1171         sprintf(proc, "/proc/%d", tcp->pid);
1172         tcp->pfd = open(proc, O_RDWR|O_EXCL);
1173 #else /* FREEBSD */
1174         sprintf(proc, "/proc/%d/mem", tcp->pid);
1175         tcp->pfd = open(proc, O_RDWR);
1176 #endif /* FREEBSD */
1177         if (tcp->pfd < 0) {
1178                 perror("strace: open(\"/proc/...\", ...)");
1179                 return -1;
1180         }
1181         if (set_cloexec_flag(tcp->pfd) < 0) {
1182                 return -1;
1183         }
1184 #endif
1185 #ifdef FREEBSD
1186         sprintf(proc, "/proc/%d/regs", tcp->pid);
1187         if ((tcp->pfd_reg = open(proc, O_RDONLY)) < 0) {
1188                 perror("strace: open(\"/proc/.../regs\", ...)");
1189                 return -1;
1190         }
1191         if (cflag) {
1192                 sprintf(proc, "/proc/%d/status", tcp->pid);
1193                 if ((tcp->pfd_status = open(proc, O_RDONLY)) < 0) {
1194                         perror("strace: open(\"/proc/.../status\", ...)");
1195                         return -1;
1196                 }
1197         } else
1198                 tcp->pfd_status = -1;
1199 #endif /* FREEBSD */
1200         rebuild_pollv();
1201         if (!attaching) {
1202                 /*
1203                  * Wait for the child to pause.  Because of a race
1204                  * condition we have to poll for the event.
1205                  */
1206                 for (;;) {
1207                         if (IOCTL_STATUS (tcp) < 0) {
1208                                 perror("strace: PIOCSTATUS");
1209                                 return -1;
1210                         }
1211                         if (tcp->status.PR_FLAGS & PR_ASLEEP)
1212                             break;
1213                 }
1214         }
1215 #ifndef FREEBSD
1216         /* Stop the process so that we own the stop. */
1217         if (IOCTL(tcp->pfd, PIOCSTOP, (char *)NULL) < 0) {
1218                 perror("strace: PIOCSTOP");
1219                 return -1;
1220         }
1221 #endif
1222 #ifdef PIOCSET
1223         /* Set Run-on-Last-Close. */
1224         arg = PR_RLC;
1225         if (IOCTL(tcp->pfd, PIOCSET, &arg) < 0) {
1226                 perror("PIOCSET PR_RLC");
1227                 return -1;
1228         }
1229         /* Set or Reset Inherit-on-Fork. */
1230         arg = PR_FORK;
1231         if (IOCTL(tcp->pfd, followfork ? PIOCSET : PIOCRESET, &arg) < 0) {
1232                 perror("PIOC{SET,RESET} PR_FORK");
1233                 return -1;
1234         }
1235 #else  /* !PIOCSET */
1236 #ifndef FREEBSD
1237         if (ioctl(tcp->pfd, PIOCSRLC) < 0) {
1238                 perror("PIOCSRLC");
1239                 return -1;
1240         }
1241         if (ioctl(tcp->pfd, followfork ? PIOCSFORK : PIOCRFORK) < 0) {
1242                 perror("PIOC{S,R}FORK");
1243                 return -1;
1244         }
1245 #else /* FREEBSD */
1246         /* just unset the PF_LINGER flag for the Run-on-Last-Close. */
1247         if (ioctl(tcp->pfd, PIOCGFL, &arg) < 0) {
1248                 perror("PIOCGFL");
1249                 return -1;
1250         }
1251         arg &= ~PF_LINGER;
1252         if (ioctl(tcp->pfd, PIOCSFL, arg) < 0) {
1253                 perror("PIOCSFL");
1254                 return -1;
1255         }
1256 #endif /* FREEBSD */
1257 #endif /* !PIOCSET */
1258 #ifndef FREEBSD
1259         /* Enable all syscall entries we care about. */
1260         premptyset(&syscalls);
1261         for (i = 1; i < MAX_QUALS; ++i) {
1262                 if (i > (sizeof syscalls) * CHAR_BIT) break;
1263                 if (qual_flags [i] & QUAL_TRACE) praddset (&syscalls, i);
1264         }
1265         praddset (&syscalls, SYS_execve);
1266         if (followfork) {
1267                 praddset (&syscalls, SYS_fork);
1268 #ifdef SYS_forkall
1269                 praddset (&syscalls, SYS_forkall);
1270 #endif
1271 #ifdef SYS_fork1
1272                 praddset (&syscalls, SYS_fork1);
1273 #endif
1274 #ifdef SYS_rfork1
1275                 praddset (&syscalls, SYS_rfork1);
1276 #endif
1277 #ifdef SYS_rforkall
1278                 praddset (&syscalls, SYS_rforkall);
1279 #endif
1280         }
1281         if (IOCTL(tcp->pfd, PIOCSENTRY, &syscalls) < 0) {
1282                 perror("PIOCSENTRY");
1283                 return -1;
1284         }
1285         /* Enable the syscall exits. */
1286         if (IOCTL(tcp->pfd, PIOCSEXIT, &syscalls) < 0) {
1287                 perror("PIOSEXIT");
1288                 return -1;
1289         }
1290         /* Enable signals we care about. */
1291         premptyset(&signals);
1292         for (i = 1; i < MAX_QUALS; ++i) {
1293                 if (i > (sizeof signals) * CHAR_BIT) break;
1294                 if (qual_flags [i] & QUAL_SIGNAL) praddset (&signals, i);
1295         }
1296         if (IOCTL(tcp->pfd, PIOCSTRACE, &signals) < 0) {
1297                 perror("PIOCSTRACE");
1298                 return -1;
1299         }
1300         /* Enable faults we care about */
1301         premptyset(&faults);
1302         for (i = 1; i < MAX_QUALS; ++i) {
1303                 if (i > (sizeof faults) * CHAR_BIT) break;
1304                 if (qual_flags [i] & QUAL_FAULT) praddset (&faults, i);
1305         }
1306         if (IOCTL(tcp->pfd, PIOCSFAULT, &faults) < 0) {
1307                 perror("PIOCSFAULT");
1308                 return -1;
1309         }
1310 #else /* FREEBSD */
1311         /* set events flags. */
1312         arg = S_SIG | S_SCE | S_SCX ;
1313         if(ioctl(tcp->pfd, PIOCBIS, arg) < 0) {
1314                 perror("PIOCBIS");
1315                 return -1;
1316         }
1317 #endif /* FREEBSD */
1318         if (!attaching) {
1319 #ifdef MIPS
1320                 /*
1321                  * The SGI PRSABORT doesn't work for pause() so
1322                  * we send it a caught signal to wake it up.
1323                  */
1324                 kill(tcp->pid, SIGINT);
1325 #else /* !MIPS */
1326 #ifdef PRSABORT
1327                 /* The child is in a pause(), abort it. */
1328                 arg = PRSABORT;
1329                 if (IOCTL (tcp->pfd, PIOCRUN, &arg) < 0) {
1330                         perror("PIOCRUN");
1331                         return -1;
1332                 }
1333 #endif
1334 #endif /* !MIPS*/
1335 #ifdef FREEBSD
1336                 /* wake up the child if it received the SIGSTOP */
1337                 kill(tcp->pid, SIGCONT);
1338 #endif
1339                 for (;;) {
1340                         /* Wait for the child to do something. */
1341                         if (IOCTL_WSTOP (tcp) < 0) {
1342                                 perror("PIOCWSTOP");
1343                                 return -1;
1344                         }
1345                         if (tcp->status.PR_WHY == PR_SYSENTRY) {
1346                                 tcp->flags &= ~TCB_INSYSCALL;
1347                                 get_scno(tcp);
1348                                 if (known_scno(tcp) == SYS_execve)
1349                                         break;
1350                         }
1351                         /* Set it running: maybe execve will be next. */
1352 #ifndef FREEBSD
1353                         arg = 0;
1354                         if (IOCTL(tcp->pfd, PIOCRUN, &arg) < 0) {
1355 #else /* FREEBSD */
1356                         if (IOCTL(tcp->pfd, PIOCRUN, 0) < 0) {
1357 #endif /* FREEBSD */
1358                                 perror("PIOCRUN");
1359                                 return -1;
1360                         }
1361 #ifdef FREEBSD
1362                         /* handle the case where we "opened" the child before
1363                            it did the kill -STOP */
1364                         if (tcp->status.PR_WHY == PR_SIGNALLED &&
1365                             tcp->status.PR_WHAT == SIGSTOP)
1366                                 kill(tcp->pid, SIGCONT);
1367 #endif
1368                 }
1369 #ifndef FREEBSD
1370         }
1371 #else /* FREEBSD */
1372         } else {
1373                 if (attaching < 2) {
1374                         /* We are attaching to an already running process.
1375                          * Try to figure out the state of the process in syscalls,
1376                          * to handle the first event well.
1377                          * This is done by having a look at the "wchan" property of the
1378                          * process, which tells where it is stopped (if it is). */
1379                         FILE * status;
1380                         char wchan[20]; /* should be enough */
1381
1382                         sprintf(proc, "/proc/%d/status", tcp->pid);
1383                         status = fopen(proc, "r");
1384                         if (status &&
1385                             (fscanf(status, "%*s %*d %*d %*d %*d %*d,%*d %*s %*d,%*d"
1386                                     "%*d,%*d %*d,%*d %19s", wchan) == 1) &&
1387                             strcmp(wchan, "nochan") && strcmp(wchan, "spread") &&
1388                             strcmp(wchan, "stopevent")) {
1389                                 /* The process is asleep in the middle of a syscall.
1390                                    Fake the syscall entry event */
1391                                 tcp->flags &= ~(TCB_INSYSCALL|TCB_STARTUP);
1392                                 tcp->status.PR_WHY = PR_SYSENTRY;
1393                                 trace_syscall(tcp);
1394                         }
1395                         if (status)
1396                                 fclose(status);
1397                 } /* otherwise it's a fork being followed */
1398         }
1399 #endif /* FREEBSD */
1400 #ifndef HAVE_POLLABLE_PROCFS
1401         if (proc_poll_pipe[0] != -1)
1402                 proc_poller(tcp->pfd);
1403         else if (nprocs > 1) {
1404                 proc_poll_open();
1405                 proc_poller(last_pfd);
1406                 proc_poller(tcp->pfd);
1407         }
1408         last_pfd = tcp->pfd;
1409 #endif /* !HAVE_POLLABLE_PROCFS */
1410         return 0;
1411 }
1412
1413 #endif /* USE_PROCFS */
1414
1415 struct tcb *
1416 pid2tcb(int pid)
1417 {
1418         int i;
1419
1420         if (pid <= 0)
1421                 return NULL;
1422
1423         for (i = 0; i < tcbtabsize; i++) {
1424                 struct tcb *tcp = tcbtab[i];
1425                 if (tcp->pid == pid && (tcp->flags & TCB_INUSE))
1426                         return tcp;
1427         }
1428
1429         return NULL;
1430 }
1431
1432 #ifdef USE_PROCFS
1433
1434 static struct tcb *
1435 first_used_tcb(void)
1436 {
1437         int i;
1438         struct tcb *tcp;
1439         for (i = 0; i < tcbtabsize; i++) {
1440                 tcp = tcbtab[i];
1441                 if (tcp->flags & TCB_INUSE)
1442                         return tcp;
1443         }
1444         return NULL;
1445 }
1446
1447 static struct tcb *
1448 pfd2tcb(pfd)
1449 int pfd;
1450 {
1451         int i;
1452
1453         for (i = 0; i < tcbtabsize; i++) {
1454                 struct tcb *tcp = tcbtab[i];
1455                 if (tcp->pfd != pfd)
1456                         continue;
1457                 if (tcp->flags & TCB_INUSE)
1458                         return tcp;
1459         }
1460         return NULL;
1461 }
1462
1463 #endif /* USE_PROCFS */
1464
1465 void
1466 droptcb(tcp)
1467 struct tcb *tcp;
1468 {
1469         if (tcp->pid == 0)
1470                 return;
1471 #ifdef TCB_CLONE_THREAD
1472         if (tcp->nclone_threads > 0) {
1473                 /* There are other threads left in this process, but this
1474                    is the one whose PID represents the whole process.
1475                    We need to keep this record around as a zombie until
1476                    all the threads die.  */
1477                 tcp->flags |= TCB_EXITING;
1478                 return;
1479         }
1480 #endif
1481         nprocs--;
1482         tcp->pid = 0;
1483
1484         if (tcp->parent != NULL) {
1485                 tcp->parent->nchildren--;
1486 #ifdef TCB_CLONE_THREAD
1487                 if (tcp->flags & TCB_CLONE_THREAD)
1488                         tcp->parent->nclone_threads--;
1489 #endif
1490                 tcp->parent->nzombies++;
1491 #ifdef LINUX
1492                 /* Update `tcp->parent->parent->nchildren' and the other fields
1493                    like NCLONE_DETACHED, only for zombie group leader that has
1494                    already reported and been short-circuited at the top of this
1495                    function.  The same condition as at the top of DETACH.  */
1496                 if ((tcp->flags & TCB_CLONE_THREAD) &&
1497                     tcp->parent->nclone_threads == 0 &&
1498                     (tcp->parent->flags & TCB_EXITING))
1499                         droptcb(tcp->parent);
1500 #endif
1501                 tcp->parent = NULL;
1502         }
1503
1504         tcp->flags = 0;
1505         if (tcp->pfd != -1) {
1506                 close(tcp->pfd);
1507                 tcp->pfd = -1;
1508 #ifdef FREEBSD
1509                 if (tcp->pfd_reg != -1) {
1510                         close(tcp->pfd_reg);
1511                         tcp->pfd_reg = -1;
1512                 }
1513                 if (tcp->pfd_status != -1) {
1514                         close(tcp->pfd_status);
1515                         tcp->pfd_status = -1;
1516                 }
1517 #endif /* !FREEBSD */
1518 #ifdef USE_PROCFS
1519                 rebuild_pollv(); /* Note, flags needs to be cleared by now.  */
1520 #endif
1521         }
1522
1523         if (outfname && followfork > 1 && tcp->outf)
1524                 fclose(tcp->outf);
1525
1526         tcp->outf = 0;
1527 }
1528
1529 #ifndef USE_PROCFS
1530
1531 static int
1532 resume(tcp)
1533 struct tcb *tcp;
1534 {
1535         if (tcp == NULL)
1536                 return -1;
1537
1538         if (!(tcp->flags & TCB_SUSPENDED)) {
1539                 fprintf(stderr, "PANIC: pid %u not suspended\n", tcp->pid);
1540                 return -1;
1541         }
1542         tcp->flags &= ~TCB_SUSPENDED;
1543 #ifdef TCB_CLONE_THREAD
1544         if (tcp->flags & TCB_CLONE_THREAD)
1545                 tcp->parent->nclone_waiting--;
1546 #endif
1547
1548         if (ptrace_restart(PTRACE_SYSCALL, tcp, 0) < 0)
1549                 return -1;
1550
1551         if (!qflag)
1552                 fprintf(stderr, "Process %u resumed\n", tcp->pid);
1553         return 0;
1554 }
1555
1556 static int
1557 resume_from_tcp (struct tcb *tcp)
1558 {
1559         int error = 0;
1560         int resumed = 0;
1561
1562         /* XXX This won't always be quite right (but it never was).
1563            A waiter with argument 0 or < -1 is waiting for any pid in
1564            a particular pgrp, which this child might or might not be
1565            in.  The waiter will only wake up if it's argument is -1
1566            or if it's waiting for tcp->pid's pgrp.  It makes a
1567            difference to wake up a waiter when there might be more
1568            traced children, because it could get a false ECHILD
1569            error.  OTOH, if this was the last child in the pgrp, then
1570            it ought to wake up and get ECHILD.  We would have to
1571            search the system for all pid's in the pgrp to be sure.
1572
1573              && (t->waitpid == -1 ||
1574                  (t->waitpid == 0 && getpgid (tcp->pid) == getpgid (t->pid))
1575                  || (t->waitpid < 0 && t->waitpid == -getpid (t->pid)))
1576         */
1577
1578         if (tcp->parent &&
1579             (tcp->parent->flags & TCB_SUSPENDED) &&
1580             (tcp->parent->waitpid <= 0 || tcp->parent->waitpid == tcp->pid)) {
1581                 error = resume(tcp->parent);
1582                 ++resumed;
1583         }
1584 #ifdef TCB_CLONE_THREAD
1585         if (tcp->parent && tcp->parent->nclone_waiting > 0) {
1586                 /* Some other threads of our parent are waiting too.  */
1587                 unsigned int i;
1588
1589                 /* Resume all the threads that were waiting for this PID.  */
1590                 for (i = 0; i < tcbtabsize; i++) {
1591                         struct tcb *t = tcbtab[i];
1592                         if (t->parent == tcp->parent && t != tcp
1593                             && ((t->flags & (TCB_CLONE_THREAD|TCB_SUSPENDED))
1594                                 == (TCB_CLONE_THREAD|TCB_SUSPENDED))
1595                             && t->waitpid == tcp->pid) {
1596                                 error |= resume (t);
1597                                 ++resumed;
1598                         }
1599                 }
1600                 if (resumed == 0)
1601                         /* Noone was waiting for this PID in particular,
1602                            so now we might need to resume some wildcarders.  */
1603                         for (i = 0; i < tcbtabsize; i++) {
1604                                 struct tcb *t = tcbtab[i];
1605                                 if (t->parent == tcp->parent && t != tcp
1606                                     && ((t->flags
1607                                          & (TCB_CLONE_THREAD|TCB_SUSPENDED))
1608                                         == (TCB_CLONE_THREAD|TCB_SUSPENDED))
1609                                     && t->waitpid <= 0
1610                                         ) {
1611                                         error |= resume (t);
1612                                         break;
1613                                 }
1614                         }
1615         }
1616 #endif
1617
1618         return error;
1619 }
1620
1621 #endif /* !USE_PROCFS */
1622
1623 /* detach traced process; continue with sig
1624    Never call DETACH twice on the same process as both unattached and
1625    attached-unstopped processes give the same ESRCH.  For unattached process we
1626    would SIGSTOP it and wait for its SIGSTOP notification forever.  */
1627
1628 static int
1629 detach(tcp, sig)
1630 struct tcb *tcp;
1631 int sig;
1632 {
1633         int error = 0;
1634 #ifdef LINUX
1635         int status, catch_sigstop;
1636         struct tcb *zombie = NULL;
1637
1638         /* If the group leader is lingering only because of this other
1639            thread now dying, then detach the leader as well.  */
1640         if ((tcp->flags & TCB_CLONE_THREAD) &&
1641             tcp->parent->nclone_threads == 1 &&
1642             (tcp->parent->flags & TCB_EXITING))
1643                 zombie = tcp->parent;
1644 #endif
1645
1646         if (tcp->flags & TCB_BPTSET)
1647                 clearbpt(tcp);
1648
1649 #ifdef LINUX
1650         /*
1651          * Linux wrongly insists the child be stopped
1652          * before detaching.  Arghh.  We go through hoops
1653          * to make a clean break of things.
1654          */
1655 #if defined(SPARC)
1656 #undef PTRACE_DETACH
1657 #define PTRACE_DETACH PTRACE_SUNDETACH
1658 #endif
1659         /*
1660          * On TCB_STARTUP we did PTRACE_ATTACH but still did not get the
1661          * expected SIGSTOP.  We must catch exactly one as otherwise the
1662          * detached process would be left stopped (process state T).
1663          */
1664         catch_sigstop = (tcp->flags & TCB_STARTUP);
1665         if ((error = ptrace(PTRACE_DETACH, tcp->pid, (char *) 1, sig)) == 0) {
1666                 /* On a clear day, you can see forever. */
1667         }
1668         else if (errno != ESRCH) {
1669                 /* Shouldn't happen. */
1670                 perror("detach: ptrace(PTRACE_DETACH, ...)");
1671         }
1672         else if (my_tgkill((tcp->flags & TCB_CLONE_THREAD ? tcp->parent->pid
1673                                                           : tcp->pid),
1674                            tcp->pid, 0) < 0) {
1675                 if (errno != ESRCH)
1676                         perror("detach: checking sanity");
1677         }
1678         else if (!catch_sigstop && my_tgkill((tcp->flags & TCB_CLONE_THREAD
1679                                               ? tcp->parent->pid : tcp->pid),
1680                                              tcp->pid, SIGSTOP) < 0) {
1681                 if (errno != ESRCH)
1682                         perror("detach: stopping child");
1683         }
1684         else
1685                 catch_sigstop = 1;
1686         if (catch_sigstop) {
1687                 for (;;) {
1688 #ifdef __WALL
1689                         if (wait4(tcp->pid, &status, __WALL, NULL) < 0) {
1690                                 if (errno == ECHILD) /* Already gone.  */
1691                                         break;
1692                                 if (errno != EINVAL) {
1693                                         perror("detach: waiting");
1694                                         break;
1695                                 }
1696 #endif /* __WALL */
1697                                 /* No __WALL here.  */
1698                                 if (waitpid(tcp->pid, &status, 0) < 0) {
1699                                         if (errno != ECHILD) {
1700                                                 perror("detach: waiting");
1701                                                 break;
1702                                         }
1703 #ifdef __WCLONE
1704                                         /* If no processes, try clones.  */
1705                                         if (wait4(tcp->pid, &status, __WCLONE,
1706                                                   NULL) < 0) {
1707                                                 if (errno != ECHILD)
1708                                                         perror("detach: waiting");
1709                                                 break;
1710                                         }
1711 #endif /* __WCLONE */
1712                                 }
1713 #ifdef __WALL
1714                         }
1715 #endif
1716                         if (!WIFSTOPPED(status)) {
1717                                 /* Au revoir, mon ami. */
1718                                 break;
1719                         }
1720                         if (WSTOPSIG(status) == SIGSTOP) {
1721                                 ptrace_restart(PTRACE_DETACH, tcp, sig);
1722                                 break;
1723                         }
1724                         error = ptrace_restart(PTRACE_CONT, tcp,
1725                                         WSTOPSIG(status) == SIGTRAP ? 0
1726                                         : WSTOPSIG(status));
1727                         if (error < 0)
1728                                 break;
1729                 }
1730         }
1731 #endif /* LINUX */
1732
1733 #if defined(SUNOS4)
1734         /* PTRACE_DETACH won't respect `sig' argument, so we post it here. */
1735         if (sig && kill(tcp->pid, sig) < 0)
1736                 perror("detach: kill");
1737         sig = 0;
1738         error = ptrace_restart(PTRACE_DETACH, tcp, sig);
1739 #endif /* SUNOS4 */
1740
1741 #ifndef USE_PROCFS
1742         error |= resume_from_tcp (tcp);
1743 #endif
1744
1745         if (!qflag)
1746                 fprintf(stderr, "Process %u detached\n", tcp->pid);
1747
1748         droptcb(tcp);
1749
1750 #ifdef LINUX
1751         if (zombie != NULL) {
1752                 /* TCP no longer exists therefore you must not detach () it.  */
1753                 droptcb(zombie);
1754         }
1755 #endif
1756
1757         return error;
1758 }
1759
1760 #ifdef USE_PROCFS
1761
1762 static void reaper(int sig)
1763 {
1764         int pid;
1765         int status;
1766
1767         while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
1768         }
1769 }
1770
1771 #endif /* USE_PROCFS */
1772
1773 static void
1774 cleanup()
1775 {
1776         int i;
1777         struct tcb *tcp;
1778
1779         for (i = 0; i < tcbtabsize; i++) {
1780                 tcp = tcbtab[i];
1781                 if (!(tcp->flags & TCB_INUSE))
1782                         continue;
1783                 if (debug)
1784                         fprintf(stderr,
1785                                 "cleanup: looking at pid %u\n", tcp->pid);
1786                 if (tcp_last &&
1787                     (!outfname || followfork < 2 || tcp_last == tcp)) {
1788                         tprintf(" <unfinished ...>");
1789                         printtrailer();
1790                 }
1791                 if (tcp->flags & TCB_ATTACHED)
1792                         detach(tcp, 0);
1793                 else {
1794                         kill(tcp->pid, SIGCONT);
1795                         kill(tcp->pid, SIGTERM);
1796                 }
1797         }
1798         if (cflag)
1799                 call_summary(outf);
1800 }
1801
1802 static void
1803 interrupt(sig)
1804 int sig;
1805 {
1806         interrupted = 1;
1807 }
1808
1809 #ifndef HAVE_STRERROR
1810
1811 #if !HAVE_DECL_SYS_ERRLIST
1812 extern int sys_nerr;
1813 extern char *sys_errlist[];
1814 #endif /* HAVE_DECL_SYS_ERRLIST */
1815
1816 const char *
1817 strerror(errno)
1818 int errno;
1819 {
1820         static char buf[64];
1821
1822         if (errno < 1 || errno >= sys_nerr) {
1823                 sprintf(buf, "Unknown error %d", errno);
1824                 return buf;
1825         }
1826         return sys_errlist[errno];
1827 }
1828
1829 #endif /* HAVE_STERRROR */
1830
1831 #ifndef HAVE_STRSIGNAL
1832
1833 #if defined HAVE_SYS_SIGLIST && !defined HAVE_DECL_SYS_SIGLIST
1834 extern char *sys_siglist[];
1835 #endif
1836 #if defined HAVE_SYS__SIGLIST && !defined HAVE_DECL__SYS_SIGLIST
1837 extern char *_sys_siglist[];
1838 #endif
1839
1840 const char *
1841 strsignal(sig)
1842 int sig;
1843 {
1844         static char buf[64];
1845
1846         if (sig < 1 || sig >= NSIG) {
1847                 sprintf(buf, "Unknown signal %d", sig);
1848                 return buf;
1849         }
1850 #ifdef HAVE__SYS_SIGLIST
1851         return _sys_siglist[sig];
1852 #else
1853         return sys_siglist[sig];
1854 #endif
1855 }
1856
1857 #endif /* HAVE_STRSIGNAL */
1858
1859 #ifdef USE_PROCFS
1860
1861 static void
1862 rebuild_pollv()
1863 {
1864         int i, j;
1865
1866         if (pollv != NULL)
1867                 free (pollv);
1868         pollv = (struct pollfd *) malloc(nprocs * sizeof pollv[0]);
1869         if (pollv == NULL) {
1870                 fprintf(stderr, "%s: out of memory\n", progname);
1871                 exit(1);
1872         }
1873
1874         for (i = j = 0; i < tcbtabsize; i++) {
1875                 struct tcb *tcp = tcbtab[i];
1876                 if (!(tcp->flags & TCB_INUSE))
1877                         continue;
1878                 pollv[j].fd = tcp->pfd;
1879                 pollv[j].events = POLLWANT;
1880                 j++;
1881         }
1882         if (j != nprocs) {
1883                 fprintf(stderr, "strace: proc miscount\n");
1884                 exit(1);
1885         }
1886 }
1887
1888 #ifndef HAVE_POLLABLE_PROCFS
1889
1890 static void
1891 proc_poll_open()
1892 {
1893         int i;
1894
1895         if (pipe(proc_poll_pipe) < 0) {
1896                 perror("pipe");
1897                 exit(1);
1898         }
1899         for (i = 0; i < 2; i++) {
1900                 if (set_cloexec_flag(proc_poll_pipe[i]) < 0) {
1901                         exit(1);
1902                 }
1903         }
1904 }
1905
1906 static int
1907 proc_poll(pollv, nfds, timeout)
1908 struct pollfd *pollv;
1909 int nfds;
1910 int timeout;
1911 {
1912         int i;
1913         int n;
1914         struct proc_pollfd pollinfo;
1915
1916         if ((n = read(proc_poll_pipe[0], &pollinfo, sizeof(pollinfo))) < 0)
1917                 return n;
1918         if (n != sizeof(struct proc_pollfd)) {
1919                 fprintf(stderr, "panic: short read: %d\n", n);
1920                 exit(1);
1921         }
1922         for (i = 0; i < nprocs; i++) {
1923                 if (pollv[i].fd == pollinfo.fd)
1924                         pollv[i].revents = pollinfo.revents;
1925                 else
1926                         pollv[i].revents = 0;
1927         }
1928         poller_pid = pollinfo.pid;
1929         return 1;
1930 }
1931
1932 static void
1933 wakeup_handler(sig)
1934 int sig;
1935 {
1936 }
1937
1938 static void
1939 proc_poller(pfd)
1940 int pfd;
1941 {
1942         struct proc_pollfd pollinfo;
1943         struct sigaction sa;
1944         sigset_t blocked_set, empty_set;
1945         int i;
1946         int n;
1947         struct rlimit rl;
1948 #ifdef FREEBSD
1949         struct procfs_status pfs;
1950 #endif /* FREEBSD */
1951
1952         switch (fork()) {
1953         case -1:
1954                 perror("fork");
1955                 _exit(1);
1956         case 0:
1957                 break;
1958         default:
1959                 return;
1960         }
1961
1962         sa.sa_handler = interactive ? SIG_DFL : SIG_IGN;
1963         sa.sa_flags = 0;
1964         sigemptyset(&sa.sa_mask);
1965         sigaction(SIGHUP, &sa, NULL);
1966         sigaction(SIGINT, &sa, NULL);
1967         sigaction(SIGQUIT, &sa, NULL);
1968         sigaction(SIGPIPE, &sa, NULL);
1969         sigaction(SIGTERM, &sa, NULL);
1970         sa.sa_handler = wakeup_handler;
1971         sigaction(SIGUSR1, &sa, NULL);
1972         sigemptyset(&blocked_set);
1973         sigaddset(&blocked_set, SIGUSR1);
1974         sigprocmask(SIG_BLOCK, &blocked_set, NULL);
1975         sigemptyset(&empty_set);
1976
1977         if (getrlimit(RLIMIT_NOFILE, &rl) < 0) {
1978                 perror("getrlimit(RLIMIT_NOFILE, ...)");
1979                 _exit(1);
1980         }
1981         n = rl.rlim_cur;
1982         for (i = 0; i < n; i++) {
1983                 if (i != pfd && i != proc_poll_pipe[1])
1984                         close(i);
1985         }
1986
1987         pollinfo.fd = pfd;
1988         pollinfo.pid = getpid();
1989         for (;;) {
1990 #ifndef FREEBSD
1991                 if (ioctl(pfd, PIOCWSTOP, NULL) < 0)
1992 #else
1993                 if (ioctl(pfd, PIOCWSTOP, &pfs) < 0)
1994 #endif
1995                 {
1996                         switch (errno) {
1997                         case EINTR:
1998                                 continue;
1999                         case EBADF:
2000                                 pollinfo.revents = POLLERR;
2001                                 break;
2002                         case ENOENT:
2003                                 pollinfo.revents = POLLHUP;
2004                                 break;
2005                         default:
2006                                 perror("proc_poller: PIOCWSTOP");
2007                         }
2008                         write(proc_poll_pipe[1], &pollinfo, sizeof(pollinfo));
2009                         _exit(0);
2010                 }
2011                 pollinfo.revents = POLLWANT;
2012                 write(proc_poll_pipe[1], &pollinfo, sizeof(pollinfo));
2013                 sigsuspend(&empty_set);
2014         }
2015 }
2016
2017 #endif /* !HAVE_POLLABLE_PROCFS */
2018
2019 static int
2020 choose_pfd()
2021 {
2022         int i, j;
2023         struct tcb *tcp;
2024
2025         static int last;
2026
2027         if (followfork < 2 &&
2028             last < nprocs && (pollv[last].revents & POLLWANT)) {
2029                 /*
2030                  * The previous process is ready to run again.  We'll
2031                  * let it do so if it is currently in a syscall.  This
2032                  * heuristic improves the readability of the trace.
2033                  */
2034                 tcp = pfd2tcb(pollv[last].fd);
2035                 if (tcp && (tcp->flags & TCB_INSYSCALL))
2036                         return pollv[last].fd;
2037         }
2038
2039         for (i = 0; i < nprocs; i++) {
2040                 /* Let competing children run round robin. */
2041                 j = (i + last + 1) % nprocs;
2042                 if (pollv[j].revents & (POLLHUP | POLLERR)) {
2043                         tcp = pfd2tcb(pollv[j].fd);
2044                         if (!tcp) {
2045                                 fprintf(stderr, "strace: lost proc\n");
2046                                 exit(1);
2047                         }
2048                         droptcb(tcp);
2049                         return -1;
2050                 }
2051                 if (pollv[j].revents & POLLWANT) {
2052                         last = j;
2053                         return pollv[j].fd;
2054                 }
2055         }
2056         fprintf(stderr, "strace: nothing ready\n");
2057         exit(1);
2058 }
2059
2060 static int
2061 trace()
2062 {
2063 #ifdef POLL_HACK
2064         struct tcb *in_syscall = NULL;
2065 #endif
2066         struct tcb *tcp;
2067         int pfd;
2068         int what;
2069         int ioctl_result = 0, ioctl_errno = 0;
2070         long arg;
2071
2072         for (;;) {
2073                 if (interactive)
2074                         sigprocmask(SIG_SETMASK, &empty_set, NULL);
2075
2076                 if (nprocs == 0)
2077                         break;
2078
2079                 switch (nprocs) {
2080                 case 1:
2081 #ifndef HAVE_POLLABLE_PROCFS
2082                         if (proc_poll_pipe[0] == -1) {
2083 #endif
2084                                 tcp = first_used_tcb();
2085                                 if (!tcp)
2086                                         continue;
2087                                 pfd = tcp->pfd;
2088                                 if (pfd == -1)
2089                                         continue;
2090                                 break;
2091 #ifndef HAVE_POLLABLE_PROCFS
2092                         }
2093                         /* fall through ... */
2094 #endif /* !HAVE_POLLABLE_PROCFS */
2095                 default:
2096 #ifdef HAVE_POLLABLE_PROCFS
2097 #ifdef POLL_HACK
2098                         /* On some systems (e.g. UnixWare) we get too much ugly
2099                            "unfinished..." stuff when multiple proceses are in
2100                            syscalls.  Here's a nasty hack */
2101
2102                         if (in_syscall) {
2103                                 struct pollfd pv;
2104                                 tcp = in_syscall;
2105                                 in_syscall = NULL;
2106                                 pv.fd = tcp->pfd;
2107                                 pv.events = POLLWANT;
2108                                 if ((what = poll (&pv, 1, 1)) < 0) {
2109                                         if (interrupted)
2110                                                 return 0;
2111                                         continue;
2112                                 }
2113                                 else if (what == 1 && pv.revents & POLLWANT) {
2114                                         goto FOUND;
2115                                 }
2116                         }
2117 #endif
2118
2119                         if (poll(pollv, nprocs, INFTIM) < 0) {
2120                                 if (interrupted)
2121                                         return 0;
2122                                 continue;
2123                         }
2124 #else /* !HAVE_POLLABLE_PROCFS */
2125                         if (proc_poll(pollv, nprocs, INFTIM) < 0) {
2126                                 if (interrupted)
2127                                         return 0;
2128                                 continue;
2129                         }
2130 #endif /* !HAVE_POLLABLE_PROCFS */
2131                         pfd = choose_pfd();
2132                         if (pfd == -1)
2133                                 continue;
2134                         break;
2135                 }
2136
2137                 /* Look up `pfd' in our table. */
2138                 if ((tcp = pfd2tcb(pfd)) == NULL) {
2139                         fprintf(stderr, "unknown pfd: %u\n", pfd);
2140                         exit(1);
2141                 }
2142 #ifdef POLL_HACK
2143         FOUND:
2144 #endif
2145                 /* Get the status of the process. */
2146                 if (!interrupted) {
2147 #ifndef FREEBSD
2148                         ioctl_result = IOCTL_WSTOP (tcp);
2149 #else /* FREEBSD */
2150                         /* Thanks to some scheduling mystery, the first poller
2151                            sometimes waits for the already processed end of fork
2152                            event. Doing a non blocking poll here solves the problem. */
2153                         if (proc_poll_pipe[0] != -1)
2154                                 ioctl_result = IOCTL_STATUS (tcp);
2155                         else
2156                                 ioctl_result = IOCTL_WSTOP (tcp);
2157 #endif /* FREEBSD */
2158                         ioctl_errno = errno;
2159 #ifndef HAVE_POLLABLE_PROCFS
2160                         if (proc_poll_pipe[0] != -1) {
2161                                 if (ioctl_result < 0)
2162                                         kill(poller_pid, SIGKILL);
2163                                 else
2164                                         kill(poller_pid, SIGUSR1);
2165                         }
2166 #endif /* !HAVE_POLLABLE_PROCFS */
2167                 }
2168                 if (interrupted)
2169                         return 0;
2170
2171                 if (interactive)
2172                         sigprocmask(SIG_BLOCK, &blocked_set, NULL);
2173
2174                 if (ioctl_result < 0) {
2175                         /* Find out what happened if it failed. */
2176                         switch (ioctl_errno) {
2177                         case EINTR:
2178                         case EBADF:
2179                                 continue;
2180 #ifdef FREEBSD
2181                         case ENOTTY:
2182 #endif
2183                         case ENOENT:
2184                                 droptcb(tcp);
2185                                 continue;
2186                         default:
2187                                 perror("PIOCWSTOP");
2188                                 exit(1);
2189                         }
2190                 }
2191
2192 #ifdef FREEBSD
2193                 if ((tcp->flags & TCB_STARTUP) && (tcp->status.PR_WHY == PR_SYSEXIT)) {
2194                         /* discard first event for a syscall we never entered */
2195                         IOCTL (tcp->pfd, PIOCRUN, 0);
2196                         continue;
2197                 }
2198 #endif
2199
2200                 /* clear the just started flag */
2201                 tcp->flags &= ~TCB_STARTUP;
2202
2203                 /* set current output file */
2204                 outf = tcp->outf;
2205                 curcol = tcp->curcol;
2206
2207                 if (cflag) {
2208                         struct timeval stime;
2209 #ifdef FREEBSD
2210                         char buf[1024];
2211                         int len;
2212
2213                         if ((len = pread(tcp->pfd_status, buf, sizeof(buf) - 1, 0)) > 0) {
2214                                 buf[len] = '\0';
2215                                 sscanf(buf,
2216                                        "%*s %*d %*d %*d %*d %*d,%*d %*s %*d,%*d %*d,%*d %ld,%ld",
2217                                        &stime.tv_sec, &stime.tv_usec);
2218                         } else
2219                                 stime.tv_sec = stime.tv_usec = 0;
2220 #else /* !FREEBSD */
2221                         stime.tv_sec = tcp->status.pr_stime.tv_sec;
2222                         stime.tv_usec = tcp->status.pr_stime.tv_nsec/1000;
2223 #endif /* !FREEBSD */
2224                         tv_sub(&tcp->dtime, &stime, &tcp->stime);
2225                         tcp->stime = stime;
2226                 }
2227                 what = tcp->status.PR_WHAT;
2228                 switch (tcp->status.PR_WHY) {
2229 #ifndef FREEBSD
2230                 case PR_REQUESTED:
2231                         if (tcp->status.PR_FLAGS & PR_ASLEEP) {
2232                                 tcp->status.PR_WHY = PR_SYSENTRY;
2233                                 if (trace_syscall(tcp) < 0) {
2234                                         fprintf(stderr, "syscall trouble\n");
2235                                         exit(1);
2236                                 }
2237                         }
2238                         break;
2239 #endif /* !FREEBSD */
2240                 case PR_SYSENTRY:
2241 #ifdef POLL_HACK
2242                         in_syscall = tcp;
2243 #endif
2244                 case PR_SYSEXIT:
2245                         if (trace_syscall(tcp) < 0) {
2246                                 fprintf(stderr, "syscall trouble\n");
2247                                 exit(1);
2248                         }
2249                         break;
2250                 case PR_SIGNALLED:
2251                         if (cflag != CFLAG_ONLY_STATS
2252                             && (qual_flags[what] & QUAL_SIGNAL)) {
2253                                 printleader(tcp);
2254                                 tprintf("--- %s (%s) ---",
2255                                         signame(what), strsignal(what));
2256                                 printtrailer();
2257 #ifdef PR_INFO
2258                                 if (tcp->status.PR_INFO.si_signo == what) {
2259                                         printleader(tcp);
2260                                         tprintf("    siginfo=");
2261                                         printsiginfo(&tcp->status.PR_INFO, 1);
2262                                         printtrailer();
2263                                 }
2264 #endif
2265                         }
2266                         break;
2267                 case PR_FAULTED:
2268                         if (cflag != CFLAGS_ONLY_STATS
2269                             && (qual_flags[what] & QUAL_FAULT)) {
2270                                 printleader(tcp);
2271                                 tprintf("=== FAULT %d ===", what);
2272                                 printtrailer();
2273                         }
2274                         break;
2275 #ifdef FREEBSD
2276                 case 0: /* handle case we polled for nothing */
2277                         continue;
2278 #endif
2279                 default:
2280                         fprintf(stderr, "odd stop %d\n", tcp->status.PR_WHY);
2281                         exit(1);
2282                         break;
2283                 }
2284                 /* Remember current print column before continuing. */
2285                 tcp->curcol = curcol;
2286                 arg = 0;
2287 #ifndef FREEBSD
2288                 if (IOCTL (tcp->pfd, PIOCRUN, &arg) < 0)
2289 #else
2290                 if (IOCTL (tcp->pfd, PIOCRUN, 0) < 0)
2291 #endif
2292                 {
2293                         perror("PIOCRUN");
2294                         exit(1);
2295                 }
2296         }
2297         return 0;
2298 }
2299
2300 #else /* !USE_PROCFS */
2301
2302 #ifdef TCB_GROUP_EXITING
2303 /* Handle an exit detach or death signal that is taking all the
2304    related clone threads with it.  This is called in three circumstances:
2305    SIG == -1    TCP has already died (TCB_ATTACHED is clear, strace is parent).
2306    SIG == 0     Continuing TCP will perform an exit_group syscall.
2307    SIG == other Continuing TCP with SIG will kill the process.
2308 */
2309 static int
2310 handle_group_exit(struct tcb *tcp, int sig)
2311 {
2312         /* We need to locate our records of all the clone threads
2313            related to TCP, either its children or siblings.  */
2314         struct tcb *leader = NULL;
2315
2316         if (tcp->flags & TCB_CLONE_THREAD)
2317                 leader = tcp->parent;
2318
2319         if (sig < 0) {
2320                 if (leader != NULL && leader != tcp
2321                  && !(leader->flags & TCB_GROUP_EXITING)
2322                  && !(tcp->flags & TCB_STARTUP)
2323                 ) {
2324                         fprintf(stderr,
2325                                 "PANIC: handle_group_exit: %d leader %d\n",
2326                                 tcp->pid, leader ? leader->pid : -1);
2327                 }
2328                 /* TCP no longer exists therefore you must not detach() it.  */
2329 #ifndef USE_PROCFS
2330                 resume_from_tcp(tcp);
2331 #endif
2332                 droptcb(tcp);   /* Already died.  */
2333         }
2334         else {
2335                 /* Mark that we are taking the process down.  */
2336                 tcp->flags |= TCB_EXITING | TCB_GROUP_EXITING;
2337                 if (tcp->flags & TCB_ATTACHED) {
2338                         detach(tcp, sig);
2339                         if (leader != NULL && leader != tcp)
2340                                 leader->flags |= TCB_GROUP_EXITING;
2341                 } else {
2342                         if (ptrace_restart(PTRACE_CONT, tcp, sig) < 0) {
2343                                 cleanup();
2344                                 return -1;
2345                         }
2346                         if (leader != NULL) {
2347                                 leader->flags |= TCB_GROUP_EXITING;
2348                                 if (leader != tcp)
2349                                         droptcb(tcp);
2350                         }
2351                         /* The leader will report to us as parent now,
2352                            and then we'll get to the SIG==-1 case.  */
2353                         return 0;
2354                 }
2355         }
2356
2357         return 0;
2358 }
2359 #endif
2360
2361 #ifdef LINUX
2362 static int
2363 handle_ptrace_event(int status, struct tcb *tcp)
2364 {
2365         if (status >> 16 == PTRACE_EVENT_VFORK ||
2366             status >> 16 == PTRACE_EVENT_CLONE ||
2367             status >> 16 == PTRACE_EVENT_FORK) {
2368                 int childpid;
2369
2370                 if (do_ptrace(PTRACE_GETEVENTMSG, tcp, NULL, &childpid) < 0) {
2371                         if (errno != ESRCH) {
2372                                 fprintf(stderr, "\
2373 %s: handle_ptrace_event: ptrace cannot get new child's pid\n",
2374                                         progname);
2375                                 cleanup();
2376                                 exit(1);
2377                         }
2378                         return -1;
2379                 }
2380                 return handle_new_child(tcp, childpid, 0);
2381         }
2382         return 1;
2383 }
2384 #endif
2385
2386 static int
2387 trace()
2388 {
2389         int pid;
2390         int wait_errno;
2391         int status;
2392         struct tcb *tcp;
2393 #ifdef LINUX
2394         struct rusage ru;
2395 #ifdef __WALL
2396         static int wait4_options = __WALL;
2397 #endif
2398 #endif /* LINUX */
2399
2400         while (nprocs != 0) {
2401                 if (interrupted)
2402                         return 0;
2403                 if (interactive)
2404                         sigprocmask(SIG_SETMASK, &empty_set, NULL);
2405 #ifdef LINUX
2406 #ifdef __WALL
2407                 pid = wait4(-1, &status, wait4_options, cflag ? &ru : NULL);
2408                 if (pid < 0 && (wait4_options & __WALL) && errno == EINVAL) {
2409                         /* this kernel does not support __WALL */
2410                         wait4_options &= ~__WALL;
2411                         errno = 0;
2412                         pid = wait4(-1, &status, wait4_options,
2413                                         cflag ? &ru : NULL);
2414                 }
2415                 if (pid < 0 && !(wait4_options & __WALL) && errno == ECHILD) {
2416                         /* most likely a "cloned" process */
2417                         pid = wait4(-1, &status, __WCLONE,
2418                                         cflag ? &ru : NULL);
2419                         if (pid == -1) {
2420                                 fprintf(stderr, "strace: clone wait4 "
2421                                                 "failed: %s\n", strerror(errno));
2422                         }
2423                 }
2424 #else
2425                 pid = wait4(-1, &status, 0, cflag ? &ru : NULL);
2426 #endif /* __WALL */
2427 #endif /* LINUX */
2428 #ifdef SUNOS4
2429                 pid = wait(&status);
2430 #endif /* SUNOS4 */
2431                 wait_errno = errno;
2432                 if (interactive)
2433                         sigprocmask(SIG_BLOCK, &blocked_set, NULL);
2434
2435                 if (pid == -1) {
2436                         switch (wait_errno) {
2437                         case EINTR:
2438                                 continue;
2439                         case ECHILD:
2440                                 /*
2441                                  * We would like to verify this case
2442                                  * but sometimes a race in Solbourne's
2443                                  * version of SunOS sometimes reports
2444                                  * ECHILD before sending us SIGCHILD.
2445                                  */
2446                                 return 0;
2447                         default:
2448                                 errno = wait_errno;
2449                                 perror("strace: wait");
2450                                 return -1;
2451                         }
2452                 }
2453                 if (pid == popen_pid) {
2454                         if (WIFEXITED(status) || WIFSIGNALED(status))
2455                                 popen_pid = -1;
2456                         continue;
2457                 }
2458                 if (debug)
2459                         fprintf(stderr, " [wait(%#x) = %u]\n", status, pid);
2460
2461                 /* Look up `pid' in our table. */
2462                 if ((tcp = pid2tcb(pid)) == NULL) {
2463 #ifdef LINUX
2464                         if (followfork) {
2465                                 /* This is needed to go with the CLONE_PTRACE
2466                                    changes in process.c/util.c: we might see
2467                                    the child's initial trap before we see the
2468                                    parent return from the clone syscall.
2469                                    Leave the child suspended until the parent
2470                                    returns from its system call.  Only then
2471                                    will we have the association of parent and
2472                                    child so that we know how to do clearbpt
2473                                    in the child.  */
2474                                 tcp = alloctcb(pid);
2475                                 tcp->flags |= TCB_ATTACHED | TCB_SUSPENDED;
2476                                 if (!qflag)
2477                                         fprintf(stderr, "\
2478 Process %d attached (waiting for parent)\n",
2479                                                 pid);
2480                         }
2481                         else
2482                                 /* This can happen if a clone call used
2483                                    CLONE_PTRACE itself.  */
2484 #endif
2485                         {
2486                                 fprintf(stderr, "unknown pid: %u\n", pid);
2487                                 if (WIFSTOPPED(status))
2488                                         ptrace(PTRACE_CONT, pid, (char *) 1, 0);
2489                                 exit(1);
2490                         }
2491                 }
2492                 /* set current output file */
2493                 outf = tcp->outf;
2494                 curcol = tcp->curcol;
2495                 if (cflag) {
2496 #ifdef LINUX
2497                         tv_sub(&tcp->dtime, &ru.ru_stime, &tcp->stime);
2498                         tcp->stime = ru.ru_stime;
2499 #endif /* !LINUX */
2500                 }
2501
2502                 if (tcp->flags & TCB_SUSPENDED) {
2503                         /*
2504                          * Apparently, doing any ptrace() call on a stopped
2505                          * process, provokes the kernel to report the process
2506                          * status again on a subsequent wait(), even if the
2507                          * process has not been actually restarted.
2508                          * Since we have inspected the arguments of suspended
2509                          * processes we end up here testing for this case.
2510                          */
2511                         continue;
2512                 }
2513                 if (WIFSIGNALED(status)) {
2514                         if (pid == strace_child)
2515                                 exit_code = 0x100 | WTERMSIG(status);
2516                         if (cflag != CFLAG_ONLY_STATS
2517                             && (qual_flags[WTERMSIG(status)] & QUAL_SIGNAL)) {
2518                                 printleader(tcp);
2519                                 tprintf("+++ killed by %s %s+++",
2520                                         signame(WTERMSIG(status)),
2521 #ifdef WCOREDUMP
2522                                         WCOREDUMP(status) ? "(core dumped) " :
2523 #endif
2524                                         "");
2525                                 printtrailer();
2526                         }
2527 #ifdef TCB_GROUP_EXITING
2528                         handle_group_exit(tcp, -1);
2529 #else
2530                         droptcb(tcp);
2531 #endif
2532                         continue;
2533                 }
2534                 if (WIFEXITED(status)) {
2535                         if (pid == strace_child)
2536                                 exit_code = WEXITSTATUS(status);
2537                         if (debug)
2538                                 fprintf(stderr, "pid %u exited with %d\n", pid, WEXITSTATUS(status));
2539                         if ((tcp->flags & (TCB_ATTACHED|TCB_STARTUP)) == TCB_ATTACHED
2540 #ifdef TCB_GROUP_EXITING
2541                             && !(tcp->parent && (tcp->parent->flags & TCB_GROUP_EXITING))
2542                             && !(tcp->flags & TCB_GROUP_EXITING)
2543 #endif
2544                         ) {
2545                                 fprintf(stderr,
2546                                         "PANIC: attached pid %u exited with %d\n",
2547                                         pid, WEXITSTATUS(status));
2548                         }
2549                         if (tcp == tcp_last) {
2550                                 if ((tcp->flags & (TCB_INSYSCALL|TCB_REPRINT)) == TCB_INSYSCALL)
2551                                         tprintf(" <unfinished ... exit status %d>\n",
2552                                                 WEXITSTATUS(status));
2553                                 tcp_last = NULL;
2554                         }
2555 #ifdef TCB_GROUP_EXITING
2556                         handle_group_exit(tcp, -1);
2557 #else
2558                         droptcb(tcp);
2559 #endif
2560                         continue;
2561                 }
2562                 if (!WIFSTOPPED(status)) {
2563                         fprintf(stderr, "PANIC: pid %u not stopped\n", pid);
2564                         droptcb(tcp);
2565                         continue;
2566                 }
2567                 if (debug)
2568                         fprintf(stderr, "pid %u stopped, [%s]\n",
2569                                 pid, signame(WSTOPSIG(status)));
2570
2571                 if (ptrace_setoptions && (status >> 16)) {
2572                         if (handle_ptrace_event(status, tcp) != 1)
2573                                 goto tracing;
2574                 }
2575
2576                 /*
2577                  * Interestingly, the process may stop
2578                  * with STOPSIG equal to some other signal
2579                  * than SIGSTOP if we happend to attach
2580                  * just before the process takes a signal.
2581                  * A no-MMU vforked child won't send up a signal,
2582                  * so skip the first (lost) execve notification.
2583                  */
2584                 if ((tcp->flags & TCB_STARTUP) &&
2585                     (WSTOPSIG(status) == SIGSTOP || strace_vforked)) {
2586                         /*
2587                          * This flag is there to keep us in sync.
2588                          * Next time this process stops it should
2589                          * really be entering a system call.
2590                          */
2591                         tcp->flags &= ~TCB_STARTUP;
2592                         if (tcp->flags & TCB_BPTSET) {
2593                                 /*
2594                                  * One example is a breakpoint inherited from
2595                                  * parent through fork ().
2596                                  */
2597                                 if (clearbpt(tcp) < 0) /* Pretty fatal */ {
2598                                         droptcb(tcp);
2599                                         cleanup();
2600                                         return -1;
2601                                 }
2602                         }
2603 #ifdef LINUX
2604                         if (followfork && (tcp->parent == NULL) && ptrace_setoptions)
2605                                 if (ptrace(PTRACE_SETOPTIONS, tcp->pid,
2606                                            NULL, ptrace_setoptions) < 0 &&
2607                                     errno != ESRCH)
2608                                         ptrace_setoptions = 0;
2609 #endif
2610                         goto tracing;
2611                 }
2612
2613                 if (WSTOPSIG(status) != SIGTRAP) {
2614                         if (WSTOPSIG(status) == SIGSTOP &&
2615                                         (tcp->flags & TCB_SIGTRAPPED)) {
2616                                 /*
2617                                  * Trapped attempt to block SIGTRAP
2618                                  * Hope we are back in control now.
2619                                  */
2620                                 tcp->flags &= ~(TCB_INSYSCALL | TCB_SIGTRAPPED);
2621                                 if (ptrace_restart(PTRACE_SYSCALL, tcp, 0) < 0) {
2622                                         cleanup();
2623                                         return -1;
2624                                 }
2625                                 continue;
2626                         }
2627                         if (cflag != CFLAG_ONLY_STATS
2628                             && (qual_flags[WSTOPSIG(status)] & QUAL_SIGNAL)) {
2629                                 unsigned long addr = 0;
2630                                 long pc = 0;
2631 #if defined(PT_CR_IPSR) && defined(PT_CR_IIP) && defined(PT_GETSIGINFO)
2632 #                               define PSR_RI   41
2633                                 struct siginfo si;
2634                                 long psr;
2635
2636                                 upeek(tcp, PT_CR_IPSR, &psr);
2637                                 upeek(tcp, PT_CR_IIP, &pc);
2638
2639                                 pc += (psr >> PSR_RI) & 0x3;
2640                                 ptrace(PT_GETSIGINFO, pid, 0, (long) &si);
2641                                 addr = (unsigned long) si.si_addr;
2642 #elif defined PTRACE_GETSIGINFO
2643                                 if (WSTOPSIG(status) == SIGSEGV ||
2644                                     WSTOPSIG(status) == SIGBUS) {
2645                                         siginfo_t si;
2646                                         if (ptrace(PTRACE_GETSIGINFO, pid,
2647                                                    0, &si) == 0)
2648                                                 addr = (unsigned long)
2649                                                         si.si_addr;
2650                                 }
2651 #endif
2652                                 printleader(tcp);
2653                                 tprintf("--- %s (%s) @ %lx (%lx) ---",
2654                                         signame(WSTOPSIG(status)),
2655                                         strsignal(WSTOPSIG(status)), pc, addr);
2656                                 printtrailer();
2657                         }
2658                         if (((tcp->flags & TCB_ATTACHED) ||
2659                              tcp->nclone_threads > 0) &&
2660                                 !sigishandled(tcp, WSTOPSIG(status))) {
2661 #ifdef TCB_GROUP_EXITING
2662                                 handle_group_exit(tcp, WSTOPSIG(status));
2663 #else
2664                                 detach(tcp, WSTOPSIG(status));
2665 #endif
2666                                 continue;
2667                         }
2668                         if (ptrace_restart(PTRACE_SYSCALL, tcp, WSTOPSIG(status)) < 0) {
2669                                 cleanup();
2670                                 return -1;
2671                         }
2672                         tcp->flags &= ~TCB_SUSPENDED;
2673                         continue;
2674                 }
2675                 /* we handled the STATUS, we are permitted to interrupt now. */
2676                 if (interrupted)
2677                         return 0;
2678                 if (trace_syscall(tcp) < 0 && !tcp->ptrace_errno) {
2679                         /* ptrace() failed in trace_syscall() with ESRCH.
2680                          * Likely a result of process disappearing mid-flight.
2681                          * Observed case: exit_group() terminating
2682                          * all processes in thread group. In this case, threads
2683                          * "disappear" in an unpredictable moment without any
2684                          * notification to strace via wait().
2685                          */
2686                         if (tcp->flags & TCB_ATTACHED) {
2687                                 if (tcp_last) {
2688                                         /* Do we have dangling line "syscall(param, param"?
2689                                          * Finish the line then. We cannot
2690                                          */
2691                                         tcp_last->flags |= TCB_REPRINT;
2692                                         tprintf(" <unfinished ...>");
2693                                         printtrailer();
2694                                 }
2695                                 detach(tcp, 0);
2696                         } else {
2697                                 ptrace(PTRACE_KILL,
2698                                         tcp->pid, (char *) 1, SIGTERM);
2699                                 droptcb(tcp);
2700                         }
2701                         continue;
2702                 }
2703                 if (tcp->flags & TCB_EXITING) {
2704 #ifdef TCB_GROUP_EXITING
2705                         if (tcp->flags & TCB_GROUP_EXITING) {
2706                                 if (handle_group_exit(tcp, 0) < 0)
2707                                         return -1;
2708                                 continue;
2709                         }
2710 #endif
2711                         if (tcp->flags & TCB_ATTACHED)
2712                                 detach(tcp, 0);
2713                         else if (ptrace_restart(PTRACE_CONT, tcp, 0) < 0) {
2714                                 cleanup();
2715                                 return -1;
2716                         }
2717                         continue;
2718                 }
2719                 if (tcp->flags & TCB_SUSPENDED) {
2720                         if (!qflag)
2721                                 fprintf(stderr, "Process %u suspended\n", pid);
2722                         continue;
2723                 }
2724         tracing:
2725                 /* Remember current print column before continuing. */
2726                 tcp->curcol = curcol;
2727                 if (ptrace_restart(PTRACE_SYSCALL, tcp, 0) < 0) {
2728                         cleanup();
2729                         return -1;
2730                 }
2731         }
2732         return 0;
2733 }
2734
2735 #endif /* !USE_PROCFS */
2736
2737 #include <stdarg.h>
2738
2739 void
2740 tprintf(const char *fmt, ...)
2741 {
2742         va_list args;
2743
2744         va_start(args, fmt);
2745         if (outf) {
2746                 int n = vfprintf(outf, fmt, args);
2747                 if (n < 0) {
2748                         if (outf != stderr)
2749                                 perror(outfname == NULL
2750                                        ? "<writing to pipe>" : outfname);
2751                 } else
2752                         curcol += n;
2753         }
2754         va_end(args);
2755         return;
2756 }
2757
2758 void
2759 printleader(tcp)
2760 struct tcb *tcp;
2761 {
2762         if (tcp_last) {
2763                 if (tcp_last->ptrace_errno) {
2764                         if (tcp_last->flags & TCB_INSYSCALL) {
2765                                 tprintf(" <unavailable>)");
2766                                 tabto(acolumn);
2767                         }
2768                         tprintf("= ? <unavailable>\n");
2769                         tcp_last->ptrace_errno = 0;
2770                 } else if (!outfname || followfork < 2 || tcp_last == tcp) {
2771                         tcp_last->flags |= TCB_REPRINT;
2772                         tprintf(" <unfinished ...>\n");
2773                 }
2774         }
2775         curcol = 0;
2776         if ((followfork == 1 || pflag_seen > 1) && outfname)
2777                 tprintf("%-5d ", tcp->pid);
2778         else if (nprocs > 1 && !outfname)
2779                 tprintf("[pid %5u] ", tcp->pid);
2780         if (tflag) {
2781                 char str[sizeof("HH:MM:SS")];
2782                 struct timeval tv, dtv;
2783                 static struct timeval otv;
2784
2785                 gettimeofday(&tv, NULL);
2786                 if (rflag) {
2787                         if (otv.tv_sec == 0)
2788                                 otv = tv;
2789                         tv_sub(&dtv, &tv, &otv);
2790                         tprintf("%6ld.%06ld ",
2791                                 (long) dtv.tv_sec, (long) dtv.tv_usec);
2792                         otv = tv;
2793                 }
2794                 else if (tflag > 2) {
2795                         tprintf("%ld.%06ld ",
2796                                 (long) tv.tv_sec, (long) tv.tv_usec);
2797                 }
2798                 else {
2799                         time_t local = tv.tv_sec;
2800                         strftime(str, sizeof(str), "%T", localtime(&local));
2801                         if (tflag > 1)
2802                                 tprintf("%s.%06ld ", str, (long) tv.tv_usec);
2803                         else
2804                                 tprintf("%s ", str);
2805                 }
2806         }
2807         if (iflag)
2808                 printcall(tcp);
2809 }
2810
2811 void
2812 tabto(col)
2813 int col;
2814 {
2815         if (curcol < col)
2816                 tprintf("%*s", col - curcol, "");
2817 }
2818
2819 void
2820 printtrailer(void)
2821 {
2822         tprintf("\n");
2823         tcp_last = NULL;
2824 }
2825
2826 #ifdef HAVE_MP_PROCFS
2827
2828 int
2829 mp_ioctl(int fd, int cmd, void *arg, int size)
2830 {
2831         struct iovec iov[2];
2832         int n = 1;
2833
2834         iov[0].iov_base = &cmd;
2835         iov[0].iov_len = sizeof cmd;
2836         if (arg) {
2837                 ++n;
2838                 iov[1].iov_base = arg;
2839                 iov[1].iov_len = size;
2840         }
2841
2842         return writev(fd, iov, n);
2843 }
2844
2845 #endif