#include <mqueue.h>

int mq_notify(mqd_t mqdes, const struct sigevent *notification);

/* Returns: 0 on success, -1 on error */

/* Defined in <signal.h> */

struct sigevent {
    int    sigev_notify;              /* Notification method: SIGEV_NONE,
                                         SIGEV_SIGNAL, or SIGEV_THREAD    */

    int    sigev_signo;               /* Signal number (used with SIGEV_SIGNAL) */

    union sigval sigev_value;         /* Data passed to signal handler or
                                         thread function                   */

    void (*sigev_notify_function)(union sigval);
                                      /* Thread function (used with SIGEV_THREAD) */

    void  *sigev_notify_attributes;  /* Thread attributes — cast to pthread_attr_t*
                                         or pass NULL for defaults          */
};

union sigval {
    int   sival_int;   /* Integer value — use for simple numeric data */
    void *sival_ptr;   /* Pointer value — use to pass a struct/object  */
};

You choose one member. For thread notification, sival_ptr is commonly used to pass a pointer to the message queue descriptor or a context struct. For signal notification with realtime signals, this value is accessible in the signal handler via siginfo_t.si_value.

#include <signal.h>
#include <mqueue.h>

int main(void)
{
    mqd_t mqd;
    struct sigevent sev;

    /* Open an existing queue in read-only mode */
    mqd = mq_open("/myqueue", O_RDONLY);
    if (mqd == (mqd_t)-1) {
        perror("mq_open");
        return 1;
    }

    /* Fill in sigevent for signal notification */
    sev.sigev_notify = SIGEV_SIGNAL;
    sev.sigev_signo  = SIGUSR1;          /* Which signal to send */
    sev.sigev_value.sival_int = 42;      /* Optional data (only useful with
                                            realtime signals) */

    /* Register for notification */
    if (mq_notify(mqd, &sev) == -1) {
        perror("mq_notify");
        return 1;
    }

    /* ... process does other work ...
       When a message arrives on an empty queue, SIGUSR1 is sent.
       Registration is removed after first notification — must call
       mq_notify() again inside the signal handler / loop. */

    return 0;
}

#include <signal.h>
#include <mqueue.h>
#include <stdio.h>

void register_placeholder(mqd_t mqd)
{
    struct sigevent sev;

    sev.sigev_notify = SIGEV_NONE;
    /* sigev_signo and other fields are ignored for SIGEV_NONE */

    if (mq_notify(mqd, &sev) == -1)
        perror("mq_notify SIGEV_NONE");
    else
        printf("Placeholder registration set — no other process can register\n");
}

void deregister(mqd_t mqd)
{
    /* Pass NULL to remove registration entirely */
    if (mq_notify(mqd, NULL) == -1)
        perror("mq_notify deregister");
    else
        printf("Registration removed\n");
}

#include <signal.h>
#include <mqueue.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

/* This function is called in a new thread when notification arrives */
void notify_handler(union sigval sv)
{
    mqd_t *mqdp = (mqd_t *)sv.sival_ptr;
    printf("Notification received! Queue descriptor: %d\n", *mqdp);
    /* Read messages from *mqdp here */
    pthread_exit(NULL);
}

int main(void)
{
    mqd_t mqd;
    struct sigevent sev;

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

    /* Pass a pointer to mqd as the argument to the thread function */
    sev.sigev_notify            = SIGEV_THREAD;
    sev.sigev_notify_function   = notify_handler;
    sev.sigev_notify_attributes = NULL;         /* Default thread attrs */
    sev.sigev_value.sival_ptr   = &mqd;         /* Passed to handler */

    if (mq_notify(mqd, &sev) == -1) {
        perror("mq_notify");
        return 1;
    }

    /* Main thread sleeps; notification thread will wake up */
    pause();
    return 0;
}