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 1548 rshoaib * Common Development and Distribution License (the "License"). 6 1548 rshoaib * 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 1548 rshoaib 22 0 stevel /* 23 10440 Roger * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 24 0 stevel * Use is subject to license terms. 25 0 stevel */ 26 0 stevel 27 0 stevel /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 28 0 stevel /* All Rights Reserved */ 29 0 stevel 30 0 stevel #define _SYSCALL32 31 0 stevel 32 0 stevel #include <stdio.h> 33 0 stevel #include <stdlib.h> 34 0 stevel #include <unistd.h> 35 0 stevel #include <ctype.h> 36 0 stevel #include <sys/types.h> 37 0 stevel #include <sys/mman.h> 38 0 stevel #include <libproc.h> 39 0 stevel #include <string.h> 40 0 stevel #include <limits.h> 41 0 stevel #include <sys/statfs.h> 42 0 stevel #include <sys/times.h> 43 0 stevel #include <sys/timex.h> 44 0 stevel #include <sys/utssys.h> 45 0 stevel #include <sys/utsname.h> 46 0 stevel #include <sys/ipc.h> 47 0 stevel #include <sys/ipc_impl.h> 48 0 stevel #include <sys/msg.h> 49 0 stevel #include <sys/msg_impl.h> 50 0 stevel #include <sys/sem.h> 51 0 stevel #include <sys/sem_impl.h> 52 0 stevel #include <sys/shm.h> 53 0 stevel #include <sys/shm_impl.h> 54 0 stevel #include <sys/dirent.h> 55 0 stevel #include <sys/utime.h> 56 0 stevel #include <ustat.h> 57 0 stevel #include <fcntl.h> 58 0 stevel #include <time.h> 59 0 stevel #include <sys/termios.h> 60 0 stevel #include <sys/termiox.h> 61 0 stevel #include <sys/termio.h> 62 0 stevel #include <sys/ttold.h> 63 0 stevel #include <sys/jioctl.h> 64 0 stevel #include <sys/filio.h> 65 0 stevel #include <stropts.h> 66 0 stevel #include <poll.h> 67 0 stevel #include <sys/uio.h> 68 0 stevel #include <sys/resource.h> 69 0 stevel #include <sys/statvfs.h> 70 0 stevel #include <sys/time.h> 71 0 stevel #include <sys/aio.h> 72 0 stevel #include <sys/socket.h> 73 0 stevel #include <netinet/in.h> 74 0 stevel #include <sys/un.h> 75 0 stevel #include <sys/byteorder.h> 76 0 stevel #include <arpa/inet.h> 77 0 stevel #include <sys/audioio.h> 78 0 stevel #include <sys/cladm.h> 79 0 stevel #include <sys/synch.h> 80 0 stevel #include <sys/synch32.h> 81 0 stevel #include <sys/sysmacros.h> 82 0 stevel #include <sys/sendfile.h> 83 0 stevel #include <priv.h> 84 0 stevel #include <ucred.h> 85 0 stevel #include <sys/ucred.h> 86 0 stevel #include <sys/port_impl.h> 87 813 dp #include <sys/zone.h> 88 813 dp #include <sys/priv_impl.h> 89 813 dp #include <sys/priv.h> 90 1676 jpk #include <tsol/label.h> 91 2447 nf202958 #include <sys/nvpair.h> 92 2447 nf202958 #include <libnvpair.h> 93 3684 rd117015 #include <sys/rctl_impl.h> 94 0 stevel 95 0 stevel #include "ramdata.h" 96 0 stevel #include "systable.h" 97 0 stevel #include "proto.h" 98 0 stevel 99 0 stevel void show_sigset(private_t *, long, const char *); 100 0 stevel void show_ioctl(private_t *, int, long); 101 0 stevel 102 10440 Roger static void 103 10440 Roger mk_ctime(char *str, size_t maxsize, time_t value) 104 10440 Roger { 105 10440 Roger (void) strftime(str, maxsize, "%b %e %H:%M:%S %Z %Y", 106 10440 Roger localtime(&value)); 107 10440 Roger } 108 10440 Roger 109 0 stevel void 110 0 stevel prtime(private_t *pri, const char *name, time_t value) 111 0 stevel { 112 0 stevel char str[80]; 113 0 stevel 114 10440 Roger mk_ctime(str, sizeof (str), value); 115 10440 Roger (void) printf("%s\t%s%s [ %lu ]\n", 116 0 stevel pri->pname, 117 0 stevel name, 118 0 stevel str, 119 10440 Roger value); 120 10440 Roger } 121 10440 Roger 122 10440 Roger void 123 10440 Roger prtimeval(private_t *pri, const char *name, struct timeval *value) 124 10440 Roger { 125 10440 Roger char str[80]; 126 10440 Roger 127 10440 Roger mk_ctime(str, sizeof (str), value->tv_sec); 128 10440 Roger (void) printf("%s\t%s%s [ %lu.%6.6lu ]\n", 129 10440 Roger pri->pname, 130 10440 Roger name, 131 10440 Roger str, 132 10440 Roger value->tv_sec, 133 10440 Roger value->tv_usec); 134 0 stevel } 135 0 stevel 136 0 stevel void 137 0 stevel prtimestruc(private_t *pri, const char *name, timestruc_t *value) 138 0 stevel { 139 10440 Roger char str[80]; 140 10440 Roger 141 10440 Roger mk_ctime(str, sizeof (str), value->tv_sec); 142 10440 Roger (void) printf("%s\t%s%s [ %lu.%9.9lu ]\n", 143 10440 Roger pri->pname, 144 10440 Roger name, 145 10440 Roger str, 146 10440 Roger value->tv_sec, 147 10440 Roger value->tv_nsec); 148 10440 Roger } 149 10440 Roger 150 10440 Roger static void 151 0 stevel show_utime(private_t *pri) 152 0 stevel { 153 0 stevel long offset; 154 0 stevel struct utimbuf utimbuf; 155 0 stevel 156 0 stevel if (pri->sys_nargs < 2 || (offset = pri->sys_args[1]) == NULL) 157 0 stevel return; 158 0 stevel 159 0 stevel if (data_model == PR_MODEL_NATIVE) { 160 0 stevel if (Pread(Proc, &utimbuf, sizeof (utimbuf), offset) 161 0 stevel != sizeof (utimbuf)) 162 0 stevel return; 163 0 stevel } else { 164 0 stevel struct utimbuf32 utimbuf32; 165 0 stevel 166 0 stevel if (Pread(Proc, &utimbuf32, sizeof (utimbuf32), offset) 167 0 stevel != sizeof (utimbuf32)) 168 0 stevel return; 169 0 stevel 170 0 stevel utimbuf.actime = (time_t)utimbuf32.actime; 171 0 stevel utimbuf.modtime = (time_t)utimbuf32.modtime; 172 0 stevel } 173 0 stevel 174 0 stevel /* print access and modification times */ 175 10440 Roger prtime(pri, "at = ", utimbuf.actime); 176 10440 Roger prtime(pri, "mt = ", utimbuf.modtime); 177 10440 Roger } 178 10440 Roger 179 10440 Roger static void 180 10440 Roger show_utimes(private_t *pri, long offset) 181 10440 Roger { 182 0 stevel struct { 183 0 stevel struct timeval atime; 184 0 stevel struct timeval mtime; 185 0 stevel } utimbuf; 186 0 stevel 187 10440 Roger if (offset == 0) 188 0 stevel return; 189 0 stevel 190 0 stevel if (data_model == PR_MODEL_NATIVE) { 191 0 stevel if (Pread(Proc, &utimbuf, sizeof (utimbuf), offset) 192 0 stevel != sizeof (utimbuf)) 193 0 stevel return; 194 0 stevel } else { 195 0 stevel struct { 196 0 stevel struct timeval32 atime; 197 0 stevel struct timeval32 mtime; 198 0 stevel } utimbuf32; 199 0 stevel 200 0 stevel if (Pread(Proc, &utimbuf32, sizeof (utimbuf32), offset) 201 0 stevel != sizeof (utimbuf32)) 202 0 stevel return; 203 0 stevel 204 0 stevel TIMEVAL32_TO_TIMEVAL(&utimbuf.atime, &utimbuf32.atime); 205 0 stevel TIMEVAL32_TO_TIMEVAL(&utimbuf.mtime, &utimbuf32.mtime); 206 0 stevel } 207 0 stevel 208 0 stevel /* print access and modification times */ 209 10440 Roger prtimeval(pri, "at = ", &utimbuf.atime); 210 10440 Roger prtimeval(pri, "mt = ", &utimbuf.mtime); 211 10440 Roger } 212 10440 Roger 213 10440 Roger static void 214 10440 Roger show_utimens(private_t *pri, long offset) 215 10440 Roger { 216 10440 Roger struct { 217 10440 Roger timespec_t atime; 218 10440 Roger timespec_t mtime; 219 10440 Roger } utimbuf; 220 10440 Roger 221 10440 Roger if (offset == 0) 222 10440 Roger return; 223 10440 Roger 224 10440 Roger if (data_model == PR_MODEL_NATIVE) { 225 10440 Roger if (Pread(Proc, &utimbuf, sizeof (utimbuf), offset) 226 10440 Roger != sizeof (utimbuf)) 227 10440 Roger return; 228 10440 Roger } else { 229 10440 Roger struct { 230 10440 Roger timespec32_t atime; 231 10440 Roger timespec32_t mtime; 232 10440 Roger } utimbuf32; 233 10440 Roger 234 10440 Roger if (Pread(Proc, &utimbuf32, sizeof (utimbuf32), offset) 235 10440 Roger != sizeof (utimbuf32)) 236 10440 Roger return; 237 10440 Roger 238 10440 Roger TIMESPEC32_TO_TIMESPEC(&utimbuf.atime, &utimbuf32.atime); 239 10440 Roger TIMESPEC32_TO_TIMESPEC(&utimbuf.mtime, &utimbuf32.mtime); 240 10440 Roger } 241 10440 Roger 242 10440 Roger /* print access and modification times */ 243 10440 Roger if (utimbuf.atime.tv_nsec == UTIME_OMIT) 244 10440 Roger (void) printf("%s\tat = UTIME_OMIT\n", pri->pname); 245 10440 Roger else if (utimbuf.atime.tv_nsec == UTIME_NOW) 246 10440 Roger (void) printf("%s\tat = UTIME_NOW\n", pri->pname); 247 10440 Roger else 248 10440 Roger prtimestruc(pri, "at = ", &utimbuf.atime); 249 10440 Roger if (utimbuf.mtime.tv_nsec == UTIME_OMIT) 250 10440 Roger (void) printf("%s\tmt = UTIME_OMIT\n", pri->pname); 251 10440 Roger else if (utimbuf.mtime.tv_nsec == UTIME_NOW) 252 10440 Roger (void) printf("%s\tmt = UTIME_NOW\n", pri->pname); 253 10440 Roger else 254 10440 Roger prtimestruc(pri, "mt = ", &utimbuf.atime); 255 0 stevel } 256 0 stevel 257 0 stevel void 258 0 stevel show_timeofday(private_t *pri) 259 0 stevel { 260 0 stevel struct timeval tod; 261 0 stevel long offset; 262 0 stevel 263 0 stevel if (pri->sys_nargs < 1 || (offset = pri->sys_args[0]) == NULL) 264 0 stevel return; 265 0 stevel 266 0 stevel if (data_model == PR_MODEL_NATIVE) { 267 0 stevel if (Pread(Proc, &tod, sizeof (tod), offset) 268 0 stevel != sizeof (tod)) 269 0 stevel return; 270 0 stevel } else { 271 0 stevel struct timeval32 tod32; 272 0 stevel 273 0 stevel if (Pread(Proc, &tod32, sizeof (tod32), offset) 274 0 stevel != sizeof (tod32)) 275 0 stevel return; 276 0 stevel 277 0 stevel TIMEVAL32_TO_TIMEVAL(&tod, &tod32); 278 0 stevel } 279 0 stevel 280 10440 Roger prtimeval(pri, "time: ", &tod); 281 0 stevel } 282 0 stevel 283 0 stevel void 284 0 stevel show_itimerval(private_t *pri, long offset, const char *name) 285 0 stevel { 286 0 stevel struct itimerval itimerval; 287 0 stevel 288 10440 Roger if (offset == 0) 289 0 stevel return; 290 0 stevel 291 0 stevel if (data_model == PR_MODEL_NATIVE) { 292 0 stevel if (Pread(Proc, &itimerval, sizeof (itimerval), offset) 293 0 stevel != sizeof (itimerval)) 294 0 stevel return; 295 0 stevel } else { 296 0 stevel struct itimerval32 itimerval32; 297 0 stevel 298 0 stevel if (Pread(Proc, &itimerval32, sizeof (itimerval32), offset) 299 0 stevel != sizeof (itimerval32)) 300 0 stevel return; 301 0 stevel 302 0 stevel ITIMERVAL32_TO_ITIMERVAL(&itimerval, &itimerval32); 303 0 stevel } 304 0 stevel 305 0 stevel (void) printf( 306 0 stevel "%s\t%s: interval: %4ld.%6.6ld sec value: %4ld.%6.6ld sec\n", 307 0 stevel pri->pname, 308 0 stevel name, 309 0 stevel itimerval.it_interval.tv_sec, 310 0 stevel itimerval.it_interval.tv_usec, 311 0 stevel itimerval.it_value.tv_sec, 312 0 stevel itimerval.it_value.tv_usec); 313 0 stevel } 314 0 stevel 315 0 stevel void 316 0 stevel show_timeval(private_t *pri, long offset, const char *name) 317 0 stevel { 318 0 stevel struct timeval timeval; 319 0 stevel 320 10440 Roger if (offset == 0) 321 0 stevel return; 322 0 stevel 323 0 stevel if (data_model == PR_MODEL_NATIVE) { 324 0 stevel if (Pread(Proc, &timeval, sizeof (timeval), offset) 325 0 stevel != sizeof (timeval)) 326 0 stevel return; 327 0 stevel } else { 328 0 stevel struct timeval32 timeval32; 329 0 stevel 330 0 stevel if (Pread(Proc, &timeval32, sizeof (timeval32), offset) 331 0 stevel != sizeof (timeval32)) 332 0 stevel return; 333 0 stevel 334 0 stevel TIMEVAL32_TO_TIMEVAL(&timeval, &timeval32); 335 0 stevel } 336 0 stevel 337 0 stevel (void) printf( 338 0 stevel "%s\t%s: %ld.%6.6ld sec\n", 339 0 stevel pri->pname, 340 0 stevel name, 341 0 stevel timeval.tv_sec, 342 0 stevel timeval.tv_usec); 343 0 stevel } 344 0 stevel 345 0 stevel void 346 0 stevel show_timestruc(private_t *pri, long offset, const char *name) 347 0 stevel { 348 0 stevel timestruc_t timestruc; 349 0 stevel 350 10440 Roger if (offset == 0) 351 0 stevel return; 352 0 stevel 353 0 stevel if (data_model == PR_MODEL_NATIVE) { 354 0 stevel if (Pread(Proc, ×truc, sizeof (timestruc), offset) 355 0 stevel != sizeof (timestruc)) 356 0 stevel return; 357 0 stevel } else { 358 0 stevel timestruc32_t timestruc32; 359 0 stevel 360 0 stevel if (Pread(Proc, ×truc32, sizeof (timestruc32), offset) 361 0 stevel != sizeof (timestruc32)) 362 0 stevel return; 363 0 stevel 364 0 stevel TIMESPEC32_TO_TIMESPEC(×truc, ×truc32); 365 0 stevel } 366 0 stevel 367 0 stevel (void) printf( 368 0 stevel "%s\t%s: %ld.%9.9ld sec\n", 369 0 stevel pri->pname, 370 0 stevel name, 371 0 stevel timestruc.tv_sec, 372 0 stevel timestruc.tv_nsec); 373 0 stevel } 374 0 stevel 375 0 stevel void 376 0 stevel show_stime(private_t *pri) 377 0 stevel { 378 0 stevel if (pri->sys_nargs >= 1) { 379 0 stevel /* print new system time */ 380 0 stevel prtime(pri, "systime = ", (time_t)pri->sys_args[0]); 381 0 stevel } 382 0 stevel } 383 0 stevel 384 0 stevel void 385 0 stevel show_times(private_t *pri) 386 0 stevel { 387 0 stevel long hz = sysconf(_SC_CLK_TCK); 388 0 stevel long offset; 389 0 stevel struct tms tms; 390 0 stevel 391 0 stevel if (pri->sys_nargs < 1 || (offset = pri->sys_args[0]) == NULL) 392 0 stevel return; 393 0 stevel 394 0 stevel if (data_model == PR_MODEL_NATIVE) { 395 0 stevel if (Pread(Proc, &tms, sizeof (tms), offset) 396 0 stevel != sizeof (tms)) 397 0 stevel return; 398 0 stevel } else { 399 0 stevel struct tms32 tms32; 400 0 stevel 401 0 stevel if (Pread(Proc, &tms32, sizeof (tms32), offset) 402 0 stevel != sizeof (tms32)) 403 0 stevel return; 404 0 stevel 405 0 stevel /* 406 0 stevel * This looks a bit odd (since the values are actually 407 0 stevel * signed), but we need to suppress sign extension to 408 0 stevel * preserve compatibility (we've always printed these 409 0 stevel * numbers as unsigned quantities). 410 0 stevel */ 411 0 stevel tms.tms_utime = (unsigned)tms32.tms_utime; 412 0 stevel tms.tms_stime = (unsigned)tms32.tms_stime; 413 0 stevel tms.tms_cutime = (unsigned)tms32.tms_cutime; 414 0 stevel tms.tms_cstime = (unsigned)tms32.tms_cstime; 415 0 stevel } 416 0 stevel 417 0 stevel (void) printf( 418 0 stevel "%s\tutim=%-6lu stim=%-6lu cutim=%-6lu cstim=%-6lu (HZ=%ld)\n", 419 0 stevel pri->pname, 420 0 stevel tms.tms_utime, 421 0 stevel tms.tms_stime, 422 0 stevel tms.tms_cutime, 423 0 stevel tms.tms_cstime, 424 0 stevel hz); 425 0 stevel } 426 0 stevel 427 0 stevel void 428 0 stevel show_uname(private_t *pri, long offset) 429 0 stevel { 430 0 stevel /* 431 0 stevel * Old utsname buffer (no longer accessible in <sys/utsname.h>). 432 0 stevel */ 433 0 stevel struct { 434 0 stevel char sysname[9]; 435 0 stevel char nodename[9]; 436 0 stevel char release[9]; 437 0 stevel char version[9]; 438 0 stevel char machine[9]; 439 0 stevel } ubuf; 440 0 stevel 441 0 stevel if (offset != NULL && 442 0 stevel Pread(Proc, &ubuf, sizeof (ubuf), offset) == sizeof (ubuf)) { 443 0 stevel (void) printf( 444 7088 raf "%s\tsys=%-9.9snod=%-9.9srel=%-9.9sver=%-9.9smch=%.9s\n", 445 7088 raf pri->pname, 446 7088 raf ubuf.sysname, 447 7088 raf ubuf.nodename, 448 7088 raf ubuf.release, 449 7088 raf ubuf.version, 450 7088 raf ubuf.machine); 451 0 stevel } 452 0 stevel } 453 0 stevel 454 0 stevel /* XX64 -- definition of 'struct ustat' is strange -- check out the defn */ 455 0 stevel void 456 0 stevel show_ustat(private_t *pri, long offset) 457 0 stevel { 458 0 stevel struct ustat ubuf; 459 0 stevel 460 0 stevel if (offset != NULL && 461 0 stevel Pread(Proc, &ubuf, sizeof (ubuf), offset) == sizeof (ubuf)) { 462 0 stevel (void) printf( 463 7088 raf "%s\ttfree=%-6ld tinode=%-5lu fname=%-6.6s fpack=%-.6s\n", 464 7088 raf pri->pname, 465 7088 raf ubuf.f_tfree, 466 7088 raf ubuf.f_tinode, 467 7088 raf ubuf.f_fname, 468 7088 raf ubuf.f_fpack); 469 0 stevel } 470 0 stevel } 471 0 stevel 472 0 stevel #ifdef _LP64 473 0 stevel void 474 0 stevel show_ustat32(private_t *pri, long offset) 475 0 stevel { 476 0 stevel struct ustat32 ubuf; 477 0 stevel 478 0 stevel if (offset != NULL && 479 0 stevel Pread(Proc, &ubuf, sizeof (ubuf), offset) == sizeof (ubuf)) { 480 0 stevel (void) printf( 481 7088 raf "%s\ttfree=%-6d tinode=%-5u fname=%-6.6s fpack=%-.6s\n", 482 7088 raf pri->pname, 483 7088 raf ubuf.f_tfree, 484 7088 raf ubuf.f_tinode, 485 7088 raf ubuf.f_fname, 486 7088 raf ubuf.f_fpack); 487 0 stevel } 488 0 stevel } 489 0 stevel #endif /* _LP64 */ 490 0 stevel 491 0 stevel void 492 0 stevel show_fusers(private_t *pri, long offset, long nproc) 493 0 stevel { 494 0 stevel f_user_t fubuf; 495 0 stevel int serial = (nproc > 4); 496 0 stevel 497 10440 Roger if (offset == 0) 498 0 stevel return; 499 0 stevel 500 0 stevel /* enter region of lengthy output */ 501 0 stevel if (serial) 502 0 stevel Eserialize(); 503 0 stevel 504 0 stevel while (nproc > 0 && 505 0 stevel Pread(Proc, &fubuf, sizeof (fubuf), offset) == sizeof (fubuf)) { 506 4321 casper (void) printf("%s\tpid=%-5d uid=%-5u flags=%s\n", 507 0 stevel pri->pname, 508 0 stevel (int)fubuf.fu_pid, 509 4321 casper fubuf.fu_uid, 510 0 stevel fuflags(pri, fubuf.fu_flags)); 511 0 stevel nproc--; 512 0 stevel offset += sizeof (fubuf); 513 0 stevel } 514 0 stevel 515 0 stevel /* exit region of lengthy output */ 516 0 stevel if (serial) 517 0 stevel Xserialize(); 518 0 stevel } 519 0 stevel 520 0 stevel void 521 0 stevel show_utssys(private_t *pri, long r0) 522 0 stevel { 523 0 stevel if (pri->sys_nargs >= 3) { 524 0 stevel switch (pri->sys_args[2]) { 525 0 stevel case UTS_UNAME: 526 0 stevel show_uname(pri, (long)pri->sys_args[0]); 527 0 stevel break; 528 0 stevel case UTS_USTAT: 529 0 stevel show_ustat(pri, (long)pri->sys_args[0]); 530 0 stevel break; 531 0 stevel case UTS_FUSERS: 532 0 stevel show_fusers(pri, (long)pri->sys_args[3], r0); 533 0 stevel break; 534 0 stevel } 535 0 stevel } 536 0 stevel } 537 0 stevel 538 0 stevel #ifdef _LP64 539 0 stevel void 540 0 stevel show_utssys32(private_t *pri, long r0) 541 0 stevel { 542 0 stevel if (pri->sys_nargs >= 3) { 543 0 stevel switch (pri->sys_args[2]) { 544 0 stevel case UTS_UNAME: 545 0 stevel show_uname(pri, (long)pri->sys_args[0]); 546 0 stevel break; 547 0 stevel case UTS_USTAT: 548 0 stevel show_ustat32(pri, (long)pri->sys_args[0]); 549 0 stevel break; 550 0 stevel case UTS_FUSERS: 551 0 stevel show_fusers(pri, (long)pri->sys_args[3], r0); 552 0 stevel break; 553 0 stevel } 554 0 stevel } 555 0 stevel } 556 0 stevel #endif /* _LP64 */ 557 0 stevel 558 0 stevel void 559 0 stevel show_cladm(private_t *pri, int code, int function, long offset) 560 0 stevel { 561 0 stevel int arg; 562 0 stevel 563 0 stevel switch (code) { 564 0 stevel case CL_INITIALIZE: 565 0 stevel switch (function) { 566 0 stevel case CL_GET_BOOTFLAG: 567 0 stevel if (Pread(Proc, &arg, sizeof (arg), offset) 568 0 stevel == sizeof (arg)) { 569 0 stevel if (arg & CLUSTER_CONFIGURED) 570 0 stevel (void) printf("%s\tbootflags=" 571 0 stevel "CLUSTER_CONFIGURED", pri->pname); 572 0 stevel if (arg & CLUSTER_BOOTED) 573 0 stevel (void) printf("|CLUSTER_BOOTED\n"); 574 0 stevel } 575 0 stevel break; 576 0 stevel } 577 0 stevel break; 578 0 stevel case CL_CONFIG: 579 0 stevel switch (function) { 580 0 stevel case CL_NODEID: 581 0 stevel case CL_HIGHEST_NODEID: 582 0 stevel if (Pread(Proc, &arg, sizeof (arg), offset) 583 0 stevel == sizeof (arg)) 584 0 stevel (void) printf("%s\tnodeid=%d\n", 585 7088 raf pri->pname, arg); 586 0 stevel } 587 0 stevel break; 588 0 stevel } 589 0 stevel } 590 0 stevel 591 4574 raf #define ALL_LOCK_TYPES \ 592 4574 raf (USYNC_PROCESS | LOCK_ERRORCHECK | LOCK_RECURSIVE | \ 593 4574 raf LOCK_PRIO_INHERIT | LOCK_PRIO_PROTECT | LOCK_ROBUST | \ 594 4574 raf USYNC_PROCESS_ROBUST) 595 0 stevel 596 0 stevel /* return cv and mutex types */ 597 0 stevel const char * 598 0 stevel synch_type(private_t *pri, uint_t type) 599 0 stevel { 600 0 stevel char *str = pri->code_buf; 601 0 stevel 602 0 stevel if (type & USYNC_PROCESS) 603 0 stevel (void) strcpy(str, "USYNC_PROCESS"); 604 0 stevel else 605 0 stevel (void) strcpy(str, "USYNC_THREAD"); 606 0 stevel 607 0 stevel if (type & LOCK_ERRORCHECK) 608 0 stevel (void) strcat(str, "|LOCK_ERRORCHECK"); 609 0 stevel if (type & LOCK_RECURSIVE) 610 0 stevel (void) strcat(str, "|LOCK_RECURSIVE"); 611 0 stevel if (type & LOCK_PRIO_INHERIT) 612 0 stevel (void) strcat(str, "|LOCK_PRIO_INHERIT"); 613 0 stevel if (type & LOCK_PRIO_PROTECT) 614 0 stevel (void) strcat(str, "|LOCK_PRIO_PROTECT"); 615 4574 raf if (type & LOCK_ROBUST) 616 4574 raf (void) strcat(str, "|LOCK_ROBUST"); 617 4574 raf if (type & USYNC_PROCESS_ROBUST) 618 4574 raf (void) strcat(str, "|USYNC_PROCESS_ROBUST"); 619 0 stevel 620 0 stevel if ((type &= ~ALL_LOCK_TYPES) != 0) 621 0 stevel (void) sprintf(str + strlen(str), "|0x%.4X", type); 622 0 stevel 623 0 stevel return ((const char *)str); 624 0 stevel } 625 0 stevel 626 0 stevel void 627 0 stevel show_mutex(private_t *pri, long offset) 628 0 stevel { 629 0 stevel lwp_mutex_t mutex; 630 0 stevel 631 0 stevel if (Pread(Proc, &mutex, sizeof (mutex), offset) == sizeof (mutex)) { 632 0 stevel (void) printf("%s\tmutex type: %s\n", 633 7088 raf pri->pname, 634 7088 raf synch_type(pri, mutex.mutex_type)); 635 0 stevel } 636 0 stevel } 637 0 stevel 638 0 stevel void 639 0 stevel show_condvar(private_t *pri, long offset) 640 0 stevel { 641 0 stevel lwp_cond_t condvar; 642 0 stevel 643 0 stevel if (Pread(Proc, &condvar, sizeof (condvar), offset) 644 0 stevel == sizeof (condvar)) { 645 0 stevel (void) printf("%s\tcondvar type: %s\n", 646 7088 raf pri->pname, 647 7088 raf synch_type(pri, condvar.cond_type)); 648 0 stevel } 649 0 stevel } 650 0 stevel 651 0 stevel void 652 0 stevel show_sema(private_t *pri, long offset) 653 0 stevel { 654 0 stevel lwp_sema_t sema; 655 0 stevel 656 0 stevel if (Pread(Proc, &sema, sizeof (sema), offset) == sizeof (sema)) { 657 0 stevel (void) printf("%s\tsema type: %s count = %u\n", 658 7088 raf pri->pname, 659 7088 raf synch_type(pri, sema.sema_type), 660 7088 raf sema.sema_count); 661 0 stevel } 662 0 stevel } 663 0 stevel 664 0 stevel void 665 0 stevel show_rwlock(private_t *pri, long offset) 666 0 stevel { 667 0 stevel lwp_rwlock_t rwlock; 668 0 stevel 669 0 stevel if (Pread(Proc, &rwlock, sizeof (rwlock), offset) == sizeof (rwlock)) { 670 0 stevel (void) printf("%s\trwlock type: %s readers = %d\n", 671 7088 raf pri->pname, 672 7088 raf synch_type(pri, rwlock.rwlock_type), 673 7088 raf rwlock.rwlock_readers); 674 0 stevel } 675 0 stevel } 676 0 stevel 677 0 stevel /* represent character as itself ('c') or octal (012) */ 678 0 stevel char * 679 0 stevel show_char(char *buf, int c) 680 0 stevel { 681 0 stevel const char *fmt; 682 0 stevel 683 0 stevel if (c >= ' ' && c < 0177) 684 0 stevel fmt = "'%c'"; 685 0 stevel else 686 0 stevel fmt = "%.3o"; 687 0 stevel 688 0 stevel (void) sprintf(buf, fmt, c&0xff); 689 0 stevel return (buf); 690 0 stevel } 691 0 stevel 692 0 stevel void 693 0 stevel show_termio(private_t *pri, long offset) 694 0 stevel { 695 0 stevel struct termio termio; 696 0 stevel char cbuf[8]; 697 0 stevel int i; 698 0 stevel 699 0 stevel if (Pread(Proc, &termio, sizeof (termio), offset) == sizeof (termio)) { 700 0 stevel (void) printf( 701 0 stevel "%s\tiflag=0%.6o oflag=0%.6o cflag=0%.6o lflag=0%.6o line=%d\n", 702 7088 raf pri->pname, 703 7088 raf termio.c_iflag, 704 7088 raf termio.c_oflag, 705 7088 raf termio.c_cflag, 706 7088 raf termio.c_lflag, 707 7088 raf termio.c_line); 708 0 stevel (void) printf("%s\t cc: ", pri->pname); 709 0 stevel for (i = 0; i < NCC; i++) 710 0 stevel (void) printf(" %s", 711 7088 raf show_char(cbuf, (int)termio.c_cc[i])); 712 0 stevel (void) fputc('\n', stdout); 713 0 stevel } 714 0 stevel } 715 0 stevel 716 0 stevel void 717 0 stevel show_termios(private_t *pri, long offset) 718 0 stevel { 719 0 stevel struct termios termios; 720 0 stevel char cbuf[8]; 721 0 stevel int i; 722 0 stevel 723 0 stevel if (Pread(Proc, &termios, sizeof (termios), offset) 724 0 stevel == sizeof (termios)) { 725 0 stevel (void) printf( 726 7088 raf "%s\tiflag=0%.6o oflag=0%.6o cflag=0%.6o lflag=0%.6o\n", 727 7088 raf pri->pname, 728 7088 raf termios.c_iflag, 729 7088 raf termios.c_oflag, 730 7088 raf termios.c_cflag, 731 7088 raf termios.c_lflag); 732 0 stevel (void) printf("%s\t cc: ", pri->pname); 733 0 stevel for (i = 0; i < NCCS; i++) { 734 0 stevel if (i == NCC) /* show new chars on new line */ 735 0 stevel (void) printf("\n%s\t\t", pri->pname); 736 0 stevel (void) printf(" %s", 737 7088 raf show_char(cbuf, (int)termios.c_cc[i])); 738 0 stevel } 739 0 stevel (void) fputc('\n', stdout); 740 0 stevel } 741 0 stevel } 742 0 stevel 743 0 stevel void 744 0 stevel show_termiox(private_t *pri, long offset) 745 0 stevel { 746 0 stevel struct termiox termiox; 747 0 stevel int i; 748 0 stevel 749 0 stevel if (Pread(Proc, &termiox, sizeof (termiox), offset) 750 0 stevel == sizeof (termiox)) { 751 0 stevel (void) printf("%s\thflag=0%.3o cflag=0%.3o rflag=0%.3o", 752 7088 raf pri->pname, 753 7088 raf termiox.x_hflag, 754 7088 raf termiox.x_cflag, 755 7088 raf termiox.x_rflag[0]); 756 0 stevel for (i = 1; i < NFF; i++) 757 0 stevel (void) printf(",0%.3o", termiox.x_rflag[i]); 758 0 stevel (void) printf(" sflag=0%.3o\n", 759 7088 raf termiox.x_sflag); 760 0 stevel } 761 0 stevel } 762 0 stevel 763 0 stevel void 764 0 stevel show_sgttyb(private_t *pri, long offset) 765 0 stevel { 766 0 stevel struct sgttyb sgttyb; 767 0 stevel 768 0 stevel if (Pread(Proc, &sgttyb, sizeof (sgttyb), offset) == sizeof (sgttyb)) { 769 0 stevel char erase[8]; 770 0 stevel char kill[8]; 771 0 stevel 772 0 stevel (void) printf( 773 0 stevel "%s\tispeed=%-2d ospeed=%-2d erase=%s kill=%s flags=0x%.8x\n", 774 7088 raf pri->pname, 775 7088 raf sgttyb.sg_ispeed&0xff, 776 7088 raf sgttyb.sg_ospeed&0xff, 777 7088 raf show_char(erase, sgttyb.sg_erase), 778 7088 raf show_char(kill, sgttyb.sg_kill), 779 7088 raf sgttyb.sg_flags); 780 0 stevel } 781 0 stevel } 782 0 stevel 783 0 stevel void 784 0 stevel show_ltchars(private_t *pri, long offset) 785 0 stevel { 786 0 stevel struct ltchars ltchars; 787 0 stevel char *p; 788 0 stevel char cbuf[8]; 789 0 stevel int i; 790 0 stevel 791 0 stevel if (Pread(Proc, <chars, sizeof (ltchars), offset) 792 0 stevel == sizeof (ltchars)) { 793 0 stevel (void) printf("%s\t cc: ", pri->pname); 794 0 stevel for (p = (char *)<chars, i = 0; i < sizeof (ltchars); i++) 795 0 stevel (void) printf(" %s", show_char(cbuf, (int)*p++)); 796 0 stevel (void) fputc('\n', stdout); 797 0 stevel } 798 0 stevel } 799 0 stevel 800 0 stevel void 801 0 stevel show_tchars(private_t *pri, long offset) 802 0 stevel { 803 0 stevel struct tchars tchars; 804 0 stevel char *p; 805 0 stevel char cbuf[8]; 806 0 stevel int i; 807 0 stevel 808 0 stevel if (Pread(Proc, &tchars, sizeof (tchars), offset) == sizeof (tchars)) { 809 0 stevel (void) printf("%s\t cc: ", pri->pname); 810 0 stevel for (p = (char *)&tchars, i = 0; i < sizeof (tchars); i++) 811 0 stevel (void) printf(" %s", show_char(cbuf, (int)*p++)); 812 0 stevel (void) fputc('\n', stdout); 813 0 stevel } 814 0 stevel } 815 0 stevel 816 0 stevel void 817 0 stevel show_termcb(private_t *pri, long offset) 818 0 stevel { 819 0 stevel struct termcb termcb; 820 0 stevel 821 0 stevel if (Pread(Proc, &termcb, sizeof (termcb), offset) == sizeof (termcb)) { 822 0 stevel (void) printf( 823 7088 raf "%s\tflgs=0%.2o termt=%d crow=%d ccol=%d vrow=%d lrow=%d\n", 824 7088 raf pri->pname, 825 7088 raf termcb.st_flgs&0xff, 826 7088 raf termcb.st_termt&0xff, 827 7088 raf termcb.st_crow&0xff, 828 7088 raf termcb.st_ccol&0xff, 829 7088 raf termcb.st_vrow&0xff, 830 7088 raf termcb.st_lrow&0xff); 831 0 stevel } 832 0 stevel } 833 0 stevel 834 0 stevel /* integer value pointed to by ioctl() arg */ 835 0 stevel void 836 0 stevel show_strint(private_t *pri, int code, long offset) 837 0 stevel { 838 0 stevel int val; 839 0 stevel 840 0 stevel if (Pread(Proc, &val, sizeof (val), offset) == sizeof (val)) { 841 0 stevel const char *s = NULL; 842 0 stevel 843 0 stevel switch (code) { /* interpret these symbolically */ 844 0 stevel case I_GRDOPT: 845 0 stevel s = strrdopt(val); 846 0 stevel break; 847 0 stevel case I_GETSIG: 848 0 stevel s = strevents(pri, val); 849 0 stevel break; 850 0 stevel case TIOCFLUSH: 851 0 stevel s = tiocflush(pri, val); 852 0 stevel break; 853 0 stevel } 854 0 stevel 855 0 stevel if (s == NULL) 856 0 stevel (void) printf("%s\t0x%.8lX: %d\n", 857 7088 raf pri->pname, offset, val); 858 0 stevel else 859 0 stevel (void) printf("%s\t0x%.8lX: %s\n", 860 7088 raf pri->pname, offset, s); 861 0 stevel } 862 0 stevel } 863 0 stevel 864 0 stevel void 865 0 stevel show_strioctl(private_t *pri, long offset) 866 0 stevel { 867 0 stevel struct strioctl strioctl; 868 0 stevel 869 0 stevel if (Pread(Proc, &strioctl, sizeof (strioctl), offset) == 870 0 stevel sizeof (strioctl)) { 871 0 stevel (void) printf( 872 7088 raf "%s\tcmd=%s timout=%d len=%d dp=0x%.8lX\n", 873 7088 raf pri->pname, 874 7088 raf ioctlname(pri, strioctl.ic_cmd), 875 7088 raf strioctl.ic_timout, 876 7088 raf strioctl.ic_len, 877 7088 raf (long)strioctl.ic_dp); 878 0 stevel 879 0 stevel if (pri->recur++ == 0) /* avoid indefinite recursion */ 880 0 stevel show_ioctl(pri, strioctl.ic_cmd, 881 7088 raf (long)strioctl.ic_dp); 882 0 stevel --pri->recur; 883 0 stevel } 884 0 stevel } 885 0 stevel 886 0 stevel #ifdef _LP64 887 0 stevel void 888 0 stevel show_strioctl32(private_t *pri, long offset) 889 0 stevel { 890 0 stevel struct strioctl32 strioctl; 891 0 stevel 892 0 stevel if (Pread(Proc, &strioctl, sizeof (strioctl), offset) == 893 0 stevel sizeof (strioctl)) { 894 0 stevel (void) printf( 895 7088 raf "%s\tcmd=%s timout=%d len=%d dp=0x%.8lX\n", 896 7088 raf pri->pname, 897 7088 raf ioctlname(pri, strioctl.ic_cmd), 898 7088 raf strioctl.ic_timout, 899 7088 raf strioctl.ic_len, 900 7088 raf (long)strioctl.ic_dp); 901 0 stevel 902 0 stevel if (pri->recur++ == 0) /* avoid indefinite recursion */ 903 0 stevel show_ioctl(pri, strioctl.ic_cmd, 904 7088 raf (long)strioctl.ic_dp); 905 0 stevel --pri->recur; 906 0 stevel } 907 0 stevel } 908 0 stevel #endif /* _LP64 */ 909 0 stevel 910 0 stevel void 911 0 stevel print_strbuf(private_t *pri, struct strbuf *sp, const char *name, int dump) 912 0 stevel { 913 0 stevel (void) printf( 914 7088 raf "%s\t%s: maxlen=%-4d len=%-4d buf=0x%.8lX", 915 7088 raf pri->pname, 916 7088 raf name, 917 7088 raf sp->maxlen, 918 7088 raf sp->len, 919 7088 raf (long)sp->buf); 920 0 stevel /* 921 0 stevel * Should we show the buffer contents? 922 0 stevel * Keyed to the '-r fds' and '-w fds' options? 923 0 stevel */ 924 0 stevel if (sp->buf == NULL || sp->len <= 0) 925 0 stevel (void) fputc('\n', stdout); 926 0 stevel else { 927 0 stevel int nb = (sp->len > 8)? 8 : sp->len; 928 0 stevel char buffer[8]; 929 0 stevel char obuf[40]; 930 0 stevel 931 0 stevel if (Pread(Proc, buffer, (size_t)nb, (long)sp->buf) == nb) { 932 0 stevel (void) strcpy(obuf, ": \""); 933 0 stevel showbytes(buffer, nb, obuf+3); 934 0 stevel (void) strcat(obuf, 935 7088 raf (nb == sp->len)? 936 7088 raf (const char *)"\"" : (const char *)"\".."); 937 0 stevel (void) fputs(obuf, stdout); 938 0 stevel } 939 0 stevel (void) fputc('\n', stdout); 940 0 stevel if (dump && sp->len > 8) 941 0 stevel showbuffer(pri, (long)sp->buf, (long)sp->len); 942 0 stevel } 943 0 stevel } 944 0 stevel 945 0 stevel #ifdef _LP64 946 0 stevel void 947 0 stevel print_strbuf32(private_t *pri, struct strbuf32 *sp, const char *name, int dump) 948 0 stevel { 949 0 stevel (void) printf( 950 7088 raf "%s\t%s: maxlen=%-4d len=%-4d buf=0x%.8lX", 951 7088 raf pri->pname, 952 7088 raf name, 953 7088 raf sp->maxlen, 954 7088 raf sp->len, 955 7088 raf (long)sp->buf); 956 0 stevel /* 957 0 stevel * Should we show the buffer contents? 958 0 stevel * Keyed to the '-r fds' and '-w fds' options? 959 0 stevel */ 960 0 stevel if (sp->buf == NULL || sp->len <= 0) 961 0 stevel (void) fputc('\n', stdout); 962 0 stevel else { 963 0 stevel int nb = (sp->len > 8)? 8 : sp->len; 964 0 stevel char buffer[8]; 965 0 stevel char obuf[40]; 966 0 stevel 967 0 stevel if (Pread(Proc, buffer, (size_t)nb, (long)sp->buf) == nb) { 968 0 stevel (void) strcpy(obuf, ": \""); 969 0 stevel showbytes(buffer, nb, obuf+3); 970 0 stevel (void) strcat(obuf, 971 7088 raf (nb == sp->len)? 972 7088 raf (const char *)"\"" : (const char *)"\".."); 973 0 stevel (void) fputs(obuf, stdout); 974 0 stevel } 975 0 stevel (void) fputc('\n', stdout); 976 0 stevel if (dump && sp->len > 8) 977 0 stevel showbuffer(pri, (long)sp->buf, (long)sp->len); 978 0 stevel } 979 0 stevel } 980 0 stevel #endif /* _LP64 */ 981 0 stevel 982 0 stevel /* strpeek and strfdinsert flags word */ 983 0 stevel const char * 984 0 stevel strflags(private_t *pri, int flags) 985 0 stevel { 986 0 stevel const char *s; 987 0 stevel 988 0 stevel switch (flags) { 989 0 stevel case 0: 990 0 stevel s = "0"; 991 0 stevel break; 992 0 stevel case RS_HIPRI: 993 0 stevel s = "RS_HIPRI"; 994 0 stevel break; 995 0 stevel default: 996 0 stevel (void) sprintf(pri->code_buf, "0x%.4X", flags); 997 0 stevel s = pri->code_buf; 998 0 stevel } 999 0 stevel 1000 0 stevel return (s); 1001 0 stevel } 1002 0 stevel 1003 0 stevel void 1004 0 stevel show_strpeek(private_t *pri, long offset) 1005 0 stevel { 1006 0 stevel struct strpeek strpeek; 1007 0 stevel 1008 0 stevel if (Pread(Proc, &strpeek, sizeof (strpeek), offset) 1009 0 stevel == sizeof (strpeek)) { 1010 0 stevel 1011 0 stevel print_strbuf(pri, &strpeek.ctlbuf, "ctl", FALSE); 1012 0 stevel print_strbuf(pri, &strpeek.databuf, "dat", FALSE); 1013 0 stevel 1014 0 stevel (void) printf("%s\tflags=%s\n", 1015 7088 raf pri->pname, 1016 7088 raf strflags(pri, strpeek.flags)); 1017 0 stevel } 1018 0 stevel } 1019 0 stevel 1020 0 stevel #ifdef _LP64 1021 0 stevel void 1022 0 stevel show_strpeek32(private_t *pri, long offset) 1023 0 stevel { 1024 0 stevel struct strpeek32 strpeek; 1025 0 stevel 1026 0 stevel if (Pread(Proc, &strpeek, sizeof (strpeek), offset) 1027 0 stevel == sizeof (strpeek)) { 1028 0 stevel 1029 0 stevel print_strbuf32(pri, &strpeek.ctlbuf, "ctl", FALSE); 1030 0 stevel print_strbuf32(pri, &strpeek.databuf, "dat", FALSE); 1031 0 stevel 1032 0 stevel (void) printf("%s\tflags=%s\n", 1033 7088 raf pri->pname, 1034 7088 raf strflags(pri, strpeek.flags)); 1035 0 stevel } 1036 0 stevel } 1037 0 stevel #endif /* _LP64 */ 1038 0 stevel 1039 0 stevel void 1040 0 stevel show_strfdinsert(private_t *pri, long offset) 1041 0 stevel { 1042 0 stevel struct strfdinsert strfdinsert; 1043 0 stevel 1044 0 stevel if (Pread(Proc, &strfdinsert, sizeof (strfdinsert), offset) == 1045 0 stevel sizeof (strfdinsert)) { 1046 0 stevel 1047 0 stevel print_strbuf(pri, &strfdinsert.ctlbuf, "ctl", FALSE); 1048 0 stevel print_strbuf(pri, &strfdinsert.databuf, "dat", FALSE); 1049 0 stevel 1050 0 stevel (void) printf("%s\tflags=%s fildes=%d offset=%d\n", 1051 7088 raf pri->pname, 1052 7088 raf strflags(pri, strfdinsert.flags), 1053 7088 raf strfdinsert.fildes, 1054 7088 raf strfdinsert.offset); 1055 0 stevel } 1056 0 stevel } 1057 0 stevel 1058 0 stevel #ifdef _LP64 1059 0 stevel void 1060 0 stevel show_strfdinsert32(private_t *pri, long offset) 1061 0 stevel { 1062 0 stevel struct strfdinsert32 strfdinsert; 1063 0 stevel 1064 0 stevel if (Pread(Proc, &strfdinsert, sizeof (strfdinsert), offset) == 1065 0 stevel sizeof (strfdinsert)) { 1066 0 stevel 1067 0 stevel print_strbuf32(pri, &strfdinsert.ctlbuf, "ctl", FALSE); 1068 0 stevel print_strbuf32(pri, &strfdinsert.databuf, "dat", FALSE); 1069 0 stevel 1070 0 stevel (void) printf("%s\tflags=%s fildes=%d offset=%d\n", 1071 7088 raf pri->pname, 1072 7088 raf strflags(pri, strfdinsert.flags), 1073 7088 raf strfdinsert.fildes, 1074 7088 raf strfdinsert.offset); 1075 0 stevel } 1076 0 stevel } 1077 0 stevel #endif /* _LP64 */ 1078 0 stevel 1079 0 stevel void 1080 0 stevel show_strrecvfd(private_t *pri, long offset) 1081 0 stevel { 1082 0 stevel struct strrecvfd strrecvfd; 1083 0 stevel 1084 0 stevel if (Pread(Proc, &strrecvfd, sizeof (strrecvfd), offset) == 1085 0 stevel sizeof (strrecvfd)) { 1086 0 stevel (void) printf( 1087 7088 raf "%s\tfd=%-5d uid=%-5u gid=%u\n", 1088 7088 raf pri->pname, 1089 7088 raf strrecvfd.fd, 1090 7088 raf strrecvfd.uid, 1091 7088 raf strrecvfd.gid); 1092 0 stevel } 1093 0 stevel } 1094 0 stevel 1095 0 stevel void 1096 0 stevel show_strlist(private_t *pri, long offset) 1097 0 stevel { 1098 0 stevel struct str_list strlist; 1099 0 stevel struct str_mlist list; 1100 0 stevel int count; 1101 0 stevel 1102 0 stevel if (Pread(Proc, &strlist, sizeof (strlist), offset) == 1103 0 stevel sizeof (strlist)) { 1104 0 stevel (void) printf("%s\tnmods=%d modlist=0x%.8lX\n", 1105 7088 raf pri->pname, 1106 7088 raf strlist.sl_nmods, 1107 7088 raf (long)strlist.sl_modlist); 1108 0 stevel 1109 0 stevel count = strlist.sl_nmods; 1110 0 stevel offset = (long)strlist.sl_modlist; 1111 0 stevel while (!interrupt && --count >= 0) { 1112 0 stevel if (Pread(Proc, &list, sizeof (list), offset) != 1113 0 stevel sizeof (list)) 1114 0 stevel break; 1115 0 stevel (void) printf("%s\t\t\"%.*s\"\n", 1116 7088 raf pri->pname, 1117 7088 raf (int)sizeof (list.l_name), 1118 7088 raf list.l_name); 1119 0 stevel offset += sizeof (struct str_mlist); 1120 0 stevel } 1121 0 stevel } 1122 0 stevel } 1123 0 stevel 1124 0 stevel #ifdef _LP64 1125 0 stevel void 1126 0 stevel show_strlist32(private_t *pri, long offset) 1127 0 stevel { 1128 0 stevel struct str_list32 strlist; 1129 0 stevel struct str_mlist list; 1130 0 stevel int count; 1131 0 stevel 1132 0 stevel if (Pread(Proc, &strlist, sizeof (strlist), offset) == 1133 0 stevel sizeof (strlist)) { 1134 0 stevel (void) printf("%s\tnmods=%d modlist=0x%.8lX\n", 1135 7088 raf pri->pname, 1136 7088 raf strlist.sl_nmods, 1137 7088 raf (long)strlist.sl_modlist); 1138 0 stevel 1139 0 stevel count = strlist.sl_nmods; 1140 0 stevel offset = (long)strlist.sl_modlist; 1141 0 stevel while (!interrupt && --count >= 0) { 1142 0 stevel if (Pread(Proc, &list, sizeof (list), offset) != 1143 0 stevel sizeof (list)) 1144 0 stevel break; 1145 0 stevel (void) printf("%s\t\t\"%.*s\"\n", 1146 7088 raf pri->pname, 1147 7088 raf (int)sizeof (list.l_name), 1148 7088 raf list.l_name); 1149 0 stevel offset += sizeof (struct str_mlist); 1150 0 stevel } 1151 0 stevel } 1152 0 stevel } 1153 0 stevel #endif /* _LP64 */ 1154 0 stevel 1155 0 stevel void 1156 0 stevel show_jwinsize(private_t *pri, long offset) 1157 0 stevel { 1158 0 stevel struct jwinsize jwinsize; 1159 0 stevel 1160 0 stevel if (Pread(Proc, &jwinsize, sizeof (jwinsize), offset) == 1161 0 stevel sizeof (jwinsize)) { 1162 0 stevel (void) printf( 1163 7088 raf "%s\tbytesx=%-3u bytesy=%-3u bitsx=%-3u bitsy=%-3u\n", 1164 7088 raf pri->pname, 1165 7088 raf (unsigned)jwinsize.bytesx, 1166 7088 raf (unsigned)jwinsize.bytesy, 1167 7088 raf (unsigned)jwinsize.bitsx, 1168 7088 raf (unsigned)jwinsize.bitsy); 1169 0 stevel } 1170 0 stevel } 1171 0 stevel 1172 0 stevel void 1173 0 stevel show_winsize(private_t *pri, long offset) 1174 0 stevel { 1175 0 stevel struct winsize winsize; 1176 0 stevel 1177 0 stevel if (Pread(Proc, &winsize, sizeof (winsize), offset) 1178 0 stevel == sizeof (winsize)) { 1179 0 stevel (void) printf( 1180 7088 raf "%s\trow=%-3d col=%-3d xpixel=%-3d ypixel=%-3d\n", 1181 7088 raf pri->pname, 1182 7088 raf winsize.ws_row, 1183 7088 raf winsize.ws_col, 1184 7088 raf winsize.ws_xpixel, 1185 7088 raf winsize.ws_ypixel); 1186 0 stevel } 1187 0 stevel } 1188 0 stevel 1189 0 stevel struct audio_stuff { 1190 0 stevel uint_t bit; 1191 0 stevel const char *str; 1192 0 stevel }; 1193 0 stevel 1194 0 stevel const struct audio_stuff audio_output_ports[] = { 1195 0 stevel { AUDIO_SPEAKER, "SPEAKER" }, 1196 0 stevel { AUDIO_HEADPHONE, "HEADPHONE" }, 1197 0 stevel { AUDIO_LINE_OUT, "LINE_OUT" }, 1198 0 stevel { AUDIO_SPDIF_OUT, "SPDIF_OUT" }, 1199 0 stevel { AUDIO_AUX1_OUT, "AUX1_OUT" }, 1200 0 stevel { AUDIO_AUX2_OUT, "AUX2_OUT" }, 1201 0 stevel { 0, NULL } 1202 0 stevel }; 1203 0 stevel 1204 0 stevel const struct audio_stuff audio_input_ports[] = { 1205 0 stevel { AUDIO_MICROPHONE, "MICROPHONE" }, 1206 0 stevel { AUDIO_LINE_IN, "LINE_IN" }, 1207 0 stevel { AUDIO_CD, "CD" }, 1208 0 stevel { AUDIO_SPDIF_IN, "SPDIF_IN" }, 1209 0 stevel { AUDIO_AUX1_IN, "AUX1_IN" }, 1210 0 stevel { AUDIO_AUX2_IN, "AUX2_IN" }, 1211 0 stevel { AUDIO_CODEC_LOOPB_IN, "CODEC_LOOPB_IN" }, 1212 0 stevel { AUDIO_SUNVTS, "SUNVTS" }, 1213 0 stevel { 0, NULL } 1214 0 stevel }; 1215 0 stevel 1216 0 stevel static const struct audio_stuff audio_hw_features[] = { 1217 0 stevel { AUDIO_HWFEATURE_DUPLEX, "DUPLEX" }, 1218 0 stevel { AUDIO_HWFEATURE_MSCODEC, "MSCODEC" }, 1219 0 stevel { AUDIO_HWFEATURE_IN2OUT, "IN2OUT" }, 1220 0 stevel { AUDIO_HWFEATURE_PLAY, "PLAY" }, 1221 0 stevel { AUDIO_HWFEATURE_RECORD, "RECORD" }, 1222 0 stevel { 0, NULL } 1223 0 stevel }; 1224 0 stevel 1225 0 stevel static const struct audio_stuff audio_sw_features[] = { 1226 0 stevel { AUDIO_SWFEATURE_MIXER, "MIXER" }, 1227 0 stevel { 0, NULL } 1228 0 stevel }; 1229 0 stevel 1230 0 stevel void 1231 0 stevel show_audio_features(const private_t *pri, 1232 0 stevel const struct audio_stuff *audio_porttab, uint_t features, 1233 0 stevel const char *name) 1234 0 stevel { 1235 0 stevel (void) printf("%s\t%s=", pri->pname, name); 1236 0 stevel if (features == 0) { 1237 0 stevel (void) printf("0\n"); 1238 0 stevel return; 1239 0 stevel } 1240 0 stevel 1241 0 stevel for (; audio_porttab->bit != 0; ++audio_porttab) { 1242 0 stevel if (features & audio_porttab->bit) { 1243 0 stevel (void) printf(audio_porttab->str); 1244 0 stevel features &= ~audio_porttab->bit; 1245 0 stevel if (features) 1246 0 stevel (void) putchar('|'); 1247 0 stevel } 1248 0 stevel } 1249 0 stevel if (features) 1250 0 stevel (void) printf("0x%x", features); 1251 0 stevel (void) putchar('\n'); 1252 0 stevel } 1253 0 stevel 1254 0 stevel void 1255 0 stevel show_audio_ports(private_t *pri, const char *mode, 1256 0 stevel const char *field, uint_t ports) 1257 0 stevel { 1258 0 stevel const struct audio_stuff *audio_porttab; 1259 0 stevel 1260 0 stevel (void) printf("%s\t%s\t%s=", pri->pname, mode, field); 1261 0 stevel if (ports == 0) { 1262 0 stevel (void) printf("0\n"); 1263 0 stevel return; 1264 0 stevel } 1265 0 stevel if (*mode == 'p') 1266 0 stevel audio_porttab = audio_output_ports; 1267 0 stevel else 1268 0 stevel audio_porttab = audio_input_ports; 1269 0 stevel for (; audio_porttab->bit != 0; ++audio_porttab) { 1270 0 stevel if (ports & audio_porttab->bit) { 1271 0 stevel (void) printf(audio_porttab->str); 1272 0 stevel ports &= ~audio_porttab->bit; 1273 0 stevel if (ports) 1274 0 stevel (void) putchar('|'); 1275 0 stevel } 1276 0 stevel } 1277 0 stevel if (ports) 1278 0 stevel (void) printf("0x%x", ports); 1279 0 stevel (void) putchar('\n'); 1280 0 stevel } 1281 0 stevel 1282 0 stevel void 1283 0 stevel show_audio_prinfo(private_t *pri, const char *mode, struct audio_prinfo *au_pr) 1284 0 stevel { 1285 0 stevel const char *s; 1286 0 stevel 1287 0 stevel /* 1288 0 stevel * The following values describe the audio data encoding. 1289 0 stevel */ 1290 0 stevel 1291 0 stevel (void) printf("%s\t%s\tsample_rate=%u channels=%u precision=%u\n", 1292 7088 raf pri->pname, mode, 1293 7088 raf au_pr->sample_rate, 1294 7088 raf au_pr->channels, 1295 7088 raf au_pr->precision); 1296 0 stevel 1297 0 stevel s = NULL; 1298 0 stevel switch (au_pr->encoding) { 1299 0 stevel case AUDIO_ENCODING_NONE: s = "NONE"; break; 1300 0 stevel case AUDIO_ENCODING_ULAW: s = "ULAW"; break; 1301 0 stevel case AUDIO_ENCODING_ALAW: s = "ALAW"; break; 1302 0 stevel case AUDIO_ENCODING_LINEAR: s = "LINEAR"; break; 1303 0 stevel case AUDIO_ENCODING_DVI: s = "DVI"; break; 1304 0 stevel case AUDIO_ENCODING_LINEAR8: s = "LINEAR8"; break; 1305 0 stevel } 1306 0 stevel if (s) 1307 0 stevel (void) printf("%s\t%s\tencoding=%s\n", pri->pname, mode, s); 1308 0 stevel else { 1309 0 stevel (void) printf("%s\t%s\tencoding=%u\n", 1310 7088 raf pri->pname, mode, au_pr->encoding); 1311 0 stevel } 1312 0 stevel 1313 0 stevel /* 1314 0 stevel * The following values control audio device configuration 1315 0 stevel */ 1316 0 stevel 1317 0 stevel (void) printf( 1318 7088 raf "%s\t%s\tgain=%u buffer_size=%u\n", 1319 7088 raf pri->pname, mode, 1320 7088 raf au_pr->gain, 1321 7088 raf au_pr->buffer_size); 1322 0 stevel show_audio_ports(pri, mode, "port", au_pr->port); 1323 0 stevel show_audio_ports(pri, mode, "avail_ports", au_pr->avail_ports); 1324 0 stevel show_audio_ports(pri, mode, "mod_ports", au_pr->mod_ports); 1325 0 stevel 1326 0 stevel /* 1327 0 stevel * The following values describe driver state 1328 0 stevel */ 1329 0 stevel 1330 0 stevel (void) printf("%s\t%s\tsamples=%u eof=%u pause=%u error=%u\n", 1331 7088 raf pri->pname, mode, 1332 7088 raf au_pr->samples, 1333 7088 raf au_pr->eof, 1334 7088 raf au_pr->pause, 1335 7088 raf au_pr->error); 1336 0 stevel (void) printf("%s\t%s\twaiting=%u balance=%u minordev=%u\n", 1337 7088 raf pri->pname, mode, 1338 7088 raf au_pr->waiting, 1339 7088 raf au_pr->balance, 1340 7088 raf au_pr->minordev); 1341 0 stevel 1342 0 stevel /* 1343 0 stevel * The following values are read-only state flags 1344 0 stevel */ 1345 0 stevel (void) printf("%s\t%s\topen=%u active=%u\n", 1346 7088 raf pri->pname, mode, 1347 7088 raf au_pr->open, 1348 7088 raf au_pr->active); 1349 0 stevel } 1350 0 stevel 1351 0 stevel void 1352 0 stevel show_audio_info(private_t *pri, long offset) 1353 0 stevel { 1354 0 stevel struct audio_info au; 1355 0 stevel 1356 0 stevel if (Pread(Proc, &au, sizeof (au), offset) == sizeof (au)) { 1357 0 stevel show_audio_prinfo(pri, "play", &au.play); 1358 0 stevel show_audio_prinfo(pri, "record", &au.record); 1359 0 stevel (void) printf("%s\tmonitor_gain=%u output_muted=%u\n", 1360 7088 raf pri->pname, au.monitor_gain, au.output_muted); 1361 0 stevel show_audio_features(pri, audio_hw_features, au.hw_features, 1362 0 stevel "hw_features"); 1363 0 stevel show_audio_features(pri, audio_sw_features, au.sw_features, 1364 0 stevel "sw_features"); 1365 0 stevel show_audio_features(pri, audio_sw_features, 1366 0 stevel au.sw_features_enabled, "sw_features_enabled"); 1367 0 stevel } 1368 0 stevel } 1369 0 stevel 1370 0 stevel void 1371 0 stevel show_ioctl(private_t *pri, int code, long offset) 1372 0 stevel { 1373 0 stevel int lp64 = (data_model == PR_MODEL_LP64); 1374 0 stevel int err = pri->Errno; /* don't display output parameters */ 1375 0 stevel /* for a failed system call */ 1376 0 stevel #ifndef _LP64 1377 0 stevel if (lp64) 1378 0 stevel return; 1379 0 stevel #endif 1380 10440 Roger if (offset == 0) 1381 0 stevel return; 1382 0 stevel 1383 0 stevel switch (code) { 1384 0 stevel case TCGETA: 1385 0 stevel if (err) 1386 0 stevel break; 1387 0 stevel /*FALLTHROUGH*/ 1388 0 stevel case TCSETA: 1389 0 stevel case TCSETAW: 1390 0 stevel case TCSETAF: 1391 0 stevel show_termio(pri, offset); 1392 0 stevel break; 1393 0 stevel case TCGETS: 1394 0 stevel if (err) 1395 0 stevel break; 1396 0 stevel /*FALLTHROUGH*/ 1397 0 stevel case TCSETS: 1398 0 stevel case TCSETSW: 1399 0 stevel case TCSETSF: 1400 0 stevel show_termios(pri, offset); 1401 0 stevel break; 1402 0 stevel case TCGETX: 1403 0 stevel if (err) 1404 0 stevel break; 1405 0 stevel /*FALLTHROUGH*/ 1406 0 stevel case TCSETX: 1407 0 stevel case TCSETXW: 1408 0 stevel case TCSETXF: 1409 0 stevel show_termiox(pri, offset); 1410 0 stevel break; 1411 0 stevel case TIOCGETP: 1412 0 stevel if (err) 1413 0 stevel break; 1414 0 stevel /*FALLTHROUGH*/ 1415 0 stevel case TIOCSETN: 1416 0 stevel case TIOCSETP: 1417 0 stevel show_sgttyb(pri, offset); 1418 0 stevel break; 1419 0 stevel case TIOCGLTC: 1420 0 stevel if (err) 1421 0 stevel break; 1422 0 stevel /*FALLTHROUGH*/ 1423 0 stevel case TIOCSLTC: 1424 0 stevel show_ltchars(pri, offset); 1425 0 stevel break; 1426 0 stevel case TIOCGETC: 1427 0 stevel if (err) 1428 0 stevel break; 1429 0 stevel /*FALLTHROUGH*/ 1430 0 stevel case TIOCSETC: 1431 0 stevel show_tchars(pri, offset); 1432 0 stevel break; 1433 0 stevel case LDGETT: 1434 0 stevel if (err) 1435 0 stevel break; 1436 0 stevel /*FALLTHROUGH*/ 1437 0 stevel case LDSETT: 1438 0 stevel show_termcb(pri, offset); 1439 0 stevel break; 1440 0 stevel /* streams ioctl()s */ 1441 0 stevel #if 0 1442 0 stevel /* these are displayed as strings in the arg list */ 1443 0 stevel /* by prt_ioa(). don't display them again here */ 1444 0 stevel case I_PUSH: 1445 0 stevel case I_LOOK: 1446 0 stevel case I_FIND: 1447 0 stevel /* these are displayed as decimal in the arg list */ 1448 0 stevel /* by prt_ioa(). don't display them again here */ 1449 0 stevel case I_LINK: 1450 0 stevel case I_UNLINK: 1451 0 stevel case I_SENDFD: 1452 0 stevel /* these are displayed symbolically in the arg list */ 1453 0 stevel /* by prt_ioa(). don't display them again here */ 1454 0 stevel case I_SRDOPT: 1455 0 stevel case I_SETSIG: 1456 0 stevel case I_FLUSH: 1457 0 stevel break; 1458 0 stevel /* this one just ignores the argument */ 1459 0 stevel case I_POP: 1460 0 stevel break; 1461 0 stevel #endif 1462 0 stevel /* these return something in an int pointed to by arg */ 1463 0 stevel case I_NREAD: 1464 0 stevel case I_GRDOPT: 1465 0 stevel case I_GETSIG: 1466 0 stevel case TIOCGSID: 1467 0 stevel case TIOCGPGRP: 1468 0 stevel case TIOCLGET: 1469 0 stevel case FIONREAD: 1470 0 stevel case FIORDCHK: 1471 0 stevel if (err) 1472 0 stevel break; 1473 0 stevel /*FALLTHROUGH*/ 1474 0 stevel /* these pass something in an int pointed to by arg */ 1475 0 stevel case TIOCSPGRP: 1476 0 stevel case TIOCFLUSH: 1477 0 stevel case TIOCLBIS: 1478 0 stevel case TIOCLBIC: 1479 0 stevel case TIOCLSET: 1480 0 stevel show_strint(pri, code, offset); 1481 0 stevel break; 1482 0 stevel /* these all point to structures */ 1483 0 stevel case I_STR: 1484 0 stevel #ifdef _LP64 1485 0 stevel if (lp64) 1486 0 stevel show_strioctl(pri, offset); 1487 0 stevel else 1488 0 stevel show_strioctl32(pri, offset); 1489 0 stevel #else 1490 0 stevel show_strioctl(pri, offset); 1491 0 stevel #endif 1492 0 stevel break; 1493 0 stevel case I_PEEK: 1494 0 stevel #ifdef _LP64 1495 0 stevel if (lp64) 1496 0 stevel show_strpeek(pri, offset); 1497 0 stevel else 1498 0 stevel show_strpeek32(pri, offset); 1499 0 stevel #else 1500 0 stevel show_strpeek(pri, offset); 1501 0 stevel #endif 1502 0 stevel break; 1503 0 stevel case I_FDINSERT: 1504 0 stevel #ifdef _LP64 1505 0 stevel if (lp64) 1506 0 stevel show_strfdinsert(pri, offset); 1507 0 stevel else 1508 0 stevel show_strfdinsert32(pri, offset); 1509 0 stevel #else 1510 0 stevel show_strfdinsert(pri, offset); 1511 0 stevel #endif 1512 0 stevel break; 1513 0 stevel case I_RECVFD: 1514 0 stevel if (err) 1515 0 stevel break; 1516 0 stevel show_strrecvfd(pri, offset); 1517 0 stevel break; 1518 0 stevel case I_LIST: 1519 0 stevel if (err) 1520 0 stevel break; 1521 0 stevel #ifdef _LP64 1522 0 stevel if (lp64) 1523 0 stevel show_strlist(pri, offset); 1524 0 stevel else 1525 0 stevel show_strlist32(pri, offset); 1526 0 stevel #else 1527 0 stevel show_strlist(pri, offset); 1528 0 stevel #endif 1529 0 stevel break; 1530 0 stevel case JWINSIZE: 1531 0 stevel if (err) 1532 0 stevel break; 1533 0 stevel show_jwinsize(pri, offset); 1534 0 stevel break; 1535 0 stevel case TIOCGWINSZ: 1536 0 stevel if (err) 1537 0 stevel break; 1538 0 stevel /*FALLTHROUGH*/ 1539 0 stevel case TIOCSWINSZ: 1540 0 stevel show_winsize(pri, offset); 1541 0 stevel break; 1542 0 stevel case AUDIO_GETINFO: 1543 0 stevel case (int)AUDIO_SETINFO: 1544 0 stevel show_audio_info(pri, offset); 1545 0 stevel break; 1546 0 stevel 1547 0 stevel default: 1548 0 stevel if (code & IOC_INOUT) { 1549 0 stevel const char *str = ioctldatastruct(code); 1550 0 stevel 1551 0 stevel (void) printf("\t\t%s", 1552 0 stevel (code & IOC_INOUT) == IOC_INOUT ? "write/read" : 1553 0 stevel code & IOC_IN ? "write" : "read"); 1554 0 stevel if (str != NULL) { 1555 0 stevel (void) printf(" (struct %s)\n", str); 1556 0 stevel } else { 1557 0 stevel (void) printf(" %d bytes\n", 1558 0 stevel (code >> 16) & IOCPARM_MASK); 1559 0 stevel } 1560 0 stevel } 1561 0 stevel } 1562 0 stevel } 1563 0 stevel 1564 0 stevel void 1565 0 stevel show_statvfs(private_t *pri) 1566 0 stevel { 1567 0 stevel long offset; 1568 0 stevel struct statvfs statvfs; 1569 0 stevel char *cp; 1570 0 stevel 1571 0 stevel if (pri->sys_nargs > 1 && (offset = pri->sys_args[1]) != NULL && 1572 0 stevel Pread(Proc, &statvfs, sizeof (statvfs), offset) 1573 0 stevel == sizeof (statvfs)) { 1574 0 stevel (void) printf( 1575 0 stevel "%s\tbsize=%-10lu frsize=%-9lu blocks=%-8llu bfree=%-9llu\n", 1576 7088 raf pri->pname, 1577 7088 raf statvfs.f_bsize, 1578 7088 raf statvfs.f_frsize, 1579 7088 raf (u_longlong_t)statvfs.f_blocks, 1580 7088 raf (u_longlong_t)statvfs.f_bfree); 1581 0 stevel (void) printf( 1582 0 stevel "%s\tbavail=%-9llu files=%-10llu ffree=%-9llu favail=%-9llu\n", 1583 7088 raf pri->pname, 1584 7088 raf (u_longlong_t)statvfs.f_bavail, 1585 7088 raf (u_longlong_t)statvfs.f_files, 1586 7088 raf (u_longlong_t)statvfs.f_ffree, 1587 7088 raf (u_longlong_t)statvfs.f_favail); 1588 7088 raf (void) printf( 1589 7088 raf "%s\tfsid=0x%-9.4lX basetype=%-7.16s namemax=%ld\n", 1590 7088 raf pri->pname, 1591 7088 raf statvfs.f_fsid, 1592 7088 raf statvfs.f_basetype, 1593 7088 raf (long)statvfs.f_namemax); 1594 7088 raf (void) printf( 1595 7088 raf "%s\tflag=%s\n", 1596 7088 raf pri->pname, 1597 7088 raf svfsflags(pri, (ulong_t)statvfs.f_flag)); 1598 0 stevel cp = statvfs.f_fstr + strlen(statvfs.f_fstr); 1599 0 stevel if (cp < statvfs.f_fstr + sizeof (statvfs.f_fstr) - 1 && 1600 0 stevel *(cp+1) != '\0') 1601 0 stevel *cp = ' '; 1602 0 stevel (void) printf("%s\tfstr=\"%.*s\"\n", 1603 7088 raf pri->pname, 1604 7088 raf (int)sizeof (statvfs.f_fstr), 1605 7088 raf statvfs.f_fstr); 1606 0 stevel } 1607 0 stevel } 1608 0 stevel 1609 0 stevel #ifdef _LP64 1610 0 stevel void 1611 0 stevel show_statvfs32(private_t *pri) 1612 0 stevel { 1613 0 stevel long offset; 1614 0 stevel struct statvfs32 statvfs; 1615 0 stevel char *cp; 1616 0 stevel 1617 0 stevel if (pri->sys_nargs > 1 && (offset = pri->sys_args[1]) != NULL && 1618 0 stevel Pread(Proc, &statvfs, sizeof (statvfs), offset) 1619 0 stevel == sizeof (statvfs)) { 1620 0 stevel (void) printf( 1621 7088 raf "%s\tbsize=%-10u frsize=%-9u blocks=%-8u bfree=%-9u\n", 1622 7088 raf pri->pname, 1623 7088 raf statvfs.f_bsize, 1624 7088 raf statvfs.f_frsize, 1625 7088 raf statvfs.f_blocks, 1626 7088 raf statvfs.f_bfree); 1627 7088 raf (void) printf( 1628 7088 raf "%s\tbavail=%-9u files=%-10u ffree=%-9u favail=%-9u\n", 1629 7088 raf pri->pname, 1630 7088 raf statvfs.f_bavail, 1631 7088 raf statvfs.f_files, 1632 7088 raf statvfs.f_ffree, 1633 7088 raf statvfs.f_favail); 1634 7088 raf (void) printf( 1635 7088 raf "%s\tfsid=0x%-9.4X basetype=%-7.16s namemax=%d\n", 1636 7088 raf pri->pname, 1637 7088 raf statvfs.f_fsid, 1638 7088 raf statvfs.f_basetype, 1639 7088 raf (int)statvfs.f_namemax); 1640 7088 raf (void) printf( 1641 7088 raf "%s\tflag=%s\n", 1642 7088 raf pri->pname, 1643 7088 raf svfsflags(pri, (ulong_t)statvfs.f_flag)); 1644 0 stevel cp = statvfs.f_fstr + strlen(statvfs.f_fstr); 1645 0 stevel if (cp < statvfs.f_fstr + sizeof (statvfs.f_fstr) - 1 && 1646 0 stevel *(cp+1) != '\0') 1647 0 stevel *cp = ' '; 1648 0 stevel (void) printf("%s\tfstr=\"%.*s\"\n", 1649 7088 raf pri->pname, 1650 7088 raf (int)sizeof (statvfs.f_fstr), 1651 7088 raf statvfs.f_fstr); 1652 0 stevel } 1653 0 stevel } 1654 0 stevel #endif /* _LP64 */ 1655 0 stevel 1656 0 stevel void 1657 0 stevel show_statvfs64(private_t *pri) 1658 0 stevel { 1659 0 stevel long offset; 1660 0 stevel struct statvfs64_32 statvfs; 1661 0 stevel char *cp; 1662 0 stevel 1663 0 stevel if (pri->sys_nargs > 1 && (offset = pri->sys_args[1]) != NULL && 1664 0 stevel Pread(Proc, &statvfs, sizeof (statvfs), offset) 1665 0 stevel == sizeof (statvfs)) { 1666 0 stevel (void) printf( 1667 7088 raf "%s\tbsize=%-10u frsize=%-9u blocks=%-8llu bfree=%-9llu\n", 1668 7088 raf pri->pname, 1669 7088 raf statvfs.f_bsize, 1670 7088 raf statvfs.f_frsize, 1671 7088 raf (u_longlong_t)statvfs.f_blocks, 1672 7088 raf (u_longlong_t)statvfs.f_bfree); 1673 0 stevel (void) printf( 1674 0 stevel "%s\tbavail=%-9llu files=%-10llu ffree=%-9llu favail=%-9llu\n", 1675 7088 raf pri->pname, 1676 7088 raf (u_longlong_t)statvfs.f_bavail, 1677 7088 raf (u_longlong_t)statvfs.f_files, 1678 7088 raf (u_longlong_t)statvfs.f_ffree, 1679 7088 raf (u_longlong_t)statvfs.f_favail); 1680 7088 raf (void) printf( 1681 7088 raf "%s\tfsid=0x%-9.4X basetype=%-7.16s namemax=%d\n", 1682 7088 raf pri->pname, 1683 7088 raf statvfs.f_fsid, 1684 7088 raf statvfs.f_basetype, 1685 7088 raf (int)statvfs.f_namemax); 1686 7088 raf (void) printf( 1687 7088 raf "%s\tflag=%s\n", 1688 7088 raf pri->pname, 1689 7088 raf svfsflags(pri, (ulong_t)statvfs.f_flag)); 1690 0 stevel cp = statvfs.f_fstr + strlen(statvfs.f_fstr); 1691 0 stevel if (cp < statvfs.f_fstr + sizeof (statvfs.f_fstr) - 1 && 1692 0 stevel *(cp+1) != '\0') 1693 0 stevel *cp = ' '; 1694 0 stevel (void) printf("%s\tfstr=\"%.*s\"\n", 1695 7088 raf pri->pname, 1696 7088 raf (int)sizeof (statvfs.f_fstr), 1697 7088 raf statvfs.f_fstr); 1698 0 stevel } 1699 0 stevel } 1700 0 stevel 1701 0 stevel void 1702 0 stevel show_statfs(private_t *pri) 1703 0 stevel { 1704 0 stevel long offset; 1705 0 stevel struct statfs statfs; 1706 0 stevel 1707 0 stevel if (pri->sys_nargs >= 2 && (offset = pri->sys_args[1]) != NULL && 1708 0 stevel Pread(Proc, &statfs, sizeof (statfs), offset) == sizeof (statfs)) { 1709 0 stevel (void) printf( 1710 0 stevel "%s\tfty=%d bsz=%ld fsz=%ld blk=%ld bfr=%ld fil=%lu ffr=%lu\n", 1711 7088 raf pri->pname, 1712 7088 raf statfs.f_fstyp, 1713 7088 raf statfs.f_bsize, 1714 7088 raf statfs.f_frsize, 1715 7088 raf statfs.f_blocks, 1716 7088 raf statfs.f_bfree, 1717 7088 raf statfs.f_files, 1718 7088 raf statfs.f_ffree); 1719 0 stevel (void) printf("%s\t fname=%.6s fpack=%.6s\n", 1720 7088 raf pri->pname, 1721 7088 raf statfs.f_fname, 1722 7088 raf statfs.f_fpack); 1723 0 stevel } 1724 0 stevel } 1725 0 stevel 1726 0 stevel #ifdef _LP64 1727 0 stevel void 1728 0 stevel show_statfs32(private_t *pri) 1729 0 stevel { 1730 0 stevel long offset; 1731 0 stevel struct statfs32 statfs; 1732 0 stevel 1733 0 stevel if (pri->sys_nargs >= 2 && (offset = pri->sys_args[1]) != NULL && 1734 0 stevel Pread(Proc, &statfs, sizeof (statfs), offset) == sizeof (statfs)) { 1735 0 stevel (void) printf( 1736 7088 raf "%s\tfty=%d bsz=%d fsz=%d blk=%d bfr=%d fil=%u ffr=%u\n", 1737 7088 raf pri->pname, 1738 7088 raf statfs.f_fstyp, 1739 7088 raf statfs.f_bsize, 1740 7088 raf statfs.f_frsize, 1741 7088 raf statfs.f_blocks, 1742 7088 raf statfs.f_bfree, 1743 7088 raf statfs.f_files, 1744 7088 raf statfs.f_ffree); 1745 0 stevel (void) printf("%s\t fname=%.6s fpack=%.6s\n", 1746 7088 raf pri->pname, 1747 7088 raf statfs.f_fname, 1748 7088 raf statfs.f_fpack); 1749 0 stevel } 1750 0 stevel } 1751 0 stevel #endif /* _LP64 */ 1752 0 stevel 1753 0 stevel void 1754 0 stevel show_flock32(private_t *pri, long offset) 1755 0 stevel { 1756 0 stevel struct flock32 flock; 1757 0 stevel 1758 0 stevel if (Pread(Proc, &flock, sizeof (flock), offset) == sizeof (flock)) { 1759 0 stevel const char *str = NULL; 1760 0 stevel 1761 0 stevel (void) printf("%s\ttyp=", pri->pname); 1762 0 stevel 1763 0 stevel switch (flock.l_type) { 1764 0 stevel case F_RDLCK: 1765 0 stevel str = "F_RDLCK"; 1766 0 stevel break; 1767 0 stevel case F_WRLCK: 1768 0 stevel str = "F_WRLCK"; 1769 0 stevel break; 1770 0 stevel case F_UNLCK: 1771 0 stevel str = "F_UNLCK"; 1772 0 stevel break; 1773 0 stevel } 1774 0 stevel if (str != NULL) 1775 0 stevel (void) printf("%s", str); 1776 0 stevel else 1777 0 stevel (void) printf("%-7d", flock.l_type); 1778 0 stevel 1779 0 stevel str = whencearg(flock.l_whence); 1780 0 stevel if (str != NULL) 1781 0 stevel (void) printf(" whence=%s", str); 1782 0 stevel else 1783 0 stevel (void) printf(" whence=%-8u", flock.l_whence); 1784 0 stevel 1785 0 stevel (void) printf( 1786 7088 raf " start=%-5d len=%-5d sys=%-2u pid=%d\n", 1787 7088 raf flock.l_start, 1788 7088 raf flock.l_len, 1789 7088 raf flock.l_sysid, 1790 7088 raf flock.l_pid); 1791 0 stevel } 1792 0 stevel } 1793 0 stevel 1794 0 stevel void 1795 0 stevel show_flock64(private_t *pri, long offset) 1796 0 stevel { 1797 0 stevel struct flock64 flock; 1798 0 stevel 1799 0 stevel if (Pread(Proc, &flock, sizeof (flock), offset) == sizeof (flock)) { 1800 0 stevel const char *str = NULL; 1801 0 stevel 1802 0 stevel (void) printf("%s\ttyp=", pri->pname); 1803 0 stevel 1804 0 stevel switch (flock.l_type) { 1805 0 stevel case F_RDLCK: 1806 0 stevel str = "F_RDLCK"; 1807 0 stevel break; 1808 0 stevel case F_WRLCK: 1809 0 stevel str = "F_WRLCK"; 1810 0 stevel break; 1811 0 stevel case F_UNLCK: 1812 0 stevel str = "F_UNLCK"; 1813 0 stevel break; 1814 0 stevel } 1815 0 stevel if (str != NULL) 1816 0 stevel (void) printf("%s", str); 1817 0 stevel else 1818 0 stevel (void) printf("%-7d", flock.l_type); 1819 0 stevel 1820 0 stevel str = whencearg(flock.l_whence); 1821 0 stevel if (str != NULL) 1822 0 stevel (void) printf(" whence=%s", str); 1823 0 stevel else 1824 0 stevel (void) printf(" whence=%-8u", flock.l_whence); 1825 0 stevel 1826 0 stevel (void) printf( 1827 7088 raf " start=%-5lld len=%-5lld sys=%-2u pid=%d\n", 1828 7088 raf (long long)flock.l_start, 1829 7088 raf (long long)flock.l_len, 1830 7088 raf flock.l_sysid, 1831 7088 raf (int)flock.l_pid); 1832 0 stevel } 1833 0 stevel } 1834 0 stevel 1835 0 stevel void 1836 0 stevel show_share(private_t *pri, long offset) 1837 0 stevel { 1838 0 stevel struct fshare fshare; 1839 0 stevel 1840 0 stevel if (Pread(Proc, &fshare, sizeof (fshare), offset) == sizeof (fshare)) { 1841 0 stevel const char *str = NULL; 1842 0 stevel int manddny = 0; 1843 0 stevel 1844 0 stevel (void) printf("%s\taccess=", pri->pname); 1845 0 stevel 1846 0 stevel switch (fshare.f_access) { 1847 0 stevel case F_RDACC: 1848 0 stevel str = "F_RDACC"; 1849 0 stevel break; 1850 0 stevel case F_WRACC: 1851 0 stevel str = "F_WRACC"; 1852 0 stevel break; 1853 0 stevel case F_RWACC: 1854 0 stevel str = "F_RWACC"; 1855 0 stevel break; 1856 0 stevel } 1857 0 stevel if (str != NULL) 1858 0 stevel (void) printf("%s", str); 1859 0 stevel else 1860 0 stevel (void) printf("%-7d", fshare.f_access); 1861 0 stevel 1862 0 stevel str = NULL; 1863 0 stevel if (fshare.f_deny & F_MANDDNY) { 1864 0 stevel fshare.f_deny &= ~F_MANDDNY; 1865 0 stevel manddny = 1; 1866 0 stevel } 1867 0 stevel switch (fshare.f_deny) { 1868 0 stevel case F_NODNY: 1869 0 stevel str = "F_NODNY"; 1870 0 stevel break; 1871 0 stevel case F_RDDNY: 1872 0 stevel str = "F_RDDNY"; 1873 0 stevel break; 1874 0 stevel case F_WRDNY: 1875 0 stevel str = "F_WRDNY"; 1876 0 stevel break; 1877 0 stevel case F_RWDNY: 1878 0 stevel str = "F_RWDNY"; 1879 0 stevel break; 1880 0 stevel case F_COMPAT: 1881 0 stevel str = "F_COMPAT"; 1882 0 stevel break; 1883 0 stevel } 1884 0 stevel if (str != NULL) { 1885 0 stevel if (manddny) 1886 0 stevel (void) printf(" deny=F_MANDDNY|%s", str); 1887 0 stevel else 1888 0 stevel (void) printf(" deny=%s", str); 1889 0 stevel } else { 1890 0 stevel (void) printf(" deny=0x%x", manddny? 1891 7088 raf fshare.f_deny | F_MANDDNY : fshare.f_deny); 1892 0 stevel } 1893 0 stevel 1894 0 stevel (void) printf(" id=%x\n", fshare.f_id); 1895 0 stevel } 1896 0 stevel } 1897 0 stevel 1898 0 stevel void 1899 0 stevel show_ffg(private_t *pri) 1900 0 stevel { 1901 0 stevel (void) putchar('\t'); 1902 0 stevel (void) putchar('\t'); 1903 0 stevel prt_ffg(pri, 0, pri->Rval1); 1904 0 stevel (void) puts(pri->sys_string); 1905 0 stevel } 1906 0 stevel 1907 0 stevel /* print values in fcntl() pointed-to structure */ 1908 0 stevel void 1909 0 stevel show_fcntl(private_t *pri) 1910 0 stevel { 1911 0 stevel long offset; 1912 0 stevel 1913 0 stevel if (pri->sys_nargs >= 2 && pri->sys_args[1] == F_GETFL) { 1914 0 stevel show_ffg(pri); 1915 0 stevel return; 1916 0 stevel } 1917 0 stevel 1918 0 stevel if (pri->sys_nargs < 3 || (offset = pri->sys_args[2]) == NULL) 1919 0 stevel return; 1920 0 stevel 1921 0 stevel switch (pri->sys_args[1]) { 1922 0 stevel #ifdef _LP64 1923 0 stevel case F_GETLK: 1924 0 stevel case F_SETLK: 1925 0 stevel case F_SETLKW: 1926 0 stevel case F_FREESP: 1927 0 stevel case F_ALLOCSP: 1928 0 stevel case F_SETLK_NBMAND: 1929 0 stevel if (data_model == PR_MODEL_LP64) 1930 0 stevel show_flock64(pri, offset); 1931 0 stevel else 1932 0 stevel show_flock32(pri, offset); 1933 0 stevel break; 1934 0 stevel case 33: /* F_GETLK64 */ 1935 0 stevel case 34: /* F_SETLK64 */ 1936 0 stevel case 35: /* F_SETLKW64 */ 1937 0 stevel case 27: /* F_FREESP64 */ 1938 7088 raf case 28: /* F_ALLOCSP64 */ 1939 0 stevel case 44: /* F_SETLK64_NBMAND */ 1940 0 stevel show_flock64(pri, offset); 1941 0 stevel break; 1942 0 stevel #else /* _LP64 */ 1943 0 stevel case F_GETLK: 1944 0 stevel case F_SETLK: 1945 0 stevel case F_SETLKW: 1946 0 stevel case F_FREESP: 1947 0 stevel case F_ALLOCSP: 1948 0 stevel case F_SETLK_NBMAND: 1949 0 stevel show_flock32(pri, offset); 1950 0 stevel break; 1951 0 stevel case F_GETLK64: 1952 0 stevel case F_SETLK64: 1953 0 stevel case F_SETLKW64: 1954 0 stevel case F_FREESP64: 1955 7088 raf case F_ALLOCSP64: 1956 0 stevel case F_SETLK64_NBMAND: 1957 0 stevel show_flock64(pri, offset); 1958 0 stevel break; 1959 0 stevel #endif /* _LP64 */ 1960 0 stevel case F_SHARE: 1961 0 stevel case F_UNSHARE: 1962 0 stevel show_share(pri, offset); 1963 0 stevel break; 1964 0 stevel } 1965 0 stevel } 1966 0 stevel 1967 0 stevel void 1968 0 stevel show_strbuf(private_t *pri, long offset, const char *name, int dump) 1969 0 stevel { 1970 0 stevel struct strbuf strbuf; 1971 0 stevel 1972 0 stevel if (Pread(Proc, &strbuf, sizeof (strbuf), offset) == sizeof (strbuf)) 1973 0 stevel print_strbuf(pri, &strbuf, name, dump); 1974 0 stevel } 1975 0 stevel 1976 0 stevel #ifdef _LP64 1977 0 stevel void 1978 0 stevel show_strbuf32(private_t *pri, long offset, const char *name, int dump) 1979 0 stevel { 1980 0 stevel struct strbuf32 strbuf; 1981 0 stevel 1982 0 stevel if (Pread(Proc, &strbuf, sizeof (strbuf), offset) == sizeof (strbuf)) 1983 0 stevel print_strbuf32(pri, &strbuf, name, dump); 1984 0 stevel } 1985 0 stevel #endif /* _LP64 */ 1986 0 stevel 1987 0 stevel void 1988 0 stevel show_gp_msg(private_t *pri, int what) 1989 0 stevel { 1990 0 stevel long offset; 1991 0 stevel int dump = FALSE; 1992 0 stevel int fdp1 = pri->sys_args[0] + 1; 1993 0 stevel 1994 0 stevel switch (what) { 1995 0 stevel case SYS_getmsg: 1996 0 stevel case SYS_getpmsg: 1997 0 stevel if (pri->Errno == 0 && prismember(&readfd, fdp1)) 1998 0 stevel dump = TRUE; 1999 0 stevel break; 2000 0 stevel case SYS_putmsg: 2001 0 stevel case SYS_putpmsg: 2002 0 stevel if (prismember(&writefd, fdp1)) 2003 0 stevel dump = TRUE; 2004 0 stevel break; 2005 0 stevel } 2006 0 stevel 2007 0 stevel /* enter region of lengthy output */ 2008 0 stevel if (dump) 2009 0 stevel Eserialize(); 2010 0 stevel 2011 0 stevel #ifdef _LP64 2012 0 stevel if (pri->sys_nargs >= 2 && (offset = pri->sys_args[1]) != NULL) { 2013 0 stevel if (data_model == PR_MODEL_LP64) 2014 0 stevel show_strbuf(pri, offset, "ctl", dump); 2015 0 stevel else 2016 0 stevel show_strbuf32(pri, offset, "ctl", dump); 2017 0 stevel } 2018 0 stevel if (pri->sys_nargs >= 3 && (offset = pri->sys_args[2]) != NULL) { 2019 0 stevel if (data_model == PR_MODEL_LP64) 2020 0 stevel show_strbuf(pri, offset, "dat", dump); 2021 0 stevel else 2022 0 stevel show_strbuf32(pri, offset, "dat", dump); 2023 0 stevel } 2024 0 stevel #else /* _LP64 */ 2025 0 stevel if (pri->sys_nargs >= 2 && (offset = pri->sys_args[1]) != NULL) 2026 0 stevel show_strbuf(pri, offset, "ctl", dump); 2027 0 stevel if (pri->sys_nargs >= 3 && (offset = pri->sys_args[2]) != NULL) 2028 0 stevel show_strbuf(pri, offset, "dat", dump); 2029 0 stevel #endif /* _LP64 */ 2030 0 stevel 2031 0 stevel /* exit region of lengthy output */ 2032 0 stevel if (dump) 2033 0 stevel Xserialize(); 2034 0 stevel } 2035 0 stevel 2036 0 stevel void 2037 0 stevel show_int(private_t *pri, long offset, const char *name) 2038 0 stevel { 2039 0 stevel int value; 2040 0 stevel 2041 0 stevel if (offset != 0 && 2042 0 stevel Pread(Proc, &value, sizeof (value), offset) == sizeof (value)) 2043 0 stevel (void) printf("%s\t%s:\t%d\n", 2044 7088 raf pri->pname, 2045 7088 raf name, 2046 7088 raf value); 2047 0 stevel } 2048 0 stevel 2049 0 stevel void 2050 0 stevel show_hhex_int(private_t *pri, long offset, const char *name) 2051 0 stevel { 2052 0 stevel int value; 2053 0 stevel 2054 0 stevel if (Pread(Proc, &value, sizeof (value), offset) == sizeof (value)) 2055 0 stevel (void) printf("%s\t%s:\t0x%.4X\n", 2056 7088 raf pri->pname, 2057 7088 raf name, 2058 7088 raf value); 2059 0 stevel } 2060 0 stevel 2061 0 stevel #define ALL_POLL_FLAGS (POLLIN|POLLPRI|POLLOUT| \ 2062 0 stevel POLLRDNORM|POLLRDBAND|POLLWRBAND|POLLERR|POLLHUP|POLLNVAL) 2063 0 stevel 2064 0 stevel const char * 2065 0 stevel pollevent(private_t *pri, int arg) 2066 0 stevel { 2067 0 stevel char *str = pri->code_buf; 2068 0 stevel 2069 0 stevel if (arg == 0) 2070 0 stevel return ("0"); 2071 0 stevel if (arg & ~ALL_POLL_FLAGS) { 2072 0 stevel (void) sprintf(str, "0x%-5X", arg); 2073 0 stevel return ((const char *)str); 2074 0 stevel } 2075 0 stevel 2076 0 stevel *str = '\0'; 2077 0 stevel if (arg & POLLIN) 2078 0 stevel (void) strcat(str, "|POLLIN"); 2079 0 stevel if (arg & POLLPRI) 2080 0 stevel (void) strcat(str, "|POLLPRI"); 2081 0 stevel if (arg & POLLOUT) 2082 0 stevel (void) strcat(str, "|POLLOUT"); 2083 0 stevel if (arg & POLLRDNORM) 2084 0 stevel (void) strcat(str, "|POLLRDNORM"); 2085 0 stevel if (arg & POLLRDBAND) 2086 0 stevel (void) strcat(str, "|POLLRDBAND"); 2087 0 stevel if (arg & POLLWRBAND) 2088 0 stevel (void) strcat(str, "|POLLWRBAND"); 2089 0 stevel if (arg & POLLERR) 2090 0 stevel (void) strcat(str, "|POLLERR"); 2091 0 stevel if (arg & POLLHUP) 2092 0 stevel (void) strcat(str, "|POLLHUP"); 2093 0 stevel if (arg & POLLNVAL) 2094 0 stevel (void) strcat(str, "|POLLNVAL"); 2095 0 stevel 2096 0 stevel return ((const char *)(str+1)); 2097 0 stevel } 2098 0 stevel 2099 0 stevel static void 2100 0 stevel show_one_pollfd(private_t *pri, struct pollfd *ppollfd) 2101 0 stevel { 2102 0 stevel /* 2103 0 stevel * can't print both events and revents in same printf. 2104 0 stevel * pollevent() returns a pointer to a TSD location. 2105 0 stevel */ 2106 0 stevel (void) printf("%s\tfd=%-2d ev=%s", 2107 0 stevel pri->pname, ppollfd->fd, pollevent(pri, ppollfd->events)); 2108 0 stevel (void) printf(" rev=%s\n", pollevent(pri, ppollfd->revents)); 2109 0 stevel } 2110 0 stevel 2111 0 stevel static void 2112 0 stevel show_all_pollfds(private_t *pri, long offset, int nfds) 2113 0 stevel { 2114 0 stevel struct pollfd pollfd[2]; 2115 0 stevel int skip = -1; 2116 0 stevel 2117 0 stevel for (; nfds && !interrupt; nfds--, offset += sizeof (struct pollfd)) { 2118 0 stevel if (Pread(Proc, &pollfd[0], sizeof (struct pollfd), offset) != 2119 0 stevel sizeof (struct pollfd)) 2120 0 stevel continue; 2121 0 stevel 2122 0 stevel if (skip >= 0 && pollfd[0].fd == pollfd[1].fd && 2123 0 stevel pollfd[0].events == pollfd[1].events && 2124 0 stevel pollfd[0].revents == pollfd[1].revents) { 2125 0 stevel skip++; 2126 0 stevel continue; 2127 0 stevel } 2128 0 stevel 2129 0 stevel if (skip > 0) 2130 0 stevel (void) printf("%s\t...last pollfd structure" 2131 0 stevel " repeated %d time%s...\n", 2132 0 stevel pri->pname, skip, (skip == 1 ? "" : "s")); 2133 0 stevel 2134 0 stevel skip = 0; 2135 0 stevel show_one_pollfd(pri, &pollfd[0]); 2136 0 stevel pollfd[1] = pollfd[0]; 2137 0 stevel } 2138 0 stevel 2139 0 stevel if (skip > 0) 2140 0 stevel (void) printf( 2141 0 stevel "%s\t...last pollfd structure repeated %d time%s...\n", 2142 0 stevel pri->pname, skip, (skip == 1 ? "" : "s")); 2143 0 stevel } 2144 0 stevel 2145 0 stevel void 2146 0 stevel show_poll(private_t *pri) 2147 0 stevel { 2148 0 stevel long offset; 2149 0 stevel int nfds; 2150 0 stevel int serial = 0; 2151 0 stevel 2152 0 stevel if (pri->sys_nargs < 2 || (offset = pri->sys_args[0]) == NULL || 2153 0 stevel (nfds = pri->sys_args[1]) <= 0) 2154 0 stevel return; 2155 0 stevel 2156 0 stevel /* enter region of lengthy output */ 2157 0 stevel if (nfds > 32) { 2158 0 stevel Eserialize(); 2159 0 stevel serial = 1; 2160 0 stevel } 2161 0 stevel 2162 0 stevel show_all_pollfds(pri, offset, nfds); 2163 0 stevel 2164 0 stevel /* exit region of lengthy output */ 2165 0 stevel if (serial) 2166 0 stevel Xserialize(); 2167 0 stevel } 2168 0 stevel 2169 0 stevel void 2170 0 stevel show_pollsys(private_t *pri) 2171 0 stevel { 2172 0 stevel long offset; 2173 0 stevel int nfds; 2174 0 stevel int serial = 0; 2175 0 stevel 2176 0 stevel if (pri->sys_nargs < 2) 2177 0 stevel return; 2178 0 stevel 2179 0 stevel offset = pri->sys_args[0]; 2180 0 stevel nfds = pri->sys_args[1]; 2181 0 stevel 2182 0 stevel /* enter region of lengthy output */ 2183 0 stevel if (offset != NULL && nfds > 32) { 2184 0 stevel Eserialize(); 2185 0 stevel serial = 1; 2186 0 stevel } 2187 0 stevel 2188 0 stevel if (offset != NULL && nfds > 0) 2189 0 stevel show_all_pollfds(pri, offset, nfds); 2190 0 stevel 2191 0 stevel if (pri->sys_nargs > 2) 2192 0 stevel show_timestruc(pri, (long)pri->sys_args[2], "timeout"); 2193 0 stevel 2194 0 stevel if (pri->sys_nargs > 3) 2195 0 stevel show_sigset(pri, (long)pri->sys_args[3], "sigmask"); 2196 0 stevel 2197 0 stevel /* exit region of lengthy output */ 2198 0 stevel if (serial) 2199 0 stevel Xserialize(); 2200 0 stevel } 2201 0 stevel 2202 0 stevel static void 2203 0 stevel show_perm64(private_t *pri, struct ipc_perm64 *ip) 2204 0 stevel { 2205 4321 casper (void) printf("%s\tu=%-5u g=%-5u cu=%-5u cg=%-5u z=%-5d " 2206 0 stevel "m=0%.6o key=%d projid=%-5d\n", 2207 0 stevel pri->pname, 2208 4321 casper ip->ipcx_uid, 2209 4321 casper ip->ipcx_gid, 2210 4321 casper ip->ipcx_cuid, 2211 4321 casper ip->ipcx_cgid, 2212 0 stevel (int)ip->ipcx_zoneid, 2213 0 stevel (unsigned int)ip->ipcx_mode, 2214 0 stevel ip->ipcx_key, 2215 0 stevel (int)ip->ipcx_projid); 2216 0 stevel } 2217 0 stevel 2218 0 stevel void 2219 0 stevel show_perm(private_t *pri, struct ipc_perm *ip) 2220 0 stevel { 2221 0 stevel (void) printf( 2222 7088 raf "%s\tu=%-5u g=%-5u cu=%-5u cg=%-5u m=0%.6o seq=%u key=%d\n", 2223 7088 raf pri->pname, 2224 7088 raf ip->uid, 2225 7088 raf ip->gid, 2226 7088 raf ip->cuid, 2227 7088 raf ip->cgid, 2228 7088 raf (int)ip->mode, 2229 7088 raf ip->seq, 2230 7088 raf ip->key); 2231 0 stevel } 2232 0 stevel 2233 0 stevel #ifdef _LP64 2234 0 stevel void 2235 0 stevel show_perm32(private_t *pri, struct ipc_perm32 *ip) 2236 0 stevel { 2237 0 stevel (void) printf( 2238 7088 raf "%s\tu=%-5u g=%-5u cu=%-5u cg=%-5u m=0%.6o seq=%u key=%d\n", 2239 7088 raf pri->pname, 2240 7088 raf ip->uid, 2241 7088 raf ip->gid, 2242 7088 raf ip->cuid, 2243 7088 raf ip->cgid, 2244 7088 raf ip->mode, 2245 7088 raf ip->seq, 2246 7088 raf ip->key); 2247 0 stevel } 2248 0 stevel #endif /* _LP64 */ 2249 0 stevel 2250 0 stevel static void 2251 0 stevel show_msgctl64(private_t *pri, long offset) 2252 0 stevel { 2253 0 stevel struct msqid_ds64 msgq; 2254 0 stevel 2255 0 stevel if (offset != NULL && 2256 0 stevel Pread(Proc, &msgq, sizeof (msgq), offset) == sizeof (msgq)) { 2257 0 stevel show_perm64(pri, &msgq.msgx_perm); 2258 0 stevel 2259 0 stevel (void) printf("%s\tbytes=%-5llu msgs=%-5llu maxby=%-5llu " 2260 0 stevel "lspid=%-5d lrpid=%-5d\n", pri->pname, 2261 0 stevel (unsigned long long)msgq.msgx_cbytes, 2262 0 stevel (unsigned long long)msgq.msgx_qnum, 2263 0 stevel (unsigned long long)msgq.msgx_qbytes, 2264 0 stevel (int)msgq.msgx_lspid, 2265 0 stevel (int)msgq.msgx_lrpid); 2266 0 stevel 2267 0 stevel prtime(pri, " st = ", (time_t)msgq.msgx_stime); 2268 0 stevel prtime(pri, " rt = ", (time_t)msgq.msgx_rtime); 2269 0 stevel prtime(pri, " ct = ", (time_t)msgq.msgx_ctime); 2270 0 stevel } 2271 0 stevel } 2272 0 stevel 2273 0 stevel void 2274 0 stevel show_msgctl(private_t *pri, long offset) 2275 0 stevel { 2276 0 stevel struct msqid_ds msgq; 2277 0 stevel 2278 0 stevel if (offset != NULL && 2279 0 stevel Pread(Proc, &msgq, sizeof (msgq), offset) == sizeof (msgq)) { 2280 0 stevel show_perm(pri, &msgq.msg_perm); 2281 0 stevel 2282 0 stevel (void) printf( 2283 0 stevel "%s\tbytes=%-5lu msgs=%-5lu maxby=%-5lu lspid=%-5u lrpid=%-5u\n", 2284 7088 raf pri->pname, 2285 7088 raf msgq.msg_cbytes, 2286 7088 raf msgq.msg_qnum, 2287 7088 raf msgq.msg_qbytes, 2288 7088 raf (int)msgq.msg_lspid, 2289 7088 raf (int)msgq.msg_lrpid); 2290 0 stevel 2291 0 stevel prtime(pri, " st = ", msgq.msg_stime); 2292 0 stevel prtime(pri, " rt = ", msgq.msg_rtime); 2293 0 stevel prtime(pri, " ct = ", msgq.msg_ctime); 2294 0 stevel } 2295 0 stevel } 2296 0 stevel 2297 0 stevel #ifdef _LP64 2298 0 stevel void 2299 0 stevel show_msgctl32(private_t *pri, long offset) 2300 0 stevel { 2301 0 stevel struct msqid_ds32 msgq; 2302 0 stevel 2303 0 stevel if (offset != NULL && 2304 0 stevel Pread(Proc, &msgq, sizeof (msgq), offset) == sizeof (msgq)) { 2305 0 stevel show_perm32(pri, &msgq.msg_perm); 2306 0 stevel 2307 0 stevel (void) printf( 2308 0 stevel "%s\tbytes=%-5u msgs=%-5u maxby=%-5u lspid=%-5u lrpid=%-5u\n", 2309 7088 raf pri->pname, 2310 7088 raf msgq.msg_cbytes, 2311 7088 raf msgq.msg_qnum, 2312 7088 raf msgq.msg_qbytes, 2313 7088 raf msgq.msg_lspid, 2314 7088 raf msgq.msg_lrpid); 2315 0 stevel 2316 0 stevel prtime(pri, " st = ", msgq.msg_stime); 2317 0 stevel prtime(pri, " rt = ", msgq.msg_rtime); 2318 0 stevel prtime(pri, " ct = ", msgq.msg_ctime); 2319 0 stevel } 2320 0 stevel } 2321 0 stevel #endif /* _LP64 */ 2322 0 stevel 2323 0 stevel void 2324 0 stevel show_msgbuf(private_t *pri, long offset, long msgsz) 2325 0 stevel { 2326 0 stevel struct msgbuf msgb; 2327 0 stevel 2328 0 stevel if (offset != NULL && 2329 0 stevel Pread(Proc, &msgb, sizeof (msgb.mtype), offset) == 2330 0 stevel sizeof (msgb.mtype)) { 2331 0 stevel /* enter region of lengthy output */ 2332 0 stevel if (msgsz > MYBUFSIZ / 4) 2333 0 stevel Eserialize(); 2334 0 stevel 2335 0 stevel (void) printf("%s\tmtype=%lu mtext[]=\n", 2336 7088 raf pri->pname, 2337 7088 raf msgb.mtype); 2338 0 stevel showbuffer(pri, 2339 7088 raf (long)(offset + sizeof (msgb.mtype)), msgsz); 2340 0 stevel 2341 0 stevel /* exit region of lengthy output */ 2342 0 stevel if (msgsz > MYBUFSIZ / 4) 2343 0 stevel Xserialize(); 2344 0 stevel } 2345 0 stevel } 2346 0 stevel 2347 0 stevel #ifdef _LP64 2348 0 stevel void 2349 0 stevel show_msgbuf32(private_t *pri, long offset, long msgsz) 2350 0 stevel { 2351 0 stevel struct ipcmsgbuf32 msgb; 2352 0 stevel 2353 0 stevel if (offset != NULL && 2354 0 stevel Pread(Proc, &msgb, sizeof (msgb.mtype), offset) == 2355 0 stevel sizeof (msgb.mtype)) { 2356 0 stevel /* enter region of lengthy output */ 2357 0 stevel if (msgsz > MYBUFSIZ / 4) 2358 0 stevel Eserialize(); 2359 0 stevel 2360 0 stevel (void) printf("%s\tmtype=%u mtext[]=\n", 2361 7088 raf pri->pname, 2362 7088 raf msgb.mtype); 2363 0 stevel showbuffer(pri, 2364 7088 raf (long)(offset + sizeof (msgb.mtype)), msgsz); 2365 0 stevel 2366 0 stevel /* exit region of lengthy output */ 2367 0 stevel if (msgsz > MYBUFSIZ / 4) 2368 0 stevel Xserialize(); 2369 0 stevel } 2370 0 stevel } 2371 0 stevel #endif /* _LP64 */ 2372 0 stevel 2373 0 stevel #ifdef _LP64 2374 0 stevel void 2375 0 stevel show_msgsys(private_t *pri, long msgsz) 2376 0 stevel { 2377 0 stevel switch (pri->sys_args[0]) { 2378 0 stevel case 0: /* msgget() */ 2379 0 stevel break; 2380 0 stevel case 1: /* msgctl() */ 2381 0 stevel if (pri->sys_nargs > 3) { 2382 0 stevel switch (pri->sys_args[2]) { 2383 0 stevel case IPC_STAT: 2384 0 stevel if (pri->Errno) 2385 0 stevel break; 2386 0 stevel /*FALLTHROUGH*/ 2387 0 stevel case IPC_SET: 2388 0 stevel if (data_model == PR_MODEL_LP64) 2389 0 stevel show_msgctl(pri, 2390 7088 raf (long)pri->sys_args[3]); 2391 0 stevel else 2392 0 stevel show_msgctl32(pri, 2393 7088 raf (long)pri->sys_args[3]); 2394 0 stevel break; 2395 0 stevel case IPC_STAT64: 2396 0 stevel if (pri->Errno) 2397 0 stevel break; 2398 0 stevel /*FALLTHROUGH*/ 2399 0 stevel case IPC_SET64: 2400 0 stevel show_msgctl64(pri, (long)pri->sys_args[3]); 2401 0 stevel break; 2402 0 stevel } 2403 0 stevel } 2404 0 stevel break; 2405 0 stevel case 2: /* msgrcv() */ 2406 0 stevel if (!pri->Errno && pri->sys_nargs > 2) { 2407 0 stevel if (data_model == PR_MODEL_LP64) 2408 0 stevel show_msgbuf(pri, pri->sys_args[2], msgsz); 2409 0 stevel else 2410 0 stevel show_msgbuf32(pri, pri->sys_args[2], msgsz); 2411 0 stevel } 2412 0 stevel break; 2413 0 stevel case 3: /* msgsnd() */ 2414 0 stevel if (pri->sys_nargs > 3) { 2415 0 stevel if (data_model == PR_MODEL_LP64) 2416 0 stevel show_msgbuf(pri, pri->sys_args[2], 2417 7088 raf pri->sys_args[3]); 2418 0 stevel else 2419 0 stevel show_msgbuf32(pri, pri->sys_args[2], 2420 7088 raf pri->sys_args[3]); 2421 0 stevel } 2422 0 stevel break; 2423 0 stevel case 4: /* msgids() */ 2424 0 stevel case 5: /* msgsnap() */ 2425 0 stevel default: /* unexpected subcode */ 2426 0 stevel break; 2427 0 stevel } 2428 0 stevel } 2429 0 stevel #else /* _LP64 */ 2430 0 stevel void 2431 0 stevel show_msgsys(private_t *pri, long msgsz) 2432 0 stevel { 2433 0 stevel switch (pri->sys_args[0]) { 2434 0 stevel case 0: /* msgget() */ 2435 0 stevel break; 2436 0 stevel case 1: /* msgctl() */ 2437 0 stevel if (pri->sys_nargs > 3) { 2438 0 stevel switch (pri->sys_args[2]) { 2439 0 stevel case IPC_STAT: 2440 0 stevel if (pri->Errno) 2441 0 stevel break; 2442 0 stevel /*FALLTHROUGH*/ 2443 0 stevel case IPC_SET: 2444 0 stevel show_msgctl(pri, (long)pri->sys_args[3]); 2445 0 stevel break; 2446 0 stevel case IPC_STAT64: 2447 0 stevel if (pri->Errno) 2448 0 stevel break; 2449 0 stevel /*FALLTHROUGH*/ 2450 0 stevel case IPC_SET64: 2451 0 stevel show_msgctl64(pri, (long)pri->sys_args[3]); 2452 0 stevel break; 2453 0 stevel } 2454 0 stevel } 2455 0 stevel break; 2456 0 stevel case 2: /* msgrcv() */ 2457 0 stevel if (!pri->Errno && pri->sys_nargs > 2) 2458 0 stevel show_msgbuf(pri, pri->sys_args[2], msgsz); 2459 0 stevel break; 2460 0 stevel case 3: /* msgsnd() */ 2461 0 stevel if (pri->sys_nargs > 3) 2462 0 stevel show_msgbuf(pri, pri->sys_args[2], 2463 7088 raf pri->sys_args[3]); 2464 0 stevel break; 2465 0 stevel case 4: /* msgids() */ 2466 0 stevel case 5: /* msgsnap() */ 2467 0 stevel default: /* unexpected subcode */ 2468 0 stevel break; 2469 0 stevel } 2470 0 stevel } 2471 0 stevel #endif /* _LP64 */ 2472 0 stevel 2473 0 stevel static void 2474 0 stevel show_semctl64(private_t *pri, long offset) 2475 0 stevel { 2476 0 stevel struct semid_ds64 semds; 2477 0 stevel 2478 0 stevel if (offset != NULL && 2479 0 stevel Pread(Proc, &semds, sizeof (semds), offset) == sizeof (semds)) { 2480 0 stevel show_perm64(pri, &semds.semx_perm); 2481 0 stevel 2482 0 stevel (void) printf("%s\tnsems=%u\n", pri->pname, semds.semx_nsems); 2483 0 stevel 2484 0 stevel prtime(pri, " ot = ", (time_t)semds.semx_otime); 2485 0 stevel prtime(pri, " ct = ", (time_t)semds.semx_ctime); 2486 0 stevel } 2487 0 stevel } 2488 0 stevel 2489 0 stevel void 2490 0 stevel show_semctl(private_t *pri, long offset) 2491 0 stevel { 2492 0 stevel struct semid_ds semds; 2493 0 stevel 2494 0 stevel if (offset != NULL && 2495 0 stevel Pread(Proc, &semds, sizeof (semds), offset) == sizeof (semds)) { 2496 0 stevel show_perm(pri, &semds.sem_perm); 2497 0 stevel 2498 0 stevel (void) printf("%s\tnsems=%u\n", 2499 7088 raf pri->pname, 2500 7088 raf semds.sem_nsems); 2501 0 stevel 2502 0 stevel prtime(pri, " ot = ", semds.sem_otime); 2503 0 stevel prtime(pri, " ct = ", semds.sem_ctime); 2504 0 stevel } 2505 0 stevel } 2506 0 stevel 2507 0 stevel #ifdef _LP64 2508 0 stevel void 2509 0 stevel show_semctl32(private_t *pri, long offset) 2510 0 stevel { 2511 0 stevel struct semid_ds32 semds; 2512 0 stevel 2513 0 stevel if (offset != NULL && 2514 0 stevel Pread(Proc, &semds, sizeof (semds), offset) == sizeof (semds)) { 2515 0 stevel show_perm32(pri, &semds.sem_perm); 2516 0 stevel 2517 0 stevel (void) printf("%s\tnsems=%u\n", 2518 7088 raf pri->pname, 2519 7088 raf semds.sem_nsems); 2520 0 stevel 2521 0 stevel prtime(pri, " ot = ", semds.sem_otime); 2522 0 stevel prtime(pri, " ct = ", semds.sem_ctime); 2523 0 stevel } 2524 0 stevel } 2525 0 stevel #endif /* _LP64 */ 2526 0 stevel 2527 0 stevel void 2528 0 stevel show_semop(private_t *pri, long offset, long nsops, long timeout) 2529 0 stevel { 2530 0 stevel struct sembuf sembuf; 2531 0 stevel const char *str; 2532 0 stevel 2533 10440 Roger if (offset == 0) 2534 0 stevel return; 2535 0 stevel 2536 0 stevel if (nsops > 40) /* let's not be ridiculous */ 2537 0 stevel nsops = 40; 2538 0 stevel 2539 0 stevel for (; nsops > 0 && !interrupt; --nsops, offset += sizeof (sembuf)) { 2540 0 stevel if (Pread(Proc, &sembuf, sizeof (sembuf), offset) != 2541 0 stevel sizeof (sembuf)) 2542 0 stevel break; 2543 0 stevel 2544 0 stevel (void) printf("%s\tsemnum=%-5u semop=%-5d semflg=", 2545 7088 raf pri->pname, 2546 7088 raf sembuf.sem_num, 2547 7088 raf sembuf.sem_op); 2548 0 stevel 2549 0 stevel if (sembuf.sem_flg == 0) 2550 0 stevel (void) printf("0\n"); 2551 0 stevel else if ((str = semflags(pri, sembuf.sem_flg)) != NULL) 2552 0 stevel (void) printf("%s\n", str); 2553 0 stevel else 2554 0 stevel (void) printf("0%.6o\n", sembuf.sem_flg); 2555 0 stevel } 2556 0 stevel if (timeout) 2557 0 stevel show_timestruc(pri, timeout, "timeout"); 2558 0 stevel } 2559 0 stevel 2560 0 stevel void 2561 0 stevel show_semsys(private_t *pri) 2562 0 stevel { 2563 0 stevel switch (pri->sys_args[0]) { 2564 0 stevel case 0: /* semctl() */ 2565 0 stevel if (pri->sys_nargs > 4) { 2566 0 stevel switch (pri->sys_args[3]) { 2567 0 stevel case IPC_STAT: 2568 0 stevel if (pri->Errno) 2569 0 stevel break; 2570 0 stevel /*FALLTHROUGH*/ 2571 0 stevel case IPC_SET: 2572 0 stevel #ifdef _LP64 2573 0 stevel if (data_model == PR_MODEL_LP64) 2574 0 stevel show_semctl(pri, 2575 7088 raf (long)pri->sys_args[4]); 2576 0 stevel else 2577 0 stevel show_semctl32(pri, 2578 7088 raf (long)pri->sys_args[4]); 2579 0 stevel #else 2580 0 stevel show_semctl(pri, (long)pri->sys_args[4]); 2581 0 stevel #endif 2582 0 stevel break; 2583 0 stevel case IPC_STAT64: 2584 0 stevel if (pri->Errno) 2585 0 stevel break; 2586 0 stevel /*FALLTHROUGH*/ 2587 0 stevel case IPC_SET64: 2588 0 stevel show_semctl64(pri, (long)pri->sys_args[4]); 2589 0 stevel break; 2590 0 stevel } 2591 0 stevel } 2592 0 stevel break; 2593 0 stevel case 1: /* semget() */ 2594 0 stevel break; 2595 0 stevel case 2: /* semop() */ 2596 0 stevel if (pri->sys_nargs > 3) 2597 0 stevel show_semop(pri, (long)pri->sys_args[2], 2598 7088 raf pri->sys_args[3], 0); 2599 0 stevel break; 2600 0 stevel case 3: /* semids() */ 2601 0 stevel break; 2602 0 stevel case 4: /* semtimedop() */ 2603 0 stevel if (pri->sys_nargs > 4) 2604 0 stevel show_semop(pri, (long)pri->sys_args[2], 2605 7088 raf pri->sys_args[3], pri->sys_args[4]); 2606 0 stevel break; 2607 0 stevel default: /* unexpected subcode */ 2608 0 stevel break; 2609 0 stevel } 2610 0 stevel } 2611 0 stevel 2612 0 stevel static void 2613 0 stevel show_shmctl64(private_t *pri, long offset) 2614 0 stevel { 2615 0 stevel struct shmid_ds64 shmds; 2616 0 stevel 2617 0 stevel if (offset != NULL && 2618 0 stevel Pread(Proc, &shmds, sizeof (shmds), offset) == sizeof (shmds)) { 2619 0 stevel show_perm64(pri, &shmds.shmx_perm); 2620 0 stevel 2621 0 stevel (void) printf( 2622 0 stevel "%s\tsize=%-6llu lpid=%-5d cpid=%-5d na=%-5llu cna=%llu\n", 2623 0 stevel pri->pname, 2624 0 stevel (unsigned long long)shmds.shmx_segsz, 2625 0 stevel (int)shmds.shmx_lpid, 2626 0 stevel (int)shmds.shmx_cpid, 2627 0 stevel (unsigned long long)shmds.shmx_nattch, 2628 0 stevel (unsigned long long)shmds.shmx_cnattch); 2629 0 stevel 2630 0 stevel prtime(pri, " at = ", (time_t)shmds.shmx_atime); 2631 0 stevel prtime(pri, " dt = ", (time_t)shmds.shmx_dtime); 2632 0 stevel prtime(pri, " ct = ", (time_t)shmds.shmx_ctime); 2633 0 stevel } 2634 0 stevel } 2635 0 stevel 2636 0 stevel void 2637 0 stevel show_shmctl(private_t *pri, long offset) 2638 0 stevel { 2639 0 stevel struct shmid_ds shmds; 2640 0 stevel 2641 0 stevel if (offset != NULL && 2642 0 stevel Pread(Proc, &shmds, sizeof (shmds), offset) == sizeof (shmds)) { 2643 0 stevel show_perm(pri, &shmds.shm_perm); 2644 0 stevel 2645 0 stevel (void) printf( 2646 7088 raf "%s\tsize=%-6lu lpid=%-5u cpid=%-5u na=%-5lu cna=%lu\n", 2647 7088 raf pri->pname, 2648 7088 raf (ulong_t)shmds.shm_segsz, 2649 7088 raf (int)shmds.shm_lpid, 2650 7088 raf (int)shmds.shm_cpid, 2651 7088 raf shmds.shm_nattch, 2652 7088 raf shmds.shm_cnattch); 2653 0 stevel 2654 0 stevel prtime(pri, " at = ", shmds.shm_atime); 2655 0 stevel prtime(pri, " dt = ", shmds.shm_dtime); 2656 0 stevel prtime(pri, " ct = ", shmds.shm_ctime); 2657 0 stevel } 2658 0 stevel } 2659 0 stevel 2660 0 stevel #ifdef _LP64 2661 0 stevel void 2662 0 stevel show_shmctl32(private_t *pri, long offset) 2663 0 stevel { 2664 0 stevel struct shmid_ds32 shmds; 2665 0 stevel 2666 0 stevel if (offset != NULL && 2667 0 stevel Pread(Proc, &shmds, sizeof (shmds), offset) == sizeof (shmds)) { 2668 0 stevel show_perm32(pri, &shmds.shm_perm); 2669 0 stevel 2670 0 stevel (void) printf( 2671 7088 raf "%s\tsize=%-6u lpid=%-5u cpid=%-5u na=%-5u cna=%u\n", 2672 7088 raf pri->pname, 2673 7088 raf shmds.shm_segsz, 2674 7088 raf shmds.shm_lpid, 2675 7088 raf shmds.shm_cpid, 2676 7088 raf shmds.shm_nattch, 2677 7088 raf shmds.shm_cnattch); 2678 0 stevel 2679 0 stevel prtime(pri, " at = ", shmds.shm_atime); 2680 0 stevel prtime(pri, " dt = ", shmds.shm_dtime); 2681 0 stevel prtime(pri, " ct = ", shmds.shm_ctime); 2682 0 stevel } 2683 0 stevel } 2684 0 stevel #endif /* _LP64 */ 2685 0 stevel 2686 0 stevel void 2687 0 stevel show_shmsys(private_t *pri) 2688 0 stevel { 2689 0 stevel switch (pri->sys_args[0]) { 2690 0 stevel case 0: /* shmat() */ 2691 0 stevel break; 2692 0 stevel case 1: /* shmctl() */ 2693 0 stevel if (pri->sys_nargs > 3) { 2694 0 stevel switch (pri->sys_args[2]) { 2695 0 stevel case IPC_STAT: 2696 0 stevel if (pri->Errno) 2697 0 stevel break; 2698 0 stevel /*FALLTHROUGH*/ 2699 0 stevel case IPC_SET: 2700 0 stevel #ifdef _LP64 2701 0 stevel if (data_model == PR_MODEL_LP64) 2702 0 stevel show_shmctl(pri, 2703 7088 raf (long)pri->sys_args[3]); 2704 0 stevel else 2705 0 stevel show_shmctl32(pri, 2706 7088 raf (long)pri->sys_args[3]); 2707 0 stevel #else 2708 0 stevel show_shmctl(pri, (long)pri->sys_args[3]); 2709 0 stevel #endif 2710 0 stevel break; 2711 0 stevel case IPC_STAT64: 2712 0 stevel if (pri->Errno) 2713 0 stevel break; 2714 0 stevel /*FALLTHROUGH*/ 2715 0 stevel case IPC_SET64: 2716 0 stevel show_shmctl64(pri, (long)pri->sys_args[3]); 2717 0 stevel break; 2718 0 stevel } 2719 0 stevel } 2720 0 stevel break; 2721 0 stevel case 2: /* shmdt() */ 2722 0 stevel case 3: /* shmget() */ 2723 0 stevel case 4: /* shmids() */ 2724 0 stevel default: /* unexpected subcode */ 2725 0 stevel break; 2726 0 stevel } 2727 0 stevel } 2728 0 stevel 2729 0 stevel void 2730 0 stevel show_groups(private_t *pri, long offset, long count) 2731 0 stevel { 2732 0 stevel int groups[100]; 2733 0 stevel 2734 0 stevel if (count > 100) 2735 0 stevel count = 100; 2736 0 stevel 2737 0 stevel if (count > 0 && offset != NULL && 2738 0 stevel Pread(Proc, &groups[0], count*sizeof (int), offset) == 2739 0 stevel count*sizeof (int)) { 2740 0 stevel int n; 2741 0 stevel 2742 0 stevel (void) printf("%s\t", pri->pname); 2743 0 stevel for (n = 0; !interrupt && n < count; n++) { 2744 0 stevel if (n != 0 && n%10 == 0) 2745 0 stevel (void) printf("\n%s\t", pri->pname); 2746 0 stevel (void) printf(" %5d", groups[n]); 2747 0 stevel } 2748 0 stevel (void) fputc('\n', stdout); 2749 0 stevel } 2750 0 stevel } 2751 0 stevel 2752 0 stevel /* 2753 0 stevel * This assumes that a sigset_t is simply an array of ints. 2754 0 stevel */ 2755 0 stevel char * 2756 0 stevel sigset_string(private_t *pri, sigset_t *sp) 2757 0 stevel { 2758 0 stevel char *s = pri->code_buf; 2759 0 stevel int n = sizeof (*sp) / sizeof (int32_t); 2760 0 stevel int32_t *lp = (int32_t *)sp; 2761 0 stevel 2762 0 stevel while (--n >= 0) { 2763 0 stevel int32_t val = *lp++; 2764 0 stevel 2765 0 stevel if (val == 0) 2766 0 stevel s += sprintf(s, " 0"); 2767 0 stevel else 2768 0 stevel s += sprintf(s, " 0x%.8X", val); 2769 0 stevel } 2770 0 stevel 2771 0 stevel return (pri->code_buf); 2772 0 stevel } 2773 0 stevel 2774 0 stevel void 2775 0 stevel show_sigset(private_t *pri, long offset, const char *name) 2776 0 stevel { 2777 0 stevel sigset_t sigset; 2778 0 stevel 2779 0 stevel if (offset != NULL && 2780 0 stevel Pread(Proc, &sigset, sizeof (sigset), offset) == sizeof (sigset)) { 2781 0 stevel (void) printf("%s\t%s =%s\n", 2782 7088 raf pri->pname, name, sigset_string(pri, &sigset)); 2783 0 stevel } 2784 0 stevel } 2785 0 stevel 2786 0 stevel #ifdef _LP64 2787 0 stevel void 2788 0 stevel show_sigaltstack32(private_t *pri, long offset, const char *name) 2789 0 stevel { 2790 0 stevel struct sigaltstack32 altstack; 2791 0 stevel 2792 0 stevel if (offset != NULL && 2793 0 stevel Pread(Proc, &altstack, sizeof (altstack), offset) == 2794 0 stevel sizeof (altstack)) { 2795 0 stevel (void) printf("%s\t%s: sp=0x%.8X size=%u flags=0x%.4X\n", 2796 7088 raf pri->pname, 2797 7088 raf name, 2798 7088 raf altstack.ss_sp, 2799 7088 raf altstack.ss_size, 2800 7088 raf altstack.ss_flags); 2801 0 stevel } 2802 0 stevel } 2803 0 stevel #endif /* _LP64 */ 2804 0 stevel 2805 0 stevel void 2806 0 stevel show_sigaltstack(private_t *pri, long offset, const char *name) 2807 0 stevel { 2808 0 stevel struct sigaltstack altstack; 2809 0 stevel 2810 0 stevel #ifdef _LP64 2811 0 stevel if (data_model != PR_MODEL_LP64) { 2812 0 stevel show_sigaltstack32(pri, offset, name); 2813 0 stevel return; 2814 0 stevel } 2815 0 stevel #endif 2816 0 stevel if (offset != NULL && 2817 0 stevel Pread(Proc, &altstack, sizeof (altstack), offset) == 2818 0 stevel sizeof (altstack)) { 2819 0 stevel (void) printf("%s\t%s: sp=0x%.8lX size=%lu flags=0x%.4X\n", 2820 7088 raf pri->pname, 2821 7088 raf name, 2822 7088 raf (ulong_t)altstack.ss_sp, 2823 7088 raf (ulong_t)altstack.ss_size, 2824 7088 raf altstack.ss_flags); 2825 0 stevel } 2826 0 stevel } 2827 0 stevel 2828 0 stevel #ifdef _LP64 2829 0 stevel void 2830 0 stevel show_sigaction32(private_t *pri, long offset, const char *name, long odisp) 2831 0 stevel { 2832 0 stevel struct sigaction32 sigaction; 2833 0 stevel 2834 0 stevel if (offset != NULL && 2835 0 stevel Pread(Proc, &sigaction, sizeof (sigaction), offset) == 2836 0 stevel sizeof (sigaction)) { 2837 0 stevel /* This is stupid, we shouldn't have to do this */ 2838 0 stevel if (odisp != NULL) 2839 0 stevel sigaction.sa_handler = (caddr32_t)odisp; 2840 0 stevel (void) printf( 2841 7088 raf "%s %s: hand = 0x%.8X mask =%s flags = 0x%.4X\n", 2842 7088 raf pri->pname, 2843 7088 raf name, 2844 7088 raf sigaction.sa_handler, 2845 7088 raf sigset_string(pri, (sigset_t *)&sigaction.sa_mask), 2846 7088 raf sigaction.sa_flags); 2847 0 stevel } 2848 0 stevel } 2849 0 stevel #endif /* _LP64 */ 2850 0 stevel 2851 0 stevel void 2852 0 stevel show_sigaction(private_t *pri, long offset, const char *name, long odisp) 2853 0 stevel { 2854 0 stevel struct sigaction sigaction; 2855 0 stevel 2856 0 stevel #ifdef _LP64 2857 0 stevel if (data_model != PR_MODEL_LP64) { 2858 0 stevel show_sigaction32(pri, offset, name, odisp); 2859 0 stevel return; 2860 0 stevel } 2861 0 stevel #endif 2862 0 stevel if (offset != NULL && 2863 0 stevel Pread(Proc, &sigaction, sizeof (sigaction), offset) == 2864 0 stevel sizeof (sigaction)) { 2865 0 stevel /* This is stupid, we shouldn't have to do this */ 2866 0 stevel if (odisp != NULL) 2867 0 stevel sigaction.sa_handler = (void (*)())odisp; 2868 0 stevel (void) printf( 2869 7088 raf "%s %s: hand = 0x%.8lX mask =%s flags = 0x%.4X\n", 2870 7088 raf pri->pname, 2871 7088 raf name, 2872 7088 raf (long)sigaction.sa_handler, 2873 7088 raf sigset_string(pri, &sigaction.sa_mask), 2874 7088 raf sigaction.sa_flags); 2875 0 stevel } 2876 0 stevel } 2877 0 stevel 2878 0 stevel #ifdef _LP64 2879 0 stevel void 2880 0 stevel print_siginfo32(private_t *pri, const siginfo32_t *sip) 2881 0 stevel { 2882 0 stevel const char *code = NULL; 2883 0 stevel 2884 0 stevel (void) printf("%s siginfo: %s", pri->pname, 2885 7088 raf signame(pri, sip->si_signo)); 2886 0 stevel 2887 0 stevel if (sip->si_signo != 0 && SI_FROMUSER(sip) && sip->si_pid != 0) { 2888 0 stevel (void) printf(" pid=%d uid=%d", sip->si_pid, sip->si_uid); 2889 0 stevel if (sip->si_code != 0) 2890 0 stevel (void) printf(" code=%d", sip->si_code); 2891 0 stevel (void) fputc('\n', stdout); 2892 0 stevel return; 2893 0 stevel } 2894 0 stevel 2895 0 stevel switch (sip->si_signo) { 2896 0 stevel default: 2897 0 stevel (void) fputc('\n', stdout); 2898 0 stevel return; 2899 0 stevel case SIGILL: 2900 0 stevel case SIGTRAP: 2901 0 stevel case SIGFPE: 2902 0 stevel case SIGSEGV: 2903 0 stevel case SIGBUS: 2904 0 stevel case SIGEMT: 2905 0 stevel case SIGCLD: 2906 0 stevel case SIGPOLL: 2907 0 stevel case SIGXFSZ: 2908 0 stevel break; 2909 0 stevel } 2910 0 stevel 2911 0 stevel switch (sip->si_signo) { 2912 0 stevel case SIGILL: 2913 0 stevel switch (sip->si_code) { 2914 0 stevel case ILL_ILLOPC: code = "ILL_ILLOPC"; break; 2915 0 stevel case ILL_ILLOPN: code = "ILL_ILLOPN"; break; 2916 0 stevel case ILL_ILLADR: code = "ILL_ILLADR"; break; 2917 0 stevel case ILL_ILLTRP: code = "ILL_ILLTRP"; break; 2918 0 stevel case ILL_PRVOPC: code = "ILL_PRVOPC"; break; 2919 0 stevel case ILL_PRVREG: code = "ILL_PRVREG"; break; 2920 0 stevel case ILL_COPROC: code = "ILL_COPROC"; break; 2921 0 stevel case ILL_BADSTK: code = "ILL_BADSTK"; break; 2922 0 stevel } 2923 0 stevel break; 2924 0 stevel case SIGTRAP: 2925 0 stevel switch (sip->si_code) { 2926 0 stevel case TRAP_BRKPT: code = "TRAP_BRKPT"; break; 2927 0 stevel case TRAP_TRACE: code = "TRAP_TRACE"; break; 2928 0 stevel case TRAP_RWATCH: code = "TRAP_RWATCH"; break; 2929 0 stevel case TRAP_WWATCH: code = "TRAP_WWATCH"; break; 2930 0 stevel case TRAP_XWATCH: code = "TRAP_XWATCH"; break; 2931 0 stevel case TRAP_DTRACE: code = "TRAP_DTRACE"; break; 2932 0 stevel } 2933 0 stevel break; 2934 0 stevel case SIGFPE: 2935 0 stevel switch (sip->si_code) { 2936 0 stevel case FPE_INTDIV: code = "FPE_INTDIV"; break; 2937 0 stevel case FPE_INTOVF: code = "FPE_INTOVF"; break; 2938 0 stevel case FPE_FLTDIV: code = "FPE_FLTDIV"; break; 2939 0 stevel case FPE_FLTOVF: code = "FPE_FLTOVF"; break; 2940 0 stevel case FPE_FLTUND: code = "FPE_FLTUND"; break; 2941 0 stevel case FPE_FLTRES: code = "FPE_FLTRES"; break; 2942 0 stevel case FPE_FLTINV: code = "FPE_FLTINV"; break; 2943 0 stevel case FPE_FLTSUB: code = "FPE_FLTSUB"; break; 2944 0 stevel #if defined(FPE_FLTDEN) 2945 0 stevel case FPE_FLTDEN: code = "FPE_FLTDEN"; break; 2946 0 stevel #endif 2947 0 stevel } 2948 0 stevel break; 2949 0 stevel case SIGSEGV: 2950 0 stevel switch (sip->si_code) { 2951 0 stevel case SEGV_MAPERR: code = "SEGV_MAPERR"; break; 2952 0 stevel case SEGV_ACCERR: code = "SEGV_ACCERR"; break; 2953 0 stevel } 2954 0 stevel break; 2955 0 stevel case SIGEMT: 2956 0 stevel switch (sip->si_code) { 2957 0 stevel #ifdef EMT_TAGOVF 2958 0 stevel case EMT_TAGOVF: code = "EMT_TAGOVF"; break; 2959 0 stevel #endif 2960 0 stevel case EMT_CPCOVF: code = "EMT_CPCOVF"; break; 2961 0 stevel } 2962 0 stevel break; 2963 0 stevel case SIGBUS: 2964 0 stevel switch (sip->si_code) { 2965 0 stevel case BUS_ADRALN: code = "BUS_ADRALN"; break; 2966 0 stevel case BUS_ADRERR: code = "BUS_ADRERR"; break; 2967 0 stevel case BUS_OBJERR: code = "BUS_OBJERR"; break; 2968 0 stevel } 2969 0 stevel break; 2970 0 stevel case SIGCLD: 2971 0 stevel switch (sip->si_code) { 2972 0 stevel case CLD_EXITED: code = "CLD_EXITED"; break; 2973 0 stevel case CLD_KILLED: code = "CLD_KILLED"; break; 2974 0 stevel case CLD_DUMPED: code = "CLD_DUMPED"; break; 2975 0 stevel case CLD_TRAPPED: code = "CLD_TRAPPED"; break; 2976 0 stevel case CLD_STOPPED: code = "CLD_STOPPED"; break; 2977 0 stevel case CLD_CONTINUED: code = "CLD_CONTINUED"; break; 2978 0 stevel } 2979 0 stevel break; 2980 0 stevel case SIGPOLL: 2981 0 stevel switch (sip->si_code) { 2982 0 stevel case POLL_IN: code = "POLL_IN"; break; 2983 0 stevel case POLL_OUT: code = "POLL_OUT"; break; 2984 0 stevel case POLL_MSG: code = "POLL_MSG"; break; 2985 0 stevel case POLL_ERR: code = "POLL_ERR"; break; 2986 0 stevel case POLL_PRI: code = "POLL_PRI"; break; 2987 0 stevel case POLL_HUP: code = "POLL_HUP"; break; 2988 0 stevel } 2989 0 stevel break; 2990 0 stevel } 2991 0 stevel 2992 0 stevel if (code == NULL) { 2993 0 stevel (void) sprintf(pri->code_buf, "code=%d", sip->si_code); 2994 0 stevel code = (const char *)pri->code_buf; 2995 0 stevel } 2996 0 stevel 2997 0 stevel switch (sip->si_signo) { 2998 0 stevel case SIGILL: 2999 0 stevel case SIGTRAP: 3000 0 stevel case SIGFPE: 3001 0 stevel case SIGSEGV: 3002 0 stevel case SIGBUS: 3003 0 stevel case SIGEMT: 3004 0 stevel (void) printf(" %s addr=0x%.8X", 3005 7088 raf code, 3006 7088 raf sip->si_addr); 3007 0 stevel break; 3008 0 stevel case SIGCLD: 3009 0 stevel (void) printf(" %s pid=%d status=0x%.4X", 3010 7088 raf code, 3011 7088 raf sip->si_pid, 3012 7088 raf sip->si_status); 3013 0 stevel break; 3014 0 stevel case SIGPOLL: 3015 0 stevel case SIGXFSZ: 3016 0 stevel (void) printf(" %s fd=%d band=%d", 3017 7088 raf code, 3018 7088 raf sip->si_fd, 3019 7088 raf sip->si_band); 3020 0 stevel break; 3021 0 stevel } 3022 0 stevel 3023 0 stevel if (sip->si_errno != 0) { 3024 0 stevel const char *ename = errname(sip->si_errno); 3025 0 stevel 3026 0 stevel (void) printf(" errno=%d", sip->si_errno); 3027 0 stevel if (ename != NULL) 3028 0 stevel (void) printf("(%s)", ename); 3029 0 stevel } 3030 0 stevel 3031 0 stevel (void) fputc('\n', stdout); 3032 0 stevel } 3033 0 stevel #endif /* _LP64 */ 3034 0 stevel 3035 0 stevel void 3036 0 stevel print_siginfo(private_t *pri, const siginfo_t *sip) 3037 0 stevel { 3038 0 stevel const char *code = NULL; 3039 0 stevel 3040 0 stevel (void) printf("%s siginfo: %s", pri->pname, 3041 7088 raf signame(pri, sip->si_signo)); 3042 0 stevel 3043 0 stevel if (sip->si_signo != 0 && SI_FROMUSER(sip) && sip->si_pid != 0) { 3044 4321 casper (void) printf(" pid=%d uid=%u", 3045 0 stevel (int)sip->si_pid, 3046 4321 casper sip->si_uid); 3047 0 stevel if (sip->si_code != 0) 3048 0 stevel (void) printf(" code=%d", sip->si_code); 3049 0 stevel (void) fputc('\n', stdout); 3050 0 stevel return; 3051 0 stevel } 3052 0 stevel 3053 0 stevel switch (sip->si_signo) { 3054 0 stevel default: 3055 0 stevel (void) fputc('\n', stdout); 3056 0 stevel return; 3057 0 stevel case SIGILL: 3058 0 stevel case SIGTRAP: 3059 0 stevel case SIGFPE: 3060 0 stevel case SIGSEGV: 3061 0 stevel case SIGBUS: 3062 0 stevel case SIGEMT: 3063 0 stevel case SIGCLD: 3064 0 stevel case SIGPOLL: 3065 0 stevel case SIGXFSZ: 3066 0 stevel break; 3067 0 stevel } 3068 0 stevel 3069 0 stevel switch (sip->si_signo) { 3070 0 stevel case SIGILL: 3071 0 stevel switch (sip->si_code) { 3072 0 stevel case ILL_ILLOPC: code = "ILL_ILLOPC"; break; 3073 0 stevel case ILL_ILLOPN: code = "ILL_ILLOPN"; break; 3074 0 stevel case ILL_ILLADR: code = "ILL_ILLADR"; break; 3075 0 stevel case ILL_ILLTRP: code = "ILL_ILLTRP"; break; 3076 0 stevel case ILL_PRVOPC: code = "ILL_PRVOPC"; break; 3077 0 stevel case ILL_PRVREG: code = "ILL_PRVREG"; break; 3078 0 stevel case ILL_COPROC: code = "ILL_COPROC"; break; 3079 0 stevel case ILL_BADSTK: code = "ILL_BADSTK"; break; 3080 0 stevel } 3081 0 stevel break; 3082 0 stevel case SIGTRAP: 3083 0 stevel switch (sip->si_code) { 3084 0 stevel case TRAP_BRKPT: code = "TRAP_BRKPT"; break; 3085 0 stevel case TRAP_TRACE: code = "TRAP_TRACE"; break; 3086 0 stevel case TRAP_RWATCH: code = "TRAP_RWATCH"; break; 3087 0 stevel case TRAP_WWATCH: code = "TRAP_WWATCH"; break; 3088 0 stevel case TRAP_XWATCH: code = "TRAP_XWATCH"; break; 3089 0 stevel case TRAP_DTRACE: code = "TRAP_DTRACE"; break; 3090 0 stevel } 3091 0 stevel break; 3092 0 stevel case SIGFPE: 3093