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