usr/src/cmd/ipcs/ipcs.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  27 /*        All Rights Reserved   */
  28
  29
  30 #pragma ident   "%Z%%M% %I%     %E% SMI"
  31
  32 /*
  33  * ipcs - IPC status
  34  *
  35  * Examine and print certain things about
  36  * message queues, semaphores and shared memory.
  37  *
  38  * IPC information is obtained via msgctl64, semctl64 and shmctl64.
  39  * As of SunOS 5.8, the IPC identifiers are obtained from msgids(),
  40  * semids(), and shmids() rather than reading them from /dev/kmem.
  41  * This ensures that the information in each msgid_ds, semid_ds or
  42  * shmid_ds data structure that we obtain is complete and consistent,
  43  * and allows us not to be a setgid-sys isaexec process.
  44  */
  45
  46 #include <sys/types.h>
  47 #include <sys/ipc.h>
  48 #include <sys/ipc_impl.h>
  49 #include <sys/msg.h>
  50 #include <sys/sem.h>
  51 #include <sys/shm.h>
  52 #include <errno.h>
  53 #include <fcntl.h>
  54 #include <time.h>
  55 #include <grp.h>
  56 #include <pwd.h>
  57 #include <stdio.h>
  58 #include <stdlib.h>
  59 #include <ctype.h>
  60 #include <unistd.h>
  61 #include <locale.h>
  62 #include <langinfo.h>
  63 #include <string.h>
  64 #include <limits.h>
  65 #include <project.h>
  66 #include <zone.h>
  67
  68 #define USAGE   \
  69         "usage: ipcs [-AabciJmopqstZ] [-D mtype] [-z zone]\n"
  70
  71 static char chdr[] = "T         ID      KEY        MODE        OWNER    GROUP";
  72                                                 /* common header format */
  73 static char chdr2[] = "  CREATOR   CGROUP";     /* c option header format */
  74 static char chdr3[] = "         PROJECT";       /* J option header format */
  75 static char opts[] = "AabciJmopqstD:z:Z";       /* getopt options */
  76
  77 static long     mtype;          /* -D: user-supplied message type */
  78 static zoneid_t zoneid;         /* -z: user-supplied zone id */
  79
  80 static int      bflg,           /* biggest size: */
  81                                 /*      segsz on m; qbytes on q; nsems on s */
  82                 cflg,           /* creator's login and group names */
  83                 Dflg,           /* dump contents of message queues */
  84                 iflg,           /* ISM attaches */
  85                 Jflg,           /* dump project name */
  86                 mflg,           /* shared memory status */
  87                 oflg,           /* outstanding data: */
  88                                 /*      nattch on m; cbytes, qnum on q */
  89                 pflg,           /* process id's: lrpid, lspid on q; */
  90                                 /*      cpid, lpid on m */
  91                 qflg,           /* message queue status */
  92                 sflg,           /* semaphore status */
  93                 tflg,           /* times: atime, ctime, dtime on m;     */
  94                                 /*      ctime, rtime, stime on q;       */
  95                                 /*      ctime, otime on s */
  96                 zflg,           /* show only objects from specified zone */
  97                 Zflg,           /* display zone name */
  98                 err;            /* option error count */
  99
 100 static void hp(char, char *, struct ipc_perm64 *, int);
 101 static void jp(struct ipc_perm64 *);
 102 static void tp(ipc_time_t);
 103 static void dumpmsgq(int);
 104 static void dumpmsg(long, char *, size_t);
 105 static zoneid_t getzone(char *);
 106 static void printzone(zoneid_t);
 107
 108 int
 109 main(int argc, char *argv[])
 110 {
 111         static  int     *ids;   /* array of IPC identifiers from *ids() */
 112         static  uint_t  nids;   /* number of entries in ids */
 113
 114         int     o;      /* option flag */
 115         int     id;     /* IPC identifier */
 116         int     i;
 117         uint_t  n;      /* table size */
 118         time_t  now;    /* date */
 119         char    tbuf[BUFSIZ];
 120         char    *dfmt;  /* date format pointer */
 121         char    *endptr;        /* terminator for strtol() */
 122
 123         (void) setlocale(LC_ALL, "");
 124         (void) textdomain(TEXT_DOMAIN);
 125
 126         (void) memset(tbuf, 0, sizeof (tbuf));
 127         dfmt = nl_langinfo(_DATE_FMT);
 128
 129         zoneid = getzoneid();   /* default zone id if -z and -Z not used */
 130
 131         /* Go through the options and set flags. */
 132         while ((o = getopt(argc, argv, opts)) != EOF) {
 133                 switch (o) {
 134                 case 'A':
 135                         bflg = cflg = iflg = oflg = pflg = tflg = Jflg = 1;
 136                         break;
 137                 case 'a':
 138                         bflg = cflg = oflg = pflg = tflg = 1;
 139                         break;
 140                 case 'b':
 141                         bflg = 1;
 142                         break;
 143                 case 'c':
 144                         cflg = 1;
 145                         break;
 146                 case 'D':
 147                         mtype = strtol(optarg, &endptr, 0);
 148                         if (endptr == optarg || *endptr != '\0') {
 149                                 (void) fprintf(stderr,
 150                                     gettext("ipcs: invalid message type: %s\n"),
 151                                     optarg);
 152                                 err++;
 153                                 break;
 154                         }
 155                         Dflg = 1;
 156                         break;
 157                 case 'i':
 158                         iflg = 1;
 159                         break;
 160                 case 'J':
 161                         Jflg = 1;
 162                         break;
 163                 case 'm':
 164                         mflg = 1;
 165                         break;
 166                 case 'o':
 167                         oflg = 1;
 168                         break;
 169                 case 'p':
 170                         pflg = 1;
 171                         break;
 172                 case 'q':
 173                         qflg = 1;
 174                         break;
 175                 case 's':
 176                         sflg = 1;
 177                         break;
 178                 case 't':
 179                         tflg = 1;
 180                         break;
 181                 case 'z':
 182                         zflg = 1;
 183                         zoneid = getzone(optarg);
 184                         break;
 185                 case 'Z':
 186                         Zflg = 1;
 187                         break;
 188                 case '?':
 189                         err++;
 190                         break;
 191                 }
 192         }
 193         if (err || (optind < argc)) {
 194                 (void) fprintf(stderr, gettext(USAGE));
 195                 exit(1);
 196         }
 197
 198         if ((mflg + qflg + sflg) == 0)
 199                 mflg = qflg = sflg = 1;
 200
 201         now = time(NULL);
 202         (void) strftime(tbuf, sizeof (tbuf), dfmt, localtime(&now));
 203         (void) printf(gettext("IPC status from <running system> as of %s\n"),
 204             tbuf);
 205
 206         /*
 207          * Print Message Queue status report.
 208          */
 209         if (qflg) {
 210                 struct msqid_ds64 qds;
 211
 212                 for (;;) {
 213                         if (msgids(ids, nids, &n) != 0) {
 214                                 perror("msgids");
 215                                 exit(1);
 216                         }
 217                         if (n <= nids)
 218                                 break;
 219                         ids = reallocarray(ids, (nids = n), sizeof (int));
 220                 }
 221
 222                 (void) printf("%s%s%s%s%s%s%s%s\n", chdr,
 223                     cflg ? chdr2 : "",
 224                     oflg ? " CBYTES  QNUM" : "",
 225                     bflg ? " QBYTES" : "",
 226                     pflg ? " LSPID LRPID" : "",
 227                     tflg ? "   STIME    RTIME    CTIME " : "",
 228                     Jflg ? chdr3 : "",
 229                     Zflg ? "     ZONE" : "");
 230
 231                 (void) printf(gettext("Message Queues:\n"));
 232
 233                 for (i = 0; i < n; i++) {
 234                         id = ids[i];
 235                         if (msgctl64(id, IPC_STAT64, &qds) < 0)
 236                                 continue;
 237                         /* ignore zone if -Z was used and -z wasn't */
 238                         if ((zflg || !Zflg) &&
 239                             qds.msgx_perm.ipcx_zoneid != zoneid)
 240                                 continue;
 241                         hp('q', "SRrw-rw-rw-", &qds.msgx_perm, id);
 242                         if (oflg)
 243                                 (void) printf(" %6llu %5llu",
 244                                     qds.msgx_cbytes, qds.msgx_qnum);
 245                         if (bflg)
 246                                 (void) printf(" %6llu", qds.msgx_qbytes);
 247                         if (pflg)
 248                                 (void) printf(" %5d %5d",
 249                                     (int)qds.msgx_lspid, (int)qds.msgx_lrpid);
 250                         if (tflg) {
 251                                 tp(qds.msgx_stime);
 252                                 tp(qds.msgx_rtime);
 253                                 tp(qds.msgx_ctime);
 254                         }
 255                         if (Jflg)
 256                                 jp(&qds.msgx_perm);
 257                         if (Zflg)
 258                                 printzone(qds.msgx_perm.ipcx_zoneid);
 259                         (void) printf("\n");
 260                         if (Dflg)
 261                                 dumpmsgq(id);
 262                 }
 263         }
 264
 265         /*
 266          * Print Shared Memory status report.
 267          */
 268         if (mflg) {
 269                 struct shmid_ds64 mds;
 270
 271                 for (;;) {
 272                         if (shmids(ids, nids, &n) != 0) {
 273                                 perror("shmids");
 274                                 exit(1);
 275                         }
 276                         if (n <= nids)
 277                                 break;
 278                         ids = reallocarray(ids, (nids = n), sizeof (int));
 279                 }
 280
 281                 if (!qflg || oflg || bflg || pflg || tflg || iflg)
 282                         (void) printf("%s%s%s%s%s%s%s%s%s\n", chdr,
 283                             cflg ? chdr2 : "",
 284                             oflg ? " NATTCH" : "",
 285                             bflg ? "      SEGSZ" : "",
 286                             pflg ? "  CPID  LPID" : "",
 287                             tflg ? "   ATIME    DTIME    CTIME " : "",
 288                             iflg ? " ISMATTCH" : "",
 289                             Jflg ? chdr3 : "",
 290                             Zflg ? "     ZONE" : "");
 291
 292                 (void) printf(gettext("Shared Memory:\n"));
 293
 294                 for (i = 0; i < n; i++) {
 295                         id = ids[i];
 296                         if (shmctl64(id, IPC_STAT64, &mds) < 0)
 297                                 continue;
 298                         /* ignore zone if -Z was used and -z wasn't */
 299                         if ((zflg || !Zflg) &&
 300                             mds.shmx_perm.ipcx_zoneid != zoneid)
 301                                 continue;
 302                         hp('m', "--rw-rw-rw-", &mds.shmx_perm, id);
 303                         if (oflg)
 304                                 (void) printf(" %6llu", mds.shmx_nattch);
 305                         if (bflg)
 306                                 (void) printf(" %10llu", mds.shmx_segsz);
 307                         if (pflg)
 308                                 (void) printf(" %5d %5d",
 309                                     (int)mds.shmx_cpid, (int)mds.shmx_lpid);
 310                         if (tflg) {
 311                                 tp(mds.shmx_atime);
 312                                 tp(mds.shmx_dtime);
 313                                 tp(mds.shmx_ctime);
 314                         }
 315                         if (iflg)
 316                                 (void) printf(" %8llu", mds.shmx_cnattch);
 317                         if (Jflg)
 318                                 jp(&mds.shmx_perm);
 319                         if (Zflg)
 320                                 printzone(mds.shmx_perm.ipcx_zoneid);
 321                         (void) printf("\n");
 322                 }
 323         }
 324
 325         /*
 326          * Print Semaphore facility status.
 327          */
 328         if (sflg) {
 329                 struct semid_ds64 sds;
 330                 union semun {
 331                         int val;
 332                         struct semid_ds64 *buf;
 333                         ushort_t *array;
 334                 } semarg;
 335                 semarg.buf = &sds;
 336
 337                 for (;;) {
 338                         if (semids(ids, nids, &n) != 0) {
 339                                 perror("semids");
 340                                 exit(1);
 341                         }
 342                         if (n <= nids)
 343                                 break;
 344                         ids = reallocarray(ids, (nids = n), sizeof (int));
 345                 }
 346
 347                 if (bflg || tflg || (!qflg && !mflg))
 348                         (void) printf("%s%s%s%s%s%s\n", chdr,
 349                             cflg ? chdr2 : "",
 350                             bflg ? " NSEMS" : "",
 351                             tflg ? "   OTIME    CTIME " : "",
 352                             Jflg ? chdr3 : "",
 353                             Zflg ? "     ZONE" : "");
 354
 355                 (void) printf(gettext("Semaphores:\n"));
 356
 357                 for (i = 0; i < n; i++) {
 358                         id = ids[i];
 359                         if (semctl64(id, 0, IPC_STAT64, semarg) < 0)
 360                                 continue;
 361                         /* ignore zone if -Z was used and -z wasn't */
 362                         if ((zflg || !Zflg) &&
 363                             sds.semx_perm.ipcx_zoneid != zoneid)
 364                                 continue;
 365                         hp('s', "--ra-ra-ra-", &sds.semx_perm, id);
 366                         if (bflg)
 367                                 (void) printf(" %5u", sds.semx_nsems);
 368                         if (tflg) {
 369                                 tp(sds.semx_otime);
 370                                 tp(sds.semx_ctime);
 371                         }
 372                         if (Jflg)
 373                                 jp(&sds.semx_perm);
 374                         if (Zflg)
 375                                 printzone(sds.semx_perm.ipcx_zoneid);
 376                         (void) printf("\n");
 377                 }
 378         }
 379
 380         return (0);
 381 }
 382
 383 /*
 384  * hp - common header print
 385  */
 386 static void
 387 hp(char type, char *modesp, struct ipc_perm64 *permp, int slot)
 388 {
 389         int             i;      /* loop control */
 390         struct group    *g;     /* ptr to group group entry */
 391         struct passwd   *u;     /* ptr to user passwd entry */
 392         char            keyfield[16];
 393
 394         (void) snprintf(keyfield, sizeof (keyfield), "  0x%x", permp->ipcx_key);
 395         (void) printf("%c %10d %-13s", type, slot, keyfield);
 396
 397         for (i = 02000; i; modesp++, i >>= 1)
 398                 (void) printf("%c", (permp->ipcx_mode & i) ? *modesp : '-');
 399         if ((u = getpwuid(permp->ipcx_uid)) == NULL)
 400                 (void) printf("%9d", (int)permp->ipcx_uid);
 401         else
 402                 (void) printf("%9.8s", u->pw_name);
 403         if ((g = getgrgid(permp->ipcx_gid)) == NULL)
 404                 (void) printf("%9d", (int)permp->ipcx_gid);
 405         else
 406                 (void) printf("%9.8s", g->gr_name);
 407
 408         if (cflg) {
 409                 if ((u = getpwuid(permp->ipcx_cuid)) == NULL)
 410                         (void) printf("%9d", (int)permp->ipcx_cuid);
 411                 else
 412                         (void) printf("%9.8s", u->pw_name);
 413                 if ((g = getgrgid(permp->ipcx_cgid)) == NULL)
 414                         (void) printf("%9d", (int)permp->ipcx_cgid);
 415                 else
 416                         (void) printf("%9.8s", g->gr_name);
 417         }
 418 }
 419
 420 /*
 421  * jp - project header print
 422  */
 423 static void
 424 jp(struct ipc_perm64 *permp)
 425 {
 426         struct project  proj;
 427         char            buf[PROJECT_BUFSZ];
 428
 429         if ((getprojbyid(permp->ipcx_projid, &proj, buf,
 430             PROJECT_BUFSZ)) == NULL)
 431                 (void) printf("%16ld", permp->ipcx_projid);
 432         else
 433                 (void) printf("%16.15s", proj.pj_name);
 434 }
 435
 436 /*
 437  * tp - time entry printer
 438  */
 439 void
 440 tp(ipc_time_t gmt64)
 441 {
 442         struct tm *t;   /* ptr to converted time */
 443         time_t gmt = (time_t)gmt64;
 444
 445         if (gmt && gmt64 <= UINT_MAX) {
 446                 t = localtime(&gmt);
 447                 (void) printf(" %2d:%2.2d:%2.2d",
 448                     t->tm_hour, t->tm_min, t->tm_sec);
 449         } else {
 450                 (void) printf("%9s", gettext(" no-entry"));
 451         }
 452 }
 453
 454 /* Round up to a sizeof (size_t) boundary */
 455 #define SZROUND(x)      (((x) + sizeof (size_t) - 1) & ~(sizeof (size_t) - 1))
 456
 457 /*
 458  * dumpmsgq - dump all messages on a message queue
 459  */
 460 void
 461 dumpmsgq(int msqid)
 462 {
 463         static struct msgsnap_head *buf = NULL;
 464         static size_t bufsize;
 465
 466         struct msgsnap_mhead *mhead;
 467         size_t i;
 468
 469         /* allocate the minimum required buffer size on first time through */
 470         if (buf == NULL)
 471                 buf = malloc(bufsize = sizeof (struct msgsnap_head));
 472
 473         /*
 474          * Fetch all messages specified by mtype from
 475          * the queue while leaving the queue intact.
 476          */
 477         for (;;) {
 478                 if (msgsnap(msqid, buf, bufsize, mtype) != 0) {
 479                         /*
 480                          * Don't complain; either the user does not have
 481                          * read permission on msqid or msqid was deleted.
 482                          */
 483                         return;
 484                 }
 485                 if (bufsize >= buf->msgsnap_size) {
 486                         /* we collected all of the messages */
 487                         break;
 488                 }
 489                 /* The buffer is too small; allocate a bigger buffer */
 490                 buf = realloc(buf, bufsize = buf->msgsnap_size);
 491         }
 492
 493         /*
 494          * Process each message in the queue (there may be none).
 495          * The first message header starts just after the buffer header.
 496          */
 497         mhead = (struct msgsnap_mhead *)(buf + 1);
 498         for (i = 0; i < buf->msgsnap_nmsg; i++) {
 499                 size_t mlen = mhead->msgsnap_mlen;
 500
 501                 dumpmsg(mhead->msgsnap_mtype, (char *)(mhead + 1), mlen);
 502
 503                 /* advance to next message header */
 504                 /* LINTED alignment */
 505                 mhead = (struct msgsnap_mhead *)
 506                     ((caddr_t)(mhead + 1) + SZROUND(mlen));
 507         }
 508 }
 509
 510 /*
 511  * dumpmsg - dump one message from a message queue.
 512  */
 513 void
 514 dumpmsg(long type, char *msg, size_t msgsize)
 515 {
 516         size_t i, j, k;
 517         int c;
 518
 519         (void) printf(gettext("  message type %ld, size %lu\n"),
 520             type, (ulong_t)msgsize);
 521
 522         for (i = 0; i < msgsize; i += 16) {
 523                 /* first in hex */
 524                 (void) printf(" %5ld:  ", (ulong_t)i);
 525                 for (j = 0; j < 16; j++) {
 526                         if ((k = i + j) < msgsize)
 527                                 (void) printf("%2.2x ", msg[k] & 0xff);
 528                         else
 529                                 (void) printf("   ");
 530                 }
 531                 /* then in ascii */
 532                 (void) printf("   ");
 533                 for (j = 0; j < 16; j++) {
 534                         if ((k = i + j) >= msgsize)
 535                                 break;
 536                         c = msg[k] & 0xff;
 537                         if (isascii(c) && isprint(c))
 538                                 (void) printf("%c", c);
 539                         else
 540                                 (void) printf(".");
 541                 }
 542                 (void) printf("\n");
 543         }
 544 }
 545
 546 /* convert string containing zone name or id to a numeric id */
 547 static zoneid_t
 548 getzone(char *arg)
 549 {
 550         zoneid_t zoneid;
 551
 552         if (zone_get_id(arg, &zoneid) != 0) {
 553                 (void) fprintf(stderr,
 554                     gettext("ipcs: unknown zone: %s\n"), arg);
 555                 exit(1);
 556         }
 557         return (zoneid);
 558 }
 559
 560 static void
 561 printzone(zoneid_t id)
 562 {
 563         char zone_name[ZONENAME_MAX];
 564
 565         if (getzonenamebyid(id, zone_name, sizeof (zone_name)) < 0)
 566                 (void) printf("%9d", (int)id);
 567         else
 568                 (void) printf("%9.8s", zone_name);
 569 }