1. El formato también es parte del protocolo
En el tema 24 separaste el nombre, el descriptor y el mapeo. El lector comprobaba que el objeto tenía el tamaño de una estructura conocida y validaba una marca, una versión y una longitud. Ese ejemplo funcionaba con programas compilados para el mismo entorno y una estructura sencilla sin referencias internas.
Ahora queremos compartir varios registros de longitud variable. Necesitamos describir dónde comienza la tabla, cuántos registros contiene, dónde están sus textos y qué reglas debe cumplir cada referencia. Una reserva suficientemente grande no responde esas preguntas.
El contrato de una región compartida incluye representación, límites, referencias internas, versión, inicialización y propiedad de los datos. Todos los participantes deben interpretar esas reglas de la misma manera.
| Pregunta | Decisión del ejemplo | Error que evita |
|---|---|---|
| ¿Cómo reconocer el formato? | Marca de cuatro bytes y versión 1. | Interpretar otro objeto como un catálogo. |
| ¿Dónde termina la región? | Tamaño externo validado y total declarado coincidente. | Recorrer bytes que no pertenecen al contrato. |
| ¿Cómo localizar cada texto? | Offset desde la base y longitud explícita. | Usar direcciones de otro proceso o buscar NUL sin límite. |
| ¿Qué orden tienen los enteros? | 32 bits, byte más significativo primero. | Depender del orden nativo de la CPU. |
| ¿Cuándo se permite leer? | Después del éxito del creador, con el objeto inmutable. | Consumir una inicialización parcial. |
El objetivo será un catálogo de nombres que se crea una vez y después se consulta. Mantenerlo inmutable nos permite estudiar el formato sin introducir todavía un asignador compartido, un contador concurrente ni un protocolo de actualización en servicio.
2. Por qué no guardar punteros nativos
struct registro_incorrecto {
unsigned id;
char *nombre;
};
/* No basta con colocar esta estructura en memoria compartida. */
registro->nombre = malloc(80);La estructura puede ser compartida, pero la reserva de malloc pertenece al heap privado del creador. El otro proceso no recibe ese contenido ni adquiere acceso al destino por leer el valor del puntero.
El problema continúa aunque el texto sí esté dentro del objeto compartido. Si el creador lo mapea en 0x1000 y el texto está 76 bytes después, su dirección local sería 0x104c. Un lector que mapee el objeto en 0x9000 necesita la dirección 0x904c.
Copiar 0x104c al lector no la convierte en una referencia al mismo texto. Puede ser una dirección no mapeada o apuntar a otro contenido. No es correcto probar una dirección de otro proceso para ver si «funciona».
mmap con dirección NULL deja al sistema elegir el rango virtual. No se garantiza una dirección común entre programas independientes, como describe mmap(2). Forzar MAP_FIXED para compensar un formato con punteros añade restricciones y puede reemplazar otros mapeos.
Los números de descriptor tampoco son referencias transferibles mediante una simple copia. Un fd igual a 4 designa una entrada de la tabla de descriptores del proceso que lo utiliza. En el catálogo guardaremos solamente datos y posiciones dentro de la región.
3. Offsets relativos a la base de la región
Un offset expresa una distancia en bytes respecto de un origen acordado. Elegiremos como origen el primer byte del mapeo del objeto completo. Si el texto comienza en la posición 76, todos almacenan el número 76 y cada proceso reconstruye su dirección local.
/* base apunta al comienzo de la region completa. */
/* Primero validar offset y longitud contra el tamano mapeado. */
const unsigned char *texto = base + offset;Un offset no necesita ser un offset de archivo utilizado directamente por mmap. Nuestros lectores mapean el objeto desde el desplazamiento de archivo cero y luego resuelven posiciones internas sin restricciones de alineación de página para los textos.
Hay que definir también las referencias ausentes. En este catálogo no hay textos opcionales: cada registro tiene uno de 1 a 64 bytes. El offset cero queda fuera del área de textos y no se interpreta como una dirección válida. En otro diseño podrías reservar cero como «sin referencia» y comprobarlo antes del rango.
El entero del formato será uint32_t, suficiente para el máximo de 4096 bytes del ejemplo. Esa elección limita el espacio de offsets; no se debe cambiar a un entero de 64 bits sin actualizar la especificación y la versión.
4. Validar rangos sin desbordamientos
No calcules primero la dirección de un destino no validado. Tampoco aceptes un rango comprobando únicamente que la suma offset + longitud parece menor que el total: la suma de enteros sin signo puede desbordar.
static inline int rango(size_t total, size_t offset, size_t longitud)
{
return offset <= total && longitud <= total - offset;
}El cortocircuito de && evita restar cuando offset supera el total. Solo después de una comprobación válida se forma base + offset y se usan los longitud bytes. Un rango vacío en el final puede ser válido para esta función genérica, aunque nuestro formato exige textos no vacíos.
Para una tabla de elementos fijos hay un segundo producto que vigilar: cantidad × tamaño_de_registro. Comprueba primero que el tamaño de registro es distinto de cero y que la cantidad no supera (total - offset_tabla) / tamaño_de_registro, tras validar el comienzo de la tabla.
Además de caber físicamente, una referencia debe apuntar a una zona permitida. Un texto no puede comenzar dentro de la cabecera aunque sus cuatro bytes «quepan» en el mapeo. El lector comprobará la distribución canónica y que cada texto continúa exactamente después del anterior.
Una longitud externa obtenida con fstat debe validarse antes de convertirla a size_t. En los programas exigiremos entre 40 y 4096 bytes. Ese límite también evita que un objeto inesperadamente grande obligue al lector a mapear una reserva arbitraria.
5. Tipos, alineación y representación
Una estructura C nativa puede contener padding entre campos y al final. Su distribución depende de tipos, alineación y ABI. Sustituir char * por uint32_t no define por sí solo un formato completo si cada programa interpreta una estructura distinta.
struct entrada_nativa {
unsigned char clase;
uint32_t offset;
};
/* No suponer que offset esta en el byte 1. */
printf("offset: %zu; tamano: %zu\n",
offsetof(struct entrada_nativa, offset), sizeof(struct entrada_nativa));offsetof, declarada en stddef.h, informa el desplazamiento que utiliza el compilador para un miembro. Sirve para verificar un layout nativo, pero no obliga a otro compilador a elegir el mismo. Su contrato está en offsetof(3).
Para el catálogo definiremos bytes explícitos. Cada entero ocupa cuatro bytes en orden de más significativo a menos significativo. El lector lo reconstruye con desplazamientos y operaciones sobre unsigned char, sin convertir una dirección posiblemente desalineada a uint32_t *.
No necesitamos empaquetar estructuras con atributos del compilador. Ese recurso cambia el layout, pero no soluciona automáticamente la alineación de los accesos, el orden de bytes ni las diferencias de representación de todos los tipos.
Los textos se tratan como secuencias de bytes con longitud. En las pruebas utilizaremos UTF-8; el programa no valida esa codificación y no necesita terminador NUL dentro del objeto. Los bytes cero no se buscan para decidir cuánto leer.
Esta codificación hace estable la representación de nuestros datos. No promete que sem_t, pthread_mutex_t, punteros, atomics o cualquier otro objeto nativo de sincronización puedan serializarse igual. Esos tipos tienen reglas de implementación y uso propias.
6. Diseñar una cabecera con versión
La versión 1 usa una cabecera de 40 bytes. La marca se compara antes de interpretar el resto. La versión decide qué reglas se aplican; el lector de este tema rechaza cualquier versión diferente de uno.
| Bytes | Campo | Regla de la versión 1 |
|---|---|---|
| 0–3. | Marca. | Los cuatro bytes ASCII IPC5. |
| 4–7. | Versión. | Entero de 32 bits igual a 1. |
| 8–11. | Longitud de cabecera. | 40 bytes. |
| 12–15. | Longitud total. | Coincide con el tamaño externo del objeto. |
| 16–19. | Estado. | 1 construyendo; 2 listo para el contrato de lectura. |
| 20–23. | Cantidad de registros. | De 1 a 16. |
| 24–27. | Offset de la tabla. | 40, desde la base de la región. |
| 28–31. | Tamaño de cada registro. | 12 bytes. |
| 32–35. | Offset del área de textos. | 40 + cantidad × 12. |
| 36–39. | Reservado. | Cero; se rechazan otros valores. |
Los campos de longitud permiten detectar un desacuerdo aunque dos binarios usen la misma versión por error. La marca no es una firma de seguridad y el campo reservado no concede compatibilidad automática con una extensión futura.
El estado distingue una construcción incompleta de un objeto terminado cuando se lo inspecciona conforme al protocolo. No convierte una lectura concurrente en una publicación sincronizada. Es un valor del formato, no un semáforo ni una operación atómica entre procesos.
7. Distribución del catálogo de ejemplo
Cada registro contiene tres enteros de 32 bits: identificador, offset de su texto y longitud del texto. Los identificadores son consecutivos desde uno. Después de la tabla se concatenan los textos sin terminadores ni huecos.
0..39 cabecera: total = 89, cantidad = 3, textos = 76
40..51 registro 1: id = 1, offset = 76, longitud = 4
52..63 registro 2: id = 2, offset = 80, longitud = 4
64..75 registro 3: id = 3, offset = 84, longitud = 5
76..79 alfa
80..83 beta
84..88 gamma
89 fin exclusivo de la regionEl offset del último texto es 84 y su longitud es 5: el final exclusivo es 89. No hay un byte 89 que el programa deba consultar. Tampoco se añade un terminador detrás de gamma.
Exigir el orden y la continuidad de textos simplifica la validación: la primera referencia coincide con el comienzo del área, cada referencia siguiente coincide con el final anterior y el cursor final coincide con el total. Se rechazan solapamientos, huecos y referencias a la tabla.
Esta restricción es una decisión del catálogo, no una obligación de todos los formatos con offsets. Un diseño con textos reutilizados, índices o listas tendría otras reglas; por ejemplo, tendría que admitir referencias repetidas o detectar ciclos.
8. Inicializar antes de admitir lectores
- Validar las entradas. Cantidad, longitudes y tamaño total se comprueban antes de crear.
- Crear exclusivamente y dimensionar. Solo el creador inicializa el objeto nuevo.
- Construir la región. Se ponen a cero los bytes y se escriben cabecera, tabla y textos.
- Marcar listo y validar la construcción. Se aplica el mismo validador que usará el lector.
- Terminar con éxito. Se retiran las referencias locales y se conserva el nombre para consultas.
- Lanzar lectores. La shell comprueba el éxito del creador antes de ejecutar el lector.
La secuencia controlada será ./crear25 ... && ./leer25 .... Los lectores pueden consultar simultáneamente el catálogo terminado porque nadie lo modifica ni lo redimensiona. La administración del nombre también se realiza de forma controlada.
Escribir LISTO al final expresa la intención del formato, pero no basta si otro proceso está sondeando esa palabra durante la construcción. El código no promete orden de publicación concurrente mediante asignaciones ordinarias ni utiliza volatile para simularlo.
Si el creador cae antes de terminar, la shell no lanza el lector por la rama de éxito. Un objeto residual requiere inspección y retirada del responsable; un futuro creador no lo reinicializa solo porque encuentre el nombre.
Para admitir lectores mientras el creador sigue vivo hará falta un mecanismo de control adecuado. Los semáforos permiten coordinar acciones, como resume sem_overview(7); su inicialización y empleo entre procesos se desarrollarán en los temas 27 a 30.
9. Código compartido: codificación y validación
Guarda esta cabecera como catalogo25.h. No contiene una estructura que se vuelque directamente al objeto. Define posiciones, límites, acceso a enteros y un validador de la región completa.
#ifndef CATALOGO25_H
#define CATALOGO25_H
#define _POSIX_C_SOURCE 200809L
#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 CAB 40u
#define REG 12u
#define MAX_REG 16u
#define MAX_TEXTO 64u
#define MAX_TOTAL 4096u
#define VERSION 1u
#define CONSTRUYENDO 1u
#define LISTO 2u
static inline void poner32(unsigned char *p, uint32_t x)
{
p[0] = (unsigned char)(x >> 24);
p[1] = (unsigned char)(x >> 16);
p[2] = (unsigned char)(x >> 8);
p[3] = (unsigned char)x;
}
static inline uint32_t leer32(const unsigned char *p)
{
return ((uint32_t)p[0] << 24) | ((uint32_t)p[1] << 16) |
((uint32_t)p[2] << 8) | (uint32_t)p[3];
}
static inline int rango(size_t total, size_t off, size_t len)
{
return off <= total && len <= total - off;
}
static inline int nombre_valido(const char *s)
{
size_t n = strlen(s);
if (n <= 7 || n > 80 || strncmp(s, "/ipc25_", 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 inline int validar(const unsigned char *b, size_t n)
{
if (n < CAB || n > MAX_TOTAL) return 0;
if (memcmp(b, "IPC5", 4) != 0 || leer32(b + 4) != VERSION ||
leer32(b + 8) != CAB || leer32(b + 12) != n ||
leer32(b + 16) != LISTO || leer32(b + 36) != 0) return 0;
size_t cantidad = leer32(b + 20);
size_t tabla = leer32(b + 24);
size_t ancho = leer32(b + 28);
size_t textos = leer32(b + 32);
if (cantidad == 0 || cantidad > MAX_REG || tabla != CAB || ancho != REG)
return 0;
if (tabla > n || cantidad > (n - tabla) / ancho) return 0;
size_t fin_tabla = tabla + cantidad * ancho;
if (textos != fin_tabla) return 0;
size_t cursor = textos;
for (size_t i = 0; i < cantidad; ++i) {
const unsigned char *r = b + tabla + i * ancho;
size_t off = leer32(r + 4);
size_t len = leer32(r + 8);
if (leer32(r) != i + 1 || len == 0 || len > MAX_TEXTO ||
off != cursor || !rango(n, off, len)) return 0;
cursor = off + len; /* Ya se demostro que cabe en n. */
}
return cursor == n;
}
#endifLa cabecera entera se comprueba disponible antes de leer campos fijos. La tabla entera se comprueba antes de formar el puntero a cada registro. El validador no necesita leer el contenido de los textos para demostrar que todas sus referencias caben.
El ancho queda validado como 12 antes de usarlo como divisor. La cantidad máxima limita el trabajo del recorrido y evita que una entrada corrupta provoque un bucle arbitrariamente grande. La función rechaza todo el catálogo si falla un solo registro.
Estos accesores no incorporan comprobaciones de rango en cada llamada: quien los utiliza debe garantizar primero que dispone de cuatro bytes. El validador y el creador cumplen esa precondición con sus controles externos y límites fijos.
10. Programa completo del creador
Guarda crear25.c junto a la cabecera. Recibe un nombre propio del laboratorio y entre uno y dieciséis textos. Acepta solamente nombres del prefijo /ipc25_ y textos de 1 a 64 bytes.
Todos los tamaños se calculan antes de shm_open. Los límites elegidos hacen representables los campos de 32 bits y el pequeño tamaño pasado a ftruncate. Si una operación falla después de crear, se retira el nombre propio; una colisión no se limpia como si fuera nuestra.
#include "catalogo25.h"
int main(int argc, char **argv)
{
if (argc < 3 || argc > 2 + (int)MAX_REG || !nombre_valido(argv[1])) {
fprintf(stderr, "Uso: %s /ipc25_nombre texto1 [texto2 ...]\n", argv[0]);
return EXIT_FAILURE;
}
size_t cantidad = (size_t)(argc - 2);
size_t longitudes[MAX_REG];
size_t textos = CAB + cantidad * REG;
size_t total = textos;
for (size_t i = 0; i < cantidad; ++i) {
size_t len = strlen(argv[i + 2]);
if (len == 0 || len > MAX_TEXTO || len > MAX_TOTAL - total) {
fprintf(stderr, "Texto %zu invalido: de 1 a 64 bytes\n", i + 1);
return EXIT_FAILURE;
}
longitudes[i] = len;
total += len;
}
int fd = shm_open(argv[1], O_CREAT | O_EXCL | O_RDWR, 0600);
if (fd == -1) {
perror("shm_open crear");
return EXIT_FAILURE;
}
int salida = EXIT_FAILURE;
unsigned char *b = MAP_FAILED;
if (ftruncate(fd, (off_t)total) == -1) {
perror("ftruncate");
goto fin;
}
b = mmap(NULL, total, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (b == MAP_FAILED) {
perror("mmap crear");
goto fin;
}
memset(b, 0, total);
memcpy(b, "IPC5", 4);
poner32(b + 4, VERSION);
poner32(b + 8, CAB);
poner32(b + 12, (uint32_t)total);
poner32(b + 16, CONSTRUYENDO);
poner32(b + 20, (uint32_t)cantidad);
poner32(b + 24, CAB);
poner32(b + 28, REG);
poner32(b + 32, (uint32_t)textos);
/* Los cuatro bytes reservados permanecen en cero. */
size_t cursor = textos;
for (size_t i = 0; i < cantidad; ++i) {
unsigned char *r = b + CAB + i * REG;
poner32(r, (uint32_t)(i + 1));
poner32(r + 4, (uint32_t)cursor);
poner32(r + 8, (uint32_t)longitudes[i]);
memcpy(b + cursor, argv[i + 2], longitudes[i]);
cursor += longitudes[i];
}
/* No hay lectores concurrentes: LISTO no es una barrera de memoria. */
poner32(b + 16, LISTO);
if (!validar(b, total)) {
fprintf(stderr, "La construccion no cumple el formato\n");
goto fin;
}
salida = EXIT_SUCCESS;
fin:
if (b != MAP_FAILED && munmap(b, total) == -1) {
perror("munmap crear");
salida = EXIT_FAILURE;
}
if (close(fd) == -1) {
perror("close crear");
salida = EXIT_FAILURE;
}
if (salida != EXIT_SUCCESS) {
if (shm_unlink(argv[1]) == -1) perror("shm_unlink tras fallo");
} else {
printf("Catalogo creado: %zu registros, %zu bytes\n", cantidad, total);
}
return salida;
}El array local longitudes sirve para preparar la construcción. No se almacena su dirección en el objeto. Durante la escritura solo se copian sus valores y los bytes de los argumentos.
No se copia el terminador NUL de cada argumento. La longitud explícita forma parte de cada registro y el total termina exactamente después del último texto. El lector debe respetar ese contrato al imprimir.
La comprobación MAX_TOTAL - total se realiza manteniendo total dentro del máximo desde el comienzo. Con los límites actuales el mayor catálogo posible ocupa 1256 bytes: 40 + 16 × 12 + 16 × 64. Los 4096 bytes son el techo de aceptación global, no una reserva que siempre se solicite.
11. Programa completo del lector
Guarda leer25.c. Primero comprueba el tamaño externo; después mapea, cierra el descriptor y valida la región completa. Solo si todas las comprobaciones pasan muestra los registros.
El argumento opcional doble conserva dos vistas simultáneas del mismo objeto. Ambas deben validar el mismo formato. Las direcciones que se imprimen sirven para observar la reconstrucción local y no se almacenan en la región.
#include "catalogo25.h"
int main(int argc, char **argv)
{
if ((argc != 2 && argc != 3) || !nombre_valido(argv[1]) ||
(argc == 3 && strcmp(argv[2], "doble") != 0)) {
fprintf(stderr, "Uso: %s /ipc25_nombre [doble]\n", argv[0]);
return EXIT_FAILURE;
}
int doble = argc == 3;
int fd = shm_open(argv[1], O_RDONLY, 0);
if (fd == -1) {
perror("shm_open leer");
return EXIT_FAILURE;
}
int salida = EXIT_FAILURE;
size_t total = 0;
const unsigned char *a = MAP_FAILED;
const unsigned char *b = MAP_FAILED;
struct stat st;
if (fstat(fd, &st) == -1) {
perror("fstat");
goto fin;
}
if (st.st_size < (off_t)CAB || st.st_size > (off_t)MAX_TOTAL) {
fprintf(stderr, "Tamano externo incompatible\n");
goto fin;
}
total = (size_t)st.st_size;
a = mmap(NULL, total, PROT_READ, MAP_SHARED, fd, 0);
if (a == MAP_FAILED) {
perror("mmap vista A");
goto fin;
}
if (doble) {
b = mmap(NULL, total, PROT_READ, MAP_SHARED, fd, 0);
if (b == MAP_FAILED) {
perror("mmap vista B");
goto fin;
}
}
int cierre = close(fd);
fd = -1;
if (cierre == -1) {
perror("close leer");
goto fin;
}
if (!validar(a, total) || (doble && !validar(b, total))) {
fprintf(stderr, "Formato incompatible\n");
goto fin;
}
printf("Vista A: %p\n", (void *)a);
if (doble) printf("Vista B: %p\n", (void *)b);
size_t cantidad = leer32(a + 20);
printf("Version: %u; registros: %zu; total: %zu\n",
(unsigned)leer32(a + 4), cantidad, total);
for (size_t i = 0; i < cantidad; ++i) {
const unsigned char *r = a + CAB + i * REG;
size_t off = leer32(r + 4);
size_t len = leer32(r + 8);
/* El validador ya comprobo todos los rangos. El objeto es inmutable. */
printf("Registro %zu: offset=%zu, longitud=%zu, texto=", i + 1, off, len);
if (fwrite(a + off, 1, len, stdout) != len || putchar('\n') == EOF) {
fprintf(stderr, "Error de salida\n");
goto fin;
}
if (doble) {
printf(" A + offset = %p; B + offset = %p\n",
(void *)(a + off), (void *)(b + off));
if (memcmp(a + off, b + off, len) != 0) {
fprintf(stderr, "Las vistas no coinciden\n");
goto fin;
}
}
}
if (fflush(stdout) == EOF || ferror(stdout)) {
fprintf(stderr, "Error al completar la salida\n");
goto fin;
}
salida = EXIT_SUCCESS;
fin:
if (b != MAP_FAILED && munmap((void *)b, total) == -1) {
perror("munmap vista B");
salida = EXIT_FAILURE;
}
if (a != MAP_FAILED && munmap((void *)a, total) == -1) {
perror("munmap vista A");
salida = EXIT_FAILURE;
}
if (fd != -1 && close(fd) == -1) {
perror("close limpieza");
salida = EXIT_FAILURE;
}
return salida; /* El lector no retira el nombre ni modifica datos. */
}No se comparan las bases restando punteros de dos mapeos diferentes. Se imprime cada dirección y se forma su referencia local con el mismo offset validado. La igualdad de textos se comprueba mediante una comparación de bytes acotada.
El descriptor no se cierra dos veces si close falla: se marca como −1 inmediatamente después del intento. Cada mapeo obtenido tiene su propia retirada en la limpieza, como en el tema anterior.
La validación previa al recorrido depende de que los datos permanezcan inmutables. Si otro proceso pudiera cambiar un offset después de validarlo, el recorrido dejaría de estar protegido por esa comprobación inicial. Esa situación exige otro protocolo.
12. Compilar y conectar los programas
$ gcc -std=c17 -O2 -Wall -Wextra -Wpedantic crear25.c -o crear25 -lrt
$ gcc -std=c17 -O2 -Wall -Wextra -Wpedantic leer25.c -o leer25 -lrt
$ nombre="/ipc25_$$_catalogo"
$ ./crear25 "$nombre" alfa beta gamma && ./leer25 "$nombre"
Catalogo creado: 3 registros, 89 bytes
Vista A: 0x...
Version: 1; registros: 3; total: 89
Registro 1: offset=76, longitud=4, texto=alfa
Registro 2: offset=80, longitud=4, texto=beta
Registro 3: offset=84, longitud=5, texto=gammaEl nombre usa el PID de la shell para reducir colisiones entre sesiones. Las direcciones varían y no forman parte de la salida esperada del contrato. Cada ejecución del lector abre y mapea por su cuenta.
La opción -lrt conserva compatibilidad con entornos donde shm_open requiere enlazar librt. Se compila en Linux o dentro de una distribución Linux de WSL, como en el tema 24.
Retirar el nombre del laboratorio
Para no repetir otro administrador completo, utiliza este programa mínimo. Guárdalo como retirar25.c. Solo admite el prefijo de este tema, pero aun así debes darle únicamente el nombre de tu propia prueba.
#include "catalogo25.h"
int main(int argc, char **argv)
{
if (argc != 2 || !nombre_valido(argv[1])) {
fprintf(stderr, "Uso: %s /ipc25_nombre\n", argv[0]);
return EXIT_FAILURE;
}
if (shm_unlink(argv[1]) == -1) {
perror("shm_unlink");
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}$ gcc -std=c17 -O2 -Wall -Wextra -Wpedantic retirar25.c -o retirar25 -lrt
$ ./retirar25 "$nombre"
$ ./leer25 "$nombre"
shm_open leer: No such file or directoryshm_unlink retira el nombre y no modifica los bytes de vistas existentes. Sus reglas de creación y retirada se documentan en shm_open(3). No uses el administrador del tema 24: aquel acepta deliberadamente un prefijo diferente.
13. Comprobar los offsets con dos vistas
Crea un catálogo nuevo o conserva el del ejemplo anterior antes de retirarlo. El modo doble mapea dos veces el mismo descriptor sin liberar primero ninguna vista.
$ ./crear25 "$nombre" alfa beta gamma && ./leer25 "$nombre" doble
Catalogo creado: 3 registros, 89 bytes
Vista A: 0x...
Vista B: 0x...
Version: 1; registros: 3; total: 89
Registro 1: offset=76, longitud=4, texto=alfa
A + offset = 0x...; B + offset = 0x...
Registro 2: offset=80, longitud=4, texto=beta
A + offset = 0x...; B + offset = 0x...
Registro 3: offset=84, longitud=5, texto=gamma
A + offset = 0x...; B + offset = 0x...
$ ./retirar25 "$nombre"Como ambas reservas siguen vivas y no se solicita reemplazar rangos, sus direcciones virtuales ocupan regiones distintas. La comprobación no depende de que el sistema elija direcciones distintas en dos procesos separados por casualidad.
El campo compartido sigue valiendo 76 para el primer registro. Un puntero absoluto formado desde A no describiría dónde está ese texto en B; la suma local desde B sí lo hace.
El modo doble es un experimento de reubicación dentro de un proceso. El uso normal entre creador y lector sigue siendo entre ejecutables independientes. No hay que mapear dos veces para consumir un catálogo.
14. Evolución de versiones y generaciones
Una versión identifica reglas de representación. Una generación identifica una instancia concreta de datos. Dos objetos distintos pueden tener versión 1 y contenidos diferentes. Cambiar la versión no reconecta un lector que conserva un mapeo de otra generación.
| Cambio propuesto | Decisión que debe documentarse | Conducta del lector actual |
|---|---|---|
| Agregar un campo a cada registro. | Nueva distribución y versión, o una extensión diseñada de antemano. | Rechaza un ancho diferente de 12. |
| Ampliar la cabecera. | Qué partes comprenden lectores antiguos y cuáles pueden ignorar. | Rechaza una cabecera diferente de 40. |
| Permitir textos vacíos. | Cambiar una regla semántica del formato. | Rechaza longitud cero. |
| Reutilizar un texto para varios registros. | Modificar la regla de continuidad y solapamiento. | Rechaza offsets que no siguen su cursor. |
| Crear otro catálogo con el mismo formato. | Definir su nombre y política de generaciones. | Puede leerlo si valida todas las reglas de versión 1. |
Un campo reservado no debe empezar a interpretarse de otra manera manteniendo la versión si los lectores antiguos exigen que sea cero. «Agregar al final» tampoco garantiza compatibilidad: nuestro lector exige coincidencia exacta entre el final del último texto y el total.
Para una evolución real puedes diseñar cabeceras extensibles, capacidades y lectores que entiendan varios formatos. Primero hay que especificar qué extensiones son compatibles. Este ejemplo prefiere rechazar lo desconocido de forma previsible.
No migres la estructura mientras hay lectores recorriéndola sin coordinación. Una estrategia posible para catálogos inmutables es preparar otra generación bajo otro nombre y comunicar cuál deben abrir las nuevas consultas. Las vistas anteriores pueden terminar sobre su objeto original.
15. Propiedad, mutación y recuperación
En nuestro contrato hay un solo escritor durante la construcción y ningún escritor después de publicarla. El creador es responsable de no admitir lectores antes del éxito. Los lectores solo poseen sus descriptores y mapeos; no reinicializan campos ni retiran el nombre al terminar.
El catálogo no incluye malloc compartido, eliminación de registros ni compactación en servicio. Si quisieras implementarlos tendrías que acordar cuándo una posición puede reutilizarse y cómo impedir que un lector siga una referencia cuyo destino cambió.
Un offset válido puede quedar obsoleto dentro del mismo rango si el objeto se modifica. El control de límites no detecta por sí solo que el registro ahora se refiere a otra entidad. Contadores de generación o identificadores pueden ayudar a diseñar esa validación, pero necesitan sus propias reglas de acceso.
Si el creador muere después de crear el nombre y antes de limpiarlo, puede quedar una región incompleta. El próximo intento exclusivo devuelve EEXIST. No adopta el objeto ni lo trata como disponible solo porque tenga tamaño suficiente.
La validación detecta desacuerdos de formato; no autentica al escritor ni tolera un tercero que modifique el respaldo mientras se consulta. Un proceso autorizado que cambie bytes después de validar rompe la premisa del recorrido. Copiar bytes mientras otro escribe tampoco garantiza obtener una instantánea consistente.
Los offsets resuelven referencias locales y el validador comprueba límites y reglas. La exclusión, la publicación concurrente y la recuperación ante fallos requieren mecanismos adicionales. El próximo tema mostrará qué ocurre cuando varios procesos modifican los mismos datos sin coordinarlos.
16. Explorar direcciones y validaciones
El catálogo de tres textos tiene 89 bytes y su área de textos comienza en 76. Cambia la base del lector B, el offset y la longitud de una referencia. El modelo solo forma una dirección local cuando el rango es válido y la cabecera indica versión y estado aceptables.
Puntero absoluto del creador A0x104c; no es una referencia reutilizable en B
Rango solicitado[76, 80), dentro de [76, 89)
Dirección reconstruida en B0x904c
Bytes seleccionadosalfa
La referencia inicial cabe; el lector usa su propia base.
Este explorador comprueba una referencia aislada. El validador C también exige identificadores, tabla completa y continuidad de todos los textos. Una selección que cruce de alfa a beta puede caber en el área y aun así no corresponder a un registro válido del catálogo original.
Seleccionar «Listo» en el modelo representa metadatos aceptables; no simula una operación de sincronización. Como en los programas, la consulta presupone que la construcción terminó y los datos ya no se modifican.
17. Pruebas del formato y diagnóstico
Entradas y tamaños
- Mínimo. Un texto de un byte produce un objeto de 53 bytes: 40 de cabecera, 12 de registro y 1 de contenido.
- Límite por registro. Un texto de 64 bytes se acepta; uno de 65 se rechaza antes de crear.
- Cantidad. Dieciséis registros se aceptan; diecisiete se rechazan antes de abrir el objeto.
- UTF-8. Con el texto ñ, la longitud habitual es 2 bytes. El programa transporta esos bytes sin contar letras.
- Colisión. Crear por segunda vez con el mismo nombre debe fallar y conservar el catálogo original.
Catálogos deliberadamente incompatibles
Para comprobar el lector, usa una copia de prueba del creador o una herramienta que prepare bytes controlados en un objeto propio. No cambies la cabecera original que comparten los tres ejecutables para ocultar un desacuerdo: queremos que el lector siga aplicando la versión 1.
| Mutación de prueba | Motivo de rechazo | Momento del control |
|---|---|---|
| Objeto de menos de 40 bytes. | No cabe la cabecera. | Antes del mapeo del lector. |
| Versión igual a 2. | Formato desconocido. | Validación de la cabecera. |
| Total declarado distinto de fstat. | Discrepancia de límites. | Validación de la cabecera. |
| Estado construyendo. | Objeto incompleto para este contrato. | Validación de la cabecera. |
| Cantidad enorme o ancho cero. | Tabla incompatible o imposible. | Antes de recorrer registros. |
| Offset 0xffffffff y longitud 64. | Destino ajeno al rango. | Antes de formar la referencia de texto. |
| Texto que apunta a la cabecera. | Zona semánticamente incorrecta. | Comparación con el cursor del área de textos. |
| Dos textos solapados o un hueco. | Se rompe la distribución canónica. | Recorrido de registros. |
| Bytes sobrantes al final. | El último destino no termina en el total. | Comprobación final del cursor. |
El creador normal valida su propia salida, así que una modificación que produzca un formato inválido será detectada y limpiada antes del éxito. Para probar el rechazo del lector con una fixture corrupta, una variante de prueba debe omitir deliberadamente esa autovalidación y dejar los bytes controlados. No retires esa comprobación del programa de uso normal.
$ ./leer25 /ipc25_fixture_invalida
Formato incompatible
$ echo $?
1La salida anterior supone que ya preparaste un objeto propio de tamaño aceptable con un formato inválido. Si el nombre no existe, el error esperado será de shm_open. El lector no borra la fixture al rechazarla; su responsable la retira después.
Comprobar la aritmética y la limpieza
Prueba rango con offset igual al total y longitud cero, con longitud uno, con offset superior al total y con valores muy grandes. Después comprueba los controles semánticos del catálogo: que un rango vacío quepa no hace válido un texto vacío.
Simula fallos de ftruncate y mmap después de una creación exitosa. Verifica que no queda el nombre propio. En cambio, si la creación falla por EEXIST, comprueba que el objeto anterior se conserva.
Repite el modo doble y verifica valores y referencias. No uses una dirección hexadecimal concreta como condición de éxito. El formato debe funcionar con cualquier base válida elegida por el sistema.
18. Resumen
- Compartir almacenamiento exige acordar cómo se interpretan sus bytes.
- Un puntero nativo no es una referencia estable entre mapeos independientes.
- Un offset desde la base permite reconstruir una dirección local después de validar.
- Los rangos se comprueban mediante restas y divisiones que evitan desbordamientos.
- Que una referencia quepa no demuestra que apunte a una zona semánticamente válida.
- Los tipos nativos, el padding y la alineación forman parte de las decisiones de representación.
- Una cabecera declara marca, versión, tamaños, estado y posiciones principales.
- El ejemplo codifica enteros explícitamente y usa textos con longitud, sin punteros ni terminadores.
- El lector valida todo el catálogo antes de consumir cualquier registro.
- LISTO describe un estado; la publicación requiere un orden de ejecución o sincronización adecuado.
- Una versión de formato y una generación de datos identifican conceptos diferentes.
- La inmutabilidad del catálogo mantiene válidas las comprobaciones durante el recorrido.
19. Preguntas de repaso y práctica
Intenta responder con las reglas del formato antes de desplegar la explicación.
1. ¿Por qué un char * dentro de una estructura compartida puede ser incorrecto?
Porque su valor es una dirección local de un proceso. Puede apuntar a memoria privada o no coincidir con la ubicación del destino en la vista de otro proceso.
2. ¿Qué origen utilizan los offsets del catálogo?
El primer byte de la región completa, mapeada desde el comienzo del objeto. No se interpretan respecto del registro ni del comienzo del área de textos.
3. ¿Por qué se valida antes de calcular base + offset?
Porque una dirección derivada de datos no comprobados puede quedar fuera del objeto. La validación debe preceder tanto al acceso como a la formación de una referencia que el programa pretenda utilizar.
4. ¿Qué ventaja tiene longitud <= total - offset?
Permite comprobar el límite sin sumar dos valores que podrían desbordar, siempre que antes se haya comprobado offset <= total.
5. ¿Por qué un texto dentro de la cabecera se rechaza aunque quepa?
Porque el formato exige que los textos estén después de la tabla y sigan el cursor canónico. Caber en memoria no equivale a respetar la distribución.
6. ¿offsetof elimina las diferencias de ABI?
No. Informa la distribución que utiliza un compilador para una estructura. Sirve para comprobar ese layout, no para imponerlo a todos los participantes.
7. ¿Por qué no se convierte b + offset a uint32_t *?
El formato se lee byte a byte para no depender de la alineación y del orden de bytes nativos. Los accesores reconstruyen explícitamente el entero.
8. ¿Por qué los textos no necesitan un terminador NUL?
Cada registro declara su longitud y el lector usa una salida acotada. No busca el final recorriendo memoria sin un límite.
9. ¿Qué evita la validación completa antes de imprimir?
Que se consuma un prefijo del catálogo antes de descubrir un registro posterior inválido. El recorrido de salida comienza con todos los campos y rangos ya comprobados.
10. ¿LISTO es una barrera de memoria entre procesos?
No. Es un campo ordinario del formato. La ejecución secuencial tras el éxito del creador y la ausencia de escritores permiten consultar este ejemplo.
11. ¿Puede cambiarse el formato manteniendo versión 1?
Solo si las reglas de compatibilidad lo prevén. Nuestro lector exige tamaños y distribución exactos, así que rechaza cambios no acordados.
12. ¿Por qué se mantienen dos mapeos vivos en el laboratorio?
Para observar dos bases distintas dentro del mismo proceso y demostrar que las referencias se reconstruyen localmente desde el mismo offset.
13. ¿Validar protege frente a un escritor concurrente?
No. Los bytes pueden cambiar después de la comprobación. Este catálogo se mantiene inmutable; permitir modificaciones exigiría un protocolo adicional.
14. ¿Una región de versión 1 siempre es la misma generación?
No. Varios objetos con datos distintos pueden respetar la misma versión. La generación identifica la instancia y la versión sus reglas de representación.
15. ¿Qué hace un creador nuevo si encuentra un nombre residual?
Falla con la creación exclusiva. No adopta, borra ni reinicializa automáticamente un objeto cuya propiedad y estado no ha establecido.
Para practicar y ampliar
- Reconstruye a mano los bytes del catálogo alfa, beta y gamma. Comprueba el total 89 y los offsets 76, 80 y 84.
- Crea un catálogo con un solo texto de un byte y otro con dieciséis textos de 64 bytes. Verifica los tamaños calculados.
- Ejecuta el lector en modo doble y relaciona cada dirección con su base y offset.
- Prueba las condiciones límite de rango sin acceder a la memoria del destino.
- Prepara fixtures propias con versión desconocida, ancho cero y offset excesivo. El lector debe rechazarlas sin imprimir registros.
- Comprueba el rechazo de un hueco, un solapamiento y bytes adicionales al final.
- Diseña una versión 2 con una etiqueta numérica adicional. Especifica primero todos los campos y reglas.
- Propón una variante que comparta textos repetidos y explica qué comprobaciones del cursor tendrías que sustituir.
- Diseña una lista enlazada mediante offsets. Incluye cómo limitar el recorrido y detectar ciclos.
- Describe un reemplazo por generaciones que permita terminar a lectores antiguos sin modificar su catálogo.
El tema 26 estudiará carreras de datos en memoria compartida: por qué compartir no sincroniza, cómo se pierden actualizaciones y qué límites tienen las demostraciones basadas solamente en repetir una ejecución.