1. Qué entorno necesita el curso
En los dos primeros temas ejecutaste ejemplos de aislamiento, tuberías y sockets. Ahora vamos a dejar preparado un espacio de trabajo para el resto del curso. Necesitas un sistema que proporcione las interfaces usadas, un compilador C y una terminal desde la que puedas iniciar varios programas.
Los ejemplos se desarrollan sobre Linux. Puedes usar una instalación directa, una máquina virtual o una distribución Linux dentro de WSL en Windows. Las instrucciones de paquetes de este tema corresponden a Ubuntu y Debian; en otra distribución tendrás que usar sus paquetes y gestor propios. No hace falta una distribución concreta ni una versión exacta de GCC para reproducir los fundamentos.
Conviene separar tres piezas que a menudo se confunden:
- Editor. Guarda y modifica el archivo de texto
.c. No determina por sí solo dónde se ejecuta el programa. - Cadena de herramientas. El compilador, ensamblador, enlazador, cabeceras y bibliotecas producen el ejecutable.
- Entorno de ejecución. El sistema que carga el programa y proporciona las llamadas que utilizará.
Instalar un editor en Windows no proporciona automáticamente las interfaces de Linux. Un GCC que genere ejecutables Windows, como una cadena MinGW, tampoco se convierte en un compilador para Linux por tener el mismo nombre. Para este curso, compila y ejecuta dentro de la terminal de la distribución Linux.
Si ya usas Linux, continúa en la sección 3. Si usas Windows, prepara primero WSL y después sigue las mismas instrucciones de Ubuntu dentro de esa distribución. Los comandos de PowerShell y los de Bash están identificados en cada ejemplo.
2. Preparar WSL si usas Windows
En un Windows compatible, abre PowerShell como administrador para la instalación inicial. El comando siguiente habilita los componentes necesarios e instala Ubuntu por defecto. Completa el reinicio si se solicita y, en el primer inicio de Ubuntu, crea tu usuario Linux.
PS> wsl --installSi WSL ya está instalado, comprueba qué distribuciones tienes. El listado muestra sus nombres y si utilizan WSL 1 o WSL 2. Para este curso usa WSL 2; una distribución concreta se puede iniciar por su nombre:
PS> wsl --list --verbose
PS> wsl --list --online
PS> wsl --install -d Ubuntu
PS> wsl -d UbuntuEl comando de instalación de Ubuntu solo hace falta si no tienes esa distribución; adapta el nombre al que elegiste. Si tu instalación existente es WSL 1, consulta el procedimiento de conversión y sus requisitos. La instalación y las incidencias de virtualización se explican en la guía oficial de WSL; los comandos de consulta se detallan en Comandos básicos de WSL.
Una vez dentro de Ubuntu, las órdenes cambian: ejecutarás uname, sudo apt, gcc y ./programa desde Bash. El indicador $ que aparece en el curso representa el prompt y no se copia como parte del comando. Lo mismo ocurre con PS> en los bloques de PowerShell.
$ uname -s
Linux
$ cat /etc/os-release
... identificación de la distribución instalada ...La versión del núcleo y el nombre de la distribución pueden variar. Si apt no existe, verifica primero dónde estás y qué distribución abriste. No intentes solucionar esa diferencia copiando órdenes de instalación de otro sistema sin adaptarlas.
3. Instalar y comprobar herramientas
En Ubuntu o Debian, instala las herramientas de compilación y diagnóstico desde sus repositorios. sudo se utiliza para administrar paquetes; los ejemplos en C se ejecutarán después con tu usuario habitual.
$ sudo apt update
$ sudo apt install build-essential man-db manpages-dev gdb strace file| Herramienta o paquete | Para qué lo usarás |
|---|---|
| build-essential | Instalar el conjunto básico para compilar, incluidas las herramientas de construcción y cabeceras de desarrollo necesarias. |
| gcc | Traducir código C y coordinar el enlace del ejecutable. |
| make | Reconstruir un programa a partir de reglas y dependencias. |
| man-db y manpages-dev | Consultar funciones y llamadas del sistema desde la terminal. |
| gdb | Detener el programa, consultar variables y recorrer su ejecución. |
| strace | Observar llamadas al sistema, argumentos y resultados. |
| file | Identificar qué tipo de ejecutable se generó. |
Comprueba el resultado sin asumir una versión fija:
$ command -v gcc make gdb strace file
$ gcc --version
$ make --version
$ man 2 pipeEn el manual, pulsa q para salir. Las secciones ayudan a distinguir interfaces con nombres parecidos: man 2 read trata la llamada de lectura, mientras que man 3 printf trata una función de biblioteca. Mira especialmente las partes SYNOPSIS, RETURN VALUE y ERRORS.
La preparación de GCC y el conjunto de construcción en Ubuntu se describen también en la guía de desarrollo de Ubuntu. Si un paquete no se encuentra, comprueba la distribución, la conexión y el resultado de la actualización del índice antes de modificar el código.
4. Organizar los archivos de trabajo
Crea una carpeta por práctica. Mantener los fuentes separados evita sobrescribir un ejemplo anterior y permite reproducir un problema con los mismos archivos:
$ mkdir -p ~/cursos/ipc/tema03
$ cd ~/cursos/ipc/tema03
$ pwd
/home/tu_usuario/cursos/ipc/tema03Guarda allí diagnostico_ipc.c y, más adelante, el Makefile. Usa un editor de texto plano, codificación UTF-8 y finales de línea LF. Los nombres distinguen mayúsculas y minúsculas: Diagnostico.c y diagnostico.c no tienen por qué ser el mismo archivo.
En WSL, trabajar bajo tu carpeta Linux suele evitar problemas de rendimiento y diferencias de permisos al cruzar sistemas de archivos. /mnt/c permite acceder a la unidad C de Windows, pero no es la misma ubicación que /home. Microsoft detalla estas diferencias en Trabajar entre sistemas de archivos.
Puedes editar con una herramienta de terminal o con un editor conectado a WSL. Lo que debes comprobar es que el archivo que guardaste sea el que compilas. Antes de investigar una discrepancia, ejecuta pwd y ls -l: muchas veces el problema es estar en otra carpeta o haber guardado el texto con un nombre distinto.
5. Del archivo C al ejecutable
Una invocación de GCC puede coordinar varias etapas: preprocesado, compilación, ensamblado y enlace. El preprocesador resuelve directivas como #include; la compilación y el ensamblado generan código objeto; el enlace combina los objetos y las referencias a bibliotecas para formar el programa.
El comando de trabajo para depurar será:
$ gcc -std=c17 -Wall -Wextra -Wpedantic -g -O0 diagnostico_ipc.c -o diagnostico_ipc| Opción | Significado práctico |
|---|---|
| -std=c17 | Fijar el dialecto ISO C usado por estos ejemplos. |
| -Wall -Wextra | Activar conjuntos útiles de advertencias; no significa activar absolutamente todas. |
| -Wpedantic | Pedir diagnósticos relacionados con el estándar seleccionado. |
| -g | Incluir información para el depurador. |
| -O0 | Desactivar optimizaciones para facilitar el recorrido inicial del código. |
| -o diagnostico_ipc | Elegir el nombre del archivo de salida. |
Para observar la separación entre compilación y enlace puedes usar -c:
$ gcc -std=c17 -Wall -Wextra -Wpedantic -g -O0 -c diagnostico_ipc.c -o diagnostico_ipc.o
$ gcc diagnostico_ipc.o -o diagnostico_ipcUn objeto no es todavía el programa que vas a ejecutar. Si no indicas -o al construir un ejecutable, GCC suele usar a.out. Las etapas y los tipos de salida están documentados en Opciones generales de GCC; los grupos de advertencias, en Opciones de advertencia.
6. C, POSIX y extensiones de Linux
El lenguaje C define tipos, expresiones y una biblioteca estándar, pero no incluye fork, pipe o los sockets Unix como parte de ISO C. Muchas interfaces del curso pertenecen a POSIX; otras son específicas de Linux. Elegir -std=c17 no hace que una API del sistema se convierta en parte del lenguaje.
Las cabeceras pueden condicionar qué declaraciones exponen. Por eso los ejemplos que necesitan interfaces POSIX empiezan con una macro de selección, antes de cualquier inclusión:
#define _POSIX_C_SOURCE 200809L
#include <unistd.h>
#include <sys/wait.h>También se puede definir mediante -D_POSIX_C_SOURCE=200809L al compilar, pero en los programas completos la dejaremos en el fuente para que el requisito sea visible. Evita definir valores distintos en el comando y en el archivo. La letra L forma parte del literal utilizado como valor de la macro.
Para ejemplos que necesiten determinadas extensiones GNU/Linux se indicará _GNU_SOURCE. No la añadas como remedio automático a cualquier error. Consulta la sección SYNOPSIS del manual para saber qué cabecera y macros solicita una interfaz. La función de estas macros y su posición se documentan en feature_test_macros(7).
Una macro de selección controla las declaraciones disponibles durante la compilación. No instala funciones en el sistema, no cambia el núcleo y no garantiza que una operación pueda ejecutarse con los permisos y límites actuales.
7. Cabeceras y bibliotecas
Una cabecera declara tipos, constantes y prototipos. Una biblioteca aporta implementaciones que el enlazador debe poder resolver. Son problemas distintos: encontrar <mqueue.h> no demuestra por sí solo que el comando de enlace sea correcto.
| Lo que usarás | Cabeceras habituales | Observación |
|---|---|---|
| Procesos y descriptores | unistd.h, sys/wait.h, sys/types.h | fork, pipe, read, write y waitpid se enlazan normalmente mediante la biblioteca C. |
| Señales | signal.h | Consulta la macro requerida y las restricciones de cada función. |
| Memoria compartida | sys/mman.h, fcntl.h, unistd.h | shm_open, mmap y ftruncate cumplen funciones diferentes. |
| Semáforos POSIX | semaphore.h | Los ejemplos usarán -pthread durante compilación y enlace. |
| Colas POSIX | mqueue.h | Los ejemplos incluirán -lrt para entornos que la requieren. |
| Sockets | sys/socket.h, sys/un.h | AF_UNIX utiliza interfaces locales; las opciones concretas dependen de la API. |
| Errores y mensajes | errno.h, stdio.h, stdlib.h | Comprobar resultados sigue siendo necesario aunque el programa compile. |
En sistemas glibc recientes algunas funciones están integradas en libc, por lo que un enlace puede funcionar sin una opción que necesitaban otros entornos. Mantener las opciones documentadas en cada ejemplo facilita reproducirlo. Para hilos y semáforos usaremos -pthread, que es una opción del compilador y no debe sustituirse sin más por -lpthread.
$ gcc -std=c17 -Wall -Wextra -Wpedantic -pthread ejemplo_semaforos.c -o ejemplo_semaforos
$ gcc -std=c17 -Wall -Wextra -Wpedantic ejemplo_cola.c -o ejemplo_cola -lrtEstos dos archivos son nombres de ejemplo para lecciones futuras; todavía no forman parte de esta práctica. Las bibliotecas indicadas con -l se colocan después del fuente u objetos que las usan. Las opciones de enlace se describen en el manual de GCC.
8. Programa completo de diagnóstico
Guarda el siguiente código como diagnostico_ipc.c. Consulta el sistema, crea una tubería, inicia un hijo y recibe de él un byte. El padre espera y comprueba su estado antes de imprimir el informe. No crea archivos con nombre ni necesita permisos de administrador.
El programa consulta el tamaño de página y el límite PIPE_BUF de esa tubería. Este último se relaciona con garantías de atomicidad entre escritores; no es la capacidad total de la tubería. Maneja por separado el caso en que fpathconf no dé un límite y el caso de error.
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/utsname.h>
#include <sys/wait.h>
#include <unistd.h>
int main(void)
{
struct utsname sistema;
if (uname(&sistema) == -1) {
perror("uname");
return EXIT_FAILURE;
}
long pagina = sysconf(_SC_PAGESIZE);
if (pagina == -1) {
fprintf(stderr, "No se pudo consultar el tamano de pagina\n");
return EXIT_FAILURE;
}
int canal[2];
if (pipe(canal) == -1) {
perror("pipe");
return EXIT_FAILURE;
}
errno = 0;
long pipe_buf = fpathconf(canal[1], _PC_PIPE_BUF);
if (pipe_buf == -1 && errno != 0) {
perror("fpathconf");
close(canal[0]);
close(canal[1]);
return EXIT_FAILURE;
}
pid_t hijo = fork();
if (hijo == -1) {
perror("fork");
close(canal[0]);
close(canal[1]);
return EXIT_FAILURE;
}
if (hijo == 0) {
close(canal[0]);
const char marca = 'K';
ssize_t enviados;
do {
enviados = write(canal[1], &marca, 1);
} while (enviados == -1 && errno == EINTR);
if (enviados == -1)
perror("write");
close(canal[1]);
_exit(enviados == 1 ? EXIT_SUCCESS : EXIT_FAILURE);
}
close(canal[1]);
char recibido = '\0';
ssize_t leidos;
do {
leidos = read(canal[0], &recibido, 1);
} while (leidos == -1 && errno == EINTR);
if (leidos == -1)
perror("read");
close(canal[0]);
int estado;
while (waitpid(hijo, &estado, 0) == -1) {
if (errno == EINTR)
continue;
perror("waitpid");
return EXIT_FAILURE;
}
if (leidos != 1 || recibido != 'K' ||
!WIFEXITED(estado) || WEXITSTATUS(estado) != EXIT_SUCCESS) {
fprintf(stderr, "La prueba de comunicacion no se completo\n");
return EXIT_FAILURE;
}
printf("Sistema: %s\n", sistema.sysname);
printf("Nucleo: %s\n", sistema.release);
printf("Arquitectura: %s\n", sistema.machine);
printf("Nivel POSIX de las cabeceras: %ld\n", (long)_POSIX_VERSION);
printf("Tamano de pagina: %ld bytes\n", pagina);
if (pipe_buf == -1)
printf("PIPE_BUF: limite indeterminado\n");
else
printf("PIPE_BUF de esta tuberia: %ld bytes\n", pipe_buf);
printf("Padre PID: %ld; hijo PID: %ld\n", (long)getpid(), (long)hijo);
printf("Byte recibido: %c\n", recibido);
puts("Prueba IPC: OK");
return EXIT_SUCCESS;
}El hijo solo envía un byte: para esta prueba basta comprobar que write devuelva 1 y reintentar EINTR. No es una rutina general de envío de bloques; para tamaños mayores necesitas manejar transferencias parciales, como en el tema 1. El padre recoge al hijo incluso si la recepción no salió bien, evitando abandonar su estado de terminación en el camino normal de error.
Observa también que el informe se imprime después de fork y waitpid. No hay un texto pendiente en el búfer de stdout que se duplique en padre e hijo. Más adelante volveremos sobre la diferencia entre los descriptores del sistema y los búferes de la biblioteca C.
9. Compilar, ejecutar e interpretar la salida
$ gcc -std=c17 -Wall -Wextra -Wpedantic -g -O0 diagnostico_ipc.c -o diagnostico_ipc
$ ./diagnostico_ipc
Sistema: Linux
Nucleo: ... version del nucleo instalado ...
Arquitectura: x86_64
Nivel POSIX de las cabeceras: 200809
Tamano de pagina: 4096 bytes
PIPE_BUF de esta tuberia: 4096 bytes
Padre PID: 3100; hijo PID: 3101
Byte recibido: K
Prueba IPC: OK
$ echo $?
0La salida es ilustrativa: cambiarán núcleo, arquitectura, PID y posiblemente tamaños. No uses 4096 como constante universal. El nivel de las cabeceras tampoco es un inventario de todas las operaciones que el entorno permitirá ejecutar.
./ pide ejecutar el archivo de la carpeta actual. La shell no tiene por qué buscar automáticamente programas allí. Consulta $? inmediatamente después de la ejecución: otro comando reemplaza ese estado. El cero indica que el programa completó su prueba; un resultado distinto requiere revisar los mensajes de error.
$ file ./diagnostico_ipc
... ELF ... ejecutable para la arquitectura del entorno ...
$ timeout 5s ./diagnostico_ipc
$ echo $?El diagnóstico debería terminar rápidamente. Si timeout vence y termina la orden, su código habitual es 124. Eso no demuestra por sí solo qué llamada se atascó; para averiguarlo usaremos strace. Un resultado correcto aquí valida el compilador y este recorrido de procesos y tubería, pero no prueba aún colas POSIX, memoria compartida, semáforos ni sockets.
10. Automatizar con un Makefile
Para no reescribir siempre las opciones, guarda este archivo con el nombre exacto Makefile en la misma carpeta del fuente. Las líneas de receta deben empezar con un tabulador real, no con espacios.
CC = gcc
CPPFLAGS =
CFLAGS = -std=c17 -Wall -Wextra -Wpedantic -g -O0
LDFLAGS =
LDLIBS =
.PHONY: all ejecutar
all: diagnostico_ipc
diagnostico_ipc: diagnostico_ipc.c
$(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) $< -o $@ $(LDLIBS)
ejecutar: diagnostico_ipc
./diagnostico_ipc$< representa la primera dependencia y $@ el objetivo. make reconstruye si el fuente es más reciente que el ejecutable. Separar opciones de preprocesado, compilación, enlace y bibliotecas ayuda a mantener el comando cuando aparezcan otros ejemplos.
$ make
$ make ejecutar
$ make -B CFLAGS='-std=c17 -Wall -Wextra -Wpedantic -O2'-B fuerza la reconstrucción. Es útil al cambiar opciones, porque este Makefile mínimo no registra por sí solo cambios en las variables del comando como una dependencia. Para volver al perfil de depuración ejecuta make -B. No compares rendimiento usando inadvertidamente un binario de otra configuración.
11. Observar con strace y GDB
strace: mirar el diálogo con el núcleo
Cuando un programa parece no avanzar, interesa saber si está esperando una lectura, escribiendo o recogiendo un hijo. strace registra llamadas al sistema. La opción -f sigue los procesos creados, por lo que puedes ver también lo que hace el hijo.
$ strace -f -o traza.log ./diagnostico_ipc
$ less traza.logBusca la creación de la tubería, la creación del hijo, el envío de K, la recepción y la espera. No todas las funciones C aparecen con su mismo nombre: la biblioteca puede implementar fork mediante clone y pipe mediante pipe2. El orden visible entre procesos también depende de la planificación.
El archivo incluye otras llamadas necesarias para cargar el programa y sus bibliotecas. Una lectura al comienzo de la traza no tiene por qué pertenecer a tu tubería. Relaciona PID, descriptores y resultados en lugar de buscar una única línea aislada. El formato de salida y las opciones se describen en strace(1).
GDB: recorrer el código C
Recompila con -g -O0 si cambiaste el perfil. Abre el ejecutable, coloca un punto de parada en main y avanza por las líneas:
$ gdb ./diagnostico_ipc
(gdb) break main
(gdb) run
(gdb) list
(gdb) next
(gdb) info locals
(gdb) continue
(gdb) quitRepite next según lo que quieras observar y consulta solo valores que ya se hayan inicializado. Una variable automática sin inicializar puede aparecer en info locals, pero eso no la convierte en un resultado válido.
Por defecto GDB sigue al padre cuando hay fork. Para una sesión distinta puedes seleccionar set follow-fork-mode child antes de run. En los ejemplos con comunicación, detener uno de los procesos puede hacer que el otro espere legítimamente. El manual de GDB sobre procesos creados con fork explica estas opciones.
Si el entorno restringe el trazado, strace o GDB pueden fallar aunque el ejecutable funcione. Eso es distinto de un error de C; revisa las políticas del entorno, especialmente en contenedores. No uses una traza instrumentada como medición del rendimiento normal: observar cada llamada añade trabajo y altera tiempos.
12. Comprobar errores de memoria
Los errores de memoria pueden confundirse con fallos del protocolo: un búfer desbordado corrompe un tamaño, una cadena sin terminador imprime bytes ajenos o un puntero inválido hace caer al receptor. GCC permite instrumentar el código para detectar parte de estos problemas.
$ gcc -std=c17 -Wall -Wextra -Wpedantic -g -O1 -fno-omit-frame-pointer -fsanitize=address,undefined diagnostico_ipc.c -o diagnostico_ipc_san
$ ./diagnostico_ipc_sanAddressSanitizer comprueba diversas clases de acceso incorrecto a memoria; UndefinedBehaviorSanitizer añade comprobaciones para ciertas operaciones con comportamiento indefinido. No prueban que el algoritmo sea correcto, no verifican que hayas cerrado todos los descriptores y no resuelven interbloqueos o carreras entre procesos.
Si compilas por separado, las opciones de instrumentación necesarias deben estar también en el enlace. Las bibliotecas de soporte deben existir en el entorno. Las opciones y sus límites están documentados en Instrumentación de GCC. Mantén el binario instrumentado separado del que usarías para medir rendimiento.
13. Resolver errores habituales
Lee el primer diagnóstico relevante y comprueba en qué etapa se produjo. Una cascada de mensajes puede ser consecuencia de una sola cabecera faltante o de una llave mal colocada.
| Síntoma | Qué comprobar | Cómo avanzar |
|---|---|---|
| gcc: command not found | Terminal, distribución y herramientas instaladas. | Ejecutar command -v gcc dentro de Linux e instalar los paquetes correspondientes. |
| Fuente no encontrado | Carpeta, nombre, mayúsculas y extensión real. | Consultar pwd y ls -l; confirmar que no se guardó como archivo .txt. |
| Una cabecera POSIX no existe | Cadena de compilación y cabeceras de desarrollo. | Confirmar que no se está usando un compilador Windows nativo por error. |
| Declaración implícita de una función | Cabecera y macro de selección antes de los includes. | Leer SYNOPSIS; no ocultar la advertencia inventando un prototipo. |
| undefined reference | Nombre, objetos incluidos y opciones de enlace. | Revisar la biblioteca necesaria y su posición, sin confundirla con una cabecera. |
| Permission denied al ejecutar | Permisos del archivo y opciones del sistema de archivos. | Consultar ls -l y trabajar en una carpeta Linux apropiada; sudo no corrige por sí solo un montaje noexec. |
| Exec format error | Tipo de archivo y arquitectura. | Consultar file; no ejecutar el objeto .o ni un binario para otro sistema. |
| No such file or directory con un binario que existe | Ruta y, si corresponde, cargador o bibliotecas del binario. | Comprobar file y reconstruir con las herramientas del entorno actual. |
| make informa missing separator | Tabuladores en las recetas. | Sustituir la indentación de esas líneas por un tabulador real. |
| Se sigue ejecutando una versión vieja | Resultado de la compilación y ubicación del binario. | No ejecutar tras una compilación fallida; usar gcc ... && ./programa. |
| El programa no termina | Lecturas bloqueadas, extremos abiertos y orden de espera. | Limitar la prueba con timeout y observarla con strace -f. |
Un editor puede guardar finales de línea CRLF al trabajar entre sistemas. En scripts y Makefiles esto puede causar errores difíciles de reconocer. Configura LF; no supongas que todo error de compilación de un archivo C se debe a ese detalle, porque GCC puede aceptar algunos finales de línea sin problemas.
Para evitar ejecutar por accidente un binario anterior, vincula las acciones con && cuando lo hagas manualmente: la segunda solo se ejecuta si la primera tiene éxito. En cambio, una línea nueva no impide que lances un archivo viejo después de un fallo.
14. Constructor de comandos y comprobación final
Selecciona el tipo de ejemplo y el perfil para ver qué cambia en el comando. El constructor solo genera texto: no ejecuta órdenes ni detecta herramientas de tu equipo. Los nombres de semáforos y colas representan fuentes de futuras lecciones; para esta práctica selecciona el diagnóstico.
gcc -std=c17 -Wall -Wextra -Wpedantic -g -O0 diagnostico_ipc.c -o diagnostico_ipcEl diagnóstico utiliza la biblioteca C. El perfil de depuración facilita recorrer el programa en GDB.
Marca las comprobaciones después de realizarlas en la terminal. La lista es una autoevaluación de esta página; no sustituye la ejecución de los comandos ni se guarda al recargar.
0 de 7 comprobaciones marcadas.
Con esto ya puedes reproducir los ejemplos y reunir evidencia cuando algo falla: fuente, comando exacto, salida del compilador, estado de terminación y una traza cuando haga falta. En el tema 4 usarás este entorno para estudiar procesos, descriptores y herencia.
15. Resumen
- El curso usa Linux; WSL 2 permite trabajar desde Windows dentro de una distribución Linux.
- Editor, compilador y entorno de ejecución cumplen funciones diferentes.
- GCC coordina etapas que van del fuente al objeto y al ejecutable.
- Las advertencias y la información de depuración ayudan a encontrar problemas antes de medir rendimiento.
- Las macros POSIX se definen antes de las cabeceras; no instalan funciones ni garantizan permisos.
- Una declaración de cabecera y una implementación enlazada son requisitos distintos.
- El diagnóstico valida un intercambio concreto; no certifica todas las funciones de IPC del entorno.
- make automatiza la construcción; strace y GDB permiten observar niveles diferentes de la ejecución.
- La instrumentación de memoria ayuda a encontrar errores, pero no demuestra corrección del protocolo.
16. Preguntas de repaso y práctica
Intenta responder antes de abrir la explicación.
1. ¿Por qué instalar un editor no basta para ejecutar fork?
Porque fork es una interfaz del entorno de ejecución y sus bibliotecas. El editor solo modifica texto; necesitas una cadena de compilación y un sistema compatibles con el ejemplo.
2. ¿Dónde se ejecuta sudo apt si usas Windows con WSL?
Dentro de la terminal de la distribución Linux que utiliza apt. La instalación inicial de WSL se realiza desde Windows con los comandos correspondientes.
3. ¿Qué diferencia hay entre -c y construir un ejecutable?
-c produce código objeto sin realizar el enlace final. Para ejecutar el programa hay que enlazar el objeto y resolver sus referencias necesarias.
4. ¿-Wall activa todas las advertencias posibles?
No. Activa un conjunto de advertencias útiles. -Wextra añade otras; las opciones concretas se consultan en el manual de GCC.
5. ¿Por qué _POSIX_C_SOURCE aparece antes de los includes?
Porque controla qué declaraciones exponen las cabeceras al procesarlas. Una cabecera puede incluir a otras, de modo que definirla después puede llegar demasiado tarde.
6. ¿Una macro POSIX garantiza que todas las operaciones funcionarán?
No. No cambia el sistema de ejecución ni sus límites, permisos o configuración. Una operación declarada y enlazada puede fallar al ejecutarse y requiere comprobar su resultado.
7. ¿Qué diferencia hay entre una cabecera faltante y undefined reference?
La primera impide disponer de declaraciones durante la construcción. Una referencia no resuelta aparece en el enlace cuando no se encuentra una implementación necesaria entre los objetos y bibliotecas utilizados.
8. ¿PIPE_BUF es el tamaño total del canal?
No. Se relaciona con garantías de atomicidad de ciertas escrituras. La capacidad de almacenamiento de la tubería es otra propiedad.
9. ¿Por qué se comprueba errno cuando fpathconf devuelve -1?
Porque -1 puede señalar un error o que no se obtiene un límite definido. Poner errno en cero antes permite distinguir esos casos según el contrato de la función.
10. ¿Qué certifica Prueba IPC: OK?
Que este programa pudo realizar sus consultas y completar el recorrido de tubería, hijo, recepción y espera. No certifica colas, semáforos ni todas las capacidades del sistema.
11. ¿Por qué usar strace -f y no solo strace?
Para seguir también los procesos creados y ver las operaciones del hijo, además de las del proceso inicial.
12. ¿Por qué forzar make al cambiar las opciones?
El Makefile mínimo compara archivos y dependencias, pero no registra los cambios de variables del comando. -B permite reconstruir incluso si el fuente no cambió.
Para practicar
- Guarda las versiones de GCC y make, el resultado de uname -s y la ruta de trabajo. Úsalos como registro del entorno de tus prácticas.
- Construye el diagnóstico en un paso y después con -c y un enlace separado. Comprueba con file la diferencia entre el objeto y el ejecutable.
- Cambia el byte K por otra letra tanto en el emisor como en la validación. Reconstruye y verifica el resultado. Después cambia solo uno para observar el fallo controlado y el estado distinto de cero.
- Ejecuta el diagnóstico varias veces y compara los PID. Explica por qué no deben estar fijados en una prueba.
- Ejecuta make dos veces sin cambios y observa qué reconstruye. Modifica el fuente, repite y compara con make -B.
- Registra una traza con -f. Identifica los dos procesos, los extremos del canal, el byte enviado y la espera de terminación.
- Construye una variante con sanitizers y comprueba que el diagnóstico termina correctamente. Explica por qué eso no demuestra que cualquier programa de IPC carezca de carreras o interbloqueos.
- Escribe un informe de fallo reproducible: carpeta, fuente, comando de construcción, diagnóstico y resultado. Distingue qué parte es un error de compilación, enlace o ejecución.