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 } 437