ipcs.c revision 1.30
1 /* $NetBSD: ipcs.c,v 1.30 2003/07/12 13:29:15 itojun Exp $ */ 2 3 /*- 4 * Copyright (c) 2000 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Simon Burge. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 /* 40 * Copyright (c) 1994 SigmaSoft, Th. Lockert <tholo (at) sigmasoft.com> 41 * All rights reserved. 42 * 43 * Redistribution and use in source and binary forms, with or without 44 * modification, are permitted provided that the following conditions 45 * are met: 46 * 1. Redistributions of source code must retain the above copyright 47 * notice, this list of conditions and the following disclaimer. 48 * 2. Redistributions in binary form must reproduce the above copyright 49 * notice, this list of conditions and the following disclaimer in the 50 * documentation and/or other materials provided with the distribution. 51 * 3. All advertising materials mentioning features or use of this software 52 * must display the following acknowledgement: 53 * This product includes software developed by SigmaSoft, Th. Lockert. 54 * 4. The name of the author may not be used to endorse or promote products 55 * derived from this software without specific prior written permission. 56 * 57 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, 58 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY 59 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 60 * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 61 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 62 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 63 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 64 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 65 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 66 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 67 */ 68 69 #include <sys/param.h> 70 #include <sys/sysctl.h> 71 #include <sys/ipc.h> 72 #include <sys/sem.h> 73 #include <sys/shm.h> 74 #include <sys/msg.h> 75 76 #include <err.h> 77 #include <fcntl.h> 78 #include <grp.h> 79 #include <kvm.h> 80 #include <limits.h> 81 #include <nlist.h> 82 #include <paths.h> 83 #include <pwd.h> 84 #include <stdio.h> 85 #include <stdlib.h> 86 #include <string.h> 87 #include <time.h> 88 #include <unistd.h> 89 90 void cvt_time(time_t, char *, size_t); 91 char *fmt_perm(u_short); 92 void ipcs_kvm(void); 93 int main(int, char **); 94 void msg_sysctl(void); 95 void sem_sysctl(void); 96 void shm_sysctl(void); 97 void show_msginfo(time_t, time_t, time_t, int, u_int64_t, mode_t, uid_t, 98 gid_t, uid_t, gid_t, u_int64_t, u_int64_t, u_int64_t, pid_t, pid_t); 99 void show_msginfo_hdr(void); 100 void show_msgtotal(struct msginfo *); 101 void show_seminfo_hdr(void); 102 void show_seminfo(time_t, time_t, int, u_int64_t, mode_t, uid_t, gid_t, 103 uid_t, gid_t, int16_t); 104 void show_semtotal(struct seminfo *); 105 void show_shminfo(time_t, time_t, time_t, int, u_int64_t, mode_t, uid_t, 106 gid_t, uid_t, gid_t, u_int32_t, u_int64_t, pid_t, pid_t); 107 void show_shminfo_hdr(void); 108 void show_shmtotal(struct shminfo *); 109 void usage(void); 110 111 char * 112 fmt_perm(u_short mode) 113 { 114 static char buffer[12]; 115 116 buffer[0] = '-'; 117 buffer[1] = '-'; 118 buffer[2] = ((mode & 0400) ? 'r' : '-'); 119 buffer[3] = ((mode & 0200) ? 'w' : '-'); 120 buffer[4] = ((mode & 0100) ? 'a' : '-'); 121 buffer[5] = ((mode & 0040) ? 'r' : '-'); 122 buffer[6] = ((mode & 0020) ? 'w' : '-'); 123 buffer[7] = ((mode & 0010) ? 'a' : '-'); 124 buffer[8] = ((mode & 0004) ? 'r' : '-'); 125 buffer[9] = ((mode & 0002) ? 'w' : '-'); 126 buffer[10] = ((mode & 0001) ? 'a' : '-'); 127 buffer[11] = '\0'; 128 return (&buffer[0]); 129 } 130 131 void 132 cvt_time(time_t t, char *buf, size_t buflen) 133 { 134 struct tm *tm; 135 136 if (t == 0) 137 (void)strlcpy(buf, "no-entry", buflen); 138 else { 139 tm = localtime(&t); 140 (void)snprintf(buf, buflen, "%2d:%02d:%02d", 141 tm->tm_hour, tm->tm_min, tm->tm_sec); 142 } 143 } 144 #define SHMINFO 1 145 #define SHMTOTAL 2 146 #define MSGINFO 4 147 #define MSGTOTAL 8 148 #define SEMINFO 16 149 #define SEMTOTAL 32 150 151 #define BIGGEST 1 152 #define CREATOR 2 153 #define OUTSTANDING 4 154 #define PID 8 155 #define TIME 16 156 157 char *core = NULL, *namelist = NULL; 158 int display = SHMINFO | MSGINFO | SEMINFO; 159 int option = 0; 160 161 int 162 main(int argc, char *argv[]) 163 { 164 int i; 165 166 while ((i = getopt(argc, argv, "MmQqSsabC:cN:optT")) != -1) 167 switch (i) { 168 case 'M': 169 display = SHMTOTAL; 170 break; 171 case 'm': 172 display = SHMINFO; 173 break; 174 case 'Q': 175 display = MSGTOTAL; 176 break; 177 case 'q': 178 display = MSGINFO; 179 break; 180 case 'S': 181 display = SEMTOTAL; 182 break; 183 case 's': 184 display = SEMINFO; 185 break; 186 case 'T': 187 display = SHMTOTAL | MSGTOTAL | SEMTOTAL; 188 break; 189 case 'a': 190 option |= BIGGEST | CREATOR | OUTSTANDING | PID | TIME; 191 break; 192 case 'b': 193 option |= BIGGEST; 194 break; 195 case 'C': 196 core = optarg; 197 break; 198 case 'c': 199 option |= CREATOR; 200 break; 201 case 'N': 202 namelist = optarg; 203 break; 204 case 'o': 205 option |= OUTSTANDING; 206 break; 207 case 'p': 208 option |= PID; 209 break; 210 case 't': 211 option |= TIME; 212 break; 213 default: 214 usage(); 215 } 216 217 if (argc - optind > 0) 218 usage(); 219 220 if (core == NULL) { 221 if (display & (MSGINFO | MSGTOTAL)) 222 msg_sysctl(); 223 if (display & (SHMINFO | SHMTOTAL)) 224 shm_sysctl(); 225 if (display & (SEMINFO | SEMTOTAL)) 226 sem_sysctl(); 227 } else 228 ipcs_kvm(); 229 exit(0); 230 } 231 232 void 233 show_msgtotal(struct msginfo *msginfo) 234 { 235 printf("msginfo:\n"); 236 printf("\tmsgmax: %6d\t(max characters in a message)\n", 237 msginfo->msgmax); 238 printf("\tmsgmni: %6d\t(# of message queues)\n", 239 msginfo->msgmni); 240 printf("\tmsgmnb: %6d\t(max characters in a message queue)\n", 241 msginfo->msgmnb); 242 printf("\tmsgtql: %6d\t(max # of messages in system)\n", 243 msginfo->msgtql); 244 printf("\tmsgssz: %6d\t(size of a message segment)\n", 245 msginfo->msgssz); 246 printf("\tmsgseg: %6d\t(# of message segments in system)\n\n", 247 msginfo->msgseg); 248 } 249 250 void 251 show_shmtotal(struct shminfo *shminfo) 252 { 253 printf("shminfo:\n"); 254 printf("\tshmmax: %7d\t(max shared memory segment size)\n", 255 shminfo->shmmax); 256 printf("\tshmmin: %7d\t(min shared memory segment size)\n", 257 shminfo->shmmin); 258 printf("\tshmmni: %7d\t(max number of shared memory identifiers)\n", 259 shminfo->shmmni); 260 printf("\tshmseg: %7d\t(max shared memory segments per process)\n", 261 shminfo->shmseg); 262 printf("\tshmall: %7d\t(max amount of shared memory in pages)\n\n", 263 shminfo->shmall); 264 } 265 266 void 267 show_semtotal(struct seminfo *seminfo) 268 { 269 printf("seminfo:\n"); 270 printf("\tsemmap: %6d\t(# of entries in semaphore map)\n", 271 seminfo->semmap); 272 printf("\tsemmni: %6d\t(# of semaphore identifiers)\n", 273 seminfo->semmni); 274 printf("\tsemmns: %6d\t(# of semaphores in system)\n", 275 seminfo->semmns); 276 printf("\tsemmnu: %6d\t(# of undo structures in system)\n", 277 seminfo->semmnu); 278 printf("\tsemmsl: %6d\t(max # of semaphores per id)\n", 279 seminfo->semmsl); 280 printf("\tsemopm: %6d\t(max # of operations per semop call)\n", 281 seminfo->semopm); 282 printf("\tsemume: %6d\t(max # of undo entries per process)\n", 283 seminfo->semume); 284 printf("\tsemusz: %6d\t(size in bytes of undo structure)\n", 285 seminfo->semusz); 286 printf("\tsemvmx: %6d\t(semaphore maximum value)\n", 287 seminfo->semvmx); 288 printf("\tsemaem: %6d\t(adjust on exit max value)\n\n", 289 seminfo->semaem); 290 } 291 292 void 293 show_msginfo_hdr(void) 294 { 295 printf("Message Queues:\n"); 296 printf("T ID KEY MODE OWNER GROUP"); 297 if (option & CREATOR) 298 printf(" CREATOR CGROUP"); 299 if (option & OUTSTANDING) 300 printf(" CBYTES QNUM"); 301 if (option & BIGGEST) 302 printf(" QBYTES"); 303 if (option & PID) 304 printf(" LSPID LRPID"); 305 if (option & TIME) 306 printf(" STIME RTIME CTIME"); 307 printf("\n"); 308 } 309 310 void 311 show_msginfo(time_t stime, time_t rtime, time_t ctime, int ipcid, u_int64_t key, 312 mode_t mode, uid_t uid, gid_t gid, uid_t cuid, gid_t cgid, 313 u_int64_t cbytes, u_int64_t qnum, u_int64_t qbytes, pid_t lspid, 314 pid_t lrpid) 315 { 316 char stime_buf[100], rtime_buf[100], ctime_buf[100]; 317 318 if (option & TIME) { 319 cvt_time(stime, stime_buf, sizeof(stime_buf)); 320 cvt_time(rtime, rtime_buf, sizeof(rtime_buf)); 321 cvt_time(ctime, ctime_buf, sizeof(ctime_buf)); 322 } 323 324 printf("q %9d %10lld %s %8s %8s", ipcid, (long long)key, fmt_perm(mode), 325 user_from_uid(uid, 0), group_from_gid(gid, 0)); 326 327 if (option & CREATOR) 328 printf(" %8s %8s", user_from_uid(cuid, 0), 329 group_from_gid(cgid, 0)); 330 331 if (option & OUTSTANDING) 332 printf(" %6lld %5lld", (long long)cbytes, (long long)qnum); 333 334 if (option & BIGGEST) 335 printf(" %6lld", (long long)qbytes); 336 337 if (option & PID) 338 printf(" %5d %5d", lspid, lrpid); 339 340 if (option & TIME) 341 printf(" %s %s %s", stime_buf, rtime_buf, ctime_buf); 342 343 printf("\n"); 344 } 345 346 void 347 show_shminfo_hdr(void) 348 { 349 printf("Shared Memory:\n"); 350 printf("T ID KEY MODE OWNER GROUP"); 351 if (option & CREATOR) 352 printf(" CREATOR CGROUP"); 353 if (option & OUTSTANDING) 354 printf(" NATTCH"); 355 if (option & BIGGEST) 356 printf(" SEGSZ"); 357 if (option & PID) 358 printf(" CPID LPID"); 359 if (option & TIME) 360 printf(" ATIME DTIME CTIME"); 361 printf("\n"); 362 } 363 364 void 365 show_shminfo(time_t atime, time_t dtime, time_t ctime, int ipcid, u_int64_t key, 366 mode_t mode, uid_t uid, gid_t gid, uid_t cuid, gid_t cgid, 367 u_int32_t nattch, u_int64_t segsz, pid_t cpid, pid_t lpid) 368 { 369 char atime_buf[100], dtime_buf[100], ctime_buf[100]; 370 371 if (option & TIME) { 372 cvt_time(atime, atime_buf, sizeof(atime_buf)); 373 cvt_time(dtime, dtime_buf, sizeof(dtime_buf)); 374 cvt_time(ctime, ctime_buf, sizeof(ctime_buf)); 375 } 376 377 printf("m %9d %10lld %s %8s %8s", ipcid, (long long)key, fmt_perm(mode), 378 user_from_uid(uid, 0), group_from_gid(gid, 0)); 379 380 if (option & CREATOR) 381 printf(" %8s %8s", user_from_uid(cuid, 0), 382 group_from_gid(cgid, 0)); 383 384 if (option & OUTSTANDING) 385 printf(" %6d", nattch); 386 387 if (option & BIGGEST) 388 printf(" %7llu", (long long)segsz); 389 390 if (option & PID) 391 printf(" %5d %5d", cpid, lpid); 392 393 if (option & TIME) 394 printf(" %s %s %s", 395 atime_buf, 396 dtime_buf, 397 ctime_buf); 398 399 printf("\n"); 400 } 401 402 void 403 show_seminfo_hdr(void) 404 { 405 printf("Semaphores:\n"); 406 printf("T ID KEY MODE OWNER GROUP"); 407 if (option & CREATOR) 408 printf(" CREATOR CGROUP"); 409 if (option & BIGGEST) 410 printf(" NSEMS"); 411 if (option & TIME) 412 printf(" OTIME CTIME"); 413 printf("\n"); 414 } 415 416 void 417 show_seminfo(time_t otime, time_t ctime, int ipcid, u_int64_t key, mode_t mode, 418 uid_t uid, gid_t gid, uid_t cuid, gid_t cgid, int16_t nsems) 419 { 420 char ctime_buf[100], otime_buf[100]; 421 422 if (option & TIME) { 423 cvt_time(otime, otime_buf, sizeof(otime_buf)); 424 cvt_time(ctime, ctime_buf, sizeof(ctime_buf)); 425 } 426 427 printf("s %9d %10lld %s %8s %8s", ipcid, (long long)key, fmt_perm(mode), 428 user_from_uid(uid, 0), group_from_gid(gid, 0)); 429 430 if (option & CREATOR) 431 printf(" %8s %8s", user_from_uid(cuid, 0), 432 group_from_gid(cgid, 0)); 433 434 if (option & BIGGEST) 435 printf(" %5d", nsems); 436 437 if (option & TIME) 438 printf(" %s %s", otime_buf, ctime_buf); 439 440 printf("\n"); 441 } 442 443 void 444 msg_sysctl(void) 445 { 446 struct msg_sysctl_info *msgsi; 447 char *buf; 448 int mib[3]; 449 size_t len; 450 int i, valid; 451 452 mib[0] = CTL_KERN; 453 mib[1] = KERN_SYSVMSG; 454 len = sizeof(valid); 455 if (sysctl(mib, 2, &valid, &len, NULL, NULL) < 0) { 456 perror("sysctl(KERN_SYSVMSG)"); 457 return; 458 } 459 if (!valid) { 460 fprintf(stderr, 461 "SVID messages facility not configured in the system\n"); 462 return; 463 } 464 465 mib[0] = CTL_KERN; 466 mib[1] = KERN_SYSVIPC_INFO; 467 mib[2] = KERN_SYSVIPC_MSG_INFO; 468 469 if (!(display & MSGINFO)) { 470 /* totals only */ 471 len = sizeof(struct msginfo); 472 } else { 473 if (sysctl(mib, 3, NULL, &len, NULL, NULL) < 0) { 474 perror("sysctl(KERN_SYSVIPC_MSG_INFO)"); 475 return; 476 } 477 } 478 479 if ((buf = malloc(len)) == NULL) 480 err(1, "malloc"); 481 msgsi = (struct msg_sysctl_info *)buf; 482 if (sysctl(mib, 3, msgsi, &len, NULL, NULL) < 0) { 483 perror("sysctl(KERN_SYSVIPC_MSG_INFO)"); 484 return; 485 } 486 487 if (display & MSGTOTAL) 488 show_msgtotal(&msgsi->msginfo); 489 490 if (display & MSGINFO) { 491 show_msginfo_hdr(); 492 for (i = 0; i < msgsi->msginfo.msgmni; i++) { 493 struct msgid_ds_sysctl *msqptr = &msgsi->msgids[i]; 494 if (msqptr->msg_qbytes != 0) 495 show_msginfo(msqptr->msg_stime, 496 msqptr->msg_rtime, 497 msqptr->msg_ctime, 498 IXSEQ_TO_IPCID(i, msqptr->msg_perm), 499 msqptr->msg_perm._key, 500 msqptr->msg_perm.mode, 501 msqptr->msg_perm.uid, 502 msqptr->msg_perm.gid, 503 msqptr->msg_perm.cuid, 504 msqptr->msg_perm.cgid, 505 msqptr->_msg_cbytes, 506 msqptr->msg_qnum, 507 msqptr->msg_qbytes, 508 msqptr->msg_lspid, 509 msqptr->msg_lrpid); 510 } 511 printf("\n"); 512 } 513 } 514 515 void 516 shm_sysctl(void) 517 { 518 struct shm_sysctl_info *shmsi; 519 char *buf; 520 int mib[3]; 521 size_t len; 522 int i /*, valid */; 523 long valid; 524 525 mib[0] = CTL_KERN; 526 mib[1] = KERN_SYSVSHM; 527 len = sizeof(valid); 528 if (sysctl(mib, 2, &valid, &len, NULL, NULL) < 0) { 529 perror("sysctl(KERN_SYSVSHM)"); 530 return; 531 } 532 if (!valid) { 533 fprintf(stderr, 534 "SVID shared memory facility not configured in the system\n"); 535 return; 536 } 537 538 mib[0] = CTL_KERN; 539 mib[1] = KERN_SYSVIPC_INFO; 540 mib[2] = KERN_SYSVIPC_SHM_INFO; 541 542 if (!(display & SHMINFO)) { 543 /* totals only */ 544 len = sizeof(struct shminfo); 545 } else { 546 if (sysctl(mib, 3, NULL, &len, NULL, NULL) < 0) { 547 perror("sysctl(KERN_SYSVIPC_SHM_INFO)"); 548 return; 549 } 550 } 551 552 if ((buf = malloc(len)) == NULL) 553 err(1, "malloc"); 554 shmsi = (struct shm_sysctl_info *)buf; 555 if (sysctl(mib, 3, shmsi, &len, NULL, NULL) < 0) { 556 perror("sysctl(KERN_SYSVIPC_SHM_INFO)"); 557 return; 558 } 559 560 if (display & SHMTOTAL) 561 show_shmtotal(&shmsi->shminfo); 562 563 if (display & SHMINFO) { 564 show_shminfo_hdr(); 565 for (i = 0; i < shmsi->shminfo.shmmni; i++) { 566 struct shmid_ds_sysctl *shmptr = &shmsi->shmids[i]; 567 if (shmptr->shm_perm.mode & 0x0800) 568 show_shminfo(shmptr->shm_atime, 569 shmptr->shm_dtime, 570 shmptr->shm_ctime, 571 IXSEQ_TO_IPCID(i, shmptr->shm_perm), 572 shmptr->shm_perm._key, 573 shmptr->shm_perm.mode, 574 shmptr->shm_perm.uid, 575 shmptr->shm_perm.gid, 576 shmptr->shm_perm.cuid, 577 shmptr->shm_perm.cgid, 578 shmptr->shm_nattch, 579 shmptr->shm_segsz, 580 shmptr->shm_cpid, 581 shmptr->shm_lpid); 582 } 583 printf("\n"); 584 } 585 } 586 587 void 588 sem_sysctl(void) 589 { 590 struct sem_sysctl_info *semsi; 591 char *buf; 592 int mib[3]; 593 size_t len; 594 int i, valid; 595 596 mib[0] = CTL_KERN; 597 mib[1] = KERN_SYSVSEM; 598 len = sizeof(valid); 599 if (sysctl(mib, 2, &valid, &len, NULL, NULL) < 0) { 600 perror("sysctl(KERN_SYSVSEM)"); 601 return; 602 } 603 if (!valid) { 604 fprintf(stderr, 605 "SVID semaphores facility not configured in the system\n"); 606 return; 607 } 608 609 mib[0] = CTL_KERN; 610 mib[1] = KERN_SYSVIPC_INFO; 611 mib[2] = KERN_SYSVIPC_SEM_INFO; 612 613 if (!(display & SEMINFO)) { 614 /* totals only */ 615 len = sizeof(struct seminfo); 616 } else { 617 if (sysctl(mib, 3, NULL, &len, NULL, NULL) < 0) { 618 perror("sysctl(KERN_SYSVIPC_SEM_INFO)"); 619 return; 620 } 621 } 622 623 if ((buf = malloc(len)) == NULL) 624 err(1, "malloc"); 625 semsi = (struct sem_sysctl_info *)buf; 626 if (sysctl(mib, 3, semsi, &len, NULL, NULL) < 0) { 627 perror("sysctl(KERN_SYSVIPC_SEM_INFO)"); 628 return; 629 } 630 631 if (display & SEMTOTAL) 632 show_semtotal(&semsi->seminfo); 633 634 if (display & SEMINFO) { 635 show_seminfo_hdr(); 636 for (i = 0; i < semsi->seminfo.semmni; i++) { 637 struct semid_ds_sysctl *semaptr = &semsi->semids[i]; 638 if ((semaptr->sem_perm.mode & SEM_ALLOC) != 0) 639 show_seminfo(semaptr->sem_otime, 640 semaptr->sem_ctime, 641 IXSEQ_TO_IPCID(i, semaptr->sem_perm), 642 semaptr->sem_perm._key, 643 semaptr->sem_perm.mode, 644 semaptr->sem_perm.uid, 645 semaptr->sem_perm.gid, 646 semaptr->sem_perm.cuid, 647 semaptr->sem_perm.cgid, 648 semaptr->sem_nsems); 649 } 650 printf("\n"); 651 } 652 } 653 654 void 655 ipcs_kvm(void) 656 { 657 struct msginfo msginfo; 658 struct msqid_ds *msqids; 659 struct seminfo seminfo; 660 struct semid_ds *sema; 661 struct shminfo shminfo; 662 struct shmid_ds *shmsegs; 663 kvm_t *kd; 664 char errbuf[_POSIX2_LINE_MAX]; 665 int i; 666 struct nlist symbols[] = { 667 {"_sema"}, 668 #define X_SEMA 0 669 {"_seminfo"}, 670 #define X_SEMINFO 1 671 {"_semu"}, 672 #define X_SEMU 2 673 {"_msginfo"}, 674 #define X_MSGINFO 3 675 {"_msqids"}, 676 #define X_MSQIDS 4 677 {"_shminfo"}, 678 #define X_SHMINFO 5 679 {"_shmsegs"}, 680 #define X_SHMSEGS 6 681 {NULL} 682 }; 683 684 if ((kd = kvm_openfiles(namelist, core, NULL, O_RDONLY, 685 errbuf)) == NULL) 686 errx(1, "can't open kvm: %s", errbuf); 687 688 689 switch (kvm_nlist(kd, symbols)) { 690 case 0: 691 break; 692 case -1: 693 errx(1, "%s: unable to read symbol table.", 694 namelist == NULL ? _PATH_UNIX : namelist); 695 /* NOTREACHED */ 696 default: 697 #ifdef notdef /* they'll be told more civilly later */ 698 warnx("nlist failed"); 699 for (i = 0; symbols[i].n_name != NULL; i++) 700 if (symbols[i].n_value == 0) 701 warnx("symbol %s not found", 702 symbols[i].n_name); 703 #endif 704 break; 705 } 706 707 if ((display & (MSGINFO | MSGTOTAL)) && 708 (kvm_read(kd, symbols[X_MSGINFO].n_value, 709 &msginfo, sizeof(msginfo)) == sizeof(msginfo))) { 710 711 if (display & MSGTOTAL) 712 show_msgtotal(&msginfo); 713 714 if (display & MSGINFO) { 715 struct msqid_ds *xmsqids; 716 717 if (kvm_read(kd, symbols[X_MSQIDS].n_value, 718 &msqids, sizeof(msqids)) != sizeof(msqids)) 719 errx(1, "kvm_read (%s): %s", 720 symbols[X_MSQIDS].n_name, kvm_geterr(kd)); 721 722 xmsqids = malloc(sizeof(struct msqid_ds) * 723 msginfo.msgmni); 724 725 if (kvm_read(kd, (u_long)msqids, xmsqids, 726 sizeof(struct msqid_ds) * msginfo.msgmni) != 727 sizeof(struct msqid_ds) * msginfo.msgmni) 728 errx(1, "kvm_read (msqids): %s", 729 kvm_geterr(kd)); 730 731 show_msginfo_hdr(); 732 for (i = 0; i < msginfo.msgmni; i++) { 733 struct msqid_ds *msqptr = &xmsqids[i]; 734 if (msqptr->msg_qbytes != 0) 735 show_msginfo(msqptr->msg_stime, 736 msqptr->msg_rtime, 737 msqptr->msg_ctime, 738 IXSEQ_TO_IPCID(i, msqptr->msg_perm), 739 msqptr->msg_perm._key, 740 msqptr->msg_perm.mode, 741 msqptr->msg_perm.uid, 742 msqptr->msg_perm.gid, 743 msqptr->msg_perm.cuid, 744 msqptr->msg_perm.cgid, 745 msqptr->_msg_cbytes, 746 msqptr->msg_qnum, 747 msqptr->msg_qbytes, 748 msqptr->msg_lspid, 749 msqptr->msg_lrpid); 750 } 751 printf("\n"); 752 } 753 } else 754 if (display & (MSGINFO | MSGTOTAL)) { 755 fprintf(stderr, 756 "SVID messages facility not configured in the system\n"); 757 } 758 if ((display & (SHMINFO | SHMTOTAL)) && 759 (kvm_read(kd, symbols[X_SHMINFO].n_value, &shminfo, 760 sizeof(shminfo)) == sizeof(shminfo))) { 761 762 if (display & SHMTOTAL) 763 show_shmtotal(&shminfo); 764 765 if (display & SHMINFO) { 766 struct shmid_ds *xshmids; 767 768 if (kvm_read(kd, symbols[X_SHMSEGS].n_value, &shmsegs, 769 sizeof(shmsegs)) != sizeof(shmsegs)) 770 errx(1, "kvm_read (%s): %s", 771 symbols[X_SHMSEGS].n_name, kvm_geterr(kd)); 772 773 xshmids = malloc(sizeof(struct shmid_ds) * 774 shminfo.shmmni); 775 776 if (kvm_read(kd, (u_long)shmsegs, xshmids, 777 sizeof(struct shmid_ds) * shminfo.shmmni) != 778 sizeof(struct shmid_ds) * shminfo.shmmni) 779 errx(1, "kvm_read (shmsegs): %s", 780 kvm_geterr(kd)); 781 782 show_shminfo_hdr(); 783 for (i = 0; i < shminfo.shmmni; i++) { 784 struct shmid_ds *shmptr = &xshmids[i]; 785 if (shmptr->shm_perm.mode & 0x0800) 786 show_shminfo(shmptr->shm_atime, 787 shmptr->shm_dtime, 788 shmptr->shm_ctime, 789 IXSEQ_TO_IPCID(i, shmptr->shm_perm), 790 shmptr->shm_perm._key, 791 shmptr->shm_perm.mode, 792 shmptr->shm_perm.uid, 793 shmptr->shm_perm.gid, 794 shmptr->shm_perm.cuid, 795 shmptr->shm_perm.cgid, 796 shmptr->shm_nattch, 797 shmptr->shm_segsz, 798 shmptr->shm_cpid, 799 shmptr->shm_lpid); 800 } 801 printf("\n"); 802 } 803 } else 804 if (display & (SHMINFO | SHMTOTAL)) { 805 fprintf(stderr, 806 "SVID shared memory facility not configured in the system\n"); 807 } 808 if ((display & (SEMINFO | SEMTOTAL)) && 809 (kvm_read(kd, symbols[X_SEMINFO].n_value, &seminfo, 810 sizeof(seminfo)) == sizeof(seminfo))) { 811 struct semid_ds *xsema; 812 813 if (display & SEMTOTAL) 814 show_semtotal(&seminfo); 815 816 if (display & SEMINFO) { 817 if (kvm_read(kd, symbols[X_SEMA].n_value, &sema, 818 sizeof(sema)) != sizeof(sema)) 819 errx(1, "kvm_read (%s): %s", 820 symbols[X_SEMA].n_name, kvm_geterr(kd)); 821 822 xsema = malloc(sizeof(struct semid_ds) * 823 seminfo.semmni); 824 825 if (kvm_read(kd, (u_long)sema, xsema, 826 sizeof(struct semid_ds) * seminfo.semmni) != 827 sizeof(struct semid_ds) * seminfo.semmni) 828 errx(1, "kvm_read (sema): %s", 829 kvm_geterr(kd)); 830 831 show_seminfo_hdr(); 832 for (i = 0; i < seminfo.semmni; i++) { 833 struct semid_ds *semaptr = &xsema[i]; 834 if ((semaptr->sem_perm.mode & SEM_ALLOC) != 0) 835 show_seminfo(semaptr->sem_otime, 836 semaptr->sem_ctime, 837 IXSEQ_TO_IPCID(i, semaptr->sem_perm), 838 semaptr->sem_perm._key, 839 semaptr->sem_perm.mode, 840 semaptr->sem_perm.uid, 841 semaptr->sem_perm.gid, 842 semaptr->sem_perm.cuid, 843 semaptr->sem_perm.cgid, 844 semaptr->sem_nsems); 845 } 846 847 printf("\n"); 848 } 849 } else 850 if (display & (SEMINFO | SEMTOTAL)) { 851 fprintf(stderr, "SVID semaphores facility not configured in the system\n"); 852 } 853 kvm_close(kd); 854 } 855 856 void 857 usage(void) 858 { 859 860 fprintf(stderr, 861 "usage: %s [-abcmopqstMQST] [-C corefile] [-N namelist]\n", 862 getprogname()); 863 exit(1); 864 } 865
Indexes created Wed Oct 29 05:09:45 GMT 2025