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

Tema 6

Señales y acciones por defecto

Pulsar Ctrl+C, pedir que termine un servicio o suspender un proceso son formas de comunicar eventos. Linux utiliza señales para esos avisos y cada una tiene una acción predeterminada. En este tema observarás esas acciones, enviarás señales desde Bash y desde C, y construirás un programa que detiene, continúa y termina a su propio hijo sin depender de pausas arbitrarias.

1. Qué es una señal

Una señal es una notificación que el sistema puede dirigir a un proceso o a un hilo para comunicar un evento. Puede originarse en una acción de otro programa, en la terminal o en una condición detectada durante la ejecución. No equivale a escribir texto en la entrada estándar.

Al pulsar Ctrl+C normalmente no se envía la cadena «Ctrl+C» a una función read. La terminal solicita la generación de SIGINT para el grupo en primer plano. Al escribir en una tubería sin lectores, el sistema puede generar SIGPIPE. En ambos casos hay un evento con un significado definido.

Para cada señal existe una disposición: usar su acción por defecto, ignorarla o ejecutar un manejador cuando la interfaz lo permita. Este tema se centra en las acciones por defecto. El tema siguiente instalará manejadores mediante sigaction y después estudiaremos qué funciones pueden usarse dentro de ellos.

Una señal comunica un evento. La acción del destinatario depende de la señal, de su disposición y de su estado; enviar una señal no equivale a obtener una confirmación de trabajo completado.

Los nombres se declaran en <signal.h>. Usa SIGTERM o SIGSTOP en C y nombres como TERM o STOP en los comandos. Los números pueden variar entre sistemas y arquitecturas; no conviertas una tabla de una máquina en constantes de tu programa.

2. Generación, estado pendiente y entrega

Conviene separar tres momentos: una señal se genera, puede quedar pendiente y finalmente se entrega, momento en que se aplica la disposición correspondiente. Que la llamada de envío tenga éxito no implica que el destinatario ya haya ejecutado su reacción.

Una máscara permite bloquear temporalmente señales para retrasar su entrega, salvo excepciones. Bloquear no es ignorar: una señal bloqueada puede quedar pendiente. Ignorar es una disposición. En programas con hilos la máscara pertenece a cada hilo, mientras que la disposición de una señal es una propiedad del proceso.

También importa si el proceso está detenido. Una señal ordinaria de terminación puede quedar pendiente hasta que continúe; SIGKILL y SIGCONT tienen efectos especiales sobre ese estado. Por eso «envié TERM y todavía aparece en ps» no basta para concluir que el envío falló.

No utilizaremos todavía las máscaras como mecanismo de coordinación. Los experimentos prepararán un estado conocido y el bloque profundizará después en sigprocmask, sigsuspend y sigwait. El panorama de disposiciones, máscaras y señales pendientes se documenta en signal(7).

3. Acciones por defecto

El manual utiliza categorías como Term, Core, Stop, Cont e Ign. Estas describen lo que ocurre si la disposición conserva su valor predeterminado; una aplicación puede modificar algunas de ellas.

SeñalAcción por defecto en LinuxUso o causa habitual
SIGINTTerminar.Interrupción solicitada desde la terminal, normalmente Ctrl+C.
SIGTERMTerminar.Solicitud convencional de terminación de un programa.
SIGKILLTerminar; no se puede capturar, ignorar ni bloquear.Terminación forzada.
SIGSTOPDetener; no se puede capturar, ignorar ni bloquear.Suspensión incondicional de la ejecución.
SIGTSTPDetener.Suspensión interactiva, normalmente Ctrl+Z.
SIGCONTContinuar si estaba detenido.Reanudar un proceso.
SIGQUITTerminar con acción de volcado de memoria.Salida de diagnóstico, normalmente Ctrl+\.
SIGUSR1 y SIGUSR2Terminar.Eventos cuyo significado decide la aplicación.
SIGPIPETerminar.Escritura en un canal sin lectores, según la interfaz.
SIGCHLDIgnorar como acción por defecto.Notificación de cambios de estado de un hijo.
SIGWINCHIgnorar.Cambio de tamaño de la terminal.

«Core» no promete que aparezca un archivo llamado core en la carpeta actual. Los límites y la configuración del sistema pueden impedir el volcado o dirigirlo a otro servicio. Y que SIGCHLD tenga acción por defecto Ign no significa que puedas omitir waitpid: en Linux no equivale sin más a configurar explícitamente SIG_IGN para esa señal.

4. SIGINT, SIGTERM y SIGKILL

SIGINT y SIGTERM terminan por defecto, pero expresan intenciones distintas. SIGINT suele venir de una interrupción interactiva. SIGTERM es la solicitud convencional que un supervisor puede enviar para pedir terminar. Si el programa instala un manejador, puede convertir esa solicitud en una transición de parada ordenada.

Sin manejador, SIGTERM no ejecuta automáticamente tu limpieza de aplicación: no vacía por ti la cola de tareas ni escribe una última transacción. El núcleo libera los recursos que le corresponden al terminar el proceso, pero las responsabilidades del protocolo siguen siendo del programa.

SIGKILL no ofrece al destinatario la posibilidad de ejecutar un manejador. Por eso no se debe diseñar una aplicación suponiendo que siempre podrá retirar nombres, guardar estado o devolver una confirmación antes de salir. Tampoco significa «desaparecer de ps instantáneamente»: un proceso puede quedar como zombi pendiente de recolección o tardar en abandonar determinadas esperas del núcleo.

Solicitud frente a resultado

Enviar TERM es solicitar una acción. Para comprobar el resultado de un hijo, espera su estado. Si necesitas saber si una operación se completó o se guardó, define además una confirmación dentro del protocolo.

5. SIGSTOP, SIGTSTP y SIGCONT

Detener un proceso no equivale a terminarlo. Un proceso detenido conserva su memoria y recursos, pero no avanza en su código hasta que continúe o termine. Si tenía abierto un escritor de tubería, ese escritor sigue existiendo: el lector no obtiene EOF solo porque el productor esté detenido.

SIGSTOP permite observar este estado sin depender de un manejador. SIGTSTP es la señal de control interactivo usada normalmente por Ctrl+Z y puede tener una disposición modificada; además intervienen las reglas del control de trabajos. No son dos nombres totalmente intercambiables.

SIGCONT solicita que un proceso detenido continúe. Su efecto de reanudación es especial y puede ocurrir aunque su entrega esté bloqueada o su disposición sea ignorar. Reanudar no reinicia el programa desde main: permite continuar donde corresponda, sujeto a otras señales pendientes.

Un proceso detenido puede retener recursos que otros esperan. Suspenderlo para inspeccionarlo modifica el comportamiento temporal del conjunto; úsalo teniendo presente qué dependencias mantiene abiertas.

6. La terminal y los grupos de procesos

Una shell con control de trabajos organiza comandos en grupos. El controlador de la terminal envía las señales de sus teclas especiales al grupo de procesos en primer plano, no únicamente a un PID que hayas impreso. Por eso Ctrl+C puede afectar a varios componentes de un pipeline.

Normalmente Ctrl+C corresponde a SIGINT, Ctrl+Z a SIGTSTP y Ctrl+\ a SIGQUIT. Esa configuración se puede consultar con stty -a y puede cambiar. Ctrl+D, en cambio, no es una señal: en el modo habitual de terminal participa en la entrega de entrada o la indicación de fin de entrada.

Un trabajo en segundo plano no recibe necesariamente la misma señal al pulsar Ctrl+C en la shell. Además, algunas shells preparan SIGINT o SIGQUIT como ignoradas para comandos asíncronos. El programa de práctica siguiente restablece explícitamente las disposiciones que queremos estudiar para que la comparación sea clara.

No necesitas dominar aún la creación de sesiones y grupos para enviar una señal a un PID concreto. Sí debes distinguir «tecla que actúa sobre el primer plano» de «llamada dirigida al proceso elegido».

7. Un proceso de práctica en C

Guarda este programa como objetivo_senales.c. Restablece las disposiciones que usaremos y deja vacía la máscara de señales para partir de un estado conocido. No instala un manejador: SIG_DFL significa utilizar la acción por defecto.

La configuración con sigaction solo prepara el experimento; la instalación de funciones manejadoras comienza en el tema 7 y las máscaras se desarrollan después. SIGKILL y SIGSTOP no aparecen en la lista porque no admiten ese cambio de disposición.

objetivo_senales.c · esperar sin consumir CPU en un bucle activo
#define _POSIX_C_SOURCE 200809L
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main(void)
{
    const int senales[] = {
        SIGINT, SIGTERM, SIGQUIT, SIGHUP, SIGUSR1, SIGUSR2,
        SIGPIPE, SIGTSTP, SIGCONT
    };
    struct sigaction accion = {0};
    accion.sa_handler = SIG_DFL;
    if (sigemptyset(&accion.sa_mask) == -1) {
        perror("sigemptyset");
        return EXIT_FAILURE;
    }
    for (size_t i = 0; i < sizeof senales / sizeof senales[0]; i++) {
        if (sigaction(senales[i], &accion, NULL) == -1) {
            perror("sigaction");
            return EXIT_FAILURE;
        }
    }
    sigset_t vacia;
    if (sigemptyset(&vacia) == -1 ||
        sigprocmask(SIG_SETMASK, &vacia, NULL) == -1) {
        perror("preparar mascara");
        return EXIT_FAILURE;
    }

    printf("PID listo: %ld\n", (long)getpid());
    puts("Esperando senales con sus acciones por defecto.");
    if (fflush(stdout) == EOF) {
        perror("fflush");
        return EXIT_FAILURE;
    }
    for (;;)
        pause();
}

pause duerme hasta una señal que termine el proceso o invoque un manejador. No imprime un contador ni consulta continuamente una variable. Si un manejador retornara, pause devolvería −1 con EINTR; este programa no instala esos manejadores y vuelve a esperar si la llamada retorna.

No uses este patrón como receta general para «consultar una bandera y después dormir»: esa combinación puede tener una carrera que resolveremos con sigsuspend. Aquí el objetivo es observar la disposición de las señales sin procesar tareas. El contrato de la espera se describe en pause(2).

Bash · compilar y probar en primer plano
$ gcc -std=c17 -Wall -Wextra -Wpedantic -g -O0 objetivo_senales.c -o objetivo_senales
$ ./objetivo_senales
PID listo: 3100
Esperando senales con sus acciones por defecto.

Pulsa Ctrl+C después del mensaje: en una terminal con la configuración habitual terminará por SIGINT. El PID es ilustrativo. Si deseas repetir la prueba, inicia una instancia nueva: un proceso terminado no se puede reanudar con CONT.

8. Enviar y observar señales desde Bash

Para controlar un proceso sin que ocupe el primer plano, ejecútalo en segundo plano y guarda su PID con $!. Espera a ver PID listo antes de enviar la primera señal: el programa tiene que terminar su preparación.

Bash interactivo · detener, continuar y terminar tu instancia de práctica
$ ./objetivo_senales &
$ pid=$!
... espera a que el programa imprima PID listo ...
$ kill -STOP "$pid"
$ ps -o pid,ppid,stat,args -p "$pid"
... el estado incluye T: proceso detenido ...
$ kill -CONT "$pid"
$ ps -o pid,ppid,stat,args -p "$pid"
... normalmente vuelve a esperar, por ejemplo con estado S ...
$ kill -TERM "$pid"
$ wait "$pid"
$ estado=$?
$ printf 'Estado informado por Bash: %s\n' "$estado"

La shell puede imprimir sus propios avisos de trabajo detenido o terminado. El detalle del estado y los tiempos de observación varían. El wait de Bash espera a un hijo de esa shell; no puede recoger arbitrariamente un proceso iniciado por otra terminal.

Repite con una instancia nueva para comparar INT y KILL. También puedes usar kill -s TERM "$pid". kill -l permite consultar los nombres disponibles, y kill -l TERM muestra el número correspondiente en el entorno.

Que kill se llame así no significa que todas sus señales maten: STOP detiene, CONT continúa y el número 0 se utiliza para comprobaciones sin enviar una señal. Trabaja con la instancia que acabas de iniciar y vuelve a obtener su PID en cada prueba; no trates un número viejo como una identidad permanente.

9. Qué significa kill y qué comprueba

La función C kill(pid, senal) devuelve 0 si la solicitud tiene éxito y −1 si falla. Su destino depende del argumento pid: un valor positivo selecciona un proceso, cero selecciona el grupo del emisor y ciertos valores negativos seleccionan grupos o un conjunto más amplio. El programa de esta lección limitará deliberadamente su interfaz a PID positivos.

El permiso depende de las identidades y capacidades del emisor y del destino, con reglas específicas para casos como SIGCONT. Ser dueño de una terminal no da autoridad sobre cualquier proceso del equipo. Entre los errores relevantes están ESRCH para un destino no encontrado, EPERM por falta de permiso y EINVAL por una señal inválida.

Con señal 0 no se genera una señal, pero se hacen las comprobaciones correspondientes. Un éxito no demuestra que el proceso esté listo, que responda a un protocolo o que no sea zombi. Además, la comprobación y una operación posterior no son atómicas: el proceso puede terminar entre ambas. Los destinos, permisos y resultados se documentan en kill(2).

10. Programa en C para enviar una señal

Este emisor acepta un PID positivo y uno de los nombres indicados. Comprueba la conversión antes de llamar a kill para no convertir un error de entrada en una operación sobre un grupo. El límite utilizado corresponde al tipo de PID habitual de Linux.

enviar_senal.c · validar el destino y comprobar el envío
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <limits.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>

int main(int argc, char *argv[])
{
    if (argc != 3) {
        fprintf(stderr, "Uso: %s PID INT|TERM|KILL|STOP|CONT|0\n", argv[0]);
        return EXIT_FAILURE;
    }
    char *fin;
    errno = 0;
    long numero = strtol(argv[1], &fin, 10);
    if (errno == ERANGE || fin == argv[1] || *fin != '\0' ||
        numero <= 0 || numero > INT_MAX) {
        fprintf(stderr, "Se requiere un PID positivo valido\n");
        return EXIT_FAILURE;
    }
    const struct { const char *nombre; int valor; } opciones[] = {
        {"INT", SIGINT}, {"TERM", SIGTERM}, {"KILL", SIGKILL},
        {"STOP", SIGSTOP}, {"CONT", SIGCONT}, {"0", 0}
    };
    int senal = -1;
    for (size_t i = 0; i < sizeof opciones / sizeof opciones[0]; i++) {
        if (strcmp(argv[2], opciones[i].nombre) == 0) {
            senal = opciones[i].valor;
            break;
        }
    }
    if (senal == -1) {
        fprintf(stderr, "Nombre de senal no admitido\n");
        return EXIT_FAILURE;
    }
    if (kill((pid_t)numero, senal) == -1) {
        int causa = errno;
        fprintf(stderr, "kill(%ld, %s): %s\n", numero, argv[2], strerror(causa));
        return EXIT_FAILURE;
    }
    if (senal == 0)
        printf("Comprobacion aceptada para PID %ld; no se envio una senal\n", numero);
    else
        printf("Solicitud %s aceptada para PID %ld\n", argv[2], numero);
    return EXIT_SUCCESS;
}
Bash · usar el emisor con tu proceso preparado
$ gcc -std=c17 -Wall -Wextra -Wpedantic enviar_senal.c -o enviar_senal
$ ./enviar_senal "$pid" 0
$ ./enviar_senal "$pid" STOP
$ ./enviar_senal "$pid" CONT
$ ./enviar_senal "$pid" TERM
$ wait "$pid"

Inicia antes una nueva instancia de objetivo_senales y conserva su PID como en la sección 8. El emisor no es el padre del objetivo: puede solicitarle una señal si tiene permiso, pero no usar waitpid para recogerlo. La shell que lo inició conserva esa responsabilidad.

11. Proyecto: controlar y recoger un hijo

El siguiente programa elimina la necesidad de introducir sleeps para «dar tiempo» al hijo. El hijo se detiene a sí mismo con raise(SIGSTOP). El padre espera ese estado, solicita CONT, observa la continuación y finalmente envía TERM y recoge la terminación.

Antes de fork se restablecen SIGTERM y SIGCHLD y se desbloquean para que la prueba no dependa de esas propiedades heredadas. No se instala un manejador de SIGCHLD: waitpid observa los cambios. Los ejemplos son de un solo hilo.

controlar_hijo.c · sincronizar la observación mediante cambios de estado
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>

static int esperar(pid_t hijo, int opciones, int *estado, int *recogido)
{
    pid_t resultado;
    do {
        resultado = waitpid(hijo, estado, opciones);
    } while (resultado == -1 && errno == EINTR);
    if (resultado == -1)
        return -1;
    if (WIFEXITED(*estado) || WIFSIGNALED(*estado))
        *recogido = 1;
    return 0;
}

int main(void)
{
    struct sigaction accion = {0};
    accion.sa_handler = SIG_DFL;
    if (sigemptyset(&accion.sa_mask) == -1 ||
        sigaction(SIGTERM, &accion, NULL) == -1 ||
        sigaction(SIGCHLD, &accion, NULL) == -1) {
        perror("preparar disposiciones");
        return EXIT_FAILURE;
    }
    sigset_t desbloquear;
    if (sigemptyset(&desbloquear) == -1 ||
        sigaddset(&desbloquear, SIGTERM) == -1 ||
        sigaddset(&desbloquear, SIGCHLD) == -1 ||
        sigprocmask(SIG_UNBLOCK, &desbloquear, NULL) == -1) {
        perror("preparar mascara");
        return EXIT_FAILURE;
    }
    pid_t hijo = fork();
    if (hijo == -1) {
        perror("fork");
        return EXIT_FAILURE;
    }
    if (hijo == 0) {
        if (raise(SIGSTOP) != 0)
            _exit(2);
        for (;;)
            pause();
    }

    int recogido = 0;
    int estado;
    int salida = EXIT_FAILURE;
    if (esperar(hijo, WUNTRACED, &estado, &recogido) == -1) {
        perror("waitpid de parada");
        goto limpieza;
    }
    if (!WIFSTOPPED(estado) || WSTOPSIG(estado) != SIGSTOP) {
        fprintf(stderr, "No se observo la parada esperada\n");
        goto limpieza;
    }
    puts("Hijo detenido por SIGSTOP");
    if (kill(hijo, SIGCONT) == -1) {
        perror("kill SIGCONT");
        goto limpieza;
    }
    if (esperar(hijo, WCONTINUED, &estado, &recogido) == -1) {
        perror("waitpid de continuacion");
        goto limpieza;
    }
    if (!WIFCONTINUED(estado)) {
        fprintf(stderr, "No se observo la continuacion esperada\n");
        goto limpieza;
    }
    puts("Hijo continuado por SIGCONT");
    if (kill(hijo, SIGTERM) == -1) {
        perror("kill SIGTERM");
        goto limpieza;
    }
    if (esperar(hijo, 0, &estado, &recogido) == -1) {
        perror("waitpid de terminacion");
        goto limpieza;
    }
    if (WIFSIGNALED(estado) && WTERMSIG(estado) == SIGTERM) {
        puts("Hijo terminado por SIGTERM y recogido");
        salida = EXIT_SUCCESS;
    } else {
        fprintf(stderr, "Terminacion diferente de la esperada\n");
    }

limpieza:
    if (!recogido) {
        /* Solo se actua sobre el hijo propio, cuyo estado no se recogio. */
        if (kill(hijo, SIGKILL) == -1 && errno != ESRCH)
            perror("kill durante limpieza");
        if (esperar(hijo, 0, &estado, &recogido) == -1)
            perror("waitpid durante limpieza");
    }
    return salida;
}
Bash · ejecutar el controlador
$ gcc -std=c17 -Wall -Wextra -Wpedantic -g -O0 controlar_hijo.c -o controlar_hijo
$ ./controlar_hijo
Hijo detenido por SIGSTOP
Hijo continuado por SIGCONT
Hijo terminado por SIGTERM y recogido
$ echo $?
0

El cero corresponde al controlador: su prueba salió bien aunque el hijo haya terminado por una señal. Esa distinción evita confundir «resultado esperado del laboratorio» con «salida normal del hijo».

La limpieza intenta terminar y recoger al hijo si falló un paso. La variable recogido evita volver a señalizar un PID cuyo estado de terminación ya se recogió. El programa no implementa un supervisor completo con tiempos límite ni recuperación de toda restricción externa; valida esta secuencia sobre su hijo.

12. Interpretar los cambios de estado

El entero que escribe waitpid no es directamente el número de señal ni el código de salida. Consulta primero la macro que indica el tipo de cambio y después la que extrae su detalle.

ComprobaciónDetalle válidoCuándo se solicita
WIFEXITED(estado)WEXITSTATUS(estado): código de salida normal.Espera habitual de terminación.
WIFSIGNALED(estado)WTERMSIG(estado): señal que causó la terminación.Espera habitual de terminación.
WIFSTOPPED(estado)WSTOPSIG(estado): señal de parada.WUNTRACED permite observar paradas en esta prueba.
WIFCONTINUED(estado)Indica la continuación por SIGCONT.WCONTINUED permite observarla.

Observar una parada o una continuación no recoge una terminación: el hijo sigue existiendo. Tras la terminación hay que recoger su estado para liberar la información pendiente. Las opciones y macros se documentan en waitpid(2).

Bash representa una terminación por señal con un estado de shell relacionado con 128 más el número de señal. En una máquina donde SIGTERM sea 15 puedes observar 143. Ese valor no es el entero crudo que waitpid dejó en estado ni una razón para fijar 15 en el código C.

Un mensaje como «Terminated» o «Killed» puede proceder de la shell, no de un printf del programa afectado. Relaciona la salida con el proceso que la produce antes de concluir que se ejecutó una limpieza.

13. Herencia y límites de las señales

fork copia las disposiciones y la máscara del hilo que lo llama. exec conserva las disposiciones ignoradas, pero restablece las que tenían manejadores; la máscara se conserva. Por eso el contexto desde el que se inicia un programa importa y los laboratorios preparan explícitamente lo que necesitan.

Las señales estándar no deben usarse como una cola exacta de ocurrencias: varias instancias de la misma señal pendientes pueden agruparse. Un evento puede significar «consulta el estado compartido» sin representar por sí mismo cuántas tareas nuevas llegaron. Las señales en tiempo real tienen otras reglas y límites, que se estudiarán al final del bloque.

Un PID también tiene vida útil. Que una comprobación previa haya sido correcta no convierte ese número en una referencia permanente al proceso original. En un supervisor, la relación padre-hijo y la recolección coordinada ayudan a controlar esa vida útil; Linux ofrece además interfaces más avanzadas para determinados diseños.

Finalmente, enviar señales no reemplaza los datos del protocolo. TERM puede solicitar parar; no contiene una lista de pedidos cancelados ni confirma que los resultados estén guardados. Los canales de datos y las notificaciones suelen complementarse.

14. Explorar acciones por defecto

El modelo representa un proceso de un solo hilo con las disposiciones por defecto y señales sin bloquear. Empieza esperando en pause. Selecciona una señal y observa cómo cambian su ejecución y la responsabilidad del padre.

Estado del procesoEsperando en pause

Señales pendientes del modeloNinguna

Último eventoTodavía no hay envíos

Responsabilidad del padreSupervisar; todavía no terminó

    Prueba STOP, luego CONT. Compara con terminar y tratar de continuar.

    Haz cuatro recorridos: STOP → CONT → TERM; TERM y comprobar que CONT ya no puede reanudarlo; STOP → TERM → CONT; y STOP → KILL. En el tercero, el modelo conserva TERM pendiente mientras está detenido y aplica su acción al continuar. KILL termina incluso al proceso detenido.

    El estado pendiente es un conjunto: repetir TERM mientras está detenido no añade un contador de mensajes. WINCH se ignora por defecto en este modelo. QUIT se muestra con su acción Core, pero no se crea un archivo ni se simula su configuración.

    La herramienta no envía señales reales, no reproduce grupos, hilos o todas las reglas de prioridad y no configura máscaras. Si acumulas señales distintas, aplica la primera guardada como simplificación; no promete ese orden de entrega en Linux. Es una ayuda para separar los estados y las responsabilidades del ejemplo.

    15. Resumen

    16. Preguntas de repaso y práctica

    Intenta responder antes de desplegar cada explicación.

    1. ¿Qué diferencia hay entre generar y entregar una señal?

    Generar solicita la notificación. Entregar aplica la disposición correspondiente. Entre ambos momentos puede quedar pendiente, por ejemplo si está bloqueada o el proceso está detenido.

    2. ¿SIGTERM ejecuta automáticamente una limpieza ordenada?

    No. Su acción predeterminada es terminar. Para convertirla en una parada de aplicación hay que implementar el manejo y el protocolo necesarios.

    3. ¿Por qué SIGKILL no permite guardar un último resultado?

    Porque el destinatario no puede capturarla, ignorarla ni bloquearla para ejecutar un manejador. La recuperación debe contemplar una terminación sin limpieza propia.

    4. ¿Un proceso detenido cerró sus descriptores?

    No. Detener la ejecución no termina el proceso ni libera sus referencias. Puede seguir manteniendo recursos que otros participantes esperan.

    5. ¿CONT vuelve a empezar desde main?

    No. Reanuda un proceso detenido. Si el proceso ya terminó, no lo resucita; hace falta crear una instancia nueva.

    6. ¿Ctrl+C se dirige siempre a un único proceso?

    No. Con la configuración habitual, la terminal genera SIGINT para el grupo de procesos en primer plano, que puede contener varios componentes de un pipeline.

    7. ¿Ctrl+D es una señal de terminación?

    No. En el modo habitual de la terminal interviene en la entrega de entrada o la indicación de fin de entrada. No equivale a enviar SIGTERM.

    8. ¿kill(pid, 0) confirma que el programa responde?

    No. Comprueba existencia y permiso según las reglas de la interfaz sin enviar una señal. No mide disponibilidad ni cumplimiento de un protocolo.

    9. ¿Por qué el emisor rechaza PID cero y negativos?

    Para que su interfaz seleccione solo procesos individuales. Esos valores tienen significados especiales en kill y podrían seleccionar grupos o conjuntos más amplios.

    10. ¿Por qué el controlador usa WUNTRACED y WCONTINUED?

    Para observar la parada y la continuación, además de la terminación. Tras esos dos primeros cambios el hijo sigue vivo; todavía no se ha recogido un estado final.

    11. ¿Qué significa que el controlador termine con cero si su hijo murió por TERM?

    Que el controlador observó el resultado esperado de su prueba. Su estado de salida es distinto del estado del hijo que está comprobando.

    12. ¿Dos TERM pendientes equivalen a dos tareas almacenadas?

    No. Las instancias pendientes de una misma señal estándar pueden agruparse. Si necesitas contar y conservar tareas, usa un almacenamiento y un protocolo adecuados.

    Para practicar

    1. Compila objetivo_senales y comprueba Ctrl+C en primer plano. Consulta inmediatamente el estado que informa la shell y relaciónalo con kill -l INT.
    2. Inicia una instancia en segundo plano, espera el mensaje de preparación y recorre STOP → CONT → TERM. Observa el estado en ps tras cada paso y recoge al hijo desde la misma shell.
    3. Inicia otra instancia y prueba STOP → TERM. Observa que puede seguir detenida; envía CONT y explica la terminación posterior.
    4. Compara con STOP → KILL. Explica por qué no es necesario continuar antes para que KILL termine al proceso detenido.
    5. Prueba las entradas inválidas del emisor: PID cero, PID negativo, texto no numérico y nombre no admitido. Comprueba que se rechazan antes de enviar.
    6. Ejecuta controlar_hijo varias veces y explica cómo confirma la parada sin sleep. Identifica qué espera recoge finalmente al hijo.
    7. Registra el controlador con strace -f -o senales.log ./controlar_hijo. Localiza la señal dirigida al propio hijo, la continuación, la terminación y las esperas. La biblioteca puede implementar raise con llamadas como tgkill.
    8. Diseña una política para un trabajador que recibe TERM: nuevas tareas, tareas en curso, confirmación y recuperación si después recibe KILL. Indica qué parte necesitará un manejador en la siguiente lección.
    Próximo paso

    Ya puedes observar lo que hace el sistema por defecto. En el tema 7 cambiarás una disposición para instalar un manejador con sigaction y convertir una señal en una solicitud de terminación controlada.