The mq_attr Structure

The mq_attr structure holds four fields. You set two of them when creating the queue and read all four when querying an existing queue.

Reading Attributes with mq_getattr()

mq_getattr() reads the current attributes of a message queue and fills the mq_attr structure you provide. It is like calling fstat() but for a message queue.

mqdes — the message queue descriptor returned by mq_open().
attr — pointer to an mq_attr structure that will be filled with the current attributes.

Example 1: Read and Display Queue Attributes

/* compile: gcc -o pmsg_getattr pmsg_getattr.c -lrt */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <mqueue.h>

int main(int argc, char *argv[])
{
    mqd_t mqd;
    struct mq_attr attr;

    if (argc != 2) {
        fprintf(stderr, "Usage: %s /queue-name\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    /* Open queue read-only — we just want to inspect it */
    mqd = mq_open(argv[1], O_RDONLY);
    if (mqd == (mqd_t) -1) {
        perror("mq_open");
        exit(EXIT_FAILURE);
    }

    /* Retrieve attributes */
    if (mq_getattr(mqd, &attr) == -1) {
        perror("mq_getattr");
        exit(EXIT_FAILURE);
    }

    printf("mq_flags  (O_NONBLOCK set?): %s\n",
           (attr.mq_flags & O_NONBLOCK) ? "YES" : "NO");
    printf("mq_maxmsg (max messages)   : %ld\n", attr.mq_maxmsg);
    printf("mq_msgsize (max msg size)  : %ld bytes\n", attr.mq_msgsize);
    printf("mq_curmsgs (current count) : %ld\n", attr.mq_curmsgs);

    mq_close(mqd);
    exit(EXIT_SUCCESS);
}

Linux Default Values for mq_maxmsg and mq_msgsize

If you pass NULL as the final argument to mq_open() when creating a queue, Linux uses its built-in defaults. These are:

Modifying Attributes with mq_setattr()

mq_setattr() lets you change the flags on an open queue description. The only flag you can change is O_NONBLOCK. Optionally, it can also return the old attributes at the same time (like an atomic read-then-write).

newattr — only the mq_flags field is examined. Other fields are ignored.
oldattr — if not NULL, filled with the previous attributes (same as calling mq_getattr() first).

Example 2: Enable O_NONBLOCK on an Existing Queue

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

int main(void)
{
    mqd_t mqd;
    struct mq_attr attr;

    /* Open queue for writing (queue must already exist) */
    mqd = mq_open("/myqueue", O_WRONLY);
    if (mqd == (mqd_t) -1) { perror("mq_open"); exit(1); }

    /* Step 1: read current flags */
    if (mq_getattr(mqd, &attr) == -1) { perror("mq_getattr"); exit(1); }

    /* Step 2: set the O_NONBLOCK bit */
    attr.mq_flags |= O_NONBLOCK;

    /* Step 3: write back — pass NULL since we don't need old attrs */
    if (mq_setattr(mqd, &attr, NULL) == -1) { perror("mq_setattr"); exit(1); }

    printf("O_NONBLOCK enabled on /myqueue\n");
    mq_close(mqd);
    return 0;
}

Example 3: Disable O_NONBLOCK (Switch Back to Blocking)

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

void set_blocking(mqd_t mqd)
{
    struct mq_attr attr;

    if (mq_getattr(mqd, &attr) == -1) { perror("mq_getattr"); return; }

    /* Clear the O_NONBLOCK bit using bitwise AND with complement */
    attr.mq_flags &= ~O_NONBLOCK;

    if (mq_setattr(mqd, &attr, NULL) == -1) { perror("mq_setattr"); return; }

    printf("Queue is now BLOCKING\n");
}

int main(void)
{
    mqd_t mqd = mq_open("/myqueue", O_RDONLY | O_NONBLOCK);
    if (mqd == (mqd_t) -1) { perror("mq_open"); exit(1); }

    set_blocking(mqd);   /* switch to blocking */

    mq_close(mqd);
    return 0;
}

Example 4: Save Old Flags and Change Atomically

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

int main(void)
{
    mqd_t mqd;
    struct mq_attr newattr, oldattr;

    mqd = mq_open("/myqueue", O_RDWR);
    if (mqd == (mqd_t) -1) { perror("mq_open"); exit(1); }

    /* We want to set O_NONBLOCK but also record what the flags were before */
    if (mq_getattr(mqd, &newattr) == -1) { perror("mq_getattr"); exit(1); }
    newattr.mq_flags |= O_NONBLOCK;

    /* oldattr receives the PREVIOUS state before the change */
    if (mq_setattr(mqd, &newattr, &oldattr) == -1) {
        perror("mq_setattr"); exit(1);
    }

    printf("Previous flags: %ld (O_NONBLOCK was %s)\n",
           oldattr.mq_flags,
           (oldattr.mq_flags & O_NONBLOCK) ? "SET" : "CLEAR");

    printf("Current flags:  %ld (O_NONBLOCK is now SET)\n", newattr.mq_flags);

    mq_close(mqd);
    return 0;
}

Interview Questions & Answers