1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
  24  */
  25 
  26 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T     */
  27 /*        All Rights Reserved   */
  28 
  29 /* Copyright (c) 2013, OmniTI Computer Consulting, Inc. All rights reserved. */
  30 
  31 #define _SYSCALL32      /* make 32-bit compat headers visible */
  32 
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <unistd.h>
  36 #include <string.h>
  37 #include <signal.h>
  38 #include <termio.h>
  39 #include <stddef.h>
  40 #include <limits.h>
  41 #include <fcntl.h>
  42 #include <ctype.h>
  43 #include <sys/types.h>
  44 #include <sys/mman.h>
  45 #include <sys/resource.h>
  46 #include <sys/ulimit.h>
  47 #include <sys/utsname.h>
  48 #include <sys/kstat.h>
  49 #include <sys/modctl.h>
  50 #include <sys/acl.h>
  51 #include <stropts.h>
  52 #include <sys/isa_defs.h>
  53 #include <sys/systeminfo.h>
  54 #include <sys/cladm.h>
  55 #include <sys/lwp.h>
  56 #include <bsm/audit.h>
  57 #include <libproc.h>
  58 #include <priv.h>
  59 #include <sys/aio.h>
  60 #include <sys/aiocb.h>
  61 #include <sys/corectl.h>
  62 #include <sys/cpc_impl.h>
  63 #include <sys/priocntl.h>
  64 #include <sys/tspriocntl.h>
  65 #include <sys/iapriocntl.h>
  66 #include <sys/rtpriocntl.h>
  67 #include <sys/fsspriocntl.h>
  68 #include <sys/fxpriocntl.h>
  69 #include <netdb.h>
  70 #include <nss_dbdefs.h>
  71 #include <sys/socketvar.h>
  72 #include <netinet/in.h>
  73 #include <netinet/tcp.h>
  74 #include <netinet/udp.h>
  75 #include <netinet/sctp.h>
  76 #include <net/route.h>
  77 #include <sys/utrap.h>
  78 #include <sys/lgrp_user.h>
  79 #include <sys/door.h>
  80 #include <sys/tsol/tndb.h>
  81 #include <sys/rctl.h>
  82 #include <sys/rctl_impl.h>
  83 #include <sys/fork.h>
  84 #include <sys/task.h>
  85 #include <sys/socket.h>
  86 #include <arpa/inet.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 connect() 2nd and 3rd arguments.
1792  */
1793 /*ARGSUSED*/
1794 void
1795 prt_sad(private_t *pri, int raw, long addr, long len)
1796 {
1797         /*
1798          * A buffer large enough for PATH_MAX size AF_UNIX address, which is
1799          * also large enough to store a sockaddr_in or a sockaddr_in6.
1800          */
1801         long buf[(sizeof (short) + PATH_MAX + sizeof (long) - 1) /
1802             sizeof (long)];
1803         struct sockaddr *sa = (struct sockaddr *)buf;
1804         struct sockaddr_in *sin = (struct sockaddr_in *)buf;
1805         struct sockaddr_un *soun = (struct sockaddr_un *)buf;
1806         struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)buf;
1807         char addrbuf[INET6_ADDRSTRLEN];
1808         char scope[8];
1809         long rlen = len;
1810 
1811         GROW(20);
1812         if (data_model == PR_MODEL_ILP32) {
1813                 pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng,
1814                     "0x%.8X", (int)addr);
1815         } else {
1816                 pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng,
1817                     "0x%.8lX", addr);
1818         }
1819 
1820         if (raw != 0)
1821                 return;
1822 
1823         if (rlen >= sizeof (buf))    /* protect against ridiculous length */
1824                 rlen = sizeof (buf) - 1;
1825         if (Pread(Proc, buf, rlen, addr) != rlen)
1826                 return;
1827 
1828         GROW(175);
1829 
1830         switch (sa->sa_family) {
1831         case AF_INET6:
1832                 if (ntohl(sin6->sin6_scope_id) == 0) {
1833                     scope[0] = '\0';
1834                 } else {
1835                     sprintf(scope, "%%%u", ntohl(sin6->sin6_scope_id));
1836                 }
1837                 pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng,
1838                     " AF_INET6 to = %s%s:%u",
1839                     inet_ntop(AF_INET6, &sin6->sin6_addr, addrbuf,
1840                     sizeof (addrbuf)),
1841                     scope, ntohs(sin6->sin6_port));
1842                 pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng,
1843                     " source id = 0x%x"
1844                     " flow class = 0x%02x flow label = 0x%05x",
1845                     ntohl(sin6->__sin6_src_id),
1846                     ntohl((sin6->sin6_flowinfo & IPV6_FLOWINFO_TCLASS) >> 20),
1847                     ntohl(sin6->sin6_flowinfo & IPV6_FLOWINFO_FLOWLABEL));
1848                 break;
1849         case AF_INET:
1850                 pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng,
1851                     " AF_INET to = %s:%u",
1852                     inet_ntop(AF_INET, &sin->sin_addr, addrbuf,
1853                     sizeof (addrbuf)),
1854                     ntohs(sin->sin_port));
1855                 break;
1856         case AF_UNIX:
1857                 len -= sizeof (soun->sun_family);
1858                 if (len >= 0) {
1859                         /* Null terminate */
1860                         soun->sun_path[len] = NULL;
1861                         pri->sys_leng += sprintf(
1862                             pri->sys_string + pri->sys_leng,
1863                             " AF_UNIX to = %s", soun->sun_path);
1864                 }
1865                 break;
1866         }
1867 
1868         /*
1869          * print the third argument len
1870          */
1871         if (data_model == PR_MODEL_ILP32) {
1872                 pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng,
1873                     ", %d", (int)len);
1874         } else {
1875                 pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng,
1876                     ", %ld", len);
1877         }
1878 
1879 }
1880 
1881 
1882 /*
1883  * Print accept4() flags argument.
1884  */
1885 void
1886 prt_acf(private_t *pri, int raw, long val)
1887 {
1888         int first = 1;
1889         if (raw || !val ||
1890             (val & ~(SOCK_CLOEXEC|SOCK_NDELAY|SOCK_NONBLOCK))) {
1891                 prt_dex(pri, 0, val);
1892                 return;
1893         }
1894 
1895         if (val & SOCK_CLOEXEC) {
1896                 outstring(pri, "|SOCK_CLOEXEC" + first);
1897                 first = 0;
1898         }
1899         if (val & SOCK_NDELAY) {
1900                 outstring(pri, "|SOCK_NDELAY" + first);
1901                 first = 0;
1902         }
1903         if (val & SOCK_NONBLOCK) {
1904                 outstring(pri, "|SOCK_NONBLOCK" + first);
1905         }
1906 }
1907 
1908 
1909 /*
1910  * Print setsockopt()/getsockopt() 2nd argument.
1911  */
1912 /*ARGSUSED*/
1913 void
1914 prt_sol(private_t *pri, int raw, long val)
1915 {
1916         if (val == SOL_SOCKET) {
1917                 outstring(pri, "SOL_SOCKET");
1918         } else if (val == SOL_ROUTE) {
1919                 outstring(pri, "SOL_ROUTE");
1920         } else {
1921                 const struct protoent *p;
1922                 struct protoent res;
1923                 char buf[NSS_BUFLEN_PROTOCOLS];
1924 
1925                 if ((p = getprotobynumber_r(val, &res,
1926                     (char *)buf, sizeof (buf))) != NULL)
1927                         outstring(pri, p->p_name);
1928                 else
1929                         prt_dec(pri, 0, val);
1930         }
1931 }
1932 
1933 
1934 const char *
1935 sol_optname(private_t *pri, long val)
1936 {
1937 #define CBSIZE  sizeof (pri->code_buf)
1938         if (val >= SO_SNDBUF) {
1939                 switch (val) {
1940                 case SO_SNDBUF:         return ("SO_SNDBUF");
1941                 case SO_RCVBUF:         return ("SO_RCVBUF");
1942                 case SO_SNDLOWAT:       return ("SO_SNDLOWAT");
1943                 case SO_RCVLOWAT:       return ("SO_RCVLOWAT");
1944                 case SO_SNDTIMEO:       return ("SO_SNDTIMEO");
1945                 case SO_RCVTIMEO:       return ("SO_RCVTIMEO");
1946                 case SO_ERROR:          return ("SO_ERROR");
1947                 case SO_TYPE:           return ("SO_TYPE");
1948                 case SO_PROTOTYPE:      return ("SO_PROTOTYPE");
1949                 case SO_ANON_MLP:       return ("SO_ANON_MLP");
1950                 case SO_MAC_EXEMPT:     return ("SO_MAC_EXEMPT");
1951                 case SO_ALLZONES:       return ("SO_ALLZONES");
1952                 case SO_MAC_IMPLICIT:   return ("SO_MAC_IMPLICIT");
1953                 case SO_VRRP:           return ("SO_VRRP");
1954                 case SO_EXCLBIND:       return ("SO_EXCLBIND");
1955                 case SO_DOMAIN:         return ("SO_DOMAIN");
1956 
1957                 default:                (void) snprintf(pri->code_buf, CBSIZE,
1958                                             "0x%lx", val);
1959                                         return (pri->code_buf);
1960                 }
1961         } else {
1962                 char *s = pri->code_buf;
1963                 size_t used = 1;
1964                 long val2;
1965 
1966                 *s = '\0';
1967                 val2 = val & ~(SO_DEBUG|SO_ACCEPTCONN|SO_REUSEADDR|SO_KEEPALIVE|
1968                     SO_DONTROUTE|SO_BROADCAST|SO_USELOOPBACK|SO_LINGER|
1969                     SO_OOBINLINE|SO_DGRAM_ERRIND|SO_RECVUCRED);
1970                 if (val2)
1971                         used = snprintf(s, CBSIZE, "|0x%lx", val2);
1972                 if (val & SO_DEBUG)
1973                         used = strlcat(s, "|SO_DEBUG", CBSIZE);
1974                 if (val & SO_ACCEPTCONN)
1975                         used = strlcat(s, "|SO_ACCEPTCONN", CBSIZE);
1976                 if (val & SO_REUSEADDR)
1977                         used = strlcat(s, "|SO_REUSEADDR", CBSIZE);
1978                 if (val & SO_KEEPALIVE)
1979                         used = strlcat(s, "|SO_KEEPALIVE", CBSIZE);
1980                 if (val & SO_DONTROUTE)
1981                         used = strlcat(s, "|SO_DONTROUTE", CBSIZE);
1982                 if (val & SO_BROADCAST)
1983                         used = strlcat(s, "|SO_BROADCAST", CBSIZE);
1984                 if (val & SO_USELOOPBACK)
1985                         used = strlcat(s, "|SO_USELOOPBACK", CBSIZE);
1986                 if (val & SO_LINGER)
1987                         used = strlcat(s, "|SO_LINGER", CBSIZE);
1988                 if (val & SO_OOBINLINE)
1989                         used = strlcat(s, "|SO_OOBINLINE", CBSIZE);
1990                 if (val & SO_DGRAM_ERRIND)
1991                         used = strlcat(s, "|SO_DGRAM_ERRIND", CBSIZE);
1992                 if (val & SO_RECVUCRED)
1993                         used = strlcat(s, "|SO_RECVUCRED", CBSIZE);
1994                 if (used >= CBSIZE || val == 0)
1995                         (void) snprintf(s + 1, CBSIZE-1, "0x%lx", val);
1996                 return ((const char *)(s + 1));
1997         }
1998 #undef CBSIZE
1999 }
2000 
2001 const char *
2002 route_optname(private_t *pri, long val)
2003 {
2004         switch (val) {
2005         case RT_AWARE:
2006                 return ("RT_AWARE");
2007         default:
2008                 (void) snprintf(pri->code_buf, sizeof (pri->code_buf),
2009                     "0x%lx", val);
2010                 return (pri->code_buf);
2011         }
2012 }
2013 
2014 const char *
2015 tcp_optname(private_t *pri, long val)
2016 {
2017         switch (val) {
2018         case TCP_NODELAY:               return ("TCP_NODELAY");
2019         case TCP_MAXSEG:                return ("TCP_MAXSEG");
2020         case TCP_KEEPALIVE:             return ("TCP_KEEPALIVE");
2021         case TCP_NOTIFY_THRESHOLD:      return ("TCP_NOTIFY_THRESHOLD");
2022         case TCP_ABORT_THRESHOLD:       return ("TCP_ABORT_THRESHOLD");
2023         case TCP_CONN_NOTIFY_THRESHOLD: return ("TCP_CONN_NOTIFY_THRESHOLD");
2024         case TCP_CONN_ABORT_THRESHOLD:  return ("TCP_CONN_ABORT_THRESHOLD");
2025         case TCP_RECVDSTADDR:           return ("TCP_RECVDSTADDR");
2026         case TCP_ANONPRIVBIND:          return ("TCP_ANONPRIVBIND");
2027         case TCP_EXCLBIND:              return ("TCP_EXCLBIND");
2028         case TCP_INIT_CWND:             return ("TCP_INIT_CWND");
2029         case TCP_KEEPALIVE_THRESHOLD:   return ("TCP_KEEPALIVE_THRESHOLD");
2030         case TCP_KEEPALIVE_ABORT_THRESHOLD:
2031                 return ("TCP_KEEPALIVE_ABORT_THRESHOLD");
2032         case TCP_CORK:                  return ("TCP_CORK");
2033         case TCP_RTO_INITIAL:           return ("TCP_RTO_INITIAL");
2034         case TCP_RTO_MIN:               return ("TCP_RTO_MIN");
2035         case TCP_RTO_MAX:               return ("TCP_RTO_MAX");
2036         case TCP_LINGER2:               return ("TCP_LINGER2");
2037 
2038         default:                        (void) snprintf(pri->code_buf,
2039                                             sizeof (pri->code_buf),
2040                                             "0x%lx", val);
2041                                         return (pri->code_buf);
2042         }
2043 }
2044 
2045 
2046 const char *
2047 sctp_optname(private_t *pri, long val)
2048 {
2049         switch (val) {
2050         case SCTP_RTOINFO:              return ("SCTP_RTOINFO");
2051         case SCTP_ASSOCINFO:            return ("SCTP_ASSOCINFO");
2052         case SCTP_INITMSG:              return ("SCTP_INITMSG");
2053         case SCTP_NODELAY:              return ("SCTP_NODELAY");
2054         case SCTP_AUTOCLOSE:            return ("SCTP_AUTOCLOSE");
2055         case SCTP_SET_PEER_PRIMARY_ADDR:
2056                 return ("SCTP_SET_PEER_PRIMARY_ADDR");
2057         case SCTP_PRIMARY_ADDR:         return ("SCTP_PRIMARY_ADDR");
2058         case SCTP_ADAPTATION_LAYER:     return ("SCTP_ADAPTATION_LAYER");
2059         case SCTP_DISABLE_FRAGMENTS:    return ("SCTP_DISABLE_FRAGMENTS");
2060         case SCTP_PEER_ADDR_PARAMS:     return ("SCTP_PEER_ADDR_PARAMS");
2061         case SCTP_DEFAULT_SEND_PARAM:   return ("SCTP_DEFAULT_SEND_PARAM");
2062         case SCTP_EVENTS:               return ("SCTP_EVENTS");
2063         case SCTP_I_WANT_MAPPED_V4_ADDR:
2064                 return ("SCTP_I_WANT_MAPPED_V4_ADDR");
2065         case SCTP_MAXSEG:               return ("SCTP_MAXSEG");
2066         case SCTP_STATUS:               return ("SCTP_STATUS");
2067         case SCTP_GET_PEER_ADDR_INFO:   return ("SCTP_GET_PEER_ADDR_INFO");
2068 
2069         case SCTP_ADD_ADDR:             return ("SCTP_ADD_ADDR");
2070         case SCTP_REM_ADDR:             return ("SCTP_REM_ADDR");
2071 
2072         default:                        (void) snprintf(pri->code_buf,
2073                                             sizeof (pri->code_buf),
2074                                             "0x%lx", val);
2075                                         return (pri->code_buf);
2076         }
2077 }
2078 
2079 
2080 const char *
2081 udp_optname(private_t *pri, long val)
2082 {
2083         switch (val) {
2084         case UDP_CHECKSUM:              return ("UDP_CHECKSUM");
2085         case UDP_ANONPRIVBIND:          return ("UDP_ANONPRIVBIND");
2086         case UDP_EXCLBIND:              return ("UDP_EXCLBIND");
2087         case UDP_RCVHDR:                return ("UDP_RCVHDR");
2088         case UDP_NAT_T_ENDPOINT:        return ("UDP_NAT_T_ENDPOINT");
2089 
2090         default:                        (void) snprintf(pri->code_buf,
2091                                             sizeof (pri->code_buf), "0x%lx",
2092                                             val);
2093                                         return (pri->code_buf);
2094         }
2095 }
2096 
2097 
2098 /*
2099  * Print setsockopt()/getsockopt() 3rd argument.
2100  */
2101 /*ARGSUSED*/
2102 void
2103 prt_son(private_t *pri, int raw, long val)
2104 {
2105         /* cheating -- look at the level */
2106         switch (pri->sys_args[1]) {
2107         case SOL_SOCKET:        outstring(pri, sol_optname(pri, val));
2108                                 break;
2109         case SOL_ROUTE:         outstring(pri, route_optname(pri, val));
2110                                 break;
2111         case IPPROTO_TCP:       outstring(pri, tcp_optname(pri, val));
2112                                 break;
2113         case IPPROTO_UDP:       outstring(pri, udp_optname(pri, val));
2114                                 break;
2115         case IPPROTO_SCTP:      outstring(pri, sctp_optname(pri, val));
2116                                 break;
2117         default:                prt_dec(pri, 0, val);
2118                                 break;
2119         }
2120 }
2121 
2122 
2123 /*
2124  * Print utrap type
2125  */
2126 /*ARGSUSED*/
2127 void
2128 prt_utt(private_t *pri, int raw, long val)
2129 {
2130         const char *s = NULL;
2131 
2132 #ifdef __sparc
2133         if (!raw) {
2134                 switch (val) {
2135                 case UT_INSTRUCTION_DISABLED:
2136                         s = "UT_INSTRUCTION_DISABLED"; break;
2137                 case UT_INSTRUCTION_ERROR:
2138                         s = "UT_INSTRUCTION_ERROR"; break;
2139                 case UT_INSTRUCTION_PROTECTION:
2140                         s = "UT_INSTRUCTION_PROTECTION"; break;
2141                 case UT_ILLTRAP_INSTRUCTION:
2142                         s = "UT_ILLTRAP_INSTRUCTION"; break;
2143                 case UT_ILLEGAL_INSTRUCTION:
2144                         s = "UT_ILLEGAL_INSTRUCTION"; break;
2145                 case UT_PRIVILEGED_OPCODE:
2146                         s = "UT_PRIVILEGED_OPCODE"; break;
2147                 case UT_FP_DISABLED:
2148                         s = "UT_FP_DISABLED"; break;
2149                 case UT_FP_EXCEPTION_IEEE_754:
2150                         s = "UT_FP_EXCEPTION_IEEE_754"; break;
2151                 case UT_FP_EXCEPTION_OTHER:
2152                         s = "UT_FP_EXCEPTION_OTHER"; break;
2153                 case UT_TAG_OVERFLOW:
2154                         s = "UT_TAG_OVERFLOW"; break;
2155                 case UT_DIVISION_BY_ZERO:
2156                         s = "UT_DIVISION_BY_ZERO"; break;
2157                 case UT_DATA_EXCEPTION:
2158                         s = "UT_DATA_EXCEPTION"; break;
2159                 case UT_DATA_ERROR:
2160                         s = "UT_DATA_ERROR"; break;
2161                 case UT_DATA_PROTECTION:
2162                         s = "UT_DATA_PROTECTION"; break;
2163                 case UT_MEM_ADDRESS_NOT_ALIGNED:
2164                         s = "UT_MEM_ADDRESS_NOT_ALIGNED"; break;
2165                 case UT_PRIVILEGED_ACTION:
2166                         s = "UT_PRIVILEGED_ACTION"; break;
2167                 case UT_ASYNC_DATA_ERROR:
2168                         s = "UT_ASYNC_DATA_ERROR"; break;
2169                 case UT_TRAP_INSTRUCTION_16:
2170                         s = "UT_TRAP_INSTRUCTION_16"; break;
2171                 case UT_TRAP_INSTRUCTION_17:
2172                         s = "UT_TRAP_INSTRUCTION_17"; break;
2173                 case UT_TRAP_INSTRUCTION_18:
2174                         s = "UT_TRAP_INSTRUCTION_18"; break;
2175                 case UT_TRAP_INSTRUCTION_19:
2176                         s = "UT_TRAP_INSTRUCTION_19"; break;
2177                 case UT_TRAP_INSTRUCTION_20:
2178                         s = "UT_TRAP_INSTRUCTION_20"; break;
2179                 case UT_TRAP_INSTRUCTION_21:
2180                         s = "UT_TRAP_INSTRUCTION_21"; break;
2181                 case UT_TRAP_INSTRUCTION_22:
2182                         s = "UT_TRAP_INSTRUCTION_22"; break;
2183                 case UT_TRAP_INSTRUCTION_23:
2184                         s = "UT_TRAP_INSTRUCTION_23"; break;
2185                 case UT_TRAP_INSTRUCTION_24:
2186                         s = "UT_TRAP_INSTRUCTION_24"; break;
2187                 case UT_TRAP_INSTRUCTION_25:
2188                         s = "UT_TRAP_INSTRUCTION_25"; break;
2189                 case UT_TRAP_INSTRUCTION_26:
2190                         s = "UT_TRAP_INSTRUCTION_26"; break;
2191                 case UT_TRAP_INSTRUCTION_27:
2192                         s = "UT_TRAP_INSTRUCTION_27"; break;
2193                 case UT_TRAP_INSTRUCTION_28:
2194                         s = "UT_TRAP_INSTRUCTION_28"; break;
2195                 case UT_TRAP_INSTRUCTION_29:
2196                         s = "UT_TRAP_INSTRUCTION_29"; break;
2197                 case UT_TRAP_INSTRUCTION_30:
2198                         s = "UT_TRAP_INSTRUCTION_30"; break;
2199                 case UT_TRAP_INSTRUCTION_31:
2200                         s = "UT_TRAP_INSTRUCTION_31"; break;
2201                 }
2202         }
2203 #endif /* __sparc */
2204 
2205         if (s == NULL)
2206                 prt_dec(pri, 0, val);
2207         else
2208                 outstring(pri, s);
2209 }
2210 
2211 
2212 /*
2213  * Print utrap handler
2214  */
2215 void
2216 prt_uth(private_t *pri, int raw, long val)
2217 {
2218         const char *s = NULL;
2219 
2220         if (!raw) {
2221                 switch (val) {
2222                 case (long)UTH_NOCHANGE:        s = "UTH_NOCHANGE"; break;
2223                 }
2224         }
2225 
2226         if (s == NULL)
2227                 prt_hex(pri, 0, val);
2228         else
2229                 outstring(pri, s);
2230 }
2231 
2232 const char *
2233 access_flags(private_t *pri, long arg)
2234 {
2235 #define E_OK 010
2236         char *str = pri->code_buf;
2237 
2238         if (arg & ~(R_OK|W_OK|X_OK|E_OK))
2239                 return (NULL);
2240 
2241         /* NB: F_OK == 0 */
2242         if (arg == F_OK)
2243                 return ("F_OK");
2244         if (arg == E_OK)
2245                 return ("F_OK|E_OK");
2246 
2247         *str = '\0';
2248         if (arg & R_OK)
2249                 (void) strlcat(str, "|R_OK", sizeof (pri->code_buf));
2250         if (arg & W_OK)
2251                 (void) strlcat(str, "|W_OK", sizeof (pri->code_buf));
2252         if (arg & X_OK)
2253                 (void) strlcat(str, "|X_OK", sizeof (pri->code_buf));
2254         if (arg & E_OK)
2255                 (void) strlcat(str, "|E_OK", sizeof (pri->code_buf));
2256         return ((const char *)(str + 1));
2257 #undef E_OK
2258 }
2259 
2260 /*
2261  * Print access() flags.
2262  */
2263 void
2264 prt_acc(private_t *pri, int raw, long val)
2265 {
2266         const char *s = raw? NULL : access_flags(pri, val);
2267 
2268         if (s == NULL)
2269                 prt_dex(pri, 0, val);
2270         else
2271                 outstring(pri, s);
2272 }
2273 
2274 /*
2275  * Print shutdown() "how" (2nd) argument
2276  */
2277 void
2278 prt_sht(private_t *pri, int raw, long val)
2279 {
2280         if (raw) {
2281                 prt_dex(pri, 0, val);
2282                 return;
2283         }
2284         switch (val) {
2285         case SHUT_RD:   outstring(pri, "SHUT_RD");      break;
2286         case SHUT_WR:   outstring(pri, "SHUT_WR");      break;
2287         case SHUT_RDWR: outstring(pri, "SHUT_RDWR");    break;
2288         default:        prt_dec(pri, 0, val);           break;
2289         }
2290 }
2291 
2292 /*
2293  * Print fcntl() F_SETFL flags (3rd) argument or fdsync flag (2nd arg)
2294  */
2295 static struct fcntl_flags {
2296         long            val;
2297         const char      *name;
2298 } fcntl_flags[] = {
2299 #define FC_FL(flag)     { (long)flag, "|" # flag }
2300         FC_FL(FREVOKED),
2301         FC_FL(FREAD),
2302         FC_FL(FWRITE),
2303         FC_FL(FNDELAY),
2304         FC_FL(FAPPEND),
2305         FC_FL(FSYNC),
2306         FC_FL(FDSYNC),
2307         FC_FL(FRSYNC),
2308         FC_FL(FOFFMAX),
2309         FC_FL(FNONBLOCK),
2310         FC_FL(FCREAT),
2311         FC_FL(FTRUNC),
2312         FC_FL(FEXCL),
2313         FC_FL(FNOCTTY),
2314         FC_FL(FXATTR),
2315         FC_FL(FASYNC),
2316         FC_FL(FNODSYNC)
2317 #undef FC_FL
2318 };
2319 
2320 void
2321 prt_ffg(private_t *pri, int raw, long val)
2322 {
2323 #define CBSIZE  sizeof (pri->code_buf)
2324         char *s = pri->code_buf;
2325         size_t used = 1;
2326         struct fcntl_flags *fp;
2327 
2328         if (raw) {
2329                 (void) snprintf(s, CBSIZE, "0x%lx", val);
2330                 outstring(pri, s);
2331                 return;
2332         }
2333         if (val == 0) {
2334                 outstring(pri, "(no flags)");
2335                 return;
2336         }
2337 
2338         *s = '\0';
2339         for (fp = fcntl_flags;
2340             fp < &fcntl_flags[sizeof (fcntl_flags) / sizeof (*fp)]; fp++) {
2341                 if (val & fp->val) {
2342                         used = strlcat(s, fp->name, CBSIZE);
2343                         val &= ~fp->val;
2344                 }
2345         }
2346 
2347         if (val != 0 && used <= CBSIZE)
2348                 used += snprintf(s + used, CBSIZE - used, "|0x%lx", val);
2349 
2350         if (used >= CBSIZE)
2351                 (void) snprintf(s + 1, CBSIZE-1, "0x%lx", val);
2352         outstring(pri, s + 1);
2353 #undef CBSIZE
2354 }
2355 
2356 void
2357 prt_prs(private_t *pri, int raw, long val)
2358 {
2359         static size_t setsize;
2360         priv_set_t *set = priv_allocset();
2361 
2362         if (setsize == 0) {
2363                 const priv_impl_info_t *info = getprivimplinfo();
2364                 if (info != NULL)
2365                         setsize = info->priv_setsize * sizeof (priv_chunk_t);
2366         }
2367 
2368         if (setsize != 0 && !raw && set != NULL &&
2369             Pread(Proc, set, setsize, val) == setsize) {
2370                 int i;
2371 
2372                 outstring(pri, "{");
2373                 for (i = 0; i < setsize / sizeof (priv_chunk_t); i++) {
2374                         char buf[9];    /* 8 hex digits + '\0' */
2375                         (void) snprintf(buf, sizeof (buf), "%08x",
2376                             ((priv_chunk_t *)set)[i]);
2377                         outstring(pri, buf);
2378                 }
2379 
2380                 outstring(pri, "}");
2381         } else {
2382                 prt_hex(pri, 0, val);
2383         }
2384 
2385         if (set != NULL)
2386                 priv_freeset(set);
2387 }
2388 
2389 /*
2390  * Print privilege set operation.
2391  */
2392 void
2393 prt_pro(private_t *pri, int raw, long val)
2394 {
2395         const char *s = NULL;
2396 
2397         if (!raw) {
2398                 switch ((priv_op_t)val) {
2399                 case PRIV_ON:           s = "PRIV_ON";          break;
2400                 case PRIV_OFF:          s = "PRIV_OFF";         break;
2401                 case PRIV_SET:          s = "PRIV_SET";         break;
2402                 }
2403         }
2404 
2405         if (s == NULL)
2406                 prt_dec(pri, 0, val);
2407         else
2408                 outstring(pri, s);
2409 }
2410 
2411 /*
2412  * Print privilege set name
2413  */
2414 void
2415 prt_prn(private_t *pri, int raw, long val)
2416 {
2417         const char *s = NULL;
2418 
2419         if (!raw)
2420                 s = priv_getsetbynum((int)val);
2421 
2422         if (s == NULL)
2423                 prt_dec(pri, 0, val);
2424         else {
2425                 char *dup = strdup(s);
2426                 char *q;
2427 
2428                 /* Do the best we can in this case */
2429                 if (dup == NULL) {
2430                         outstring(pri, s);
2431                         return;
2432                 }
2433 
2434                 outstring(pri, "PRIV_");
2435 
2436                 q = dup;
2437 
2438                 while (*q != '\0') {
2439                         *q = toupper(*q);
2440                         q++;
2441                 }
2442                 outstring(pri, dup);
2443                 free(dup);
2444         }
2445 }
2446 
2447 /*
2448  * Print process flag names.
2449  */
2450 void
2451 prt_pfl(private_t *pri, int raw, long val)
2452 {
2453         const char *s = NULL;
2454 
2455         if (!raw) {
2456                 switch ((int)val) {
2457                 case PRIV_DEBUG:        s = "PRIV_DEBUG";       break;
2458                 case PRIV_AWARE:        s = "PRIV_AWARE";       break;
2459                 case PRIV_XPOLICY:      s = "PRIV_XPOLICY";     break;
2460                 case PRIV_AWARE_RESET:  s = "PRIV_AWARE_RESET"; break;
2461                 case PRIV_PFEXEC:       s = "PRIV_PFEXEC";      break;
2462                 case NET_MAC_AWARE:     s =  "NET_MAC_AWARE";   break;
2463                 case NET_MAC_AWARE_INHERIT:
2464                         s = "NET_MAC_AWARE_INHERIT";
2465                         break;
2466                 }
2467         }
2468 
2469         if (s == NULL)
2470                 prt_dec(pri, 0, val);
2471         else
2472                 outstring(pri, s);
2473 }
2474 
2475 /*
2476  * Print lgrp_affinity_{get,set}() arguments.
2477  */
2478 /*ARGSUSED*/
2479 void
2480 prt_laf(private_t *pri, int raw, long val)
2481 {
2482         lgrp_affinity_args_t    laff;
2483 
2484         if (Pread(Proc, &laff, sizeof (lgrp_affinity_args_t), val) !=
2485             sizeof (lgrp_affinity_args_t)) {
2486                 prt_hex(pri, 0, val);
2487                 return;
2488         }
2489         /*
2490          * arrange the arguments in the order that user calls with
2491          */
2492         prt_dec(pri, 0, laff.idtype);
2493         outstring(pri, ", ");
2494         prt_dec(pri, 0, laff.id);
2495         outstring(pri, ", ");
2496         prt_dec(pri, 0, laff.lgrp);
2497         outstring(pri, ", ");
2498         if (pri->sys_args[0] == LGRP_SYS_AFFINITY_SET)
2499                 prt_dec(pri, 0, laff.aff);
2500 }
2501 
2502 /*
2503  * Print a key_t as IPC_PRIVATE if it is 0.
2504  */
2505 void
2506 prt_key(private_t *pri, int raw, long val)
2507 {
2508         if (!raw && val == 0)
2509                 outstring(pri, "IPC_PRIVATE");
2510         else
2511                 prt_dec(pri, 0, val);
2512 }
2513 
2514 
2515 /*
2516  * Print zone_getattr() attribute types.
2517  */
2518 void
2519 prt_zga(private_t *pri, int raw, long val)
2520 {
2521         const char *s = NULL;
2522 
2523         if (!raw) {
2524                 switch ((int)val) {
2525                 case ZONE_ATTR_NAME:    s = "ZONE_ATTR_NAME";   break;
2526                 case ZONE_ATTR_ROOT:    s = "ZONE_ATTR_ROOT";   break;
2527                 case ZONE_ATTR_STATUS:  s = "ZONE_ATTR_STATUS"; break;
2528                 case ZONE_ATTR_PRIVSET: s = "ZONE_ATTR_PRIVSET"; break;
2529                 case ZONE_ATTR_UNIQID:  s = "ZONE_ATTR_UNIQID"; break;
2530                 case ZONE_ATTR_POOLID:  s = "ZONE_ATTR_POOLID"; break;
2531                 case ZONE_ATTR_INITPID: s = "ZONE_ATTR_INITPID"; break;
2532                 case ZONE_ATTR_SLBL:    s = "ZONE_ATTR_SLBL"; break;
2533                 case ZONE_ATTR_INITNAME:        s = "ZONE_ATTR_INITNAME"; break;
2534                 case ZONE_ATTR_BOOTARGS:        s = "ZONE_ATTR_BOOTARGS"; break;
2535                 case ZONE_ATTR_BRAND:   s = "ZONE_ATTR_BRAND"; break;
2536                 case ZONE_ATTR_FLAGS:   s = "ZONE_ATTR_FLAGS"; break;
2537                 case ZONE_ATTR_PHYS_MCAP: s = "ZONE_ATTR_PHYS_MCAP"; break;
2538                 }
2539         }
2540 
2541         if (s == NULL)
2542                 prt_dec(pri, 0, val);
2543         else
2544                 outstring(pri, s);
2545 }
2546 
2547 /*
2548  * Print a file descriptor as AT_FDCWD if necessary
2549  */
2550 void
2551 prt_atc(private_t *pri, int raw, long val)
2552 {
2553         if ((int)val == AT_FDCWD) {
2554                 if (raw)
2555                         prt_hex(pri, 0, (uint_t)AT_FDCWD);
2556                 else
2557                         outstring(pri, "AT_FDCWD");
2558         } else {
2559                 prt_dec(pri, 0, val);
2560         }
2561 }
2562 
2563 /*
2564  * Print Trusted Networking database operation codes (labelsys; tn*)
2565  */
2566 static void
2567 prt_tnd(private_t *pri, int raw, long val)
2568 {
2569         const char *s = NULL;
2570 
2571         if (!raw) {
2572                 switch ((tsol_dbops_t)val) {
2573                 case TNDB_NOOP:         s = "TNDB_NOOP";        break;
2574                 case TNDB_LOAD:         s = "TNDB_LOAD";        break;
2575                 case TNDB_DELETE:       s = "TNDB_DELETE";      break;
2576                 case TNDB_FLUSH:        s = "TNDB_FLUSH";       break;
2577                 case TNDB_GET:          s = "TNDB_GET";         break;
2578                 }
2579         }
2580 
2581         if (s == NULL)
2582                 prt_dec(pri, 0, val);
2583         else
2584                 outstring(pri, s);
2585 }
2586 
2587 /*
2588  * Print LIO_XX flags
2589  */
2590 void
2591 prt_lio(private_t *pri, int raw, long val)
2592 {
2593         if (raw)
2594                 prt_dec(pri, 0, val);
2595         else if (val == LIO_WAIT)
2596                 outstring(pri, "LIO_WAIT");
2597         else if (val == LIO_NOWAIT)
2598                 outstring(pri, "LIO_NOWAIT");
2599         else
2600                 prt_dec(pri, 0, val);
2601 }
2602 
2603 const char *
2604 door_flags(private_t *pri, long val)
2605 {
2606         door_attr_t attr = (door_attr_t)val;
2607         char *str = pri->code_buf;
2608 
2609         *str = '\0';
2610 #define PROCESS_FLAG(flg)                                               \
2611         if (attr & flg) {                                           \
2612                 (void) strlcat(str, "|" #flg, sizeof (pri->code_buf));       \
2613                 attr &= ~flg;                                               \
2614         }
2615 
2616         PROCESS_FLAG(DOOR_UNREF);
2617         PROCESS_FLAG(DOOR_UNREF_MULTI);
2618         PROCESS_FLAG(DOOR_PRIVATE);
2619         PROCESS_FLAG(DOOR_REFUSE_DESC);
2620         PROCESS_FLAG(DOOR_NO_CANCEL);
2621         PROCESS_FLAG(DOOR_LOCAL);
2622         PROCESS_FLAG(DOOR_REVOKED);
2623         PROCESS_FLAG(DOOR_IS_UNREF);
2624 #undef PROCESS_FLAG
2625 
2626         if (attr != 0 || *str == '\0') {
2627                 size_t len = strlen(str);
2628                 (void) snprintf(str + len, sizeof (pri->code_buf) - len,
2629                     "|0x%X", attr);
2630         }
2631 
2632         return (str + 1);
2633 }
2634 
2635 /*
2636  * Print door_create() flags
2637  */
2638 void
2639 prt_dfl(private_t *pri, int raw, long val)
2640 {
2641         if (raw)
2642                 prt_hex(pri, 0, val);
2643         else
2644                 outstring(pri, door_flags(pri, val));
2645 }
2646 
2647 /*
2648  * Print door_*param() param argument
2649  */
2650 void
2651 prt_dpm(private_t *pri, int raw, long val)
2652 {
2653         if (raw)
2654                 prt_hex(pri, 0, val);
2655         else if (val == DOOR_PARAM_DESC_MAX)
2656                 outstring(pri, "DOOR_PARAM_DESC_MAX");
2657         else if (val == DOOR_PARAM_DATA_MIN)
2658                 outstring(pri, "DOOR_PARAM_DATA_MIN");
2659         else if (val == DOOR_PARAM_DATA_MAX)
2660                 outstring(pri, "DOOR_PARAM_DATA_MAX");
2661         else
2662                 prt_hex(pri, 0, val);
2663 }
2664 
2665 /*
2666  * Print rctlsys subcodes
2667  */
2668 void
2669 prt_rsc(private_t *pri, int raw, long val)      /* print utssys code */
2670 {
2671         const char *s = raw? NULL : rctlsyscode(val);
2672 
2673         if (s == NULL)
2674                 prt_dec(pri, 0, val);
2675         else
2676                 outstring(pri, s);
2677 }
2678 
2679 /*
2680  * Print getrctl flags
2681  */
2682 void
2683 prt_rgf(private_t *pri, int raw, long val)
2684 {
2685         long action = val & (~RCTLSYS_ACTION_MASK);
2686 
2687         if (raw)
2688                 prt_hex(pri, 0, val);
2689         else if (action == RCTL_FIRST)
2690                 outstring(pri, "RCTL_FIRST");
2691         else if (action == RCTL_NEXT)
2692                 outstring(pri, "RCTL_NEXT");
2693         else if (action == RCTL_USAGE)
2694                 outstring(pri, "RCTL_USAGE");
2695         else
2696                 prt_hex(pri, 0, val);
2697 }
2698 
2699 /*
2700  * Print setrctl flags
2701  */
2702 void
2703 prt_rsf(private_t *pri, int raw, long val)
2704 {
2705         long action = val & (~RCTLSYS_ACTION_MASK);
2706         long pval = val & RCTL_LOCAL_ACTION_MASK;
2707         char *s = pri->code_buf;
2708 
2709         if (raw) {
2710                 prt_hex(pri, 0, val);
2711                 return;
2712         } else if (action == RCTL_INSERT)
2713                 (void) strcpy(s, "RCTL_INSERT");
2714         else if (action == RCTL_DELETE)
2715                 (void) strcpy(s, "RCTL_DELETE");
2716         else if (action == RCTL_REPLACE)
2717                 (void) strcpy(s, "RCTL_REPLACE");
2718         else {
2719                 prt_hex(pri, 0, val);
2720                 return;
2721         }
2722 
2723         if (pval & RCTL_USE_RECIPIENT_PID) {
2724                 pval ^= RCTL_USE_RECIPIENT_PID;
2725                 (void) strlcat(s, "|RCTL_USE_RECIPIENT_PID",
2726                     sizeof (pri->code_buf));
2727         }
2728 
2729         if ((pval & RCTLSYS_ACTION_MASK) != 0)
2730                 prt_hex(pri, 0, val);
2731         else if (*s != '\0')
2732                 outstring(pri, s);
2733         else
2734                 prt_hex(pri, 0, val);
2735 }
2736 
2737 /*
2738  * Print rctlctl flags
2739  */
2740 void
2741 prt_rcf(private_t *pri, int raw, long val)
2742 {
2743         long action = val & (~RCTLSYS_ACTION_MASK);
2744 
2745         if (raw)
2746                 prt_hex(pri, 0, val);
2747         else if (action == RCTLCTL_GET)
2748                 outstring(pri, "RCTLCTL_GET");
2749         else if (action == RCTLCTL_SET)
2750                 outstring(pri, "RCTLCTL_SET");
2751         else
2752                 prt_hex(pri, 0, val);
2753 }
2754 
2755 /*
2756  * Print setprojrctl flags
2757  */
2758 void
2759 prt_spf(private_t *pri, int raw, long val)
2760 {
2761         long action = val & TASK_PROJ_MASK;
2762 
2763         if (!raw && (action == TASK_PROJ_PURGE))
2764                 outstring(pri, "TASK_PROJ_PURGE");
2765         else
2766                 prt_hex(pri, 0, val);
2767 }
2768 
2769 /*
2770  * Print forkx() flags
2771  */
2772 void
2773 prt_fxf(private_t *pri, int raw, long val)
2774 {
2775         char *str;
2776 
2777         if (val == 0)
2778                 outstring(pri, "0");
2779         else if (raw || (val & ~(FORK_NOSIGCHLD | FORK_WAITPID)))
2780                 prt_hhx(pri, 0, val);
2781         else {
2782                 str = pri->code_buf;
2783                 *str = '\0';
2784                 if (val & FORK_NOSIGCHLD)
2785                         (void) strlcat(str, "|FORK_NOSIGCHLD",
2786                             sizeof (pri->code_buf));
2787                 if (val & FORK_WAITPID)
2788                         (void) strlcat(str, "|FORK_WAITPID",
2789                             sizeof (pri->code_buf));
2790                 outstring(pri, str + 1);
2791         }
2792 }
2793 
2794 /*
2795  * Print faccessat() flag
2796  */
2797 void
2798 prt_fat(private_t *pri, int raw, long val)
2799 {
2800         if (val == 0)
2801                 outstring(pri, "0");
2802         else if (!raw && val == AT_EACCESS)
2803                 outstring(pri, "AT_EACCESS");
2804         else
2805                 prt_hex(pri, 0, val);
2806 }
2807 
2808 /*
2809  * Print unlinkat() flag
2810  */
2811 void
2812 prt_uat(private_t *pri, int raw, long val)
2813 {
2814         if (val == 0)
2815                 outstring(pri, "0");
2816         else if (!raw && val == AT_REMOVEDIR)
2817                 outstring(pri, "AT_REMOVEDIR");
2818         else
2819                 prt_hex(pri, 0, val);
2820 }
2821 
2822 /*
2823  * Print AT_SYMLINK_NOFOLLOW / AT_SYMLINK_FOLLOW flag
2824  */
2825 void
2826 prt_snf(private_t *pri, int raw, long val)
2827 {
2828         if (val == 0)
2829                 outstring(pri, "0");
2830         else if (!raw && val == AT_SYMLINK_NOFOLLOW)
2831                 outstring(pri, "AT_SYMLINK_NOFOLLOW");
2832         else if (!raw && val == AT_SYMLINK_FOLLOW)
2833                 outstring(pri, "AT_SYMLINK_FOLLOW");
2834         else
2835                 prt_hex(pri, 0, val);
2836 }
2837 
2838 /*
2839  * Array of pointers to print functions, one for each format.
2840  */
2841 void (* const Print[])() = {
2842         prt_nov,        /* NOV -- no value */
2843         prt_dec,        /* DEC -- print value in decimal */
2844         prt_oct,        /* OCT -- print value in octal */
2845         prt_hex,        /* HEX -- print value in hexadecimal */
2846         prt_dex,        /* DEX -- print value in hexadecimal if big enough */
2847         prt_stg,        /* STG -- print value as string */
2848         prt_ioc,        /* IOC -- print ioctl code */
2849         prt_fcn,        /* FCN -- print fcntl code */
2850         prt_s86,        /* S86 -- print sysi86 code */
2851         prt_uts,        /* UTS -- print utssys code */
2852         prt_opn,        /* OPN -- print open code */
2853         prt_sig,        /* SIG -- print signal name plus flags */
2854         prt_uat,        /* UAT -- print unlinkat() flag */
2855         prt_msc,        /* MSC -- print msgsys command */
2856         prt_msf,        /* MSF -- print msgsys flags */
2857         prt_smc,        /* SMC -- print semsys command */
2858         prt_sef,        /* SEF -- print semsys flags */
2859         prt_shc,        /* SHC -- print shmsys command */
2860         prt_shf,        /* SHF -- print shmsys flags */
2861         prt_fat,        /* FAT -- print faccessat( flag */
2862         prt_sfs,        /* SFS -- print sysfs code */
2863         prt_rst,        /* RST -- print string returned by syscall */
2864         prt_smf,        /* SMF -- print streams message flags */
2865         prt_ioa,        /* IOA -- print ioctl argument */
2866         prt_pip,        /* PIP -- print pipe flags */
2867         prt_mtf,        /* MTF -- print mount flags */
2868         prt_mft,        /* MFT -- print mount file system type */
2869         prt_iob,        /* IOB -- print contents of I/O buffer */
2870         prt_hhx,        /* HHX -- print value in hexadecimal (half size) */
2871         prt_wop,        /* WOP -- print waitsys() options */
2872         prt_spm,        /* SPM -- print sigprocmask argument */
2873         prt_rlk,        /* RLK -- print readlink buffer */
2874         prt_mpr,        /* MPR -- print mmap()/mprotect() flags */
2875         prt_mty,        /* MTY -- print mmap() mapping type flags */
2876         prt_mcf,        /* MCF -- print memcntl() function */
2877         prt_mc4,        /* MC4 -- print memcntl() (fourth) argument */
2878         prt_mc5,        /* MC5 -- print memcntl() (fifth) argument */
2879         prt_mad,        /* MAD -- print madvise() argument */
2880         prt_ulm,        /* ULM -- print ulimit() argument */
2881         prt_rlm,        /* RLM -- print get/setrlimit() argument */
2882         prt_cnf,        /* CNF -- print sysconfig() argument */
2883         prt_inf,        /* INF -- print sysinfo() argument */
2884         prt_ptc,        /* PTC -- print pathconf/fpathconf() argument */
2885         prt_fui,        /* FUI -- print fusers() input argument */
2886         prt_idt,        /* IDT -- print idtype_t, waitid() argument */
2887         prt_lwf,        /* LWF -- print lwp_create() flags */
2888         prt_itm,        /* ITM -- print [get|set]itimer() arg */
2889         prt_llo,        /* LLO -- print long long offset arg */
2890         prt_mod,        /* MOD -- print modctl() subcode */
2891         prt_whn,        /* WHN -- print lseek() whence arguiment */
2892         prt_acl,        /* ACL -- print acl() code */
2893         prt_aio,        /* AIO -- print kaio() code */
2894         prt_aud,        /* AUD -- print auditsys() code */
2895         prt_uns,        /* DEC -- print value in unsigned decimal */
2896         prt_clc,        /* CLC -- print cladm command argument */
2897         prt_clf,        /* CLF -- print cladm flag argument */
2898         prt_cor,        /* COR -- print corectl() subcode */
2899         prt_cco,        /* CCO -- print corectl() options */
2900         prt_ccc,        /* CCC -- print corectl() content */
2901         prt_rcc,        /* RCC -- print corectl() returned content */
2902         prt_cpc,        /* CPC -- print cpc() subcode */
2903         prt_sqc,        /* SQC -- print sigqueue() si_code argument */
2904         prt_pc4,        /* PC4 -- print priocntlsys() (fourth) argument */
2905         prt_pc5,        /* PC5 -- print priocntlsys() (key, value) pairs */
2906         prt_pst,        /* PST -- print processor set id */
2907         prt_mif,        /* MIF -- print meminfo() arguments */
2908         prt_pfm,        /* PFM -- print so_socket() proto-family (1st) arg */
2909         prt_skt,        /* SKT -- print so_socket() socket-type (2nd) arg */
2910         prt_skp,        /* SKP -- print so_socket() protocol (3rd) arg */
2911         prt_skv,        /* SKV -- print socket version arg */
2912         prt_sad,        /* SAD -- print connect 2nd and 3rd arguments */
2913         prt_sol,        /* SOL -- print [sg]etsockopt() level (2nd) arg */
2914         prt_son,        /* SON -- print [sg]etsockopt() opt-name (3rd) arg */
2915         prt_utt,        /* UTT -- print utrap type */
2916         prt_uth,        /* UTH -- print utrap handler */
2917         prt_acc,        /* ACC -- print access() flags */
2918         prt_sht,        /* SHT -- print shutdown() how (2nd) argument */
2919         prt_ffg,        /* FFG -- print fcntl() flags (3rd) argument */
2920         prt_prs,        /* PRS -- print privilege set */
2921         prt_pro,        /* PRO -- print privilege set operation */
2922         prt_prn,        /* PRN -- print privilege set name */
2923         prt_pfl,        /* PFL -- print privilege/process flag name */
2924         prt_laf,        /* LAF -- print lgrp_affinity arguments */
2925         prt_key,        /* KEY -- print key_t 0 as IPC_PRIVATE */
2926         prt_zga,        /* ZGA -- print zone_getattr attribute types */
2927         prt_atc,        /* ATC -- print AT_FDCWD or file descriptor */
2928         prt_lio,        /* LIO -- print LIO_XX flags */
2929         prt_dfl,        /* DFL -- print door_create() flags */
2930         prt_dpm,        /* DPM -- print DOOR_PARAM_XX flags */
2931         prt_tnd,        /* TND -- print trusted network data base opcode */
2932         prt_rsc,        /* RSC -- print rctlsys() subcodes */
2933         prt_rgf,        /* RGF -- print getrctl() flags */
2934         prt_rsf,        /* RSF -- print setrctl() flags */
2935         prt_rcf,        /* RCF -- print rctlsys_ctl() flags */
2936         prt_fxf,        /* FXF -- print forkx() flags */
2937         prt_spf,        /* SPF -- print rctlsys_projset() flags */
2938         prt_un1,        /* UN1 -- as prt_uns except for -1 */
2939         prt_mob,        /* MOB -- print mmapobj() flags */
2940         prt_snf,        /* SNF -- print AT_SYMLINK_[NO]FOLLOW flag */
2941         prt_skc,        /* SKC -- print sockconfig() subcode */
2942         prt_acf,        /* ACF -- print accept4 flags */
2943         prt_pfd,        /* PFD -- print pipe fds */
2944         prt_dec,        /* HID -- hidden argument, make this the last one */
2945 };