← Comunicación entre Procesos Bloque 1 · Fundamentos y entorno de trabajo · Tema 3 de 52

Tema 3

Preparar los ejemplos en C sobre Linux

Antes de profundizar en señales, tuberías y memoria compartida, necesitas un entorno donde los ejemplos se puedan compilar, ejecutar y observar. Prepararás Linux o WSL, instalarás GCC y herramientas de diagnóstico, entenderás las opciones de compilación y comprobarás el conjunto con un programa que crea un hijo y le recibe un byte. También aprenderás a distinguir un error del código de un problema de cabeceras, enlace o ejecución.

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:

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.

Una ruta de trabajo sencilla

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.

PowerShell · instalación inicial de WSL
PS> wsl --install

Si 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:

PowerShell · consultar e iniciar la distribución
PS> wsl --list --verbose
PS> wsl --list --online
PS> wsl --install -d Ubuntu
PS> wsl -d Ubuntu

El 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.

Bash · comprobar que estás dentro de Linux
$ 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.

Bash · paquetes para el curso en Ubuntu o Debian
$ sudo apt update
$ sudo apt install build-essential man-db manpages-dev gdb strace file
Herramienta o paquetePara qué lo usarás
build-essentialInstalar el conjunto básico para compilar, incluidas las herramientas de construcción y cabeceras de desarrollo necesarias.
gccTraducir código C y coordinar el enlace del ejecutable.
makeReconstruir un programa a partir de reglas y dependencias.
man-db y manpages-devConsultar funciones y llamadas del sistema desde la terminal.
gdbDetener el programa, consultar variables y recorrer su ejecución.
straceObservar llamadas al sistema, argumentos y resultados.
fileIdentificar qué tipo de ejecutable se generó.

Comprueba el resultado sin asumir una versión fija:

Bash · verificar las herramientas disponibles
$ command -v gcc make gdb strace file
$ gcc --version
$ make --version
$ man 2 pipe

En 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:

Bash · carpeta de esta lección
$ mkdir -p ~/cursos/ipc/tema03
$ cd ~/cursos/ipc/tema03
$ pwd
/home/tu_usuario/cursos/ipc/tema03

Guarda 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.

Del fuente al programaEl fuente C y sus cabeceras pasan por preprocesado y compilación para formar un objeto. El enlace añade las referencias necesarias a bibliotecas y produce el ejecutable. Fuente .c+ cabecerasObjeto .oEjecutable Preprocesar y compilar → ensamblar → enlazar
Un diagnóstico de compilación no es el mismo problema que un error de enlace o un fallo al ejecutar.

El comando de trabajo para depurar será:

Bash · construcción con información de depuración
$ gcc -std=c17 -Wall -Wextra -Wpedantic -g -O0 diagnostico_ipc.c -o diagnostico_ipc
OpciónSignificado práctico
-std=c17Fijar el dialecto ISO C usado por estos ejemplos.
-Wall -WextraActivar conjuntos útiles de advertencias; no significa activar absolutamente todas.
-WpedanticPedir diagnósticos relacionados con el estándar seleccionado.
-gIncluir información para el depurador.
-O0Desactivar optimizaciones para facilitar el recorrido inicial del código.
-o diagnostico_ipcElegir el nombre del archivo de salida.

Para observar la separación entre compilación y enlace puedes usar -c:

Bash · construir en dos pasos
$ gcc -std=c17 -Wall -Wextra -Wpedantic -g -O0 -c diagnostico_ipc.c -o diagnostico_ipc.o
$ gcc diagnostico_ipc.o -o diagnostico_ipc

Un 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:

al principio de un fuente que usa POSIX
#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ásCabeceras habitualesObservación
Procesos y descriptoresunistd.h, sys/wait.h, sys/types.hfork, pipe, read, write y waitpid se enlazan normalmente mediante la biblioteca C.
Señalessignal.hConsulta la macro requerida y las restricciones de cada función.
Memoria compartidasys/mman.h, fcntl.h, unistd.hshm_open, mmap y ftruncate cumplen funciones diferentes.
Semáforos POSIXsemaphore.hLos ejemplos usarán -pthread durante compilación y enlace.
Colas POSIXmqueue.hLos ejemplos incluirán -lrt para entornos que la requieren.
Socketssys/socket.h, sys/un.hAF_UNIX utiliza interfaces locales; las opciones concretas dependen de la API.
Errores y mensajeserrno.h, stdio.h, stdlib.hComprobar 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.

Bash · comandos orientativos para ejemplos posteriores
$ 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 -lrt

Estos 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.

diagnostico_ipc.c · comprobar compilación y un intercambio entre procesos
#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

Bash · construir y comprobar el diagnóstico
$ 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 $?
0

La 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.

Bash · identificar el binario y limitar una ejecución de prueba
$ 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.

Makefile · construir y ejecutar el diagnóstico
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.

Bash · usar las reglas
$ 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.

Bash · registrar la ejecución completa
$ strace -f -o traza.log ./diagnostico_ipc
$ less traza.log

Busca 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:

sesión de GDB · comandos dentro del depurador
$ gdb ./diagnostico_ipc
(gdb) break main
(gdb) run
(gdb) list
(gdb) next
(gdb) info locals
(gdb) continue
(gdb) quit

Repite 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.

Bash · construir una variante con comprobaciones
$ gcc -std=c17 -Wall -Wextra -Wpedantic -g -O1 -fno-omit-frame-pointer -fsanitize=address,undefined diagnostico_ipc.c -o diagnostico_ipc_san
$ ./diagnostico_ipc_san

AddressSanitizer 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íntomaQué comprobarCómo avanzar
gcc: command not foundTerminal, distribución y herramientas instaladas.Ejecutar command -v gcc dentro de Linux e instalar los paquetes correspondientes.
Fuente no encontradoCarpeta, nombre, mayúsculas y extensión real.Consultar pwd y ls -l; confirmar que no se guardó como archivo .txt.
Una cabecera POSIX no existeCadena 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ónCabecera y macro de selección antes de los includes.Leer SYNOPSIS; no ocultar la advertencia inventando un prototipo.
undefined referenceNombre, objetos incluidos y opciones de enlace.Revisar la biblioteca necesaria y su posición, sin confundirla con una cabecera.
Permission denied al ejecutarPermisos 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 errorTipo 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 existeRuta y, si corresponde, cargador o bibliotecas del binario.Comprobar file y reconstruir con las herramientas del entorno actual.
make informa missing separatorTabuladores en las recetas.Sustituir la indentación de esas líneas por un tabulador real.
Se sigue ejecutando una versión viejaResultado de la compilación y ubicación del binario.No ejecutar tras una compilación fallida; usar gcc ... && ./programa.
El programa no terminaLecturas 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.

comando generado · ejecutar desde Bash
gcc -std=c17 -Wall -Wextra -Wpedantic -g -O0 diagnostico_ipc.c -o diagnostico_ipc

El 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

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

  1. 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.
  2. 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.
  3. 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.
  4. Ejecuta el diagnóstico varias veces y compara los PID. Explica por qué no deben estar fijados en una prueba.
  5. Ejecuta make dos veces sin cambios y observa qué reconstruye. Modifica el fuente, repite y compara con make -B.
  6. Registra una traza con -f. Identifica los dos procesos, los extremos del canal, el byte enviado y la espera de terminación.
  7. 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.
  8. 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.