usr/src/cmd/ptools/psig/psig.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 #pragma ident   "%Z%%M% %I%     %E% SMI"
  27
  28 #include <stdio.h>
  29 #include <stdio_ext.h>
  30 #include <stdlib.h>
  31 #include <unistd.h>
  32 #include <ctype.h>
  33 #include <fcntl.h>
  34 #include <string.h>
  35 #include <signal.h>
  36 #include <stddef.h>
  37 #include <sys/types.h>
  38 #include <sys/stat.h>
  39 #include <libproc.h>
  40
  41 /* evil knowledge of libc internals */
  42 #include "../../../lib/libc/inc/thr_uberdata.h"
  43
  44 #define MAX_SYMNAMLEN   1024    /* Recommended max symbol name length */
  45
  46 static  char    *sigflags(int, int);
  47 static  int     look(char *);
  48 static  void    perr(char *);
  49 static  int     usage(void);
  50 static  uintptr_t deinterpose(int, void *, psinfo_t *, struct sigaction *);
  51
  52 static  char    *command;
  53 static  char    *procname;
  54 static  int     all_flag = 0;
  55 static  int     lookuphandlers_flag = 1;
  56
  57 int
  58 main(int argc, char **argv)
  59 {
  60         int rc = 0;
  61         int c;
  62         struct rlimit rlim;
  63
  64         if ((command = strrchr(argv[0], '/')) != NULL)
  65                 command++;
  66         else
  67                 command = argv[0];
  68
  69         while ((c = getopt(argc, argv, "an")) != EOF) {
  70                 switch (c) {
  71                 case 'a':
  72                         all_flag = 1;
  73                         break;
  74                 case 'n':
  75                         lookuphandlers_flag = 0;
  76                         break;
  77                 default:
  78                         return (usage());
  79                 }
  80         }
  81
  82         if (argc - optind < 1) {
  83                 return (usage());
  84         }
  85
  86         /*
  87          * Make sure we'll have enough file descriptors to handle a target
  88          * that has many many mappings.
  89          */
  90         if (getrlimit(RLIMIT_NOFILE, &rlim) == 0) {
  91                 rlim.rlim_cur = rlim.rlim_max;
  92                 (void) setrlimit(RLIMIT_NOFILE, &rlim);
  93                 (void) enable_extended_FILE_stdio(-1, -1);
  94         }
  95
  96         for (; optind != argc; optind++) {
  97                 rc += look(argv[optind]);
  98         }
  99
 100         return (rc);
 101 }
 102
 103 static int
 104 usage(void)
 105 {
 106         (void) fprintf(stderr, "usage:\t%s [-n] pid ...\n", command);
 107         (void) fprintf(stderr, "  (report process signal actions)\n");
 108
 109         return (2);
 110 }
 111
 112 static uintptr_t
 113 uberdata_addr(struct ps_prochandle *Pr, char dmodel)
 114 {
 115         GElf_Sym sym;
 116
 117         if (Plookup_by_name(Pr, "libc.so", "_tdb_bootstrap", &sym) < 0)
 118                 return (NULL);
 119 #ifdef _LP64
 120         if (dmodel != PR_MODEL_NATIVE) {
 121                 caddr32_t uaddr;
 122                 caddr32_t addr;
 123
 124                 if (Pread(Pr, &addr, sizeof (addr), sym.st_value)
 125                     == sizeof (addr) &&
 126                     addr != 0 &&
 127                     Pread(Pr, &uaddr, sizeof (uaddr), (uintptr_t)addr)
 128                     == sizeof (uaddr) &&
 129                     uaddr != 0)
 130                         return ((uintptr_t)uaddr);
 131         }
 132 #endif
 133         if (dmodel == PR_MODEL_NATIVE) {
 134                 uintptr_t uaddr;
 135                 uintptr_t addr;
 136
 137                 if (Pread(Pr, &addr, sizeof (addr), sym.st_value)
 138                     == sizeof (addr) &&
 139                     addr != 0 &&
 140                     Pread(Pr, &uaddr, sizeof (uaddr), addr)
 141                     == sizeof (uaddr) &&
 142                     uaddr != 0)
 143                         return (uaddr);
 144         }
 145         if (Plookup_by_name(Pr, "libc.so", "_uberdata", &sym) < 0)
 146                 return (0);
 147         return (sym.st_value);
 148 }
 149
 150 /*
 151  * Iterator function used to generate the process sigmask
 152  * from the individual lwp sigmasks.
 153  */
 154 static int
 155 lwp_iter(void *cd, const lwpstatus_t *lwpstatus)
 156 {
 157         sigset_t *ssp = cd;
 158
 159         ssp->__sigbits[0] &= lwpstatus->pr_lwphold.__sigbits[0];
 160         ssp->__sigbits[1] &= lwpstatus->pr_lwphold.__sigbits[1];
 161         ssp->__sigbits[2] &= lwpstatus->pr_lwphold.__sigbits[2];
 162         ssp->__sigbits[3] &= lwpstatus->pr_lwphold.__sigbits[3];
 163
 164         /*
 165          * Return non-zero to terminate the iteration
 166          * if the sigmask has become all zeros.
 167          */
 168         return ((ssp->__sigbits[0] | ssp->__sigbits[1] |
 169             ssp->__sigbits[2] | ssp->__sigbits[3]) == 0);
 170 }
 171
 172 static int
 173 look(char *arg)
 174 {
 175         char pathname[100];
 176         struct stat statb;
 177         int fd = -1;
 178         int sig, gcode;
 179         sigset_t holdmask;
 180         int maxsig;
 181         struct sigaction *action = NULL;
 182         psinfo_t psinfo;
 183         const psinfo_t *psinfop;
 184         struct ps_prochandle *Pr = NULL;
 185         uintptr_t uberaddr;
 186         uintptr_t aharraddr;
 187         uintptr_t intfnaddr;
 188         size_t aharrlen;
 189         void *aharr = NULL;
 190         int error = 1;
 191
 192         procname = arg;         /* for perr() */
 193         if ((Pr = proc_arg_grab(arg, PR_ARG_PIDS, PGRAB_RDONLY|PGRAB_FORCE,
 194             &gcode)) == NULL || (psinfop = Ppsinfo(Pr)) == NULL) {
 195                 (void) fprintf(stderr, "%s: cannot examine %s: %s\n",
 196                     command, arg, Pgrab_error(gcode));
 197                 goto look_error;
 198         }
 199         (void) memcpy(&psinfo, psinfop, sizeof (psinfo_t));
 200         proc_unctrl_psinfo(&psinfo);
 201
 202         (void) sprintf(pathname, "/proc/%d/sigact", (int)psinfo.pr_pid);
 203         if ((fd = open(pathname, O_RDONLY)) < 0) {
 204                 perr("open sigact");
 205                 goto look_error;
 206         }
 207
 208         if (fstat(fd, &statb) != 0) {
 209                 perr("fstat sigact");
 210                 goto look_error;
 211         }
 212         maxsig = statb.st_size / sizeof (struct sigaction);
 213         action = malloc(maxsig * sizeof (struct sigaction));
 214         if (action == NULL) {
 215                 (void) fprintf(stderr,
 216                 "%s: cannot malloc() space for %d sigaction structures\n",
 217                         command, maxsig);
 218                 goto look_error;
 219         }
 220         if (read(fd, (char *)action, maxsig * sizeof (struct sigaction)) !=
 221             maxsig * sizeof (struct sigaction)) {
 222                 perr("read sigact");
 223                 goto look_error;
 224         }
 225         (void) close(fd);
 226         fd = -1;
 227
 228         (void) printf("%d:\t%.70s\n", (int)psinfo.pr_pid, psinfo.pr_psargs);
 229
 230         (void) sigfillset(&holdmask);
 231         (void) Plwp_iter(Pr, lwp_iter, &holdmask);
 232
 233         if ((uberaddr = uberdata_addr(Pr, psinfo.pr_dmodel)) == 0) {
 234                 aharraddr = 0;
 235                 aharrlen = 0;
 236                 intfnaddr = 0;
 237         } else {
 238 #ifdef _LP64
 239                 if (psinfo.pr_dmodel != PR_MODEL_NATIVE) {
 240                         caddr32_t addr;
 241                         aharraddr = uberaddr +
 242                                 offsetof(uberdata32_t, siguaction);
 243                         aharrlen = sizeof (siguaction32_t) * NSIG;
 244                         (void) Pread(Pr, &addr, sizeof (addr),
 245                             uberaddr + offsetof(uberdata32_t, sigacthandler));
 246                         intfnaddr = (uintptr_t)addr;
 247                 } else
 248 #endif
 249                 {
 250                         aharraddr = uberaddr +
 251                                 offsetof(uberdata_t, siguaction);
 252                         aharrlen = sizeof (siguaction_t) * NSIG;
 253                         (void) Pread(Pr, &intfnaddr, sizeof (intfnaddr),
 254                             uberaddr + offsetof(uberdata_t, sigacthandler));
 255                 }
 256         }
 257
 258         if (aharraddr) {
 259                 aharr = malloc(aharrlen);
 260                 if (aharr == NULL) {
 261                         (void) fprintf(stderr,
 262                         "%s: cannot malloc() space for actual handler array\n",
 263                             command);
 264                         goto look_error;
 265                 }
 266
 267                 if (Pread(Pr, aharr, aharrlen, aharraddr) != aharrlen) {
 268                         (void) fprintf(stderr,
 269                             "%s: signal handler data at %p cannot be read.\n",
 270                             command, (void *)aharraddr);
 271                         free(aharr);
 272                         aharr = NULL;
 273                 }
 274         }
 275
 276         for (sig = 1; sig <= maxsig; sig++) {
 277                 struct sigaction *sp = &action[sig - 1];
 278                 int caught = 0;
 279                 char buf[SIG2STR_MAX];
 280                 char *s;
 281
 282                 /* proc_signame() returns "SIG..."; skip the "SIG" part */
 283                 (void) printf("%s\t", proc_signame(sig, buf, sizeof (buf)) + 3);
 284
 285                 if (prismember(&holdmask, sig))
 286                         (void) printf("blocked,");
 287
 288                 if (sp->sa_handler == SIG_DFL)
 289                         (void) printf("default");
 290                 else if (sp->sa_handler == SIG_IGN)
 291                         (void) printf("ignored");
 292                 else
 293                         caught = 1;
 294
 295                 if (caught || all_flag) {
 296                         uintptr_t haddr;
 297                         GElf_Sym hsym;
 298                         char hname[MAX_SYMNAMLEN];
 299                         char buf[PRSIGBUFSZ];
 300
 301                         haddr = (uintptr_t)sp->sa_handler;
 302
 303                         if (aharr && intfnaddr && haddr == intfnaddr)
 304                                 haddr = deinterpose(sig, aharr, &psinfo, sp);
 305
 306                         if (haddr == (uintptr_t)SIG_DFL) {
 307                                 if (caught)
 308                                         (void) printf("default");
 309                                 caught = 0;
 310                         } else if (haddr == (uintptr_t)SIG_IGN) {
 311                                 if (caught)
 312                                         (void) printf("ignored");
 313                                 caught = 0;
 314                         } else {
 315                                 if (caught)
 316                                         (void) printf("caught");
 317                         }
 318
 319                         if (caught || all_flag) {
 320                                 if (lookuphandlers_flag && haddr > 1 &&
 321                                     Plookup_by_addr(Pr, haddr, hname,
 322                                     sizeof (hname), &hsym) == 0)
 323                                         (void) printf("\t%-8s", hname);
 324                                 else
 325                                         (void) printf("\t0x%-8lx",
 326                                                 (ulong_t)haddr);
 327
 328                                 s = sigflags(sig, sp->sa_flags);
 329                                 (void) printf("%s", (*s != '\0')? s : "\t0");
 330                                 (void) proc_sigset2str(&sp->sa_mask, ",", 1,
 331                                     buf, sizeof (buf));
 332                                 if (buf[0] != '\0')
 333                                         (void) printf("\t%s", buf);
 334                         }
 335                 } else if (sig == SIGCLD) {
 336                         s = sigflags(sig,
 337                                 sp->sa_flags & (SA_NOCLDWAIT|SA_NOCLDSTOP));
 338                         if (*s != '\0')
 339                                 (void) printf("\t\t%s", s);
 340                 }
 341                 (void) printf("\n");
 342         }
 343
 344         error = 0;
 345
 346 look_error:
 347         if (fd >= 0)
 348                 (void) close(fd);
 349         if (aharr)
 350                 free(aharr);
 351         if (action)
 352                 free(action);
 353         if (Pr)
 354                 Prelease(Pr, 0);
 355         return (error);
 356 }
 357
 358 static void
 359 perr(char *s)
 360 {
 361         if (s)
 362                 (void) fprintf(stderr, "%s: ", procname);
 363         else
 364                 s = procname;
 365         perror(s);
 366 }
 367
 368 static char *
 369 sigflags(int sig, int flags)
 370 {
 371         static char code_buf[100];
 372         char *str = code_buf;
 373         int flagmask =
 374                 (SA_ONSTACK|SA_RESETHAND|SA_RESTART|SA_SIGINFO|SA_NODEFER);
 375
 376         if (sig == SIGCLD)
 377                 flagmask |= (SA_NOCLDSTOP|SA_NOCLDWAIT);
 378
 379         *str = '\0';
 380         if (flags & ~flagmask)
 381                 (void) sprintf(str, ",0x%x,", flags & ~flagmask);
 382         else if (flags == 0)
 383                 return (str);
 384
 385         if (flags & SA_RESTART)
 386                 (void) strcat(str, ",RESTART");
 387         if (flags & SA_RESETHAND)
 388                 (void) strcat(str, ",RESETHAND");
 389         if (flags & SA_ONSTACK)
 390                 (void) strcat(str, ",ONSTACK");
 391         if (flags & SA_SIGINFO)
 392                 (void) strcat(str, ",SIGINFO");
 393         if (flags & SA_NODEFER)
 394                 (void) strcat(str, ",NODEFER");
 395
 396         if (sig == SIGCLD) {
 397                 if (flags & SA_NOCLDWAIT)
 398                         (void) strcat(str, ",NOCLDWAIT");
 399                 if (flags & SA_NOCLDSTOP)
 400                         (void) strcat(str, ",NOCLDSTOP");
 401         }
 402
 403         *str = '\t';
 404
 405         return (str);
 406 }
 407
 408 /*ARGSUSED2*/
 409 static uintptr_t
 410 deinterpose(int sig, void *aharr, psinfo_t *psinfo, struct sigaction *sp)
 411 {
 412         if (sp->sa_handler == SIG_DFL || sp->sa_handler == SIG_IGN)
 413                 return ((uintptr_t)sp->sa_handler);
 414 #ifdef _LP64
 415         if (psinfo->pr_dmodel != PR_MODEL_NATIVE) {
 416                 struct sigaction32 *sa32 = (struct sigaction32 *)
 417                         ((uintptr_t)aharr + sig * sizeof (siguaction32_t) +
 418                         offsetof(siguaction32_t, sig_uaction));
 419
 420                 sp->sa_flags = sa32->sa_flags;
 421                 sp->sa_handler = (void (*)())(uintptr_t)sa32->sa_handler;
 422                 (void) memcpy(&sp->sa_mask, &sa32->sa_mask,
 423                         sizeof (sp->sa_mask));
 424         } else
 425 #endif
 426         {
 427                 struct sigaction *sa = (struct sigaction *)
 428                         ((uintptr_t)aharr + sig * sizeof (siguaction_t) +
 429                         offsetof(siguaction_t, sig_uaction));
 430
 431                 sp->sa_flags = sa->sa_flags;
 432                 sp->sa_handler = sa->sa_handler;
 433                 sp->sa_mask = sa->sa_mask;
 434         }
 435         return ((uintptr_t)sp->sa_handler);
 436 }