1. Interpretar el resultado antes de actuar
Hasta ahora construimos intercambios en los que cada operación se comprobaba, pero nos centramos en el recorrido normal. Para que ese recorrido sea útil hace falta definir qué ocurre si una llamada falla, devuelve menos de lo esperado o no puede avanzar todavía.
La primera regla es leer el contrato de cada función. Muchas llamadas devuelven −1 ante un error, pero no es una convención que puedas aplicar a toda API sin consultar su documentación. Tampoco todos los resultados positivos significan «operación lógica completa».
| Resultado de read con tamaño solicitado mayor que cero | Interpretación | Acción posible |
|---|---|---|
| Un número positivo | Se recibieron exactamente esos bytes. | Procesarlos o acumularlos y actualizar el progreso. |
| 0 | Fin de entrada para el flujo que estamos estudiando. | Comprobar si el protocolo ya estaba completo o quedó truncado. |
| −1 con EINTR | La llamada se interrumpió antes de entregar bytes. | Reintentar si la operación sigue siendo necesaria. |
| −1 con EAGAIN | No puede progresar ahora en modo no bloqueante. | Conservar el estado y esperar disponibilidad. |
| −1 con otro error | La operación falló por una causa específica. | Clasificarla, informar y aplicar la política de recuperación. |
El alcance de la tabla importa: una lectura solicitada con tamaño cero puede devolver cero sin demostrar EOF; otros mecanismos, como datagramas de longitud cero, tienen reglas distintas. Para los flujos, una lectura corta no es por sí sola un error ni prueba que el emisor haya terminado. Consulta el contrato completo en read(2).
2. Consultar y conservar errno
errno, declarado por <errno.h>, permite consultar la causa de determinados fallos. Úsalo cuando el resultado de la función indique que corresponde hacerlo. Una llamada exitosa no tiene que ponerlo en cero; comprobar un valor anterior después de un éxito puede fabricar un error inexistente.
int fd = open(ruta, O_RDONLY);
if (fd == -1) {
int causa = errno;
/* Otras operaciones podrian modificar errno. */
fprintf(stderr, "No se pudo abrir %s: %s\n", ruta, strerror(causa));
}perror describe el valor de errno que encuentra al llamarlo; strerror(causa) permite describir una copia guardada. Incluye <string.h> para esta última. No compares el texto del mensaje: puede cambiar según el idioma. Toma decisiones con constantes como EACCES o EINTR, no con sus números en una máquina concreta.
Hay interfaces donde un valor aparentemente especial también puede ser un resultado válido. En esos casos el manual puede pedir poner errno en cero antes de llamar, como viste con fpathconf en el tema 3. Esa excepción no obliga a reiniciar errno antes de todas las funciones.
La forma de consultar errno y sus limitaciones se documentan en errno(3). En este tema los ejemplos son de un solo hilo y los mensajes se imprimen desde el flujo normal del programa, no desde manejadores de señales.
3. Clasificar errores por su significado
Reintentar indefinidamente cualquier fallo puede ocultar un defecto, consumir CPU o repetir una operación con efectos. Antes de reintentar, distingue qué tipo de situación tienes:
| Situación | Ejemplos | Qué revisar |
|---|---|---|
| Interrupción | EINTR en una operación que lo documenta. | Si sigue siendo necesaria o se solicitó cancelar. |
| Falta temporal de disponibilidad | EAGAIN o EWOULDBLOCK. | Esperar un evento, sin reiniciar el trabajo aceptado. |
| Uso incorrecto o estado inválido | EBADF, EINVAL. | Descriptor, argumentos, flags y estado del recurso. |
| Acceso denegado | EACCES, EPERM. | Usuario, permisos y reglas específicas de la operación. |
| Recursos agotados | EMFILE, ENFILE, ENOMEM. | Fugas, límites y capacidad; no solo la última llamada. |
| Interlocutor desaparecido | EPIPE en un canal sin lectores. | Abandonar o reconstruir la conversación según el protocolo. |
| Nombre no disponible | ENOENT o EEXIST, según la creación o apertura. | Quién crea el objeto y si pertenece a otra instancia. |
Estos nombres no implican la misma causa en toda API. EAGAIN en una creación de proceso, por ejemplo, no significa «espera lectura en un descriptor». Una recuperación correcta depende de la operación que falló, del estado que conservas y de las garantías que espera la aplicación.
4. Transferencias parciales y progreso
Una escritura que devuelve 4 cuando pediste 12 aceptó cuatro bytes. La próxima operación debe empezar en el quinto, no en el primero. De lo contrario puedes duplicar un prefijo. El mismo principio se aplica al acumular fragmentos recibidos.
/* cantidad es el total y usados empieza en cero. */
ssize_t n = write(fd, datos + usados, cantidad - usados);
if (n > 0)
usados += (size_t)n;Usa ssize_t para el resultado, porque debe representar −1, y size_t para cantidades y posiciones no negativas. No conviertas el resultado a un entero sin signo antes de comprobar si es negativo.
Una función de «escribir todo» necesita mantener ese contador, tratar errores y evitar un bucle sin avance si obtiene un resultado inesperado de cero con bytes pendientes. Su contrato también debe decir si trabaja con descriptores bloqueantes: si devuelve al aparecer EAGAIN, el llamador debe conservar cuánto se aceptó.
No todas las unidades se pueden partir de la misma forma. En un flujo puedes continuar desde el offset pendiente; en un transporte de mensajes, dividir un envío en varios puede cambiar las fronteras que verá el receptor. Y aceptar bytes no significa que el otro programa los haya procesado o almacenado de forma durable. Las escrituras parciales se documentan en write(2).
5. EINTR: interrupción y política de reintento
Una señal puede interrumpir ciertas llamadas bloqueantes. Según la interfaz y la configuración del manejador, la llamada puede reiniciarse o retornar un error EINTR. Si ya entregó bytes, puede informar ese progreso con un resultado positivo: primero procesa el resultado y después decide qué falta.
ssize_t n;
do {
n = read(fd, buffer, sizeof buffer);
} while (n == -1 && errno == EINTR);Este bucle es apropiado cuando la operación debe continuar y no hay otra política de cancelación. Si la señal representa una petición de parada, reintentar sin consultar ese estado puede impedir la salida esperada. Tampoco supongas que SA_RESTART reinicia todas las interfaces: el comportamiento depende de la llamada.
Con tiempos límite aparece otra trampa: reintentar una espera de cinco segundos desde cero tras cada interrupción puede prolongarla indefinidamente. Para un límite total conviene conservar una fecha de vencimiento basada en reloj monótono y recalcular el tiempo restante. En los bloques posteriores se desarrollará la integración de señales y esperas.
6. EAGAIN y E/S no bloqueante
En una tubería bloqueante, leer cuando no hay datos pero queda un escritor puede poner al proceso en espera. Con O_NONBLOCK, la operación no espera esa condición: devuelve el error correspondiente, normalmente EAGAIN. Eso no significa EOF.
El programa debe conservar su estado y esperar disponibilidad mediante select, poll o epoll cuando corresponda. Volver a llamar sin pausa en un bucle convierte una espera eficiente en una consulta continua que consume CPU. La disponibilidad tampoco reserva los datos para ti si hay otros lectores: debes seguir gestionando el resultado real de la operación.
Un canal puede indicar simultáneamente datos pendientes y que su escritor cerró. No descartes automáticamente el contenido al observar un evento de cierre: consume lo que corresponde y detecta el fin según la interfaz. Las esperas y sus eventos se documentan en poll(2); aquí solo anticipamos su papel y dejaremos la multiplexación completa para el bloque 9.
7. Experimento en C: EAGAIN y EPIPE
Este laboratorio utiliza los dos extremos de una tubería en un solo proceso para aislar dos situaciones. Primero intenta leer sin datos, con el escritor abierto y el lector en modo no bloqueante. Después cierra el lector y escribe, de modo que no existe ningún receptor.
La segunda prueba configura SIGPIPE para ignorarla y así poder observar EPIPE como resultado de write. Con la disposición predeterminada, esa señal puede terminar al proceso antes de que gestione el retorno. Es una decisión explícita del laboratorio, no una recomendación de ignorar todas las señales.
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
int main(void)
{
int canal[2];
if (pipe(canal) == -1) {
perror("pipe");
return EXIT_FAILURE;
}
int resultado = EXIT_FAILURE;
int flags = fcntl(canal[0], F_GETFL);
if (flags == -1 || fcntl(canal[0], F_SETFL, flags | O_NONBLOCK) == -1) {
perror("fcntl");
goto finalizar;
}
char byte;
ssize_t n = read(canal[0], &byte, 1);
int causa = errno;
if (n != -1 || (causa != EAGAIN && causa != EWOULDBLOCK)) {
fprintf(stderr, "La lectura no produjo el EAGAIN esperado\n");
goto finalizar;
}
printf("Canal vacio, escritor abierto: EAGAIN (%s)\n", strerror(causa));
struct sigaction accion = {0};
accion.sa_handler = SIG_IGN;
if (sigemptyset(&accion.sa_mask) == -1 ||
sigaction(SIGPIPE, &accion, NULL) == -1) {
perror("configurar SIGPIPE");
goto finalizar;
}
close(canal[0]);
canal[0] = -1;
n = write(canal[1], "X", 1);
causa = errno;
if (n != -1 || causa != EPIPE) {
fprintf(stderr, "La escritura no produjo el EPIPE esperado\n");
goto finalizar;
}
printf("Canal sin lectores: EPIPE (%s)\n", strerror(causa));
resultado = EXIT_SUCCESS;
finalizar:
if (canal[0] != -1)
close(canal[0]);
close(canal[1]);
return resultado;
}$ gcc -std=c17 -Wall -Wextra -Wpedantic errores_pipe.c -o errores_pipe
$ ./errores_pipe
Canal vacio, escritor abierto: EAGAIN (Resource temporarily unavailable)
Canal sin lectores: EPIPE (Broken pipe)
$ echo $?
0El texto entre paréntesis depende del idioma del entorno. El cero final significa que se observaron los fallos que la prueba esperaba, no que read y write hayan tenido éxito. La relación entre lectores, escritores, EOF y SIGPIPE se describe en pipe(7).
8. Espera, interbloqueo y tiempo límite
Un proceso dormido no está necesariamente fallando. Esperar una petición que todavía no llegó es parte normal de un servidor. La pregunta es qué evento permitirá avanzar y quién puede producirlo.
Un interbloqueo aparece cuando las dependencias impiden producir ese evento. En el capturador del tema 4, si el padre espera al hijo antes de drenar una salida grande, el hijo puede esperar espacio mientras el padre espera su terminación. También dos procesos que comienzan esperando la primera petición del otro pueden quedarse detenidos sin que ningún búfer esté lleno.
Un tiempo límite permite abandonar una espera, pero no demuestra si el interlocutor falló ni deshace lo que ya ejecutó. timeout 3s ./programa es útil durante las prácticas; no sustituye un protocolo interno de cancelación y limpieza.
Para un servicio conviene fijar límites por fase o por operación completa: conexión, recepción, procesamiento y respuesta. Al agotarlos decide qué hacer con datos parciales, tareas en curso y respuestas que lleguen tarde. Reenviar una operación sin conocer su resultado puede repetir su efecto.
9. El ciclo de vida de los recursos
Antes de programar un intercambio, haz un inventario de lo que se adquiere y quién lo libera. El camino de error puede recorrer solo una parte de esta secuencia:
- Crear o abrir. Obtener descriptores, mapas, nombres o procesos.
- Configurar. Establecer flags, tamaño, permisos y estructuras iniciales.
- Publicar y usar. Permitir que otros participantes encuentren el recurso cuando esté listo.
- Dejar de admitir trabajo. Evitar nuevas operaciones cuando comienza la parada.
- Completar o cancelar. Resolver los intercambios en curso conforme al protocolo.
- Liberar y recoger. Cerrar referencias, retirar nombres propios cuando corresponda y recoger los hijos.
Inicializar un descriptor con −1 ayuda a distinguir «todavía no adquirido» de un número válido. Después de transferir o liberar su propiedad, actualiza la variable para no cerrarlo otra vez por accidente. Un número liberado puede reutilizarse para otro objeto: un doble close puede cerrar un recurso diferente.
En Linux no reintentes close a ciegas tras un error: el descriptor puede haberse liberado y reutilizado. Otros sistemas tienen diferencias, especialmente alrededor de EINTR; consulta el contrato de la plataforma. El helper del proyecto siguiente está pensado para Linux y registra el problema sin volver a cerrar ese número. Los matices están documentados en close(2).
Un punto común de limpieza puede ser más claro que copiar los mismos cierres en cada rama. Un goto usado para salir hacia esa limpieza no es una recuperación automática: cada variable debe indicar qué recurso sigue perteneciendo a esa rama y cada hijo creado necesita una política de recolección.
10. Proyecto: completar o rechazar una transferencia
Este programa espera una unidad de exactamente 12 bytes. El hijo puede enviar los 12, cerrar después de 7 o terminar con error sin enviar. El padre distingue transferencia completa, EOF antes del primer byte, contenido truncado y fallo de lectura; después cierra sus referencias y recoge al hijo.
El emisor divide intencionadamente el contenido en bloques de hasta tres bytes. Eso genera varias escrituras sin asumir que cada una coincida con una lectura. Es un protocolo de tamaño fijo, no un ejemplo de delimitación aplicable a cualquier mensaje.
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>
enum recepcion { COMPLETA, SIN_DATOS, TRUNCADA, ERROR_LECTURA };
/* Linux: no reintentar close; preservar errno del fallo principal. */
static int cerrar_fd(int *fd)
{
if (*fd == -1)
return 0;
int previo = errno;
int numero = *fd;
*fd = -1;
int resultado = close(numero);
if (resultado == -1)
perror("close durante limpieza");
errno = previo;
return resultado;
}
static int enviar(int fd, const char *datos, size_t total)
{
size_t usados = 0;
while (usados < total) {
size_t pedido = total - usados;
if (pedido > 3)
pedido = 3;
ssize_t n = write(fd, datos + usados, pedido);
if (n > 0) {
usados += (size_t)n;
} else if (n == -1 && errno == EINTR) {
continue;
} else {
if (n == 0)
errno = EIO;
return -1;
}
}
return 0;
}
static enum recepcion recibir(int fd, char *datos, size_t total, size_t *usados)
{
*usados = 0;
while (*usados < total) {
ssize_t n = read(fd, datos + *usados, total - *usados);
if (n > 0) {
*usados += (size_t)n;
} else if (n == 0) {
return *usados == 0 ? SIN_DATOS : TRUNCADA;
} else if (errno != EINTR) {
return ERROR_LECTURA;
}
}
return COMPLETA;
}
int main(int argc, char *argv[])
{
if (argc != 2 || (strcmp(argv[1], "normal") != 0 &&
strcmp(argv[1], "truncado") != 0 && strcmp(argv[1], "fallo") != 0)) {
fprintf(stderr, "Uso: %s normal|truncado|fallo\n", argv[0]);
return EXIT_FAILURE;
}
int canal[2] = {-1, -1};
pid_t hijo = -1;
int resultado = EXIT_FAILURE;
if (pipe(canal) == -1) {
perror("pipe");
goto limpieza;
}
hijo = fork();
if (hijo == -1) {
perror("fork");
goto limpieza;
}
if (hijo == 0) {
if (cerrar_fd(&canal[0]) == -1)
_exit(2);
int codigo = 0;
if (strcmp(argv[1], "fallo") == 0) {
codigo = 3;
} else {
const char datos[] = "ABCDEFGHIJKL";
size_t cantidad = strcmp(argv[1], "truncado") == 0 ? 7 : 12;
if (enviar(canal[1], datos, cantidad) == -1) {
perror("enviar");
codigo = 2;
}
}
if (cerrar_fd(&canal[1]) == -1)
codigo = 2;
_exit(codigo);
}
if (cerrar_fd(&canal[1]) == -1)
goto limpieza;
char datos[12];
size_t usados;
enum recepcion estado = recibir(canal[0], datos, sizeof datos, &usados);
if (estado == COMPLETA) {
printf("Completa: %zu bytes [%.*s]\n", usados, (int)usados, datos);
resultado = EXIT_SUCCESS;
} else if (estado == SIN_DATOS) {
fprintf(stderr, "EOF antes de recibir la unidad esperada\n");
} else if (estado == TRUNCADA) {
fprintf(stderr, "Truncada: %zu de %zu bytes\n", usados, sizeof datos);
} else {
int causa = errno;
fprintf(stderr, "Error de lectura: %s\n", strerror(causa));
}
limpieza:
if (cerrar_fd(&canal[0]) == -1)
resultado = EXIT_FAILURE;
if (cerrar_fd(&canal[1]) == -1)
resultado = EXIT_FAILURE;
if (hijo > 0) {
int estado_hijo;
pid_t recogido;
do {
recogido = waitpid(hijo, &estado_hijo, 0);
} while (recogido == -1 && errno == EINTR);
if (recogido == -1) {
perror("waitpid");
resultado = EXIT_FAILURE;
} else if (WIFEXITED(estado_hijo)) {
int codigo = WEXITSTATUS(estado_hijo);
fprintf(stderr, "Hijo recogido: salida %d\n", codigo);
if (codigo != 0)
resultado = EXIT_FAILURE;
} else {
fprintf(stderr, "El hijo no termino normalmente\n");
resultado = EXIT_FAILURE;
}
}
return resultado;
}$ gcc -std=c17 -Wall -Wextra -Wpedantic -g -O0 transferencia.c -o transferencia
$ ./transferencia normal
Completa: 12 bytes [ABCDEFGHIJKL]
Hijo recogido: salida 0
$ ./transferencia truncado
Truncada: 7 de 12 bytes
Hijo recogido: salida 0
$ echo $?
1
$ ./transferencia fallo
EOF antes de recibir la unidad esperada
Hijo recogido: salida 3El orden visual de stdout y stderr puede variar al redirigirlos. El caso truncado muestra una distinción importante: el hijo puede terminar con cero y aun así incumplir el protocolo. En el caso fallo se observan tanto la ausencia de datos como un estado de terminación distinto de cero.
La limpieza cierra referencias incluso si la lectura falló y recoge al hijo si se creó. Se usa sobre descriptores bloqueantes; no añade tiempos límite ni recupera un interlocutor que se quede vivo sin cerrar. SIGPIPE conserva su disposición predeterminada en este segundo programa. Si lo amplías con cancelación o consumidores que abandonan, tendrás que definir esa política explícitamente.
El receptor valida la longitud, no un protocolo completo: no comprueba autenticidad, formato arbitrario ni contenido adicional después de los doce bytes. Una aplicación real puede necesitar todas esas comprobaciones. Tampoco se está generando EINTR de forma deliberada en esta práctica; su rama se implementa, pero requiere una prueba específica con señales para ejercitarla.
11. Permisos, nombres y responsabilidades
Cuando una IPC tiene nombre, encontrar el objeto no significa estar autorizado a usarlo. Una FIFO puede depender de los permisos de su directorio y del propio objeto; una cola o una región POSIX tiene sus reglas de apertura y acceso. El modo solicitado al crear puede verse afectado por la máscara umask.
No conviertas «funciona como administrador» en la solución habitual a EACCES. Revisa qué usuario crea, qué usuario abre, con qué operación y qué permisos necesita. Conceder acceso general puede hacer que otros procesos escriban datos inesperados o retiren recursos de otra instancia.
También hay que distinguir cerrar una referencia de retirar un nombre. close no sustituye a munmap, mq_unlink, shm_unlink o sem_unlink. Las referencias existentes y los nombres tienen vidas relacionadas, pero no idénticas. Cada bloque del curso tratará las reglas de sus objetos.
Si la creación exclusiva falla con EEXIST, no borres automáticamente el objeto para volver a intentar: puede pertenecer a otro servicio que está trabajando. Define una estrategia de identificación, exclusión y recuperación. El responsable de retirar un nombre debería poder justificar que es suyo y que el protocolo permite hacerlo.
12. Parada y cancelación
Un cierre ordenado es una transición del servicio, no solo una llamada final. Normalmente implica dejar de aceptar trabajo, decidir qué tareas pendientes se completan, notificar a los participantes y liberar lo que cada uno posee.
Para un productor y un consumidor, el cierre del último escritor puede anunciar que no habrá más bytes. Eso no sustituye la comprobación de integridad del último mensaje. En un protocolo de varias peticiones puede hacer falta un mensaje de parada y una respuesta de confirmación antes de cerrar.
Una señal de terminación debe integrarse con esa política. El manejador no debería ejecutar indiscriminadamente printf, liberaciones complejas o funciones que no sean seguras en ese contexto. El próximo bloque explicará qué se puede hacer y cómo llevar la decisión de parada al flujo normal del programa.
El sistema cierra los descriptores del proceso terminado, pero eso no implica completar trabajo pendiente, retirar todos sus nombres persistentes o devolver contadores a un estado coherente. Una aplicación que necesite recuperarse debe contemplar la caída abrupta además del cierre normal.
Si utilizas tiempos límite, distingue «dejar de esperar» de «detener al otro proceso». Una respuesta puede llegar después de que el cliente abandonó. Si decides reintentar, utiliza identificadores y reglas de idempotencia cuando haya efectos que no deban repetirse.
13. Diagnosticar con evidencia
Cuando un intercambio falla, registra qué operación estaba realizando cada proceso. Un mensaje como «error IPC» dice poco; «read del canal de respuestas, petición 42, después de 7 de 12 bytes» orienta la investigación.
| Síntoma | Hipótesis que conviene comprobar | Evidencia útil |
|---|---|---|
| Espera después de mostrar todo el texto | Queda un escritor abierto y no llega EOF. | Descriptores en /proc/PID/fd y cierres en strace. |
| CPU alta sin progreso | Se reintenta EAGAIN sin esperar un evento. | Resultados repetidos y estado de los bucles. |
| Contenido duplicado | Se reenvió desde cero tras un progreso parcial. | Offsets acumulados y bytes aceptados en cada operación. |
| Termina al desaparecer el lector | Actuó SIGPIPE. | Señales y estado de terminación. |
| Fallos tras muchas solicitudes | Hay fugas de descriptores o recursos. | Cantidad de referencias y límites de la instancia. |
| EOF con una unidad incompleta | El emisor cerró antes de cumplir el protocolo. | Bytes recibidos, estado del hijo y mensajes previos. |
$ timeout 5s ./transferencia normal
$ strace -f -o transferencia.log ./transferencia truncado
$ less transferencia.logLa segunda orden termina con estado distinto de cero porque la prueba truncada se rechaza. En la traza podrás encontrar las escrituras, el cierre del emisor, la lectura que devuelve cero y la espera del padre. No esperes una lectura por escritura: el flujo puede agrupar los bytes de otro modo.
Si ocurre un fallo primario y también falla la limpieza, conserva ambos datos sin ocultar el primero. Registra fase, PID y recurso cuando ayuden, pero evita volcar automáticamente contenido que no sea necesario para entender el problema.
14. Simular resultados y decisiones
Selecciona una secuencia y avanza llamada por llamada. La unidad tiene 12 bytes. Observa que una interrupción o una espera no borra los bytes ya aceptados, y que EOF puede indicar un mensaje incompleto.
Progreso acumulado0 de 12 bytes
Bytes pendientes12
Último resultadoSin llamadas
DecisiónSolicitar los bytes pendientes
El siguiente envío comienza en el byte 0. Cada resultado positivo avanza esa posición.
En la secuencia con EAGAIN, hay un paso de espera y otro de disponibilidad antes de reintentar. El programa real usaría una espera adecuada, no un botón. En el caso EPIPE se supone que SIGPIPE se ha tratado para poder observar el error.
Es un modelo de decisiones, no una llamada al sistema ni un planificador real. La secuencia de resultados está preparada para mostrar cada caso. El progreso de escritura representa bytes aceptados por el canal, no una confirmación de que el receptor terminó de procesarlos.
15. Resumen
- Interpreta el resultado antes de consultar errno y conserva la causa antes de operaciones que puedan modificarla.
- Una transferencia parcial avanza el offset; reintentar desde cero puede duplicar contenido.
- EINTR requiere una política de continuidad o cancelación; EAGAIN requiere gestionar disponibilidad.
- EOF termina el flujo, pero puede dejar una unidad de protocolo truncada.
- SIGPIPE y EPIPE requieren una decisión explícita sobre la pérdida del lector.
- Una espera normal tiene un evento que puede desbloquearla; un interbloqueo requiere cambiar las dependencias.
- La limpieza depende de lo que realmente se adquirió y de quién es su propietario.
- Cerrar referencias, retirar nombres y recoger hijos son responsabilidades distintas.
- Un cierre ordenado y una caída abrupta necesitan políticas de recuperación diferentes.
16. Preguntas de repaso y práctica
Intenta justificar la respuesta antes de abrirla.
1. ¿Por qué errno distinto de cero no demuestra que la última llamada falló?
Porque una operación exitosa no tiene que ponerlo en cero. Primero hay que comprobar el valor de retorno y el contrato de la función.
2. ¿Por qué guardar errno antes de limpiar recursos?
Porque la limpieza y otros mensajes pueden modificarlo. Una copia permite conservar la causa del fallo primario.
3. write acepta 4 de 12 bytes. ¿Desde dónde continúa el envío?
Desde el offset 4, con 8 bytes pendientes. Repetir los doce desde el inicio puede duplicar los cuatro ya aceptados.
4. ¿Una lectura corta implica EOF?
No. Un resultado positivo solo informa de los bytes entregados. El final del flujo se detecta mediante las reglas de la interfaz, por ejemplo un read de tamaño positivo que retorna cero.
5. ¿Qué distingue EINTR de EAGAIN en estas operaciones?
EINTR indica una interrupción de la llamada. EAGAIN en E/S no bloqueante indica que no puede progresar ahora. La segunda situación requiere esperar disponibilidad en lugar de consultar continuamente.
6. ¿Siempre conviene reintentar EINTR?
No. Debe respetarse la política de cancelación y de tiempo límite. Tampoco hay que aplicar a close en Linux un bucle de reintento copiado de read.
7. ¿Por qué el laboratorio ignora SIGPIPE?
Para que escribir sin lectores permita observar el retorno EPIPE en vez de terminar por la disposición predeterminada de la señal. Esa decisión está limitada a este laboratorio.
8. ¿Por qué el caso truncado es un fallo si el hijo terminó con cero?
Porque el protocolo esperaba doce bytes y solo recibió siete. La terminación del proceso y el cumplimiento del protocolo son comprobaciones diferentes.
9. ¿Cerrar un descriptor retira automáticamente todos los nombres de IPC?
No. Cada tipo de recurso tiene sus operaciones: cerrar referencias, desmapear y retirar nombres no son equivalentes.
10. ¿Qué problema tiene reintentar una espera completa después de cada interrupción?
Puede reiniciar el presupuesto de tiempo y prolongar la operación más allá del límite total. Una fecha de vencimiento permite calcular lo que queda.
11. ¿Por qué no borrar un objeto que causa EEXIST y volver a crear?
Porque puede pertenecer a otra instancia activa. Hay que establecer propiedad y una política de recuperación antes de retirar un nombre.
12. ¿Un tiempo límite demuestra que el servidor no ejecutó la tarea?
No. Puede haberla ejecutado y haber perdido o retrasado la respuesta. El protocolo necesita identificar reintentos y evitar efectos duplicados cuando corresponda.
Para practicar
- Ejecuta errores_pipe y explica por qué su estado final es cero aunque observe dos errores de llamadas al sistema.
- En una copia del primer ejemplo, elimina la configuración que ignora SIGPIPE. Predice qué sucede en la escritura sin lectores y consulta el estado que informa la shell.
- Ejecuta los tres modos de transferencia y registra por separado stdout, stderr y el estado de terminación.
- Cambia la cantidad del modo truncado de 7 a 11 y después a 0. Explica por qué se distinguen truncación y ausencia de una unidad.
- Modifica la validación del receptor para esperar más de doce bytes. Comprueba que la limpieza y waitpid se realizan aunque el contenido quede incompleto.
- Omite temporalmente el cierre del escritor del padre y prueba transferencia truncado con timeout 3s. Explica por qué desaparece la detección de EOF. Restaura el cierre.
- Dibuja la propiedad de cada descriptor en padre e hijo y recorre los caminos pipe fallido, fork fallido, lectura fallida y mensaje incompleto.
- Diseña un cierre ordenado para una cola de tareas: admisión de trabajo, tareas pendientes, confirmación, referencias, nombres y recuperación tras una caída.
Con este tema termina el bloque de fundamentos. El siguiente comienza por las señales y sus acciones por defecto, para después instalar manejadores y construir esperas sin carreras.