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 /* 23 * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright 2020 Joyent, Inc. 25 */ 26 27 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 28 /* All Rights Reserved */ 29 30 /* Copyright (c) 2013, OmniTI Computer Consulting, Inc. All rights reserved. */ 31 32 #define _SYSCALL32 /* make 32-bit compat headers visible */ 33 34 #include <stdio.h> 35 #include <stdlib.h> 36 #include <unistd.h> 37 #include <string.h> 38 #include <signal.h> 39 #include <termio.h> 40 #include <stddef.h> 41 #include <limits.h> 42 #include <fcntl.h> 43 #include <ctype.h> 44 #include <sys/types.h> 45 #include <sys/mman.h> 46 #include <sys/resource.h> 47 #include <sys/ulimit.h> 48 #include <sys/utsname.h> 49 #include <sys/kstat.h> 50 #include <sys/modctl.h> 51 #include <sys/acl.h> 52 #include <stropts.h> 53 #include <sys/isa_defs.h> 54 #include <sys/systeminfo.h> 55 #include <sys/cladm.h> 56 #include <sys/lwp.h> 57 #include <bsm/audit.h> 58 #include <libproc.h> 59 #include <priv.h> 60 #include <sys/aio.h> 61 #include <sys/aiocb.h> 62 #include <sys/corectl.h> 63 #include <sys/cpc_impl.h> 64 #include <sys/priocntl.h> 65 #include <sys/tspriocntl.h> 66 #include <sys/iapriocntl.h> 67 #include <sys/rtpriocntl.h> 68 #include <sys/fsspriocntl.h> 69 #include <sys/fxpriocntl.h> 70 #include <sys/proc.h> 71 #include <netdb.h> 72 #include <nss_dbdefs.h> 73 #include <sys/socketvar.h> 74 #include <netinet/in.h> 75 #include <netinet/tcp.h> 76 #include <netinet/udp.h> 77 #include <netinet/sctp.h> 78 #include <net/route.h> 79 #include <sys/utrap.h> 80 #include <sys/lgrp_user.h> 81 #include <sys/door.h> 82 #include <sys/tsol/tndb.h> 83 #include <sys/rctl.h> 84 #include <sys/rctl_impl.h> 85 #include <sys/fork.h> 86 #include <sys/task.h> 87 #include <sys/random.h> 88 #include "ramdata.h" 89 #include "print.h" 90 #include "proto.h" 91 #include "systable.h" 92 93 void grow(private_t *, int nbyte); 94 95 #define GROW(nb) if (pri->sys_leng + (nb) >= pri->sys_ssize) grow(pri, (nb)) 96 97 98 /*ARGSUSED*/ 99 void 100 prt_nov(private_t *pri, int raw, long val) /* print nothing */ 101 { 102 } 103 104 /*ARGSUSED*/ 105 void 106 prt_dec(private_t *pri, int raw, long val) /* print as decimal */ 107 { 108 GROW(24); 109 if (data_model == PR_MODEL_ILP32) 110 pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng, 111 "%d", (int)val); 112 else 113 pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng, 114 "%ld", val); 115 } 116 117 /*ARGSUSED*/ 118 void 119 prt_uns(private_t *pri, int raw, long val) /* print as unsigned decimal */ 120 { 121 GROW(24); 122 if (data_model == PR_MODEL_ILP32) 123 pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng, 124 "%u", (int)val); 125 else 126 pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng, 127 "%lu", val); 128 } 129 130 /* print as unsigned decimal, except for -1 */ 131 void 132 prt_un1(private_t *pri, int raw, long val) 133 { 134 if ((int)val == -1) 135 prt_dec(pri, raw, val); 136 else 137 prt_uns(pri, raw, val); 138 } 139 140 /*ARGSUSED*/ 141 void 142 prt_oct(private_t *pri, int raw, long val) /* print as octal */ 143 { 144 GROW(24); 145 if (data_model == PR_MODEL_ILP32) 146 pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng, 147 "%#o", (int)val); 148 else 149 pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng, 150 "%#lo", val); 151 } 152 153 /*ARGSUSED*/ 154 void 155 prt_hex(private_t *pri, int raw, long val) /* print as hexadecimal */ 156 { 157 GROW(20); 158 if (data_model == PR_MODEL_ILP32) 159 pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng, 160 "0x%.8X", (int)val); 161 else 162 pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng, 163 "0x%.8lX", val); 164 } 165 166 /* print as hexadecimal (half size) */ 167 /*ARGSUSED*/ 168 void 169 prt_hhx(private_t *pri, int raw, long val) 170 { 171 GROW(20); 172 if (data_model == PR_MODEL_ILP32) 173 pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng, 174 "0x%.4X", (int)val); 175 else 176 pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng, 177 "0x%.4lX", val); 178 } 179 180 /* print as decimal if small, else hexadecimal */ 181 /*ARGSUSED*/ 182 void 183 prt_dex(private_t *pri, int raw, long val) 184 { 185 if (val & 0xff000000) 186 prt_hex(pri, 0, val); 187 else 188 prt_dec(pri, 0, val); 189 } 190 191 /* print long long offset */ 192 /*ARGSUSED*/ 193 void 194 prt_llo(private_t *pri, int raw, long val1, long val2) 195 { 196 int hival; 197 int loval; 198 199 #ifdef _LONG_LONG_LTOH 200 hival = (int)val2; 201 loval = (int)val1; 202 #else 203 hival = (int)val1; 204 loval = (int)val2; 205 #endif 206 207 if (hival == 0) { 208 prt_dex(pri, 0, loval); 209 } else { 210 GROW(18); 211 pri->sys_leng += 212 sprintf(pri->sys_string + pri->sys_leng, "0x%.8X%.8X", 213 hival, loval); 214 } 215 } 216 217 void 218 escape_string(private_t *pri, const char *s) 219 { 220 /* 221 * We want to avoid outputting unprintable characters that may 222 * destroy the user's terminal. So we do one pass to find any 223 * unprintable characters, size the array appropriately, and 224 * then walk each character by hand. Those that are unprintable 225 * are replaced by a hex escape (\xNN). We also escape quotes for 226 * completeness. 227 */ 228 int i, unprintable, quotes; 229 size_t len = strlen(s); 230 for (i = 0, unprintable = 0, quotes = 0; i < len; i++) { 231 if (!isprint(s[i])) 232 unprintable++; 233 if (s[i] == '"') 234 quotes++; 235 } 236 237 GROW(len + 3 * unprintable + quotes + 2); 238 239 pri->sys_string[pri->sys_leng++] = '"'; 240 for (i = 0; i < len; i++) { 241 if (s[i] == '"') 242 pri->sys_string[pri->sys_leng++] = '\\'; 243 244 if (isprint(s[i])) { 245 pri->sys_string[pri->sys_leng++] = s[i]; 246 } else { 247 pri->sys_leng += sprintf(pri->sys_string + 248 pri->sys_leng, "\\x%02x", (uint8_t)s[i]); 249 } 250 } 251 pri->sys_string[pri->sys_leng++] = '"'; 252 } 253 254 void 255 prt_stg(private_t *pri, int raw, long val) /* print as string */ 256 { 257 char *s = raw? NULL : fetchstring(pri, (long)val, PATH_MAX); 258 259 if (s == NULL) 260 prt_hex(pri, 0, val); 261 else 262 escape_string(pri, s); 263 } 264 265 /* print as string returned from syscall */ 266 void 267 prt_rst(private_t *pri, int raw, long val) 268 { 269 char *s = (raw || pri->Errno)? NULL : 270 fetchstring(pri, (long)val, PATH_MAX); 271 272 if (s == NULL) 273 prt_hex(pri, 0, val); 274 else { 275 GROW((int)strlen(s) + 2); 276 pri->sys_leng += snprintf(pri->sys_string + pri->sys_leng, 277 pri->sys_ssize - pri->sys_leng, "\"%s\"", s); 278 } 279 } 280 281 /* print contents of readlink() buffer */ 282 void 283 prt_rlk(private_t *pri, int raw, long val) 284 { 285 char *s = (raw || pri->Errno || pri->Rval1 <= 0)? NULL : 286 fetchstring(pri, (long)val, 287 (pri->Rval1 > PATH_MAX)? PATH_MAX : (int)pri->Rval1); 288 289 if (s == NULL) 290 prt_hex(pri, 0, val); 291 else { 292 GROW((int)strlen(s) + 2); 293 pri->sys_leng += snprintf(pri->sys_string + pri->sys_leng, 294 pri->sys_ssize - pri->sys_leng, "\"%s\"", s); 295 } 296 } 297 298 void 299 prt_ioc(private_t *pri, int raw, long val) /* print ioctl code */ 300 { 301 const char *s = raw? NULL : ioctlname(pri, (int)val); 302 303 if (s == NULL) 304 prt_hex(pri, 0, val); 305 else 306 outstring(pri, s); 307 } 308 309 void 310 prt_ioa(private_t *pri, int raw, long val) /* print ioctl argument */ 311 { 312 const char *s; 313 314 /* cheating -- look at the ioctl() code */ 315 switch (pri->sys_args[1]) { 316 317 /* kstat ioctl()s */ 318 case KSTAT_IOC_READ: 319 case KSTAT_IOC_WRITE: 320 #ifdef _LP64 321 if (data_model == PR_MODEL_ILP32) 322 prt_stg(pri, raw, 323 val + offsetof(kstat32_t, ks_name[0])); 324 else 325 #endif 326 prt_stg(pri, raw, 327 val + offsetof(kstat_t, ks_name[0])); 328 break; 329 330 /* streams ioctl()s */ 331 case I_LOOK: 332 prt_rst(pri, raw, val); 333 break; 334 case I_PUSH: 335 case I_FIND: 336 prt_stg(pri, raw, val); 337 break; 338 case I_LINK: 339 case I_UNLINK: 340 case I_SENDFD: 341 prt_dec(pri, 0, val); 342 break; 343 case I_SRDOPT: 344 if (raw || (s = strrdopt(val)) == NULL) 345 prt_dec(pri, 0, val); 346 else 347 outstring(pri, s); 348 break; 349 case I_SETSIG: 350 if (raw || (s = strevents(pri, val)) == NULL) 351 prt_hex(pri, 0, val); 352 else 353 outstring(pri, s); 354 break; 355 case I_FLUSH: 356 if (raw || (s = strflush(val)) == NULL) 357 prt_dec(pri, 0, val); 358 else 359 outstring(pri, s); 360 break; 361 362 /* tty ioctl()s */ 363 case TCSBRK: 364 case TCXONC: 365 case TCFLSH: 366 case TCDSET: 367 prt_dec(pri, 0, val); 368 break; 369 370 default: 371 prt_hex(pri, 0, val); 372 break; 373 } 374 } 375 376 void 377 prt_pip(private_t *pri, int raw, long val) /* print pipe code */ 378 { 379 const char *s = NULL; 380 381 if (!raw) { 382 switch (val) { 383 case O_CLOEXEC: 384 s = "O_CLOEXEC"; 385 break; 386 case O_NONBLOCK: 387 s = "O_NONBLOCK"; 388 break; 389 case O_CLOEXEC|O_NONBLOCK: 390 s = "O_CLOEXEC|O_NONBLOCK"; 391 break; 392 } 393 } 394 395 if (s == NULL) 396 prt_dex(pri, 0, val); 397 else 398 outstring(pri, s); 399 } 400 401 void 402 prt_pfd(private_t *pri, int raw, long val) /* print pipe code */ 403 { 404 int fds[2]; 405 char str[32]; 406 407 /* the fds only have meaning if the return value is 0 */ 408 if (!raw && 409 pri->Rval1 >= 0 && 410 Pread(Proc, fds, sizeof (fds), (long)val) == sizeof (fds)) { 411 (void) snprintf(str, sizeof (str), "[%d,%d]", fds[0], fds[1]); 412 outstring(pri, str); 413 } else { 414 prt_hex(pri, 0, val); 415 } 416 } 417 418 void 419 prt_fcn(private_t *pri, int raw, long val) /* print fcntl code */ 420 { 421 const char *s = raw? NULL : fcntlname(val); 422 423 if (s == NULL) 424 prt_dec(pri, 0, val); 425 else 426 outstring(pri, s); 427 } 428 429 void 430 prt_s86(private_t *pri, int raw, long val) /* print sysi86 code */ 431 { 432 433 const char *s = raw? NULL : si86name(val); 434 435 if (s == NULL) 436 prt_dec(pri, 0, val); 437 else 438 outstring(pri, s); 439 } 440 441 void 442 prt_uts(private_t *pri, int raw, long val) /* print utssys code */ 443 { 444 const char *s = raw? NULL : utscode(val); 445 446 if (s == NULL) 447 prt_dec(pri, 0, val); 448 else 449 outstring(pri, s); 450 } 451 452 void 453 prt_msc(private_t *pri, int raw, long val) /* print msgsys command */ 454 { 455 const char *s = raw? NULL : msgcmd(val); 456 457 if (s == NULL) 458 prt_dec(pri, 0, val); 459 else 460 outstring(pri, s); 461 } 462 463 void 464 prt_msf(private_t *pri, int raw, long val) /* print msgsys flags */ 465 { 466 const char *s = raw? NULL : msgflags(pri, (int)val); 467 468 if (s == NULL) 469 prt_oct(pri, 0, val); 470 else 471 outstring(pri, s); 472 } 473 474 void 475 prt_smc(private_t *pri, int raw, long val) /* print semsys command */ 476 { 477 const char *s = raw? NULL : semcmd(val); 478 479 if (s == NULL) 480 prt_dec(pri, 0, val); 481 else 482 outstring(pri, s); 483 } 484 485 void 486 prt_sef(private_t *pri, int raw, long val) /* print semsys flags */ 487 { 488 const char *s = raw? NULL : semflags(pri, (int)val); 489 490 if (s == NULL) 491 prt_oct(pri, 0, val); 492 else 493 outstring(pri, s); 494 } 495 496 void 497 prt_shc(private_t *pri, int raw, long val) /* print shmsys command */ 498 { 499 const char *s = raw? NULL : shmcmd(val); 500 501 if (s == NULL) 502 prt_dec(pri, 0, val); 503 else 504 outstring(pri, s); 505 } 506 507 void 508 prt_shf(private_t *pri, int raw, long val) /* print shmsys flags */ 509 { 510 const char *s = raw? NULL : shmflags(pri, (int)val); 511 512 if (s == NULL) 513 prt_oct(pri, 0, val); 514 else 515 outstring(pri, s); 516 } 517 518 void 519 prt_sfs(private_t *pri, int raw, long val) /* print sysfs code */ 520 { 521 const char *s = raw? NULL : sfsname(val); 522 523 if (s == NULL) 524 prt_dec(pri, 0, val); 525 else 526 outstring(pri, s); 527 } 528 529 void 530 prt_opn(private_t *pri, int raw, long val) /* print open code */ 531 { 532 const char *s = raw? NULL : openarg(pri, val); 533 534 if (s == NULL) 535 prt_oct(pri, 0, val); 536 else 537 outstring(pri, s); 538 } 539 540 void 541 prt_sig(private_t *pri, int raw, long val) /* print signal name */ 542 { 543 const char *s = raw? NULL : signame(pri, (int)val); 544 545 if (s == NULL) 546 prt_hex(pri, 0, val); 547 else 548 outstring(pri, s); 549 } 550 551 void 552 prt_smf(private_t *pri, int raw, long val) /* print streams message flags */ 553 { 554 switch (val) { 555 case 0: 556 prt_dec(pri, 0, val); 557 break; 558 case RS_HIPRI: 559 if (raw) 560 prt_hhx(pri, 0, val); 561 else 562 outstring(pri, "RS_HIPRI"); 563 break; 564 default: 565 prt_hhx(pri, 0, val); 566 break; 567 } 568 } 569 570 void 571 prt_mtf(private_t *pri, int raw, long val) /* print mount flags */ 572 { 573 const char *s = raw? NULL : mountflags(pri, val); 574 575 if (s == NULL) 576 prt_hex(pri, 0, val); 577 else 578 outstring(pri, s); 579 } 580 581 void 582 prt_mft(private_t *pri, int raw, long val) /* print mount file system type */ 583 { 584 if (val >= 0 && val < 256) 585 prt_dec(pri, 0, val); 586 else if (raw) 587 prt_hex(pri, 0, val); 588 else 589 prt_stg(pri, raw, val); 590 } 591 592 #define ISREAD(code) \ 593 ((code) == SYS_read || (code) == SYS_pread || (code) == SYS_pread64 || \ 594 (code) == SYS_recv || (code) == SYS_recvfrom) 595 #define ISWRITE(code) \ 596 ((code) == SYS_write || (code) == SYS_pwrite || \ 597 (code) == SYS_pwrite64 || (code) == SYS_send || (code) == SYS_sendto) 598 599 /* print contents of read() or write() I/O buffer */ 600 void 601 prt_iob(private_t *pri, int raw, long val) 602 { 603 const lwpstatus_t *Lsp = pri->lwpstat; 604 int syscall = Lsp->pr_what; 605 int fdp1 = pri->sys_args[0] + 1; 606 ssize_t nbyte = ISWRITE(syscall)? pri->sys_args[2] : 607 (pri->Errno? 0 : pri->Rval1); 608 int elsewhere = FALSE; /* TRUE iff dumped elsewhere */ 609 char buffer[IOBSIZE]; 610 611 pri->iob_buf[0] = '\0'; 612 613 if (Lsp->pr_why == PR_SYSEXIT && nbyte > IOBSIZE) { 614 if (ISREAD(syscall)) 615 elsewhere = prismember(&readfd, fdp1); 616 else 617 elsewhere = prismember(&writefd, fdp1); 618 } 619 620 if (nbyte <= 0 || elsewhere) 621 prt_hex(pri, 0, val); 622 else { 623 int nb = nbyte > IOBSIZE? IOBSIZE : (int)nbyte; 624 625 if (Pread(Proc, buffer, (size_t)nb, (long)val) != nb) 626 prt_hex(pri, 0, val); 627 else { 628 pri->iob_buf[0] = '"'; 629 showbytes(buffer, nb, pri->iob_buf + 1); 630 (void) strlcat(pri->iob_buf, 631 (nb == nbyte)? 632 (const char *)"\"" : (const char *)"\"..", 633 sizeof (pri->iob_buf)); 634 if (raw) 635 prt_hex(pri, 0, val); 636 else 637 outstring(pri, pri->iob_buf); 638 } 639 } 640 } 641 #undef ISREAD 642 #undef ISWRITE 643 644 void 645 prt_idt(private_t *pri, int raw, long val) /* print idtype_t, waitid() arg */ 646 { 647 const char *s = raw? NULL : idtype_enum(pri, val); 648 649 if (s == NULL) 650 prt_dec(pri, 0, val); 651 else 652 outstring(pri, s); 653 } 654 655 void 656 prt_wop(private_t *pri, int raw, long val) /* print waitid() options */ 657 { 658 const char *s = raw? NULL : woptions(pri, (int)val); 659 660 if (s == NULL) 661 prt_oct(pri, 0, val); 662 else 663 outstring(pri, s); 664 } 665 666 void 667 prt_whn(private_t *pri, int raw, long val) /* print lseek() whence argument */ 668 { 669 const char *s = raw? NULL : whencearg(val); 670 671 if (s == NULL) 672 prt_dec(pri, 0, val); 673 else 674 outstring(pri, s); 675 } 676 677 /*ARGSUSED*/ 678 void 679 prt_spm(private_t *pri, int raw, long val) /* print sigprocmask argument */ 680 { 681 const char *s = NULL; 682 683 if (!raw) { 684 switch (val) { 685 case SIG_BLOCK: s = "SIG_BLOCK"; break; 686 case SIG_UNBLOCK: s = "SIG_UNBLOCK"; break; 687 case SIG_SETMASK: s = "SIG_SETMASK"; break; 688 } 689 } 690 691 if (s == NULL) 692 prt_dec(pri, 0, val); 693 else 694 outstring(pri, s); 695 } 696 697 const char * 698 mmap_protect(private_t *pri, long arg) 699 { 700 char *str = pri->code_buf; 701 702 if (arg & ~(PROT_READ|PROT_WRITE|PROT_EXEC)) 703 return ((char *)NULL); 704 705 if (arg == PROT_NONE) 706 return ("PROT_NONE"); 707 708 *str = '\0'; 709 if (arg & PROT_READ) 710 (void) strlcat(str, "|PROT_READ", sizeof (pri->code_buf)); 711 if (arg & PROT_WRITE) 712 (void) strlcat(str, "|PROT_WRITE", sizeof (pri->code_buf)); 713 if (arg & PROT_EXEC) 714 (void) strlcat(str, "|PROT_EXEC", sizeof (pri->code_buf)); 715 return ((const char *)(str + 1)); 716 } 717 718 const char * 719 mmap_type(private_t *pri, long arg) 720 { 721 char *str = pri->code_buf; 722 size_t used; 723 724 #define CBSIZE sizeof (pri->code_buf) 725 switch (arg & MAP_TYPE) { 726 case MAP_SHARED: 727 used = strlcpy(str, "MAP_SHARED", CBSIZE); 728 break; 729 case MAP_PRIVATE: 730 used = strlcpy(str, "MAP_PRIVATE", CBSIZE); 731 break; 732 default: 733 used = snprintf(str, CBSIZE, "%ld", arg&MAP_TYPE); 734 break; 735 } 736 737 arg &= ~(_MAP_NEW|MAP_TYPE); 738 739 if (arg & ~(MAP_FIXED|MAP_RENAME|MAP_NORESERVE|MAP_ANON|MAP_ALIGN| 740 MAP_TEXT|MAP_INITDATA|MAP_32BIT)) 741 (void) snprintf(str + used, sizeof (pri->code_buf) - used, 742 "|0x%lX", arg); 743 else { 744 if (arg & MAP_FIXED) 745 (void) strlcat(str, "|MAP_FIXED", CBSIZE); 746 if (arg & MAP_RENAME) 747 (void) strlcat(str, "|MAP_RENAME", CBSIZE); 748 if (arg & MAP_NORESERVE) 749 (void) strlcat(str, "|MAP_NORESERVE", CBSIZE); 750 if (arg & MAP_ANON) 751 (void) strlcat(str, "|MAP_ANON", CBSIZE); 752 if (arg & MAP_ALIGN) 753 (void) strlcat(str, "|MAP_ALIGN", CBSIZE); 754 if (arg & MAP_TEXT) 755 (void) strlcat(str, "|MAP_TEXT", CBSIZE); 756 if (arg & MAP_INITDATA) 757 (void) strlcat(str, "|MAP_INITDATA", CBSIZE); 758 if (arg & MAP_32BIT) 759 (void) strlcat(str, "|MAP_32BIT", CBSIZE); 760 } 761 762 return ((const char *)str); 763 #undef CBSIZE 764 } 765 766 void 767 prt_mpr(private_t *pri, int raw, long val) /* print mmap()/mprotect() flags */ 768 { 769 const char *s = raw? NULL : mmap_protect(pri, val); 770 771 if (s == NULL) 772 prt_hhx(pri, 0, val); 773 else 774 outstring(pri, s); 775 } 776 777 void 778 prt_mty(private_t *pri, int raw, long val) /* print mmap() mapping type flags */ 779 { 780 const char *s = raw? NULL : mmap_type(pri, val); 781 782 if (s == NULL) 783 prt_hhx(pri, 0, val); 784 else 785 outstring(pri, s); 786 } 787 788 void 789 prt_mob(private_t *pri, int raw, long val) /* print mmapobj() flags */ 790 { 791 if (val == 0) 792 prt_dec(pri, 0, val); 793 else if (raw || (val & ~(MMOBJ_PADDING|MMOBJ_INTERPRET)) != 0) 794 prt_hhx(pri, 0, val); 795 else { 796 #define CBSIZE sizeof (pri->code_buf) 797 char *s = pri->code_buf; 798 799 *s = '\0'; 800 if (val & MMOBJ_PADDING) 801 (void) strlcat(s, "|MMOBJ_PADDING", CBSIZE); 802 if (val & MMOBJ_INTERPRET) 803 (void) strlcat(s, "|MMOBJ_INTERPRET", CBSIZE); 804 outstring(pri, s + 1); 805 #undef CBSIZE 806 } 807 } 808 809 /*ARGSUSED*/ 810 void 811 prt_mcf(private_t *pri, int raw, long val) /* print memcntl() function */ 812 { 813 const char *s = NULL; 814 815 if (!raw) { 816 switch (val) { 817 case MC_SYNC: s = "MC_SYNC"; break; 818 case MC_LOCK: s = "MC_LOCK"; break; 819 case MC_UNLOCK: s = "MC_UNLOCK"; break; 820 case MC_ADVISE: s = "MC_ADVISE"; break; 821 case MC_LOCKAS: s = "MC_LOCKAS"; break; 822 case MC_UNLOCKAS: s = "MC_UNLOCKAS"; break; 823 case MC_HAT_ADVISE: s = "MC_HAT_ADVISE"; break; 824 } 825 } 826 827 if (s == NULL) 828 prt_dec(pri, 0, val); 829 else 830 outstring(pri, s); 831 } 832 833 void 834 prt_mad(private_t *pri, int raw, long val) /* print madvise() argument */ 835 { 836 const char *s = NULL; 837 838 if (!raw) { 839 switch (val) { 840 case MADV_NORMAL: s = "MADV_NORMAL"; break; 841 case MADV_RANDOM: s = "MADV_RANDOM"; break; 842 case MADV_SEQUENTIAL: s = "MADV_SEQUENTIAL"; break; 843 case MADV_WILLNEED: s = "MADV_WILLNEED"; break; 844 case MADV_DONTNEED: s = "MADV_DONTNEED"; break; 845 case MADV_FREE: s = "MADV_FREE"; break; 846 case MADV_ACCESS_DEFAULT: s = "MADV_ACCESS_DEFAULT"; break; 847 case MADV_ACCESS_LWP: s = "MADV_ACCESS_LWP"; break; 848 case MADV_ACCESS_MANY: s = "MADV_ACCESS_MANY"; break; 849 case MADV_PURGE: s = "MADV_PURGE"; break; 850 } 851 } 852 853 if (s == NULL) 854 prt_dec(pri, 0, val); 855 else 856 outstring(pri, s); 857 } 858 859 void 860 prt_mc4(private_t *pri, int raw, long val) /* print memcntl() (4th) argument */ 861 { 862 if (val == 0) 863 prt_dec(pri, 0, val); 864 else if (raw) 865 prt_hhx(pri, 0, val); 866 else { 867 char *s = NULL; 868 869 #define CBSIZE sizeof (pri->code_buf) 870 /* cheating -- look at memcntl func */ 871 switch (pri->sys_args[2]) { 872 case MC_ADVISE: 873 prt_mad(pri, 0, val); 874 return; 875 876 case MC_SYNC: 877 if ((val & ~(MS_SYNC|MS_ASYNC|MS_INVALIDATE)) == 0) { 878 *(s = pri->code_buf) = '\0'; 879 if (val & MS_SYNC) 880 (void) strlcat(s, "|MS_SYNC", CBSIZE); 881 if (val & MS_ASYNC) 882 (void) strlcat(s, "|MS_ASYNC", CBSIZE); 883 if (val & MS_INVALIDATE) 884 (void) strlcat(s, "|MS_INVALIDATE", 885 CBSIZE); 886 } 887 break; 888 889 case MC_LOCKAS: 890 case MC_UNLOCKAS: 891 if ((val & ~(MCL_CURRENT|MCL_FUTURE)) == 0) { 892 *(s = pri->code_buf) = '\0'; 893 if (val & MCL_CURRENT) 894 (void) strlcat(s, "|MCL_CURRENT", 895 CBSIZE); 896 if (val & MCL_FUTURE) 897 (void) strlcat(s, "|MCL_FUTURE", 898 CBSIZE); 899 } 900 break; 901 } 902 #undef CBSIZE 903 904 if (s == NULL || *s == '\0') 905 prt_hhx(pri, 0, val); 906 else 907 outstring(pri, ++s); 908 } 909 } 910 911 void 912 prt_mc5(private_t *pri, int raw, long val) /* print memcntl() (5th) argument */ 913 { 914 char *s; 915 916 #define CBSIZE sizeof (pri->code_buf) 917 if (val == 0) 918 prt_dec(pri, 0, val); 919 else if (raw || (val & ~VALID_ATTR)) 920 prt_hhx(pri, 0, val); 921 else { 922 s = pri->code_buf; 923 *s = '\0'; 924 if (val & SHARED) 925 (void) strlcat(s, "|SHARED", CBSIZE); 926 if (val & PRIVATE) 927 (void) strlcat(s, "|PRIVATE", CBSIZE); 928 if (val & PROT_READ) 929 (void) strlcat(s, "|PROT_READ", CBSIZE); 930 if (val & PROT_WRITE) 931 (void) strlcat(s, "|PROT_WRITE", CBSIZE); 932 if (val & PROT_EXEC) 933 (void) strlcat(s, "|PROT_EXEC", CBSIZE); 934 if (*s == '\0') 935 prt_hhx(pri, 0, val); 936 else 937 outstring(pri, ++s); 938 } 939 #undef CBSIZE 940 } 941 942 void 943 prt_ulm(private_t *pri, int raw, long val) /* print ulimit() argument */ 944 { 945 const char *s = NULL; 946 947 if (!raw) { 948 switch (val) { 949 case UL_GFILLIM: s = "UL_GFILLIM"; break; 950 case UL_SFILLIM: s = "UL_SFILLIM"; break; 951 case UL_GMEMLIM: s = "UL_GMEMLIM"; break; 952 case UL_GDESLIM: s = "UL_GDESLIM"; break; 953 } 954 } 955 956 if (s == NULL) 957 prt_dec(pri, 0, val); 958 else 959 outstring(pri, s); 960 } 961 962 void 963 prt_rlm(private_t *pri, int raw, long val) /* print get/setrlimit() argument */ 964 { 965 const char *s = NULL; 966 967 if (!raw) { 968 switch (val) { 969 case RLIMIT_CPU: s = "RLIMIT_CPU"; break; 970 case RLIMIT_FSIZE: s = "RLIMIT_FSIZE"; break; 971 case RLIMIT_DATA: s = "RLIMIT_DATA"; break; 972 case RLIMIT_STACK: s = "RLIMIT_STACK"; break; 973 case RLIMIT_CORE: s = "RLIMIT_CORE"; break; 974 case RLIMIT_NOFILE: s = "RLIMIT_NOFILE"; break; 975 case RLIMIT_VMEM: s = "RLIMIT_VMEM"; break; 976 } 977 } 978 979 if (s == NULL) 980 prt_dec(pri, 0, val); 981 else 982 outstring(pri, s); 983 } 984 985 void 986 prt_cnf(private_t *pri, int raw, long val) /* print sysconfig code */ 987 { 988 const char *s = raw? NULL : sconfname(val); 989 990 if (s == NULL) 991 prt_dec(pri, 0, val); 992 else 993 outstring(pri, s); 994 } 995 996 void 997 prt_inf(private_t *pri, int raw, long val) /* print sysinfo code */ 998 { 999 const char *s = NULL; 1000 1001 if (!raw) { 1002 switch (val) { 1003 case SI_SYSNAME: s = "SI_SYSNAME"; break; 1004 case SI_HOSTNAME: s = "SI_HOSTNAME"; break; 1005 case SI_RELEASE: s = "SI_RELEASE"; break; 1006 case SI_VERSION: s = "SI_VERSION"; break; 1007 case SI_MACHINE: s = "SI_MACHINE"; break; 1008 case SI_ARCHITECTURE: s = "SI_ARCHITECTURE"; break; 1009 case SI_ARCHITECTURE_32:s = "SI_ARCHITECTURE_32"; break; 1010 case SI_ARCHITECTURE_64:s = "SI_ARCHITECTURE_64"; break; 1011 case SI_ARCHITECTURE_K: s = "SI_ARCHITECTURE_K"; break; 1012 case SI_HW_SERIAL: s = "SI_HW_SERIAL"; break; 1013 case SI_HW_PROVIDER: s = "SI_HW_PROVIDER"; break; 1014 case SI_SRPC_DOMAIN: s = "SI_SRPC_DOMAIN"; break; 1015 case SI_SET_HOSTNAME: s = "SI_SET_HOSTNAME"; break; 1016 case SI_SET_SRPC_DOMAIN: s = "SI_SET_SRPC_DOMAIN"; break; 1017 case SI_PLATFORM: s = "SI_PLATFORM"; break; 1018 case SI_ISALIST: s = "SI_ISALIST"; break; 1019 case SI_DHCP_CACHE: s = "SI_DHCP_CACHE"; break; 1020 } 1021 } 1022 1023 if (s == NULL) 1024 prt_dec(pri, 0, val); 1025 else 1026 outstring(pri, s); 1027 } 1028 1029 void 1030 prt_ptc(private_t *pri, int raw, long val) /* print pathconf code */ 1031 { 1032 const char *s = raw? NULL : pathconfname(val); 1033 1034 if (s == NULL) 1035 prt_dec(pri, 0, val); 1036 else 1037 outstring(pri, s); 1038 } 1039 1040 void 1041 prt_fui(private_t *pri, int raw, long val) /* print fusers() input argument */ 1042 { 1043 const char *s = raw? NULL : fuiname(val); 1044 1045 if (s == NULL) 1046 prt_hhx(pri, 0, val); 1047 else 1048 outstring(pri, s); 1049 } 1050 1051 void 1052 prt_lwf(private_t *pri, int raw, long val) /* print lwp_create() flags */ 1053 { 1054 char *s; 1055 1056 if (val == 0) 1057 prt_dec(pri, 0, val); 1058 else if (raw || 1059 (val & ~(LWP_DAEMON|LWP_DETACHED|LWP_SUSPENDED))) 1060 prt_hhx(pri, 0, val); 1061 else { 1062 #define CBSIZE sizeof (pri->code_buf) 1063 s = pri->code_buf; 1064 *s = '\0'; 1065 if (val & LWP_DAEMON) 1066 (void) strlcat(s, "|LWP_DAEMON", CBSIZE); 1067 if (val & LWP_DETACHED) 1068 (void) strlcat(s, "|LWP_DETACHED", CBSIZE); 1069 if (val & LWP_SUSPENDED) 1070 (void) strlcat(s, "|LWP_SUSPENDED", CBSIZE); 1071 outstring(pri, ++s); 1072 #undef CBSIZE 1073 } 1074 } 1075 1076 void 1077 prt_itm(private_t *pri, int raw, long val) /* print [get|set]itimer() arg */ 1078 { 1079 const char *s = NULL; 1080 1081 if (!raw) { 1082 switch (val) { 1083 case ITIMER_REAL: s = "ITIMER_REAL"; break; 1084 case ITIMER_VIRTUAL: s = "ITIMER_VIRTUAL"; break; 1085 case ITIMER_PROF: s = "ITIMER_PROF"; break; 1086 #ifdef ITIMER_REALPROF 1087 case ITIMER_REALPROF: s = "ITIMER_REALPROF"; break; 1088 #endif 1089 } 1090 } 1091 1092 if (s == NULL) 1093 prt_dec(pri, 0, val); 1094 else 1095 outstring(pri, s); 1096 } 1097 1098 void 1099 prt_mod(private_t *pri, int raw, long val) /* print modctl() code */ 1100 { 1101 const char *s = NULL; 1102 1103 if (!raw) { 1104 switch (val) { 1105 case MODLOAD: s = "MODLOAD"; break; 1106 case MODUNLOAD: s = "MODUNLOAD"; break; 1107 case MODINFO: s = "MODINFO"; break; 1108 case MODRESERVED: s = "MODRESERVED"; break; 1109 case MODSETMINIROOT: s = "MODSETMINIROOT"; break; 1110 case MODADDMAJBIND: s = "MODADDMAJBIND"; break; 1111 case MODGETPATH: s = "MODGETPATH"; break; 1112 case MODGETPATHLEN: s = "MODGETPATHLEN"; break; 1113 case MODREADSYSBIND: s = "MODREADSYSBIND"; break; 1114 case MODGETMAJBIND: s = "MODGETMAJBIND"; break; 1115 case MODGETNAME: s = "MODGETNAME"; break; 1116 case MODSIZEOF_DEVID: s = "MODSIZEOF_DEVID"; break; 1117 case MODGETDEVID: s = "MODGETDEVID"; break; 1118 case MODSIZEOF_MINORNAME: s = "MODSIZEOF_MINORNAME"; break; 1119 case MODGETMINORNAME: s = "MODGETMINORNAME"; break; 1120 case MODGETFBNAME: s = "MODGETFBNAME"; break; 1121 case MODEVENTS: s = "MODEVENTS"; break; 1122 case MODREREADDACF: s = "MODREREADDACF"; break; 1123 case MODLOADDRVCONF: s = "MODLOADDRVCONF"; break; 1124 case MODUNLOADDRVCONF: s = "MODUNLOADDRVCONF"; break; 1125 case MODREMMAJBIND: s = "MODREMMAJBIND"; break; 1126 case MODDEVT2INSTANCE: s = "MODDEVT2INSTANCE"; break; 1127 case MODGETDEVFSPATH_LEN: s = "MODGETDEVFSPATH_LEN"; break; 1128 case MODGETDEVFSPATH: s = "MODGETDEVFSPATH"; break; 1129 case MODDEVID2PATHS: s = "MODDEVID2PATHS"; break; 1130 case MODSETDEVPOLICY: s = "MODSETDEVPOLICY"; break; 1131 case MODGETDEVPOLICY: s = "MODGETDEVPOLICY"; break; 1132 case MODALLOCPRIV: s = "MODALLOCPRIV"; break; 1133 case MODGETDEVPOLICYBYNAME: 1134 s = "MODGETDEVPOLICYBYNAME"; break; 1135 case MODLOADMINORPERM: s = "MODLOADMINORPERM"; break; 1136 case MODADDMINORPERM: s = "MODADDMINORPERM"; break; 1137 case MODREMMINORPERM: s = "MODREMMINORPERM"; break; 1138 case MODREMDRVCLEANUP: s = "MODREMDRVCLEANUP"; break; 1139 case MODDEVEXISTS: s = "MODDEVEXISTS"; break; 1140 case MODDEVREADDIR: s = "MODDEVREADDIR"; break; 1141 case MODDEVEMPTYDIR: s = "MODDEVEMPTYDIR"; break; 1142 case MODDEVNAME: s = "MODDEVNAME"; break; 1143 case MODGETDEVFSPATH_MI_LEN: 1144 s = "MODGETDEVFSPATH_MI_LEN"; break; 1145 case MODGETDEVFSPATH_MI: 1146 s = "MODGETDEVFSPATH_MI"; break; 1147 case MODREMDRVALIAS: s = "MODREMDRVALIAS"; break; 1148 case MODHPOPS: s = "MODHPOPS"; break; 1149 } 1150 } 1151 1152 if (s == NULL) 1153 prt_dec(pri, 0, val); 1154 else 1155 outstring(pri, s); 1156 } 1157 1158 void 1159 prt_acl(private_t *pri, int raw, long val) /* print acl() code */ 1160 { 1161 const char *s = NULL; 1162 1163 if (!raw) { 1164 switch (val) { 1165 case GETACL: s = "GETACL"; break; 1166 case SETACL: s = "SETACL"; break; 1167 case GETACLCNT: s = "GETACLCNT"; break; 1168 case ACE_GETACL: s = "ACE_GETACL"; break; 1169 case ACE_SETACL: s = "ACE_SETACL"; break; 1170 case ACE_GETACLCNT: s = "ACE_GETACLCNT"; break; 1171 } 1172 } 1173 1174 if (s == NULL) 1175 prt_dec(pri, 0, val); 1176 else 1177 outstring(pri, s); 1178 } 1179 1180 void 1181 prt_aio(private_t *pri, int raw, long val) /* print kaio() code */ 1182 { 1183 const char *s = NULL; 1184 char buf[32]; 1185 1186 if (!raw) { 1187 switch (val & ~AIO_POLL_BIT) { 1188 case AIOREAD: s = "AIOREAD"; break; 1189 case AIOWRITE: s = "AIOWRITE"; break; 1190 case AIOWAIT: s = "AIOWAIT"; break; 1191 case AIOCANCEL: s = "AIOCANCEL"; break; 1192 case AIONOTIFY: s = "AIONOTIFY"; break; 1193 case AIOINIT: s = "AIOINIT"; break; 1194 case AIOSTART: s = "AIOSTART"; break; 1195 case AIOLIO: s = "AIOLIO"; break; 1196 case AIOSUSPEND: s = "AIOSUSPEND"; break; 1197 case AIOERROR: s = "AIOERROR"; break; 1198 case AIOLIOWAIT: s = "AIOLIOWAIT"; break; 1199 case AIOAREAD: s = "AIOAREAD"; break; 1200 case AIOAWRITE: s = "AIOAWRITE"; break; 1201 /* 1202 * We have to hardcode the values for the 64-bit versions of 1203 * these calls, because <sys/aio.h> defines them to be identical 1204 * when compiled 64-bit. If our target is 32-bit, we still need 1205 * to decode them correctly. 1206 */ 1207 case 13: s = "AIOLIO64"; break; 1208 case 14: s = "AIOSUSPEND64"; break; 1209 case 15: s = "AUIOERROR64"; break; 1210 case 16: s = "AIOLIOWAIT64"; break; 1211 case 17: s = "AIOAREAD64"; break; 1212 case 18: s = "AIOAWRITE64"; break; 1213 case 19: s = "AIOCANCEL64"; break; 1214 1215 /* 1216 * AIOFSYNC doesn't correspond to a syscall. 1217 */ 1218 case AIOWAITN: s = "AIOWAITN"; break; 1219 } 1220 if (s != NULL && (val & AIO_POLL_BIT)) { 1221 (void) strlcpy(buf, s, sizeof (buf)); 1222 (void) strlcat(buf, "|AIO_POLL_BIT", sizeof (buf)); 1223 s = (const char *)buf; 1224 } 1225 } 1226 1227 if (s == NULL) 1228 prt_dec(pri, 0, val); 1229 else 1230 outstring(pri, s); 1231 } 1232 1233 void 1234 prt_aud(private_t *pri, int raw, long val) /* print auditsys() code */ 1235 { 1236 const char *s = NULL; 1237 1238 if (!raw) { 1239 switch (val) { 1240 case BSM_GETAUID: s = "BSM_GETAUID"; break; 1241 case BSM_SETAUID: s = "BSM_SETAUID"; break; 1242 case BSM_GETAUDIT: s = "BSM_GETAUDIT"; break; 1243 case BSM_SETAUDIT: s = "BSM_SETAUDIT"; break; 1244 case BSM_AUDIT: s = "BSM_AUDIT"; break; 1245 case BSM_AUDITCTL: s = "BSM_AUDITCTL"; break; 1246 case BSM_GETAUDIT_ADDR: s = "BSM_GETAUDIT_ADDR"; break; 1247 case BSM_SETAUDIT_ADDR: s = "BSM_SETAUDIT_ADDR"; break; 1248 } 1249 } 1250 1251 if (s == NULL) 1252 prt_dec(pri, 0, val); 1253 else 1254 outstring(pri, s); 1255 } 1256 1257 void 1258 prt_cor(private_t *pri, int raw, long val) /* print corectl() subcode */ 1259 { 1260 const char *s = NULL; 1261 1262 if (!raw) { 1263 switch (val) { 1264 case CC_SET_OPTIONS: 1265 s = "CC_SET_OPTIONS"; break; 1266 case CC_GET_OPTIONS: 1267 s = "CC_GET_OPTIONS"; break; 1268 case CC_SET_GLOBAL_PATH: 1269 s = "CC_SET_GLOBAL_PATH"; break; 1270 case CC_GET_GLOBAL_PATH: 1271 s = "CC_GET_GLOBAL_PATH"; break; 1272 case CC_SET_PROCESS_PATH: 1273 s = "CC_SET_PROCESS_PATH"; break; 1274 case CC_GET_PROCESS_PATH: 1275 s = "CC_GET_PROCESS_PATH"; break; 1276 case CC_SET_GLOBAL_CONTENT: 1277 s = "CC_SET_GLOBAL_CONTENT"; break; 1278 case CC_GET_GLOBAL_CONTENT: 1279 s = "CC_GET_GLOBAL_CONTENT"; break; 1280 case CC_SET_PROCESS_CONTENT: 1281 s = "CC_SET_PROCESS_CONTENT"; break; 1282 case CC_GET_PROCESS_CONTENT: 1283 s = "CC_GET_PROCESS_CONTENT"; break; 1284 case CC_SET_DEFAULT_PATH: 1285 s = "CC_SET_DEFAULT_PATH"; break; 1286 case CC_GET_DEFAULT_PATH: 1287 s = "CC_GET_DEFAULT_PATH"; break; 1288 case CC_SET_DEFAULT_CONTENT: 1289 s = "CC_SET_DEFAULT_CONTENT"; break; 1290 case CC_GET_DEFAULT_CONTENT: 1291 s = "CC_GET_DEFAULT_CONTENT"; break; 1292 } 1293 } 1294 1295 if (s == NULL) 1296 prt_dec(pri, 0, val); 1297 else 1298 outstring(pri, s); 1299 } 1300 1301 void 1302 prt_cco(private_t *pri, int raw, long val) /* print corectl() options */ 1303 { 1304 char *s; 1305 1306 if (val == 0) 1307 prt_dec(pri, 0, val); 1308 else if (raw || (val & ~CC_OPTIONS)) 1309 prt_hhx(pri, 0, val); 1310 else { 1311 #define CBSIZE sizeof (pri->code_buf) 1312 s = pri->code_buf; 1313 *s = '\0'; 1314 if (val & CC_GLOBAL_PATH) 1315 (void) strlcat(s, "|CC_GLOBAL_PATH", CBSIZE); 1316 if (val & CC_PROCESS_PATH) 1317 (void) strlcat(s, "|CC_PROCESS_PATH", CBSIZE); 1318 if (val & CC_GLOBAL_SETID) 1319 (void) strlcat(s, "|CC_GLOBAL_SETID", CBSIZE); 1320 if (val & CC_PROCESS_SETID) 1321 (void) strlcat(s, "|CC_PROCESS_SETID", CBSIZE); 1322 if (val & CC_GLOBAL_LOG) 1323 (void) strlcat(s, "|CC_GLOBAL_LOG", CBSIZE); 1324 if (*s == '\0') 1325 prt_hhx(pri, 0, val); 1326 else 1327 outstring(pri, ++s); 1328 #undef CBSIZE 1329 } 1330 } 1331 1332 void 1333 prt_ccc(private_t *pri, int raw, long val) /* print corectl() content */ 1334 { 1335 core_content_t ccc; 1336 1337 if (Pread(Proc, &ccc, sizeof (ccc), val) != sizeof (ccc)) 1338 prt_hex(pri, 0, val); 1339 else if (!raw && proc_content2str(ccc, pri->code_buf, 1340 sizeof (pri->code_buf)) >= 0) 1341 outstring(pri, pri->code_buf); 1342 else 1343 prt_hhx(pri, 0, (long)ccc); 1344 } 1345 1346 void 1347 prt_rcc(private_t *pri, int raw, long val) /* print corectl() ret. cont. */ 1348 { 1349 core_content_t ccc; 1350 1351 if (pri->Errno || Pread(Proc, &ccc, sizeof (ccc), val) != sizeof (ccc)) 1352 prt_hex(pri, 0, val); 1353 else if (!raw && proc_content2str(ccc, pri->code_buf, 1354 sizeof (pri->code_buf)) >= 0) 1355 outstring(pri, pri->code_buf); 1356 else 1357 prt_hhx(pri, 0, (long)ccc); 1358 } 1359 1360 void 1361 prt_cpc(private_t *pri, int raw, long val) /* print cpc() subcode */ 1362 { 1363 const char *s = NULL; 1364 1365 if (!raw) { 1366 switch (val) { 1367 case CPC_BIND: s = "CPC_BIND"; break; 1368 case CPC_SAMPLE: s = "CPC_SAMPLE"; break; 1369 case CPC_INVALIDATE: s = "CPC_INVALIDATE"; break; 1370 case CPC_RELE: s = "CPC_RELE"; break; 1371 case CPC_EVLIST_SIZE: s = "CPC_EVLIST_SIZE"; break; 1372 case CPC_LIST_EVENTS: s = "CPC_LIST_EVENTS"; break; 1373 case CPC_ATTRLIST_SIZE: s = "CPC_ATTRLIST_SIZE"; break; 1374 case CPC_LIST_ATTRS: s = "CPC_LIST_ATTRS"; break; 1375 case CPC_IMPL_NAME: s = "CPC_IMPL_NAME"; break; 1376 case CPC_CPUREF: s = "CPC_CPUREF"; break; 1377 case CPC_USR_EVENTS: s = "CPC_USR_EVENTS"; break; 1378 case CPC_SYS_EVENTS: s = "CPC_SYS_EVENTS"; break; 1379 case CPC_NPIC: s = "CPC_NPIC"; break; 1380 case CPC_CAPS: s = "CPC_CAPS"; break; 1381 case CPC_ENABLE: s = "CPC_ENABLE"; break; 1382 case CPC_DISABLE: s = "CPC_DISABLE"; break; 1383 } 1384 } 1385 1386 if (s == NULL) 1387 prt_dec(pri, 0, val); 1388 else 1389 outstring(pri, s); 1390 } 1391 1392 void 1393 outstring(private_t *pri, const char *s) 1394 { 1395 int len = strlen(s); 1396 1397 GROW(len); 1398 (void) strcpy(pri->sys_string + pri->sys_leng, s); 1399 pri->sys_leng += len; 1400 } 1401 1402 void 1403 grow(private_t *pri, int nbyte) /* reallocate format buffer if necessary */ 1404 { 1405 while (pri->sys_leng + nbyte >= pri->sys_ssize) 1406 pri->sys_string = my_realloc(pri->sys_string, 1407 pri->sys_ssize *= 2, "format buffer"); 1408 } 1409 1410 void 1411 prt_clc(private_t *pri, int raw, long val) 1412 { 1413 const char *s = NULL; 1414 1415 if (!raw) { 1416 switch (val) { 1417 case CL_INITIALIZE: s = "CL_INITIALIZE"; break; 1418 case CL_CONFIG: s = "CL_CONFIG"; break; 1419 } 1420 } 1421 1422 if (s == NULL) 1423 prt_dec(pri, 0, val); 1424 else 1425 outstring(pri, s); 1426 } 1427 1428 void 1429 prt_clf(private_t *pri, int raw, long val) 1430 { 1431 const char *s = NULL; 1432 1433 if (!raw) { 1434 switch (pri->sys_args[0]) { 1435 case CL_CONFIG: 1436 switch (pri->sys_args[1]) { 1437 case CL_NODEID: 1438 s = "CL_NODEID"; break; 1439 case CL_HIGHEST_NODEID: 1440 s = "CL_HIGHEST_NODEID"; break; 1441 } 1442 break; 1443 case CL_INITIALIZE: 1444 switch (pri->sys_args[1]) { 1445 case CL_GET_BOOTFLAG: 1446 s = "CL_GET_BOOTFLAG"; break; 1447 } 1448 break; 1449 } 1450 } 1451 1452 if (s == NULL) 1453 prt_dec(pri, 0, val); 1454 else 1455 outstring(pri, s); 1456 } 1457 1458 void 1459 prt_sqc(private_t *pri, int raw, long val) /* print sigqueue() si_code */ 1460 { 1461 const char *s = NULL; 1462 1463 if (!raw) { 1464 switch ((int)val) { 1465 case SI_QUEUE: s = "SI_QUEUE"; break; 1466 case SI_TIMER: s = "SI_TIMER"; break; 1467 case SI_ASYNCIO: s = "SI_ASYNCIO"; break; 1468 case SI_MESGQ: s = "SI_MESGQ"; break; 1469 } 1470 } 1471 1472 if (s == NULL) 1473 prt_dec(pri, 0, val); 1474 else 1475 outstring(pri, s); 1476 } 1477 1478 /* 1479 * print priocntlsys() (key, value) pair key. 1480 */ 1481 void 1482 print_pck(private_t *pri, int raw, long val) 1483 { 1484 const char *s = NULL; 1485 char clname[PC_CLNMSZ]; 1486 1487 if ((pri->sys_args[2] != PC_GETXPARMS && 1488 pri->sys_args[2] != PC_SETXPARMS) || val == 0 || raw) { 1489 prt_dec(pri, 0, val); 1490 return; 1491 } 1492 1493 if (pri->sys_args[3] == 0) { 1494 if (val == PC_KY_CLNAME) { 1495 s = "PC_KY_CLNAME"; 1496 outstring(pri, s); 1497 } else 1498 prt_dec(pri, 0, val); 1499 return; 1500 } 1501 1502 if (Pread(Proc, &clname, PC_CLNMSZ, pri->sys_args[3]) != PC_CLNMSZ) { 1503 prt_dec(pri, 0, val); 1504 return; 1505 } 1506 1507 if (strcmp(clname, "TS") == 0) { 1508 switch (val) { 1509 case TS_KY_UPRILIM: s = "TS_KY_UPRILIM"; break; 1510 case TS_KY_UPRI: s = "TS_KY_UPRI"; break; 1511 default: break; 1512 } 1513 } else if (strcmp(clname, "IA") == 0) { 1514 switch (val) { 1515 case IA_KY_UPRILIM: s = "IA_KY_UPRILIM"; break; 1516 case IA_KY_UPRI: s = "IA_KY_UPRI"; break; 1517 case IA_KY_MODE: s = "IA_KY_MODE"; break; 1518 default: break; 1519 } 1520 } else if (strcmp(clname, "RT") == 0) { 1521 switch (val) { 1522 case RT_KY_PRI: s = "RT_KY_PRI"; break; 1523 case RT_KY_TQSECS: s = "RT_KY_TQSECS"; break; 1524 case RT_KY_TQNSECS: s = "RT_KY_TQNSECS"; break; 1525 case RT_KY_TQSIG: s = "RT_KY_TQSIG"; break; 1526 default: break; 1527 } 1528 } else if (strcmp(clname, "FSS") == 0) { 1529 switch (val) { 1530 case FSS_KY_UPRILIM: s = "FSS_KY_UPRILIM"; break; 1531 case FSS_KY_UPRI: s = "FSS_KY_UPRI"; break; 1532 default: break; 1533 } 1534 } else if (strcmp(clname, "FX") == 0) { 1535 switch (val) { 1536 case FX_KY_UPRILIM: s = "FX_KY_UPRILIM"; break; 1537 case FX_KY_UPRI: s = "FX_KY_UPRI"; break; 1538 case FX_KY_TQSECS: s = "FX_KY_TQSECS"; break; 1539 case FX_KY_TQNSECS: s = "FX_KY_TQNSECS"; break; 1540 default: break; 1541 } 1542 } 1543 1544 if (s == NULL) 1545 prt_dec(pri, 0, val); 1546 else 1547 outstring(pri, s); 1548 } 1549 1550 /* 1551 * print priocntlsys() fourth argument. 1552 */ 1553 /*ARGSUSED*/ 1554 void 1555 prt_pc4(private_t *pri, int raw, long val) 1556 { 1557 /* look at pricntlsys function */ 1558 if ((pri->sys_args[2] != PC_GETXPARMS && 1559 pri->sys_args[2] != PC_SETXPARMS)) 1560 prt_hex(pri, 0, val); 1561 else if (val) 1562 prt_stg(pri, 0, val); 1563 else 1564 prt_dec(pri, 0, val); 1565 } 1566 1567 /* 1568 * print priocntlsys() (key, value) pairs (5th argument). 1569 */ 1570 /*ARGSUSED*/ 1571 void 1572 prt_pc5(private_t *pri, int raw, long val) 1573 { 1574 pc_vaparms_t prms; 1575 pc_vaparm_t *vpp = &prms.pc_parms[0]; 1576 uint_t cnt; 1577 1578 1579 /* look at pricntlsys function */ 1580 if ((pri->sys_args[2] != PC_GETXPARMS && 1581 pri->sys_args[2] != PC_SETXPARMS) || val == 0) { 1582 prt_dec(pri, 0, 0); 1583 return; 1584 } 1585 1586 if (Pread(Proc, &prms, sizeof (prms), val) != sizeof (prms)) { 1587 prt_hex(pri, 0, val); 1588 return; 1589 } 1590 1591 if ((cnt = prms.pc_vaparmscnt) > PC_VAPARMCNT) 1592 return; 1593 1594 for (; cnt--; vpp++) { 1595 print_pck(pri, 0, vpp->pc_key); 1596 outstring(pri, ", "); 1597 prt_hex(pri, 0, (long)vpp->pc_parm); 1598 outstring(pri, ", "); 1599 } 1600 1601 prt_dec(pri, 0, PC_KY_NULL); 1602 } 1603 1604 1605 void 1606 prt_psflags(private_t *pri, secflagset_t val) 1607 { 1608 size_t len; 1609 char *ptr; 1610 char str[1024]; 1611 1612 if (val == 0) { 1613 outstring(pri, "0x0"); 1614 return; 1615 } 1616 1617 *str = '\0'; 1618 if (secflag_isset(val, PROC_SEC_ASLR)) { 1619 (void) strlcat(str, "|PROC_SEC_ASLR", sizeof (str)); 1620 secflag_clear(&val, PROC_SEC_ASLR); 1621 } 1622 if (secflag_isset(val, PROC_SEC_FORBIDNULLMAP)) { 1623 (void) strlcat(str, "|PROC_SEC_FORBIDNULLMAP", 1624 sizeof (str)); 1625 secflag_clear(&val, PROC_SEC_FORBIDNULLMAP); 1626 } 1627 if (secflag_isset(val, PROC_SEC_NOEXECSTACK)) { 1628 (void) strlcat(str, "|PROC_SEC_NOEXECSTACK", 1629 sizeof (str)); 1630 secflag_clear(&val, PROC_SEC_NOEXECSTACK); 1631 } 1632 1633 if (val != 0) { 1634 len = strlen(str); 1635 ptr = str + len; 1636 (void) snprintf(ptr, sizeof (str) - len, "|%#x", val); 1637 } 1638 1639 outstring(pri, str + 1); 1640 } 1641 1642 /* 1643 * Print a psecflags(2) delta 1644 */ 1645 void 1646 prt_psdelta(private_t *pri, int raw, long value) 1647 { 1648 secflagdelta_t psd; 1649 1650 if ((raw != 0) || 1651 (Pread(Proc, &psd, sizeof (psd), value) != sizeof (psd))) { 1652 prt_hex(pri, 0, value); 1653 return; 1654 } 1655 outstring(pri, "{ "); 1656 prt_psflags(pri, psd.psd_add); 1657 outstring(pri, ", "); 1658 prt_psflags(pri, psd.psd_rem); 1659 outstring(pri, ", "); 1660 prt_psflags(pri, psd.psd_assign); 1661 outstring(pri, ", "); 1662 outstring(pri, psd.psd_ass_active ? "B_TRUE" : "B_FALSE"); 1663 outstring(pri, " }"); 1664 } 1665 1666 /* 1667 * Print a psecflagswhich_t 1668 */ 1669 void 1670 prt_psfw(private_t *pri, int raw, long value) 1671 { 1672 psecflagwhich_t which = (psecflagwhich_t)value; 1673 char *s; 1674 1675 if (raw != 0) { 1676 prt_dec(pri, 0, value); 1677 return; 1678 } 1679 1680 switch (which) { 1681 case PSF_EFFECTIVE: 1682 s = "PSF_EFFECTIVE"; 1683 break; 1684 case PSF_INHERIT: 1685 s = "PSF_INHERIT"; 1686 break; 1687 case PSF_LOWER: 1688 s = "PSF_LOWER"; 1689 break; 1690 case PSF_UPPER: 1691 s = "PSF_UPPER"; 1692 break; 1693 } 1694 1695 if (s == NULL) 1696 prt_dec(pri, 0, value); 1697 else 1698 outstring(pri, s); 1699 } 1700 1701 /* 1702 * Print processor set id, including logical expansion of "special" ids. 1703 */ 1704 void 1705 prt_pst(private_t *pri, int raw, long val) 1706 { 1707 const char *s = NULL; 1708 1709 if (!raw) { 1710 switch ((psetid_t)val) { 1711 case PS_NONE: s = "PS_NONE"; break; 1712 case PS_QUERY: s = "PS_QUERY"; break; 1713 case PS_MYID: s = "PS_MYID"; break; 1714 } 1715 } 1716 1717 if (s == NULL) 1718 prt_dec(pri, 0, val); 1719 else 1720 outstring(pri, s); 1721 } 1722 1723 /* 1724 * Print meminfo() argument. 1725 */ 1726 /*ARGSUSED*/ 1727 void 1728 prt_mif(private_t *pri, int raw, long val) 1729 { 1730 struct meminfo minfo; 1731 1732 #ifdef _LP64 1733 if (data_model == PR_MODEL_ILP32) { 1734 struct meminfo32 minfo32; 1735 1736 if (Pread(Proc, &minfo32, sizeof (struct meminfo32), val) != 1737 sizeof (struct meminfo32)) { 1738 prt_dec(pri, 0, pri->sys_args[1]); /* addr_count */ 1739 outstring(pri, ", "); 1740 prt_hex(pri, 0, val); 1741 return; 1742 } 1743 /* 1744 * arrange the arguments in the order that user calls with 1745 */ 1746 prt_hex(pri, 0, minfo32.mi_inaddr); 1747 outstring(pri, ", "); 1748 prt_dec(pri, 0, pri->sys_args[1]); /* addr_count */ 1749 outstring(pri, ", "); 1750 prt_hex(pri, 0, minfo32.mi_info_req); 1751 outstring(pri, ", "); 1752 prt_dec(pri, 0, minfo32.mi_info_count); 1753 outstring(pri, ", "); 1754 prt_hex(pri, 0, minfo32.mi_outdata); 1755 outstring(pri, ", "); 1756 prt_hex(pri, 0, minfo32.mi_validity); 1757 return; 1758 } 1759 #endif 1760 if (Pread(Proc, &minfo, sizeof (struct meminfo), val) != 1761 sizeof (struct meminfo)) { 1762 prt_dec(pri, 0, pri->sys_args[1]); /* addr_count */ 1763 outstring(pri, ", "); 1764 prt_hex(pri, 0, val); 1765 return; 1766 } 1767 /* 1768 * arrange the arguments in the order that user calls with 1769 */ 1770 prt_hex(pri, 0, (long)minfo.mi_inaddr); 1771 outstring(pri, ", "); 1772 prt_dec(pri, 0, pri->sys_args[1]); /* addr_count */ 1773 outstring(pri, ", "); 1774 prt_hex(pri, 0, (long)minfo.mi_info_req); 1775 outstring(pri, ", "); 1776 prt_dec(pri, 0, minfo.mi_info_count); 1777 outstring(pri, ", "); 1778 prt_hex(pri, 0, (long)minfo.mi_outdata); 1779 outstring(pri, ", "); 1780 prt_hex(pri, 0, (long)minfo.mi_validity); 1781 } 1782 1783 1784 /* 1785 * Print so_socket() 1st argument. 1786 */ 1787 /*ARGSUSED*/ 1788 void 1789 prt_pfm(private_t *pri, int raw, long val) 1790 { 1791 /* Protocol Families have same names as Address Families */ 1792 if ((ulong_t)val < MAX_AFCODES) { 1793 outstring(pri, "PF_"); 1794 outstring(pri, afcodes[val]); 1795 } else { 1796 prt_dec(pri, 0, val); 1797 } 1798 } 1799 1800 /* 1801 * Print sockconfig() subcode. 1802 */ 1803 /*ARGSUSED*/ 1804 void 1805 prt_skc(private_t *pri, int raw, long val) 1806 { 1807 const char *s = NULL; 1808 1809 if (!raw) { 1810 switch (val) { 1811 case SOCKCONFIG_ADD_SOCK: 1812 s = "SOCKCONFIG_ADD_SOCK"; break; 1813 case SOCKCONFIG_REMOVE_SOCK: 1814 s = "SOCKCONFIG_REMOVE_SOCK"; break; 1815 case SOCKCONFIG_ADD_FILTER: 1816 s = "SOCKCONFIG_ADD_FILTER"; break; 1817 case SOCKCONFIG_REMOVE_FILTER: 1818 s = "SOCKCONFIG_REMOVE_FILTER"; break; 1819 } 1820 } 1821 if (s == NULL) 1822 prt_dec(pri, 0, val); 1823 else 1824 outstring(pri, s); 1825 } 1826 /* 1827 * Print so_socket() 2nd argument. 1828 */ 1829 /*ARGSUSED*/ 1830 void 1831 prt_skt(private_t *pri, int raw, long val) 1832 { 1833 const char *s; 1834 long type = val & SOCK_TYPE_MASK; 1835 1836 if ((ulong_t)type <= MAX_SOCKTYPES && 1837 (s = socktype_codes[type]) != NULL) { 1838 outstring(pri, s); 1839 if ((val & SOCK_CLOEXEC) != 0) { 1840 outstring(pri, "|SOCK_CLOEXEC"); 1841 } 1842 } else { 1843 prt_dec(pri, 0, val); 1844 } 1845 } 1846 1847 1848 /* 1849 * Print so_socket() 3rd argument. 1850 */ 1851 /*ARGSUSED*/ 1852 void 1853 prt_skp(private_t *pri, int raw, long val) 1854 { 1855 const char *s; 1856 1857 /* cheating -- look at the protocol-family */ 1858 switch (pri->sys_args[0]) { 1859 case PF_INET6: 1860 case PF_INET: 1861 case PF_NCA: if ((s = ipprotos((int)val)) != NULL) { 1862 outstring(pri, s); 1863 break; 1864 } 1865 /* FALLTHROUGH */ 1866 default: prt_dec(pri, 0, val); 1867 break; 1868 } 1869 } 1870 1871 1872 /* 1873 * Print so_socket() 5th argument. 1874 */ 1875 /*ARGSUSED*/ 1876 void 1877 prt_skv(private_t *pri, int raw, long val) 1878 { 1879 switch (val) { 1880 case SOV_STREAM: outstring(pri, "SOV_STREAM"); break; 1881 case SOV_DEFAULT: outstring(pri, "SOV_DEFAULT"); break; 1882 case SOV_SOCKSTREAM: outstring(pri, "SOV_SOCKSTREAM"); break; 1883 case SOV_SOCKBSD: outstring(pri, "SOV_SOCKBSD"); break; 1884 case SOV_XPG4_2: outstring(pri, "SOV_XPG4_2"); break; 1885 default: prt_dec(pri, 0, val); break; 1886 } 1887 } 1888 1889 /* 1890 * Print accept4() flags argument. 1891 */ 1892 void 1893 prt_acf(private_t *pri, int raw, long val) 1894 { 1895 int first = 1; 1896 if (raw || !val || 1897 (val & ~(SOCK_CLOEXEC|SOCK_NDELAY|SOCK_NONBLOCK))) { 1898 prt_dex(pri, 0, val); 1899 return; 1900 } 1901 1902 if (val & SOCK_CLOEXEC) { 1903 outstring(pri, "|SOCK_CLOEXEC" + first); 1904 first = 0; 1905 } 1906 if (val & SOCK_NDELAY) { 1907 outstring(pri, "|SOCK_NDELAY" + first); 1908 first = 0; 1909 } 1910 if (val & SOCK_NONBLOCK) { 1911 outstring(pri, "|SOCK_NONBLOCK" + first); 1912 } 1913 } 1914 1915 1916 /* 1917 * Print setsockopt()/getsockopt() 2nd argument. 1918 */ 1919 /*ARGSUSED*/ 1920 void 1921 prt_sol(private_t *pri, int raw, long val) 1922 { 1923 if (val == SOL_SOCKET) { 1924 outstring(pri, "SOL_SOCKET"); 1925 } else if (val == SOL_ROUTE) { 1926 outstring(pri, "SOL_ROUTE"); 1927 } else { 1928 const struct protoent *p; 1929 struct protoent res; 1930 char buf[NSS_BUFLEN_PROTOCOLS]; 1931 1932 if ((p = getprotobynumber_r(val, &res, 1933 (char *)buf, sizeof (buf))) != NULL) 1934 outstring(pri, p->p_name); 1935 else 1936 prt_dec(pri, 0, val); 1937 } 1938 } 1939 1940 1941 const char * 1942 sol_optname(private_t *pri, long val) 1943 { 1944 #define CBSIZE sizeof (pri->code_buf) 1945 if (val >= SO_SNDBUF) { 1946 switch (val) { 1947 case SO_SNDBUF: return ("SO_SNDBUF"); 1948 case SO_RCVBUF: return ("SO_RCVBUF"); 1949 case SO_SNDLOWAT: return ("SO_SNDLOWAT"); 1950 case SO_RCVLOWAT: return ("SO_RCVLOWAT"); 1951 case SO_SNDTIMEO: return ("SO_SNDTIMEO"); 1952 case SO_RCVTIMEO: return ("SO_RCVTIMEO"); 1953 case SO_ERROR: return ("SO_ERROR"); 1954 case SO_TYPE: return ("SO_TYPE"); 1955 case SO_PROTOTYPE: return ("SO_PROTOTYPE"); 1956 case SO_ANON_MLP: return ("SO_ANON_MLP"); 1957 case SO_MAC_EXEMPT: return ("SO_MAC_EXEMPT"); 1958 case SO_ALLZONES: return ("SO_ALLZONES"); 1959 case SO_MAC_IMPLICIT: return ("SO_MAC_IMPLICIT"); 1960 case SO_VRRP: return ("SO_VRRP"); 1961 case SO_EXCLBIND: return ("SO_EXCLBIND"); 1962 case SO_DOMAIN: return ("SO_DOMAIN"); 1963 1964 default: (void) snprintf(pri->code_buf, CBSIZE, 1965 "0x%lx", val); 1966 return (pri->code_buf); 1967 } 1968 } else { 1969 char *s = pri->code_buf; 1970 size_t used = 1; 1971 long val2; 1972 1973 *s = '\0'; 1974 val2 = val & ~(SO_DEBUG|SO_ACCEPTCONN|SO_REUSEADDR|SO_KEEPALIVE| 1975 SO_DONTROUTE|SO_BROADCAST|SO_USELOOPBACK|SO_LINGER| 1976 SO_OOBINLINE|SO_DGRAM_ERRIND|SO_RECVUCRED); 1977 if (val2) 1978 used = snprintf(s, CBSIZE, "|0x%lx", val2); 1979 if (val & SO_DEBUG) 1980 used = strlcat(s, "|SO_DEBUG", CBSIZE); 1981 if (val & SO_ACCEPTCONN) 1982 used = strlcat(s, "|SO_ACCEPTCONN", CBSIZE); 1983 if (val & SO_REUSEADDR) 1984 used = strlcat(s, "|SO_REUSEADDR", CBSIZE); 1985 if (val & SO_KEEPALIVE) 1986 used = strlcat(s, "|SO_KEEPALIVE", CBSIZE); 1987 if (val & SO_DONTROUTE) 1988 used = strlcat(s, "|SO_DONTROUTE", CBSIZE); 1989 if (val & SO_BROADCAST) 1990 used = strlcat(s, "|SO_BROADCAST", CBSIZE); 1991 if (val & SO_USELOOPBACK) 1992 used = strlcat(s, "|SO_USELOOPBACK", CBSIZE); 1993 if (val & SO_LINGER) 1994 used = strlcat(s, "|SO_LINGER", CBSIZE); 1995 if (val & SO_OOBINLINE) 1996 used = strlcat(s, "|SO_OOBINLINE", CBSIZE); 1997 if (val & SO_DGRAM_ERRIND) 1998 used = strlcat(s, "|SO_DGRAM_ERRIND", CBSIZE); 1999 if (val & SO_RECVUCRED) 2000 used = strlcat(s, "|SO_RECVUCRED", CBSIZE); 2001 if (used >= CBSIZE || val == 0) 2002 (void) snprintf(s + 1, CBSIZE-1, "0x%lx", val); 2003 return ((const char *)(s + 1)); 2004 } 2005 #undef CBSIZE 2006 } 2007 2008 const char * 2009 route_optname(private_t *pri, long val) 2010 { 2011 switch (val) { 2012 case RT_AWARE: 2013 return ("RT_AWARE"); 2014 default: 2015 (void) snprintf(pri->code_buf, sizeof (pri->code_buf), 2016 "0x%lx", val); 2017 return (pri->code_buf); 2018 } 2019 } 2020 2021 const char * 2022 tcp_optname(private_t *pri, long val) 2023 { 2024 switch (val) { 2025 case TCP_NODELAY: return ("TCP_NODELAY"); 2026 case TCP_MAXSEG: return ("TCP_MAXSEG"); 2027 case TCP_KEEPALIVE: return ("TCP_KEEPALIVE"); 2028 case TCP_NOTIFY_THRESHOLD: return ("TCP_NOTIFY_THRESHOLD"); 2029 case TCP_ABORT_THRESHOLD: return ("TCP_ABORT_THRESHOLD"); 2030 case TCP_CONN_NOTIFY_THRESHOLD: return ("TCP_CONN_NOTIFY_THRESHOLD"); 2031 case TCP_CONN_ABORT_THRESHOLD: return ("TCP_CONN_ABORT_THRESHOLD"); 2032 case TCP_RECVDSTADDR: return ("TCP_RECVDSTADDR"); 2033 case TCP_ANONPRIVBIND: return ("TCP_ANONPRIVBIND"); 2034 case TCP_EXCLBIND: return ("TCP_EXCLBIND"); 2035 case TCP_INIT_CWND: return ("TCP_INIT_CWND"); 2036 case TCP_KEEPALIVE_THRESHOLD: return ("TCP_KEEPALIVE_THRESHOLD"); 2037 case TCP_KEEPALIVE_ABORT_THRESHOLD: 2038 return ("TCP_KEEPALIVE_ABORT_THRESHOLD"); 2039 case TCP_CORK: return ("TCP_CORK"); 2040 case TCP_RTO_INITIAL: return ("TCP_RTO_INITIAL"); 2041 case TCP_RTO_MIN: return ("TCP_RTO_MIN"); 2042 case TCP_RTO_MAX: return ("TCP_RTO_MAX"); 2043 case TCP_LINGER2: return ("TCP_LINGER2"); 2044 case TCP_KEEPIDLE: return ("TCP_KEEPIDLE"); 2045 case TCP_KEEPCNT: return ("TCP_KEEPCNT"); 2046 case TCP_KEEPINTVL: return ("TCP_KEEPINTVL"); 2047 case TCP_CONGESTION: return ("TCP_CONGESTION"); 2048 2049 default: (void) snprintf(pri->code_buf, 2050 sizeof (pri->code_buf), 2051 "0x%lx", val); 2052 return (pri->code_buf); 2053 } 2054 } 2055 2056 2057 const char * 2058 sctp_optname(private_t *pri, long val) 2059 { 2060 switch (val) { 2061 case SCTP_RTOINFO: return ("SCTP_RTOINFO"); 2062 case SCTP_ASSOCINFO: return ("SCTP_ASSOCINFO"); 2063 case SCTP_INITMSG: return ("SCTP_INITMSG"); 2064 case SCTP_NODELAY: return ("SCTP_NODELAY"); 2065 case SCTP_AUTOCLOSE: return ("SCTP_AUTOCLOSE"); 2066 case SCTP_SET_PEER_PRIMARY_ADDR: 2067 return ("SCTP_SET_PEER_PRIMARY_ADDR"); 2068 case SCTP_PRIMARY_ADDR: return ("SCTP_PRIMARY_ADDR"); 2069 case SCTP_ADAPTATION_LAYER: return ("SCTP_ADAPTATION_LAYER"); 2070 case SCTP_DISABLE_FRAGMENTS: return ("SCTP_DISABLE_FRAGMENTS"); 2071 case SCTP_PEER_ADDR_PARAMS: return ("SCTP_PEER_ADDR_PARAMS"); 2072 case SCTP_DEFAULT_SEND_PARAM: return ("SCTP_DEFAULT_SEND_PARAM"); 2073 case SCTP_EVENTS: return ("SCTP_EVENTS"); 2074 case SCTP_I_WANT_MAPPED_V4_ADDR: 2075 return ("SCTP_I_WANT_MAPPED_V4_ADDR"); 2076 case SCTP_MAXSEG: return ("SCTP_MAXSEG"); 2077 case SCTP_STATUS: return ("SCTP_STATUS"); 2078 case SCTP_GET_PEER_ADDR_INFO: return ("SCTP_GET_PEER_ADDR_INFO"); 2079 2080 case SCTP_ADD_ADDR: return ("SCTP_ADD_ADDR"); 2081 case SCTP_REM_ADDR: return ("SCTP_REM_ADDR"); 2082 2083 default: (void) snprintf(pri->code_buf, 2084 sizeof (pri->code_buf), 2085 "0x%lx", val); 2086 return (pri->code_buf); 2087 } 2088 } 2089 2090 2091 const char * 2092 udp_optname(private_t *pri, long val) 2093 { 2094 switch (val) { 2095 case UDP_CHECKSUM: return ("UDP_CHECKSUM"); 2096 case UDP_ANONPRIVBIND: return ("UDP_ANONPRIVBIND"); 2097 case UDP_EXCLBIND: return ("UDP_EXCLBIND"); 2098 case UDP_RCVHDR: return ("UDP_RCVHDR"); 2099 case UDP_NAT_T_ENDPOINT: return ("UDP_NAT_T_ENDPOINT"); 2100 2101 default: (void) snprintf(pri->code_buf, 2102 sizeof (pri->code_buf), "0x%lx", 2103 val); 2104 return (pri->code_buf); 2105 } 2106 } 2107 2108 2109 /* 2110 * Print setsockopt()/getsockopt() 3rd argument. 2111 */ 2112 /*ARGSUSED*/ 2113 void 2114 prt_son(private_t *pri, int raw, long val) 2115 { 2116 /* cheating -- look at the level */ 2117 switch (pri->sys_args[1]) { 2118 case SOL_SOCKET: outstring(pri, sol_optname(pri, val)); 2119 break; 2120 case SOL_ROUTE: outstring(pri, route_optname(pri, val)); 2121 break; 2122 case IPPROTO_TCP: outstring(pri, tcp_optname(pri, val)); 2123 break; 2124 case IPPROTO_UDP: outstring(pri, udp_optname(pri, val)); 2125 break; 2126 case IPPROTO_SCTP: outstring(pri, sctp_optname(pri, val)); 2127 break; 2128 default: prt_dec(pri, 0, val); 2129 break; 2130 } 2131 } 2132 2133 2134 /* 2135 * Print utrap type 2136 */ 2137 /*ARGSUSED*/ 2138 void 2139 prt_utt(private_t *pri, int raw, long val) 2140 { 2141 const char *s = NULL; 2142 2143 #ifdef __sparc 2144 if (!raw) { 2145 switch (val) { 2146 case UT_INSTRUCTION_DISABLED: 2147 s = "UT_INSTRUCTION_DISABLED"; break; 2148 case UT_INSTRUCTION_ERROR: 2149 s = "UT_INSTRUCTION_ERROR"; break; 2150 case UT_INSTRUCTION_PROTECTION: 2151 s = "UT_INSTRUCTION_PROTECTION"; break; 2152 case UT_ILLTRAP_INSTRUCTION: 2153 s = "UT_ILLTRAP_INSTRUCTION"; break; 2154 case UT_ILLEGAL_INSTRUCTION: 2155 s = "UT_ILLEGAL_INSTRUCTION"; break; 2156 case UT_PRIVILEGED_OPCODE: 2157 s = "UT_PRIVILEGED_OPCODE"; break; 2158 case UT_FP_DISABLED: 2159 s = "UT_FP_DISABLED"; break; 2160 case UT_FP_EXCEPTION_IEEE_754: 2161 s = "UT_FP_EXCEPTION_IEEE_754"; break; 2162 case UT_FP_EXCEPTION_OTHER: 2163 s = "UT_FP_EXCEPTION_OTHER"; break; 2164 case UT_TAG_OVERFLOW: 2165 s = "UT_TAG_OVERFLOW"; break; 2166 case UT_DIVISION_BY_ZERO: 2167 s = "UT_DIVISION_BY_ZERO"; break; 2168 case UT_DATA_EXCEPTION: 2169 s = "UT_DATA_EXCEPTION"; break; 2170 case UT_DATA_ERROR: 2171 s = "UT_DATA_ERROR"; break; 2172 case UT_DATA_PROTECTION: 2173 s = "UT_DATA_PROTECTION"; break; 2174 case UT_MEM_ADDRESS_NOT_ALIGNED: 2175 s = "UT_MEM_ADDRESS_NOT_ALIGNED"; break; 2176 case UT_PRIVILEGED_ACTION: 2177 s = "UT_PRIVILEGED_ACTION"; break; 2178 case UT_ASYNC_DATA_ERROR: 2179 s = "UT_ASYNC_DATA_ERROR"; break; 2180 case UT_TRAP_INSTRUCTION_16: 2181 s = "UT_TRAP_INSTRUCTION_16"; break; 2182 case UT_TRAP_INSTRUCTION_17: 2183 s = "UT_TRAP_INSTRUCTION_17"; break; 2184 case UT_TRAP_INSTRUCTION_18: 2185 s = "UT_TRAP_INSTRUCTION_18"; break; 2186 case UT_TRAP_INSTRUCTION_19: 2187 s = "UT_TRAP_INSTRUCTION_19"; break; 2188 case UT_TRAP_INSTRUCTION_20: 2189 s = "UT_TRAP_INSTRUCTION_20"; break; 2190 case UT_TRAP_INSTRUCTION_21: 2191 s = "UT_TRAP_INSTRUCTION_21"; break; 2192 case UT_TRAP_INSTRUCTION_22: 2193 s = "UT_TRAP_INSTRUCTION_22"; break; 2194 case UT_TRAP_INSTRUCTION_23: 2195 s = "UT_TRAP_INSTRUCTION_23"; break; 2196 case UT_TRAP_INSTRUCTION_24: 2197 s = "UT_TRAP_INSTRUCTION_24"; break; 2198 case UT_TRAP_INSTRUCTION_25: 2199 s = "UT_TRAP_INSTRUCTION_25"; break; 2200 case UT_TRAP_INSTRUCTION_26: 2201 s = "UT_TRAP_INSTRUCTION_26"; break; 2202 case UT_TRAP_INSTRUCTION_27: 2203 s = "UT_TRAP_INSTRUCTION_27"; break; 2204 case UT_TRAP_INSTRUCTION_28: 2205 s = "UT_TRAP_INSTRUCTION_28"; break; 2206 case UT_TRAP_INSTRUCTION_29: 2207 s = "UT_TRAP_INSTRUCTION_29"; break; 2208 case UT_TRAP_INSTRUCTION_30: 2209 s = "UT_TRAP_INSTRUCTION_30"; break; 2210 case UT_TRAP_INSTRUCTION_31: 2211 s = "UT_TRAP_INSTRUCTION_31"; break; 2212 } 2213 } 2214 #endif /* __sparc */ 2215 2216 if (s == NULL) 2217 prt_dec(pri, 0, val); 2218 else 2219 outstring(pri, s); 2220 } 2221 2222 2223 /* 2224 * Print utrap handler 2225 */ 2226 void 2227 prt_uth(private_t *pri, int raw, long val) 2228 { 2229 const char *s = NULL; 2230 2231 if (!raw) { 2232 switch (val) { 2233 case (long)UTH_NOCHANGE: s = "UTH_NOCHANGE"; break; 2234 } 2235 } 2236 2237 if (s == NULL) 2238 prt_hex(pri, 0, val); 2239 else 2240 outstring(pri, s); 2241 } 2242 2243 const char * 2244 access_flags(private_t *pri, long arg) 2245 { 2246 #define E_OK 010 2247 char *str = pri->code_buf; 2248 2249 if (arg & ~(R_OK|W_OK|X_OK|E_OK)) 2250 return (NULL); 2251 2252 /* NB: F_OK == 0 */ 2253 if (arg == F_OK) 2254 return ("F_OK"); 2255 if (arg == E_OK) 2256 return ("F_OK|E_OK"); 2257 2258 *str = '\0'; 2259 if (arg & R_OK) 2260 (void) strlcat(str, "|R_OK", sizeof (pri->code_buf)); 2261 if (arg & W_OK) 2262 (void) strlcat(str, "|W_OK", sizeof (pri->code_buf)); 2263 if (arg & X_OK) 2264 (void) strlcat(str, "|X_OK", sizeof (pri->code_buf)); 2265 if (arg & E_OK) 2266 (void) strlcat(str, "|E_OK", sizeof (pri->code_buf)); 2267 return ((const char *)(str + 1)); 2268 #undef E_OK 2269 } 2270 2271 /* 2272 * Print access() flags. 2273 */ 2274 void 2275 prt_acc(private_t *pri, int raw, long val) 2276 { 2277 const char *s = raw? NULL : access_flags(pri, val); 2278 2279 if (s == NULL) 2280 prt_dex(pri, 0, val); 2281 else 2282 outstring(pri, s); 2283 } 2284 2285 /* 2286 * Print shutdown() "how" (2nd) argument 2287 */ 2288 void 2289 prt_sht(private_t *pri, int raw, long val) 2290 { 2291 if (raw) { 2292 prt_dex(pri, 0, val); 2293 return; 2294 } 2295 switch (val) { 2296 case SHUT_RD: outstring(pri, "SHUT_RD"); break; 2297 case SHUT_WR: outstring(pri, "SHUT_WR"); break; 2298 case SHUT_RDWR: outstring(pri, "SHUT_RDWR"); break; 2299 default: prt_dec(pri, 0, val); break; 2300 } 2301 } 2302 2303 /* 2304 * Print fcntl() F_SETFL flags (3rd) argument or fdsync flag (2nd arg) 2305 */ 2306 static struct fcntl_flags { 2307 long val; 2308 const char *name; 2309 } fcntl_flags[] = { 2310 #define FC_FL(flag) { (long)flag, "|" # flag } 2311 FC_FL(FREVOKED), 2312 FC_FL(FREAD), 2313 FC_FL(FWRITE), 2314 FC_FL(FNDELAY), 2315 FC_FL(FAPPEND), 2316 FC_FL(FSYNC), 2317 FC_FL(FDSYNC), 2318 FC_FL(FRSYNC), 2319 FC_FL(FOFFMAX), 2320 FC_FL(FNONBLOCK), 2321 FC_FL(FCREAT), 2322 FC_FL(FTRUNC), 2323 FC_FL(FEXCL), 2324 FC_FL(FNOCTTY), 2325 FC_FL(FXATTR), 2326 FC_FL(FASYNC), 2327 FC_FL(FNODSYNC) 2328 #undef FC_FL 2329 }; 2330 2331 void 2332 prt_ffg(private_t *pri, int raw, long val) 2333 { 2334 #define CBSIZE sizeof (pri->code_buf) 2335 char *s = pri->code_buf; 2336 size_t used = 1; 2337 struct fcntl_flags *fp; 2338 2339 if (raw) { 2340 (void) snprintf(s, CBSIZE, "0x%lx", val); 2341 outstring(pri, s); 2342 return; 2343 } 2344 if (val == 0) { 2345 outstring(pri, "(no flags)"); 2346 return; 2347 } 2348 2349 *s = '\0'; 2350 for (fp = fcntl_flags; 2351 fp < &fcntl_flags[sizeof (fcntl_flags) / sizeof (*fp)]; fp++) { 2352 if (val & fp->val) { 2353 used = strlcat(s, fp->name, CBSIZE); 2354 val &= ~fp->val; 2355 } 2356 } 2357 2358 if (val != 0 && used <= CBSIZE) 2359 used += snprintf(s + used, CBSIZE - used, "|0x%lx", val); 2360 2361 if (used >= CBSIZE) 2362 (void) snprintf(s + 1, CBSIZE-1, "0x%lx", val); 2363 outstring(pri, s + 1); 2364 #undef CBSIZE 2365 } 2366 2367 void 2368 prt_prs(private_t *pri, int raw, long val) 2369 { 2370 static size_t setsize; 2371 priv_set_t *set = priv_allocset(); 2372 2373 if (setsize == 0) { 2374 const priv_impl_info_t *info = getprivimplinfo(); 2375 if (info != NULL) 2376 setsize = info->priv_setsize * sizeof (priv_chunk_t); 2377 } 2378 2379 if (setsize != 0 && !raw && set != NULL && 2380 Pread(Proc, set, setsize, val) == setsize) { 2381 int i; 2382 2383 outstring(pri, "{"); 2384 for (i = 0; i < setsize / sizeof (priv_chunk_t); i++) { 2385 char buf[9]; /* 8 hex digits + '\0' */ 2386 (void) snprintf(buf, sizeof (buf), "%08x", 2387 ((priv_chunk_t *)set)[i]); 2388 outstring(pri, buf); 2389 } 2390 2391 outstring(pri, "}"); 2392 } else { 2393 prt_hex(pri, 0, val); 2394 } 2395 2396 if (set != NULL) 2397 priv_freeset(set); 2398 } 2399 2400 /* 2401 * Print privilege set operation. 2402 */ 2403 void 2404 prt_pro(private_t *pri, int raw, long val) 2405 { 2406 const char *s = NULL; 2407 2408 if (!raw) { 2409 switch ((priv_op_t)val) { 2410 case PRIV_ON: s = "PRIV_ON"; break; 2411 case PRIV_OFF: s = "PRIV_OFF"; break; 2412 case PRIV_SET: s = "PRIV_SET"; break; 2413 } 2414 } 2415 2416 if (s == NULL) 2417 prt_dec(pri, 0, val); 2418 else 2419 outstring(pri, s); 2420 } 2421 2422 /* 2423 * Print privilege set name 2424 */ 2425 void 2426 prt_prn(private_t *pri, int raw, long val) 2427 { 2428 const char *s = NULL; 2429 2430 if (!raw) 2431 s = priv_getsetbynum((int)val); 2432 2433 if (s == NULL) 2434 prt_dec(pri, 0, val); 2435 else { 2436 char *dup = strdup(s); 2437 char *q; 2438 2439 /* Do the best we can in this case */ 2440 if (dup == NULL) { 2441 outstring(pri, s); 2442 return; 2443 } 2444 2445 outstring(pri, "PRIV_"); 2446 2447 q = dup; 2448 2449 while (*q != '\0') { 2450 *q = toupper(*q); 2451 q++; 2452 } 2453 outstring(pri, dup); 2454 free(dup); 2455 } 2456 } 2457 2458 /* 2459 * Print process flag names. 2460 */ 2461 void 2462 prt_pfl(private_t *pri, int raw, long val) 2463 { 2464 const char *s = NULL; 2465 2466 if (!raw) { 2467 switch ((int)val) { 2468 case PRIV_DEBUG: s = "PRIV_DEBUG"; break; 2469 case PRIV_AWARE: s = "PRIV_AWARE"; break; 2470 case PRIV_XPOLICY: s = "PRIV_XPOLICY"; break; 2471 case PRIV_AWARE_RESET: s = "PRIV_AWARE_RESET"; break; 2472 case PRIV_PFEXEC: s = "PRIV_PFEXEC"; break; 2473 case NET_MAC_AWARE: s = "NET_MAC_AWARE"; break; 2474 case NET_MAC_AWARE_INHERIT: 2475 s = "NET_MAC_AWARE_INHERIT"; 2476 break; 2477 } 2478 } 2479 2480 if (s == NULL) 2481 prt_dec(pri, 0, val); 2482 else 2483 outstring(pri, s); 2484 } 2485 2486 /* 2487 * Print lgrp_affinity_{get,set}() arguments. 2488 */ 2489 /*ARGSUSED*/ 2490 void 2491 prt_laf(private_t *pri, int raw, long val) 2492 { 2493 lgrp_affinity_args_t laff; 2494 2495 if (Pread(Proc, &laff, sizeof (lgrp_affinity_args_t), val) != 2496 sizeof (lgrp_affinity_args_t)) { 2497 prt_hex(pri, 0, val); 2498 return; 2499 } 2500 /* 2501 * arrange the arguments in the order that user calls with 2502 */ 2503 prt_dec(pri, 0, laff.idtype); 2504 outstring(pri, ", "); 2505 prt_dec(pri, 0, laff.id); 2506 outstring(pri, ", "); 2507 prt_dec(pri, 0, laff.lgrp); 2508 outstring(pri, ", "); 2509 if (pri->sys_args[0] == LGRP_SYS_AFFINITY_SET) 2510 prt_dec(pri, 0, laff.aff); 2511 } 2512 2513 /* 2514 * Print a key_t as IPC_PRIVATE if it is 0. 2515 */ 2516 void 2517 prt_key(private_t *pri, int raw, long val) 2518 { 2519 if (!raw && val == 0) 2520 outstring(pri, "IPC_PRIVATE"); 2521 else 2522 prt_dec(pri, 0, val); 2523 } 2524 2525 2526 /* 2527 * Print zone_getattr() attribute types. 2528 */ 2529 void 2530 prt_zga(private_t *pri, int raw, long val) 2531 { 2532 const char *s = NULL; 2533 2534 if (!raw) { 2535 switch ((int)val) { 2536 case ZONE_ATTR_NAME: s = "ZONE_ATTR_NAME"; break; 2537 case ZONE_ATTR_ROOT: s = "ZONE_ATTR_ROOT"; break; 2538 case ZONE_ATTR_STATUS: s = "ZONE_ATTR_STATUS"; break; 2539 case ZONE_ATTR_PRIVSET: s = "ZONE_ATTR_PRIVSET"; break; 2540 case ZONE_ATTR_UNIQID: s = "ZONE_ATTR_UNIQID"; break; 2541 case ZONE_ATTR_POOLID: s = "ZONE_ATTR_POOLID"; break; 2542 case ZONE_ATTR_INITPID: s = "ZONE_ATTR_INITPID"; break; 2543 case ZONE_ATTR_SLBL: s = "ZONE_ATTR_SLBL"; break; 2544 case ZONE_ATTR_INITNAME: s = "ZONE_ATTR_INITNAME"; break; 2545 case ZONE_ATTR_BOOTARGS: s = "ZONE_ATTR_BOOTARGS"; break; 2546 case ZONE_ATTR_BRAND: s = "ZONE_ATTR_BRAND"; break; 2547 case ZONE_ATTR_FLAGS: s = "ZONE_ATTR_FLAGS"; break; 2548 case ZONE_ATTR_PHYS_MCAP: s = "ZONE_ATTR_PHYS_MCAP"; break; 2549 } 2550 } 2551 2552 if (s == NULL) 2553 prt_dec(pri, 0, val); 2554 else 2555 outstring(pri, s); 2556 } 2557 2558 /* 2559 * Print a file descriptor as AT_FDCWD if necessary 2560 */ 2561 void 2562 prt_atc(private_t *pri, int raw, long val) 2563 { 2564 if ((int)val == AT_FDCWD) { 2565 if (raw) 2566 prt_hex(pri, 0, (uint_t)AT_FDCWD); 2567 else 2568 outstring(pri, "AT_FDCWD"); 2569 } else { 2570 prt_dec(pri, 0, val); 2571 } 2572 } 2573 2574 /* 2575 * Print Trusted Networking database operation codes (labelsys; tn*) 2576 */ 2577 static void 2578 prt_tnd(private_t *pri, int raw, long val) 2579 { 2580 const char *s = NULL; 2581 2582 if (!raw) { 2583 switch ((tsol_dbops_t)val) { 2584 case TNDB_NOOP: s = "TNDB_NOOP"; break; 2585 case TNDB_LOAD: s = "TNDB_LOAD"; break; 2586 case TNDB_DELETE: s = "TNDB_DELETE"; break; 2587 case TNDB_FLUSH: s = "TNDB_FLUSH"; break; 2588 case TNDB_GET: s = "TNDB_GET"; break; 2589 } 2590 } 2591 2592 if (s == NULL) 2593 prt_dec(pri, 0, val); 2594 else 2595 outstring(pri, s); 2596 } 2597 2598 /* 2599 * Print LIO_XX flags 2600 */ 2601 void 2602 prt_lio(private_t *pri, int raw, long val) 2603 { 2604 if (raw) 2605 prt_dec(pri, 0, val); 2606 else if (val == LIO_WAIT) 2607 outstring(pri, "LIO_WAIT"); 2608 else if (val == LIO_NOWAIT) 2609 outstring(pri, "LIO_NOWAIT"); 2610 else 2611 prt_dec(pri, 0, val); 2612 } 2613 2614 const char * 2615 door_flags(private_t *pri, long val) 2616 { 2617 door_attr_t attr = (door_attr_t)val; 2618 char *str = pri->code_buf; 2619 2620 *str = '\0'; 2621 #define PROCESS_FLAG(flg) \ 2622 if (attr & flg) { \ 2623 (void) strlcat(str, "|" #flg, sizeof (pri->code_buf)); \ 2624 attr &= ~flg; \ 2625 } 2626 2627 PROCESS_FLAG(DOOR_UNREF); 2628 PROCESS_FLAG(DOOR_UNREF_MULTI); 2629 PROCESS_FLAG(DOOR_PRIVATE); 2630 PROCESS_FLAG(DOOR_REFUSE_DESC); 2631 PROCESS_FLAG(DOOR_NO_CANCEL); 2632 PROCESS_FLAG(DOOR_LOCAL); 2633 PROCESS_FLAG(DOOR_REVOKED); 2634 PROCESS_FLAG(DOOR_IS_UNREF); 2635 #undef PROCESS_FLAG 2636 2637 if (attr != 0 || *str == '\0') { 2638 size_t len = strlen(str); 2639 (void) snprintf(str + len, sizeof (pri->code_buf) - len, 2640 "|0x%X", attr); 2641 } 2642 2643 return (str + 1); 2644 } 2645 2646 /* 2647 * Print door_create() flags 2648 */ 2649 void 2650 prt_dfl(private_t *pri, int raw, long val) 2651 { 2652 if (raw) 2653 prt_hex(pri, 0, val); 2654 else 2655 outstring(pri, door_flags(pri, val)); 2656 } 2657 2658 /* 2659 * Print door_*param() param argument 2660 */ 2661 void 2662 prt_dpm(private_t *pri, int raw, long val) 2663 { 2664 if (raw) 2665 prt_hex(pri, 0, val); 2666 else if (val == DOOR_PARAM_DESC_MAX) 2667 outstring(pri, "DOOR_PARAM_DESC_MAX"); 2668 else if (val == DOOR_PARAM_DATA_MIN) 2669 outstring(pri, "DOOR_PARAM_DATA_MIN"); 2670 else if (val == DOOR_PARAM_DATA_MAX) 2671 outstring(pri, "DOOR_PARAM_DATA_MAX"); 2672 else 2673 prt_hex(pri, 0, val); 2674 } 2675 2676 /* 2677 * Print rctlsys subcodes 2678 */ 2679 void 2680 prt_rsc(private_t *pri, int raw, long val) /* print utssys code */ 2681 { 2682 const char *s = raw? NULL : rctlsyscode(val); 2683 2684 if (s == NULL) 2685 prt_dec(pri, 0, val); 2686 else 2687 outstring(pri, s); 2688 } 2689 2690 /* 2691 * Print getrctl flags 2692 */ 2693 void 2694 prt_rgf(private_t *pri, int raw, long val) 2695 { 2696 long action = val & (~RCTLSYS_ACTION_MASK); 2697 2698 if (raw) 2699 prt_hex(pri, 0, val); 2700 else if (action == RCTL_FIRST) 2701 outstring(pri, "RCTL_FIRST"); 2702 else if (action == RCTL_NEXT) 2703 outstring(pri, "RCTL_NEXT"); 2704 else if (action == RCTL_USAGE) 2705 outstring(pri, "RCTL_USAGE"); 2706 else 2707 prt_hex(pri, 0, val); 2708 } 2709 2710 /* 2711 * Print setrctl flags 2712 */ 2713 void 2714 prt_rsf(private_t *pri, int raw, long val) 2715 { 2716 long action = val & (~RCTLSYS_ACTION_MASK); 2717 long pval = val & RCTL_LOCAL_ACTION_MASK; 2718 char *s = pri->code_buf; 2719 2720 if (raw) { 2721 prt_hex(pri, 0, val); 2722 return; 2723 } else if (action == RCTL_INSERT) 2724 (void) strcpy(s, "RCTL_INSERT"); 2725 else if (action == RCTL_DELETE) 2726 (void) strcpy(s, "RCTL_DELETE"); 2727 else if (action == RCTL_REPLACE) 2728 (void) strcpy(s, "RCTL_REPLACE"); 2729 else { 2730 prt_hex(pri, 0, val); 2731 return; 2732 } 2733 2734 if (pval & RCTL_USE_RECIPIENT_PID) { 2735 pval ^= RCTL_USE_RECIPIENT_PID; 2736 (void) strlcat(s, "|RCTL_USE_RECIPIENT_PID", 2737 sizeof (pri->code_buf)); 2738 } 2739 2740 if ((pval & RCTLSYS_ACTION_MASK) != 0) 2741 prt_hex(pri, 0, val); 2742 else if (*s != '\0') 2743 outstring(pri, s); 2744 else 2745 prt_hex(pri, 0, val); 2746 } 2747 2748 /* 2749 * Print rctlctl flags 2750 */ 2751 void 2752 prt_rcf(private_t *pri, int raw, long val) 2753 { 2754 long action = val & (~RCTLSYS_ACTION_MASK); 2755 2756 if (raw) 2757 prt_hex(pri, 0, val); 2758 else if (action == RCTLCTL_GET) 2759 outstring(pri, "RCTLCTL_GET"); 2760 else if (action == RCTLCTL_SET) 2761 outstring(pri, "RCTLCTL_SET"); 2762 else 2763 prt_hex(pri, 0, val); 2764 } 2765 2766 /* 2767 * Print setprojrctl flags 2768 */ 2769 void 2770 prt_spf(private_t *pri, int raw, long val) 2771 { 2772 long action = val & TASK_PROJ_MASK; 2773 2774 if (!raw && (action == TASK_PROJ_PURGE)) 2775 outstring(pri, "TASK_PROJ_PURGE"); 2776 else 2777 prt_hex(pri, 0, val); 2778 } 2779 2780 /* 2781 * Print forkx() flags 2782 */ 2783 void 2784 prt_fxf(private_t *pri, int raw, long val) 2785 { 2786 char *str; 2787 2788 if (val == 0) 2789 outstring(pri, "0"); 2790 else if (raw || (val & ~(FORK_NOSIGCHLD | FORK_WAITPID))) 2791 prt_hhx(pri, 0, val); 2792 else { 2793 str = pri->code_buf; 2794 *str = '\0'; 2795 if (val & FORK_NOSIGCHLD) 2796 (void) strlcat(str, "|FORK_NOSIGCHLD", 2797 sizeof (pri->code_buf)); 2798 if (val & FORK_WAITPID) 2799 (void) strlcat(str, "|FORK_WAITPID", 2800 sizeof (pri->code_buf)); 2801 outstring(pri, str + 1); 2802 } 2803 } 2804 2805 /* 2806 * Print faccessat() flag 2807 */ 2808 void 2809 prt_fat(private_t *pri, int raw, long val) 2810 { 2811 if (val == 0) 2812 outstring(pri, "0"); 2813 else if (!raw && val == AT_EACCESS) 2814 outstring(pri, "AT_EACCESS"); 2815 else 2816 prt_hex(pri, 0, val); 2817 } 2818 2819 /* 2820 * Print unlinkat() flag 2821 */ 2822 void 2823 prt_uat(private_t *pri, int raw, long val) 2824 { 2825 if (val == 0) 2826 outstring(pri, "0"); 2827 else if (!raw && val == AT_REMOVEDIR) 2828 outstring(pri, "AT_REMOVEDIR"); 2829 else 2830 prt_hex(pri, 0, val); 2831 } 2832 2833 /* 2834 * Print AT_SYMLINK_NOFOLLOW / AT_SYMLINK_FOLLOW flag 2835 */ 2836 void 2837 prt_snf(private_t *pri, int raw, long val) 2838 { 2839 if (val == 0) 2840 outstring(pri, "0"); 2841 else if (!raw && val == AT_SYMLINK_NOFOLLOW) 2842 outstring(pri, "AT_SYMLINK_NOFOLLOW"); 2843 else if (!raw && val == AT_SYMLINK_FOLLOW) 2844 outstring(pri, "AT_SYMLINK_FOLLOW"); 2845 else 2846 prt_hex(pri, 0, val); 2847 } 2848 2849 void 2850 prt_grf(private_t *pri, int raw, long val) 2851 { 2852 int first = 1; 2853 2854 if (raw != 0 || val == 0 || 2855 (val & ~(GRND_NONBLOCK | GRND_RANDOM)) != 0) { 2856 outstring(pri, "0"); 2857 return; 2858 } 2859 2860 if (val & GRND_NONBLOCK) { 2861 outstring(pri, "|GRND_NONBLOCK" + first); 2862 first = 0; 2863 } 2864 if (val & GRND_RANDOM) { 2865 outstring(pri, "|GRND_RANDOM" + first); 2866 first = 0; 2867 } 2868 } 2869 2870 /* 2871 * Array of pointers to print functions, one for each format. 2872 */ 2873 void (* const Print[])() = { 2874 prt_nov, /* NOV -- no value */ 2875 prt_dec, /* DEC -- print value in decimal */ 2876 prt_oct, /* OCT -- print value in octal */ 2877 prt_hex, /* HEX -- print value in hexadecimal */ 2878 prt_dex, /* DEX -- print value in hexadecimal if big enough */ 2879 prt_stg, /* STG -- print value as string */ 2880 prt_ioc, /* IOC -- print ioctl code */ 2881 prt_fcn, /* FCN -- print fcntl code */ 2882 prt_s86, /* S86 -- print sysi86 code */ 2883 prt_uts, /* UTS -- print utssys code */ 2884 prt_opn, /* OPN -- print open code */ 2885 prt_sig, /* SIG -- print signal name plus flags */ 2886 prt_uat, /* UAT -- print unlinkat() flag */ 2887 prt_msc, /* MSC -- print msgsys command */ 2888 prt_msf, /* MSF -- print msgsys flags */ 2889 prt_smc, /* SMC -- print semsys command */ 2890 prt_sef, /* SEF -- print semsys flags */ 2891 prt_shc, /* SHC -- print shmsys command */ 2892 prt_shf, /* SHF -- print shmsys flags */ 2893 prt_fat, /* FAT -- print faccessat( flag */ 2894 prt_sfs, /* SFS -- print sysfs code */ 2895 prt_rst, /* RST -- print string returned by syscall */ 2896 prt_smf, /* SMF -- print streams message flags */ 2897 prt_ioa, /* IOA -- print ioctl argument */ 2898 prt_pip, /* PIP -- print pipe flags */ 2899 prt_mtf, /* MTF -- print mount flags */ 2900 prt_mft, /* MFT -- print mount file system type */ 2901 prt_iob, /* IOB -- print contents of I/O buffer */ 2902 prt_hhx, /* HHX -- print value in hexadecimal (half size) */ 2903 prt_wop, /* WOP -- print waitsys() options */ 2904 prt_spm, /* SPM -- print sigprocmask argument */ 2905 prt_rlk, /* RLK -- print readlink buffer */ 2906 prt_mpr, /* MPR -- print mmap()/mprotect() flags */ 2907 prt_mty, /* MTY -- print mmap() mapping type flags */ 2908 prt_mcf, /* MCF -- print memcntl() function */ 2909 prt_mc4, /* MC4 -- print memcntl() (fourth) argument */ 2910 prt_mc5, /* MC5 -- print memcntl() (fifth) argument */ 2911 prt_mad, /* MAD -- print madvise() argument */ 2912 prt_ulm, /* ULM -- print ulimit() argument */ 2913 prt_rlm, /* RLM -- print get/setrlimit() argument */ 2914 prt_cnf, /* CNF -- print sysconfig() argument */ 2915 prt_inf, /* INF -- print sysinfo() argument */ 2916 prt_ptc, /* PTC -- print pathconf/fpathconf() argument */ 2917 prt_fui, /* FUI -- print fusers() input argument */ 2918 prt_idt, /* IDT -- print idtype_t, waitid() argument */ 2919 prt_lwf, /* LWF -- print lwp_create() flags */ 2920 prt_itm, /* ITM -- print [get|set]itimer() arg */ 2921 prt_llo, /* LLO -- print long long offset arg */ 2922 prt_mod, /* MOD -- print modctl() subcode */ 2923 prt_whn, /* WHN -- print lseek() whence arguiment */ 2924 prt_acl, /* ACL -- print acl() code */ 2925 prt_aio, /* AIO -- print kaio() code */ 2926 prt_aud, /* AUD -- print auditsys() code */ 2927 prt_uns, /* DEC -- print value in unsigned decimal */ 2928 prt_clc, /* CLC -- print cladm command argument */ 2929 prt_clf, /* CLF -- print cladm flag argument */ 2930 prt_cor, /* COR -- print corectl() subcode */ 2931 prt_cco, /* CCO -- print corectl() options */ 2932 prt_ccc, /* CCC -- print corectl() content */ 2933 prt_rcc, /* RCC -- print corectl() returned content */ 2934 prt_cpc, /* CPC -- print cpc() subcode */ 2935 prt_sqc, /* SQC -- print sigqueue() si_code argument */ 2936 prt_pc4, /* PC4 -- print priocntlsys() (fourth) argument */ 2937 prt_pc5, /* PC5 -- print priocntlsys() (key, value) pairs */ 2938 prt_pst, /* PST -- print processor set id */ 2939 prt_mif, /* MIF -- print meminfo() arguments */ 2940 prt_pfm, /* PFM -- print so_socket() proto-family (1st) arg */ 2941 prt_skt, /* SKT -- print so_socket() socket-type (2nd) arg */ 2942 prt_skp, /* SKP -- print so_socket() protocol (3rd) arg */ 2943 prt_skv, /* SKV -- print socket version arg */ 2944 prt_sol, /* SOL -- print [sg]etsockopt() level (2nd) arg */ 2945 prt_son, /* SON -- print [sg]etsockopt() opt-name (3rd) arg */ 2946 prt_utt, /* UTT -- print utrap type */ 2947 prt_uth, /* UTH -- print utrap handler */ 2948 prt_acc, /* ACC -- print access() flags */ 2949 prt_sht, /* SHT -- print shutdown() how (2nd) argument */ 2950 prt_ffg, /* FFG -- print fcntl() flags (3rd) argument */ 2951 prt_prs, /* PRS -- print privilege set */ 2952 prt_pro, /* PRO -- print privilege set operation */ 2953 prt_prn, /* PRN -- print privilege set name */ 2954 prt_pfl, /* PFL -- print privilege/process flag name */ 2955 prt_laf, /* LAF -- print lgrp_affinity arguments */ 2956 prt_key, /* KEY -- print key_t 0 as IPC_PRIVATE */ 2957 prt_zga, /* ZGA -- print zone_getattr attribute types */ 2958 prt_atc, /* ATC -- print AT_FDCWD or file descriptor */ 2959 prt_lio, /* LIO -- print LIO_XX flags */ 2960 prt_dfl, /* DFL -- print door_create() flags */ 2961 prt_dpm, /* DPM -- print DOOR_PARAM_XX flags */ 2962 prt_tnd, /* TND -- print trusted network data base opcode */ 2963 prt_rsc, /* RSC -- print rctlsys() subcodes */ 2964 prt_rgf, /* RGF -- print getrctl() flags */ 2965 prt_rsf, /* RSF -- print setrctl() flags */ 2966 prt_rcf, /* RCF -- print rctlsys_ctl() flags */ 2967 prt_fxf, /* FXF -- print forkx() flags */ 2968 prt_spf, /* SPF -- print rctlsys_projset() flags */ 2969 prt_un1, /* UN1 -- as prt_uns except for -1 */ 2970 prt_mob, /* MOB -- print mmapobj() flags */ 2971 prt_snf, /* SNF -- print AT_SYMLINK_[NO]FOLLOW flag */ 2972 prt_skc, /* SKC -- print sockconfig() subcode */ 2973 prt_acf, /* ACF -- print accept4 flags */ 2974 prt_pfd, /* PFD -- print pipe fds */ 2975 prt_grf, /* GRF -- print getrandom flags */ 2976 prt_psdelta, /* PSDLT -- print psecflags(2) delta */ 2977 prt_psfw, /* PSFW -- print psecflags(2) set */ 2978 prt_dec, /* HID -- hidden argument, make this the last one */ 2979 }; 2980