1. Qué comunica SIGCHLD
Cuando un hijo cambia de estado, el padre puede recibir SIGCHLD. La notificación se relaciona con terminación y, según la configuración, con parada o continuación. No contiene por sí sola todos los resultados pendientes de todos los hijos.
Un hijo terminado deja información que su padre puede recoger con una operación de espera. Mientras esa información está pendiente, normalmente se observa como zombi: ya no ejecuta su programa, pero conserva el estado necesario para la recolección.
Recibir SIGCHLD no recoge automáticamente ese estado. Tampoco recoger un estado requiere necesariamente ejecutar un manejador: el padre puede esperar con waitpid, aceptar SIGCHLD mediante una espera síncrona o utilizar un manejador mínimo y un protocolo como el del tema anterior.
SIGCHLD significa «revisa los cambios de tus hijos». La fuente de verdad sobre qué estados puedes recoger es la interfaz de espera, no el número de veces que se invocó el manejador.
2. Una señal no es un contador de hijos
SIGCHLD es una señal estándar. Si tres hijos terminan mientras la señal está bloqueada, el conjunto pendiente puede representar una única SIGCHLD. Si el padre hace un solo waitpid por notificación y después vuelve a dormir, puede dejar otros hijos terminados sin recoger.
La solución es consultar hasta agotar los estados disponibles. La misma idea aparece en otros mecanismos: una notificación suele indicar que hay que drenar o revisar un estado, no que exista exactamente una unidad de trabajo.
No intentes arreglarlo incrementando un contador desde el manejador. Además de las restricciones del manejador, el sistema ya pudo agrupar ocurrencias antes de invocarlo. Un contador de invocaciones no reconstruye los eventos que dejaron de estar separados.
Incluso un siginfo_t asociado a una entrega de SIGCHLD no sustituye el recorrido de todos los estados pendientes. Puede aportar datos de un cambio, pero el padre sigue teniendo que coordinar la recolección de sus hijos.
3. Recoger estados con WNOHANG
Para revisar sin bloquear utiliza waitpid(-1, &estado, WNOHANG). En este contexto, −1 como selector significa cualquier hijo del llamador. El resultado distingue tres situaciones:
| Retorno | Significado | Acción |
|---|---|---|
| PID positivo | Se obtuvo un estado de ese hijo. | Interpretarlo, actualizar el registro y seguir consultando. |
| 0 | Existen hijos, pero no hay un estado que coincida disponible ahora. | Volver a una espera coordinada si queda trabajo pendiente. |
| −1 con EINTR | La operación fue interrumpida. | Reintentar según el protocolo. |
| −1 con ECHILD | No hay hijos que coincidan y puedan esperarse en ese contexto. | Comprobar el registro, las disposiciones y quién más pudo recogerlos. |
Con estas opciones recogeremos terminaciones. Si necesitas observar paradas y continuaciones, aparecen WUNTRACED y WCONTINUED, ya estudiadas en el tema 6. Un cambio de parada no se cuenta como un hijo definitivamente recogido.
Interpreta el entero estado con WIFEXITED, WEXITSTATUS, WIFSIGNALED y WTERMSIG según corresponda. El contrato completo está en waitpid(2).
4. Disposiciones y política de recolección
Que la acción por defecto de SIGCHLD se describa como ignorar no significa que sea equivalente a instalar explícitamente SIG_IGN. En Linux, SIG_IGN explícito o SA_NOCLDWAIT pueden cambiar la conservación de estados de terminación y hacer que no existan los zombis que esperabas recoger.
Si quieres examinar los estados, establece deliberadamente una política compatible con ello. SA_NOCLDSTOP reduce las notificaciones relacionadas con paradas y continuaciones, pero no reemplaza la recolección de terminaciones. Estos flags se documentan en sigaction(2).
Debe existir un dueño de la recolección. En un proceso con varios módulos o hilos, dos componentes que llaman a waitpid(-1, ...) pueden quitarse mutuamente estados que el otro esperaba. El proyecto siguiente posee todos los hijos que crea y no tiene otro recolector.
El código de diagnóstico y las impresiones se harán en main. El manejador solo permitirá despertar sigsuspend; no formateará mensajes ni modificará una lista de procesos desde la interrupción.
5. Proyecto: recoger varios hijos
Este programa crea tres hijos que terminan con códigos 10, 11 y 12. Bloquea SIGCHLD antes de crearlos, configura su acción y después alterna entre recoger todo lo disponible y esperar una nueva notificación.
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>
enum { NUM_HIJOS = 3 };
static void despertar(int senal)
{
(void)senal; /* El retorno permite volver de sigsuspend. */
}
int main(void)
{
sigset_t control, previa;
if (sigemptyset(&control) == -1 ||
sigaddset(&control, SIGCHLD) == -1 ||
sigprocmask(SIG_BLOCK, &control, &previa) == -1) {
perror("bloquear SIGCHLD");
return EXIT_FAILURE;
}
struct sigaction accion = {0};
accion.sa_handler = despertar;
accion.sa_mask = control;
accion.sa_flags = SA_NOCLDSTOP;
if (sigaction(SIGCHLD, &accion, NULL) == -1) {
perror("sigaction");
return EXIT_FAILURE;
}
sigset_t espera = previa;
if (sigdelset(&espera, SIGCHLD) == -1) {
perror("preparar espera");
return EXIT_FAILURE;
}
pid_t hijos[NUM_HIJOS] = {0};
int pendientes = 0;
int resultado = EXIT_FAILURE;
for (int i = 0; i < NUM_HIJOS; i++) {
pid_t pid = fork();
if (pid == -1) {
perror("fork");
goto limpieza;
}
if (pid == 0)
_exit(10 + i);
hijos[i] = pid;
pendientes++;
}
while (pendientes > 0) {
for (;;) {
int estado;
pid_t pid = waitpid(-1, &estado, WNOHANG);
if (pid > 0) {
int encontrado = 0;
for (int i = 0; i < NUM_HIJOS; i++) {
if (hijos[i] == pid) {
hijos[i] = 0;
encontrado = 1;
break;
}
}
if (!encontrado) {
fprintf(stderr, "Estado de un hijo no registrado\n");
goto limpieza;
}
pendientes--;
if (WIFEXITED(estado))
printf("Hijo %ld recogido: salida %d\n", (long)pid, WEXITSTATUS(estado));
else if (WIFSIGNALED(estado))
printf("Hijo %ld recogido: senal %d\n", (long)pid, WTERMSIG(estado));
continue;
}
if (pid == 0)
break;
if (errno == EINTR)
continue;
if (errno == ECHILD && pendientes == 0)
break;
perror("waitpid de revision");
goto limpieza;
}
if (pendientes > 0 &&
sigsuspend(&espera) == -1 && errno != EINTR) {
perror("sigsuspend");
goto limpieza;
}
}
puts("Todos los hijos fueron recogidos");
resultado = EXIT_SUCCESS;
limpieza:
/* Solo quedan PID propios que este programa todavia no recogio. */
for (int i = 0; i < NUM_HIJOS; i++) {
if (hijos[i] > 0 && kill(hijos[i], SIGKILL) == -1 && errno != ESRCH)
perror("kill durante limpieza");
}
for (int i = 0; i < NUM_HIJOS; i++) {
if (hijos[i] > 0) {
int estado;
pid_t pid;
do {
pid = waitpid(hijos[i], &estado, 0);
} while (pid == -1 && errno == EINTR);
if (pid == -1) {
perror("waitpid durante limpieza");
resultado = EXIT_FAILURE;
}
}
}
return resultado;
}$ gcc -std=c17 -Wall -Wextra -Wpedantic -g -O0 recoger_hijos.c -o recoger_hijos
$ ./recoger_hijos
Hijo 4100 recogido: salida 10
Hijo 4101 recogido: salida 11
Hijo 4102 recogido: salida 12
Todos los hijos fueron recogidosEl cero final del padre significa que recogió todos los estados previstos, no que cada hijo retornó cero. Los códigos distintos son deliberados. El orden de los hijos en la salida no debe formar parte de la comprobación.
6. Por qué no se pierde el despertar
SIGCHLD permanece bloqueada durante la revisión. Si un hijo termina después de que waitpid retorne cero, su notificación puede quedar pendiente. Al entrar en sigsuspend con una máscara que permite SIGCHLD, esa señal puede invocar el manejador y hacer volver al bucle.
Si el hijo ya había terminado antes de la revisión, waitpid puede recogerlo sin necesidad de ejecutar antes el manejador. Por eso el programa comienza revisando estados y no esperando ciegamente una señal nueva.
También puede quedar una notificación cuyo estado ya recogiste. El bucle vuelve a revisar y, si todavía hay hijos vivos pero no resultados nuevos, espera otra vez. No presupone una relación uno a uno entre entrega de señal y retorno positivo de waitpid.
Esta atomicidad resuelve la ventana de espera, pero no impone un tiempo máximo a hijos que no terminan. El proyecto crea hijos que salen inmediatamente; un supervisor real necesita además políticas de trabajo, cancelación y tiempo límite.
7. Qué aportan las señales en tiempo real
Las señales en tiempo real permiten mantener varias instancias pendientes de una misma señal, sujetas a límites. Para un mismo número de señal, las instancias se entregan en el orden en que se encolaron. Eso contrasta con una señal estándar pendiente, cuyas ocurrencias pueden agruparse.
El nombre tiempo real no promete una fecha límite de ejecución, latencia fija ni procesamiento inmediato. El destinatario puede estar ocupado, detenido o manteniendo la señal bloqueada. Lo nuevo que nos interesa aquí es la conservación de instancias y los datos asociados.
El rango disponible se consulta mediante SIGRTMIN y SIGRTMAX. No fijes números como 34 en el fuente: la biblioteca puede reservar parte del rango y calcular SIGRTMIN durante la ejecución. Si necesitas varias señales, verifica que SIGRTMIN más tu desplazamiento no supere SIGRTMAX.
En Linux, entre señales en tiempo real diferentes se priorizan los números menores; no conviertas eso en una regla de orden de mensajes entre todos los mecanismos y emisores. El experimento utiliza un único número, SIGRTMIN, para que el orden de una secuencia enviada se pueda estudiar sin mezclar prioridades. Las propiedades generales se describen en signal(7).
8. Enviar un valor con sigqueue
union sigval dato;
dato.sival_int = 42;
if (sigqueue(destino, senal_rt, dato) == -1) {
/* Consultar errno y decidir como tratar el envio rechazado. */
}union sigval puede representar un entero o un valor de puntero. No contiene un búfer arbitrario. Enviar un puntero de tu espacio privado no copia los datos apuntados ni hace que esa dirección tenga sentido en otro proceso.
sigqueue devuelve cero si el envío fue aceptado y −1 ante un fallo. Entre las causas relevantes están permisos insuficientes, destino inexistente o límite de señales pendientes alcanzado. Un envío aceptado no confirma que el destinatario haya validado el valor ni terminado su trabajo.
Usar sigqueue sobre una señal estándar no la transforma en una cola con las garantías de una señal en tiempo real. El tipo de señal sigue siendo parte del contrato. La interfaz y los datos asociados se documentan en sigqueue(3).
9. Recibir datos y comprobar su origen
Los datos asociados pueden observarse mediante un manejador de tres argumentos configurado con SA_SIGINFO o mediante una aceptación síncrona como sigwaitinfo. En el primer caso siguen aplicándose las restricciones de los manejadores; no se habilita printf por disponer de más argumentos.
| Interfaz | Dónde llega la información | Resultado |
|---|---|---|
| sigaction con SA_SIGINFO | En siginfo_t durante un manejador asíncrono. | La función manejadora debe registrar solo información apropiada para su contexto. |
| sigwait | Devuelve el número por un argumento. | Cero o código de error; no proporciona siginfo_t. |
| sigwaitinfo | Escribe siginfo_t en el flujo normal. | Número de señal o −1 con errno. |
Comprueba si_code antes de interpretar campos cuyo significado depende del origen. Para un evento enviado con sigqueue, SI_QUEUE permite interpretar si_value; si_pid y si_uid aportan metadatos del emisor según ese contrato. En SIGCHLD aparecen otros códigos y datos de cambio de estado.
No leas todos los campos como si estuvieran definidos para cualquier señal. Y mostrar el PID del emisor en un diagnóstico no sustituye una política de autorización de la aplicación. El ejemplo utilizará sigwaitinfo para procesar y mostrar los datos desde main. Su aceptación y sus errores se explican en sigwaitinfo(2).
10. Programa receptor con sigwaitinfo
Guarda este archivo como receptor_rt.c. Bloquea SIGRTMIN antes de prepararse, establece una disposición conocida y acepta sus eventos sin manejador. Los enteros se muestran como datos de la práctica y −1 queda reservado para solicitar el fin.
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void)
{
int senal_rt = SIGRTMIN;
if (senal_rt > SIGRTMAX) {
fprintf(stderr, "No hay una senal RT disponible\n");
return EXIT_FAILURE;
}
sigset_t esperadas;
if (sigemptyset(&esperadas) == -1 ||
sigaddset(&esperadas, senal_rt) == -1 ||
sigprocmask(SIG_BLOCK, &esperadas, NULL) == -1) {
perror("bloquear senal RT");
return EXIT_FAILURE;
}
struct sigaction accion = {0};
accion.sa_handler = SIG_DFL;
if (sigemptyset(&accion.sa_mask) == -1 ||
sigaction(senal_rt, &accion, NULL) == -1) {
perror("preparar disposicion");
return EXIT_FAILURE;
}
printf("PID listo: %ld\n", (long)getpid());
printf("Senal usada: %d (SIGRTMIN)\n", senal_rt);
puts("Envia enteros con sigqueue; -1 solicita terminar.");
if (fflush(stdout) == EOF) {
perror("fflush");
return EXIT_FAILURE;
}
size_t recibidos = 0;
for (;;) {
siginfo_t info;
int recibida = sigwaitinfo(&esperadas, &info);
if (recibida == -1) {
if (errno == EINTR)
continue;
perror("sigwaitinfo");
return EXIT_FAILURE;
}
if (recibida != senal_rt || info.si_code != SI_QUEUE) {
puts("Evento sin el formato sigqueue esperado: ignorado por la aplicacion");
if (fflush(stdout) == EOF)
return EXIT_FAILURE;
continue;
}
int valor = info.si_value.sival_int;
if (valor == -1) {
printf("Fin solicitado; %zu valores aceptados\n", recibidos);
return EXIT_SUCCESS;
}
recibidos++;
printf("Valor %d; emisor PID %ld, UID %lu\n", valor,
(long)info.si_pid, (unsigned long)info.si_uid);
if (fflush(stdout) == EOF) {
perror("fflush");
return EXIT_FAILURE;
}
}
}La señal permanece bloqueada para su entrega asíncrona, pero sigwaitinfo puede aceptarla. Así el receptor no termina por la acción predeterminada de esa señal ni entra en un manejador mientras imprime.
El valor −1 es una decisión de este protocolo. No es un valor mágico de sigqueue ni un fin de archivo del núcleo. El receptor no acepta órdenes de parada procedentes de una señal enviada sin el formato SI_QUEUE que espera.
11. Programa emisor de valores
Este emisor valida un PID positivo y hasta 32 enteros antes de empezar. Si aparece −1, debe ser el último valor del comando. La validación evita que un error de texto se descubra después de haber enviado parte de la lista.
Los fallos durante los envíos siguen pudiendo dejar una secuencia parcial aceptada. El programa lo informa y no reenvía toda la lista automáticamente, porque podría duplicar los elementos que ya se aceptaron.
#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>
enum { MAX_VALORES = 32 };
static int convertir(const char *texto, long minimo, long maximo, long *valor)
{
char *fin;
errno = 0;
long numero = strtol(texto, &fin, 10);
if (errno == ERANGE || fin == texto || *fin != '\0' ||
numero < minimo || numero > maximo)
return -1;
*valor = numero;
return 0;
}
int main(int argc, char *argv[])
{
if (argc < 3 || argc > MAX_VALORES + 2) {
fprintf(stderr, "Uso: %s PID valor [valores...], maximo 32\n", argv[0]);
return EXIT_FAILURE;
}
long pid;
if (convertir(argv[1], 1, INT_MAX, &pid) == -1) {
fprintf(stderr, "PID positivo invalido\n");
return EXIT_FAILURE;
}
int valores[MAX_VALORES];
int cantidad = argc - 2;
for (int i = 0; i < cantidad; i++) {
long numero;
if (convertir(argv[i + 2], INT_MIN, INT_MAX, &numero) == -1) {
fprintf(stderr, "Valor entero invalido: %s\n", argv[i + 2]);
return EXIT_FAILURE;
}
valores[i] = (int)numero;
if (valores[i] == -1 && i != cantidad - 1) {
fprintf(stderr, "El fin -1 solo puede aparecer al final\n");
return EXIT_FAILURE;
}
}
int senal_rt = SIGRTMIN;
if (senal_rt > SIGRTMAX) {
fprintf(stderr, "No hay una senal RT disponible\n");
return EXIT_FAILURE;
}
for (int i = 0; i < cantidad; i++) {
union sigval dato = { .sival_int = valores[i] };
if (sigqueue((pid_t)pid, senal_rt, dato) == -1) {
int causa = errno;
fprintf(stderr, "Enviado %d de %d; siguiente rechazado: %s\n",
i, cantidad, strerror(causa));
return EXIT_FAILURE;
}
printf("Aceptado para envio: %d\n", valores[i]);
}
return EXIT_SUCCESS;
}El límite del PID corresponde al tipo habitual de Linux usado en el curso. El receptor y el emisor calculan la señal con SIGRTMIN en sus propios entornos; si se ejecutaran con entornos que eligieran números distintos, tendrían que acordar el número disponible como parte del protocolo.
12. Probar el intercambio y sus límites
$ gcc -std=c17 -Wall -Wextra -Wpedantic -g -O0 receptor_rt.c -o receptor_rt
$ gcc -std=c17 -Wall -Wextra -Wpedantic -g -O0 emisor_rt.c -o emisor_rt
$ ./receptor_rt &
$ pid=$!
... espera las tres líneas de preparación ...
$ ./emisor_rt "$pid" 10 20 30 -1
$ wait "$pid"El emisor informa los valores aceptados para envío. El receptor mostrará 10, 20 y 30, junto con los metadatos del emisor, y después informará tres valores antes del fin. Las salidas de ambos programas pueden intercalarse; identifica cuál produce cada línea.
Para comprobar que las instancias se conservan mientras el receptor no avanza, inicia otra instancia preparada, envíale STOP, encola una secuencia y luego envía CONT. El receptor aceptará los valores pendientes de esa misma señal en orden. La parada de este laboratorio se envía mediante el entero −1, no mediante un kill sin datos.
La cola es finita. En Linux, RLIMIT_SIGPENDING limita señales pendientes asociadas al usuario real, de modo que no debes pensar solo en una cola privada de este proceso. Si sigqueue falla con EAGAIN, el emisor debe aplicar una política de presión y reintento que conserve qué elementos ya se aceptaron.
Consulta los límites con ulimit -i desde Bash o mediante getrlimit en una aplicación, sin suponer un valor fijo. La regla del límite se describe en getrlimit(2). No hace falta cambiarla para realizar estas prácticas pequeñas.
Un receptor que nunca recibe −1 puede esperar indefinidamente. Y un emisor que terminó con éxito no confirmó una transacción durable en el receptor. Si necesitas confirmaciones, recuperación o grandes volúmenes, define esos requisitos o elige colas de mensajes, memoria compartida o sockets según el caso.
13. Explorar agrupación y colas
Una SIGCHLD, varios estados disponibles
En este modelo las terminaciones se acumulan mientras la notificación estándar queda pendiente. Haz terminar los tres hijos antes de atender el aviso y compara recoger todos los estados con recoger solo uno.
| Hijo del modelo | Estado |
|---|---|
| A | Vivo |
| B | Vivo |
| C | Vivo |
SIGCHLD pendienteNo
Estados por recoger0
Hijos recogidos0 de 3
Termina los tres hijos antes de atender la notificación.
Si recoges solo uno después de las tres terminaciones, pueden quedar resultados sin una señal nueva que te despierte. En el programa real, el bucle de WNOHANG evita depender de esa nueva notificación. Cambiar la opción reinicia el modelo.
Una presencia pendiente frente a varias instancias
El segundo modelo compara una señal estándar pendiente con una señal en tiempo real. La cola RT tiene capacidad didáctica de tres elementos; no representa el límite real del núcleo ni reserva −1 como fin. Introduce valores distintos y acepta eventos uno por uno.
Contenido pendienteVacío
Envíos aceptados en el modelo0
Eventos aceptados por el receptor0
Último valor recibidoNinguno
Encola tres valores y después intenta un cuarto para observar el límite del modelo.
En el modo estándar el modelo conserva la información de la primera instancia pendiente, como ocurre en Linux en este caso; los nuevos envíos no se convierten en una lista de valores. En el modo RT se conserva el orden para ese único número de señal y el cuarto envío se rechaza mientras la cola siga llena.
Ambas herramientas son representaciones didácticas: no crean procesos, no envían señales reales ni reproducen toda la planificación. El contador de envíos aceptados no es una confirmación de procesamiento o persistencia.
14. Diagnóstico y decisiones de diseño
| Síntoma | Qué comprobar |
|---|---|
| Quedan zombis después de una SIGCHLD. | Si se recoge hasta agotar resultados, y no solo un hijo por aviso. |
| waitpid informa ECHILD inesperadamente. | Registro de hijos, otros recolectores, SIG_IGN explícito y SA_NOCLDWAIT. |
| Una señal RT termina al receptor. | Que el número esté acordado y bloqueado antes de recibir. |
| Faltan valores al utilizar una señal estándar. | Si se está suponiendo encolado donde solo hay presencia pendiente. |
| El dato recibido no tiene sentido. | si_code, el miembro correcto de sigval y el origen de la señal. |
| sigqueue devuelve EAGAIN. | Límite compartido, ritmo de consumo y política para envíos parciales. |
$ strace -f -o hijos.log ./recoger_hijos
$ strace -o emisor.log ./emisor_rt "$pid" 40 50 -1La segunda orden requiere una instancia nueva del receptor preparada y su PID vigente. En Linux pueden aparecer wait4, rt_sigsuspend, rt_sigqueueinfo y rt_sigtimedwait según la operación. No esperes una entrega visible de SIGCHLD por cada hijo ni una impresión por cada llamada del kernel.
Las señales RT pueden ser útiles para pequeños eventos de control con datos. Si necesitas grandes mensajes, colas durables, múltiples clientes o un protocolo de respuestas más elaborado, compara los mecanismos de los siguientes bloques. Conservar instancias pendientes no convierte a las señales en una base de datos ni en una cola de trabajos con confirmaciones.
15. Resumen
- SIGCHLD notifica cambios; waitpid proporciona los estados que el padre puede recoger.
- Una señal estándar puede agrupar varios eventos: el recolector debe revisar hasta agotar lo disponible.
- WNOHANG distingue estado disponible, ausencia temporal y errores.
- Disposiciones y flags como SIG_IGN, SA_NOCLDWAIT y SA_NOCLDSTOP afectan la política.
- Bloquear durante la revisión y esperar con sigsuspend evita perder una terminación entre ambos pasos.
- Las señales RT conservan instancias sujetas a límites; su nombre no garantiza una latencia.
- sigqueue permite asociar un entero o un valor de puntero, sin copiar una estructura apuntada.
- sigwaitinfo ofrece datos en el flujo normal; SA_SIGINFO los ofrece en un manejador.
- Un envío aceptado no equivale a trabajo completado, confirmación ni persistencia.
16. Preguntas de repaso y práctica
Intenta responder antes de abrir la explicación.
1. ¿Por qué una SIGCHLD no significa un único hijo terminado?
Porque es una señal estándar y varias ocurrencias pendientes pueden agruparse. El padre debe revisar los estados que ofrece waitpid.
2. ¿Qué distingue waitpid con WNOHANG al devolver cero?
No obtuvo un estado disponible que coincidiera ahora, aunque existen hijos. No significa lo mismo que un error ECHILD.
3. ¿Por qué revisar antes de esperar una nueva señal?
Porque un hijo puede haber terminado y estar listo para recoger aunque su notificación todavía esté pendiente o ya se haya atendido.
4. ¿SIG_IGN explícito para SIGCHLD equivale a su acción predeterminada?
No se debe asumir esa equivalencia. En Linux puede cambiar la conservación de estados de terminación y la posibilidad de recogerlos.
5. ¿Por qué el padre del proyecto devuelve cero si los hijos salen con 10, 11 y 12?
Porque su objetivo es crear y recoger esos hijos con los estados deliberados. El resultado del supervisor y los códigos de cada hijo son datos distintos.
6. ¿Señal en tiempo real implica ejecución antes de una fecha límite?
No. Aquí aporta instancias encoladas y datos, dentro de ciertos límites. La planificación y el trabajo del receptor siguen afectando el tiempo de atención.
7. ¿Por qué usar SIGRTMIN y verificar SIGRTMAX?
Porque el rango disponible puede depender de la biblioteca y de sus reservas. No debe fijarse a mano un número observado en otra máquina.
8. ¿sigqueue convierte SIGUSR1 en una cola exacta de valores?
No. SIGUSR1 sigue siendo estándar y sus ocurrencias pendientes pueden agruparse. El mecanismo de envío no cambia su naturaleza.
9. ¿Enviar sival_ptr transfiere los bytes apuntados?
No. Transfiere un valor de puntero, que puede no tener sentido en el espacio del receptor. Los datos requieren otro protocolo o una región compartida acordada.
10. ¿Por qué comprobar SI_QUEUE antes de leer el valor del ejemplo?
Porque los campos de siginfo_t tienen significado según el origen. El receptor solo interpreta como dato de su protocolo los eventos que cumplen ese formato.
11. ¿Cómo se informa un fallo de sigwaitinfo?
Con −1 y errno, a diferencia de sigwait, que devuelve directamente un número de error distinto de cero.
12. ¿Qué debe conservar el emisor si falla después de enviar parte de una lista?
Qué elementos se aceptaron y cuál fue rechazado. Reenviar toda la lista sin identificación ni deduplicación puede repetir datos ya aceptados.
Para practicar
- Ejecuta recoger_hijos y verifica que se recogen tres PID diferentes con los códigos 10, 11 y 12, sin exigir un orden fijo.
- Cambia NUM_HIJOS a cinco y comprueba cómo afecta al registro y al total. Mantén códigos de salida dentro del rango que puede recuperar WEXITSTATUS.
- En el simulador de SIGCHLD, haz terminar los tres hijos antes de atender el aviso. Compara el bucle completo con recoger una sola vez.
- Envía los valores 10, 20 y 30 y después el fin. Identifica qué mensajes son del emisor y cuáles confirman aceptación en el receptor.
- Detén un receptor preparado con STOP, envía una lista y luego CONT. Comprueba el orden conservado para esa misma señal.
- Prueba PID cero, un PID negativo, un entero fuera de rango y un −1 situado antes de otro dato. Comprueba que el emisor rechaza la entrada antes de empezar.
- En una instancia nueva, envía al número RT elegido una señal con kill, sin sigqueue. Comprueba que el receptor no interpreta sus campos como un valor del protocolo. Termina luego mediante el emisor con −1.
- Diseña una confirmación para cada valor: identificador, respuesta, límite y regla de reintento. Decide si conservar señales RT o utilizar otro canal simplificaría ese contrato.
Con este tema termina el bloque de señales. El tema 11 abre el bloque de tuberías anónimas: crearás un canal con pipe y estudiarás sus extremos, bloqueos, EOF y composición de comandos.