Below is how the key fields of msqid_ds relate to the operations that affect them:

SUSv3 (the POSIX standard) mandates all the fields above except __msg_cbytes. The double-underscore prefix is a conventional Linux signal that the field is an implementation extension. Despite this, most real UNIX variants (Solaris, HP-UX, AIX, FreeBSD) provide an equivalent field because tracking current queue occupancy in bytes is practically essential.

This program creates a message queue, sends one message, then reads and prints all key fields of the associated msqid_ds structure using IPC_STAT.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/msg.h>
#include <time.h>

/* Message structure for msgsnd/msgrcv */
struct my_msg {
    long mtype;          /* message type - must be > 0 */
    char mtext[64];      /* message payload */
};

int main(void)
{
    int msqid;
    struct msqid_ds ds;
    struct my_msg msg;

    /* Step 1: Create a private message queue (key = IPC_PRIVATE) */
    msqid = msgget(IPC_PRIVATE, IPC_CREAT | 0600);
    if (msqid == -1) {
        perror("msgget");
        exit(EXIT_FAILURE);
    }
    printf("Created message queue, msqid = %d\n\n", msqid);

    /* Step 2: Send one message to the queue */
    msg.mtype = 1;
    strncpy(msg.mtext, "Hello EmbeddedPathashala", sizeof(msg.mtext));
    if (msgsnd(msqid, &msg, strlen(msg.mtext) + 1, 0) == -1) {
        perror("msgsnd");
        exit(EXIT_FAILURE);
    }
    printf("Sent message: \"%s\"\n\n", msg.mtext);

    /* Step 3: Retrieve msqid_ds structure using IPC_STAT */
    if (msgctl(msqid, IPC_STAT, &ds) == -1) {
        perror("msgctl IPC_STAT");
        exit(EXIT_FAILURE);
    }

    /* Step 4: Print all important fields */
    printf("===== msqid_ds Fields =====\n");
    printf("msg_qnum   (messages in queue)  : %lu\n",
           (unsigned long) ds.msg_qnum);
    printf("msg_qbytes (max bytes allowed)  : %lu\n",
           (unsigned long) ds.msg_qbytes);
    printf("msg_lspid  (last sender PID)    : %d\n",
           (int) ds.msg_lspid);
    printf("msg_lrpid  (last receiver PID)  : %d\n",
           (int) ds.msg_lrpid);
    printf("msg_ctime  (last change time)   : %s",
           ctime(&ds.msg_ctime));

    /* Step 5: Cleanup - remove the queue */
    if (msgctl(msqid, IPC_RMID, NULL) == -1) {
        perror("msgctl IPC_RMID");
        exit(EXIT_FAILURE);
    }
    printf("\nMessage queue removed.\n");
    return 0;
}

This example mirrors Listing 46-5 from TLPI. It shows how to use IPC_STAT to fetch the current structure, modify msg_qbytes, and push the update back with IPC_SET. The pattern is always: read first, modify, write back.

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

int main(void)
{
    int msqid;
    struct msqid_ds ds;

    /* Create a private message queue */
    msqid = msgget(IPC_PRIVATE, IPC_CREAT | 0600);
    if (msqid == -1) { perror("msgget"); exit(1); }

    /* --- Read current state --- */
    if (msgctl(msqid, IPC_STAT, &ds) == -1) {
        perror("msgctl IPC_STAT"); exit(1);
    }
    printf("Before: msg_qbytes = %lu bytes\n",
           (unsigned long) ds.msg_qbytes);

    /*
     * Modify msg_qbytes.
     * Unprivileged process: max = MSGMNB (typically 16384)
     * Privileged process  : max = INT_MAX
     *
     * Here we set it to 4096 bytes (lower than default).
     * Once the queue holds 4096 bytes of message data,
     * further msgsnd() calls will block.
     */
    ds.msg_qbytes = 4096;

    /* --- Write back to kernel --- */
    if (msgctl(msqid, IPC_SET, &ds) == -1) {
        perror("msgctl IPC_SET"); exit(1);
    }

    /* Verify the change */
    if (msgctl(msqid, IPC_STAT, &ds) == -1) {
        perror("msgctl IPC_STAT verify"); exit(1);
    }
    printf("After : msg_qbytes = %lu bytes\n",
           (unsigned long) ds.msg_qbytes);

    /* Cleanup */
    msgctl(msqid, IPC_RMID, NULL);
    printf("Queue removed.\n");
    return 0;
}