util-linux/ipcs.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * ipcs.c -- provides information on allocated ipc resources.
   4  *
   5  * 01 Sept 2004 - Rodney Radford <rradford@mindspring.com>
   6  * Adapted for busybox from util-linux-2.12a.
   7  *
   8  * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
   9  */
  10
  11 /* X/OPEN tells us to use <sys/{types,ipc,sem}.h> for semctl() */
  12 /* X/OPEN tells us to use <sys/{types,ipc,msg}.h> for msgctl() */
  13 /* X/OPEN tells us to use <sys/{types,ipc,shm}.h> for shmctl() */
  14 #include <sys/types.h>
  15 #include <sys/ipc.h>
  16 #include <sys/sem.h>
  17 #include <sys/msg.h>
  18 #include <sys/shm.h>
  19
  20 #include "libbb.h"
  21
  22 /*-------------------------------------------------------------------*/
  23 /* SHM_DEST and SHM_LOCKED are defined in kernel headers,
  24    but inside #ifdef __KERNEL__ ... #endif */
  25 #ifndef SHM_DEST
  26 /* shm_mode upper byte flags */
  27 #define SHM_DEST        01000   /* segment will be destroyed on last detach */
  28 #define SHM_LOCKED      02000   /* segment will not be swapped */
  29 #endif
  30
  31 /* For older kernels the same holds for the defines below */
  32 #ifndef MSG_STAT
  33 #define MSG_STAT        11
  34 #define MSG_INFO        12
  35 #endif
  36
  37 #ifndef SHM_STAT
  38 #define SHM_STAT        13
  39 #define SHM_INFO        14
  40 struct shm_info {
  41         int used_ids;
  42         ulong shm_tot;          /* total allocated shm */
  43         ulong shm_rss;          /* total resident shm */
  44         ulong shm_swp;          /* total swapped shm */
  45         ulong swap_attempts;
  46         ulong swap_successes;
  47 };
  48 #endif
  49
  50 #ifndef SEM_STAT
  51 #define SEM_STAT        18
  52 #define SEM_INFO        19
  53 #endif
  54
  55 /* Some versions of libc only define IPC_INFO when __USE_GNU is defined. */
  56 #ifndef IPC_INFO
  57 #define IPC_INFO        3
  58 #endif
  59 /*-------------------------------------------------------------------*/
  60
  61 /* The last arg of semctl is a union semun, but where is it defined?
  62    X/OPEN tells us to define it ourselves, but until recently
  63    Linux include files would also define it. */
  64 #if defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED)
  65 /* union semun is defined by including <sys/sem.h> */
  66 #else
  67 /* according to X/OPEN we have to define it ourselves */
  68 union semun {
  69         int val;
  70         struct semid_ds *buf;
  71         unsigned short int *array;
  72         struct seminfo *__buf;
  73 };
  74 #endif
  75
  76 /* X/OPEN (Jan 1987) does not define fields key, seq in struct ipc_perm;
  77    libc 4/5 does not mention struct ipc_term at all, but includes
  78    <linux/ipc.h>, which defines a struct ipc_perm with such fields.
  79    glibc-1.09 has no support for sysv ipc.
  80    glibc 2 uses __key, __seq */
  81 #if defined(__GNU_LIBRARY__) && __GNU_LIBRARY__ > 1
  82 #define KEY __key
  83 #else
  84 #define KEY key
  85 #endif
  86
  87 #define LIMITS 1
  88 #define STATUS 2
  89 #define CREATOR 3
  90 #define TIME 4
  91 #define PID 5
  92
  93 static char format;
  94
  95 static void print_perms(int id, struct ipc_perm *ipcp)
  96 {
  97         struct passwd *pw;
  98         struct group *gr;
  99
 100         printf("%-10d %-10o", id, ipcp->mode & 0777);
 101
 102         if ((pw = getpwuid(ipcp->cuid)))
 103                 printf(" %-10s", pw->pw_name);
 104         else
 105                 printf(" %-10d", ipcp->cuid);
 106         if ((gr = getgrgid(ipcp->cgid)))
 107                 printf(" %-10s", gr->gr_name);
 108         else
 109                 printf(" %-10d", ipcp->cgid);
 110
 111         if ((pw = getpwuid(ipcp->uid)))
 112                 printf(" %-10s", pw->pw_name);
 113         else
 114                 printf(" %-10d", ipcp->uid);
 115         if ((gr = getgrgid(ipcp->gid)))
 116                 printf(" %-10s\n", gr->gr_name);
 117         else
 118                 printf(" %-10d\n", ipcp->gid);
 119 }
 120
 121
 122 static void do_shm(void)
 123 {
 124         int maxid, shmid, id;
 125         struct shmid_ds shmseg;
 126         struct shm_info shm_info;
 127         struct shminfo shminfo;
 128         struct ipc_perm *ipcp = &shmseg.shm_perm;
 129         struct passwd *pw;
 130
 131         maxid = shmctl(0, SHM_INFO, (struct shmid_ds *) (void *) &shm_info);
 132         if (maxid < 0) {
 133                 printf("kernel not configured for %s\n", "shared memory");
 134                 return;
 135         }
 136
 137         switch (format) {
 138         case LIMITS:
 139                 printf("------ Shared Memory %s --------\n", "Limits");
 140                 if ((shmctl(0, IPC_INFO, (struct shmid_ds *) (void *) &shminfo)) < 0)
 141                         return;
 142                 /* glibc 2.1.3 and all earlier libc's have ints as fields
 143                    of struct shminfo; glibc 2.1.91 has unsigned long; ach */
 144                 printf("max number of segments = %lu\n"
 145                                   "max seg size (kbytes) = %lu\n"
 146                                   "max total shared memory (pages) = %lu\n"
 147                                   "min seg size (bytes) = %lu\n",
 148                                   (unsigned long) shminfo.shmmni,
 149                                   (unsigned long) (shminfo.shmmax >> 10),
 150                                   (unsigned long) shminfo.shmall,
 151                                   (unsigned long) shminfo.shmmin);
 152                 return;
 153
 154         case STATUS:
 155                 printf("------ Shared Memory %s --------\n", "Status");
 156                 printf(   "segments allocated %d\n"
 157                                   "pages allocated %ld\n"
 158                                   "pages resident  %ld\n"
 159                                   "pages swapped   %ld\n"
 160                                   "Swap performance: %ld attempts\t%ld successes\n",
 161                                   shm_info.used_ids,
 162                                   shm_info.shm_tot,
 163                                   shm_info.shm_rss,
 164                                   shm_info.shm_swp,
 165                                   shm_info.swap_attempts, shm_info.swap_successes);
 166                 return;
 167
 168         case CREATOR:
 169                 printf("------ Shared Memory %s --------\n", "Segment Creators/Owners");
 170                 printf(   "%-10s %-10s %-10s %-10s %-10s %-10s\n",
 171                                   "shmid", "perms", "cuid", "cgid", "uid", "gid");
 172                 break;
 173
 174         case TIME:
 175                 printf("------ Shared Memory %s --------\n", "Attach/Detach/Change Times");
 176                 printf(   "%-10s %-10s %-20s %-20s %-20s\n",
 177                                   "shmid", "owner", "attached", "detached", "changed");
 178                 break;
 179
 180         case PID:
 181                 printf("------ Shared Memory %s --------\n", "Creator/Last-op");
 182                 printf(   "%-10s %-10s %-10s %-10s\n",
 183                                   "shmid", "owner", "cpid", "lpid");
 184                 break;
 185
 186         default:
 187                 printf("------ Shared Memory %s --------\n", "Segments");
 188                 printf(   "%-10s %-10s %-10s %-10s %-10s %-10s %-12s\n",
 189                                   "key", "shmid", "owner", "perms", "bytes", "nattch",
 190                                   "status");
 191                 break;
 192         }
 193
 194         for (id = 0; id <= maxid; id++) {
 195                 shmid = shmctl(id, SHM_STAT, &shmseg);
 196                 if (shmid < 0)
 197                         continue;
 198                 if (format == CREATOR) {
 199                         print_perms(shmid, ipcp);
 200                         continue;
 201                 }
 202                 pw = getpwuid(ipcp->uid);
 203                 switch (format) {
 204                 case TIME:
 205                         if (pw)
 206                                 printf("%-10d %-10.10s", shmid, pw->pw_name);
 207                         else
 208                                 printf("%-10d %-10d", shmid, ipcp->uid);
 209                         /* ctime uses static buffer: use separate calls */
 210                         printf(" %-20.16s", shmseg.shm_atime
 211                                           ? ctime(&shmseg.shm_atime) + 4 : "Not set");
 212                         printf(" %-20.16s", shmseg.shm_dtime
 213                                           ? ctime(&shmseg.shm_dtime) + 4 : "Not set");
 214                         printf(" %-20.16s\n", shmseg.shm_ctime
 215                                           ? ctime(&shmseg.shm_ctime) + 4 : "Not set");
 216                         break;
 217                 case PID:
 218                         if (pw)
 219                                 printf("%-10d %-10.10s", shmid, pw->pw_name);
 220                         else
 221                                 printf("%-10d %-10d", shmid, ipcp->uid);
 222                         printf(" %-10d %-10d\n", shmseg.shm_cpid, shmseg.shm_lpid);
 223                         break;
 224
 225                 default:
 226                         printf("0x%08x ", ipcp->KEY);
 227                         if (pw)
 228                                 printf("%-10d %-10.10s", shmid, pw->pw_name);
 229                         else
 230                                 printf("%-10d %-10d", shmid, ipcp->uid);
 231                         printf(" %-10o %-10lu %-10ld %-6s %-6s\n", ipcp->mode & 0777,
 232                                           /*
 233                                            * earlier: int, Austin has size_t
 234                                            */
 235                                           (unsigned long) shmseg.shm_segsz,
 236                                           /*
 237                                            * glibc-2.1.3 and earlier has unsigned short;
 238                                            * Austin has shmatt_t
 239                                            */
 240                                           (long) shmseg.shm_nattch,
 241                                           ipcp->mode & SHM_DEST ? "dest" : " ",
 242                                           ipcp->mode & SHM_LOCKED ? "locked" : " ");
 243                         break;
 244                 }
 245         }
 246 }
 247
 248
 249 static void do_sem(void)
 250 {
 251         int maxid, semid, id;
 252         struct semid_ds semary;
 253         struct seminfo seminfo;
 254         struct ipc_perm *ipcp = &semary.sem_perm;
 255         struct passwd *pw;
 256         union semun arg;
 257
 258         arg.array = (ushort *) (void *) &seminfo;
 259         maxid = semctl(0, 0, SEM_INFO, arg);
 260         if (maxid < 0) {
 261                 printf("kernel not configured for %s\n", "semaphores");
 262                 return;
 263         }
 264
 265         switch (format) {
 266         case LIMITS:
 267                 printf("------ Semaphore %s --------\n", "Limits");
 268                 arg.array = (ushort *) (void *) &seminfo;       /* damn union */
 269                 if ((semctl(0, 0, IPC_INFO, arg)) < 0)
 270                         return;
 271                 printf("max number of arrays = %d\n"
 272                                   "max semaphores per array = %d\n"
 273                                   "max semaphores system wide = %d\n"
 274                                   "max ops per semop call = %d\n"
 275                                   "semaphore max value = %d\n",
 276                                   seminfo.semmni,
 277                                   seminfo.semmsl,
 278                                   seminfo.semmns, seminfo.semopm, seminfo.semvmx);
 279                 return;
 280
 281         case STATUS:
 282                 printf("------ Semaphore %s --------\n", "Status");
 283                 printf(   "used arrays = %d\n"
 284                                   "allocated semaphores = %d\n",
 285                                   seminfo.semusz, seminfo.semaem);
 286                 return;
 287
 288         case CREATOR:
 289                 printf("------ Semaphore %s --------\n", "Arrays Creators/Owners");
 290                 printf(   "%-10s %-10s %-10s %-10s %-10s %-10s\n",
 291                                   "semid", "perms", "cuid", "cgid", "uid", "gid");
 292                 break;
 293
 294         case TIME:
 295                 printf("------ Shared Memory %s --------\n", "Operation/Change Times");
 296                 printf(   "%-8s %-10s %-26.24s %-26.24s\n",
 297                                   "shmid", "owner", "last-op", "last-changed");
 298                 break;
 299
 300         case PID:
 301                 break;
 302
 303         default:
 304                 printf("------ Semaphore %s --------\n", "Arrays");
 305                 printf(   "%-10s %-10s %-10s %-10s %-10s\n",
 306                                   "key", "semid", "owner", "perms", "nsems");
 307                 break;
 308         }
 309
 310         for (id = 0; id <= maxid; id++) {
 311                 arg.buf = (struct semid_ds *) &semary;
 312                 semid = semctl(id, 0, SEM_STAT, arg);
 313                 if (semid < 0)
 314                         continue;
 315                 if (format == CREATOR) {
 316                         print_perms(semid, ipcp);
 317                         continue;
 318                 }
 319                 pw = getpwuid(ipcp->uid);
 320                 switch (format) {
 321                 case TIME:
 322                         if (pw)
 323                                 printf("%-8d %-10.10s", semid, pw->pw_name);
 324                         else
 325                                 printf("%-8d %-10d", semid, ipcp->uid);
 326                         /* ctime uses static buffer: use separate calls */
 327                         printf("  %-26.24s", semary.sem_otime
 328                                           ? ctime(&semary.sem_otime) : "Not set");
 329                         printf(" %-26.24s\n", semary.sem_ctime
 330                                           ? ctime(&semary.sem_ctime) : "Not set");
 331                         break;
 332                 case PID:
 333                         break;
 334
 335                 default:
 336                         printf("0x%08x ", ipcp->KEY);
 337                         if (pw)
 338                                 printf("%-10d %-10.9s", semid, pw->pw_name);
 339                         else
 340                                 printf("%-10d %-9d", semid, ipcp->uid);
 341                         printf(" %-10o %-10ld\n", ipcp->mode & 0777,
 342                                           /*
 343                                            * glibc-2.1.3 and earlier has unsigned short;
 344                                            * glibc-2.1.91 has variation between
 345                                            * unsigned short and unsigned long
 346                                            * Austin prescribes unsigned short.
 347                                            */
 348                                           (long) semary.sem_nsems);
 349                         break;
 350                 }
 351         }
 352 }
 353
 354
 355 static void do_msg(void)
 356 {
 357         int maxid, msqid, id;
 358         struct msqid_ds msgque;
 359         struct msginfo msginfo;
 360         struct ipc_perm *ipcp = &msgque.msg_perm;
 361         struct passwd *pw;
 362
 363         maxid = msgctl(0, MSG_INFO, (struct msqid_ds *) (void *) &msginfo);
 364         if (maxid < 0) {
 365                 printf("kernel not configured for %s\n", "message queues");
 366                 return;
 367         }
 368
 369         switch (format) {
 370         case LIMITS:
 371                 if ((msgctl(0, IPC_INFO, (struct msqid_ds *) (void *) &msginfo)) < 0)
 372                         return;
 373                 printf("------ Message%s --------\n", "s: Limits");
 374                 printf(   "max queues system wide = %d\n"
 375                                   "max size of message (bytes) = %d\n"
 376                                   "default max size of queue (bytes) = %d\n",
 377                                   msginfo.msgmni, msginfo.msgmax, msginfo.msgmnb);
 378                 return;
 379
 380         case STATUS:
 381                 printf("------ Message%s --------\n", "s: Status");
 382                 printf(   "allocated queues = %d\n"
 383                                   "used headers = %d\n"
 384                                   "used space = %d bytes\n",
 385                                   msginfo.msgpool, msginfo.msgmap, msginfo.msgtql);
 386                 return;
 387
 388         case CREATOR:
 389                 printf("------ Message%s --------\n", " Queues: Creators/Owners");
 390                 printf(   "%-10s %-10s %-10s %-10s %-10s %-10s\n",
 391                                   "msqid", "perms", "cuid", "cgid", "uid", "gid");
 392                 break;
 393
 394         case TIME:
 395                 printf("------ Message%s --------\n", " Queues Send/Recv/Change Times");
 396                 printf(   "%-8s %-10s %-20s %-20s %-20s\n",
 397                                   "msqid", "owner", "send", "recv", "change");
 398                 break;
 399
 400         case PID:
 401                 printf("------ Message%s --------\n", " Queues PIDs");
 402                 printf(   "%-10s %-10s %-10s %-10s\n",
 403                                   "msqid", "owner", "lspid", "lrpid");
 404                 break;
 405
 406         default:
 407                 printf("------ Message%s --------\n", " Queues");
 408                 printf(   "%-10s %-10s %-10s %-10s %-12s %-12s\n",
 409                                   "key", "msqid", "owner", "perms", "used-bytes", "messages");
 410                 break;
 411         }
 412
 413         for (id = 0; id <= maxid; id++) {
 414                 msqid = msgctl(id, MSG_STAT, &msgque);
 415                 if (msqid < 0)
 416                         continue;
 417                 if (format == CREATOR) {
 418                         print_perms(msqid, ipcp);
 419                         continue;
 420                 }
 421                 pw = getpwuid(ipcp->uid);
 422                 switch (format) {
 423                 case TIME:
 424                         if (pw)
 425                                 printf("%-8d %-10.10s", msqid, pw->pw_name);
 426                         else
 427                                 printf("%-8d %-10d", msqid, ipcp->uid);
 428                         printf(" %-20.16s", msgque.msg_stime
 429                                           ? ctime(&msgque.msg_stime) + 4 : "Not set");
 430                         printf(" %-20.16s", msgque.msg_rtime
 431                                           ? ctime(&msgque.msg_rtime) + 4 : "Not set");
 432                         printf(" %-20.16s\n", msgque.msg_ctime
 433                                           ? ctime(&msgque.msg_ctime) + 4 : "Not set");
 434                         break;
 435                 case PID:
 436                         if (pw)
 437                                 printf("%-8d %-10.10s", msqid, pw->pw_name);
 438                         else
 439                                 printf("%-8d %-10d", msqid, ipcp->uid);
 440                         printf("  %5d     %5d\n", msgque.msg_lspid, msgque.msg_lrpid);
 441                         break;
 442
 443                 default:
 444                         printf("0x%08x ", ipcp->KEY);
 445                         if (pw)
 446                                 printf("%-10d %-10.10s", msqid, pw->pw_name);
 447                         else
 448                                 printf("%-10d %-10d", msqid, ipcp->uid);
 449                         printf(" %-10o %-12ld %-12ld\n", ipcp->mode & 0777,
 450                                           /*
 451                                            * glibc-2.1.3 and earlier has unsigned short;
 452                                            * glibc-2.1.91 has variation between
 453                                            * unsigned short, unsigned long
 454                                            * Austin has msgqnum_t
 455                                            */
 456                                           (long) msgque.msg_cbytes, (long) msgque.msg_qnum);
 457                         break;
 458                 }
 459         }
 460 }
 461
 462
 463 static void print_shm(int shmid)
 464 {
 465         struct shmid_ds shmds;
 466         struct ipc_perm *ipcp = &shmds.shm_perm;
 467
 468         if (shmctl(shmid, IPC_STAT, &shmds) == -1) {
 469                 bb_perror_msg("shmctl");
 470                 return;
 471         }
 472
 473         printf("\nShared memory Segment shmid=%d\n"
 474                           "uid=%d\tgid=%d\tcuid=%d\tcgid=%d\n"
 475                           "mode=%#o\taccess_perms=%#o\n"
 476                           "bytes=%ld\tlpid=%d\tcpid=%d\tnattch=%ld\n",
 477                           shmid,
 478                           ipcp->uid, ipcp->gid, ipcp->cuid, ipcp->cgid,
 479                           ipcp->mode, ipcp->mode & 0777,
 480                           (long) shmds.shm_segsz, shmds.shm_lpid, shmds.shm_cpid,
 481                           (long) shmds.shm_nattch);
 482         printf("att_time=%-26.24s\n",
 483                           shmds.shm_atime ? ctime(&shmds.shm_atime) : "Not set");
 484         printf("det_time=%-26.24s\n",
 485                           shmds.shm_dtime ? ctime(&shmds.shm_dtime) : "Not set");
 486         printf("change_time=%-26.24s\n\n", ctime(&shmds.shm_ctime));
 487 }
 488
 489
 490 static void print_msg(int msqid)
 491 {
 492         struct msqid_ds buf;
 493         struct ipc_perm *ipcp = &buf.msg_perm;
 494
 495         if (msgctl(msqid, IPC_STAT, &buf) == -1) {
 496                 bb_perror_msg("msgctl");
 497                 return;
 498         }
 499
 500         printf("\nMessage Queue msqid=%d\n"
 501                           "uid=%d\tgid=%d\tcuid=%d\tcgid=%d\tmode=%#o\n"
 502                           "cbytes=%ld\tqbytes=%ld\tqnum=%ld\tlspid=%d\tlrpid=%d\n",
 503                           msqid, ipcp->uid, ipcp->gid, ipcp->cuid, ipcp->cgid, ipcp->mode,
 504                           /*
 505                            * glibc-2.1.3 and earlier has unsigned short;
 506                            * glibc-2.1.91 has variation between
 507                            * unsigned short, unsigned long
 508                            * Austin has msgqnum_t (for msg_qbytes)
 509                            */
 510                           (long) buf.msg_cbytes, (long) buf.msg_qbytes,
 511                           (long) buf.msg_qnum, buf.msg_lspid, buf.msg_lrpid);
 512
 513         printf("send_time=%-26.24s\n",
 514                           buf.msg_stime ? ctime(&buf.msg_stime) : "Not set");
 515         printf("rcv_time=%-26.24s\n",
 516                           buf.msg_rtime ? ctime(&buf.msg_rtime) : "Not set");
 517         printf("change_time=%-26.24s\n\n",
 518                           buf.msg_ctime ? ctime(&buf.msg_ctime) : "Not set");
 519 }
 520
 521 static void print_sem(int semid)
 522 {
 523         struct semid_ds semds;
 524         struct ipc_perm *ipcp = &semds.sem_perm;
 525         union semun arg;
 526         unsigned int i;
 527
 528         arg.buf = &semds;
 529         if (semctl(semid, 0, IPC_STAT, arg)) {
 530                 bb_perror_msg("semctl");
 531                 return;
 532         }
 533
 534         printf("\nSemaphore Array semid=%d\n"
 535                           "uid=%d\t gid=%d\t cuid=%d\t cgid=%d\n"
 536                           "mode=%#o, access_perms=%#o\n"
 537                           "nsems = %ld\n"
 538                           "otime = %-26.24s\n",
 539                           semid,
 540                           ipcp->uid, ipcp->gid, ipcp->cuid, ipcp->cgid,
 541                           ipcp->mode, ipcp->mode & 0777,
 542                           (long) semds.sem_nsems,
 543                           semds.sem_otime ? ctime(&semds.sem_otime) : "Not set");
 544         printf("ctime = %-26.24s\n"
 545                           "%-10s %-10s %-10s %-10s %-10s\n",
 546                           ctime(&semds.sem_ctime),
 547                           "semnum", "value", "ncount", "zcount", "pid");
 548
 549         arg.val = 0;
 550         for (i = 0; i < semds.sem_nsems; i++) {
 551                 int val, ncnt, zcnt, pid;
 552
 553                 val = semctl(semid, i, GETVAL, arg);
 554                 ncnt = semctl(semid, i, GETNCNT, arg);
 555                 zcnt = semctl(semid, i, GETZCNT, arg);
 556                 pid = semctl(semid, i, GETPID, arg);
 557                 if (val < 0 || ncnt < 0 || zcnt < 0 || pid < 0) {
 558                         bb_perror_msg_and_die("semctl");
 559                 }
 560                 printf("%-10d %-10d %-10d %-10d %-10d\n", i, val, ncnt, zcnt, pid);
 561         }
 562         puts("");
 563 }
 564
 565 int ipcs_main(int argc, char **argv);
 566 int ipcs_main(int argc, char **argv)
 567 {
 568         int id = 0;
 569         unsigned flags = 0;
 570         unsigned opt;
 571         char *opt_i;
 572 #define flag_print      (1<<0)
 573 #define flag_msg        (1<<1)
 574 #define flag_sem        (1<<2)
 575 #define flag_shm        (1<<3)
 576
 577         opt = getopt32(argv, "i:aqsmtcplu", &opt_i);
 578         if (opt & 0x1) { // -i
 579                 id = xatoi(opt_i);
 580                 flags |= flag_print;
 581         }
 582         if (opt & 0x2) flags |= flag_msg | flag_sem | flag_shm; // -a
 583         if (opt & 0x4) flags |= flag_msg; // -q
 584         if (opt & 0x8) flags |= flag_sem; // -s
 585         if (opt & 0x10) flags |= flag_shm; // -m
 586         if (opt & 0x20) format = TIME; // -t
 587         if (opt & 0x40) format = CREATOR; // -c
 588         if (opt & 0x80) format = PID; // -p
 589         if (opt & 0x100) format = LIMITS; // -l
 590         if (opt & 0x200) format = STATUS; // -u
 591
 592         if (flags & flag_print) {
 593                 if (flags & flag_shm) {
 594                         print_shm(id);
 595                         fflush_stdout_and_exit(0);
 596                 }
 597                 if (flags & flag_sem) {
 598                         print_sem(id);
 599                         fflush_stdout_and_exit(0);
 600                 }
 601                 if (flags & flag_msg) {
 602                         print_msg(id);
 603                         fflush_stdout_and_exit(0);
 604                 }
 605                 bb_show_usage();
 606         }
 607
 608         if (!(flags & (flag_shm | flag_msg | flag_sem)))
 609                 flags |= flag_msg | flag_shm | flag_sem;
 610         puts("");
 611
 612         if (flags & flag_shm) {
 613                 do_shm();
 614                 puts("");
 615         }
 616         if (flags & flag_sem) {
 617                 do_sem();
 618                 puts("");
 619         }
 620         if (flags & flag_msg) {
 621                 do_msg();
 622                 puts("");
 623         }
 624         fflush_stdout_and_exit(0);
 625 }