1. La ventana entre consultar y dormir
En el tema 7 adelantamos una carrera que ahora estudiaremos en detalle. Supón que un manejador asigna 1 a un flag y que main utiliza este patrón:
while (!peticion)
pause();Una ejecución posible es: main lee cero; llega la señal; el manejador pone uno y retorna; main entra en pause. La señal ya se atendió, pero el programa duerme esperando otra. No hace falta una máquina con varios núcleos para que ocurra: basta una interrupción en ese intervalo.
Repetir la prueba sin observar el fallo no elimina la ventana. Añadir sleep cambia la probabilidad y puede hacer más lento el programa, pero no une la consulta con la espera. Declarar el flag volatile sig_atomic_t evita otro tipo de problema; tampoco vuelve atómicas esas dos acciones.
Una espera correcta debe conservar la petición si llega antes de dormir y permitir atenderla si llega durante la espera, sin dejar un intervalo donde el despertar pueda consumirse antes de que el programa empiece a esperar.
Veremos dos soluciones. Con sigsuspend el manejador registra la petición bajo un protocolo de máscaras. Con sigwait el flujo normal acepta directamente una señal que se mantuvo bloqueada, sin ejecutar un manejador para ese conjunto.
2. Construir conjuntos de señales
Un sigset_t representa un conjunto, no necesariamente un entero que puedas construir sumando números de señal. Su interfaz permite añadir, quitar y consultar miembros:
| Operación | Qué hace | Resultado que se comprueba |
|---|---|---|
| sigemptyset(&conjunto) | Inicializa un conjunto vacío. | 0 o −1. |
| sigfillset(&conjunto) | Inicializa el conjunto con las señales contempladas por la interfaz. | 0 o −1. |
| sigaddset(&conjunto, señal) | Añade una señal. | 0 o −1. |
| sigdelset(&conjunto, señal) | Retira una señal. | 0 o −1. |
| sigismember(&conjunto, señal) | Consulta pertenencia. | 1 si pertenece, 0 si no, −1 si falla. |
Crear el conjunto no cambia todavía la máscara del hilo. Por ejemplo, añadir SIGUSR1 a una variable local solo prepara una descripción que después podrás usar en sigprocmask, sigsuspend o sigwait. Cada una interpreta ese conjunto de una manera distinta.
sigset_t control;
if (sigemptyset(&control) == -1 ||
sigaddset(&control, SIGUSR1) == -1 ||
sigaddset(&control, SIGTERM) == -1) {
/* Tratar el error antes de usar el conjunto. */
}No confundas un error de sigismember con «sí pertenece»: comprobar solo si el retorno es distinto de cero mezclaría 1 con −1. Las operaciones de preparación se comprueban igual que las llamadas de ejecución.
3. Administrar la máscara con sigprocmask
La máscara indica qué señales están bloqueadas para el hilo. En los programas de un solo hilo de esta lección utilizaremos sigprocmask y conservaremos la máscara anterior cuando la necesitemos.
| Modo | Efecto sobre la máscara actual | Uso típico |
|---|---|---|
| SIG_BLOCK | Añade los miembros del conjunto. | Proteger una consulta de estado sin retirar otros bloqueos. |
| SIG_UNBLOCK | Retira los miembros del conjunto. | Permitir esas señales, conservando los demás miembros. |
| SIG_SETMASK | Sustituye la máscara completa. | Restaurar una máscara guardada o instalar una calculada. |
sigset_t anterior;
if (sigprocmask(SIG_BLOCK, &control, &anterior) == -1) {
/* No continuar suponiendo que las señales quedaron bloqueadas. */
}Con set igual a NULL puedes consultar la máscara sin modificarla. Si instalas un conjunto con SIG_SETMASK, ese conjunto es la máscara nueva completa, no una lista adicional de señales que se desbloquean. La distinción es importante al preparar sigsuspend.
No es posible bloquear SIGKILL ni SIGSTOP. Intentarlo dentro de un conjunto no proporciona una zona inmune a esas señales. Los modos, resultados y restricciones se documentan en sigprocmask(2).
Restaurar una máscara puede permitir entregar señales que ya estaban pendientes. Trata esa restauración como un punto donde puede cambiar el control del programa, no como una mera asignación local sin efectos.
4. Bloqueada, pendiente e ignorada
Bloqueada significa que su entrega está impedida por la máscara. Pendiente significa que existe una instancia generada por atender. Ignorada describe una disposición. Son propiedades diferentes: una señal bloqueada que aún no se generó no tiene por qué estar pendiente.
sigpending obtiene una instantánea del conjunto pendiente para el hilo que lo consulta. No consume las señales ni las entrega a un manejador. Consultarlo repetidamente tampoco sustituye una espera: sería una consulta activa innecesaria.
Si una señal estándar se genera varias veces mientras está pendiente, sus ocurrencias pueden agruparse. Una pertenencia al conjunto pendiente expresa presencia, no un contador. Tampoco debes construir el protocolo suponiendo un orden universal de entrega entre señales estándar distintas.
La consulta se describe en sigpending(2). El experimento siguiente instala expresamente un manejador y bloquea SIGUSR1 para que la observación no dependa de una disposición ignorada heredada.
5. Experimento: observar una señal pendiente
El programa bloquea SIGUSR1, instala un manejador y genera dos ocurrencias con raise. Después consulta el conjunto pendiente, permite entregar la señal y vuelve a consultar. Las impresiones se ejecutan en main y el manejador solo asigna un flag.
#define _POSIX_C_SOURCE 200809L
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
static volatile sig_atomic_t recibida = 0;
static void anotar(int senal)
{
(void)senal;
recibida = 1;
}
static int mostrar(const char *fase)
{
sigset_t pendientes;
if (sigpending(&pendientes) == -1) {
perror("sigpending");
return -1;
}
int miembro = sigismember(&pendientes, SIGUSR1);
if (miembro == -1) {
perror("sigismember");
return -1;
}
printf("%s: flag=%d, pendiente=%d\n", fase, (int)recibida, miembro);
return 0;
}
int main(void)
{
sigset_t conjunto, previa;
if (sigemptyset(&conjunto) == -1 ||
sigaddset(&conjunto, SIGUSR1) == -1 ||
sigprocmask(SIG_BLOCK, &conjunto, &previa) == -1) {
perror("bloquear SIGUSR1");
return EXIT_FAILURE;
}
int resultado = EXIT_FAILURE;
struct sigaction accion = {0};
accion.sa_handler = anotar;
if (sigemptyset(&accion.sa_mask) == -1 ||
sigaction(SIGUSR1, &accion, NULL) == -1) {
perror("sigaction");
goto restaurar;
}
if (raise(SIGUSR1) != 0 || raise(SIGUSR1) != 0) {
perror("raise");
goto restaurar;
}
if (mostrar("Antes de desbloquear") == -1)
goto restaurar;
if (sigprocmask(SIG_UNBLOCK, &conjunto, NULL) == -1) {
perror("desbloquear SIGUSR1");
goto restaurar;
}
if (mostrar("Despues de desbloquear") == -1)
goto restaurar;
resultado = recibida == 1 ? EXIT_SUCCESS : EXIT_FAILURE;
restaurar:
if (sigprocmask(SIG_SETMASK, &previa, NULL) == -1) {
perror("restaurar mascara");
resultado = EXIT_FAILURE;
}
return resultado;
}$ gcc -std=c17 -Wall -Wextra -Wpedantic observar_pendiente.c -o observar_pendiente
$ ./observar_pendiente
Antes de desbloquear: flag=0, pendiente=1
Despues de desbloquear: flag=1, pendiente=0Antes de desbloquear, el manejador no se ejecutó, pero la señal está pendiente. Al permitirla se aplica la acción instalada. Las dos llamadas a raise no convierten el conjunto en un contador de dos unidades. Este programa termina después del experimento; restaura la máscara previa y mantiene su manejador hasta salir.
6. La espera atómica con sigsuspend
sigsuspend sustituye temporalmente la máscara del hilo por la recibida y lo suspende hasta una señal que invoque un manejador o lo termine. Si el manejador retorna, sigsuspend retorna con −1 y EINTR y se recupera la máscara que estaba vigente antes de la llamada.
En el patrón correcto se bloquean primero las señales de control. Mientras están bloqueadas, main consulta sus flags. Si no hay trabajo, llama a sigsuspend con una máscara que las permita: no hay un desbloqueo separado seguido de una espera.
/* Ya se bloquearon las señales de control y se instalaron sus acciones. */
sigset_t espera = previa;
sigdelset(&espera, SIGUSR1); /* Comprobar los resultados en el programa completo. */
sigdelset(&espera, SIGTERM);
while (!peticion && !parar) {
if (sigsuspend(&espera) == -1 && errno != EINTR) {
/* Tratar el error. */
}
}El argumento es la máscara temporal completa de señales que quedan bloqueadas. No es un conjunto de las señales que quieres recibir. Si pasas justamente un conjunto que contiene SIGUSR1 y SIGTERM, podrías bloquear las dos que necesitabas para despertar.
La base previa conserva las decisiones heredadas sobre otras señales. Retirar explícitamente las de control indica que este programa quiere atenderlas aunque inicialmente vinieran bloqueadas. Al volver de cada manejador se restablece el bloqueo que protege la consulta de los flags.
El bucle sigue siendo necesario: una señal ajena puede invocar otro manejador y hacer retornar la espera sin satisfacer la condición de la aplicación. EINTR indica que retornó de un manejador, no qué petición lógica debes procesar. La interfaz se detalla en sigsuspend(2).
7. Proyecto: peticiones con manejador
Este servicio pequeño acepta SIGUSR1 como petición de trabajo y SIGTERM como parada. Bloquea ambas antes de instalar los manejadores y solo permite su entrega durante sigsuspend. Por eso puede copiar o limpiar sus flags y realizar esta práctica sencilla sin recibir otra intervención de esos manejadores en mitad de la operación.
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
static volatile sig_atomic_t peticion = 0;
static volatile sig_atomic_t parar = 0;
static void registrar(int senal)
{
if (senal == SIGUSR1)
peticion = 1;
else if (senal == SIGTERM)
parar = 1;
}
int main(void)
{
sigset_t control, previa;
if (sigemptyset(&control) == -1 ||
sigaddset(&control, SIGUSR1) == -1 ||
sigaddset(&control, SIGTERM) == -1 ||
sigprocmask(SIG_BLOCK, &control, &previa) == -1) {
perror("preparar bloqueo");
return EXIT_FAILURE;
}
struct sigaction accion = {0};
accion.sa_handler = registrar;
accion.sa_mask = control;
if (sigaction(SIGUSR1, &accion, NULL) == -1 ||
sigaction(SIGTERM, &accion, NULL) == -1) {
perror("sigaction");
return EXIT_FAILURE;
}
sigset_t espera = previa;
if (sigdelset(&espera, SIGUSR1) == -1 ||
sigdelset(&espera, SIGTERM) == -1) {
perror("preparar espera");
return EXIT_FAILURE;
}
printf("PID listo: %ld\n", (long)getpid());
puts("SIGUSR1 solicita trabajo; SIGTERM solicita parada.");
if (fflush(stdout) == EOF) {
perror("fflush");
return EXIT_FAILURE;
}
while (!parar) {
while (!peticion && !parar) {
if (sigsuspend(&espera) == -1 && errno != EINTR) {
perror("sigsuspend");
return EXIT_FAILURE;
}
}
if (parar)
break;
peticion = 0; /* Las señales de control vuelven a estar bloqueadas. */
puts("SIGUSR1 atendida desde main");
if (fflush(stdout) == EOF) {
perror("fflush");
return EXIT_FAILURE;
}
}
puts("Parada controlada con sigsuspend");
return EXIT_SUCCESS;
}$ gcc -std=c17 -Wall -Wextra -Wpedantic -g -O0 espera_sigsuspend.c -o espera_sigsuspend
$ ./espera_sigsuspend &
$ pid=$!
... espera las líneas de preparación ...
$ kill -USR1 "$pid"
SIGUSR1 atendida desde main
$ kill -TERM "$pid"
$ wait "$pid"
Parada controlada con sigsuspendEl trabajo real está representado por una impresión. Durante ese trabajo las señales de control permanecen bloqueadas: una petición puede quedar pendiente hasta volver a esperar. Para trabajo largo o para atender otros descriptores hay que diseñar puntos de cancelación y una integración más apropiada; el ejemplo no promete una latencia máxima de parada.
La prioridad por la parada se aplica a los flags ya observados. Si dos señales diferentes siguen pendientes, no se impone por este código un orden universal de entrega. No confundas la política de la aplicación con una garantía de orden del sistema.
8. Recepción síncrona con sigwait
sigwait permite otro enfoque: mantener bloqueadas las señales elegidas y aceptarlas desde una llamada normal. Cuando una señal del conjunto está pendiente, sigwait la consume y escribe su número en el argumento de salida. No ejecuta para esa aceptación un manejador asíncrono.
int senal;
int error = sigwait(&esperadas, &senal);
if (error != 0) {
fprintf(stderr, "sigwait: %s\n", strerror(error));
}El conjunto contiene las señales que quieres aceptar, a diferencia de la máscara temporal de sigsuspend. Deben estar bloqueadas según el protocolo. No las desbloquees justo antes de llamar: con su disposición predeterminada podrían terminar el proceso en lugar de ser aceptadas por la espera.
sigwait devuelve cero si tiene éxito y un número de error si falla. Ese error se interpreta directamente; no se debe llamar a perror suponiendo que errno contiene la causa. Tras el éxito puedes usar printf y otras funciones normales, porque estás ejecutando el flujo normal del hilo, no un manejador. Su contrato está documentado en sigwait(3).
9. Proyecto: peticiones sin manejador
La versión siguiente mantiene la misma interfaz de práctica: USR1 pide trabajo y TERM pide terminar. La diferencia está en la recepción: no utiliza flags compartidos con un manejador ni funciones asíncronas. Establece disposiciones conocidas y mantiene bloqueadas ambas señales mientras las acepta con sigwait.
#define _POSIX_C_SOURCE 200809L
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
int main(void)
{
sigset_t esperadas;
if (sigemptyset(&esperadas) == -1 ||
sigaddset(&esperadas, SIGUSR1) == -1 ||
sigaddset(&esperadas, SIGTERM) == -1 ||
sigprocmask(SIG_BLOCK, &esperadas, NULL) == -1) {
perror("bloquear senales esperadas");
return EXIT_FAILURE;
}
/* Evitar que una disposicion ignorada heredada afecte la practica. */
struct sigaction predeterminada = {0};
predeterminada.sa_handler = SIG_DFL;
if (sigemptyset(&predeterminada.sa_mask) == -1 ||
sigaction(SIGUSR1, &predeterminada, NULL) == -1 ||
sigaction(SIGTERM, &predeterminada, NULL) == -1) {
perror("preparar disposiciones");
return EXIT_FAILURE;
}
printf("PID listo: %ld\n", (long)getpid());
puts("SIGUSR1 solicita trabajo; SIGTERM solicita parada.");
if (fflush(stdout) == EOF) {
perror("fflush");
return EXIT_FAILURE;
}
for (;;) {
int senal;
int error = sigwait(&esperadas, &senal);
if (error != 0) {
fprintf(stderr, "sigwait: %s\n", strerror(error));
return EXIT_FAILURE;
}
if (senal == SIGTERM) {
puts("SIGTERM aceptada por sigwait; salida normal");
return EXIT_SUCCESS;
}
if (senal == SIGUSR1) {
puts("SIGUSR1 aceptada por sigwait; trabajo desde main");
if (fflush(stdout) == EOF) {
perror("fflush");
return EXIT_FAILURE;
}
}
}
}$ gcc -std=c17 -Wall -Wextra -Wpedantic -g -O0 -pthread recepcion_sigwait.c -o recepcion_sigwait
$ ./recepcion_sigwait &
$ pid=$!
... espera las líneas de preparación ...
$ kill -USR1 "$pid"
SIGUSR1 aceptada por sigwait; trabajo desde main
$ kill -TERM "$pid"
$ wait "$pid"
SIGTERM aceptada por sigwait; salida normalLa opción -pthread mantiene la configuración habitual para interfaces de espera asociadas a programas POSIX con hilos, aunque este programa no crea hilos y las bibliotecas de Linux actuales puedan resolver sigwait desde libc.
La acción predeterminada de TERM sigue siendo terminar, pero no se aplica como entrega asíncrona aquí: la señal está bloqueada y sigwait la acepta. El programa decide salir normalmente. Mantiene las señales bloqueadas hasta terminar; no es una biblioteca que deba restaurar el estado del llamador.
Si una petición llega antes de que main entre en sigwait, queda pendiente y la llamada puede aceptarla inmediatamente. Si llega mientras espera, permite completar la espera. En ninguno de esos casos hay una comprobación de flag seguida de una ventana sin protección.
10. Comparar los mecanismos de espera
| Mecanismo | Cómo espera | Dónde se procesa la petición | Precaución principal |
|---|---|---|---|
| pause | Duerme hasta una señal con el efecto adecuado. | Un manejador y el código que recupere el control. | No coordina por sí sola una comprobación previa de estado. |
| sigsuspend | Cambia temporalmente la máscara y espera. | Manejador mínimo y trabajo posterior en el flujo normal. | Preparar la máscara completa y volver a comprobar la condición. |
| sigwait | Acepta una señal de un conjunto bloqueado. | Flujo normal, después del retorno exitoso. | Bloquear el conjunto y no confundir su código de error con errno. |
| Self-pipe con poll | Espera un descriptor de avisos junto con otros posibles canales. | Manejador de notificación y bucle normal. | Vida útil, no bloqueo del escritor y coordinación de los flags. |
Elige un modelo de recepción para cada conjunto de señales. No mezcles sin diseño una espera con sigwait y un manejador que compita por esas mismas señales. Tampoco intentes usar sigwait como un lector general de sockets: acepta señales, no bytes de un descriptor.
Para un programa cuyo único evento es una señal, sigwait puede simplificar el flujo. Si necesitas conservar manejadores y una condición compartida simple, sigsuspend encaja con un protocolo de máscara. Si además atiendes muchos canales, considera una integración de eventos como la estudiada en el tema 8.
11. Máscaras, hilos y herencia
La máscara pertenece al hilo. En programas con varios hilos utiliza pthread_sigmask para cambiarla de forma definida por POSIX. Esta función también devuelve cero o un número de error, en lugar de seguir la convención de −1 y errno de sigprocmask.
Un patrón habitual bloquea las señales de control antes de crear los hilos, de modo que hereden ese bloqueo, y dedica un hilo a aceptarlas con sigwait. Si otro hilo las deja desbloqueadas, una señal dirigida al proceso puede entregarse allí de forma asíncrona en vez de quedar para el receptor elegido.
El hilo que espera puede usar funciones normales después de sigwait, pero sus datos compartidos con otros hilos siguen necesitando sincronización normal. Dejar el contexto asíncrono no elimina las carreras entre hilos. Además, una señal dirigida específicamente a otro hilo no se convierte automáticamente en una señal disponible para el hilo receptor.
El contrato de esta operación se documenta en pthread_sigmask(3). Los programas completos de esta lección siguen siendo de un hilo; esta sección explica qué habría que cambiar al ampliar el diseño.
fork hereda la máscara del hilo que lo llama y exec la conserva. Por tanto, un proceso puede iniciar otro programa con señales todavía bloqueadas. En los ejemplos hemos declarado qué señales controla cada programa en lugar de depender de una máscara supuestamente vacía.
12. Orden, tiempos límite y errores
La atomicidad de una espera evita una carrera específica; no garantiza que algún emisor vaya a generar la señal. Un proceso puede esperar correctamente para siempre si nunca llega una petición. Las prácticas esperan hasta recibir TERM; en un servicio real puedes necesitar una política de tiempo límite y cancelación.
sigwait no recibe un argumento de tiempo. Existen interfaces como sigtimedwait que añaden información y espera limitada, pero tienen otro contrato de retorno y errores. No copies el tratamiento de sigwait sin consultar esa interfaz.
Las señales estándar siguen pudiendo agruparse mientras están pendientes. Enviar diez USR1 no obliga a que sigwait retorne diez veces ni a que el manejador registre diez tareas. Si necesitas unidades contables, conserva el trabajo en una cola o utiliza un mecanismo con garantías acordes al problema.
No dependas del orden entre USR1 y TERM para vaciar una supuesta cola de trabajo. Define dónde se almacena ese trabajo y cómo la parada lo completa o lo cancela. La ordenación de señales pendientes y otras propiedades generales se describen en signal(7).
Por último, no utilices este patrón para intentar continuar normalmente después de bloquear señales de fallo síncrono como una violación de memoria. Las señales de control elegidas por un protocolo y los fallos producidos por la ejecución tienen responsabilidades distintas.
13. Explorar la carrera paso a paso
El modelo usa una única señal, SIGUSR1. Con el patrón inseguro, pulsa «Consultar flag», envía la señal y después pulsa «Esperar»: el programa puede dormirse aunque el flag ya valga uno. Compara esa secuencia con sigsuspend y con sigwait.
ContextoFlujo normal
SIGUSR1 bloqueadaNo
Señal pendienteNo
Flag del manejador0
Decisión de la aplicaciónTodavía no se consultó
Consulta el flag, envía la señal y empieza a esperar para observar la ventana del patrón inseguro.
Prueba también enviar antes de la consulta y enviar mientras ya se espera. En el modelo con sigsuspend, al volver del manejador la señal vuelve a quedar bloqueada; pulsa «Consultar flag» para verificar la condición. En el modelo con sigwait no hay manejador y el flag permanece en cero: la petición llega como resultado de la llamada.
Repetir una señal bloqueada mantiene un único estado pendiente en este modelo de señal estándar. La herramienta no envía señales reales ni simula hilos, todas las causas de retorno o tiempos límite. Cambiar de modelo reinicia el recorrido.
14. Probar y diagnosticar
Para probar un programa que espera señales, observa primero que terminó la preparación. Los ejemplos imprimen el PID y vacían stdout antes de esperar. Usa ese PID o el guardado con $! desde la misma shell que inició tu instancia.
$ strace -o espera.log ./espera_sigsuspend
... desde otra terminal, envía USR1 y TERM al PID que imprime el programa ...
$ less espera.logEn Linux puedes encontrar rt_sigprocmask, rt_sigsuspend y el retorno del manejador. Con sigwait, la biblioteca puede utilizar una llamada como rt_sigtimedwait; no tiene por qué aparecer una llamada del núcleo con el nombre exacto de la función C.
| Síntoma | Hipótesis que conviene comprobar |
|---|---|
| El manejador no aparece, pero la señal está pendiente. | La máscara todavía la bloquea. |
| sigsuspend nunca permite la señal esperada. | Se pasó como máscara temporal el conjunto que debía desbloquearse. |
| Se necesita una segunda señal para avanzar. | La primera llegó entre la consulta del flag y una espera separada. |
| sigwait no acepta una señal del proceso. | Otro hilo puede tenerla desbloqueada o el conjunto no contiene la señal elegida. |
| El mensaje de error no corresponde al fallo. | Se usó perror para una función que devolvía directamente el código de error. |
| Se atienden menos peticiones que envíos. | Se está suponiendo una cola exacta donde hay señales estándar y flags agrupables. |
Una prueba de ráfagas no debe exigir un retorno por envío de señal estándar. Para comprobar peticiones separadas, envía una y espera su confirmación antes de emitir la siguiente. Para estudiar la llegada antes de esperar, bloquea primero y verifica que queda pendiente, como hace el primer laboratorio.
Estos programas mantienen sus señales de control bloqueadas mientras imprimen o procesan su acción normal. Si el destino de stdout se atasca, puede retrasar la siguiente aceptación. La corrección de la espera no sustituye una política completa de recursos y latencia.
15. Resumen
- Consultar un flag y llamar después a pause deja una ventana donde puede perderse el momento de despertar.
- Un conjunto de señales es una descripción; solo cambia la máscara cuando una operación lo utiliza para ese fin.
- SIG_BLOCK añade, SIG_UNBLOCK retira y SIG_SETMASK sustituye la máscara.
- Bloquear, tener pendiente e ignorar son conceptos diferentes.
- sigpending consulta presencia sin consumir la señal.
- sigsuspend cambia temporalmente la máscara y espera; al volver de un manejador restaura el bloqueo anterior.
- sigwait acepta una señal bloqueada y devuelve su número sin ejecutar un manejador para esa aceptación.
- sigwait y pthread_sigmask devuelven códigos de error directamente.
- En programas con hilos hay que coordinar las máscaras de todos los posibles receptores.
16. Preguntas de repaso y práctica
Responde antes de desplegar la explicación.
1. ¿Qué ventana existe entre consultar un flag y pause?
Una señal puede ejecutar su manejador después de la consulta y antes de la espera. El programa entra entonces en pause con la petición ya registrada y puede necesitar otra señal para despertar.
2. ¿Añadir SIGTERM a un sigset_t la bloquea?
No. Solo modifica un conjunto local. Hace falta utilizarlo con una operación que cambie la máscara, como sigprocmask con SIG_BLOCK.
3. ¿SIG_BLOCK reemplaza toda la máscara?
No. Añade los miembros indicados. SIG_SETMASK realiza la sustitución completa.
4. ¿Una señal bloqueada está necesariamente pendiente?
No. El bloqueo impide su entrega; debe generarse una instancia para que pueda quedar pendiente. Una señal ignorada tiene además otra disposición.
5. ¿sigpending consume la señal?
No. Consulta una instantánea. La señal se atiende mediante la entrega correspondiente o se acepta con una operación de espera apropiada.
6. ¿Qué contiene el argumento de sigsuspend?
La máscara temporal completa de señales que quedarán bloqueadas durante la espera. No es la lista de las señales que quieres recibir.
7. ¿Por qué hay que volver a consultar la condición tras sigsuspend?
Porque un manejador puede retornar sin satisfacer la petición lógica que espera el programa. EINTR no identifica por sí solo el trabajo pendiente.
8. ¿Debe desbloquearse el conjunto antes de sigwait?
No. Se mantiene bloqueado para que la señal quede disponible para su aceptación síncrona, en vez de entregarse con una acción asíncrona.
9. ¿Por qué se puede imprimir después de sigwait?
Porque el retorno se procesa en el flujo normal del hilo. No es una ejecución dentro de un manejador asíncrono, aunque los datos compartidos con otros hilos sigan necesitando coordinación.
10. ¿Cómo se trata un error de sigwait?
Consultando su retorno distinto de cero, que es un código de error. Puede describirse con strerror(error), sin suponer que errno contiene esa causa.
11. ¿Por qué bloquear antes de crear los hilos?
Para que hereden la máscara prevista y una señal dirigida al proceso no se entregue accidentalmente a otro hilo que la dejó desbloqueada.
12. ¿Una espera sin carreras garantiza que no se espere para siempre?
No. Evita una ventana de coordinación, pero el emisor puede no generar nunca la señal. Un límite de tiempo es otra propiedad que debe diseñarse.
Para practicar
- Ejecuta observar_pendiente y explica los cuatro valores de la salida: flag y pertenencia al conjunto antes y después del desbloqueo.
- En una copia del primer programa, añade una tercera llamada a raise mientras SIGUSR1 está bloqueada. Explica por qué el conjunto pendiente no representa un contador.
- Ejecuta espera_sigsuspend y envía peticiones separadas por su confirmación. Después solicita la parada y comprueba el estado final de la shell.
- Repite con recepcion_sigwait. Identifica qué líneas desaparecieron al no necesitar un manejador ni un flag de comunicación asíncrona.
- Dibuja las máscaras antes, durante y después de sigsuspend. Explica qué señales controla el programa y cuáles conserva de la máscara anterior.
- Reproduce en el simulador la llegada entre consulta y espera en los tres modos. Distingue una señal pendiente, un flag modificado y una señal aceptada como resultado.
- Diseña un servicio con varios hilos y un receptor con sigwait: orden de bloqueo, creación de hilos, comunicación del receptor y parada de trabajadores.
- Propón una prueba para un emisor que desaparece sin enviar la señal. Separa la corrección de la espera de la política de tiempo límite y recuperación.
El tema 10 aplicará estas ideas a SIGCHLD, la recolección de hijos y las señales en tiempo real, incluyendo la entrega de valores con sigqueue.