¿El uso concurrente de sigwait y signalfd en un programa multihilo resulta en una condición de carrera?

Estoy escribiendo un programa multi-threaded en el cual, entre otras cosas, tengo un hilo escuchando un socket para conexiones de red entrantes. Para permitir que esto se interrumpa, estoy utilizando poll en combinación con signalfd (en lugar de una llamada await cruda). Sin embargo, también tengo otros hilos a los que necesito notificar de posibles interrupciones, por lo que estoy utilizando una llamada sigwait en un hilo dedicado para esperar señales. Mi intento de hacer que la competencia ocurra está en el siguiente código:

int main()
{
    int sigval = 0;

    sigset_t mask;
    sigemptyset(&mask);
    sigaddset(&mask, SIGINT);
    pthread_sigmask(SIG_BLOCK, &mask, nullptr);

    int sfd = signalfd(-1, &mask, SFD_NONBLOCK);

    auto handler = std::thread([&] {
        int signal;
        sigwait(&mask, &signal);
        sigval = signal;
    });

    pollfd pfd[1] = {{.fd=sfd, .events=POLLIN}};

    int ret = poll(pfd, 1, -1);

    std::cout << "Poll returned with revents = " << pfd[0].revents << std::endl;

    handler.join();

    std::cout << "Handled thread set sigval to: " << sigval << std::endl;

    return 0;
}

Cada vez que ejecuto esto y lo interrumpo con SIGINT, parece funcionar, en el sentido de que la llamada poll devuelve, y sigval es establecido por el hilo del manejador. Sin embargo, mi entendimiento es que sigwait consume la señal, mientras que signalfd no lo hace. Entonces, si de alguna manera sigwait fuera llamado antes de que signalfd recibiera la notificación de la señal, este programa podría quedarse colgado para siempre (con poll esperando una señal que no llega). Asumo que, dado que no puedo lograr que el programa se quede colgado, hay algo bajo la capucha que evita que esto ocurra, pero ¿puedo garantizar que esto siempre será cierto?