1. De una terminación a una solicitud
En el tema anterior observaste las acciones predeterminadas: SIGINT y SIGTERM normalmente terminaban al destinatario. Ahora queremos que el programa registre la solicitud, deje de esperar trabajo y ejecute una secuencia de limpieza antes de salir.
La operación fundamental es cambiar la disposición de una señal. En lugar de SIG_DFL, instalamos una función que el sistema invocará cuando entregue esa señal. Esa función se llama manejador y no se ejecuta como una tarea independiente elegida por el programa: puede interrumpir su flujo normal.
Por eso el diseño tendrá dos partes: el manejador anota una petición mínima y el flujo normal realiza las acciones complejas. Preparar un archivo, imprimir mensajes o retirar un nombre no se hará desde el manejador.
Instalar un manejador cambia qué ocurre al entregar una señal. No cambia quién puede enviarla ni convierte automáticamente su recepción en una parada segura: hacen falta un protocolo de espera y una política de limpieza.
Los ejemplos son de un solo hilo y se ejecutan en Linux. En una aplicación con varios hilos tendrías que decidir además qué hilo recibe las señales y cómo se coordinan sus máscaras.
2. La interfaz de sigaction
int sigaction(int senal,
const struct sigaction *nueva,
struct sigaction *anterior);El primer argumento identifica la señal. Si nueva no es NULL, indica la acción a instalar. Si anterior no es NULL, recibe la configuración previa. Puedes consultar sin modificar pasando NULL como nueva, o instalar y obtener la anterior en la misma llamada.
El resultado es 0 si la operación tiene éxito y −1 si falla. Comprueba ese resultado antes de anunciar que el proceso está preparado. SIGKILL y SIGSTOP no permiten instalar un manejador ni cambiar su disposición.
Usaremos sigaction para declarar de forma explícita la función, su máscara y sus flags. Evita combinar instalaciones mediante signal y sigaction sobre una misma señal sin una razón clara: dificulta saber qué configuración está vigente. La interfaz y sus campos están documentados en sigaction(2).
3. Preparar struct sigaction
La estructura puede incluir campos específicos de la implementación. No hace falta copiar una definición del manual en tu código: incluye signal.h y utiliza el tipo que proporciona el entorno.
| Campo | Responsabilidad | Configuración inicial del curso |
|---|---|---|
| sa_handler | Función de un argumento, o las disposiciones SIG_DFL y SIG_IGN. | Una función void manejador(int). |
| sa_mask | Señales adicionales bloqueadas durante la ejecución del manejador. | Un conjunto inicializado con sigemptyset y, si hace falta, sigaddset. |
| sa_flags | Opciones que cambian aspectos de entrega y retorno. | 0, salvo que el ejemplo necesite una opción concreta. |
| sa_sigaction | Variante de tres argumentos con información adicional. | Se utilizaría con SA_SIGINFO, en lugar de sa_handler. |
struct sigaction accion = {0};
accion.sa_handler = solicitar_parada;
if (sigemptyset(&accion.sa_mask) == -1) {
/* Tratar el error. */
}
accion.sa_flags = 0;
if (sigaction(SIGTERM, &accion, NULL) == -1) {
/* Tratar el error. */
}La inicialización con {0} evita dejar campos indeterminados, pero el conjunto sa_mask se prepara con las operaciones de conjuntos. No supongas que sigset_t es un entero que puedes manipular con sumas o bits elegidos a mano. Tampoco asignes simultáneamente sa_handler y sa_sigaction: pueden compartir almacenamiento en la implementación.
4. Un manejador mínimo
static volatile sig_atomic_t detener = 0;
static void solicitar_parada(int senal)
{
(void)senal;
detener = 1;
}La variable tiene duración estática y se consulta desde el flujo normal. sig_atomic_t permite el acceso simple necesario para esta comunicación con el manejador; volatile indica que su valor puede cambiar de una forma que el compilador no ve como una asignación normal en el bucle.
Eso no convierte a volatile en una herramienta general de sincronización entre hilos o procesos. Tampoco convierte operaciones compuestas, como mantener una cola o un contador mediante incremento, en una solución completa. En este caso solo necesitamos una petición de parada, no contar cada ocurrencia.
El manejador no usa printf, malloc, fclose ni exit. Esas funciones pueden interrumpirse mientras tienen estructuras internas en un estado transitorio, y volver a llamarlas desde el manejador puede ser incorrecto. El tema 8 estudiará con detalle las funciones async-signal-safe y la conservación de errno; aquí usaremos únicamente asignaciones a flags.
La distinción entre una función normal y una función segura en ese contexto se explica en signal-safety(7). Que una función se pueda llamar desde varios hilos no implica que se pueda llamar desde un manejador.
5. Dos máscaras con responsabilidades distintas
La máscara del hilo indica qué señales están bloqueadas ahora. En nuestros programas de un hilo se consulta o cambia con sigprocmask. El campo sa_mask describe señales que se añadirán temporalmente al conjunto bloqueado cuando se ejecute ese manejador.
Con el comportamiento habitual, también se bloquea durante su manejador la propia señal que se está atendiendo, aunque sa_mask esté vacío. Por tanto, vacío no significa «se permite cualquier reentrada». Otras señales pueden interrumpir el manejador si no están bloqueadas.
Si el mismo estado se modifica desde manejadores de SIGINT y SIGTERM, puedes añadir ambas señales a sa_mask para impedir que esas dos rutinas se aniden entre sí. Los demás bloqueos que ya tenía el hilo siguen aplicándose. Al retornar del manejador se restaura la máscara correspondiente al contexto interrumpido.
Instalar una acción no desbloquea una señal que venía bloqueada. Este detalle explica muchos casos en que sigaction tuvo éxito pero «no pasa nada». Las operaciones sobre la máscara del hilo se documentan en sigprocmask(2).
6. Flags y reinicio de operaciones
Los flags se eligen por una propiedad necesaria, no como una lista que se añade a todos los programas. Estas opciones aparecen con frecuencia:
| Flag | Efecto relevante | Qué no debes asumir |
|---|---|---|
| SA_RESTART | Permite reiniciar determinadas operaciones interrumpidas al volver del manejador. | No reinicia todas las interfaces ni hace que un bucle consulte automáticamente su flag de parada. |
| SA_SIGINFO | Selecciona sa_sigaction y su información adicional. | No se usa con la firma de un argumento de sa_handler. |
| SA_NODEFER | Evita el bloqueo automático de la propia señal, salvo que esté en sa_mask. | No hace que un manejador sea reentrante o seguro. |
| SA_RESETHAND | Restablece la disposición al entrar en el manejador. | No mantiene un manejador permanente para todas las ocurrencias. |
| SA_NOCLDSTOP | Para SIGCHLD, evita notificaciones asociadas a ciertas paradas y continuaciones de hijos. | No sustituye la recolección de terminaciones con waitpid. |
Piensa en un read bloqueado. Sin reinicio automático puede retornar EINTR y dar ocasión de consultar detener. Con SA_RESTART, ciertas lecturas pueden continuar bloqueadas después del manejador; el flag ya cambió, pero el flujo normal todavía no ha vuelto al punto donde lo consulta.
Eso no convierte a SA_RESTART en bueno o malo: depende del protocolo de espera. Nuestra parada controlada usará sigsuspend y sa_flags = 0. Un sistema que espere datos en varios descriptores necesita otra integración, como una notificación al bucle de eventos, que se estudiará después.
7. Primer programa: instalar, provocar y restaurar
Este programa instala un manejador para SIGUSR1, provoca esa señal con raise y comprueba el flag al volver. También consulta la acción instalada y restaura la que existía antes. No necesita otro proceso para estudiar la configuración.
El ejemplo exige SIGUSR1 sin bloquear y lo comprueba. Así no confunde una instalación correcta con una señal que quedó pendiente por la máscara heredada. El programa de la sección 9 sí administrará explícitamente el bloqueo y la espera.
#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;
}
int main(void)
{
sigset_t mascara;
if (sigprocmask(SIG_BLOCK, NULL, &mascara) == -1) {
perror("consultar mascara");
return EXIT_FAILURE;
}
int bloqueada = sigismember(&mascara, SIGUSR1);
if (bloqueada == -1) {
perror("sigismember");
return EXIT_FAILURE;
}
if (bloqueada) {
fprintf(stderr, "Esta prueba requiere SIGUSR1 sin bloquear\n");
return EXIT_FAILURE;
}
struct sigaction accion = {0}, anterior, observada;
accion.sa_handler = anotar;
if (sigemptyset(&accion.sa_mask) == -1) {
perror("sigemptyset");
return EXIT_FAILURE;
}
accion.sa_flags = 0;
if (sigaction(SIGUSR1, &accion, &anterior) == -1) {
perror("instalar accion");
return EXIT_FAILURE;
}
int resultado = EXIT_FAILURE;
if (sigaction(SIGUSR1, NULL, &observada) == -1) {
perror("consultar accion");
goto restaurar;
}
if (observada.sa_handler != anotar) {
fprintf(stderr, "La accion no coincide con la instalada\n");
goto restaurar;
}
puts("Manejador instalado y consultado");
printf("Antes de raise: recibida = %d\n", (int)recibida);
if (raise(SIGUSR1) != 0) {
perror("raise");
goto restaurar;
}
printf("Despues de raise: recibida = %d\n", (int)recibida);
if (recibida == 1)
resultado = EXIT_SUCCESS;
restaurar:
if (sigaction(SIGUSR1, &anterior, NULL) == -1) {
perror("restaurar accion");
return EXIT_FAILURE;
}
puts("Accion anterior restaurada");
return resultado;
}$ gcc -std=c17 -Wall -Wextra -Wpedantic -g -O0 accion_basica.c -o accion_basica
$ ./accion_basica
Manejador instalado y consultado
Antes de raise: recibida = 0
Despues de raise: recibida = 1
Accion anterior restauradaLas impresiones pertenecen a main. En esta prueba de un hilo y señal no bloqueada, el manejador provocado por raise se ejecuta antes de que raise retorne. No extrapoles ese orden a una llamada kill desde otro proceso: allí enviar y observar la reacción son pasos distintos.
8. La carrera entre consultar y dormir
El siguiente patrón parece razonable, pero no garantiza una espera correcta:
while (!detener)
pause();El programa puede comprobar que detener vale cero y recibir la señal inmediatamente después. El manejador cambia el flag y retorna; entonces el programa llama a pause y duerme a pesar de que la petición ya estaba registrada. Si no llega otra señal, puede quedarse esperando indefinidamente.
La solución requiere que la comprobación y el cambio a la espera estén coordinados. Bloquearemos SIGINT y SIGTERM mientras el flujo normal consulta el estado. sigsuspend instalará temporalmente una máscara que las permita y dormirá como parte de esa operación. Al retornar del manejador, se recuperará la máscara anterior, con esas señales bloqueadas.
- Bloquear las señales de control. Así no interrumpen la preparación ni la consulta del flag.
- Instalar las acciones y preparar recursos. Una petición que llegue queda pendiente.
- Consultar el flag con el bloqueo vigente. Si aún no hay petición, usar sigsuspend para esperar permitiendo esas señales.
- Volver y comprobar. El manejador ya pudo registrar la petición y la máscara bloqueada se restableció.
Este es un adelanto del tema 9, necesario para que el ejemplo de terminación no enseñe una carrera. La sustitución temporal y la restauración de la máscara se documentan en sigsuspend(2). Su retorno −1 con EINTR es el resultado esperado al volver de un manejador, no un fallo del protocolo.
9. Proyecto: una parada controlada
El programa crea un archivo temporal propio para representar un recurso con nombre que deberá retirar. Tras recibir SIGINT o SIGTERM, el manejador registra la primera solicitud. main deja la espera, cierra el descriptor y retira el archivo. Se imprime el PID cuando la preparación ya está completa.
No procesa una cola de trabajo: se concentra en la transición de espera a limpieza. Es un programa completo que va a salir, no una biblioteca que deba dejar restaurada la configuración de su llamador. Mantiene las dos señales de control bloqueadas durante su limpieza para que no la vuelvan a iniciar.
#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 solicitud = 0;
static void solicitar_parada(int senal)
{
if (solicitud == 0)
solicitud = senal;
}
int main(void)
{
sigset_t control, previa;
if (sigemptyset(&control) == -1 ||
sigaddset(&control, SIGINT) == -1 ||
sigaddset(&control, SIGTERM) == -1) {
perror("preparar conjunto de control");
return EXIT_FAILURE;
}
if (sigprocmask(SIG_BLOCK, &control, &previa) == -1) {
perror("bloquear control");
return EXIT_FAILURE;
}
struct sigaction accion = {0};
accion.sa_handler = solicitar_parada;
accion.sa_mask = control;
accion.sa_flags = 0;
if (sigaction(SIGINT, &accion, NULL) == -1 ||
sigaction(SIGTERM, &accion, NULL) == -1) {
perror("instalar manejadores");
return EXIT_FAILURE;
}
char ruta[] = "/tmp/ipc-parada-XXXXXX";
int fd = -1;
int creado = 0;
int resultado = EXIT_FAILURE;
fd = mkstemp(ruta);
if (fd == -1) {
perror("mkstemp");
goto limpieza;
}
creado = 1;
sigset_t espera = previa;
if (sigdelset(&espera, SIGINT) == -1 ||
sigdelset(&espera, SIGTERM) == -1) {
perror("preparar mascara de espera");
goto limpieza;
}
printf("PID listo: %ld\n", (long)getpid());
printf("Recurso temporal: %s\n", ruta);
if (fflush(stdout) == EOF) {
perror("fflush");
goto limpieza;
}
while (solicitud == 0) {
if (sigsuspend(&espera) == -1 && errno != EINTR) {
perror("sigsuspend");
goto limpieza;
}
}
printf("Solicitud recibida: %s\n", solicitud == SIGINT ? "SIGINT" : "SIGTERM");
puts("Limpieza desde main");
resultado = EXIT_SUCCESS;
limpieza:
if (fd != -1) {
int numero = fd;
fd = -1;
if (close(numero) == -1) {
perror("close");
resultado = EXIT_FAILURE;
}
}
if (creado) {
if (unlink(ruta) == -1) {
perror("unlink");
resultado = EXIT_FAILURE;
} else {
puts("Recurso temporal retirado");
}
}
if (resultado == EXIT_SUCCESS)
puts("Salida controlada");
return resultado;
}sa_mask incluye ambas señales de control. Mientras se ejecuta solicitar_parada, SIGINT y SIGTERM no se anidan entre sí; así la comprobación y asignación que conserva la primera solicitud no recibe otra intervención de esas dos rutinas. No hemos intentado contar todas las señales recibidas.
La máscara de espera conserva el resto de la máscara heredada y retira de ella SIGINT y SIGTERM, porque este programa decide atenderlas. Al volver de sigsuspend se restaura el bloqueo que protege la consulta y la limpieza. Esto no cambia las disposiciones de otras señales.
10. Probar SIGINT y SIGTERM
$ gcc -std=c17 -Wall -Wextra -Wpedantic -g -O0 parada_controlada.c -o parada_controlada
$ ./parada_controlada &
$ pid=$!
PID listo: 3400
Recurso temporal: /tmp/ipc-parada-aB12cDEl PID y la ruta son ilustrativos. Espera a ver las líneas de preparación antes de enviar la señal en esta práctica manual. Guarda la ruta mostrada si quieres comprobar que existe mientras el proceso espera y que desaparece al terminar.
$ kill -TERM "$pid"
$ wait "$pid"
Solicitud recibida: SIGTERM
Limpieza desde main
Recurso temporal retirado
Salida controlada
$ echo $?
0Ahora el proceso termina normalmente desde main con cero. No es la terminación predeterminada por SIGTERM que observaste en el tema anterior. El manejador transformó el evento en una petición que el programa decidió cumplir.
Inicia una instancia nueva para probar INT. También puedes ejecutarlo en primer plano y pulsar Ctrl+C con la configuración habitual de la terminal. El programa instala su acción para SIGINT aunque una shell haya preparado esa señal de otra forma al iniciar un trabajo en segundo plano.
Al observar stdout y stderr por rutas distintas puede variar el orden visible de los mensajes. La evidencia principal es que termina con el estado esperado, que se informa la solicitud y que la ruta temporal propia ya no existe.
11. Limpieza, repetición y errores
La limpieza se ejecuta en main, después de que el manejador retornó. En ese contexto se pueden utilizar las funciones normales del programa respetando sus contratos. La asignación del flag no tiene que cerrar por sí sola todos los recursos.
Si llega otra petición de SIGINT o SIGTERM durante la limpieza de este ejemplo, queda bloqueada; no reinicia el procedimiento ni interrumpe otro close o unlink. El proceso termina después. En un servicio más complejo podrías elegir otra política, como una segunda petición que fuerce cancelar trabajo, pero tendrías que implementarla explícitamente.
El archivo se crea con un nombre único y se retira solo si esta instancia lo creó. El descriptor se cierra una vez y se invalida en la variable. En Linux no copiamos el bucle de reintento de read para repetir close ciegamente.
SIGKILL, una caída del programa o una terminación por otra señal pueden impedir llegar a main. El sistema cerrará el descriptor, pero el nombre temporal puede permanecer. El diseño de recuperación debe contemplar esa posibilidad.
La práctica se ejecuta con salidas estándar disponibles y no establece una política adicional para SIGPIPE o fallos de comunicación de un servicio. Tampoco simula tareas a medio terminar, durabilidad o una cola distribuida. Muestra una transición concreta y verificable: esperar una petición, cerrar una referencia y retirar un nombre propio.
12. Consultar, restaurar y heredar acciones
El primer programa conservó una estructura anterior y la reinstaló. Eso resulta útil cuando una pieza de código cambia temporalmente una disposición y debe devolverla a su estado previo. No basta con restablecer SIG_DFL si el llamador había instalado una acción distinta.
En un programa con varios módulos, la disposición de una señal es un recurso del proceso: dos componentes que la cambian sin coordinarse pueden sobrescribir sus decisiones. Guardar una copia no evita por sí solo esa competencia. En una aplicación con hilos sigue siendo una configuración compartida por el proceso.
fork hereda las disposiciones. Tras un exec exitoso se restablecen las que tenían manejadores, mientras las ignoradas se conservan; la máscara también se conserva. Un manejador instalado para la imagen anterior no se convierte en una función del nuevo programa. La relación entre señales y reemplazo se describe en signal(7).
Restaurar una máscara puede permitir la entrega de señales pendientes. Por tanto, restaurar acciones y máscaras es parte del protocolo de salida de un módulo, no una sucesión de llamadas que se puedan ordenar sin pensar qué eventos quedaron pendientes.
13. Explorar máscaras y trabajo diferido
El modelo separa la entrada en un manejador, su retorno y la limpieza normal. Las señales representadas son SIGINT y SIGTERM, ambas con terminación por defecto. Elige una disposición y comprueba cuándo se puede ejecutar la limpieza.
Contexto actualFlujo normal
Bloqueadas durante el manejadorNinguna en este instante
PendientesNinguna
Flag de solicitud0
Recurso de la aplicaciónAbierto; nombre presente
Envía INT. Mientras su manejador esté activo, compara enviar TERM con la máscara adicional activada o desactivada.
Con la máscara adicional activa, envía INT y después TERM antes de retornar. TERM queda pendiente. Al retornar de INT se puede atender TERM y, tras volver al flujo normal, se habilita la limpieza. Sin la máscara adicional, TERM puede anidarse en el manejador de INT; INT sigue bloqueada automáticamente mientras está activa.
El modelo usa una máscara normal vacía y un orden elegido para las señales pendientes; no reproduce todas las reglas de entrega del sistema. Los manejadores se mantienen visibles por pasos para estudiarlos, aunque el manejador real del ejemplo solo hace una comprobación y una asignación. La limpieza representa el trabajo diferido, no un manejador que deba esperar un botón.
Cambiar de disposición o de máscara reinicia la instancia. SIG_DFL muestra una terminación sin retirar el nombre; SIG_IGN no cambia el flag ni habilita una parada controlada. La herramienta no ejecuta señales ni operaciones reales sobre archivos.
14. Diagnosticar un manejador que no funciona
| Síntoma | Qué comprobar |
|---|---|
| La instalación parece no tener efecto. | Resultado de sigaction, señal elegida, PID y máscara vigente. |
| El proceso sigue bloqueado después de cambiar el flag. | Si una operación se reinició y si existe una notificación adecuada para despertar el bucle. |
| La primera señal no basta y la segunda lo despierta. | Una posible carrera entre consultar el flag y llamar a pause. |
| La impresión desde el manejador se atasca o corrompe salida. | Uso de funciones de stdio u otras operaciones no seguras en ese contexto. |
| Otra señal interrumpe el manejador. | sa_mask, bloqueo automático de la propia señal y opciones como SA_NODEFER. |
| El nuevo programa no usa el manejador del lanzador. | El efecto de exec sobre disposiciones y máscaras. |
| Un archivo queda tras una terminación forzada. | Que no se llegó al flujo normal de limpieza y hace falta una política de recuperación. |
$ strace -o parada.log ./parada_controlada
... envía una señal al PID que imprime el programa desde otra terminal ...
$ less parada.logUsa el PID impreso por el programa, no el de strace. Puedes encontrar rt_sigaction, rt_sigprocmask, rt_sigsuspend y rt_sigreturn según el entorno, seguidos de las operaciones de archivo. Los nombres de las llamadas del núcleo no tienen que coincidir con los de las funciones de biblioteca.
En una traza, EINTR o una indicación de reinicio alrededor de señales no prueban por sí solos que exista un error. Relaciónalos con la máscara, el retorno del manejador y el estado que consulta main.
15. Resumen
- sigaction instala o consulta una disposición mediante una configuración explícita.
- sa_handler elige la función o disposición; sa_mask añade bloqueos temporales y sa_flags modifica aspectos concretos.
- La propia señal se bloquea normalmente durante su manejador, aunque sa_mask esté vacío.
- Instalar una acción no elimina un bloqueo que ya tenía el hilo.
- Un flag volatile sig_atomic_t permite registrar una petición simple; la limpieza queda en el flujo normal.
- SA_RESTART no reinicia todas las llamadas ni resuelve por sí solo una parada.
- Consultar el flag y llamar después a pause puede perder el momento adecuado para despertar.
- Bloquear durante la consulta y esperar con sigsuspend permite construir el recorrido sin esa carrera.
- La terminación forzada y la recuperación de recursos requieren decisiones adicionales.
16. Preguntas de repaso y práctica
Responde antes de abrir cada explicación.
1. ¿Cómo se consulta una acción sin modificarla?
Pasando NULL como nueva acción y una dirección válida para recibir la anterior. Debe comprobarse el resultado de la llamada.
2. ¿Por qué inicializar sa_mask con sigemptyset?
Porque es un conjunto del tipo sigset_t y debe manipularse con su interfaz. No se debe depender de una representación interna elegida a mano.
3. ¿sa_mask vacío permite reentrar automáticamente con la misma señal?
No. Normalmente la señal atendida se añade al bloqueo temporal. SA_NODEFER modifica esa regla, salvo que la propia señal esté explícitamente en sa_mask.
4. ¿Instalar un manejador desbloquea la señal?
No. La disposición y la máscara son configuraciones diferentes. La señal puede seguir pendiente porque el hilo la mantiene bloqueada.
5. ¿Por qué no imprimir desde solicitar_parada?
Porque stdio no ofrece la seguridad necesaria para esa interrupción asíncrona. El manejador registra un flag y main imprime después de recuperar el control.
6. ¿volatile convierte una cola en segura para el manejador?
No. El ejemplo utiliza accesos simples a sig_atomic_t. Las estructuras complejas, operaciones compuestas y coordinación entre hilos exigen otras garantías.
7. ¿SA_RESTART garantiza que main verá pronto la petición de parada?
No. Algunas operaciones pueden continuar bloqueadas después del manejador. La aplicación debe integrar la petición con su mecanismo de espera.
8. ¿Qué carrera tiene while (!detener) pause()?
La señal puede ejecutarse después de consultar el flag y antes de pause. El programa entra entonces en la espera con la petición ya registrada.
9. ¿Por qué sigsuspend retorna normalmente con EINTR?
Porque una señal invocó un manejador y este retornó. La llamada restaura la máscara previa y permite volver a comprobar el estado del programa.
10. ¿Qué protege añadir INT y TERM a sa_mask?
Impide que esos dos manejadores se aniden entre sí durante su ejecución. No bloquea todas las demás señales ni protege operaciones de otros hilos.
11. ¿Por qué la parada controlada termina con cero?
Porque main cumplió la solicitud y completó la limpieza prevista, y después retornó normalmente. No terminó mediante la acción predeterminada de TERM.
12. ¿Se puede garantizar retirar el archivo con un manejador de SIGKILL?
No. SIGKILL no admite manejador. Puede cerrar el descriptor al terminar el proceso, pero no ejecutar la retirada del nombre que era responsabilidad de la aplicación.
Para practicar
- Compila accion_basica y localiza qué líneas se ejecutan en el manejador y cuáles en main. Explica por qué las impresiones no forman parte de la interrupción.
- Consulta una acción anterior antes y después de la restauración y compara sus campos relevantes, sin comparar toda la estructura byte a byte.
- Ejecuta parada_controlada con TERM y después, en una instancia nueva, con INT. Registra estado de salida y existencia del archivo antes y después.
- Detén una instancia preparada con STOP, envíale varias TERM y continúa con CONT. Observa que la petición se atiende y la limpieza no se repite como si hubiera una cola de tareas.
- En una instancia nueva, prueba KILL. Identifica la ruta temporal que quedó y retira únicamente ese archivo propio después de comprobarlo. Explica por qué el descriptor cerrado no equivale al nombre retirado.
- Usa el simulador con sa_mask vacío y con INT y TERM añadidas. Dibuja el contexto al que vuelve cada manejador cuando retorna.
- Explica por escrito por qué añadir SA_RESTART no corrige la carrera de consultar y después llamar a pause.
- Diseña la parada de un servicio con trabajo en curso: qué registra el manejador, cómo despierta el flujo normal y qué confirma el servicio antes de salir.