/* Defined in <sys/msg.h> */
struct msqid_ds {
    struct ipc_perm  msg_perm;      /* Ownership and permissions */
    time_t           msg_stime;     /* Time of last msgsnd() */
    time_t           msg_rtime;     /* Time of last msgrcv() */
    time_t           msg_ctime;     /* Time of last change (creation or IPC_SET) */
    unsigned long    __msg_cbytes;  /* Current bytes in queue (non-standard) */
    msgqnum_t        msg_qnum;      /* Number of messages currently in queue */
    msglen_t         msg_qbytes;    /* Maximum bytes allowed in queue */
    pid_t            msg_lspid;     /* PID of process that called last msgsnd() */
    pid_t            msg_lrpid;     /* PID of process that called last msgrcv() */
};

AUTO = updated automatically by the kernel   IPC_SET = can be updated via IPC_SET

The msg_perm field is itself a structure. It is the same ipc_perm sub-structure used across all System V IPC objects (message queues, semaphores, shared memory).

struct ipc_perm {
    key_t          __key;    /* Key supplied to msgget() — non-modifiable */
    uid_t          uid;      /* Effective UID of owner — settable via IPC_SET */
    gid_t          gid;      /* Effective GID of owner — settable via IPC_SET */
    uid_t          cuid;     /* Effective UID of creator — NOT settable */
    gid_t          cgid;     /* Effective GID of creator — NOT settable */
    unsigned short mode;     /* Permission bits (rwxrwxrwx format) — settable via IPC_SET */
    unsigned short __seq;    /* Sequence number (used in msqid generation) */
};

All three timestamp fields — msg_stime, msg_rtime, msg_ctime — are of type time_t and store time as seconds since the Unix Epoch (midnight, 1 January 1970, UTC). This is the same format as the value returned by time().

A value of 0 in msg_stime or msg_rtime means “this operation has never occurred on this queue.” This is a useful sentinel: if msg_stime is 0, the queue has never had a message sent to it. If msg_rtime is 0, no message has ever been received from it.

msg_ctime is different — it is set to the current time at the moment of queue creation and also updated whenever IPC_SET is called. It records the last “configuration change” to the queue, similar to the st_ctime field in a file’s stat structure.

This field is the most operationally important one for system performance. It controls how much data can accumulate in the queue before msgsnd() is forced to block.

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

/* Helper: print time_t field. Shows "Never" if t == 0 */
static void print_time(const char *label, time_t t)
{
    if (t == 0)
        printf("%-28s: Never\n", label);
    else
        printf("%-28s: %s", label, ctime(&t)); /* ctime adds \n */
}

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

    /* Create a private queue with read+write for owner only */
    msqid = msgget(IPC_PRIVATE, 0600);
    if (msqid == -1) { perror("msgget"); exit(1); }

    /* Read queue metadata */
    if (msgctl(msqid, IPC_STAT, &info) == -1) {
        perror("msgctl IPC_STAT");
        exit(1);
    }

    printf("====== msqid_ds contents (msqid=%d) ======\n\n", msqid);

    /* Ownership and permissions */
    printf("%-28s: %d\n",    "msg_perm.uid  (owner)",  info.msg_perm.uid);
    printf("%-28s: %d\n",    "msg_perm.gid  (owner)",  info.msg_perm.gid);
    printf("%-28s: %d\n",    "msg_perm.cuid (creator)", info.msg_perm.cuid);
    printf("%-28s: %d\n",    "msg_perm.cgid (creator)", info.msg_perm.cgid);
    printf("%-28s: %04o\n",  "msg_perm.mode (perms)",  info.msg_perm.mode & 0777);

    /* Timestamps */
    print_time("msg_stime (last msgsnd)", info.msg_stime);
    print_time("msg_rtime (last msgrcv)", info.msg_rtime);
    print_time("msg_ctime (last change)", info.msg_ctime);

    /* Queue statistics */
    printf("%-28s: %lu\n", "msg_qnum  (messages now)",
           (unsigned long)info.msg_qnum);
    printf("%-28s: %lu bytes\n", "msg_qbytes (max capacity)",
           (unsigned long)info.msg_qbytes);
    printf("%-28s: %d\n", "msg_lspid (last sender PID)",  info.msg_lspid);
    printf("%-28s: %d\n", "msg_lrpid (last receiver PID)", info.msg_lrpid);

    /* Cleanup */
    msgctl(msqid, IPC_RMID, NULL);
    return 0;
}
/*
 * Sample Output (right after creation — no messages sent/received yet):
 *   ====== msqid_ds contents (msqid=98308) ======
 *   msg_perm.uid  (owner)      : 1000
 *   msg_perm.gid  (owner)      : 1000
 *   msg_perm.cuid (creator)    : 1000
 *   msg_perm.cgid (creator)    : 1000
 *   msg_perm.mode (perms)      : 0600
 *   msg_stime (last msgsnd)    : Never
 *   msg_rtime (last msgrcv)    : Never
 *   msg_ctime (last change)    : Mon Jun  8 09:00:00 2026
 *   msg_qnum  (messages now)   : 0
 *   msg_qbytes (max capacity)  : 16384 bytes
 *   msg_lspid (last sender PID): 0
 *   msg_lrpid (last receiver PID): 0
 */

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

struct message {
    long mtype;
    char mtext[64];
};

static void show_queue_stats(int msqid, const char *when)
{
    struct msqid_ds info;
    if (msgctl(msqid, IPC_STAT, &info) == -1) {
        perror("msgctl IPC_STAT"); return;
    }
    printf("\n--- State: %-30s ---\n", when);
    printf("  msg_qnum  (messages in queue): %lu\n",
           (unsigned long)info.msg_qnum);
    printf("  msg_stime (last send)         : %s",
           info.msg_stime ? ctime(&info.msg_stime) : "Never\n");
    printf("  msg_rtime (last recv)         : %s",
           info.msg_rtime ? ctime(&info.msg_rtime) : "Never\n");
    printf("  msg_lspid (last sender PID)   : %d\n",  info.msg_lspid);
    printf("  msg_lrpid (last receiver PID) : %d\n",  info.msg_lrpid);
}

int main(void)
{
    int msqid;
    struct message msg;

    msqid = msgget(IPC_PRIVATE, 0600);
    if (msqid == -1) { perror("msgget"); exit(1); }

    /* --- State 1: Just after creation --- */
    show_queue_stats(msqid, "After creation");

    /* --- Send a message --- */
    msg.mtype = 1;
    strncpy(msg.mtext, "Hello from EmbeddedPathashala!", sizeof(msg.mtext)-1);
    if (msgsnd(msqid, &msg, strlen(msg.mtext)+1, 0) == -1) {
        perror("msgsnd"); exit(1);
    }

    /* --- State 2: After sending --- */
    show_queue_stats(msqid, "After msgsnd()");

    /* --- Receive the message --- */
    if (msgrcv(msqid, &msg, sizeof(msg.mtext), 0, 0) == -1) {
        perror("msgrcv"); exit(1);
    }

    /* --- State 3: After receiving --- */
    show_queue_stats(msqid, "After msgrcv()");

    msgctl(msqid, IPC_RMID, NULL);
    return 0;
}
/*
 * This example clearly shows:
 *  - msg_qnum goes 0 → 1 → 0 as a message is sent then received
 *  - msg_stime is "Never" until the first msgsnd()
 *  - msg_rtime is "Never" until the first msgrcv()
 *  - msg_lspid and msg_lrpid are 0 until the first send/receive
 */