← Comunicación entre ProcesosBloque 2 · Señales · Tema 8 de 52

Tema 8

Programar manejadores seguros

Un manejador puede interrumpir al programa mientras una biblioteca actualiza sus estructuras internas. Una función válida en main puede ser incorrecta en ese instante. Aprenderás a reducir el trabajo del manejador, conservar errno, utilizar flags simples y despertar un bucle normal para ejecutar allí las acciones complejas, con dos programas completos en C.

1. Por qué importa el punto de interrupción

En el tema 7 usamos un manejador que solo registraba una solicitud. Ahora vamos a justificar esa limitación. Cuando el sistema entrega una señal, el flujo normal puede estar en medio de una función, con datos internos modificados solo parcialmente.

Imagina una biblioteca que mantiene un búfer, una posición y un contador. Si la señal interrumpe la actualización entre dos pasos y el manejador vuelve a utilizar esa biblioteca, podría encontrar una combinación transitoria que no esperaba. Si además intenta adquirir un bloqueo que mantiene el código interrumpido, puede esperar a que avance un código que no avanzará hasta que el manejador retorne.

Por eso un manejador no debe tratarse como una función que main decidió llamar en un momento cómodo. No eliges el estado interno de las bibliotecas cuando entra. Que un ejemplo con printf parezca funcionar muchas veces no demuestra que ese uso sea correcto.

En esta lección seguimos usando programas de un solo hilo. El problema existe aun sin varios hilos: la interrupción puede introducir una reentrada dentro del mismo hilo. En un proceso con varios hilos se añaden otras decisiones sobre máscaras, recepción y coordinación.

2. Qué significa async-signal-safe

Una función async-signal-safe ofrece las garantías necesarias para poder llamarse desde un manejador bajo el contrato correspondiente. Esa propiedad no se deduce solo de que la función sea habitual, rápida o utilizable desde varios hilos.

La seguridad puede basarse en reentrancia o en mecanismos que evitan un estado observable inconsistente. No necesitas adivinar la implementación de cada función: consulta las garantías del estándar y del entorno. La lista y la explicación de los problemas de stdio se encuentran en signal-safety(7).

También hay que separar seguridad de reentrada de conveniencia para el diseño. write es una operación que puede usarse en ese contexto, pero escribir en un descriptor bloqueante puede dejar al manejador esperando. close puede ser una función permitida y, aun así, cerrar desde el manejador un recurso que main usa puede romper la lógica de la aplicación.

No pruebes una garantía ejecutando una rutina miles de veces y esperando que falle. Las pruebas ayudan a verificar el protocolo elegido; no convierten una llamada sin la garantía requerida en una llamada segura.

3. Qué funciones llevar al flujo normal

OperaciónDecisión en estos ejemplosMotivo
printf, fprintf, perror, fflushSolo en el flujo normal.Usan stdio o servicios que no se deben reintroducir arbitrariamente desde el manejador.
malloc, realloc, freeSolo en el flujo normal.El asignador puede estar actualizando su estado cuando se entrega la señal.
Formatear registros, recargar configuración o modificar listasTrabajo diferido.Involucra múltiples datos, llamadas y posibles bloqueos.
Asignar una petición a volatile sig_atomic_tPatrón básico del manejador.Representa un estado simple sin construir una estructura compleja.
write sobre un canal preparadoNotificación mínima, con protocolo y modo adecuados.Puede despertar al flujo normal sin usar stdio.
_exitSolo si la política exige terminar inmediatamente.No ejecuta la limpieza normal ni el vaciado de stdio de exit.

No copies la tabla como una lista completa de POSIX. Elige primero una estrategia que necesite pocas operaciones y revisa cada dependencia que introduzca el manejador. Una función auxiliar propia tampoco se vuelve segura por no ser de biblioteca: hay que revisar todo lo que llama y todo lo que toca.

Un registro detallado puede prepararse después: el manejador marca «hay que revisar» y main consulta el estado, construye el mensaje y lo imprime. Esa separación mantiene la información útil sin usar el mecanismo de registro dentro de la interrupción.

4. Flags y límites de sig_atomic_t

patrón · una petición de estado, no un contador de mensajes
static volatile sig_atomic_t recargar = 0;

static void solicitar_recarga(int senal)
{
    (void)senal;
    recargar = 1;
}

Este flag responde «¿existe una petición por atender?». Dos señales antes de atenderla pueden seguir dando el mismo valor 1. Eso es adecuado si recargar significa volver a consultar la configuración actual y no contar exactamente cuántas veces se envió la señal.

sig_atomic_t y volatile no convierten automáticamente un incremento o una secuencia de varias operaciones en una transacción. Tampoco resuelven sincronización general entre hilos. No extrapoles este patrón a una cola compartida, punteros cambiantes o una estructura de varios campos.

Hay una carrera adicional al consumir el flag. Si main lo lee, llega otra señal y después main lo pone a cero, puede borrar una nueva petición. En el proyecto bloquearemos temporalmente las señales de control para copiar y limpiar los flags como una sección coordinada. Después volveremos a permitir su entrega.

En el patrón del proyecto solo se asignan valores simples a los flags. Las peticiones que llegan mientras están bloqueadas pueden quedar pendientes y entregarse al restaurar la máscara. La configuración de sa_mask complementa ese protocolo durante el propio manejador.

5. Conservar errno

Una llamada segura puede modificar errno. Si el manejador interrumpe al código normal entre una llamada fallida y la lectura de su causa, dejar otro valor cambia el diagnóstico de una operación ajena.

patrón · guardar al entrar y restaurar antes de volver
static void avisar(int senal)
{
    int previo = errno;
    /* Registrar estado y realizar solo operaciones adecuadas. */
    (void)senal;
    errno = previo;
}

La copia es local a esa invocación del manejador. Restaurar errno no repara una llamada insegura ni elimina otros efectos: solo conserva ese dato del contexto interrumpido. Si necesitas comunicar un error del canal de notificación, utiliza una política explícita y no el errno que dejes accidentalmente en main.

Los manejadores que únicamente asignan un flag no necesitan provocar una llamada de biblioteca para parecer más completos. En el siguiente laboratorio haremos una llamada fallida deliberada para que se vea por qué la conservación importa.

6. Experimento en C con errno

El manejador de esta prueba llama a read con un descriptor inválido para provocar EBADF. Guarda en variables simples el valor de entrada, el error deliberado y el valor de salida. Todas las impresiones se hacen después, desde main.

El modo conservar aplica el patrón correcto; alterar reproduce intencionalmente la omisión de la restauración y debe rechazarse como ejemplo de código correcto. No estamos recomendando provocar errores dentro de un manejador real.

errno_manejador.c · observar una alteración controlada
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

static volatile sig_atomic_t conservar = 1;
static volatile sig_atomic_t entrada = 0;
static volatile sig_atomic_t interior = 0;
static volatile sig_atomic_t salida = 0;
static volatile sig_atomic_t recibida = 0;

static void observar(int senal)
{
    int previo = errno;
    (void)senal;
    entrada = previo;
    char byte;
    ssize_t n = read(-1, &byte, 1); /* Fallo deliberado: EBADF. */
    interior = n == -1 ? errno : 0;
    if (conservar)
        errno = previo;
    salida = errno;
    recibida = 1;
}

int main(int argc, char *argv[])
{
    if (argc != 2 || (strcmp(argv[1], "conservar") != 0 &&
        strcmp(argv[1], "alterar") != 0)) {
        fprintf(stderr, "Uso: %s conservar|alterar\n", argv[0]);
        return EXIT_FAILURE;
    }
    conservar = strcmp(argv[1], "conservar") == 0;
    struct sigaction accion = {0};
    accion.sa_handler = observar;
    if (sigemptyset(&accion.sa_mask) == -1 ||
        sigaction(SIGUSR1, &accion, NULL) == -1) {
        perror("sigaction");
        return EXIT_FAILURE;
    }
    sigset_t permitir;
    if (sigemptyset(&permitir) == -1 ||
        sigaddset(&permitir, SIGUSR1) == -1 ||
        sigprocmask(SIG_UNBLOCK, &permitir, NULL) == -1) {
        perror("desbloquear SIGUSR1");
        return EXIT_FAILURE;
    }
    errno = ENOENT; /* Valor reconocible para el experimento en Linux. */
    if (raise(SIGUSR1) != 0) {
        perror("raise");
        return EXIT_FAILURE;
    }
    if (!recibida || interior != EBADF) {
        fprintf(stderr, "No se observo el recorrido esperado\n");
        return EXIT_FAILURE;
    }
    printf("errno al entrar: %d\n", (int)entrada);
    printf("error deliberado dentro: %d (EBADF)\n", (int)interior);
    printf("errno al salir: %d\n", (int)salida);
    if (entrada == salida) {
        puts("Estado interrumpido preservado");
        return EXIT_SUCCESS;
    }
    puts("Estado interrumpido alterado");
    return EXIT_FAILURE;
}
Bash · comparar los dos modos
$ gcc -std=c17 -Wall -Wextra -Wpedantic -g -O0 errno_manejador.c -o errno_manejador
$ ./errno_manejador conservar
errno al entrar: 2
error deliberado dentro: 9 (EBADF)
errno al salir: 2
Estado interrumpido preservado
$ ./errno_manejador alterar
errno al entrar: 2
error deliberado dentro: 9 (EBADF)
errno al salir: 9
Estado interrumpido alterado
$ echo $?
1

Los números son ilustrativos de Linux; el programa decide con EBADF, no con 9. Se comparan los valores registrados dentro del propio manejador. No se usa como única prueba el errno posterior a raise, porque una función exitosa puede modificar errno según su contrato.

El laboratorio prepara SIGUSR1 sin bloquear y no ejecuta otras tareas. No pretende que cualquier dato de una aplicación se pueda publicar de esta forma: son campos simples para estudiar este recorrido concreto.

7. Separar la notificación del trabajo

Un diseño práctico puede interpretar SIGUSR1 como «hay que revisar la configuración actual» y SIGINT o SIGTERM como «se ha solicitado parar». El manejador no abre ni analiza archivos de configuración: registra el estado y despierta al componente que puede hacerlo.

  1. Registrar la intención. Poner un flag de recarga o de parada.
  2. Notificar sin esperar trabajo complejo. Despertar el mecanismo de espera del flujo normal.
  3. Recuperar el control normal. Consultar de forma coordinada las peticiones.
  4. Ejecutar la acción. Imprimir, validar, recargar o cerrar recursos fuera del manejador.

Un flag basta para guardar la intención, pero no necesariamente para despertar al programa. Si main comprobó cero y después entra en una espera, una señal recibida en ese intervalo puede dejar el flag cambiado y ningún nuevo evento que lo saque de la espera.

El tema 7 utilizó una máscara y sigsuspend para coordinar esa transición. Aquí veremos otro patrón útil cuando el flujo normal ya espera descriptores: una notificación que permanece legible en un canal.

8. Despertar el bucle mediante una self-pipe

Una self-pipe es una tubería cuyos extremos mantiene el mismo proceso para pasar una notificación desde el manejador a su bucle normal. No transmite en este caso el contenido de una tarea: un byte significa «revisa los flags».

Del manejador al bucle normalEl manejador guarda errno, marca un flag y escribe un byte sin bloquear. El bucle espera el lector con poll, consulta las peticiones y ejecuta el trabajo normal. Manejadorflag + byterestaura errnoTuberíano bloqueanteFlujo normalpoll + consultatrabajo diferido El byte despierta; los flags indican la intención
Se conserva el despertar aunque la señal llegue justo antes de empezar la espera.

El escritor debe ser no bloqueante. Si el canal se llena, no queremos dormir dentro del manejador. En este protocolo, EAGAIN al intentar escribir un byte es tolerable: el canal ya tiene bytes legibles y el flag conserva la petición. Esto no sería suficiente para una cola que necesitara guardar exactamente cada evento.

El lector también será no bloqueante para poder vaciar los avisos sin quedarse esperando un byte adicional. La creación con flags mediante pipe2 es una extensión de Linux y requiere _GNU_SOURCE en este ejemplo. La interfaz se documenta en pipe(2).

9. Proyecto: recarga y parada diferidas

Guarda el siguiente programa como servicio_diferido.c. El manejador solo marca peticiones, escribe un byte y conserva errno. main consume los avisos, copia y limpia los flags con las señales de control bloqueadas y vuelve a permitirlas antes de ejecutar el trabajo.

La recarga es una impresión que representa el lugar donde una aplicación validaría su configuración. La parada tiene prioridad si ambas peticiones están presentes en la misma instantánea. Si la tubería sufre un fallo distinto de interrupción o falta de espacio, el manejador aplica una política explícita de terminación inmediata con _exit(2); no intenta imprimir un diagnóstico desde allí.

servicio_diferido.c · ejemplo Linux de un solo hilo
#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <poll.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

static volatile sig_atomic_t recargar = 0;
static volatile sig_atomic_t detener = 0;
/* En este entorno Linux, sig_atomic_t permite representar el descriptor. */
static volatile sig_atomic_t aviso_fd = -1;

static void notificar(int senal)
{
    int previo = errno;
    if (senal == SIGUSR1)
        recargar = 1;
    else
        detener = 1;
    const char byte = '!';
    ssize_t n;
    do {
        n = write((int)aviso_fd, &byte, 1);
    } while (n == -1 && errno == EINTR);
    if (n != 1 && !(n == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)))
        _exit(2); /* Fallo del canal: politica deliberada, sin stdio. */
    errno = previo;
}

static int vaciar_avisos(int fd)
{
    char buffer[128];
    for (;;) {
        ssize_t n = read(fd, buffer, sizeof buffer);
        if (n > 0)
            continue;
        if (n == -1 && errno == EINTR)
            continue;
        if (n == -1 && (errno == EAGAIN || errno == EWOULDBLOCK))
            return 0;
        if (n == 0)
            errno = EPIPE;
        return -1;
    }
}

int main(void)
{
    sigset_t control, previa;
    if (sigemptyset(&control) == -1 ||
        sigaddset(&control, SIGUSR1) == -1 ||
        sigaddset(&control, SIGINT) == -1 ||
        sigaddset(&control, SIGTERM) == -1 ||
        sigprocmask(SIG_BLOCK, &control, &previa) == -1) {
        perror("preparar bloqueo");
        return EXIT_FAILURE;
    }
    int canal[2] = {-1, -1};
    int resultado = EXIT_FAILURE;
    if (pipe2(canal, O_NONBLOCK | O_CLOEXEC) == -1) {
        perror("pipe2");
        goto limpieza;
    }
    aviso_fd = canal[1];
    struct sigaction accion = {0};
    accion.sa_handler = notificar;
    accion.sa_mask = control;
    accion.sa_flags = 0;
    if (sigaction(SIGUSR1, &accion, NULL) == -1 ||
        sigaction(SIGINT, &accion, NULL) == -1 ||
        sigaction(SIGTERM, &accion, NULL) == -1) {
        perror("sigaction");
        goto limpieza;
    }
    sigset_t activa = previa;
    if (sigdelset(&activa, SIGUSR1) == -1 ||
        sigdelset(&activa, SIGINT) == -1 ||
        sigdelset(&activa, SIGTERM) == -1) {
        perror("preparar mascara activa");
        goto limpieza;
    }
    printf("PID listo: %ld\n", (long)getpid());
    puts("USR1 solicita recarga; INT o TERM solicita parada.");
    if (fflush(stdout) == EOF) {
        perror("fflush");
        goto limpieza;
    }

    for (;;) {
        if (sigprocmask(SIG_BLOCK, &control, NULL) == -1) {
            perror("bloquear para consultar");
            goto limpieza;
        }
        int hacer_recarga = recargar;
        int hacer_parada = detener;
        recargar = 0;
        if (vaciar_avisos(canal[0]) == -1) {
            perror("vaciar avisos");
            goto limpieza;
        }
        if (sigprocmask(SIG_SETMASK, &activa, NULL) == -1) {
            perror("restaurar mascara activa");
            goto limpieza;
        }
        if (hacer_parada) {
            puts("Parada atendida desde main");
            resultado = EXIT_SUCCESS;
            break;
        }
        if (hacer_recarga) {
            puts("Recarga atendida desde main");
            if (fflush(stdout) == EOF) {
                perror("fflush");
                goto limpieza;
            }
        }
        struct pollfd evento = { .fd = canal[0], .events = POLLIN };
        if (poll(&evento, 1, -1) == -1) {
            if (errno == EINTR)
                continue;
            perror("poll");
            goto limpieza;
        }
        if (evento.revents & (POLLERR | POLLHUP | POLLNVAL)) {
            fprintf(stderr, "Estado inesperado del canal de avisos\n");
            goto limpieza;
        }
    }

limpieza:
    if (sigprocmask(SIG_BLOCK, &control, NULL) == -1) {
        perror("bloquear para cerrar");
        return EXIT_FAILURE;
    }
    aviso_fd = -1;
    for (int i = 0; i < 2; i++) {
        if (canal[i] != -1 && close(canal[i]) == -1) {
            perror("close");
            resultado = EXIT_FAILURE;
        }
    }
    return resultado;
}

El descriptor que consulta el manejador se publica antes de permitir las señales y se mantiene válido mientras pueden entregarse. Su valor no se cambia concurrentemente con el manejador: al cerrar se bloquean primero esas señales. La disposición cubre solo las tres señales de control del ejemplo.

La tubería guarda un despertar que no depende de que poll ya esté esperando. Si una señal llega después de restaurar la máscara pero antes de poll, el manejador deja un byte y poll encuentra el descriptor legible. Si poll retorna EINTR, el bucle vuelve a consultar los flags en lugar de darlo por un fallo fatal.

Las lecturas y escrituras pueden agruparse: no hay una recarga por byte. La escritura mínima y sus errores se rigen por write(2); la espera de disponibilidad se describe en poll(2).

10. Compilar y probar el servicio

Bash · iniciar la práctica en segundo plano
$ gcc -std=c17 -Wall -Wextra -Wpedantic -g -O0 servicio_diferido.c -o servicio_diferido
$ ./servicio_diferido &
$ pid=$!
PID listo: 3500
USR1 solicita recarga; INT o TERM solicita parada.

Espera a ver la preparación completa y conserva el PID de esa instancia. Envía una petición, espera su confirmación impresa por main y después prueba la parada:

Bash · peticiones y trabajo normal
$ kill -USR1 "$pid"
Recarga atendida desde main
$ kill -TERM "$pid"
$ wait "$pid"
Parada atendida desde main
$ echo $?
0

El PID es ilustrativo. El emisor del tema 6 no admitía USR1 en su interfaz; aquí usamos directamente kill de Bash. Una instancia nueva permite comparar INT y TERM como peticiones de parada.

Si envías varias USR1 muy juntas, no esperes necesariamente el mismo número de mensajes de recarga. La señal estándar puede agruparse y el flag representa una petición por atender. Para verificar recargas separadas, envía una nueva después de observar que se atendió la anterior.

La aplicación solo observa su canal de avisos. En un servidor real ese descriptor podría formar parte de un conjunto con sockets de clientes, manteniendo la misma separación entre notificación y procesamiento. La multiplexación completa se desarrollará en su bloque.

11. Capacidad, repetición y fallos

Hay dos agrupaciones distintas. El sistema puede agrupar ocurrencias pendientes de una señal estándar; además, nuestro flag agrupa varias peticiones recibidas antes de atenderlas. Ni el número de bytes del canal ni el de llamadas al manejador constituye un contador exacto de tareas.

Si el canal está lleno, una escritura no bloqueante de un byte puede fallar con EAGAIN. La intención ya quedó en el flag y hay contenido que permite despertar al lector. Al volver al flujo normal se vacían los avisos y se consulta la intención con la coordinación correspondiente.

Si el escritor fuera bloqueante, el manejador podría esperar espacio. Pero quien libera ese espacio es main y main no puede avanzar hasta que retorne el manejador. Ese es un interbloqueo que no desaparece porque write sea async-signal-safe.

Los reintentos por EINTR del envío mínimo no reemplazan la política sobre otros fallos. El ejemplo trata EAGAIN como un despertar ya disponible y otros resultados inesperados como un fallo fatal del canal. Esa terminación no promete limpieza compleja; es una decisión visible que una aplicación podría sustituir por otro protocolo seguro.

La función que procesa una recarga puede tardar o fallar. El hecho de recibir TERM no interrumpe mágicamente una tarea larga del flujo normal: hay que definir puntos de cancelación y cuándo se revisa la petición. Incluso una impresión por stdout puede esperar si su destino deja de consumir. Este laboratorio no garantiza una latencia máxima de parada.

12. Vida útil de los descriptores

Un manejador que utiliza un descriptor depende de su propiedad y duración. Si main lo cierra y ese número se reutiliza, la siguiente notificación podría escribir en otro objeto. Evitar funciones inseguras no protege de ese error de diseño.

  1. Bloquear durante la preparación. Crear el canal antes de permitir que se ejecute el manejador.
  2. Configurar ambos extremos. En este ejemplo son no bloqueantes y close-on-exec desde su creación.
  3. Publicar el descriptor estable. El manejador lo utiliza mientras las señales pueden entregarse.
  4. Bloquear antes de retirar. Impedir nuevas ejecuciones del manejador antes de invalidar y cerrar el canal.

El ejemplo es un programa que termina y no restaura la máscara al llamador. Un módulo reutilizable necesitaría coordinar disposiciones previas, señales pendientes y la entrega al volver a habilitarlas. Tampoco conserva el protocolo automáticamente si se añade otro hilo que reciba estas señales.

El lector se mantiene abierto mientras el manejador puede escribir. Si lo cierras prematuramente, aparece el problema de SIGPIPE o EPIPE en lugar de un aviso normal. No basta con añadir una comprobación de errno después de un fallo si la disposición de SIGPIPE ya terminó al proceso.

Para un programa que solo espera una señal, el patrón con sigsuspend del tema anterior puede ser más sencillo. Su cambio temporal de máscara está documentado en sigsuspend(2). La self-pipe aporta valor cuando necesitas integrar la señal con una espera de descriptores.

13. Explorar notificación y trabajo diferido

El modelo tiene un canal de solo tres bytes para mostrar rápidamente la saturación. Esa capacidad es didáctica y no representa una capacidad real de tubería. Envía varias peticiones antes de pulsar «Atender desde main».

ContextoFlujo normal

Bytes de aviso0 de 3

PeticionesNinguna

errno del contextoENOENT

Recargas atendidas0

    Primero puedes esperar: una señal dejará el descriptor legible. Los bytes despiertan; los flags expresan la intención.

    Compara cuatro casos: esperar y después enviar; llenar el canal y enviar otra petición; repetir eso sin conservar errno; y llenar el canal con un escritor bloqueante. En el último, el modelo impide atender desde main porque el manejador sigue esperando que avance ese mismo flujo.

    La simulación agrupa las recargas pendientes en un flag y da prioridad a la parada cuando ambas se atienden juntas. No reproduce la ejecución del kernel, la entrega de cada señal ni el bloqueo temporal usado para tomar la instantánea. Cambiar una opción reinicia la instancia; no se ejecutan señales reales.

    14. Revisar un manejador con criterio

    Una revisión útil sigue las dependencias, no solo el nombre de la función principal. Para cada manejador comprueba lo siguiente:

    Bash · observar el despertar y las acciones diferidas
    $ strace -o diferido.log ./servicio_diferido
    ... usa desde otra terminal el PID que imprime el servicio ...
    $ less diferido.log

    Busca el write de un byte en el manejador, su retorno, la consulta de avisos y las impresiones del flujo normal. poll puede mostrar una interrupción o disponibilidad según el instante de entrega. La traza permite estudiar el recorrido, pero modifica los tiempos y no convierte una operación insegura en segura.

    Si comparas dos implementaciones, conserva el mismo significado de la petición. Un contador de tareas y un flag de «revisar la configuración» no ofrecen las mismas garantías aunque ambos reaccionen a USR1.

    15. Resumen

    16. Preguntas de repaso y práctica

    Responde antes de desplegar la explicación.

    1. ¿Por qué un printf que parece funcionar puede ser incorrecto en el manejador?

    Porque puede reintroducir stdio cuando el código interrumpido tenía estructuras internas a medio actualizar. Repetir una prueba sin observar un fallo no aporta esa garantía.

    2. ¿Thread-safe implica async-signal-safe?

    No. La coordinación entre hilos no garantiza que una función se pueda reintroducir desde una interrupción del mismo hilo; un bloqueo interno puede ser parte del problema.

    3. ¿Por qué write no debería usar aquí un escritor bloqueante?

    Si el canal se llena, el manejador puede esperar a que main lo vacíe, pero main no puede continuar hasta que el manejador retorne.

    4. ¿Qué protege guardar errno?

    El diagnóstico del contexto interrumpido. No corrige otros efectos ni convierte funciones inseguras en seguras.

    5. ¿Un flag de recarga conserva todas las ocurrencias?

    No. Representa que hay una petición pendiente. Varias ocurrencias pueden agruparse tanto por la señal estándar como por el propio flag.

    6. ¿Qué carrera hay al leer un flag y ponerlo a cero sin coordinarse?

    Una señal puede volver a marcarlo entre ambas operaciones y main borrar esa petición nueva. El proyecto bloquea las señales de control durante la instantánea y el reinicio.

    7. ¿Por qué EAGAIN puede tolerarse en esta self-pipe?

    La intención ya está guardada y el canal lleno tiene contenido legible que puede despertar al bucle. No sería suficiente para conservar una lista exacta de eventos.

    8. ¿Qué evita perder el despertar justo antes de poll?

    El manejador deja un byte en el canal. Cuando el bucle empieza la espera, el descriptor ya está legible y puede atender los flags.

    9. ¿Cada byte significa una recarga?

    No. Los bytes son avisos para consultar estado. La instantánea de los flags determina qué trabajo se debe realizar.

    10. ¿Por qué se bloquean señales antes de cerrar el canal?

    Para que el manejador no use un descriptor ya cerrado o un número reutilizado para otro objeto.

    11. ¿Qué diferencia hay entre exit y _exit en esta política?

    exit ejecuta acciones normales de terminación, como vaciar stdio. _exit termina inmediatamente sin esa limpieza de usuario; por eso el ejemplo la reserva a un fallo fatal del canal.

    12. ¿Una recarga larga permite prometer parada inmediata por TERM?

    No. La petición se registra, pero el flujo normal debe llegar a un punto donde atenderla. Hace falta diseñar cancelación y límites para prometer una latencia de salida.

    Para practicar

    1. Ejecuta los dos modos de errno_manejador y registra la entrada, el error deliberado y la salida. Explica por qué alterar termina con estado distinto de cero.
    2. Localiza todas las llamadas de biblioteca que hace notificar, incluida la terminación de emergencia. Clasifica su contrato y la política aplicada.
    3. Ejecuta servicio_diferido, envía una USR1 y espera la confirmación antes de repetir. Después pide la parada con TERM y comprueba su estado.
    4. En una instancia nueva, detén el servicio con STOP, envía varias USR1 y luego CONT. Explica por qué no debes exigir una recarga por envío.
    5. Recorre el caso de canal lleno en el simulador con y sin modo no bloqueante. Identifica qué participante debería liberar espacio.
    6. Desactiva la conservación de errno en el modelo y provoca EAGAIN. Explica qué información del contexto se alteró.
    7. Dibuja el intervalo entre la restauración de la máscara y poll. Sitúa una señal en ese punto y sigue el byte que evita perder el aviso.
    8. Diseña una extensión con configuración real: cómo se valida una versión, qué sucede si falla y cuándo se atiende una parada durante esa operación.