#include <sys/types.h>    /* For portability */
#include <sys/msg.h>

int msgctl(int msqid, int cmd, struct msqid_ds *buf);

/* Returns: 0 on success, -1 on error (errno set) */

Parameters explained:

The cmd argument controls what operation msgctl() performs. There are three fundamental values:

msgctl() can be called at any stage — not just at the end. For example, you might call it after msgget() to adjust the queue’s byte limit before any messages are sent, or periodically call it with IPC_STAT to monitor queue depth.

This is the most common use of msgctl(). Every queue you create should be cleaned up — otherwise it persists in kernel memory until the system reboots.

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

int main(void)
{
    key_t key;
    int   msqid;

    /* Step 1: Generate a unique key for this queue */
    key = ftok("/tmp", 'A');
    if (key == -1) {
        perror("ftok");
        exit(EXIT_FAILURE);
    }

    /* Step 2: Create (or open) the message queue */
    msqid = msgget(key, IPC_CREAT | 0660);
    if (msqid == -1) {
        perror("msgget");
        exit(EXIT_FAILURE);
    }
    printf("Queue created. msqid = %d\n", msqid);

    /* Step 3: ... (send/receive messages here) ... */

    /* Step 4: Delete the queue when done */
    /* IPC_RMID: third argument is ignored — pass NULL */
    if (msgctl(msqid, IPC_RMID, NULL) == -1) {
        perror("msgctl IPC_RMID");
        exit(EXIT_FAILURE);
    }
    printf("Queue msqid=%d deleted successfully.\n", msqid);

    return 0;
}
/*
 * Output:
 *   Queue created. msqid = 32769
 *   Queue msqid=32769 deleted successfully.
 *
 * Important: After IPC_RMID, any process blocked on msgsnd()
 * or msgrcv() on this queue will be woken up and their call
 * will return -1 with errno == EIDRM.
 */

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

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

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

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

    printf("=== IPC_STAT Results ===\n");
    printf("Owner UID       : %d\n",  info.msg_perm.uid);
    printf("Owner GID       : %d\n",  info.msg_perm.gid);
    printf("Permissions     : %o\n",  info.msg_perm.mode & 0777);
    printf("Messages in queue: %lu\n", (unsigned long)info.msg_qnum);
    printf("Max queue bytes : %lu\n", (unsigned long)info.msg_qbytes);
    printf("Last msgsnd() time: %s",
           (info.msg_stime == 0) ? "Never\n" : ctime(&info.msg_stime));
    printf("Last msgrcv() time: %s",
           (info.msg_rtime == 0) ? "Never\n" : ctime(&info.msg_rtime));
    printf("PID of last sender  : %d\n", info.msg_lspid);
    printf("PID of last receiver: %d\n", info.msg_lrpid);

    /* ---- IPC_SET: Change permissions ----
     * Best practice: start from IPC_STAT result, then modify only
     * the fields you need. This avoids accidental overwrites.
     */
    info.msg_perm.mode = 0666;  /* Allow rw for everyone */

    if (msgctl(msqid, IPC_SET, &info) == -1) {
        perror("msgctl IPC_SET");
        exit(1);
    }
    printf("\nPermissions updated to 0666.\n");

    /* Confirm the change */
    if (msgctl(msqid, IPC_STAT, &info) == -1) {
        perror("msgctl IPC_STAT (verify)");
        exit(1);
    }
    printf("New permissions : %o\n", info.msg_perm.mode & 0777);

    /* Cleanup */
    msgctl(msqid, IPC_RMID, NULL);
    return 0;
}
/*
 * Sample Output:
 *   === IPC_STAT Results ===
 *   Owner UID       : 1000
 *   Owner GID       : 1000
 *   Permissions     : 600
 *   Messages in queue: 0
 *   Max queue bytes : 16384
 *   Last msgsnd() time: Never
 *   Last msgrcv() time: Never
 *   PID of last sender  : 0
 *   PID of last receiver: 0
 *
 *   Permissions updated to 0666.
 *   New permissions : 666
 */

This is a subtle but important behaviour that comes up in interviews:

/* Robust msgrcv() that handles queue deletion gracefully */
ssize_t result = msgrcv(msqid, &msg, sizeof(msg.mtext), 0, 0);
if (result == -1) {
    if (errno == EIDRM) {
        /* The queue was deleted while we were waiting.
           This is a normal shutdown scenario — exit cleanly. */
        printf("Queue was removed. Exiting...\n");
        exit(EXIT_SUCCESS);
    } else if (errno == EINTR) {
        /* Interrupted by a signal — retry or exit depending on design */
        printf("Interrupted by signal. Retrying...\n");
        /* ... retry logic ... */
    } else {
        perror("msgrcv");
        exit(EXIT_FAILURE);
    }
}

You can also inspect and remove System V message queues from the command line using standard Linux tools. This is very useful for debugging.