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