1. Un semáforo alojado en la región
En el tema 27 sem_open creaba o abría un recurso con nombre y devolvía una referencia local. El contador estaba en una región compartida distinta. Ahora almacenaremos el semáforo y los datos que protege dentro de la misma región.
struct region {
sem_t mutex;
uint64_t contador;
};El programa reserva espacio para la estructura completa. El proceso responsable inicializa mutex con sem_init. Los demás utilizan la dirección del miembro dentro de su propia vista de la región.
Un semáforo sin nombre se identifica por el objeto sem_t situado en almacenamiento compartido, no por un nombre pasado a sem_open. Todos deben operar sobre ese mismo objeto, sin copiarlo.
| Decisión | Con nombre | Sin nombre entre procesos |
|---|---|---|
| Preparación. | sem_open con creación. | Reservar almacenamiento compartido y llamar a sem_init. |
| Conexión. | Abrir el nombre o heredar una referencia. | Acceder a la región que contiene el objeto. |
| Espera y publicación. | sem_wait y sem_post. | Las mismas operaciones sobre la dirección local del miembro. |
| Finalización. | sem_close y retirada del nombre con sem_unlink. | sem_destroy una vez que no quedan usuarios; después liberar la región. |
El almacenamiento puede ser anónimo y heredarse con fork, o proceder de un objeto de memoria compartida con nombre. Que el respaldo tenga un nombre no convierte al semáforo que contiene en uno abierto mediante sem_open.
2. sem_init y sem_destroy
int sem_init(sem_t *s, int pshared, unsigned int valor);
int sem_destroy(sem_t *s);Ambas funciones retornan cero al tener éxito y −1 al fallar, con el motivo en errno. sem_init recibe la dirección de almacenamiento que ya existe: no devuelve un nuevo sem_t * como sem_open.
pshared igual a cero selecciona uso entre hilos de un mismo proceso. Un valor distinto de cero selecciona uso entre procesos y requiere que el objeto esté en memoria realmente compartida. Usaremos el valor 1 para expresarlo, según sem_init(3).
if (sem_init(&r->mutex, 1, 1) == -1) {
perror("sem_init");
/* No utilizar ni destruir un semaforo cuya inicializacion fallo. */
}Los dos unos tienen significados distintos. El segundo argumento elige el ámbito entre procesos; el tercero establece un permiso inicial para exclusión. Un canal de notificación podría usar pshared igual a 1 y valor inicial cero.
Algunos sistemas pueden no soportar semáforos compartidos entre procesos y devolver ENOSYS. Un valor inicial fuera de los límites puede producir EINVAL. Los ejemplos comprueban el retorno y no continúan suponiendo que todos los entornos tienen idéntico soporte.
3. Dos condiciones para compartir entre procesos
| Ubicación de sem_t | pshared | Interpretación |
|---|---|---|
| Variable privada en pila o heap habitual. | 0. | Puede servir para hilos del mismo proceso; no es coordinación entre procesos. |
| Variable privada después de fork. | 1. | Configuración incorrecta: el argumento no transforma la memoria privada en compartida. |
| Región MAP_SHARED. | 0. | No se configura para comunicar procesos; no debe usarse así aunque alguna prueba parezca funcionar. |
| Región MAP_SHARED. | 1. | Combinación apropiada para el objetivo de este tema, con inicialización y ciclo de vida correctos. |
fork no convierte una variable global ordinaria en compartida. Si colocas sem_t en una variable privada y cada hijo modifica su copia, ya no estás usando el mismo almacenamiento del semáforo.
MAP_PRIVATE tampoco sirve para construir este canal. Aunque las vistas comiencen con contenido parecido, sus escrituras privadas no constituyen el objeto compartido que requiere el protocolo.
Una prueba sin contención puede no revelar una configuración equivocada. No aceptes como demostración que «el primer sem_wait no se bloqueó». Importan tanto la ubicación del objeto como la configuración de las operaciones de espera entre procesos.
4. Ubicación, alineación y objeto opaco
Coloca sem_t como un miembro normal de una estructura nativa y reserva sizeof de la estructura. El compilador determinará su alineación y el padding que necesita. No fuerces un empaquetado que deje el semáforo desalineado.
sem_t es opaco: no se editan sus campos internos, no se serializa como los enteros del catálogo del tema 25 y no se copia con una asignación de estructuras o memcpy después de inicializarlo.
El tamaño y la representación pueden depender de la implementación y ABI. Los participantes que comparten una estructura nativa con sem_t deben utilizar un entorno compatible. Una marca de versión o sizeof coincidente no demuestra por sí sola toda la compatibilidad binaria.
Dos procesos independientes pueden tener bases distintas. Cada uno obtiene &r->mutex desde su propio mapeo. No es necesario que coincidan las direcciones virtuales ni que se almacene un puntero a mutex dentro de la región.
No hagas memset de toda la estructura después de sem_init. El cero binario no equivale a una inicialización POSIX y puede destruir el estado interno de un semáforo ya activo. Inicializa datos ordinarios de manera separada o realiza la preparación de bytes antes de crear los semáforos.
5. Inicialización única antes de fork
- Reservar la región compartida. Obtener un mapeo válido para la estructura completa.
- Preparar los datos. Asignar valores iniciales a los campos de aplicación.
- Inicializar cada semáforo una vez. Registrar cuáles tuvieron éxito.
- Crear participantes. Solo entonces ejecutar fork y permitir operaciones sobre los semáforos.
El padre es el único inicializador. Los hijos heredan el mapeo ya preparado y utilizan sus miembros. No ejecutan sem_init al entrar a su rama de código.
Reinicializar un semáforo que ya está inicializado tiene comportamiento indefinido. No es una forma de restaurar su valor ni de desbloquear esperadores. Tampoco debe decidirse que «todavía no está inicializado» observando bytes internos.
Si hay varios semáforos y falla la preparación del segundo, el programa destruye solo el primero, porque todavía no existen usuarios. Un indicador local de inicialización permite tomar esa decisión sin consultar un objeto inválido.
6. Usar, terminar usuarios y destruir
PADRE HIJOS
mmap MAP_SHARED
inicializar datos
sem_init(..., 1, valor)
fork ----------------------------> utilizar sem_wait / sem_post
supervisar terminar operaciones
recoger todos <------------------ munmap de su vista y _exit
comprobar que no quedan usuarios
sem_destroy
munmap de la regionEl hijo retira su mapeo al terminar, pero no destruye el semáforo común. Esa destrucción corresponde al responsable cuando sabe que no existe ningún usuario presente ni futuro de esa generación.
Destruir un semáforo con participantes bloqueados sobre él tiene comportamiento indefinido. sem_destroy no es una operación de cancelación ni una forma de despertar esperadores, como advierte sem_destroy(3).
El orden es importante: sem_destroy antes de liberar el almacenamiento que contiene el objeto. Después de munmap ya no se puede formar una referencia válida para destruirlo. El valor del semáforo no prueba que nadie vaya a usarlo.
Una ejecución que termina en error también debe resolver quiénes siguen vivos antes de destruir. Los programas de este tema cancelan a los hijos pendientes ante un fallo y los recogen antes de desmontar la región.
7. Código de apoyo y supervisión
Guarda apoyo28.h. Incluye validación de cantidades, espera de permisos con reintento de EINTR y un supervisor que recoge al hijo que termine. Ante fallo, cancela solo hijos todavía no recogidos.
La salida sin_usuarios confirma si se recogieron todos los hijos conocidos. Si esa condición no puede comprobarse, el padre no llama a sem_destroy como si la destrucción fuera segura.
#ifndef APOYO28_H
#define APOYO28_H
#define _DEFAULT_SOURCE
#include <errno.h>
#include <inttypes.h>
#include <semaphore.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <unistd.h>
struct hijo { pid_t pid; int recogido; };
static inline int numero(const char *s, unsigned maximo, unsigned *salida)
{
if (!*s) return -1;
for (const char *p = s; *p; ++p)
if (*p < '0' || *p > '9') return -1;
errno = 0;
char *fin;
unsigned long n = strtoul(s, &fin, 10);
if (errno || *fin || n == 0 || n > maximo) return -1;
*salida = (unsigned)n;
return 0;
}
static inline int esperar_permiso(sem_t *s)
{
int r;
do { r = sem_wait(s); } while (r == -1 && errno == EINTR);
return r;
}
static inline int recoger(struct hijo *h, unsigned n, int cancelar,
int *sin_usuarios)
{
int fallo = cancelar;
unsigned recogidos = 0;
while (!fallo && recogidos < n) {
int estado;
pid_t pid;
do { pid = waitpid(-1, &estado, 0); } while (pid == -1 && errno == EINTR);
if (pid == -1) { perror("waitpid"); fallo = 1; break; }
unsigned i = 0;
while (i < n && h[i].pid != pid) ++i;
if (i == n || h[i].recogido) {
fprintf(stderr, "PID inesperado\n"); fallo = 1; break;
}
h[i].recogido = 1;
++recogidos;
if (!WIFEXITED(estado) || WEXITSTATUS(estado) != 0) {
fprintf(stderr, "Hijo fallido: se cancela la ejecucion\n");
fallo = 1;
}
}
if (fallo) {
for (unsigned i = 0; i < n; ++i)
if (!h[i].recogido && kill(h[i].pid, SIGKILL) == -1 && errno != ESRCH)
perror("kill hijo pendiente");
for (unsigned i = 0; i < n; ++i) {
if (h[i].recogido) continue;
int estado;
pid_t pid;
do { pid = waitpid(h[i].pid, &estado, 0); }
while (pid == -1 && errno == EINTR);
if (pid == -1) perror("waitpid limpieza");
else h[i].recogido = 1;
}
}
*sin_usuarios = 1;
for (unsigned i = 0; i < n; ++i)
if (!h[i].recogido) *sin_usuarios = 0;
return fallo ? -1 : 0;
}
#endifEl supervisor se utiliza en programas independientes, de un solo hilo antes de fork, sin otros hijos ni recolectores. Se llama una vez por ejecución y conoce todas las referencias a la región. En otro servicio habría que incorporar al contrato cualquier usuario externo.
La cancelación no intenta restaurar permisos ni datos. Descarta la operación y asegura la terminación de los usuarios conocidos. Se envía SIGKILL a todos los pendientes antes de esperarlos, evitando quedar esperando uno mientras otro conserva un permiso perdido.
8. Programa: contador con semáforo embebido
Guarda contador28.c. El comportamiento esperado coincide con el contador del tema 27, pero ahora no hay sem_open, nombre de semáforo ni referencias que cerrar con sem_close.
#include "apoyo28.h"
struct region {
sem_t mutex;
uint64_t contador;
};
static int trabajar(struct region *r, unsigned iteraciones)
{
for (unsigned i = 0; i < iteraciones; ++i) {
if (esperar_permiso(&r->mutex) == -1) return 2;
uint64_t anterior = r->contador;
r->contador = anterior + 1;
if (sem_post(&r->mutex) == -1) return 3;
}
return 0;
}
int main(int argc, char **argv)
{
unsigned cantidad, iteraciones;
if (argc != 3 || numero(argv[1], 8, &cantidad) == -1 ||
numero(argv[2], 1000000, &iteraciones) == -1) {
fprintf(stderr, "Uso: %s trabajadores(1..8) iteraciones(1..1000000)\n",
argv[0]);
return EXIT_FAILURE;
}
struct region *r = mmap(NULL, sizeof *r, PROT_READ | PROT_WRITE,
MAP_SHARED | MAP_ANONYMOUS, -1, 0);
if (r == MAP_FAILED) { perror("mmap"); return EXIT_FAILURE; }
r->contador = 0;
int inicializado = 0, fallo = 0, sin_usuarios = 1;
struct hijo hijos[8];
unsigned creados = 0;
if (sem_init(&r->mutex, 1, 1) == -1) {
perror("sem_init"); fallo = 1; goto fin;
}
inicializado = 1;
for (unsigned i = 0; i < cantidad; ++i) {
pid_t pid = fork();
if (pid == -1) { perror("fork"); fallo = 1; goto fin; }
if (pid == 0) {
int codigo = trabajar(r, iteraciones);
/* Un usuario retira su vista, no destruye el objeto comun. */
if (munmap(r, sizeof *r) == -1) codigo = 4;
_exit(codigo);
}
hijos[creados++] = (struct hijo){pid, 0};
}
fin:
if (recoger(hijos, creados, fallo, &sin_usuarios) == -1) fallo = 1;
if (!fallo) {
uint64_t esperado = (uint64_t)cantidad * iteraciones;
printf("Hijos recogidos: %u\nEsperado: %" PRIu64 "\nContador: %" PRIu64 "\n",
creados, esperado, r->contador);
if (r->contador != esperado) fallo = 1;
}
if (inicializado && sin_usuarios) {
if (sem_destroy(&r->mutex) == -1) {
perror("sem_destroy"); fallo = 1;
}
} else if (inicializado) {
fprintf(stderr, "No se destruye: no se confirmo el fin de usuarios\n");
fallo = 1;
}
if (munmap(r, sizeof *r) == -1) { perror("munmap padre"); fallo = 1; }
return fallo ? EXIT_FAILURE : EXIT_SUCCESS;
}El indicador inicializado solo se activa después del retorno cero de sem_init. Si falla, no se invoca sem_destroy sobre ese almacenamiento. Como aún no se crearon hijos, la limpieza puede retirar inmediatamente el mapeo.
El padre lee el contador después de la recolección correcta. El semáforo protege las modificaciones durante el trabajo; la recolección fija el momento de consulta final. No hace falta volatile ni sincronización mediante demoras.
9. Compilar y verificar el contador
$ gcc -std=c17 -O2 -Wall -Wextra -Wpedantic contador28.c -o contador28 -pthread
$ ./contador28 2 100000
Hijos recogidos: 2
Esperado: 200000
Contador: 200000
$ ./contador28 8 1000
Hijos recogidos: 8
Esperado: 8000
Contador: 8000La opción -pthread configura la compilación y el enlace para estas interfaces. La macro _DEFAULT_SOURCE de la cabecera expone MAP_ANONYMOUS en glibc con C17 estricto.
La cantidad máxima es ocho millones de incrementos, representable en uint64_t. La aceptación no depende de un orden alternado de los trabajadores: cada incremento protegido conserva la contribución anterior.
No aparecerá un nombre sem.ipc28 en /dev/shm porque no se creó un semáforo con nombre. La región de estos ejemplos también es anónima; su vida útil depende de las vistas que conserva la familia de procesos.
10. Un canal de una sola casilla
Un segundo ejemplo permitirá observar dos semáforos en la misma región. Un productor escribe números consecutivos en una casilla y un consumidor verifica su secuencia y suma sus cuadrados. Solo puede existir un valor pendiente en cada momento.
| Semáforo | Valor inicial | Significado |
|---|---|---|
| libre. | 1. | El productor puede escribir en la casilla. |
| datos. | 0. | Hay una unidad disponible para consumir. |
PRODUCTOR CONSUMIDOR
esperar libre esperar datos
escribir valor leer y validar valor
publicar datos publicar libre
PADRE
inicializar libre y datos antes de fork
esperar a ambos hijos
verificar la suma
destruir datos y libre
retirar su mapeoEl productor no sobrescribe hasta recibir libre de nuevo. El consumidor no lee hasta adquirir datos. El permiso comunica que la fase anterior terminó, evitando que ambos accedan de manera conflictiva a la casilla.
No hay un mutex adicional porque existe un productor, un consumidor y una sola casilla con propiedad transferida por las dos esperas. Con varios productores o consumidores habría que volver a analizar la propiedad de cada campo y los índices.
La cantidad de elementos es conocida por ambos hijos. No necesitamos todavía mensajes de fin ni un búfer circular; esos elementos se integrarán en el proyecto del tema 30.
11. Programa: productor y consumidor
Guarda canal28.c. Acepta entre 1 y 1000 elementos. El padre inicializa ambos semáforos antes de lanzar hijos, registra cuántas inicializaciones tuvieron éxito y utiliza el supervisor de la cabecera.
#include "apoyo28.h"
struct canal {
sem_t libre;
sem_t datos;
uint64_t valor;
uint64_t suma;
};
static int producir(struct canal *r, unsigned cantidad)
{
for (unsigned i = 1; i <= cantidad; ++i) {
if (esperar_permiso(&r->libre) == -1) return 2;
r->valor = i;
if (sem_post(&r->datos) == -1) return 3;
}
return 0;
}
static int consumir(struct canal *r, unsigned cantidad)
{
uint64_t suma = 0;
for (unsigned i = 1; i <= cantidad; ++i) {
if (esperar_permiso(&r->datos) == -1) return 4;
uint64_t valor = r->valor;
if (valor != i) return 5;
suma += valor * valor;
if (sem_post(&r->libre) == -1) return 6;
}
r->suma = suma;
return 0;
}
int main(int argc, char **argv)
{
unsigned cantidad;
if (argc != 2 || numero(argv[1], 1000, &cantidad) == -1) {
fprintf(stderr, "Uso: %s elementos(1..1000)\n", argv[0]);
return EXIT_FAILURE;
}
struct canal *r = mmap(NULL, sizeof *r, PROT_READ | PROT_WRITE,
MAP_SHARED | MAP_ANONYMOUS, -1, 0);
if (r == MAP_FAILED) { perror("mmap"); return EXIT_FAILURE; }
r->valor = 0;
r->suma = 0;
sem_t *semaforos[2] = {&r->libre, &r->datos};
unsigned valores[2] = {1, 0};
unsigned inicializados = 0, creados = 0;
int fallo = 0, sin_usuarios = 1;
struct hijo hijos[2];
for (unsigned i = 0; i < 2; ++i) {
if (sem_init(semaforos[i], 1, valores[i]) == -1) {
perror("sem_init canal"); fallo = 1; goto fin;
}
++inicializados;
}
for (unsigned i = 0; i < 2; ++i) {
pid_t pid = fork();
if (pid == -1) { perror("fork"); fallo = 1; goto fin; }
if (pid == 0) {
int codigo = i == 0 ? producir(r, cantidad) : consumir(r, cantidad);
if (munmap(r, sizeof *r) == -1) codigo = 7;
_exit(codigo);
}
hijos[creados++] = (struct hijo){pid, 0};
}
fin:
if (recoger(hijos, creados, fallo, &sin_usuarios) == -1) fallo = 1;
if (!fallo) {
uint64_t n = cantidad;
uint64_t esperado = n * (n + 1) * (2 * n + 1) / 6;
printf("Elementos: %u\nSuma de cuadrados: %" PRIu64 "\nEsperado: %" PRIu64 "\n",
cantidad, r->suma, esperado);
if (r->suma != esperado) fallo = 1;
}
if (sin_usuarios) {
while (inicializados > 0) {
--inicializados;
if (sem_destroy(semaforos[inicializados]) == -1) {
perror("sem_destroy canal"); fallo = 1;
}
}
} else {
fprintf(stderr, "No se destruye: no se confirmo el fin de usuarios\n");
fallo = 1;
}
if (munmap(r, sizeof *r) == -1) { perror("munmap padre"); fallo = 1; }
return fallo ? EXIT_FAILURE : EXIT_SUCCESS;
}El array semaforos contiene punteros locales para recorrer los dos miembros durante preparación y limpieza. No se guarda ese array en la región ni se copia su contenido a otro proceso para conectarlo.
El consumidor mantiene la acumulación en una variable privada y publica suma al terminar. El padre no consulta ese campo hasta recoger a ambos hijos. Las operaciones sobre valor, en cambio, se coordinan durante todo el intercambio.
Si falla la segunda inicialización, inicializados vale uno y se destruye solamente libre. Si falla el segundo fork, el productor existente puede estar esperando libre: el supervisor lo cancela y recoge antes de destruir los semáforos.
12. Verificar el intercambio y sus invariantes
$ gcc -std=c17 -O2 -Wall -Wextra -Wpedantic canal28.c -o canal28 -pthread
$ ./canal28 1
Elementos: 1
Suma de cuadrados: 1
Esperado: 1
$ ./canal28 10
Elementos: 10
Suma de cuadrados: 385
Esperado: 385
$ ./canal28 1000
Elementos: 1000
Suma de cuadrados: 333833500
Esperado: 333833500El resultado usa la suma de cuadrados de 1 a N: N × (N + 1) × (2N + 1) / 6. Con el límite de 1000 los valores intermedios caben en uint64_t. No se aceptan cantidades externas sin límite antes de multiplicar.
La casilla es de capacidad uno, pero puede transportar mil unidades porque sus permisos se reutilizan. No se necesita reservar un array para todos los valores ni enviar un permiso que corresponda a contenido todavía no escrito.
| Fase | Quién puede actuar sobre valor | Qué cambia de permiso |
|---|---|---|
| Casilla disponible. | Productor después de adquirir libre. | Retira el derecho a sobrescribir de otro turno. |
| Valor escrito. | El productor ya terminó su acceso. | Publica datos para habilitar al consumidor. |
| Valor disponible. | Consumidor después de adquirir datos. | Consume la unidad pendiente. |
| Lectura terminada. | El consumidor ya no necesita el valor. | Publica libre para el próximo turno. |
Durante el trabajo puede haber un permiso adquirido que todavía no se haya publicado en el otro semáforo. Por eso no se impone que una consulta aislada muestre siempre libre + datos igual a uno. La invariancia describe el derecho a utilizar la casilla, incluyendo al participante que está procesando una transición.
Al terminar normalmente, el último dato ya fue consumido y libre volvió a publicarse. Sin embargo, para decidir la destrucción utilizamos la terminación de usuarios, no el valor final de esos contadores.
13. Procesos independientes y publicación de la región
Un semáforo sin nombre también puede ser usado por procesos independientes si está dentro de un objeto de memoria compartida al que todos conectan. La ausencia de un nombre de semáforo no exige parentesco; exige localizar el mismo almacenamiento.
CREADOR
shm_open con O_CREAT | O_EXCL y O_RDWR
ftruncate al tamano nativo acordado
mmap MAP_SHARED, PROT_READ | PROT_WRITE
inicializar datos y sem_init(..., 1, valor), una sola vez
publicar la disponibilidad mediante un protocolo externo
PARTICIPANTE
shm_open existente con O_RDWR
fstat y comprobar contrato de distribucion
mmap MAP_SHARED, PROT_READ | PROT_WRITE
esperar confirmacion de inicializacion antes de usar sem_t
sem_wait / sem_post sobre el miembro local
munmap al desconectarse; no sem_destroy por su cuentaIncluso un consumidor que solo lee los datos de aplicación necesita poder modificar el almacenamiento del semáforo al hacer sem_wait y sem_post. Un mapeo PROT_READ de la estructura entera no basta para esas operaciones.
El tamaño correcto, una marca ordinaria o el simple hecho de encontrar el nombre no garantizan que sem_init haya terminado. El creador exclusivo elige quién prepara el objeto, pero no vuelve atómica la secuencia completa de preparación y publicación.
Una solución inicial puede ejecutar participantes solo después del éxito del creador, como en los temas 24 y 25. Un servicio concurrente necesita otro canal o un protocolo de arranque ya establecido. No se puede esperar sobre el propio semáforo todavía no inicializado para averiguar si su inicialización terminó.
El responsable de destruir debe saber que todos los participantes independientes se desconectaron y que ninguno podrá volver a operar sobre esa generación. Recoger hijos con waitpid solo demuestra la salida de esos hijos, no la de clientes ajenos.
El nombre del objeto compartido se gestiona con shm_unlink y su descriptor con close. Esas operaciones no sustituyen sem_destroy. El mecanismo de conexión a regiones se describe en shm_open(3).
14. Inicialización parcial y rutas de error
| Punto de fallo | Estado real | Limpieza válida |
|---|---|---|
| mmap. | No hay región utilizable. | No acceder, no inicializar y no destruir. |
| Primer sem_init. | Ningún semáforo confirmado como inicializado. | Retirar el mapeo, sin sem_destroy sobre ese objeto. |
| Segundo sem_init. | El primero está preparado; aún no hay usuarios. | Destruir solo el primero y retirar la región. |
| fork intermedio. | Hay semáforos y algunos hijos conocidos. | Cancelar y recoger hijos; después destruir los inicializados. |
| Trabajo de un hijo. | Puede haber un permiso o dato incompleto. | Descartar la ejecución, terminar usuarios y destruir. |
| Recolección no confirmada. | No se pudo demostrar que todos salieron. | No efectuar una destrucción suponiendo ausencia de usuarios. |
El registro de inicialización pertenece al responsable de preparar y desmontar. No es una bandera compartida para que cualquier proceso compita por inicializar «si está a cero».
Los programas destruyen en orden inverso a la preparación por claridad. Lo esencial es destruir únicamente objetos inicializados y hacerlo cuando ya no haya usuarios, no el orden nominal de los dos miembros.
La rama hija no tiene responsabilidad de rollback de la inicialización global. Su responsabilidad es dejar de usar los objetos y terminar. Si destruyera un semáforo al salir mientras otro hijo continúa, rompería el contrato del grupo.
En una aplicación larga hay que tratar también fallos de la propia destrucción y de liberación. No se reutiliza a ciegas un sem_t cuyo desmontaje no se comprende. Los ejemplos informan el error y finalizan sin presentar la operación como exitosa.
15. Destrucción y límites de recuperación
sem_destroy no comprueba por ti todo el protocolo de vida útil. No debes provocar una destrucción con esperadores para comprobar si la biblioteca devuelve EBUSY: la precondición ya se incumplió y no existe esa garantía general de detección.
Consultar sem_getvalue tampoco demuestra que no haya usuarios. Un valor disponible no excluye que otro participante esté a punto de ejecutar sem_wait; un valor cero tampoco distingue todas las razones por las que falta un permiso.
Una terminación anormal puede dejar un semáforo sin permisos. Después de cancelar y recoger a todos los usuarios conocidos, se puede destruir el objeto inicializado aunque no haya vuelto al valor inicial. La precondición importante es la ausencia de usuarios y esperadores, no restablecer artificialmente el contador.
Los ejemplos aplican fallo total. No publican permisos extra para salvar una ejecución parcial ni reinicializan el objeto mientras hay procesos vivos. Un servicio que deba continuar tras una caída necesitaría un diseño explícito de consistencia y recuperación.
No hay un plazo global de supervisión: un hijo suspendido sin terminar puede mantener al padre esperando. Las esperas temporales y las políticas de recuperación se abordarán en el tema 29. Una caída abrupta del padre tampoco ejecuta sus llamadas a sem_destroy.
Si un padre retira su propia vista sin destruir porque no logró confirmar la salida de todos, eso no retira las vistas de los demás. Se evita la destrucción insegura, pero no se promete una limpieza global completa en una situación fuera de las condiciones del supervisor.
16. Explorar el ciclo de vida
El modelo permite intentar operaciones en orden correcto o incorrecto. Primero reserva la región, inicializa y lanza dos usuarios. Después puedes representar esperadores y terminar al grupo antes de destruir. Los intentos inválidos se rechazan didácticamente, sin ejecutar comportamiento indefinido real.
Región del responsableNo reservada
SemáforoNo inicializado
Usuarios y esperadores0 usuarios; 0 esperadores
Responsabilidad pendienteReservar almacenamiento
La ubicación y pshared deben corresponder al uso entre procesos.
«Terminar y recoger usuarios» representa una fase completa del supervisor. Si había esperadores, incluye cancelarlos y confirmar su terminación; no presupone que sem_destroy los despertó. Este modelo estudia vida útil, no el balance interno de permisos.
Cambiar almacenamiento o pshared reinicia el experimento. La configuración de hilos puede inicializar un semáforo local válido, pero el modelo no permite usarlo como si fuera coordinación entre procesos.
17. Pruebas, observación y diagnóstico
Comprobar resultados sin depender del reparto
$ ./contador28 1 1
Hijos recogidos: 1
Esperado: 1
Contador: 1
$ for prueba in 1 2 3 4 5; do ./canal28 1000 || exit 1; done
$ ./canal28 0
Uso: ./canal28 elementos(1..1000)Prueba entradas no numéricas, negativas y fuera de rango. Deben rechazarse antes de crear la región. Para el contador valida cantidad × iteraciones; para el canal valida orden de elementos y suma, no solo el número de operaciones terminadas.
Inyectar fallos con recursos propios
- Primer sem_init fallido. Simula ENOSYS en una copia y comprueba que no se destruye un objeto no inicializado.
- Segundo sem_init fallido. Simula el fallo en canal28 y verifica que solo se destruye libre.
- Segundo fork fallido. Comprueba que el productor existente se cancela y recoge, aunque ya esté esperando una casilla disponible.
- Consumidor fallido. Fuerza su salida tras adquirir datos. El supervisor debe cancelar al productor pendiente y descartar la suma.
- Escritor fallido con permiso. En el contador fuerza una salida después de sem_wait. El resto se cancela; no se intenta restaurar el valor con sem_init.
No pruebes configuraciones incorrectas de pshared, destrucciones activas o copias de sem_t esperando un error seguro. Analiza esos casos con el simulador o revisa el código: algunas violaciones no tienen un resultado definido que un test pueda exigir.
Observar esperas y accesos
$ strace -f -e trace=mmap,munmap,futex,clone,fork,vfork,wait4 ./canal28 10La traza puede mostrar mapeos, bloqueos, creación de hijos y esperas. No esperes una llamada al sistema sem_init ni un futex por cada sem_wait: parte del trabajo puede resolverse en la biblioteca sin entrar al núcleo.
Los mecanismos generales de espera y publicación son los mismos que en el tema anterior. Lo que cambia aquí es dónde vive el semáforo, cómo se inicializa y quién puede destruirlo. La distinción entre ambas clases se resume en sem_overview(7).
| Síntoma | Revisión | Decisión correcta |
|---|---|---|
| Solo funciona sin contención. | Ubicación y pshared. | Objeto realmente compartido y configuración entre procesos. |
| Un hijo empieza con otro estado. | Se inicializó después de fork o en cada hijo. | Un inicializador antes de admitir usuarios. |
| El consumidor lee valores repetidos. | Permisos de casilla y acceso fuera de fase. | Esperar datos antes de leer y libre antes de sobrescribir. |
| La limpieza llama a sem_close. | Se mezclaron clases de semáforo. | sem_destroy para el objeto inicializado con sem_init. |
| Se pierde el objeto al retirar una vista. | Se intenta destruir después de munmap. | Destruir antes de liberar su almacenamiento, sin usuarios. |
| Se bloquea la recuperación. | Hay un usuario vivo detenido o un permiso perdido. | Definir supervisión y cancelación; no reinicializar a ciegas. |
18. Resumen
- Un semáforo sin nombre vive en un objeto sem_t cuyo almacenamiento aporta la aplicación.
- Para procesos se necesitan memoria compartida y pshared distinto de cero.
- pshared no convierte una variable privada en compartida.
- sem_init se ejecuta una sola vez antes de que los usuarios operen.
- sem_t es opaco: no se copia, serializa ni pone a cero después de inicializar.
- Los participantes usan sem_wait y sem_post sobre la dirección local del mismo miembro.
- Los hijos retiran sus vistas; el responsable destruye el objeto común al final.
- sem_destroy no cancela ni despierta de forma válida a esperadores.
- Primero se confirma el fin de usuarios, después se destruye y finalmente se libera la región.
- Una preparación parcial solo limpia los semáforos inicializados correctamente.
- Un objeto shm_open puede contener semáforos sin nombre, con publicación y ABI acordadas.
- El canal de una casilla transfiere el derecho a escribir y leer mediante dos semáforos.
19. Preguntas de repaso y práctica
Responde antes de desplegar las explicaciones.
1. ¿Qué cambia respecto de un semáforo con nombre?
La aplicación reserva el almacenamiento del sem_t y lo inicializa con sem_init. No se obtiene una referencia mediante sem_open ni se administra un nombre de semáforo.
2. ¿Qué significan los dos unos de sem_init(&r->mutex, 1, 1)?
El primero configura uso entre procesos; el segundo concede un permiso inicial para exclusión. Son parámetros con funciones distintas.
3. ¿pshared igual a uno basta si sem_t está en la pila?
No. El objeto debe estar en memoria realmente compartida. El argumento no cambia la clase de almacenamiento.
4. ¿Por qué no se usa pshared cero entre padre e hijo?
Porque esa configuración corresponde a hilos de un mismo proceso. Que los bytes estén en un mapeo compartido no cambia el ámbito seleccionado para el semáforo.
5. ¿Puede cada hijo llamar a sem_init al empezar?
No sobre el mismo objeto ya inicializado. El responsable lo prepara una sola vez antes de admitir usuarios; reinicializarlo activo tiene comportamiento indefinido.
6. ¿Por qué sem_t se coloca como miembro normal de una estructura?
Para que el compilador respete su alineación y tamaño nativos. No se debe empaquetar ni manipular su representación interna.
7. ¿Se puede copiar la estructura después de inicializar los semáforos?
No para crear otro objeto utilizable por copia de sem_t. Los usuarios deben acceder al objeto original en el respaldo compartido.
8. ¿Por qué el hijo solo ejecuta munmap al terminar?
Retira su vista local. Destruir el semáforo común mientras otro usuario sigue operando sería una violación del ciclo de vida.
9. ¿Cuándo es seguro ejecutar sem_destroy?
Cuando el semáforo fue inicializado correctamente y se ha establecido que no quedan usuarios ni esperadores y que no podrán aparecer nuevos usos de esa generación.
10. ¿sem_destroy debe devolver un error si hay esperadores?
No se puede depender de eso. Destruir con procesos o hilos bloqueados incumple la precondición y tiene comportamiento indefinido.
11. ¿Qué se limpia si falla el segundo sem_init?
Solo el primer semáforo que terminó de inicializarse y el almacenamiento reservado, siempre antes de que existan usuarios.
12. ¿Por qué el canal no necesita otro mutex para la casilla?
Porque un único productor y un único consumidor transfieren el derecho a acceder mediante libre y datos. No pueden sobrescribir y leer la casilla de manera conflictiva si respetan ese protocolo.
13. ¿Un lector independiente puede mapear toda la estructura con PROT_READ?
No si va a ejecutar sem_wait o sem_post sobre el semáforo embebido, porque esas operaciones modifican su almacenamiento. Necesita acceso de escritura al área correspondiente.
14. ¿Un valor inicial recupera automáticamente un objeto tras una caída?
No. No debe reinicializarse mientras haya usuarios. Los ejemplos cancelan, recogen, descartan el estado y destruyen al final.
15. ¿Un nombre shm_open hace que el semáforo interno tenga nombre?
No. El nombre localiza la región, pero el semáforo interno se creó con sem_init y se destruye con sem_destroy.
Para practicar y ampliar
- Compara contador27 y contador28 e identifica qué operaciones de preparación y limpieza cambian.
- Dibuja la vida del miembro mutex desde mmap hasta el munmap final.
- Ejecuta el contador con uno y ocho hijos y comprueba el total sin exigir alternancia.
- Calcula a mano los permisos y el propietario de la casilla durante tres intercambios del canal.
- Simula el fallo de la segunda inicialización y comprueba qué sem_destroy debe ejecutarse.
- Simula el fallo del segundo fork y la salida anormal de un consumidor con un permiso adquirido.
- Usa el explorador para intentar destruir con usuarios y retirar almacenamiento antes de destruir.
- Diseña una conexión a un objeto shm_open con el mismo sem_t embebido, explicando cómo confirmarías la inicialización.
- Explica por qué una versión de datos portable no convierte sem_t en una representación portable entre bibliotecas.
- Propón cómo pasar de una casilla a un búfer circular, identificando qué índices y permisos adicionales habrá que coordinar.
El tema 29 estudiará esperas, errores y recuperación: sem_trywait, sem_timedwait, EINTR y qué límites aparecen cuando un proceso muere mientras conserva un permiso.