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