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