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