Internally, the Linux kernel maintains an array called the entries array to track all System V IPC objects (message queues, semaphores, shared memory segments). Each slot in this array either holds an active IPC object or is empty. When you call msgget(), the kernel assigns a slot in this array.

The key insight is: the msqid (message queue ID) returned by msgget() is NOT the same as the slot index. The msqid encodes both the slot index and a sequence number. However, to enumerate all queues, we need to iterate over the entries array directly using the index.

MSG_INFO is a Linux-specific (non-POSIX) extension to msgctl(). When called as:

int maxind = msgctl(0, MSG_INFO, (struct msqid_ds *) &msginfo);

It returns the highest used index in the kernel’s entries array. It also fills the msginfo structure (of type struct msginfo) with system-wide statistics.

MSG_STAT is similar to IPC_STAT but with a crucial difference:

The return value of msgctl(ind, MSG_STAT, &ds) is the actual msqid assigned to that queue. This is important because msqid != index.

Get the maximum index and system limits for message queues:

#define _GNU_SOURCE
#include <stdio.h>
#include <sys/types.h>
#include <sys/msg.h>
#include <stdlib.h>

int main(void) {
    struct msginfo info;
    int maxind;

    /* MSG_INFO fills a msginfo struct, returns max used index */
    maxind = msgctl(0, MSG_INFO, (struct msqid_ds *) &info);
    if (maxind == -1) {
        perror("msgctl MSG_INFO");
        exit(EXIT_FAILURE);
    }

    printf("Maximum used index in entries array: %d\n", maxind);
    printf("\n--- System-wide Message Queue Limits ---\n");
    printf("Max message queues (msgmni): %d\n",  info.msgmni);
    printf("Max bytes per queue (msgmnb): %d\n", info.msgmnb);
    printf("Max bytes per message (msgmax): %d\n", info.msgmax);
    printf("Max total messages (msgtql): %d\n",  info.msgtql);

    return 0;
}

This is the core technique from TLPI — enumerate every active queue on the system:

#define _GNU_SOURCE
#include <stdio.h>
#include <sys/types.h>
#include <sys/msg.h>
#include <errno.h>
#include <stdlib.h>

int main(void) {
    int maxind, ind, msqid;
    struct msqid_ds ds;
    struct msginfo msginfo;

    /* Step 1: Get the highest used index in kernel entries array */
    maxind = msgctl(0, MSG_INFO, (struct msqid_ds *) &msginfo);
    if (maxind == -1) {
        perror("msgctl MSG_INFO");
        exit(EXIT_FAILURE);
    }

    printf("maxind: %d\n\n", maxind);
    printf("%-6s %-10s %-12s %s\n", "index", "msqid", "key", "messages");
    printf("----------------------------------------------\n");

    /* Step 2: Iterate over all slots 0..maxind */
    for (ind = 0; ind <= maxind; ind++) {

        /* MSG_STAT uses array index, returns the msqid */
        msqid = msgctl(ind, MSG_STAT, &ds);

        if (msqid == -1) {
            /* EINVAL = empty slot, EACCES = no permission — both are normal */
            if (errno != EINVAL && errno != EACCES)
                perror("msgctl MSG_STAT (unexpected)");
            continue;   /* Skip this slot */
        }

        /* Print info about this active queue */
        printf("%-6d %-10d 0x%08lx  %7ld\n",
               ind,
               msqid,
               (unsigned long) ds.msg_perm.__key,
               (long) ds.msg_qnum);   /* Number of messages currently in queue */
    }

    return 0;
}

Extract full metadata for each queue including byte counts, owner, permissions, and timestamps:

#define _GNU_SOURCE
#include <stdio.h>
#include <sys/types.h>
#include <sys/msg.h>
#include <time.h>
#include <errno.h>
#include <stdlib.h>

int main(void) {
    int maxind, ind, msqid;
    struct msqid_ds ds;
    struct msginfo msginfo;

    maxind = msgctl(0, MSG_INFO, (struct msqid_ds *) &msginfo);
    if (maxind == -1) { perror("msgctl"); exit(1); }

    for (ind = 0; ind <= maxind; ind++) {
        msqid = msgctl(ind, MSG_STAT, &ds);
        if (msqid == -1) {
            if (errno != EINVAL && errno != EACCES)
                perror("msgctl MSG_STAT");
            continue;
        }

        printf("\n=== Queue at index %d (msqid = %d) ===\n", ind, msqid);
        printf("  IPC key      : 0x%08lx\n", (unsigned long)ds.msg_perm.__key);
        printf("  Owner UID    : %u\n",   ds.msg_perm.uid);
        printf("  Owner GID    : %u\n",   ds.msg_perm.gid);
        printf("  Permissions  : %04o\n", ds.msg_perm.mode & 0777);
        printf("  Messages now : %lu\n",  (unsigned long)ds.msg_qnum);
        printf("  Bytes now    : %lu\n",  (unsigned long)ds.msg_cbytes);
        printf("  Max bytes    : %lu\n",  (unsigned long)ds.msg_qbytes);
        printf("  Last send    : %s",     ctime(&ds.msg_stime));
        printf("  Last receive : %s",     ctime(&ds.msg_rtime));
        printf("  Last change  : %s",     ctime(&ds.msg_ctime));
    }

    return 0;
}

Both IPC_STAT and MSG_STAT fill a struct msqid_ds. Understanding its fields is essential for system programming: