These three limits are the primary constraints. When any of these is hit, a specific system call fails with a specific error code.

Some UNIX implementations define two additional limits. Linux does not enforce these directly, but they appear in older documentation and other OS man pages.

It is legal to send a message with an mtext size of 0 bytes. However, even though the message carries no data, it still consumes kernel overhead (for bookkeeping, the message header, etc.). Without a limit on these, a process could flood the queue with infinite zero-length messages.

Linux handles this by treating zero-length messages as equivalent to 1-byte messages when counting against the msg_qbytes limit. So the maximum number of zero-length messages you can put in a queue equals the maximum number of 1-byte messages — which is bounded by msg_qbytes.

Linux exposes all three enforced limits as readable/writable files under /proc/sys/kernel/. This means you can:

• Read current limit: cat /proc/sys/kernel/msgmni
• Change limit (as root): echo 2048 > /proc/sys/kernel/msgmni
• Make permanent across reboots: add to /etc/sysctl.conf

Changes to MSGMNB via /proc affect all subsequently created message queues (the initial msg_qbytes for new queues), as well as raising the ceiling for unprivileged IPC_SET calls on existing queues.

Instead of reading /proc files, your program can query the kernel for all message queue limits at once using the Linux-specific msgctl(IPC_INFO) operation. This fills a struct msginfo with the current values of all limits.

The struct msginfo includes fields such as:

This program reads all three system-wide message queue limits from the /proc filesystem and prints them in a human-readable form.

#include <stdio.h>
#include <stdlib.h>

/* Helper: read a single integer from a /proc file */
static long read_proc_int(const char *path)
{
    FILE *fp;
    long val;

    fp = fopen(path, "r");
    if (fp == NULL) {
        perror(path);
        return -1;
    }
    if (fscanf(fp, "%ld", &val) != 1)
        val = -1;
    fclose(fp);
    return val;
}

int main(void)
{
    long msgmni, msgmax, msgmnb;

    msgmni = read_proc_int("/proc/sys/kernel/msgmni");
    msgmax = read_proc_int("/proc/sys/kernel/msgmax");
    msgmnb = read_proc_int("/proc/sys/kernel/msgmnb");

    printf("===== System V Message Queue Limits =====\n\n");
    printf("MSGMNI  (max queues on system)  : %ld\n", msgmni);
    printf("MSGMAX  (max bytes per message) : %ld bytes\n", msgmax);
    printf("MSGMNB  (max bytes per queue)   : %ld bytes\n", msgmnb);
    printf("\n");
    printf("Notes:\n");
    printf("  - Unprivileged IPC_SET: msg_qbytes max = MSGMNB (%ld)\n", msgmnb);
    printf("  - Privileged IPC_SET : msg_qbytes max = INT_MAX (2147483647)\n");
    printf("  - To change: echo VALUE > /proc/sys/kernel/msgmni (as root)\n");
    return 0;
}

This program uses the Linux-specific IPC_INFO operation of msgctl() to read the msginfo structure and display all message queue limits programmatically (no file I/O needed).

#define _GNU_SOURCE          /* Required to get IPC_INFO and struct msginfo */
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/msg.h>

int main(void)
{
    struct msginfo info;

    /*
     * IPC_INFO: Linux-specific operation.
     * First arg (msqid) is ignored — pass 0.
     * Cast the msginfo pointer to (struct msqid_ds *) as required by API.
     * Returns the highest occupied slot in the message queue table.
     */
    if (msgctl(0, IPC_INFO, (struct msqid_ds *) &info) == -1) {
        perror("msgctl IPC_INFO");
        exit(EXIT_FAILURE);
    }

    printf("===== msginfo (from IPC_INFO) =====\n\n");
    printf("msgmni  (max queues)            : %d\n", info.msgmni);
    printf("msgmax  (max bytes/message)     : %d bytes\n", info.msgmax);
    printf("msgmnb  (max bytes/queue)       : %d bytes\n", info.msgmnb);
    printf("msgtql  (max total messages)    : %d\n", info.msgtql);
    printf("msgpool (kernel buffer pool KB) : %d\n", info.msgpool);
    return 0;
}