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.
| Recurso | Cómo se obtiene | Có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
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).
/* 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.
$ umask
0022
$ nombre="/ipc24_$$_demo"
$ printf '%s\n' "$nombre"
/ipc24_..._demoEl 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.
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
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.
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
-> munmapLa 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.
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.
| Comando | Responsabilidad | Estado 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.
#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.
$ 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 directoryEl 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
$ ./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.
$ ./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.
$ ./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 nuevoAhora 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.
$ ./shm24 retirar /ipc24_sesionAEl 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.
#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;
}$ gcc -std=c17 -O2 -Wall -Wextra -Wpedantic generaciones24.c -o generaciones24 -lrt
$ ./generaciones24
Vista antigua: 111
Vista nueva: 222
Apertura posterior: 222
$ echo $?
0La 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ón | Responsabilidad | Acció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.
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).
$ ./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
$ 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
$ ./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
- Nombre ausente. Ejecuta leer antes de crear. Debe fallar sin dejar un objeto nuevo.
- Creación repetida. Usa dos textos distintos con el mismo nombre. El segundo intento debe fallar y el primero seguir disponible.
- Tamaño incompatible. En una copia de laboratorio, crea exclusivamente otro objeto del prefijo propio y dale un tamaño distinto. El lector debe rechazarlo antes de mmap.
- Formato incompatible. En una copia del creador cambia la versión escrita, conservando el tamaño. El lector original debe rechazar el formato.
- Fallo tras crear. En una copia de prueba, simula un error de ftruncate después de obtener el objeto nuevo. Comprueba que se cierra el descriptor y se retira el nombre.
- Vista antigua. Repite el laboratorio con dos terminales. El lector conectado debe conservar el texto antiguo tras la recreación.
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íntoma | Posible causa | Qué 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
- shm_open conecta programas independientes con un objeto identificado por nombre.
- El retorno es un descriptor entero, no un puntero a datos.
- O_CREAT | O_EXCL permite distinguir una creación propia de una colisión.
- Un objeto nuevo comienza con tamaño cero; el creador lo dimensiona con ftruncate.
- mmap con MAP_SHARED crea una vista del respaldo abierto, sin MAP_ANONYMOUS.
- El lector valida tamaño y formato sin redimensionar ni inicializar el objeto.
- Encontrar el nombre o el tamaño esperado no confirma que la publicación haya terminado.
- close, munmap y shm_unlink retiran recursos diferentes.
- Un mapeo puede sobrevivir al cierre del descriptor y a la retirada del nombre.
- Recrear un nombre produce otro objeto; las vistas antiguas conservan su identidad.
- La persistencia del recurso en el núcleo no promete durabilidad tras reinicios.
- La propiedad del nombre y la sincronización de los datos deben definirse explícitamente.
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
- Ejecuta crear, dos lecturas y retirar. Explica por qué ambas lecturas obtienen el texto completo.
- Comprueba el rechazo de un nombre fuera del prefijo y verifica que no se crea un recurso.
- Prueba texto vacío, 159 bytes y 160 bytes. Relaciona cada resultado con la capacidad del array.
- Repite la colisión de creadores y verifica que se conserva el primer texto.
- Conserva una vista con esperar, retira el nombre y prueba una apertura nueva antes de recrearlo.
- Recrea el nombre con otro texto y compara el lector antiguo con uno nuevo.
- Ejecuta generaciones24 con strace y localiza las dos creaciones y las dos retiradas del nombre.
- Simula fallos después de crear y después de mapear, comprobando qué recursos debe limpiar cada ruta.
- Dibuja la secuencia de referencias de un objeto sin nombre que todavía tiene un lector conectado.
- 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.
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.