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