← Comunicación entre ProcesosBloque 7 · Semáforos POSIX entre procesos · Tema 29 de 52

Tema 29

Esperas, errores y recuperación

Un proceso no siempre puede esperar indefinidamente a que aparezca un permiso. Vas a intentar adquisiciones inmediatas, construir fechas límite y tratar señales sin renovar el plazo. También estudiarás qué puede concluirse cuando vence una espera y cómo descartar una región incompleta si un trabajador muere conservando un permiso.

1. Decidir qué significa dejar de esperar

En los temas 27 y 28, sem_wait esperaba un permiso y el supervisor detectaba hijos que terminaban con error. Si un participante permanecía vivo pero no publicaba, otro podía seguir bloqueado.

Ahora añadiremos dos decisiones: no esperar si no hay disponibilidad inmediata y dejar de bloquear cuando se alcance una fecha. Ninguna de ellas restablece el recurso ni concede acceso a los datos protegidos.

Un intento fallido o una espera vencida significa que esta operación no adquirió un permiso. No significa que sea seguro entrar, publicar una unidad de reemplazo ni reinicializar el semáforo.

El programa debe elegir si rechaza el trabajo, conserva la solicitud para más tarde, pide cancelación o falla la ejecución. «Reintentar siempre» no constituye por sí solo una política de recuperación.

DecisiónPreguntaEjemplo
Disponibilidad inmediata.¿Puedo adquirir ahora sin bloquear?Rechazar una tarea si no hay plaza.
Fecha límite.¿Hasta cuándo acepto permanecer esperando?Esperar un resultado durante una ventana de calendario.
Cancelación.¿Debe abandonarse esta solicitud?Atender una petición SIGTERM según el contrato del programa.
Recuperación.¿Cómo quedan los datos y los participantes?Terminar usuarios y reemplazar una generación incompleta.

2. Tres modos de adquisición

interfaces · declaradas en semaphore.h
int sem_wait(sem_t *s);
int sem_trywait(sem_t *s);
int sem_timedwait(sem_t *s, const struct timespec *limite);

Las tres retornan cero si consumen un permiso y −1 al fallar. No retornan el número de permisos restantes. Solo el éxito autoriza a realizar el acceso que el protocolo protege.

OperaciónSi puede adquirirSi no puede adquirir
sem_wait.Consume una unidad.Espera, salvo interrupción o error.
sem_trywait.Consume una unidad.Retorna EAGAIN sin esperar disponibilidad.
sem_timedwait.Consume una unidad.Espera hasta poder adquirir, ser interrumpida o alcanzar el límite.

sem_timedwait recibe una fecha absoluta referida a CLOCK_REALTIME. No recibe un intervalo relativo ni un timespec construido con CLOCK_MONOTONIC. El contrato de las tres funciones se describe en sem_wait(3).

Las operaciones sirven tanto para semáforos abiertos con sem_open como para objetos preparados con sem_init. Cambia la forma de obtener y destruir el recurso, no el significado de adquirir.

3. sem_trywait: intentar y decidir

patrón · ausencia inmediata no es una avería
if (sem_trywait(s) == 0) {
    /* Se obtuvo un permiso: ejecutar la operacion autorizada. */
} else if (errno == EAGAIN) {
    /* No se obtuvo: rechazar, posponer o atender otro trabajo. */
} else {
    perror("sem_trywait");
}

La comprobación y el consumo pertenecen a una misma operación. No hace falta consultar sem_getvalue antes: entre una consulta y la acción otro participante podría consumir la unidad.

EAGAIN no diagnostica un bloqueo permanente ni un dueño muerto. Solo describe que este intento no pudo consumir inmediatamente. Después de retornar, otro proceso puede publicar y cambiar la disponibilidad.

Evita un bucle vacío que llame continuamente a sem_trywait hasta tener éxito. Consume CPU y convierte la estrategia en espera activa sin definir qué otra tarea útil se atiende. Si la intención es esperar, utiliza una operación de espera adecuada.

sem_getvalue puede servir como observación transitoria, pero no como adquisición ni como prueba de quién conserva un permiso. Su resultado ya puede haber cambiado al volver, según sem_getvalue(3).

4. Clasificar errores antes de reaccionar

ResultadoInterpretaciónReacción del ejemplo
Retorno 0.Se consumió un permiso.Registrar adquisición; no consultar errno como si hubiera fallo.
EAGAIN en sem_trywait.No había adquisición inmediata.Informar indisponibilidad.
ETIMEDOUT en sem_timedwait.La espera terminó sin adquisición por su límite.Informar vencimiento; no publicar compensaciones.
EINTR.Una señal interrumpió la operación.Decidir cancelación o reintentar con el mismo límite.
EINVAL.Puede haber un argumento temporal inválido.Corregir la construcción; no insistir indefinidamente.
EOVERFLOW al publicar.El valor excedería el máximo del semáforo.Fallar el protocolo y revisar el balance de publicaciones.

errno solo se interpreta cuando el retorno indica error. Una adquisición exitosa puede dejar en errno el valor de una llamada anterior; no se transforma en fallo por ese motivo.

Un objeto sin inicializar, destruido o ubicado incorrectamente ya incumple las condiciones de uso. No pruebes a operarlo esperando que todos esos errores se detecten de manera segura mediante un código concreto.

Una publicación fallida no debe ignorarse. sem_post conserva el valor si informa error y puede fallar por exceso de permisos, como explica sem_post(3).

5. Construir una fecha límite absoluta

Para esperar hasta 1500 ms a partir del comienzo, consulta CLOCK_REALTIME una vez, suma un segundo y 500 millones de nanosegundos, y normaliza el resultado. Si tv_nsec alcanza mil millones, lleva una unidad a tv_sec.

ejemplo numérico · normalizar la suma
ahora:              tv_sec = 100, tv_nsec = 800000000
intervalo:          1500 ms
suma sin normalizar tv_sec = 101, tv_nsec = 1300000000
limite correcto:    tv_sec = 102, tv_nsec = 300000000

tv_nsec debe quedar entre cero y 999999999. El código completo comprueba también el desbordamiento al sumar segundos a time_t. Limitar la entrada a 60 segundos reduce el rango, pero no justifica una suma de enteros potencialmente desbordada.

El límite se construye antes del bucle de espera. Cada reintento utiliza la misma estructura. No se vuelve a calcular «ahora + intervalo» al recibir una señal, porque eso alargaría la ventana.

Un límite ya vencido no implica necesariamente error si el permiso puede consumirse inmediatamente. sem_timedwait puede tener éxito en ese caso. La operación limita una espera necesaria; no reemplaza una regla de negocio que prohíba aceptar algo después de una fecha.

6. Reloj de calendario y duración monotónica

CLOCK_REALTIME representa el tiempo de calendario. Si el reloj cambia, una fecha absoluta puede quedar más cerca o más lejos. Por eso un intervalo sumado a ese reloj no equivale siempre a una duración estable observada desde fuera.

CLOCK_MONOTONIC sirve para medir duraciones sin los saltos discontinuos del reloj de calendario. Se puede usar para medir cuánto transcurrió, pero sus números no se pasan como fecha a sem_timedwait. Las diferencias se describen en clock_gettime(2).

Si la implementación ofrece sem_clockwait, esa interfaz permite indicar explícitamente el reloj, incluido CLOCK_MONOTONIC en glibc. Hay que comprobar disponibilidad y macros de exposición del entorno; no cambiar solo el reloj con el que se construye el argumento de sem_timedwait. Véase la documentación de semáforos de glibc.

Este tema utiliza sem_timedwait para estudiar su contrato común en los entornos del curso. No promete un tiempo de respuesta exacto: además del reloj, influyen la planificación, el código anterior y la limpieza posterior.

7. EINTR sin renovar el plazo

patrón · una fecha fija durante todos los reintentos
/* limite se construyo una sola vez antes de este bucle. */
for (;;) {
    if (se_solicito_cancelar) {
        /* Salir sin afirmar adquisicion ni publicar un permiso. */
        break;
    }
    if (sem_timedwait(s, &limite) == 0) {
        /* Se adquirio: esta rama determina el tratamiento del permiso. */
        break;
    }
    if (errno == EINTR) continue;
    /* ETIMEDOUT u otro error: no se adquirio. */
    break;
}

El programa de terminales instalará un manejador sin SA_RESTART. SIGUSR1 solo permitirá observar la interrupción; SIGINT y SIGTERM marcarán una solicitud de cancelación. El manejador no imprime, no libera permisos y no toca la estructura protegida.

La configuración de manejadores y sus flags se documenta en sigaction(2). La solicitud se registra mediante volatile sig_atomic_t, una bandera local para comunicación con el manejador; no se utiliza como sustituto de sincronización entre procesos.

Existe un intervalo entre consultar la bandera y entrar a la espera. Si la señal llega allí, la cancelación puede no atenderse hasta que la operación retorne por adquisición o vencimiento. El ejemplo tiene un límite finito y no promete cancelación instantánea libre de esa carrera.

La política será explícita: si la operación retorna éxito, se considera consumido el permiso aunque haya llegado una solicitud casi al mismo tiempo. Si aún no se adquirió y el bucle observa cancelación, abandona. No se «deshace» una adquisición exitosa con un post automático de notificación.

8. Código de apoyo para plazos y nombres

Guarda apoyo29.h. Los programas utilizan nombres propios con prefijo /ipc29_ y valores acotados. limite_real construye una fecha normalizada y usa la comprobación de suma de GCC para no desbordar time_t.

apoyo29.h · fecha absoluta y transferencias de control
#ifndef APOYO29_H
#define APOYO29_H
#define _DEFAULT_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <semaphore.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>

static inline int numero(const char *s, unsigned minimo,
                         unsigned maximo, unsigned *salida)
{
    if (!*s) return -1;
    for (const char *p = s; *p; ++p)
        if (*p < '0' || *p > '9') return -1;
    errno = 0;
    char *fin;
    unsigned long n = strtoul(s, &fin, 10);
    if (errno || *fin || n < minimo || n > maximo) return -1;
    *salida = (unsigned)n;
    return 0;
}

static inline int nombre_valido(const char *s)
{
    size_t n = strlen(s);
    if (n <= 7 || n > 80 || strncmp(s, "/ipc29_", 7) != 0) return 0;
    for (size_t i = 7; i < n; ++i) {
        unsigned char c = (unsigned char)s[i];
        if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
              (c >= '0' && c <= '9') || c == '_' || c == '-')) return 0;
    }
    return 1;
}

static inline int limite_real(unsigned ms, struct timespec *t)
{
    if (ms > 60000) { errno = EINVAL; return -1; }
    if (clock_gettime(CLOCK_REALTIME, t) == -1) return -1;
    long ns = t->tv_nsec + (long)(ms % 1000) * 1000000L;
    time_t extra = (time_t)(ms / 1000);
    if (ns >= 1000000000L) { ns -= 1000000000L; ++extra; }
    time_t segundos;
    if (__builtin_add_overflow(t->tv_sec, extra, &segundos)) {
        errno = EOVERFLOW;
        return -1;
    }
    t->tv_sec = segundos;
    t->tv_nsec = ns;
    return 0;
}

static inline int esperar_plazo(sem_t *s, const struct timespec *limite)
{
    int r;
    do { r = sem_timedwait(s, limite); } while (r == -1 && errno == EINTR);
    return r;
}

static inline int enviar_byte(int fd, unsigned char c)
{
    ssize_t n;
    do { n = write(fd, &c, 1); } while (n == -1 && errno == EINTR);
    return n == 1 ? 0 : -1;
}

static inline int recibir_byte(int fd, unsigned char *c)
{
    ssize_t n;
    do { n = read(fd, c, 1); } while (n == -1 && errno == EINTR);
    return n == 1 ? 0 : -1;
}
#endif

La suma de nanosegundos queda por debajo de dos mil millones antes de normalizar, dentro del rango long de los sistemas Linux considerados. La suma de segundos se comprueba con __builtin_add_overflow, una interfaz del compilador GCC utilizado en las prácticas.

esperar_plazo reintenta EINTR sin cancelación para el segundo ejemplo. El primer programa utiliza su propio bucle para distinguir una interrupción ordinaria de una solicitud de abandono.

9. Programa: probar y esperar con límite

Guarda espera29.c. Además de crear, publicar y retirar, ofrece probar con sem_trywait y plazo con sem_timedwait. Una adquisición consume una notificación; no hay devolución automática.

Los retornos de la herramienta son: 0 adquirido u operación administrativa correcta; 1 error; 2 sin disponibilidad inmediata; 3 plazo vencido; 4 cancelación observada sin adquisición.

espera29.c · reintentos con fecha fija y señales locales
#include "apoyo29.h"

static volatile sig_atomic_t cancelar = 0;

static void manejar(int signo)
{
    if (signo == SIGINT || signo == SIGTERM) cancelar = 1;
    /* SIGUSR1 interrumpe sin pedir cancelacion. */
}

static int configurar(void)
{
    struct sigaction a;
    memset(&a, 0, sizeof a);
    a.sa_handler = manejar;
    if (sigemptyset(&a.sa_mask) == -1 ||
        sigaction(SIGUSR1, &a, NULL) == -1 ||
        sigaction(SIGINT, &a, NULL) == -1 ||
        sigaction(SIGTERM, &a, NULL) == -1) return -1;
    return 0;
}

int main(int argc, char **argv)
{
    if (argc < 3 || !nombre_valido(argv[2])) goto uso;
    int crear = strcmp(argv[1], "crear") == 0;
    int probar = strcmp(argv[1], "probar") == 0;
    int plazo = strcmp(argv[1], "plazo") == 0;
    int publicar = strcmp(argv[1], "publicar") == 0;
    int retirar = strcmp(argv[1], "retirar") == 0;
    unsigned valor = 0;
    if (crear || plazo) {
        if (argc != 4 || numero(argv[3], 0, crear ? 32 : 60000, &valor) == -1)
            goto uso;
    } else if (argc != 3 || !(probar || publicar || retirar)) goto uso;
    if (retirar) {
        if (sem_unlink(argv[2]) == -1) { perror("sem_unlink"); return 1; }
        return 0;
    }
    if ((probar || plazo) && configurar() == -1) {
        perror("sigaction"); return 1;
    }
    sem_t *s = crear ? sem_open(argv[2], O_CREAT | O_EXCL, 0600, valor)
                     : sem_open(argv[2], 0);
    if (s == SEM_FAILED) { perror("sem_open"); return 1; }
    int salida = 0;
    unsigned interrupciones = 0;
    if (crear) {
        printf("Creado con %u permisos\n", valor);
    } else if (publicar) {
        if (sem_post(s) == -1) { perror("sem_post"); salida = 1; }
    } else {
        struct timespec limite;
        if (plazo && limite_real(valor, &limite) == -1) {
            perror("construir limite"); salida = 1; goto fin;
        }
        printf("Preparado PID %ld: %s\n", (long)getpid(), argv[1]);
        if (fflush(stdout) == EOF) { salida = 1; goto fin; }
        for (;;) {
            if (cancelar) { salida = 4; break; }
            int r = probar ? sem_trywait(s) : sem_timedwait(s, &limite);
            if (r == 0) { salida = 0; break; }
            int motivo = errno;
            if (cancelar) { salida = 4; break; }
            if (motivo == EINTR) {
                if (interrupciones < UINT_MAX) ++interrupciones;
                continue; /* No se reconstruye limite. */
            }
            if (probar && motivo == EAGAIN) salida = 2;
            else if (plazo && motivo == ETIMEDOUT) salida = 3;
            else { errno = motivo; perror("adquirir"); salida = 1; }
            break;
        }
        const char *mensajes[] = {
            "Permiso consumido", "Error de adquisicion", "Sin permiso inmediato",
            "Plazo agotado sin adquisicion", "Cancelacion sin adquisicion"
        };
        printf("%s\nReintentos por EINTR: %u\n", mensajes[salida], interrupciones);
    }
fin:
    if (fflush(stdout) == EOF || ferror(stdout)) salida = 1;
    if (sem_close(s) == -1) { perror("sem_close"); salida = 1; }
    if (crear && salida != 0 && sem_unlink(argv[2]) == -1)
        perror("sem_unlink tras fallo");
    return salida;
uso:
    fprintf(stderr, "Uso: %s crear /ipc29_nombre valor(0..32)\n"
                    "     %s probar|publicar|retirar /ipc29_nombre\n"
                    "     %s plazo /ipc29_nombre milisegundos(0..60000)\n",
                    argv[0], argv[0], argv[0]);
    return 1;
}

El manejador solo asigna la bandera local para cancelación. No llama a sem_post, no imprime y no toca datos del recurso. El contador de reintentos mide retornos EINTR atendidos por el bucle, no el número exacto de señales enviadas o entregadas.

La fecha se construye antes del mensaje «Preparado». Si se envía una señal justo después de ver ese mensaje, podría llegar antes de que el proceso entre al núcleo. Por eso un ensayo manual no debe exigir un número exacto de interrupciones.

10. Laboratorio de permisos, plazos y señales

Bash en Linux o WSL · compilar y crear un recurso propio
$ gcc -std=c17 -O2 -Wall -Wextra -Wpedantic espera29.c -o espera29 -pthread
$ nombre="/ipc29_$$_prueba"
$ ./espera29 crear "$nombre" 0
Creado con 0 permisos
$ ./espera29 probar "$nombre"
Preparado PID ...: probar
Sin permiso inmediato
Reintentos por EINTR: 0
$ echo $?
2
$ ./espera29 plazo "$nombre" 200
Preparado PID ...: plazo
Plazo agotado sin adquisicion
Reintentos por EINTR: 0
$ echo $?
3

El retorno 2 indica que no se esperó disponibilidad; el 3 corresponde al vencimiento de una operación temporal. Ambos dejan sin consumo de permisos a esa llamada. La herramienta no publica nada para compensarlos.

Una adquisición inmediata con límite ya alcanzado

Bash · plazo cero y permiso disponible
$ ./espera29 publicar "$nombre"
$ ./espera29 plazo "$nombre" 0
Preparado PID ...: plazo
Permiso consumido
Reintentos por EINTR: 0

La fecha se construye con el instante actual y puede estar vencida al entrar. Si el permiso está disponible, la adquisición puede completarse igualmente. Si no hay permiso, el mismo plazo cero termina por ETIMEDOUT.

Interrumpir y publicar desde otra terminal

terminal A · conserva el nombre propio de la prueba
$ ./espera29 plazo "$nombre" 10000
Preparado PID 12345: plazo

En B usa el nombre exacto de A y reemplaza 12345 por el PID impreso. Una variable de la shell de A no aparece automáticamente en B.

terminal B · una interrupción no renueva los diez segundos iniciales
$ kill -USR1 12345
$ ./espera29 publicar /ipc29_NOMBRE_DE_A

Si se publica a tiempo, A consume y termina. El número de reintentos puede variar según cuándo se recibió la señal. Si no publicas, el plazo sigue siendo el original; no se convierte en «diez segundos después de cada señal».

Solicitar cancelación

Lanza otra espera, observa su nuevo PID y envíale SIGTERM. Si el bucle observa la solicitud sin haber adquirido, informa «Cancelacion sin adquisicion» y retorna 4. Esta es la política de nuestra aplicación, no el mecanismo de cancelación de hilos pthread_cancel.

Si la señal llega en el intervalo anterior a la espera, el programa puede seguir esperando hasta adquirir o vencer. Si la operación ya tuvo éxito, la adquisición prevalece y se informa consumo. No diseñes una prueba que exija una resolución instantánea y única para eventos casi simultáneos.

terminal A · limpieza después de terminar los participantes
$ ./espera29 retirar "$nombre"

Una colisión de creación debe fallar sin borrar el semáforo existente. Como en el tema 27, los nombres se administran de forma serial y solo se retiran recursos propios del laboratorio.

11. Un timeout no demuestra muerte ni consistencia

Después de ETIMEDOUT, un trabajador puede seguir calculando, estar detenido, no haber sido planificado o haber muerto. El semáforo no conserva una identidad de propietario que permita distinguir esas situaciones mediante la espera.

Vencimiento, estado del proceso y estado de datos son preguntas distintasTras un timeout se sabe que no hubo adquisición. Para decidir una política deben examinarse por separado la terminación del trabajador, la consistencia de datos y la posibilidad de futuros accesos. ETIMEDOUTNo se adquirio¿El trabajador termino? Consultar su estado¿Los datos son consistentes? Aplicar el protocolo¿Quedan usuarios? Terminar antes de destruir
El tiempo agotado no responde las otras tres preguntas.

waitpid con WNOHANG puede informar la terminación de un hijo propio sin bloquear. Si retorna cero, aún no hay una terminación recogible en ese instante; eso no demuestra progreso ni excluye una caída inmediatamente posterior.

Si el hijo murió, tampoco queda demostrado que sus datos sean correctos. Pudo caer después de modificar un campo y antes de completar otro. Incluso conocer su PID no convierte un semáforo en un registro transaccional.

El segundo programa elegirá una política conservadora: si no logra adquirir dentro del plazo, confirma o fuerza la terminación del usuario conocido, lo recoge y descarta toda la región. No continúa sobre una estructura cuya consistencia no puede probar.

12. Programa: trabajador normal, fallido o detenido

Guarda recuperacion29.c. Hay un solo hijo y un semáforo embebido con un permiso. El hijo adquiere, deja una modificación incompleta y avisa por una tubería. En normal completa el dato y publica; en fallar termina con código 7; en colgar permanece vivo sin publicar.

El padre comienza su espera temporal después del aviso, para no consumir el permiso antes de que el hijo entre. La tubería bloqueante de preparación no tiene aquí un presupuesto global: el límite de milisegundos cubre la adquisición posterior, no toda la vida del supervisor.

recuperacion29.c · detectar, terminar usuarios y descartar sin post de rescate
#include "apoyo29.h"

struct region {
    sem_t mutex;
    unsigned fase;
    unsigned dato;
};

static int cerrar(int *fd)
{
    if (*fd == -1) return 0;
    int r = close(*fd);
    *fd = -1;
    if (r == -1) perror("close");
    return r;
}

static int trabajar(struct region *r, int aviso, const char *modo)
{
    int n;
    do { n = sem_wait(&r->mutex); } while (n == -1 && errno == EINTR);
    if (n == -1) return 2;
    r->fase = 1; /* Modificacion incompleta. */
    r->dato = 7;
    if (enviar_byte(aviso, 'A') == -1) return 3;
    if (strcmp(modo, "fallar") == 0) _exit(7);
    if (strcmp(modo, "colgar") == 0)
        for (;;) pause();
    r->dato = 49;
    r->fase = 2;
    if (sem_post(&r->mutex) == -1) return 4;
    return 0;
}

int main(int argc, char **argv)
{
    unsigned ms;
    if (argc != 3 || (strcmp(argv[1], "normal") != 0 &&
                      strcmp(argv[1], "fallar") != 0 &&
                      strcmp(argv[1], "colgar") != 0) ||
        numero(argv[2], 1, 60000, &ms) == -1) {
        fprintf(stderr, "Uso: %s normal|fallar|colgar plazo_ms(1..60000)\n", argv[0]);
        return 1;
    }
    struct sigaction a;
    memset(&a, 0, sizeof a);
    a.sa_handler = SIG_IGN;
    if (sigemptyset(&a.sa_mask) == -1 || sigaction(SIGPIPE, &a, NULL) == -1) {
        perror("SIGPIPE"); return 1;
    }
    struct region *r = mmap(NULL, sizeof *r, PROT_READ | PROT_WRITE,
                            MAP_SHARED | MAP_ANONYMOUS, -1, 0);
    if (r == MAP_FAILED) { perror("mmap"); return 1; }
    r->fase = 0;
    r->dato = 0;
    int inicializado = 0, adquirido = 0, recogido = 0;
    int salida = 1, estado = 0;
    unsigned resultado = 0;
    pid_t hijo = -1;
    int aviso[2] = {-1, -1};
    if (sem_init(&r->mutex, 1, 1) == -1) { perror("sem_init"); goto fin; }
    inicializado = 1;
    if (pipe(aviso) == -1) { perror("pipe"); goto fin; }
    hijo = fork();
    if (hijo == -1) { perror("fork"); goto fin; }
    if (hijo == 0) {
        cerrar(&aviso[0]);
        int codigo = trabajar(r, aviso[1], argv[1]);
        if (cerrar(&aviso[1]) == -1) codigo = 5;
        if (munmap(r, sizeof *r) == -1) codigo = 6;
        _exit(codigo);
    }
    if (cerrar(&aviso[1]) == -1) goto fin;
    unsigned char c;
    if (recibir_byte(aviso[0], &c) == -1 || c != 'A') {
        fprintf(stderr, "No se confirmo preparacion del hijo\n"); goto fin;
    }
    puts("Preparacion confirmada: el hijo adquirio el permiso.");
    struct timespec limite;
    if (limite_real(ms, &limite) == -1) { perror("limite"); goto fin; }
    if (esperar_plazo(&r->mutex, &limite) == 0) {
        adquirido = 1;
        if (r->fase != 2 || r->dato != 49) {
            fprintf(stderr, "Datos incompatibles pese a la adquisicion\n"); goto fin;
        }
        resultado = r->dato;
        salida = 0;
    } else if (errno == ETIMEDOUT) {
        salida = 3;
        puts("Plazo agotado: no se adquirio ni se publica un permiso de rescate.");
        pid_t pid;
        do { pid = waitpid(hijo, &estado, WNOHANG); }
        while (pid == -1 && errno == EINTR);
        if (pid == hijo) { recogido = 1; puts("Terminacion del hijo confirmada."); }
        else if (pid == 0) puts("Sin terminacion observable: puede seguir vivo.");
        else { perror("waitpid WNOHANG"); salida = 1; }
    } else {
        perror("sem_timedwait");
    }

fin:
    if (cerrar(&aviso[0]) == -1) salida = 1;
    if (cerrar(&aviso[1]) == -1) salida = 1;
    /* Solo se devuelve si el propio padre adquirio de verdad. */
    if (adquirido && sem_post(&r->mutex) == -1) {
        perror("sem_post padre"); salida = 1;
    }
    if (hijo > 0 && !recogido) {
        if (salida != 0 && kill(hijo, SIGKILL) == -1 && errno != ESRCH)
            perror("kill hijo");
        pid_t pid;
        do { pid = waitpid(hijo, &estado, 0); } while (pid == -1 && errno == EINTR);
        if (pid == hijo) recogido = 1;
        else { perror("waitpid final"); salida = 1; }
    }
    if (recogido) {
        if (WIFEXITED(estado)) printf("Hijo recogido; codigo %d\n", WEXITSTATUS(estado));
        else if (WIFSIGNALED(estado)) printf("Hijo recogido; senal %d\n", WTERMSIG(estado));
        if (salida == 0 && (!WIFEXITED(estado) || WEXITSTATUS(estado) != 0))
            salida = 1;
        if (salida == 0) printf("Resultado confirmado: %u\n", resultado);
        else puts("Usuario terminado; datos descartados. No se continua sobre esta region.");
    }
    if (inicializado && (hijo < 0 || recogido)) {
        if (sem_destroy(&r->mutex) == -1) { perror("sem_destroy"); salida = 1; }
    } else if (inicializado) {
        fprintf(stderr, "No se destruye sin confirmar el fin del usuario\n");
        salida = 1;
    }
    if (munmap(r, sizeof *r) == -1) { perror("munmap"); salida = 1; }
    if (fflush(stdout) == EOF || ferror(stdout)) salida = 1;
    return salida;
}

El aviso por tubería confirma una acción del programa del hijo; no convierte al semáforo en un recurso que identifique a su dueño. En normal el hijo puede haber publicado antes de que el padre entre a esperar y la adquisición se completará inmediatamente.

El padre no consulta fase ni dato al vencer el plazo. Solo examina esos campos si adquirió correctamente. Ante fallo descarta el almacenamiento después de resolver la vida del hijo, sin usar datos parciales para decidir que puede continuar.

El proceso es independiente, de un solo hilo antes de fork y sin otros recolectores de ese PID. Solo se envía SIGKILL al hijo todavía no recogido. La consulta WNOHANG y la recolección se rigen por wait(2).

13. Observar la supervisión y el descarte

Bash · una ejecución aceptada
$ gcc -std=c17 -O2 -Wall -Wextra -Wpedantic recuperacion29.c -o recuperacion29 -pthread
$ ./recuperacion29 normal 1000
Preparacion confirmada: el hijo adquirio el permiso.
Hijo recogido; codigo 0
Resultado confirmado: 49
$ echo $?
0

La aceptación requiere adquisición, validación de datos y terminación exitosa del hijo. Si el entorno impide completar dentro del plazo, incluso el modo normal puede fallar la espera; «normal» elige el comportamiento del trabajador, no garantiza la planificación.

Bash · caída conservando el permiso
$ ./recuperacion29 fallar 200
Preparacion confirmada: el hijo adquirio el permiso.
Plazo agotado: no se adquirio ni se publica un permiso de rescate.
Terminacion del hijo confirmada.
Hijo recogido; codigo 7
Usuario terminado; datos descartados. No se continua sobre esta region.
$ echo $?
3

La línea de terminación inmediata depende de si waitpid ya puede observarla al consultar. Si no, la limpieza envía cancelación al pendiente y lo recoge. Lo exigible es que no se acepte el dato parcial ni quede un usuario conocido al destruir.

Bash · proceso vivo que no publica
$ ./recuperacion29 colgar 200
Preparacion confirmada: el hijo adquirio el permiso.
Plazo agotado: no se adquirio ni se publica un permiso de rescate.
Sin terminacion observable: puede seguir vivo.
Hijo recogido; senal 9
Usuario terminado; datos descartados. No se continua sobre esta region.

En colgar el hijo permanece en pause y no termina por sí mismo. El padre no deduce muerte del timeout: primero observa que no hay terminación y después aplica su política de cancelación. La señal exacta puede variar si interviene otro actor externo.

14. Recuperar exige otro contrato

El programa anterior recupera el control de sus procesos, pero no repara el estado de una operación incompleta. Descarta la región. Si un servicio debe continuar, necesita decidir qué datos pueden reutilizarse y cómo se excluyen usuarios de una generación antigua.

Pregunta de recuperaciónInformación necesariaLo que no basta
¿La operación llegó a completarse?Estado de compromiso, confirmaciones y validación de consistencia.Que un permiso vuelva a estar disponible.
¿Puede repetirse el trabajo?Identificadores e idempotencia de sus efectos.Reenviar sin saber si hubo un efecto externo.
¿Puede crearse otro recurso?Retirada o aislamiento de los usuarios antiguos y nueva generación.Reutilizar el mismo nombre y suponer que reconecta vistas.
¿Quién está autorizado a reconstruir?Un responsable elegido y una fase sin acceso concurrente incompatible.Que cualquier proceso llame a sem_init cuando vea cero.

Ni sem_close ni la terminación devuelven automáticamente un permiso consumido. Tampoco existe un «deshacer todo» de los campos protegidos por el semáforo. Un sem_post de rescate puede admitir a otro proceso sobre datos a medio modificar.

Un mutex robusto es otra herramienta con un contrato diferente: puede informar EOWNERDEAD y exigir que el nuevo propietario repare la consistencia. Esa detección no repara por sí misma los datos y requiere la configuración adecuada, según pthread_mutexattr_setrobust(3).

Para un búfer con varios permisos, el problema puede afectar a huecos, elementos y exclusión a la vez. Recuperar cada contador por separado sin conocer qué operación estaba en curso puede violar la estructura del búfer.

Una política inicial válida es fallo total y reinicio desde datos de entrada conservados, siempre que los efectos externos puedan manejarse correctamente. Otra puede reconstruir desde un registro de operaciones. La elección pertenece al protocolo de aplicación.

15. Limpieza y límites del presupuesto temporal

La limpieza debe distinguir permiso adquirido, proceso terminado y objeto inicializado. Esos hechos no se sustituyen entre sí. Una espera vencida deja al padre sin permiso, pero puede dejar un hijo vivo y un semáforo perfectamente inicializado.

  1. Registrar el resultado real de la adquisición. No publicar si nunca se obtuvo el permiso.
  2. Aplicar la política de fallo. En el ejemplo se abandona el conjunto, sin consumir datos parciales.
  3. Terminar y recoger al usuario conocido. La cancelación se dirige solo al hijo pendiente.
  4. Destruir cuando ya no hay usuarios. El valor puede seguir en cero; no se necesita un post artificial.
  5. Retirar el almacenamiento local. Después de destruir, munmap cierra la vida de la región.

No conviertas «la adquisición tiene plazo» en «el proceso entero siempre termina en ese tiempo». La apertura, la preparación, la planificación y la recolección tienen sus propias condiciones. Un proceso en ciertos estados del núcleo puede no completar la terminación de inmediato incluso después de solicitarla.

El segundo ejemplo usa una preparación bloqueante y no integra un presupuesto monotónico global para todas sus fases. Un supervisor de servicio tendría que incorporar el canal de preparación a su bucle de eventos y supervisar todo el ciclo, no solo el semáforo.

Si no se logra confirmar la salida del hijo, no se llama a sem_destroy suponiendo que no hay usuarios. Retirar la vista local no borra la que otros conservan. Esa ruta informa error y no promete una limpieza global completa.

16. Explorar reintentos y fechas límite

El modelo parte de un reloj en cero, una ventana de diez segundos y ningún permiso. Avanza tres segundos, interrumpe y compara conservar la fecha con recalcularla. Publicar permite estudiar una llegada posterior al timeout de una operación anterior.

Reloj del modelo0 s

Fecha límite10 s

Operación temporal originalEsperando

Permisos disponibles0

Avanza y genera interrupciones para comparar las políticas.

Si la espera original ya terminó, publicar no cambia retroactivamente su resultado. Una nueva sem_trywait puede consumir la unidad que llegó más tarde. Así se distingue la decisión sobre una solicitud de la vida posterior del recurso.

Mientras la espera original está activa, el modelo reserva la llegada para completar esa espera y no permite competir con el botón de una nueva llamada. Es una simplificación didáctica; no representa una garantía general de prioridad entre esperadores.

El tiempo avanza en pasos y no reproduce saltos de CLOCK_REALTIME ni retrasos del planificador. La comparación se centra en el error de renovar el presupuesto al reintentar.

17. Pruebas y diagnóstico

Resultados que sí tienen un contrato

Comprobar EINTR sin una prueba frágil

Una secuencia de señales enviada desde fuera puede llegar entre llamadas o agruparse. Para verificar automáticamente que no se renueva la fecha, una prueba puede envolver sem_timedwait, hacer que retorne EINTR varias veces y comparar el timespec recibido en todos los intentos.

Esa prueba debe conservar el comportamiento real después de los errores inyectados. También puede forzar una interrupción que marque cancelación y comprobar que no se consume ni se publica un permiso por ese camino.

Para probar la normalización, proporciona un reloj controlado cercano al final de un segundo y verifica el acarreo. No cambies la hora del sistema para probar código de un curso. Una suma cercana al máximo de time_t debe rechazarse sin desbordar.

Pruebas de supervisión

Ejecuta los tres modos del segundo programa. En fallar y colgar debe retornarse vencimiento, no mostrarse un resultado confirmado y haberse recogido al hijo antes de destruir. Un controlador de pruebas debe imponer su propio límite externo y limpiar a los procesos de la prueba si el programa se bloquea.

Simula también fallo de sem_init y de fork. No debe destruirse un objeto no inicializado ni intentarse recoger un PID inexistente. Un fallo en la preparación del hijo debe dar EOF o error, cancelar al pendiente y descartar el dato.

Bash · observar la espera y la recolección
$ strace -f -e trace=futex,read,write,wait4,kill,close ./recuperacion29 fallar 200

La traza puede mostrar esperas internas de biblioteca y las llamadas de supervisión. No todos los éxitos de adquisición requieren un futex visible. Las operaciones sobre fase y dato son accesos a memoria, no escrituras a la tubería.

SíntomaQué revisarCorrección
Las señales prolongan la espera.Se reconstruye la fecha dentro del bucle.Calcular una vez y conservarla al reintentar.
Timeout inmediato inesperado.Se pasó una duración o un reloj equivocado.Fecha absoluta normalizada del reloj apropiado.
Éxito aunque el límite ya pasó.Había permiso disponible.Distinguir límite de espera de fecha de aceptación del negocio.
Un timeout admite más usuarios.Se publica por una adquisición que no ocurrió.No fabricar permisos de compensación.
Se aceptan datos incompletos.Se infiere consistencia de un permiso o de una muerte.Validación y protocolo de compromiso, o descarte completo.
La cancelación no es instantánea.Señal recibida entre bandera y espera.Reconocer el alcance de esta política o usar un diseño de espera integrado.

18. Resumen

19. Preguntas de repaso y práctica

Responde antes de desplegar cada explicación.

1. ¿EAGAIN significa que el semáforo está averiado?

No. En sem_trywait indica que el intento no pudo adquirir inmediatamente. El estado puede cambiar por una publicación posterior.

2. ¿Por qué no se consulta sem_getvalue antes de intentar?

Porque consultar y consumir serían acciones separadas. Otra operación puede cambiar el valor; la adquisición correcta es la llamada que intenta consumir.

3. ¿Qué reloj utiliza sem_timedwait?

Su fecha absoluta se refiere a CLOCK_REALTIME. Un timespec tomado de CLOCK_MONOTONIC no es un argumento equivalente.

4. ¿Qué se hace si la suma de nanosegundos llega a mil millones?

Se resta mil millones a tv_nsec y se añade un segundo, comprobando también que la suma de segundos sea representable.

5. ¿Por qué se conserva la fecha tras EINTR?

Porque reconstruir ahora más el intervalo renovaría el plazo y podría prolongar indefinidamente la ventana originalmente aceptada.

6. ¿Una señal enviada equivale a un retorno EINTR observado?

No necesariamente. Puede llegar entre llamadas, y algunas señales pueden agruparse. El contador del programa registra reintentos efectivamente atendidos.

7. ¿Puede tener éxito una llamada con fecha ya vencida?

Sí, si puede adquirir inmediatamente. El plazo limita la espera necesaria; no expresa por sí solo una fecha límite de aceptación del trabajo.

8. ¿Por qué no se publica al recibir ETIMEDOUT?

Porque esa llamada no adquirió un permiso que devolver. Publicar agregaría capacidad y podría admitir participantes indebidamente.

9. ¿Qué significa un permiso que llega después del timeout?

Puede quedar disponible para otra adquisición. No modifica retroactivamente el resultado de la llamada que ya terminó.

10. ¿El timeout prueba que el trabajador murió?

No. Puede seguir vivo, detenido, calculando o no haber sido planificado. Su terminación se comprueba mediante mecanismos de supervisión apropiados.

11. ¿Por qué el padre no lee fase y dato al vencer?

Porque no adquirió la protección y el trabajador podría seguir modificándolos. El ejemplo descarta el estado después de terminar al usuario conocido.

12. ¿Por qué se confirma preparación mediante una tubería?

Para que el padre comience a adquirir después de que el hijo haya consumido el permiso. No es una propiedad de dueño añadida al semáforo.

13. ¿La bandera local de cancelación garantiza respuesta instantánea?

No. Una señal puede llegar entre comprobarla y comenzar la espera. La operación puede retornar más tarde por adquisición o vencimiento según la política explicada.

14. ¿Un mutex robusto repara automáticamente los datos?

No. Puede informar muerte del propietario y habilitar un protocolo de reparación, pero la consistencia debe restablecerla la aplicación.

15. ¿Qué debe cumplirse antes de sem_destroy en la ruta de fallo?

Que el semáforo se inicializó correctamente y se confirmó que no quedan usuarios ni esperadores que puedan operar sobre esa generación.

Para practicar y ampliar

  1. Prueba sem_trywait con cero y con una unidad; verifica el consumo y los retornos.
  2. Compara plazo cero con permiso disponible y sin permiso.
  3. Interrumpe una espera mediante SIGUSR1 sin reconstruir la fecha.
  4. Solicita cancelación y explica los resultados posibles si una publicación llega casi al mismo tiempo.
  5. En el simulador, extiende varias veces el límite incorrecto y compáralo con una fecha fija.
  6. Publica después de un timeout y comprueba que una nueva operación puede adquirir.
  7. Ejecuta normal, fallar y colgar; identifica cuándo se conoce la terminación del hijo.
  8. Simula errores de sem_init, fork y preparación, verificando la limpieza de recursos realmente obtenidos.
  9. Diseña una generación nueva de datos que no pueda ser modificada por participantes de la anterior.
  10. Define un protocolo de tarea idempotente antes de decidir cómo reintentar tras una confirmación perdida.
Próximo paso

El tema 30 integrará memoria compartida y semáforos en un búfer circular: productor y consumidor con permisos de huecos, elementos y exclusión mutua.