Section 46.9 — Limitations of System V Message Queues

Kernel Limits — Reading and Tuning

## View current kernel limits for message queues
$ cat /proc/sys/kernel/msgmax   # Max size of a single message (bytes)
8192

$ cat /proc/sys/kernel/msgmnb   # Max bytes in a single queue
16384

$ cat /proc/sys/kernel/msgmni   # Max number of queues system-wide
32000

## Temporarily increase (lost on reboot)
$ sudo sysctl -w kernel.msgmnb=65536
$ sudo sysctl -w kernel.msgmni=1024

## Permanently increase (survives reboot) — add to /etc/sysctl.conf:
kernel.msgmnb = 65536
kernel.msgmni = 1024
kernel.msgmax = 65536

/* limits_demo.c — Show queue limits from inside C */
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

int main(void)
{
    /* msginfo holds system-wide limits */
    struct msginfo info;
    if (msgctl(0, IPC_INFO, (struct msqid_ds *)&info) == -1) {
        perror("msgctl IPC_INFO");
        return 1;
    }
    printf("MSGMAX (max msg bytes) : %d\n", info.msgmax);
    printf("MSGMNB (max queue bytes): %d\n", info.msgmnb);
    printf("MSGMNI (max queues)     : %d\n", info.msgmni);
    printf("MSGTQL (max messages)   : %d\n", info.msgtql);
    printf("MSGPOOL (msg pool size) : %d KB\n", info.msgpool);
    return 0;
}

System V vs POSIX Message Queues

POSIX message queues (mq_open) were designed to fix the limitations of System V. Here’s a direct comparison:

Quick POSIX Message Queue Example

/* posix_mq_demo.c — POSIX alternative to System V */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <mqueue.h>
#include <fcntl.h>

#define QUEUE_NAME  "/demo_queue"
#define MAX_MSG     128
#define MAX_MSGS    10

int main(void)
{
    struct mq_attr attr = {
        .mq_flags   = 0,
        .mq_maxmsg  = MAX_MSGS,
        .mq_msgsize = MAX_MSG,
        .mq_curmsgs = 0
    };

    /* Create queue — note the /name style, like a file */
    mqd_t mq = mq_open(QUEUE_NAME, O_CREAT | O_RDWR, 0666, &attr);
    if (mq == (mqd_t)-1) { perror("mq_open"); return 1; }

    /* Send — has a built-in priority argument (0=lowest) */
    const char *msg = "Hello from POSIX MQ";
    if (mq_send(mq, msg, strlen(msg)+1, 0) == -1) {
        perror("mq_send"); return 1;
    }
    printf("Sent: '%s'\n", msg);

    /* Receive */
    char buf[MAX_MSG];
    unsigned int prio;
    ssize_t n = mq_receive(mq, buf, MAX_MSG, &prio);
    if (n == -1) { perror("mq_receive"); return 1; }
    printf("Received (priority=%u): '%s'\n", prio, buf);

    /* Close and unlink — like close() + unlink() for files */
    mq_close(mq);
    mq_unlink(QUEUE_NAME);  /* Remove the named queue */
    return 0;
}
/* Compile: gcc posix_mq_demo.c -o posix_mq_demo -lrt */

Decision Guide: Which IPC Mechanism to Choose

Chapter 46 — Complete Summary

Quick Reference Card

/* === System V Message Queue Quick Reference === */

/* 1. Create/Open */
int qid = msgget(IPC_PRIVATE,  IPC_CREAT | 0666);        // private
int qid = msgget(ftok("/f",'A'), IPC_CREAT | 0666);       // shared
int qid = msgget(key,  IPC_CREAT | IPC_EXCL | 0666);     // fail if exists
int qid = msgget(key,  0666);                              // open only

/* 2. Message structure */
struct Msg { long mtype; /* your data */ };

/* 3. Send */
msgsnd(qid, &msg, sizeof(msg.payload_only), 0);           // blocking
msgsnd(qid, &msg, sizeof(msg.payload_only), IPC_NOWAIT);  // non-blocking

/* 4. Receive */
msgrcv(qid, &buf, max_payload, 0,   0);        // first any type
msgrcv(qid, &buf, max_payload, 5,   0);        // type=5 only
msgrcv(qid, &buf, max_payload, -5,  0);        // lowest type <=5
msgrcv(qid, &buf, max_payload, 0,   IPC_NOWAIT);  // non-blocking

/* 5. Control */
msgctl(qid, IPC_STAT, &ds);   // read info
msgctl(qid, IPC_SET,  &ds);   // change settings
msgctl(qid, IPC_RMID, NULL);  // delete — always do this!

/* 6. Shell */
// ipcs -q          list queues
// ipcrm -q msqid   remove by ID