← Comunicación entre ProcesosBloque 10 · Protocolos, fallos y diagnóstico · Tema 42 de 52

Tema 42

Integrar señales y temporizadores al bucle

Vas a coordinar datos, cancelación y vencimientos sin depender de revisar una bandera justo antes de dormir. Compararás el despertar mediante self-pipe con la espera de máscara atómica y con los descriptores signalfd y timerfd de Linux. Los ejemplos separan notificación, estado pendiente y trabajo de aplicación para evitar carreras y mantener seguros los manejadores.

1. Tres fuentes de trabajo en un bucle

Los temas 37 a 40 coordinaron descriptores y el tema 41 definió un contrato de mensajes. Un servicio también necesita reaccionar cuando se pide terminar, recargar estado o vencer un plazo. Esas decisiones deben convivir con la E/S, sin ejecutarse dentro de un manejador inseguro.

FuenteNotificación posibleTrabajo del flujo principal
Datos.Descriptor preparado.Leer, alimentar el parser y conservar pendientes.
Señal.Bandera y despertar, espera atómica o signalfd.Cancelar, recargar o recoger hijos según la política.
Tiempo.Timeout de espera o timerfd.Revisar plazos y programar acciones vencidas.

La notificación indica que hay algo que revisar. El estado pendiente indica qué falta atender. El bucle decide qué trabajo ejecutar y cómo terminarlo.

Los tres programas son de un solo hilo y administran SIGUSR1, SIGINT y SIGTERM. SIGUSR1 solicita una recarga didáctica; SIGINT y SIGTERM solicitan fin ordenado con código 128 + señal. El vencimiento normal termina con cero. No instalan control para SIGKILL ni SIGSTOP, que no pueden capturarse de esa manera.

2. La carrera entre comprobar y esperar

secuencia incorrecta · la señal llega en la ventana intermedia
flujo principal                     señal
if (!parar)                         /* todavia es falso */
                                    manejador: parar = 1
select(..., timeout = NULL)          /* la señal ya fue atendida */
                                    /* puede no llegar otra señal */

El manejador hizo su trabajo, pero no interrumpió una espera que todavía no había comenzado. El bucle puede dormir aunque la bandera esté activa. volatile sig_atomic_t permite comunicar ese estado básico; no vuelve atómicas las dos operaciones de comprobar y esperar.

Una espera periódica limita el retraso si se programó deliberadamente así, pero no elimina la ventana ni ofrece respuesta inmediata. Las soluciones que estudiaremos conservan un despertar pendiente o cambian la máscara de forma atómica respecto de la espera.

Tres formas de conservar la relación entre señal y esperaSelf-pipe deja un byte observable junto con una bandera. pselect o ppoll mantienen bloqueadas las señales hasta el cambio atómico de máscara al esperar. signalfd recibe señales bloqueadas como registros de un descriptor. Self-pipebandera pendientey byte de despertarpselect / ppollbloqueo fuerade la espera atómicasignalfdseñal bloqueadaleída como registroLa aplicación atiende el trabajo en su flujo principal.
Las tres estrategias tienen precondiciones de máscara, propiedad y limpieza.

3. Manejadores mínimos y trabajo diferido

Un manejador puede interrumpir al programa mientras stdio, memoria dinámica u otras estructuras están en una actualización interna. No debe llamar printf, malloc ni ejecutar la lógica normal de recarga o cierre del servicio.

En los ejemplos con manejador se modifican banderas volatile sig_atomic_t; en self-pipe también se usa write, que es async-signal-safe. Si se toca errno, se conserva al entrar y se restaura antes de retornar. La lista y las condiciones se documentan en signal-safety(7).

Las señales estándar pueden agruparse. Diez envíos de SIGUSR1 no garantizan diez ejecuciones del manejador ni diez recargas. Una bandera sirve para «hay que revisar», no como una cola fiable de cantidades. Para SIGCHLD se recogerían todos los hijos disponibles, en lugar de suponer un hijo por aviso.

4. El invariante de self-pipe

La aplicación crea una tubería propia y observa su extremo lector en poll, select o epoll. El manejador marca el trabajo pendiente e intenta escribir un byte en el extremo no bloqueante. Si la señal llega antes de la espera, el byte queda legible; si llega durante ella, la interrumpe o hace observable la tubería.

Si write obtiene EAGAIN porque la tubería está llena, no reintenta esperando espacio. Ya existen bytes que mantienen el despertar pendiente y la bandera conserva el trabajo. Los bytes son avisos, no un registro exacto de todas las señales.

Para tomar y limpiar banderas sin perder una señal nueva, el flujo principal bloquea temporalmente las señales gestionadas, drena la tubería, copia el estado y limpia lo que corresponda. Luego restaura la máscara de ejecución. Una señal posterior vuelve a dejar su propia notificación.

Los extremos deben permanecer válidos mientras el manejador pueda usarlos. Al terminar se bloquean primero esas señales, se deshabilita el descriptor usado por el manejador y recién después se cierran ambos extremos.

5. Programa completo con self-pipe

Guarda selfpipe42.c junto a plazo37.h del tema 37. Espera hasta tres segundos desde el arranque del bucle, atiende recargas y puede cancelarse. Usa pipe y fcntl para preparar ambos extremos antes de habilitar las señales.

selfpipe42.c · banderas autoritativas y notificación persistente
#define _POSIX_C_SOURCE 200809L
#include "plazo37.h"
#include <poll.h>
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
#include <inttypes.h>

static volatile sig_atomic_t recargar42, parar42, error42;
static volatile sig_atomic_t aviso42 = -1;

static void notificar42(int signo)
{
    int guardado = errno;
    if (signo == SIGUSR1) recargar42 = 1;
    else if (!parar42) parar42 = signo;
    unsigned char byte = 1;
    ssize_t n;
    do { n = write((int)aviso42, &byte, 1); } while (n == -1 && errno == EINTR);
    if (n != 1 && !(n == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)))
        error42 = 1;
    errno = guardado;
}

static int preparar42(int fd)
{
    int estado = fcntl(fd, F_GETFL), descriptor = fcntl(fd, F_GETFD);
    if (estado == -1 || descriptor == -1 ||
        fcntl(fd, F_SETFL, estado | O_NONBLOCK) == -1 ||
        fcntl(fd, F_SETFD, descriptor | FD_CLOEXEC) == -1) {
        perror("fcntl"); return -1;
    }
    return 0;
}

static int drenar42(int fd)
{
    unsigned char bytes[128];
    for (;;) {
        ssize_t n = read(fd, bytes, sizeof bytes);
        if (n > 0) continue;
        if (n == -1 && errno == EINTR) continue;
        if (n == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) return 0;
        if (n == 0) fprintf(stderr, "EOF inesperado de self-pipe\n");
        else perror("read self-pipe");
        return -1;
    }
}

int main(void)
{
    sigset_t gestionadas, anterior, ejecucion;
    sigemptyset(&gestionadas);
    sigaddset(&gestionadas, SIGUSR1); sigaddset(&gestionadas, SIGINT);
    sigaddset(&gestionadas, SIGTERM);
    if (sigprocmask(SIG_BLOCK, &gestionadas, &anterior) == -1) {
        perror("bloquear"); return EXIT_FAILURE;
    }
    ejecucion = anterior;
    sigdelset(&ejecucion, SIGUSR1); sigdelset(&ejecucion, SIGINT);
    sigdelset(&ejecucion, SIGTERM);
    int canal[2] = { -1, -1 }, salida = EXIT_FAILURE;
    if (pipe(canal) == -1) { perror("pipe"); goto fin; }
    if (preparar42(canal[0]) == -1 || preparar42(canal[1]) == -1) goto fin;
    struct sigaction accion = {0};
    accion.sa_handler = notificar42;
    accion.sa_mask = gestionadas;
    if (sigaction(SIGUSR1, &accion, NULL) == -1 ||
        sigaction(SIGINT, &accion, NULL) == -1 ||
        sigaction(SIGTERM, &accion, NULL) == -1) {
        perror("sigaction"); goto fin;
    }
    aviso42 = canal[1];
    struct timespec limite;
    if (fijar_plazo37(&limite, 3) == -1) goto fin;
    if (sigprocmask(SIG_SETMASK, &ejecucion, NULL) == -1) {
        perror("habilitar"); goto fin;
    }
    printf("Self-pipe listo; PID=%jd; plazo=3 s\n", (intmax_t)getpid());
    if (fflush(stdout) == EOF) goto fin;
    for (;;) {
        if (sigprocmask(SIG_BLOCK, &gestionadas, NULL) == -1) goto fin;
        if (drenar42(canal[0]) == -1) goto fin;
        int recarga = (int)recargar42, fin_senal = (int)parar42, fallo = (int)error42;
        recargar42 = 0;
        if (sigprocmask(SIG_SETMASK, &ejecucion, NULL) == -1) goto fin;
        if (fallo) { fprintf(stderr, "Fallo de notificacion del manejador\n"); goto fin; }
        if (recarga) {
            puts("Recarga atendida en el flujo principal");
            if (fflush(stdout) == EOF) goto fin;
        }
        if (fin_senal) { salida = 128 + fin_senal; break; }
        struct timeval tv;
        int r = restante37(&limite, &tv);
        if (r == -1) goto fin;
        if (r == 0) { salida = EXIT_SUCCESS; break; }
        int ms = (int)(tv.tv_sec * 1000 + (tv.tv_usec + 999) / 1000);
        struct pollfd p = { .fd = canal[0], .events = POLLIN, .revents = 0 };
        r = poll(&p, 1, ms);
        if (r == -1) {
            if (errno == EINTR) continue;
            perror("poll"); goto fin;
        }
        if (r > 0 && (p.revents & (POLLERR | POLLHUP | POLLNVAL))) {
            fprintf(stderr, "Fallo del canal de despertar\n"); goto fin;
        }
    }
fin:
    /* Programa autonomo: las señales gestionadas quedan bloqueadas hasta salir. */
    if (sigprocmask(SIG_BLOCK, &gestionadas, NULL) == -1) return EXIT_FAILURE;
    aviso42 = -1;
    if (canal[1] != -1 && close(canal[1]) == -1) salida = EXIT_FAILURE;
    if (canal[0] != -1 && close(canal[0]) == -1) salida = EXIT_FAILURE;
    return salida;
}

El manejador bloquea las tres señales gestionadas mientras ejecuta su notificación mediante sa_mask. El descriptor se publica solo cuando la tubería y los manejadores ya están preparados. Los fallos de write distintos de tubería llena se conservan para diagnóstico fuera del manejador.

6. Ejecutar y cerrar sin carreras de descriptor

Bash en Linux · compilar y esperar el fin normal
$ gcc -std=c11 -Wall -Wextra -Wpedantic -O2 selfpipe42.c -o selfpipe42
$ ./selfpipe42
Self-pipe listo; PID=4200; plazo=3 s
$ echo $?
0

Para probar recarga y cancelación, un controlador debe esperar el mensaje inicial y enviar SIGUSR1 o SIGTERM al PID real. Una señal puede llegar antes de poll: el byte persistente evita perder ese despertar. El programa no imprime desde el manejador.

Este ejecutable termina después de limpiar y mantiene bloqueadas sus señales durante esa limpieza. No es una función de biblioteca que devuelva el control a otra aplicación. Una biblioteca necesitaría acordar restauración de disposiciones, máscara y señales pendientes; desbloquear ciegamente después de restaurar SIG_DFL podría ejecutar una terminación pendiente.

No cierres el lector mientras el manejador todavía puede escribir: además de un descriptor reutilizado, podría aparecer SIGPIPE. El orden de bloqueo y cierre del ejemplo evita esa situación con los recursos que administra.

7. La espera atómica con pselect y ppoll

Otra solución mantiene las señales bloqueadas mientras el flujo principal revisa y limpia sus banderas. La espera cambia temporalmente a una máscara que permite entregarlas, de forma atómica respecto de dormir. Al retornar se restaura la máscara bloqueada.

invariante · no existe un desbloqueo manual antes de esperar
bloquear señales gestionadas y guardar mascara anterior
instalar manejadores
preparar mascara_de_espera que permita esas señales

en cada vuelta, todavia bloqueadas:
    atender y limpiar banderas
    reconstruir intereses y tiempo restante
    pselect(..., &mascara_de_espera)
    /* o ppoll(..., &mascara_de_espera) */
    /* al retornar, vuelven a estar bloqueadas */

pselect usa fd_set y timespec, y conserva el límite FD_SETSIZE de sus conjuntos. ppoll usa pollfd y timespec. La máscara es la que estará vigente durante la espera, no un listado de «señales que se quieren recibir» para bloquear adicionalmente.

Desbloquear con sigprocmask y llamar después a select o poll mantiene una ventana entre ambas llamadas. Para la operación atómica se usan las interfaces apropiadas, documentadas en pselect(2) y ppoll(2).

8. Programa completo de máscara atómica

Guarda atomica42.c junto a plazo37.h. Elige pselect o ppoll por argumento. Una tubería contiene un byte X que se atiende en el bucle; después se mantiene la espera de señales y plazo, sin confundir ausencia de datos con finalización del programa.

atomica42.c · mismas banderas y dos interfaces de espera
#define _GNU_SOURCE
#include "plazo37.h"
#include <poll.h>
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>
#include <inttypes.h>
#include <stdlib.h>
#include <string.h>

static volatile sig_atomic_t recargar_a42, parar_a42;
static void marcar_a42(int signo)
{
    if (signo == SIGUSR1) recargar_a42 = 1;
    else if (!parar_a42) parar_a42 = signo;
}

int main(int argc, char **argv)
{
    if (argc != 2 || (strcmp(argv[1], "pselect") && strcmp(argv[1], "ppoll"))) {
        fprintf(stderr, "Uso: %s pselect|ppoll\n", argv[0]); return EXIT_FAILURE;
    }
    int usar_pselect = strcmp(argv[1], "pselect") == 0;
    sigset_t gestionadas, anterior, espera;
    sigemptyset(&gestionadas);
    sigaddset(&gestionadas, SIGUSR1); sigaddset(&gestionadas, SIGINT);
    sigaddset(&gestionadas, SIGTERM);
    if (sigprocmask(SIG_BLOCK, &gestionadas, &anterior) == -1) {
        perror("bloquear"); return EXIT_FAILURE;
    }
    espera = anterior;
    sigdelset(&espera, SIGUSR1); sigdelset(&espera, SIGINT);
    sigdelset(&espera, SIGTERM);
    struct sigaction accion = {0};
    accion.sa_handler = marcar_a42; accion.sa_mask = gestionadas;
    if (sigaction(SIGUSR1, &accion, NULL) == -1 ||
        sigaction(SIGINT, &accion, NULL) == -1 ||
        sigaction(SIGTERM, &accion, NULL) == -1) {
        perror("sigaction"); return EXIT_FAILURE;
    }
    int canal[2] = { -1, -1 }, salida = EXIT_FAILURE, pendiente = 1;
    if (pipe2(canal, O_NONBLOCK | O_CLOEXEC) == -1) { perror("pipe2"); goto fin; }
    if (usar_pselect && canal[0] >= FD_SETSIZE) {
        fprintf(stderr, "Descriptor fuera de FD_SETSIZE\n"); goto fin;
    }
    if (write(canal[1], "X", 1) != 1) { perror("precarga"); goto fin; }
    struct timespec limite;
    if (fijar_plazo37(&limite, 3) == -1) goto fin;
    printf("Espera atomica lista: %s; PID=%jd; plazo=3 s\n", argv[1], (intmax_t)getpid());
    if (fflush(stdout) == EOF) goto fin;
    for (;;) {
        /* Estas señales estan bloqueadas fuera de pselect/ppoll. */
        if (recargar_a42) {
            recargar_a42 = 0;
            puts("Recarga atendida en el flujo principal");
            if (fflush(stdout) == EOF) goto fin;
        }
        if (parar_a42) { salida = 128 + (int)parar_a42; break; }
        struct timeval tv;
        int r = restante37(&limite, &tv);
        if (r == -1) goto fin;
        if (r == 0) { salida = EXIT_SUCCESS; break; }
        struct timespec restante = { .tv_sec = tv.tv_sec, .tv_nsec = tv.tv_usec * 1000L };
        if (usar_pselect) {
            fd_set lectura;
            FD_ZERO(&lectura);
            if (pendiente) FD_SET(canal[0], &lectura);
            r = pselect(pendiente ? canal[0] + 1 : 0, &lectura,
                        NULL, NULL, &restante, &espera);
        } else {
            struct pollfd p = { .fd = pendiente ? canal[0] : -1, .events = POLLIN };
            r = ppoll(&p, 1, &restante, &espera);
            if (r > 0 && (p.revents & (POLLERR | POLLHUP | POLLNVAL))) {
                fprintf(stderr, "Fallo del canal de datos\n"); goto fin;
            }
        }
        if (r == -1) {
            if (errno == EINTR) continue;
            perror("espera atomica"); goto fin;
        }
        if (r > 0 && pendiente) {
            char byte;
            ssize_t n = read(canal[0], &byte, 1);
            if (n == 1 && byte == 'X') {
                pendiente = 0; puts("Dato X atendido");
                if (fflush(stdout) == EOF) goto fin;
            } else if (n == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK)) {
                continue;
            } else { fprintf(stderr, "Dato inesperado\n"); goto fin; }
        }
    }
fin:
    /* La mascara bloqueada ya fue restaurada al retornar de la espera. */
    if (canal[1] != -1 && close(canal[1]) == -1) salida = EXIT_FAILURE;
    if (canal[0] != -1 && close(canal[0]) == -1) salida = EXIT_FAILURE;
    return salida;
}
Bash en Linux · dos recorridos equivalentes
$ gcc -std=c11 -Wall -Wextra -Wpedantic -O2 atomica42.c -o atomica42
$ ./atomica42 pselect
Espera atomica lista: pselect; PID=4201; plazo=3 s
Dato X atendido
$ ./atomica42 ppoll
Espera atomica lista: ppoll; PID=4202; plazo=3 s
Dato X atendido

El programa completo se prueba en Linux porque utiliza pipe2 y ppoll. El patrón de máscara con pselect puede aplicarse en entornos POSIX que proporcionen esa interfaz, preparando la tubería con pipe y fcntl cuando corresponda.

9. Plazos, actividad y política de vencimientos

Una señal o un dato no renueva implícitamente el plazo. Los ejemplos conservan una fecha límite monotónica y reconstruyen el restante antes de cada espera, como en el tema 37. Un retorno EINTR no recibe tres segundos nuevos.

Si una aplicación necesita timeout de inactividad, debe definir qué actividad lo renueva: recibir un byte, completar una trama o aceptar trabajo. Ese contrato es distinto de un plazo total. Un emisor que avanza muy lentamente puede satisfacer uno e incumplir el otro.

Con varias fechas límite, la espera se calcula hasta la más próxima y al despertar se revisan las acciones vencidas. El reloj y la planificación no garantizan despertar en un instante exacto ni ejecutar una acción por cada intervalo perdido.

10. Aceptar señales mediante signalfd

En Linux se puede bloquear un conjunto de señales y aceptarlas leyendo un descriptor creado con signalfd. El bucle observa ese descriptor con poll o epoll y ejecuta sus decisiones sin entrar en un manejador tradicional.

C en Linux · bloqueo antes de habilitar la vía de recepción
sigprocmask(SIG_BLOCK, &gestionadas, NULL);
int sfd = signalfd(-1, &gestionadas, SFD_NONBLOCK | SFD_CLOEXEC);
/* Comprobar ambos retornos y registrar sfd en la espera. */

struct signalfd_siginfo info;
/* read(sfd, &info, sizeof info): interpretar solo registros completos. */

Crear el descriptor no bloquea las señales automáticamente. Si se dejan habilitadas para entrega normal, podrían ejecutar su disposición en lugar de recibirse por esta vía. SIGKILL y SIGSTOP no pueden gestionarse con signalfd. Véase signalfd(2).

Una lectura puede devolver varios registros completos si el búfer lo permite. El ejemplo limita el número de lecturas por turno y utiliza level-triggered para retomar lo pendiente. Las señales estándar siguen pudiendo agruparse: signalfd no transforma SIGUSR1 en una cola ilimitada de solicitudes de recarga.

11. Temporizadores observables con timerfd

timerfd_create crea un temporizador de Linux que se hace legible cuando vence. timerfd_settime lo arma con un valor inicial y un intervalo opcional. Una lectura correcta devuelve un uint64_t con la cantidad de vencimientos acumulados desde la lectura anterior.

C en Linux · temporizador periódico de 200 ms
int tfd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK | TFD_CLOEXEC);
struct itimerspec programa = {
    .it_value = { .tv_sec = 0, .tv_nsec = 200000000L },
    .it_interval = { .tv_sec = 0, .tv_nsec = 200000000L }
};
/* timerfd_settime(tfd, 0, &programa, NULL): comprobar retorno. */
/* read(tfd, &cantidad, sizeof cantidad): comprobar exactamente ocho bytes. */

it_value igual a cero desarma el timer. Un intervalo cero con un valor inicial positivo produce un solo vencimiento. TFD_TIMER_ABSTIME permite fijar el vencimiento inicial como fecha absoluta del reloj elegido. Véase timerfd_create(2).

CLOCK_MONOTONIC evita depender de cambios del calendario; CLOCK_BOOTTIME permite incluir suspensión en los intervalos cuando ese es el requisito. Los temporizadores basados en CLOCK_REALTIME y ajustes del reloj necesitan una política propia, incluidas las opciones de cancelación que correspondan.

Si una lectura devuelve cinco, no hay cinco registros distintos de timerfd que deban leerse uno a uno. El bucle decide si resume trabajo, omite ejecuciones atrasadas o recupera una cantidad limitada. Repetir sin límite una tarea costosa por cada vencimiento acumulado puede volver a retrasar el servicio.

12. Programa Linux con señales, timer y datos

Guarda descriptores42.c junto a plazo37.h. Registra tres fuentes en epoll: signalfd, timerfd y un socket con hola ya enviado. Drena y verifica el socket, acumula al menos cinco vencimientos periódicos y permite recarga o cancelación por señales.

El bucle atiende señales notificadas en el lote antes que timer y datos. Esa prioridad es una política local de despacho; no implica un orden cronológico total entre eventos del sistema. Un plazo global de tres segundos limita el ensayo si no completa su contrato normal.

descriptores42.c · control, tiempo y datos dentro de epoll
#define _GNU_SOURCE
#include "plazo37.h"
#include <sys/epoll.h>
#include <sys/signalfd.h>
#include <sys/timerfd.h>
#include <sys/socket.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdlib.h>
#include <string.h>

static int agregar_d42(int epfd, int fd, uint32_t id)
{
    struct epoll_event ev = { .events = EPOLLIN, .data.u32 = id };
    if (epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev) == -1) {
        perror("epoll_ctl ADD"); return -1;
    }
    return 0;
}

static int senales_d42(int fd, int *terminar)
{
    for (unsigned turno = 0; turno < 4; ++turno) {
        struct signalfd_siginfo info[4];
        ssize_t n = read(fd, info, sizeof info);
        if (n > 0 && (size_t)n % sizeof info[0] == 0) {
            size_t cantidad = (size_t)n / sizeof info[0];
            for (size_t i = 0; i < cantidad; ++i) {
                if (info[i].ssi_signo == SIGUSR1) puts("Recarga leida desde signalfd");
                else if (info[i].ssi_signo == SIGINT || info[i].ssi_signo == SIGTERM) {
                    *terminar = (int)info[i].ssi_signo;
                    return 0;
                }
            }
        } else if (n == -1 && errno == EINTR) continue;
        else if (n == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) return 0;
        else { fprintf(stderr, "Lectura incompatible de signalfd\n"); return -1; }
    }
    return 0; /* LT notificara otra vez si queda pendiente. */
}

int main(void)
{
    sigset_t gestionadas;
    sigemptyset(&gestionadas);
    sigaddset(&gestionadas, SIGUSR1); sigaddset(&gestionadas, SIGINT);
    sigaddset(&gestionadas, SIGTERM);
    if (sigprocmask(SIG_BLOCK, &gestionadas, NULL) == -1) {
        perror("bloquear"); return EXIT_FAILURE;
    }
    /* Este ejecutable es dueño de esas disposiciones, incluso si heredo SIG_IGN. */
    struct sigaction normal = {0};
    normal.sa_handler = SIG_DFL;
    sigemptyset(&normal.sa_mask);
    if (sigaction(SIGUSR1, &normal, NULL) == -1 ||
        sigaction(SIGINT, &normal, NULL) == -1 ||
        sigaction(SIGTERM, &normal, NULL) == -1) {
        perror("sigaction"); return EXIT_FAILURE;
    }
    int epfd = -1, sfd = -1, tfd = -1, par[2] = { -1, -1 };
    int salida = EXIT_FAILURE, terminar = 0, armado = 0, datos_fin = 0;
    size_t usados = 0;
    char datos[4];
    uint64_t vencimientos = 0;
    sfd = signalfd(-1, &gestionadas, SFD_NONBLOCK | SFD_CLOEXEC);
    if (sfd == -1) { perror("signalfd"); goto fin; }
    tfd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK | TFD_CLOEXEC);
    if (tfd == -1) { perror("timerfd_create"); goto fin; }
    epfd = epoll_create1(EPOLL_CLOEXEC);
    if (epfd == -1) { perror("epoll_create1"); goto fin; }
    if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC,
                   0, par) == -1) { perror("socketpair"); goto fin; }
    ssize_t enviados;
    do { enviados = send(par[0], "hola", 4, MSG_NOSIGNAL); }
    while (enviados == -1 && errno == EINTR);
    if (enviados != 4) { fprintf(stderr, "Precarga de socket incompleta\n"); goto fin; }
    int emisor = par[0]; par[0] = -1;
    if (close(emisor) == -1) { perror("close emisor"); goto fin; }
    if (agregar_d42(epfd, sfd, 1) == -1 || agregar_d42(epfd, tfd, 2) == -1 ||
        agregar_d42(epfd, par[1], 3) == -1) goto fin;
    struct itimerspec programa = {
        .it_value = { .tv_sec = 0, .tv_nsec = 200000000L },
        .it_interval = { .tv_sec = 0, .tv_nsec = 200000000L }
    };
    if (timerfd_settime(tfd, 0, &programa, NULL) == -1) {
        perror("timerfd_settime"); goto fin;
    }
    armado = 1;
    struct timespec limite;
    if (fijar_plazo37(&limite, 3) == -1) goto fin;
    printf("Descriptores42 listo; PID=%jd; periodo=200 ms\n", (intmax_t)getpid());
    if (fflush(stdout) == EOF) goto fin;
    while (!terminar && !(datos_fin && vencimientos >= 5)) {
        struct timeval tv;
        int tiempo = restante37(&limite, &tv);
        if (tiempo == -1) goto fin;
        if (tiempo == 0) { fprintf(stderr, "Plazo global agotado\n"); goto fin; }
        int ms = (int)(tv.tv_sec * 1000 + (tv.tv_usec + 999) / 1000);
        struct epoll_event ev[3];
        int n = epoll_wait(epfd, ev, 3, ms);
        if (n == -1) {
            if (errno == EINTR) continue;
            perror("epoll_wait"); goto fin;
        }
        for (int i = 0; i < n; ++i) {
            if (ev[i].data.u32 < 1 || ev[i].data.u32 > 3) {
                fprintf(stderr, "Identidad de evento invalida\n"); goto fin;
            }
            if (ev[i].events & EPOLLERR) {
                fprintf(stderr, "Error en una fuente de eventos\n"); goto fin;
            }
            if (ev[i].data.u32 == 1) {
                if (senales_d42(sfd, &terminar) == -1) goto fin;
            }
        }
        if (terminar) break;
        for (int i = 0; i < n; ++i) {
            if (ev[i].data.u32 == 2) {
                uint64_t cantidad;
                ssize_t r = read(tfd, &cantidad, sizeof cantidad);
                if (r == (ssize_t)sizeof cantidad) {
                    if (cantidad > UINT64_MAX - vencimientos) {
                        fprintf(stderr, "Contador de timer fuera de rango\n"); goto fin;
                    }
                    vencimientos += cantidad;
                    printf("Vencimientos acumulados: %" PRIu64 "\n", vencimientos);
                } else if (r == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK)) {
                    continue;
                } else { fprintf(stderr, "Lectura incompatible de timerfd\n"); goto fin; }
            } else if (ev[i].data.u32 == 3 && !datos_fin) {
                char bloque[2];
                ssize_t r = recv(par[1], bloque, sizeof bloque, 0);
                if (r > 0) {
                    if ((size_t)r > sizeof datos - usados) goto fin;
                    memcpy(datos + usados, bloque, (size_t)r); usados += (size_t)r;
                } else if (r == 0) {
                    if (usados != 4 || memcmp(datos, "hola", 4) != 0) {
                        fprintf(stderr, "Datos incompletos o incorrectos\n"); goto fin;
                    }
                    if (epoll_ctl(epfd, EPOLL_CTL_DEL, par[1], NULL) == -1) {
                        perror("DEL datos"); goto fin;
                    }
                    int lector = par[1]; par[1] = -1;
                    if (close(lector) == -1) { perror("close lector"); goto fin; }
                    datos_fin = 1; puts("Datos verificados y EOF retirado");
                } else if (errno != EINTR && errno != EAGAIN && errno != EWOULDBLOCK) {
                    perror("recv datos"); goto fin;
                }
            }
        }
        if (fflush(stdout) == EOF) goto fin;
    }
    salida = terminar ? 128 + terminar : EXIT_SUCCESS;
fin:
    /* No se desbloquean las señales gestionadas durante la limpieza. */
    if (armado) {
        struct itimerspec cero = {0};
        if (timerfd_settime(tfd, 0, &cero, NULL) == -1) salida = EXIT_FAILURE;
    }
    if (par[0] != -1 && close(par[0]) == -1) salida = EXIT_FAILURE;
    if (par[1] != -1 && close(par[1]) == -1) salida = EXIT_FAILURE;
    if (tfd != -1 && close(tfd) == -1) salida = EXIT_FAILURE;
    if (sfd != -1 && close(sfd) == -1) salida = EXIT_FAILURE;
    if (epfd != -1 && close(epfd) == -1) salida = EXIT_FAILURE;
    if (fflush(stdout) == EOF) salida = EXIT_FAILURE;
    return salida;
}

El socket tiene datos y cierre desde el comienzo. El modo LT permite recibir dos bytes por evento hasta verificar el cuerpo y EOF; después se retira esa fuente para no despertar continuamente. Los errores de las fuentes fallan el laboratorio.

La lectura de timerfd no usa un bucle que repita acciones de aplicación cantidad veces. Suma el contador y muestra el estado. El signalfd tiene un presupuesto de lectura por turno y puede volver a notificarse si quedan señales.

13. Ejecutar y comprobar los contadores

Bash en Linux · tres fuentes en la misma espera
$ gcc -std=c11 -Wall -Wextra -Wpedantic -O2 descriptores42.c -o descriptores42
$ timeout 5s ./descriptores42
Descriptores42 listo; PID=4203; periodo=200 ms
Datos verificados y EOF retirado
Vencimientos acumulados: 1
Vencimientos acumulados: 2
Vencimientos acumulados: 3
Vencimientos acumulados: 4
Vencimientos acumulados: 5

Los números pueden avanzar a saltos si el proceso tarda en leer el timer. El requisito es acumular al menos cinco y verificar los datos; no observar exactamente cinco lecturas ni una traza idéntica. Un controlador puede detener temporalmente el proceso con SIGSTOP y reanudarlo con SIGCONT antes del plazo para comprobar acumulación.

Para señales, espera siempre el mensaje inicial. SIGUSR1 debe producir una recarga en contexto normal. SIGTERM debe cerrar los recursos y retornar 143; SIGINT, 130. timeout tiene sus propios códigos y no debe confundirse con esos resultados del programa.

14. Máscaras, hilos y vida de los recursos

Los ejemplos toman control de tres señales y terminan como ejecutables independientes. Fuera de la espera atómica, o durante toda la vía signalfd, esas señales permanecen bloqueadas. La limpieza no vuelve a habilitar una disposición predeterminada con una señal pendiente.

En programas con varios hilos, las máscaras pertenecen a cada hilo. La configuración se prepara antes de crearlos para que hereden el bloqueo y se usa pthread_sigmask según el diseño. Si otro hilo deja habilitada una señal dirigida al proceso, esa señal puede entregarse por la vía normal y no por el signalfd esperado.

La máscara se hereda con fork y se conserva a través de exec. CLOEXEC cierra descriptores al completar exec, pero no desbloquea señales. Un proceso trabajador debe recibir una configuración deliberada de referencias y máscara, en lugar de heredar accidentalmente la política del supervisor.

Compartir un signalfd o una referencia de timerfd tampoco crea consumidores independientes de los mismos eventos: las lecturas consumen estado compartido del recurso correspondiente. No dupliques esos descriptores sin definir quién los leerá.

En una integración ET hay que adaptar también el drenaje o conservar trabajo local, como en el tema 40. Los programas de este tema usan LT para repartir turnos y observar EOF o registros pendientes sin introducir esa obligación adicional.

15. Explorar la ventana de carrera

El modelo permite colocar una señal después de revisar una bandera y antes de entrar en espera. Compara una estrategia incorrecta, self-pipe, una máscara atómica y signalfd. El reloj manual agrega vencimientos de un timer de descriptor, que se acumulan hasta procesarlos.

Etapa del bucleAntes de comprobar

Bandera de finInactiva

Señal bloqueada pendienteNo

Byte de self-pipeNinguno

Vencimientos sin leer0

Último resultadoSin operación

Revisa la bandera, genera una señal en la ventana y después entra en espera.

En el modo incorrecto, revisa, genera la señal y entra en espera: el modelo queda dormido con bandera activa. Repite con cada solución para observar qué conserva el despertar. La máscara atómica entrega la señal al habilitarla durante la espera; signalfd la consume al procesar su registro.

Avanzar el reloj puede despertar también el modo incorrecto, pero por otro evento y con retraso: no elimina la carrera original. Genera varios vencimientos antes de procesar para observar una sola lectura agregada. El modelo simplifica señales estándar como estado pendiente único y la tubería como capacidad de un aviso; no ejecuta llamadas del sistema ni reproduce toda la planificación.

16. Pruebas y diagnóstico

Recorridos normales y cancelación

Forzar la ventana en lugar de confiar en pausas

Un wrapper de poll puede enviar una señal al propio proceso justo antes de la llamada real. En self-pipe, la señal ya atendida debe dejar bytes que impidan dormir. Para pselect o ppoll, un wrapper puede generarla antes de la llamada real mientras está bloqueada: la sustitución atómica de máscara debe permitir atenderla sin perderla.

Comprueba la saturación de self-pipe llenándola bajo una máscara bloqueada en un controlador. Después habilita una señal y verifica que EAGAIN no bloquea al manejador y que la bandera pendiente se atiende. No exijas un byte por señal ni una recarga por cada kill.

Inyecta EINTR antes de lecturas o esperas y comprueba que el plazo no se reinicia. Después de un error de espera no deben procesarse conjuntos o lotes viejos. Al forzar un fallo de creación o registro, el programa debe cerrar todos los recursos que ya obtuvo.

Para timerfd, conserva su lectura real de ocho bytes al probar acumulación. No lo fragmentes artificialmente como si fuera un flujo de protocolo: un búfer demasiado pequeño para ese contador no cumple su interfaz. Los registros signalfd también tienen su propio tamaño y contrato.

Bash en Linux · observar las esperas y sus fuentes
$ strace -e trace=rt_sigprocmask,rt_sigaction,poll,read,write ./selfpipe42
$ strace -e trace=rt_sigprocmask,pselect6,ppoll,read ./atomica42 ppoll
$ strace -e trace=signalfd4,timerfd_create,timerfd_settime,epoll_ctl,epoll_wait,read,recvfrom,close ./descriptores42

Las implementaciones de biblioteca pueden usar variantes de syscall y el reloj puede resolverse mediante vDSO. Compara máscaras, tamaños de lectura y estados, sin exigir que cada función de C aparezca con el mismo nombre en la traza.

El controlador debe esperar el mensaje de arranque, imponer su propio límite y recoger cada proceso que lanzó. Un plazo interno no convierte en interrumpible cualquier escritura de diagnóstico ni reemplaza la supervisión del ensayo.

17. Errores frecuentes

ErrorConsecuenciaCorrección
Comprobar bandera y dormir por separado.Se puede perder el despertar futuro.Self-pipe, máscara atómica o recepción por descriptor bien configurada.
Ejecutar printf o recarga dentro del manejador.Se usan funciones no seguras en contexto interrumpido.Trabajo diferido en el flujo principal.
Usar write bloqueante en self-pipe.El manejador puede esperar a su propio consumidor.Extremo no bloqueante y bandera que sobreviva a EAGAIN.
Contar bytes como cantidad exacta de señales.La agrupación y saturación alteran esa cuenta.Revisar el estado pendiente y drenar el aviso.
Limpiar banderas sin protección frente a nuevas señales.Puede borrarse trabajo recién notificado.Tomar y limpiar bajo una máscara apropiada.
Desbloquear antes de llamar a poll.Se conserva la ventana entre llamadas.Usar la sustitución atómica de ppoll o pselect.
Crear signalfd sin bloquear señales.La disposición normal puede adelantarse a la lectura.Configurar bloqueo y propiedad antes de esperar.
Leer timerfd con un búfer de un byte.No cumple el contrato del contador de ocho bytes.uint64_t y comprobación del retorno exacto.
Confundir cinco vencimientos con cinco registros.Se pierde tiempo o se ejecuta trabajo acumulado sin límite.Política explícita de agregación y recuperación.
Cerrar la tubería con el manejador habilitado.Descriptor reutilizado, error o SIGPIPE.Bloquear y retirar la vía de notificación antes de cerrar.
Renovar el plazo tras una señal.La operación puede prolongarse por actividad ajena.Conservar una fecha límite y recalcular restante.
Suponer que CLOEXEC restaura la máscara.El ejecutable nuevo hereda señales bloqueadas.Configurar deliberadamente máscara y descriptores antes de exec.

18. Resumen

19. Preguntas de repaso y práctica

Responde separando señal generada, estado pendiente, despertar y trabajo ejecutado.

1. ¿Por qué una bandera atómica no elimina por sí sola la carrera?

Porque la comprobación y el inicio de una espera son operaciones distintas. La señal puede atenderse entre ambas.

2. ¿Qué conserva self-pipe si la señal llega antes de poll?

Una bandera pendiente y un byte legible que hace observable el despertar futuro.

3. ¿Qué se hace si la tubería está llena?

El manejador no espera espacio. Los bytes existentes ya mantienen el despertar y la bandera conserva el trabajo.

4. ¿Por qué se guarda errno en el manejador?

Para que su operación de notificación no altere el valor que tenía el código interrumpido.

5. ¿Dónde se ejecuta una recarga?

En el flujo principal, después de tomar el estado pendiente. Allí pueden utilizarse las funciones normales del programa.

6. ¿Qué máscara recibe pselect o ppoll?

La máscara que estará vigente temporalmente durante la espera, permitiendo las señales que estaban bloqueadas fuera de ella.

7. ¿Desbloquear y llamar luego a poll es equivalente?

No. Deja una ventana entre ambas llamadas. La interfaz atómica evita esa separación.

8. ¿signalfd bloquea automáticamente las señales de su conjunto?

No. El programa configura el bloqueo para que la disposición normal no compita con la recepción por descriptor.

9. ¿Se pueden recibir SIGKILL o SIGSTOP mediante signalfd?

No. No son señales que este mecanismo permita interceptar.

10. ¿Qué significa leer un valor cinco de timerfd?

Se acumularon cinco vencimientos desde la lectura anterior. No son cinco registros pendientes que deban retirarse por separado.

11. ¿Qué diferencia hay entre plazo total e inactividad?

El total mantiene su límite original. La inactividad se renueva según una definición explícita de actividad válida.

12. ¿El orden del arreglo epoll define qué ocurrió primero en el sistema?

No. El bucle puede aplicar una prioridad local, pero el lote no constituye un registro cronológico completo.

13. ¿Por qué se bloquean señales antes de cerrar self-pipe?

Para impedir que el manejador escriba sobre un extremo cerrado o un número reutilizado.

14. ¿CLOEXEC desbloquea las señales al ejecutar otro programa?

No. Controla descriptores. La máscara se conserva a través de exec y debe configurarse por separado.

15. ¿Qué cambia si se usan varios hilos?

Las máscaras son por hilo y debe definirse quién recibe cada señal y consume cada descriptor, normalmente preparando el bloqueo antes de crear los hilos.

Para practicar y ampliar

  1. Reproduce en el simulador la señal que llega después de revisar una bandera.
  2. Ejecuta los tres programas y distingue recarga, vencimiento y cancelación.
  3. Fuerza una señal inmediatamente antes de la espera real con un controlador.
  4. Llena self-pipe y verifica que la bandera sobrevive aunque otro byte no quepa.
  5. Envía señales repetidas y explica por qué no exiges una recarga por cada envío.
  6. Compara pselect y ppoll con descriptores de número alto dentro de los límites del entorno.
  7. Retén brevemente la lectura del timer y observa la acumulación.
  8. Define una política que limite trabajo de recuperación después de muchos vencimientos.
  9. Diseña cómo integrar cancelación y plazos por petición en el servidor del tema 39.
  10. Especifica la máscara y los descriptores que heredaría un trabajador antes de exec.
Próximo paso

El tema 43 estudiará desconexiones y procesos caídos: timeout, cancelación, recursos huérfanos, reintentos e idempotencia. Un despertar correcto permite atender un fallo; todavía hace falta decidir qué significa para el trabajo de aplicación.