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