← Comunicación entre ProcesosBloque 6 · Memoria compartida · Tema 24 de 52

Tema 24

Memoria compartida POSIX con shm_open

En el tema anterior compartiste una región heredada después de fork. Ahora vas a darle un nombre para que puedan encontrarla programas independientes. Aprenderás a crear el objeto, establecer su tamaño, mapearlo y retirar cada recurso en el momento adecuado. Los ejemplos permitirán observar por qué cerrar un descriptor, retirar un mapeo y eliminar un nombre son tres operaciones diferentes.

1. Nombre, objeto, descriptor y mapeo

La región anónima del tema 23 se creaba antes de fork. El hijo podía utilizarla porque heredaba una vista de ese recurso. Un programa lanzado después desde otra terminal no tenía un nombre de aplicación con el que localizarla.

La memoria compartida POSIX añade esa posibilidad de conexión. El creador utiliza un nombre, por ejemplo /ipc24_demo, y otro proceso abre ese mismo nombre. Después, cada uno mapea el objeto en su propio espacio virtual.

El nombre permite localizar un objeto. shm_open devuelve un descriptor que lo referencia. mmap crea una vista de memoria del objeto dentro de un proceso.

Un nombre, un objeto y dos mapeos independientesEl nombre ipc24_demo localiza un objeto de memoria compartida. Un creador y un lector poseen mapeos del mismo objeto en sus espacios virtuales. Los descriptores se utilizan al conectar y pueden cerrarse después de mapear. Nombre: /ipc24_demoObjeto compartidotamaño y contenidoindependientes del nombreCreadormmap de escrituradirección ALectormmap de lecturadirección B
Las direcciones A y B pueden ser distintas. La conexión se establece mediante el objeto, no haciendo coincidir punteros.
RecursoCómo se obtieneCómo se deja de utilizar
Nombre público.shm_open con creación exclusiva.shm_unlink retira ese nombre.
Descriptor de archivo.Retorno entero de shm_open.close cierra esa referencia.
Mapeo del proceso.mmap sobre el descriptor.munmap retira ese rango virtual.
Almacenamiento del objeto.Objeto creado y dimensionado.Se libera cuando ya no tiene nombre ni referencias que lo mantengan vivo.

Un objeto puede continuar disponible por su nombre aunque el creador haya terminado. También puede seguir siendo usado mediante mapeos antiguos después de que el nombre desaparezca. Esta separación será el centro de los laboratorios.

2. Crear y abrir con shm_open

interfaces · sys/mman.h, fcntl.h, sys/stat.h y unistd.h
int shm_open(const char *nombre, int flags, mode_t permisos);
int shm_unlink(const char *nombre);
int ftruncate(int fd, off_t longitud);
int close(int fd);

shm_open retorna un descriptor mayor o igual a cero al tener éxito y −1 al fallar. No devuelve una dirección ni un identificador de cola. Los errores de shm_open y shm_unlink se informan mediante errno, según shm_open(3).

fragmentos · roles distintos de creador y lector
/* Creador: debe obtener un objeto nuevo. */
int fd = shm_open("/ipc24_demo", O_CREAT | O_EXCL | O_RDWR, 0600);

/* Lector: exige que el objeto ya exista. */
int fd_lector = shm_open("/ipc24_demo", O_RDONLY, 0);

El creador combina O_CREAT y O_EXCL. Si el nombre existe, obtiene EEXIST y no adopta su contenido. El lector no usa O_CREAT: si falta el recurso, debe recibir ENOENT en lugar de crear accidentalmente un objeto vacío.

Utiliza O_RDWR para la creación y el dimensionado. O_RDONLY permite conectar un lector con un mapeo de solo lectura. No traslades automáticamente las combinaciones de flags de una FIFO, una cola de mensajes o un archivo regular a este recurso.

Evita especialmente O_TRUNC al conectar un participante. Su intención es truncar el objeto y puede destruir un estado que otros están usando. Tampoco intentes arreglar una colisión borrando primero cualquier nombre que ya exista: el proceso que falló con EEXIST no adquirió la propiedad de ese recurso.

3. Nombres, permisos y umask

Usaremos un nombre corto con una barra inicial y sin barras internas. No se pasa /dev/shm/ipc24_demo a shm_open. La ruta visible en Linux es una representación de la implementación; el identificador de la API será /ipc24_demo.

Los ejemplos aceptan únicamente nombres que comiencen por /ipc24_ y continúen con letras ASCII, cifras, guion o guion bajo, hasta 80 caracteres en total. Es una política del laboratorio para reconocer nuestros objetos, no el límite general que impone POSIX.

El modo 0600 solicita lectura y escritura para el propietario. La máscara umask puede quitar permisos al crear el objeto. Si ejecutas todos los comandos con el mismo usuario y una máscara habitual, ese modo resulta suficiente para las pruebas sin publicar datos para otros usuarios.

Bash · inspeccionar la máscara y elegir un nombre de laboratorio
$ umask
0022
$ nombre="/ipc24_$$_demo"
$ printf '%s\n' "$nombre"
/ipc24_..._demo

El número generado por $$ ayuda a evitar colisiones entre sesiones. No es un secreto ni una garantía contra un tercero que pueda adivinar el nombre. En un servicio real, los permisos, el espacio de nombres y la política de administración forman parte del diseño.

La cuenta del creador y la del lector deben tener permisos compatibles. Compartir el nombre por un mensaje no concede automáticamente acceso. Ante EACCES, revisa la identidad efectiva y los permisos en lugar de ampliar a 0666 sin analizar quién debe poder conectarse.

4. Dimensionar con ftruncate

Un objeto recién creado comienza con tamaño cero. Obtener su descriptor todavía no reserva una región utilizable del tamaño de tu estructura. Antes de mapear y acceder a sus datos, el creador debe establecer la longitud prevista.

fragmento · dimensionar solo el objeto nuevo del creador
size_t bytes = sizeof(struct datos);
if (ftruncate(fd, (off_t)bytes) == -1) {
    perror("ftruncate");
    /* Cerrar el descriptor y retirar el nombre recien creado. */
}

El argumento es un tamaño final, no una cantidad de bytes que se añade. Reducir la longitud elimina contenido; aumentarla extiende el objeto. La función requiere un descriptor abierto para escritura y devuelve cero o −1, según ftruncate(2).

En el código completo el objeto es pequeño y fijo. Para tamaños externos debes comprobar límites, desbordamientos de multiplicación y representabilidad en off_t antes de convertir. Un cast no convierte un tamaño imposible en una reserva correcta.

La longitud del objeto y la longitud de un mapeo son decisiones relacionadas, pero distintas. No confíes en que mmap rechace todos los rangos que superan el respaldo: un acceso posterior fuera de la parte válida puede terminar en SIGBUS. El lector comprobará el tamaño antes de mapear.

El lector tampoco llama a ftruncate «por seguridad». Abrir un recurso existente no autoriza a redimensionarlo. Mientras existan lectores, el contrato de este tema prohíbe cambiar la longitud del objeto.

5. Mapear y cerrar el descriptor

fragmento · descriptor válido y tamaño ya establecido
struct datos *p = mmap(NULL, bytes, PROT_READ | PROT_WRITE,
                       MAP_SHARED, fd, 0);
if (p == MAP_FAILED) {
    perror("mmap");
    /* No acceder a p. */
}
/* Tras un mmap exitoso puede cerrarse fd y conservarse p. */

Aquí no se agrega MAP_ANONYMOUS: el respaldo es el objeto abierto con shm_open. El descriptor es el enlace que permite obtener una vista del objeto. Utilizamos desplazamiento cero y MAP_SHARED, como establece el contrato de mmap(2).

Después del mapeo, close no invalida la vista. Puedes conservar solamente la dirección y su longitud para acceder y llamar luego a munmap. Esta es la política de los ejemplos: cerrar pronto el descriptor y mantener únicamente las vistas necesarias.

El creador necesita lectura y escritura. El lector combina O_RDONLY con PROT_READ y MAP_SHARED. La protección local le impide modificar la región desde esa vista; no garantiza que otro proceso autorizado no la modifique.

Un lector y un creador pueden obtener direcciones distintas para el mismo objeto. Por eso la estructura del ejemplo contiene un array interno de caracteres y valores, sin punteros nativos que otro proceso deba interpretar.

6. Conectar un lector sin modificar el objeto

El lector abre el nombre, consulta fstat y exige exactamente el tamaño del contrato. Solo después solicita un mapeo de lectura. Una vez conectado, valida los campos antes de usar la longitud y el texto.

secuencia · comprobaciones previas y posteriores al mapeo
shm_open(nombre, O_RDONLY, 0)
    -> fstat: longitud externa esperada
    -> mmap: vista local de solo lectura
    -> close: el descriptor ya no es necesario
    -> validar marca, version y longitud interna
    -> consumir el texto acotado
    -> munmap

La longitud externa evita interpretar un objeto de otro tamaño. La longitud interna evita leer fuera del array. Son dos controles distintos: un objeto puede tener el tamaño correcto y contener un formato inválido.

Comprobar fstat no congela el recurso. Si otro participante lo trunca después, la comprobación anterior no impide el fallo. En el laboratorio existe una regla explícita: una vez inicializado, ese objeto no se redimensiona ni se modifica.

La marca y la versión detectan algunas equivocaciones de formato; no autentican al creador ni resuelven una publicación concurrente. El tema 25 profundizará en distribución, offsets, versiones e inicialización para procesos independientes.

7. La existencia del nombre no indica que esté listo

O_CREAT | O_EXCL elige un único creador para ese nombre. No vuelve atómica la secuencia completa de dimensionar, mapear e inicializar. Otro proceso puede localizar el nombre cuando el tamaño todavía es cero o cuando los datos aún no se escribieron.

intervalo de inicialización · una conexión puede llegar demasiado pronto
CREADOR                            LECTOR PREMATURO
shm_open: aparece el nombre
                                   shm_open: ya puede encontrarlo
ftruncate: establece el tamano
mmap
escribir cabecera y texto
terminar con exito
                                   No basta haber encontrado el nombre.

El tamaño correcto demuestra una dimensión, no una inicialización completa. Una bandera ordinaria escrita al final tampoco constituye por sí sola un mecanismo de publicación entre procesos.

Para aislar el ciclo de vida del recurso, el ejemplo utiliza una publicación por fases controlada desde la shell: primero se ejecuta el creador y se comprueba su éxito; después se lanza el lector. Durante la lectura, los datos permanecen inmutables.

No se lanza el creador con & para conectar inmediatamente al lector, ni se inserta sleep esperando acertar una demora. Si más adelante ambos deben arrancar concurrentemente, habrá que añadir un canal de control o un mecanismo de sincronización con reglas de inicialización propias.

En los temas de semáforos estudiaremos cómo permitir que procesos vivos esperen una condición del protocolo. Aquí no usaremos volatile ni sondeo de una variable para ocultar esa necesidad.

8. Contrato del ejemplo entre programas independientes

Una sola herramienta ofrecerá tres operaciones. Cada invocación es un proceso independiente, sin parentesco necesario con las demás.

ComandoResponsabilidadEstado que deja
crear nombre texto.Crea exclusivamente, dimensiona e inicializa.Objeto con nombre; sin descriptores ni mapeos del creador.
leer nombre.Abre, valida y muestra un texto inmutable.No cambia el contenido ni retira el nombre.
leer nombre esperar.Prepara la vista y espera Enter antes de consumirla.Permite observar una vista que sobrevive al nombre.
retirar nombre.Retira explícitamente el nombre del laboratorio.Impide nuevas aperturas por ese nombre.

El texto acepta de cero a 159 bytes. Una cadena UTF-8 puede usar varios bytes por carácter; el límite se aplica a bytes, no a letras visibles. La estructura incluye una marca fija, versión, longitud y un array de 160 bytes con terminador NUL.

Los programas del ejemplo se compilan en el mismo sistema con la misma definición de estructura. No se presenta este layout nativo como un formato universal o persistente. Ningún campo contiene direcciones de la pila, del heap ni de otro proceso.

La administración es serial: no hay un tercero que retire, reemplace, trunque o modifique el objeto durante la creación. En los laboratorios posteriores sí retiraremos un nombre con un lector conectado, manteniendo inmutable el objeto antiguo.

El creador limpia el nombre si falla después de haberlo creado. Ante EEXIST no lo borra. La operación retirar es una acción explícita del responsable del laboratorio, distinta de la limpieza de un lector.

9. Programa completo: crear, leer y retirar

Guarda este archivo como shm24.c. El código comprueba retornos, conserva la propiedad de creación y valida el tamaño antes de acceder a los campos. El lector puede cerrar su descriptor y mantener la vista durante la pausa de inspección.

shm24.c · herramienta de memoria compartida con datos inmutables
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <fcntl.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>

#define MARCA UINT32_C(0x49504324)
#define VERSION UINT32_C(1)

struct datos {
    uint32_t marca;
    uint32_t version;
    uint32_t longitud;
    char texto[160];
};

static int nombre_valido(const char *s)
{
    size_t n = strlen(s);
    if (n <= 7 || n > 80 || strncmp(s, "/ipc24_", 7) != 0) return 0;
    for (size_t i = 7; i < n; ++i) {
        unsigned char c = (unsigned char)s[i];
        if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
              (c >= '0' && c <= '9') || c == '_' || c == '-')) return 0;
    }
    return 1;
}

static int crear(const char *nombre, const char *texto)
{
    size_t n = strlen(texto);
    if (n >= sizeof(((struct datos *)0)->texto)) {
        fprintf(stderr, "Texto demasiado largo: maximo 159 bytes\n");
        return EXIT_FAILURE;
    }
    int fd = shm_open(nombre, O_CREAT | O_EXCL | O_RDWR, 0600);
    if (fd == -1) {
        perror("shm_open crear");
        return EXIT_FAILURE; /* No hemos creado ni adoptado el objeto. */
    }
    int salida = EXIT_FAILURE;
    size_t bytes = sizeof(struct datos);
    struct datos *p = MAP_FAILED;
    if (ftruncate(fd, (off_t)bytes) == -1) {
        perror("ftruncate");
        goto fin;
    }
    p = mmap(NULL, bytes, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (p == MAP_FAILED) {
        perror("mmap crear");
        goto fin;
    }
    /* No hay lectores concurrentes durante esta inicializacion. */
    memset(p, 0, bytes);
    p->marca = MARCA;
    p->version = VERSION;
    p->longitud = (uint32_t)n;
    memcpy(p->texto, texto, n + 1);
    salida = EXIT_SUCCESS;

fin:
    if (p != MAP_FAILED && munmap(p, bytes) == -1) {
        perror("munmap crear");
        salida = EXIT_FAILURE;
    }
    if (close(fd) == -1) {
        perror("close crear");
        salida = EXIT_FAILURE;
    }
    if (salida != EXIT_SUCCESS) {
        if (shm_unlink(nombre) == -1) perror("shm_unlink tras fallo");
    } else {
        printf("Creado %s: %zu bytes; texto de %zu bytes\n", nombre, bytes, n);
    }
    return salida;
}

static int leer(const char *nombre, int pausar)
{
    int fd = shm_open(nombre, O_RDONLY, 0);
    if (fd == -1) {
        perror("shm_open leer");
        return EXIT_FAILURE;
    }
    int salida = EXIT_FAILURE;
    size_t bytes = sizeof(struct datos);
    const struct datos *p = MAP_FAILED;
    struct stat st;
    if (fstat(fd, &st) == -1) {
        perror("fstat");
        goto fin;
    }
    if (st.st_size != (off_t)bytes) {
        fprintf(stderr, "Tamano incompatible; esperado: %zu bytes\n", bytes);
        goto fin;
    }
    p = mmap(NULL, bytes, PROT_READ, MAP_SHARED, fd, 0);
    if (p == MAP_FAILED) {
        perror("mmap leer");
        goto fin;
    }
    /* En Linux no se reintenta close sobre un fd posiblemente liberado. */
    int cierre = close(fd);
    fd = -1;
    if (cierre == -1) {
        perror("close leer");
        goto fin;
    }
    if (pausar) {
        printf("Mapeo preparado; descriptor cerrado. Pulsa Enter para leer.\n");
        fflush(stdout);
        if (getchar() == EOF) {
            fprintf(stderr, "No se recibio entrada para continuar\n");
            goto fin;
        }
    }
    /* El contrato impide escrituras y truncamientos concurrentes. */
    if (p->marca != MARCA || p->version != VERSION ||
        p->longitud >= sizeof p->texto || p->texto[p->longitud] != '\0') {
        fprintf(stderr, "Formato incompatible\n");
        goto fin;
    }
    if (printf("Texto (%u bytes): ", (unsigned)p->longitud) < 0 ||
        fwrite(p->texto, 1, p->longitud, stdout) != p->longitud ||
        putchar('\n') == EOF || fflush(stdout) == EOF) {
        fprintf(stderr, "Error al escribir la salida\n");
        goto fin;
    }
    salida = EXIT_SUCCESS;

fin:
    if (p != MAP_FAILED && munmap((void *)p, bytes) == -1) {
        perror("munmap leer");
        salida = EXIT_FAILURE;
    }
    if (fd != -1 && close(fd) == -1) {
        perror("close leer al limpiar");
        salida = EXIT_FAILURE;
    }
    return salida; /* El lector nunca retira el nombre. */
}

int main(int argc, char **argv)
{
    if (argc < 3 || !nombre_valido(argv[2])) goto uso;
    if (strcmp(argv[1], "crear") == 0 && argc == 4)
        return crear(argv[2], argv[3]);
    if (strcmp(argv[1], "leer") == 0 &&
        (argc == 3 || (argc == 4 && strcmp(argv[3], "esperar") == 0)))
        return leer(argv[2], argc == 4);
    if (strcmp(argv[1], "retirar") == 0 && argc == 3) {
        if (shm_unlink(argv[2]) == -1) {
            perror("shm_unlink retirar");
            return EXIT_FAILURE;
        }
        printf("Nombre retirado: %s\n", argv[2]);
        return EXIT_SUCCESS;
    }
uso:
    fprintf(stderr, "Uso: %s crear /ipc24_nombre texto\n"
                    "     %s leer /ipc24_nombre [esperar]\n"
                    "     %s retirar /ipc24_nombre\n", argv[0], argv[0], argv[0]);
    return EXIT_FAILURE;
}

La expresión con sizeof usada para consultar la capacidad del array no desreferencia el puntero nulo: sizeof no evalúa ese operando. La comprobación se hace antes de crear cualquier recurso, de modo que una entrada demasiado larga no deja un objeto vacío.

El cortocircuito de || evita indexar texto con una longitud fuera de rango. El lector usa fwrite con longitud explícita y no confía solamente en imprimir una cadena sin comprobar sus límites.

En la ruta de creación, el descriptor se conserva hasta la limpieza común para simplificar las salidas de error. En el lector se cierra inmediatamente después de mapear, lo que permite demostrar que la vista sigue viva sin él.

10. Compilar y ejecutar las operaciones

Compila dentro de Linux o de tu distribución Linux en WSL. Los ejemplos usan la API POSIX; un compilador que genere ejecutables nativos de Windows no proporciona automáticamente estas funciones.

Bash · crear antes de lanzar el lector
$ gcc -std=c17 -O2 -Wall -Wextra -Wpedantic shm24.c -o shm24 -lrt
$ nombre="/ipc24_$$_demo"
$ ./shm24 crear "$nombre" "hola desde memoria compartida" && ./shm24 leer "$nombre"
Creado /ipc24_..._demo: ... bytes; texto de 29 bytes
Texto (29 bytes): hola desde memoria compartida
$ ./shm24 leer "$nombre"
Texto (29 bytes): hola desde memoria compartida
$ ./shm24 retirar "$nombre"
Nombre retirado: /ipc24_..._demo
$ ./shm24 leer "$nombre"
shm_open leer: No such file or directory

El operador && ejecuta el lector únicamente si el creador terminó con retorno cero. Son dos procesos independientes coordinados por la shell. El segundo lector vuelve a ver el mismo texto: leer memoria no retira una unidad como mq_receive.

La cantidad de bytes del objeto es sizeof(struct datos), calculada por el compilador. En un sistema Linux habitual será 172; el programa muestra el valor real y no lo codifica como una constante externa.

La opción -lrt mantiene compatibilidad con entornos que requieren librt para shm_open. En versiones recientes de glibc puede no ser necesaria para enlazar. No se necesita -pthread porque el programa todavía no utiliza semáforos ni hilos.

Los puntos suspensivos representan el nombre elegido y el tamaño observado. Los mensajes de perror dependen del idioma del sistema. Para comprobar un fallo desde la shell, consulta el estado inmediatamente con echo $?.

Comprobar que una colisión no destruye el dato

Bash · conservar el objeto creado por la primera operación
$ ./shm24 crear "$nombre" "primero"
$ ./shm24 crear "$nombre" "segundo"
shm_open crear: File exists
$ echo $?
1
$ ./shm24 leer "$nombre"
Texto (7 bytes): primero
$ ./shm24 retirar "$nombre"

El segundo creador no llega a ftruncate ni a la inicialización. Tampoco ejecuta shm_unlink en esa ruta. El estado que ya existía sigue perteneciendo a quien lo creó y administra.

11. Laboratorio con un lector que conserva su vista

Usaremos dos terminales del mismo usuario. El primer lector conectará y cerrará su descriptor, pero conservará el mapeo mientras espera Enter. En la otra terminal retiraremos el nombre y crearemos un objeto nuevo.

terminal A · elegir un nombre propio y conservar la vista
$ ./shm24 crear /ipc24_sesionA "objeto antiguo" && ./shm24 leer /ipc24_sesionA esperar
Creado /ipc24_sesionA: ... bytes; texto de 14 bytes
Mapeo preparado; descriptor cerrado. Pulsa Enter para leer.

Si ese nombre ya existe, el creador fallará. Elige otro para tu sesión y úsalo en ambas terminales. No retires un objeto ajeno solamente para reutilizar el nombre del ejemplo.

terminal B · después de observar «Mapeo preparado» en A
$ ./shm24 retirar /ipc24_sesionA
$ ./shm24 leer /ipc24_sesionA
shm_open leer: No such file or directory
$ ./shm24 crear /ipc24_sesionA "objeto nuevo" && ./shm24 leer /ipc24_sesionA
Creado /ipc24_sesionA: ... bytes; texto de 12 bytes
Texto (12 bytes): objeto nuevo

Ahora vuelve a A y pulsa Enter. Su lector debe mostrar Texto (14 bytes): objeto antiguo. Aunque el nombre volvió a existir, la vista de A no se reconectó al objeto nuevo.

terminal B · limpieza del nombre de la generación nueva
$ ./shm24 retirar /ipc24_sesionA

El objeto antiguo perdió su nombre, pero se mantuvo vivo por la vista de A hasta su munmap. El nuevo tuvo un ciclo de vida diferente. No hay una operación que cambie de respaldo todos los mapeos existentes al recrear un nombre.

La pausa con getchar sirve para controlar el experimento desde la terminal. Los datos antiguos no se modifican durante ella, así que no se usa esa pausa como sustituto de sincronización para leer escrituras en curso.

12. Programa completo: dos generaciones del mismo nombre

Podemos reproducir el cambio de identidad sin coordinar terminales. Este segundo programa crea un objeto con el número 111, conserva su mapeo, retira el nombre y crea otro con 222 bajo el mismo nombre. Finalmente abre el nombre una vez más y comprueba a qué generación llega.

El programa mantiene tres vistas: una antigua, una nueva y una de consulta posterior. Los descriptores se cierran al mapear. No necesita hijos porque la propiedad observada es la identidad del objeto respaldante, no el parentesco entre procesos.

generaciones24.c · un nombre reutilizado no sustituye un mapeo existente
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>

static int *crear_vista(const char *nombre, int *propio)
{
    int fd = shm_open(nombre, O_CREAT | O_EXCL | O_RDWR, 0600);
    if (fd == -1) {
        perror("shm_open exclusivo");
        return MAP_FAILED;
    }
    *propio = 1; /* La limpieza conoce la propiedad aun si falla despues. */
    int *p = MAP_FAILED;
    if (ftruncate(fd, (off_t)sizeof *p) == -1) {
        perror("ftruncate");
    } else {
        p = mmap(NULL, sizeof *p, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
        if (p == MAP_FAILED) perror("mmap");
    }
    if (close(fd) == -1) {
        perror("close");
        if (p != MAP_FAILED && munmap(p, sizeof *p) == -1)
            perror("munmap tras close");
        return MAP_FAILED;
    }
    return p;
}

int main(void)
{
    char nombre[80];
    int n = snprintf(nombre, sizeof nombre, "/ipc24_gen_%ld", (long)getpid());
    if (n < 0 || (size_t)n >= sizeof nombre) return EXIT_FAILURE;
    int propio = 0;
    int salida = EXIT_FAILURE;
    int *antigua = MAP_FAILED;
    int *nueva = MAP_FAILED;
    const int *consulta = MAP_FAILED;
    int fd = -1;

    antigua = crear_vista(nombre, &propio);
    if (antigua == MAP_FAILED) goto fin;
    *antigua = 111;
    if (shm_unlink(nombre) == -1) {
        perror("shm_unlink antigua");
        goto fin;
    }
    propio = 0; /* El nombre antiguo ya no existe. */

    nueva = crear_vista(nombre, &propio);
    if (nueva == MAP_FAILED) goto fin;
    *nueva = 222;
    fd = shm_open(nombre, O_RDONLY, 0);
    if (fd == -1) {
        perror("shm_open consulta");
        goto fin;
    }
    consulta = mmap(NULL, sizeof *consulta, PROT_READ, MAP_SHARED, fd, 0);
    if (consulta == MAP_FAILED) {
        perror("mmap consulta");
        goto fin;
    }
    int cierre = close(fd);
    fd = -1;
    if (cierre == -1) {
        perror("close consulta");
        goto fin;
    }
    printf("Vista antigua: %d\n", *antigua);
    printf("Vista nueva: %d\n", *nueva);
    printf("Apertura posterior: %d\n", *consulta);
    if (*antigua == 111 && *nueva == 222 && *consulta == 222)
        salida = EXIT_SUCCESS;

fin:
    /* Administracion serial: nadie sustituye el nombre durante la prueba. */
    if (propio && shm_unlink(nombre) == -1) {
        perror("shm_unlink limpieza");
        salida = EXIT_FAILURE;
    }
    if (fd != -1 && close(fd) == -1) {
        perror("close limpieza");
        salida = EXIT_FAILURE;
    }
    if (consulta != MAP_FAILED && munmap((void *)consulta, sizeof *consulta) == -1) {
        perror("munmap consulta");
        salida = EXIT_FAILURE;
    }
    if (nueva != MAP_FAILED && munmap(nueva, sizeof *nueva) == -1) {
        perror("munmap nueva");
        salida = EXIT_FAILURE;
    }
    if (antigua != MAP_FAILED && munmap(antigua, sizeof *antigua) == -1) {
        perror("munmap antigua");
        salida = EXIT_FAILURE;
    }
    return salida;
}
Bash · observar identidad y terminar sin nombre residual
$ gcc -std=c17 -O2 -Wall -Wextra -Wpedantic generaciones24.c -o generaciones24 -lrt
$ ./generaciones24
Vista antigua: 111
Vista nueva: 222
Apertura posterior: 222
$ echo $?
0

La variable propio representa si esta ejecución conserva la responsabilidad sobre el nombre. Se pone a uno inmediatamente después de una creación exitosa, incluso si falla el dimensionado posterior. Se pone a cero cuando el nombre se retira.

Si la segunda creación falla por EEXIST, propio continúa en cero y la limpieza no borra ese nombre. Bajo el contrato serial no debería aparecer otro creador, pero la ruta evita atribuirse un objeto que no se obtuvo.

Si un tercero pudiera sustituir nombres durante la ejecución, un indicador local no bastaría para garantizar a qué objeto apunta actualmente el nombre. La política de administración y de generaciones tendría que formar parte del protocolo del servicio.

13. Limpieza normal y rutas de error

La limpieza depende de lo que llegó a obtener cada rol. No se invoca shm_unlink desde cualquier proceso que termina: un lector no debe quitar el nombre que futuros lectores necesitan.

SituaciónResponsabilidadAcción
Falla la creación exclusiva.No se adquirió el objeto.Informar el error sin borrar el nombre existente.
Falla ftruncate tras crear.Hay descriptor y nombre propios.Cerrar y retirar el nombre propio.
Falla mmap tras dimensionar.No hay vista válida.Cerrar el descriptor y retirar el nombre propio.
El creador termina correctamente.El objeto debe seguir localizable.munmap y close, conservando el nombre.
Un lector termina o rechaza el formato.Solo posee sus referencias.munmap y close si corresponden; conservar el nombre.
Se retira el servicio del laboratorio.El responsable administra el nombre.shm_unlink y finalización de los usuarios conectados.

Eliminar el nombre mientras existen vistas no las cancela. Un protocolo de cierre de servicio debe decidir si permite terminar a usuarios antiguos, cómo impide admitir otros y cuándo libera los datos. shm_unlink solo resuelve la retirada del nombre.

Los ejemplos no reintentan close sobre el mismo entero después de un error en Linux. Ese número puede haber quedado liberado. El lector lo cambia a −1 tras el intento para que la limpieza no vuelva a cerrarlo.

Una caída por SIGKILL no ejecuta la limpieza escrita en C. El sistema retira las referencias del proceso, pero un objeto todavía nombrado puede permanecer. El responsable debe reconocer el recurso y decidir su retirada; el nombre no incluye una caducidad automática.

No reutilizar a ciegas un objeto huérfano

Que no conozcas un creador activo no demuestra que no existan lectores ni que el contenido sea compatible. Para recuperar un servicio hacen falta reglas de propiedad y generación. El laboratorio usa nombres propios y retirada explícita.

14. Persistencia y observación en Linux

La persistencia de un nombre en el núcleo permite que el creador termine antes de que aparezca el lector. No convierte el objeto en una base de datos duradera ni promete conservarlo tras reiniciar el sistema. En Linux suele residir en un tmpfs montado en /dev/shm, según shm_overview(7).

Bash · inspección del objeto de tu sesión
$ ./shm24 crear "$nombre" "inspeccion"
$ ls -l "/dev/shm/${nombre#/}"
$ stat "/dev/shm/${nombre#/}"
$ df -h /dev/shm
$ ./shm24 retirar "$nombre"

La expansión ${nombre#/} elimina la barra inicial al construir la ruta de inspección de Linux. Esas rutas se usan para observar; el programa sigue creando y retirando mediante las funciones POSIX.

Un entorno con contenedores puede tener un montaje de /dev/shm diferente y un límite pequeño. Compartir una cadena de nombre no garantiza que dos procesos ubicados en entornos aislados encuentren el mismo objeto. Revisa también dónde ejecutas cada terminal.

Que ftruncate y mmap hayan tenido éxito no permite prometer que cualquier escritura futura obtendrá memoria. El respaldo puede quedarse sin espacio cuando se materialicen las páginas. Los ejemplos son pequeños; para regiones grandes hay que estudiar límites y fallos durante el acceso.

Relacionar la API con llamadas del sistema

Bash · inspeccionar creación, mapeo y retirada
$ strace -e trace=openat,ftruncate,mmap,munmap,close,unlink,unlinkat ./shm24 crear "$nombre" "traza"
$ strace -e trace=openat,fstat,newfstatat,mmap,munmap,close ./shm24 leer "$nombre"
$ strace -e trace=unlink,unlinkat ./shm24 retirar "$nombre"

No esperes una llamada al núcleo llamada shm_open: la biblioteca puede implementar la operación mediante apertura de la representación del objeto. Las llamadas exactas dependen del sistema y de la biblioteca; también aparecerán accesos del cargador.

El texto compartido se escribe con accesos a memoria, no con una llamada write al objeto. La traza revela la preparación y el ciclo de vida, pero no cada carga y almacenamiento sobre el rango mapeado.

15. Explorar nombres y referencias

Este modelo comienza sin recurso. Crea un objeto, conecta un lector y cierra el descriptor del creador. Después retira el nombre y crea otra generación. El lector conservará su vínculo con la primera hasta retirar su propia vista.

Nombre /ipc24_modeloNo existe

Descriptor del creadorCerrado

Vista del lectorSin mapeo

Objetos vivos y referenciasNinguno

Crea el primer objeto para comenzar.

El modelo agrupa creación, dimensionado e inicialización como una acción terminada correctamente. No simula la carrera de publicación explicada antes. «Mapear lector» también incluye abrir, mapear y cerrar su descriptor temporal.

Solo representa un descriptor de creador y una vista de lector a la vez. Para crear G2 después de G1, cierra primero el descriptor de G1 y retira su nombre. Puedes conservar la vista de G1 mientras G2 mantiene su nuevo nombre y descriptor.

16. Pruebas y diagnóstico

Longitudes y contenido

Bash · un texto vacío también es válido
$ ./shm24 crear "$nombre" "" && ./shm24 leer "$nombre"
Creado /ipc24_..._demo: ... bytes; texto de 0 bytes
Texto (0 bytes): 
$ ./shm24 retirar "$nombre"

Prueba además 159 bytes ASCII y comprueba que se aceptan. Con 160 bytes debe rechazarse la entrada antes de crear el objeto. Si usas caracteres como á o ñ, cuenta su representación UTF-8 en bytes.

Rechazo del contrato y limpieza

Realiza las variantes sobre nombres que hayas creado para probar y que no estén siendo usados. No trunques un recurso mientras un lector lo consulta para «comprobar» si la validación lo protege: ese comportamiento está fuera del contrato y puede provocar SIGBUS.

SíntomaPosible causaQué revisar
EEXIST al crear.El nombre ya identifica un objeto.Propiedad del recurso y elección del nombre; no borrar automáticamente.
ENOENT al leer.No se creó o ya se retiró el nombre.Secuencia de comandos, texto exacto del nombre y entorno de ejecución.
EACCES al abrir.Permisos o identidad incompatibles.Modo efectivo, umask y usuario.
Tamaño incompatible.Inicialización incompleta u otro contrato.Éxito del creador y tamaño externo; el lector no debe repararlo.
Formato incompatible.Marca, versión, longitud o terminación incorrectas.Binarios y estructura acordada, sin omitir validaciones.
SIGBUS al acceder.Respaldo insuficiente, truncamiento o falta de espacio.Tamaño estable y recursos del montaje.
El dato viejo sigue visible.Se conserva una vista de otra generación.Identidad del objeto y momento de conexión.
Queda un nombre al terminar.El creador lo conserva para lectores o hubo una caída.Quién tiene la responsabilidad de retirar.

Para comprobar el orden, usa primero la ejecución secuencial con &&. Una solución que parece funcionar lanzando ambos programas simultáneamente puede estar aprovechando una planificación favorable y seguir teniendo una carrera de inicialización.

17. Resumen

18. Preguntas de repaso y práctica

Intenta responder antes de desplegar cada explicación.

1. ¿Qué añade shm_open al ejemplo anónimo del tema 23?

Permite localizar un objeto por nombre desde procesos independientes, sin depender de heredar la región mediante fork.

2. ¿Qué devuelve shm_open?

Un descriptor de archivo no negativo al tener éxito, o −1 al fallar. Para obtener una dirección de memoria se utiliza después mmap.

3. ¿Por qué se combina O_CREAT con O_EXCL?

Para exigir un objeto nuevo y no confundir una apertura existente con una creación propia. EEXIST no concede permiso para borrar o reconfigurar el recurso encontrado.

4. ¿Por qué no se puede acceder inmediatamente a una estructura tras crear?

El objeto nuevo tiene tamaño cero. Antes hay que dimensionarlo, mapearlo e inicializar sus datos, además de coordinar cuándo pueden conectarse los lectores.

5. ¿Por qué el lector no usa O_CREAT ni ftruncate?

Porque su función es consumir un recurso preparado por otro rol. Crear o redimensionar ocultaría errores y podría destruir el estado de otros usuarios.

6. ¿El tamaño correcto demuestra que el creador terminó?

No. El tamaño se establece antes de escribir todos los campos. Hace falta un protocolo de publicación; el ejemplo lanza el lector después de la terminación exitosa del creador.

7. ¿Por qué no se añade MAP_ANONYMOUS?

Porque el respaldo es el objeto identificado por el descriptor de shm_open. Un mapeo anónimo sería otra clase de reserva y no usaría ese objeto como respaldo.

8. ¿Qué ocurre al cerrar el descriptor después de mmap?

Se cierra esa referencia, pero el mapeo conserva el acceso al objeto. Más tarde debe retirarse con munmap.

9. ¿shm_unlink cancela a los lectores conectados?

No. Retira el nombre, impidiendo nuevas aperturas por él mientras no se recree. Los lectores existentes conservan sus referencias y vistas.

10. ¿Qué verá una apertura posterior si se reutiliza el nombre?

Conectará al objeto nuevo. Un mapeo antiguo seguirá vinculado a la generación anterior.

11. ¿Por qué los lectores pueden obtener direcciones diferentes?

Cada proceso elige su rango virtual al mapear. Compartir almacenamiento no exige que las direcciones sean iguales.

12. ¿PROT_READ convierte en inmutable el objeto global?

No. Restringe esa vista local. Otro proceso con permisos de escritura podría cambiar el objeto; el contrato del ejemplo prohíbe esas modificaciones durante la lectura.

13. ¿Quién retira el nombre al fallar una creación?

Solo quien obtuvo con éxito el objeto nuevo tiene esa responsabilidad en el laboratorio. Si la creación exclusiva falló, no se borra el recurso existente.

14. ¿Quedan datos duraderos tras reiniciar?

No se promete. La persistencia del objeto en el núcleo permite sobrevivir a un proceso, pero no equivale a un archivo de almacenamiento duradero.

15. ¿Por qué una marca y una versión no son sincronización?

Porque validan valores del formato, pero no establecen por sí mismas cuándo terminó una escritura concurrente ni el orden de publicación de todos los campos.

Para practicar y ampliar

  1. Ejecuta crear, dos lecturas y retirar. Explica por qué ambas lecturas obtienen el texto completo.
  2. Comprueba el rechazo de un nombre fuera del prefijo y verifica que no se crea un recurso.
  3. Prueba texto vacío, 159 bytes y 160 bytes. Relaciona cada resultado con la capacidad del array.
  4. Repite la colisión de creadores y verifica que se conserva el primer texto.
  5. Conserva una vista con esperar, retira el nombre y prueba una apertura nueva antes de recrearlo.
  6. Recrea el nombre con otro texto y compara el lector antiguo con uno nuevo.
  7. Ejecuta generaciones24 con strace y localiza las dos creaciones y las dos retiradas del nombre.
  8. Simula fallos después de crear y después de mapear, comprobando qué recursos debe limpiar cada ruta.
  9. Dibuja la secuencia de referencias de un objeto sin nombre que todavía tiene un lector conectado.
  10. Diseña el arranque de un servicio con lectores concurrentes. Identifica cómo avisaría que terminó de inicializar y quién retiraría su nombre al cerrar.
Próximo paso

En el tema 25 diseñaremos datos para procesos independientes: usar offsets en lugar de punteros, validar versiones y organizar la inicialización de estructuras compartidas.