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