1. Nombre, objeto y apertura
El tema 19 mostró qué conserva una cola de mensajes. Ahora vamos a preparar el recurso que compartirán productores y consumidores, sin desarrollar todavía su protocolo de envío.
Para razonar sobre su vida útil, separa tres conceptos:
- Nombre. Permite localizar la cola mediante mq_open y se retira con mq_unlink.
- Objeto de cola. Mantiene los mensajes pendientes y los límites de tamaño y cantidad.
- Apertura. Proporciona una referencia de uso, con acceso y estado de espera, que se cierra mediante mq_close.
Crear, abrir, cerrar y retirar el nombre son operaciones diferentes. Que una de ellas tenga éxito no significa que las demás hayan ocurrido.
Dos procesos pueden abrir la misma cola sin parentesco si ven el mismo espacio de IPC y tienen permisos. No necesitan un encuentro lector/escritor como en una FIFO. Abrir para escritura no exige que ya exista un consumidor.
2. Elegir un nombre de cola
Usaremos nombres de la forma /curso20_demo: una barra inicial, al menos un carácter después y ninguna otra barra. Es la convención adecuada para los ejemplos sobre Linux. Un nombre de cola no es la ruta de una FIFO dentro del directorio del proyecto.
| Nombre propuesto | Uso en el curso |
|---|---|
| /curso20_demo. | Admitido: barra inicial y un único componente. |
| curso20_demo. | Rechazado: falta la barra inicial. |
| /. | Rechazado: falta el componente de nombre. |
| /curso20/demo. | Rechazado por la convención utilizada: contiene otra barra. |
| /dev/mqueue/curso20_demo. | No se pasa así a mq_open; /dev/mqueue es una vista de administración de Linux. |
La herramienta del tema restringe además el nombre a letras ASCII, dígitos, punto, guion y guion bajo, con un máximo de 128 bytes incluyendo la barra. Es una decisión de la herramienta, no una enumeración completa de todos los nombres que podría aceptar una implementación.
Dos procesos con el mismo texto de nombre pueden ver objetos distintos si utilizan espacios de IPC diferentes. En un contenedor, comprueba también su entorno y la vista de mqueue antes de atribuir un fallo al programa.
3. Las formas de mq_open y el tipo mqd_t
mqd_t mq_open(const char *nombre, int flags);
mqd_t mq_open(const char *nombre, int flags, mode_t modo,
struct mq_attr *atributos);
/* Abrir algo que debe existir. */
mqd_t cola = mq_open(nombre, O_RDONLY);
if (cola == (mqd_t)-1) {
perror("mq_open");
}Con O_CREAT debes proporcionar modo y atributos; sin ese flag se utiliza la forma de dos argumentos. Un puntero de atributos NULL solicita los valores de creación predeterminados del sistema.
El retorno es mqd_t, no un puntero. El valor de fallo es (mqd_t)-1, distinto de comprobar cero. Para cerrar la referencia se usa mq_close. El código portable no depende de que mqd_t tenga la misma representación o uso que un descriptor de archivo de Linux.
Las cabeceras habituales son mqueue.h, fcntl.h y sys/stat.h. Compilaremos con -lrt para enlazar las funciones en los entornos que lo requieren.
4. Combinar acceso, creación y modo de espera
| Flag | Propósito | Precaución |
|---|---|---|
| O_RDONLY. | Referencia para recibir. | Selecciona exactamente un modo de acceso. |
| O_WRONLY. | Referencia para enviar. | No necesita un receptor ya abierto. |
| O_RDWR. | Permite enviar y recibir. | Útil en laboratorios; define los roles de una aplicación real. |
| O_CREAT. | Crea si no existe. | Por sí solo también acepta una cola existente. |
| O_EXCL junto con O_CREAT. | Exige crear una nueva. | EEXIST permite detectar un nombre ocupado sin sobrescribirlo. |
| O_NONBLOCK. | Solicita operaciones sin espera ante cola llena o vacía. | No crea mensajes ni cambia la capacidad. |
| O_CLOEXEC, disponible en Linux. | Impide conservar esa referencia al ejecutar otro programa. | La herencia por fork sigue siendo otra cuestión. |
Los ejemplos de creación usan O_CREAT | O_EXCL: si el nombre existe, fallan sin retirarlo. Una apertura no consume ni descarta mensajes previos. Las combinaciones y condiciones de la función están documentadas en mq_open(3).
5. Configurar struct mq_attr
struct mq_attr pedido = {0};
pedido.mq_maxmsg = 4;
pedido.mq_msgsize = 64;
mqd_t cola = mq_open(nombre, O_CREAT | O_EXCL | O_RDWR | O_NONBLOCK,
0660, &pedido);| Campo | Significado | Al crear |
|---|---|---|
| mq_maxmsg. | Máximo de mensajes pendientes. | Se solicita un valor positivo dentro de los límites del sistema. |
| mq_msgsize. | Máximo de bytes de un mensaje. | Se solicita un valor positivo dentro de los límites del sistema. |
| mq_curmsgs. | Cantidad de mensajes actualmente pendientes. | No se utiliza para precargar contenido. |
| mq_flags. | Estado de espera asociado a la apertura. | O_NONBLOCK se pasa en los flags de mq_open; este campo no lo sustituye. |
Los campos que configuran el objeto al crear son mq_maxmsg y mq_msgsize. Después de abrir, consulta con mq_getattr lo que realmente tiene la cola antes de reservar un búfer o asumir un contrato.
El producto mq_maxmsg × mq_msgsize ayuda a dimensionar el máximo de contenido, pero no representa toda la memoria que el núcleo contabiliza para administrar la cola. Un mensaje pequeño ocupa una entrada de su límite de cantidad.
6. Abrir una cola existente no la reconfigura
Si O_CREAT encuentra una cola existente, los atributos de creación y el modo suministrados no reemplazan los del objeto. El nuevo proceso obtiene una apertura de lo que ya existía, si sus permisos lo permiten.
/* La cola ya se creo con maxmsg = 4 y msgsize = 64. */
struct mq_attr distinto = {.mq_maxmsg = 1, .mq_msgsize = 8};
mqd_t otra = mq_open(nombre, O_CREAT | O_RDONLY | O_NONBLOCK,
0600, &distinto);
/* Si abre el objeto existente, este sigue teniendo 4 y 64. */No continúes automáticamente después de EEXIST con una configuración asumida. Puedes rechazar el arranque, abrir sin crear y validar, o utilizar un nombre nuevo; la aplicación debe elegir.
mq_setattr tampoco sirve para cambiar mq_maxmsg o mq_msgsize de una cola existente. Si necesitas otro tamaño, hace falta un plan de migración hacia otro objeto y coordinar a sus participantes.
7. Permisos y umask
El modo de creación usa bits de lectura y escritura para propietario, grupo y otros. En Linux, la máscara umask retira permisos del modo solicitado al crear una cola nueva. Con modo 0660 y umask 0027 se obtiene 0640.
El permiso de lectura permite abrir para recibir y el de escritura para enviar. O_RDWR exige ambos. Que el nombre sea visible en una herramienta no implica que otro proceso tenga permiso para abrirlo.
$ (umask 027; ./mq_admin crear "$nombre" 4 64)El subshell evita modificar la máscara de las órdenes posteriores. La aplicación no cambia permisos de una cola existente al pasar otro modo a O_CREAT. El papel de umask sobre colas POSIX en Linux se describe en umask(2).
Para el laboratorio comparte un nombre solo entre procesos del mismo usuario y utiliza nombres propios. No retires un objeto ocupado suponiendo que es un residuo de tu prueba.
8. Programa: crear, consultar y retirar
La herramienta tiene tres órdenes: crear una cola nueva con límites explícitos, consultar una existente y retirar un nombre. Crear cierra su descriptor al terminar, pero deja la cola nombrada para que otro proceso la abra después.
Solo se elimina una cola recién creada automáticamente si falla su consulta inicial. EEXIST nunca provoca un borrado. La orden retirar es una acción explícita que debe reservarse para recursos cuyo ciclo de vida controlas.
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <fcntl.h>
#include <mqueue.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
static int nombre_valido(const char *nombre)
{
size_t n = strlen(nombre);
if (n < 2 || n > 128 || nombre[0] != '/') return 0;
for (size_t i = 1; i < n; ++i) {
unsigned char c = (unsigned char)nombre[i];
if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
(c >= '0' && c <= '9') || c == '_' || c == '-' || c == '.'))
return 0;
}
return 1;
}
static int positivo(const char *texto, long *valor)
{
if (*texto == '\0') return -1;
for (const char *p = texto; *p != '\0'; ++p)
if (*p < '0' || *p > '9') return -1;
errno = 0;
char *fin;
long n = strtol(texto, &fin, 10);
if (errno == ERANGE || *fin != '\0' || n <= 0) return -1;
*valor = n;
return 0;
}
static int mostrar(mqd_t cola)
{
struct mq_attr a;
if (mq_getattr(cola, &a) == -1) return -1;
printf("maxmsg=%ld msgsize=%ld curmsgs=%ld modo=%s\n",
a.mq_maxmsg, a.mq_msgsize, a.mq_curmsgs,
a.mq_flags & O_NONBLOCK ? "no bloqueante" : "bloqueante");
return 0;
}
int main(int argc, char *argv[])
{
if (argc < 3 || !nombre_valido(argv[2])) goto uso;
int crear = strcmp(argv[1], "crear") == 0;
int ver = strcmp(argv[1], "ver") == 0;
int retirar = strcmp(argv[1], "retirar") == 0;
if ((crear && argc != 5) || ((ver || retirar) && argc != 3) ||
(!crear && !ver && !retirar)) goto uso;
if (retirar) {
if (mq_unlink(argv[2]) == -1) { perror("mq_unlink"); return 1; }
puts("Nombre retirado; las referencias abiertas siguen siendo validas");
return 0;
}
struct mq_attr pedido = {0};
if (crear && (positivo(argv[3], &pedido.mq_maxmsg) == -1 ||
positivo(argv[4], &pedido.mq_msgsize) == -1)) goto uso;
mqd_t cola = crear ?
mq_open(argv[2], O_CREAT | O_EXCL | O_RDWR | O_NONBLOCK, 0660, &pedido) :
mq_open(argv[2], O_RDONLY | O_NONBLOCK);
if (cola == (mqd_t)-1) { perror("mq_open"); return 1; }
int resultado = 0;
if (mostrar(cola) == -1) {
perror("mq_getattr");
resultado = 1;
if (crear && mq_unlink(argv[2]) == -1) perror("mq_unlink limpieza");
}
if (mq_close(cola) == -1) { perror("mq_close"); resultado = 1; }
if (crear && resultado == 0)
puts("Cola creada y descriptor cerrado; el nombre permanece");
return resultado;
uso:
fprintf(stderr, "Uso: %s crear /nombre maxmsg msgsize\n"
" %s ver /nombre\n"
" %s retirar /nombre\n", argv[0], argv[0], argv[0]);
return 2;
}La orden ver abre sin O_CREAT y no modifica la cola. El modo que imprime corresponde a su propia apertura no bloqueante. mq_curmsgs es una observación de ese instante y puede cambiar si otros procesos envían o reciben.
9. Ejecutar operaciones desde procesos independientes
$ gcc -std=c17 -Wall -Wextra -Wpedantic mq_admin.c -o mq_admin -lrt
$ nombre="/curso20_${UID}_$$"
$ (umask 027; ./mq_admin crear "$nombre" 4 64)
maxmsg=4 msgsize=64 curmsgs=0 modo=no bloqueante
Cola creada y descriptor cerrado; el nombre permanece
$ ./mq_admin ver "$nombre"
maxmsg=4 msgsize=64 curmsgs=0 modo=no bloqueante
$ ./mq_admin crear "$nombre" 1 8
mq_open: File existsEl segundo proceso puede abrir la cola aunque el creador ya haya terminado. El tercer comando usa O_EXCL: falla y conserva el objeto de cuatro mensajes y 64 bytes. Los textos de error dependen del idioma del sistema.
$ ./mq_admin retirar "$nombre"
Nombre retirado; las referencias abiertas siguen siendo validas
$ ./mq_admin ver "$nombre"
mq_open: No such file or directory
$ echo $?
1En esta secuencia no quedan otros descriptores abiertos al retirar el nombre, de modo que el objeto puede destruirse. El siguiente laboratorio mantendrá referencias para observar la otra posibilidad.
10. Atributos de cola y estado de apertura
mq_getattr devuelve una estructura que combina propiedades del objeto con el estado de la apertura consultada. mq_maxmsg, mq_msgsize y mq_curmsgs describen la cola; mq_flags refleja O_NONBLOCK de esa apertura.
struct mq_attr nuevo = {.mq_flags = O_NONBLOCK};
struct mq_attr anterior;
if (mq_setattr(cola, &nuevo, &anterior) == -1) {
perror("mq_setattr");
}mq_setattr modifica O_NONBLOCK; no cambia el modo de acceso ni los límites de cantidad y tamaño. El resto de campos de nuevo no redimensiona el objeto. Las reglas están en mq_getattr(3) y mq_setattr(3).
Dos llamadas independientes a mq_open pueden tener estados de espera distintos sobre la misma cola. En cambio, la referencia que un hijo hereda por fork comparte la descripción de apertura con la del padre: cambiar O_NONBLOCK desde ella se refleja en esa apertura compartida.
Copiar una variable mqd_t en C no crea una apertura independiente. Si necesitas otra, utiliza mq_open mientras el nombre siga disponible. Evita cerrar dos veces una misma referencia por haber copiado su valor a dos variables.
11. Laboratorio: herencia y generaciones de cola
El experimento crea una cola de tres mensajes y 64 bytes. La segunda apertura propone otros límites, pero como el objeto existe no los modifica. Después se retira el nombre, un hijo cambia el modo de la apertura A heredada y el padre comprueba que B mantiene su estado independiente.
Finalmente se crea otra cola bajo el mismo nombre con límites distintos. Las referencias A y B siguen asociadas al objeto anterior, mientras C apunta al nuevo. Los nombres temporales se crean con O_EXCL y solo se retiran cuando su creación pertenece al programa.
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <fcntl.h>
#include <mqueue.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <unistd.h>
static int mostrar(const char *etiqueta, mqd_t cola)
{
struct mq_attr a;
if (mq_getattr(cola, &a) == -1) { perror("mq_getattr"); return -1; }
printf("%s: max=%ld tam=%ld modo=%s\n", etiqueta, a.mq_maxmsg,
a.mq_msgsize, a.mq_flags & O_NONBLOCK ? "no bloqueante" : "bloqueante");
return 0;
}
int main(void)
{
struct sigaction accion = {0};
accion.sa_handler = SIG_DFL;
if (sigemptyset(&accion.sa_mask) == -1 ||
sigaction(SIGCHLD, &accion, NULL) == -1) {
perror("preparar SIGCHLD"); return 1;
}
char nombre[96];
struct mq_attr original = {.mq_maxmsg = 3, .mq_msgsize = 64};
mqd_t a = (mqd_t)-1, b = (mqd_t)-1, c = (mqd_t)-1;
int nombrada = 0, resultado = 1;
for (int intento = 0; intento < 100; ++intento) {
snprintf(nombre, sizeof nombre, "/aperturas20_%ld_%d", (long)getpid(), intento);
a = mq_open(nombre, O_CREAT | O_EXCL | O_RDWR, 0600, &original);
if (a != (mqd_t)-1 || errno != EEXIST) break;
}
if (a == (mqd_t)-1) { perror("crear A"); return 1; }
nombrada = 1;
struct mq_attr propuesto = {.mq_maxmsg = 1, .mq_msgsize = 8};
b = mq_open(nombre, O_CREAT | O_RDWR | O_NONBLOCK, 0600, &propuesto);
if (b == (mqd_t)-1) { perror("abrir B"); goto limpieza; }
if (mostrar("A inicial", a) == -1 || mostrar("B inicial", b) == -1)
goto limpieza;
struct mq_attr cambio = {.mq_flags = 0}, anterior;
if (mq_setattr(b, &cambio, &anterior) == -1) {
perror("modo B"); goto limpieza;
}
printf("B antes del cambio: %s\n",
anterior.mq_flags & O_NONBLOCK ? "no bloqueante" : "bloqueante");
if (mq_unlink(nombre) == -1) { perror("unlink original"); goto limpieza; }
nombrada = 0;
mqd_t ausente = mq_open(nombre, O_RDONLY);
if (ausente != (mqd_t)-1) {
mq_close(ausente);
fprintf(stderr, "Aparecio una cola inesperada bajo el nombre\n");
goto limpieza;
}
if (errno != ENOENT) { perror("abrir nombre retirado"); goto limpieza; }
puts("Nueva apertura por el nombre retirado: ENOENT");
if (fflush(stdout) == EOF) { perror("fflush"); goto limpieza; }
pid_t hijo = fork();
if (hijo == -1) { perror("fork"); goto limpieza; }
if (hijo == 0) {
struct mq_attr no_bloqueante = {.mq_flags = O_NONBLOCK};
int r = mq_setattr(a, &no_bloqueante, NULL);
mq_close(a); mq_close(b);
_exit(r == 0 ? 0 : 1);
}
int estado;
while (waitpid(hijo, &estado, 0) == -1) {
if (errno == EINTR) continue;
perror("waitpid"); goto limpieza;
}
if (!WIFEXITED(estado) || WEXITSTATUS(estado) != 0) {
fprintf(stderr, "El hijo no completo el cambio\n"); goto limpieza;
}
if (mostrar("A tras el hijo", a) == -1 || mostrar("B independiente", b) == -1)
goto limpieza;
struct mq_attr nuevos = {.mq_maxmsg = 1, .mq_msgsize = 16};
c = mq_open(nombre, O_CREAT | O_EXCL | O_RDWR | O_NONBLOCK, 0600, &nuevos);
if (c == (mqd_t)-1) { perror("crear C"); goto limpieza; }
nombrada = 1;
if (mq_unlink(nombre) == -1) { perror("unlink nueva"); goto limpieza; }
nombrada = 0;
if (mostrar("A antigua", a) == -1 || mostrar("C nueva", c) == -1)
goto limpieza;
resultado = 0;
limpieza:
if (nombrada && mq_unlink(nombre) == -1) {
perror("mq_unlink limpieza"); resultado = 1;
}
if (c != (mqd_t)-1 && mq_close(c) == -1) { perror("close C"); resultado = 1; }
if (b != (mqd_t)-1 && mq_close(b) == -1) { perror("close B"); resultado = 1; }
if (a != (mqd_t)-1 && mq_close(a) == -1) { perror("close A"); resultado = 1; }
return resultado;
}$ gcc -std=c17 -Wall -Wextra -Wpedantic aperturas_mq.c -o aperturas_mq -lrt
$ ./aperturas_mq
A inicial: max=3 tam=64 modo=bloqueante
B inicial: max=3 tam=64 modo=no bloqueante
B antes del cambio: no bloqueante
Nueva apertura por el nombre retirado: ENOENT
A tras el hijo: max=3 tam=64 modo=no bloqueante
B independiente: max=3 tam=64 modo=bloqueante
A antigua: max=3 tam=64 modo=no bloqueante
C nueva: max=1 tam=16 modo=no bloqueanteEl padre espera al hijo antes de consultar A, de modo que el cambio ya ocurrió. B tiene otra descripción de apertura y no cambia con A. La consulta posterior a mq_unlink demuestra que retirar el nombre no invalida esas referencias.
El laboratorio es de un solo hilo antes de fork y el hijo utiliza _exit. En un programa con varios hilos debes revisar las restricciones de operaciones permitidas entre fork y exec; no copies esta rama de experimento como un lanzador general.
12. mq_close y mq_unlink: responsabilidades distintas
| Estado | ¿Puede abrirse por el nombre? | ¿Pueden usarse referencias existentes? |
|---|---|---|
| Nombrada y abierta. | Sí, con acceso permitido. | Sí. |
| Nombrada y sin aperturas. | Sí. | No hay referencias actuales, pero el objeto permanece. |
| Desvinculada y todavía abierta. | No se abre ese objeto por el nombre retirado. | Sí, hasta cerrar sus últimas referencias. |
| Desvinculada y sin aperturas. | No. | El objeto ya puede destruirse y liberar sus mensajes. |
mq_close libera un descriptor del proceso; no retira el nombre ni equivale a avisar que ya no quedan productores. Su contrato está en mq_close(3).
mq_unlink retira inmediatamente el nombre. El objeto permanece mientras existan aperturas, y una creación posterior del mismo texto de nombre identifica otra cola. El contrato se describe en mq_unlink(3).
Un cliente normal cierra su referencia y deja la retirada al responsable del servicio. Si todos ejecutaran mq_unlink al salir, el primero impediría conexiones posteriores y podría provocar generaciones distintas durante una recreación.
Para un recurso interno de procesos que ya comparten sus referencias puede ser útil desvincular pronto. Para un servicio al que se conectarán procesos futuros, el nombre debe seguir disponible hasta la fase de retirada acordada.
13. Límites y observación en Linux
Una petición de atributos puede ser positiva y aun así no estar permitida. En Linux intervienen límites de mensajes por cola, tamaño por mensaje, número de colas, descriptores y recursos contabilizados por usuario.
$ cat /proc/sys/fs/mqueue/msg_max
$ cat /proc/sys/fs/mqueue/msgsize_max
$ cat /proc/sys/fs/mqueue/queues_max
$ ulimit -q
$ ls -ld /dev/mqueueNo fijes como garantía los valores observados en tu equipo. El límite mostrado por ulimit -q no representa simplemente la cantidad de bytes de texto pendientes; el sistema también contabiliza recursos de administración.
Si mqueue está montado y el nombre del ejemplo es /curso20_demo, su vista habitual es /dev/mqueue/curso20_demo. Puedes inspeccionarla con ls y stat, pero el programa sigue pasando /curso20_demo a mq_open. No uses esa ruta de montaje como un nombre de API.
La ausencia del montaje visible no basta para concluir que las llamadas mq_* no están disponibles. Comprueba el error concreto y el entorno del proceso. Los límites y particularidades de Linux se documentan en mq_overview(7).
14. Validar el contrato al conectarse
Un consumidor debe comprobar los atributos existentes antes de reservar memoria y empezar a recibir. Por ejemplo, un servicio que exige exactamente 64 bytes máximos por mensaje puede rechazar una cola antigua de otro tamaño.
struct mq_attr actual;
if (mq_getattr(cola, &actual) == -1) {
perror("mq_getattr");
mq_close(cola);
/* Terminar esta conexion. */
} else if (actual.mq_msgsize != 64 || actual.mq_maxmsg != 4) {
fprintf(stderr, "Configuracion de cola incompatible\n");
mq_close(cola);
/* El responsable del servicio decide si debe migrarse. */
}El valor mq_curmsgs no es una reserva de capacidad ni una promesa para la siguiente llamada. Otro proceso puede enviar o recibir después de consultarlo. La operación de E/S debe gestionar igualmente sus retornos reales.
Los atributos tampoco validan la versión del contenido. Una cola con capacidad correcta puede contener mensajes de otra versión del protocolo. El formato de cada mensaje necesita su propia validación, como se explicó en el tema 19.
15. Explorar nombres y referencias
Crea A, abre B, retira el nombre y crea C. A utiliza una cola de tres mensajes de 64 bytes; una creación C utiliza una de un mensaje de 16 bytes. Observa qué referencias siguen asociadas al objeto antiguo y cuándo desaparece cada objeto.
Nombre /cola20No existe
Referencia ACerrada
Referencia BCerrada
Referencia CCerrada
Objetos vivos: Ninguno
Crea una cola para comenzar. El modelo no contiene mensajes.
Prueba también cerrar A antes de retirar su nombre: la cola sigue nombrada y B puede abrirla. Después de retirar el nombre intenta abrir B: si no conservaba ya una referencia, obtendrá ENOENT en el modelo.
16. Diagnosticar errores y verificar la limpieza
| Error o síntoma | Qué comprobar |
|---|---|
| EEXIST con O_CREAT | O_EXCL. | El nombre ya está ocupado. No lo retires sin conocer al responsable. |
| ENOENT al abrir sin O_CREAT. | Nombre correcto, arranque del creador, retirada previa y espacio de IPC. |
| EACCES. | Permisos existentes y acceso solicitado; O_RDWR necesita lectura y escritura. |
| EINVAL al crear. | Atributos positivos, límites de configuración y combinación de flags. |
| ENOSPC. | Límites de cantidad de colas u otros recursos asociados. |
| EMFILE o ENFILE. | Límites de referencias o recursos del sistema; en Linux también puede intervenir la cuota de colas del usuario. |
| mq_setattr no modifica el tamaño. | Solo cambia O_NONBLOCK; no redimensiona el objeto. |
| La cola sigue visible después del creador. | mq_close no ejecuta mq_unlink; la persistencia nombrada es esperable. |
| Dos grupos no intercambian mensajes con el mismo nombre. | Podrían usar generaciones distintas tras unlink/recreación, o distintos espacios de IPC. |
$ strace -o mq20.log ./mq_admin ver "$nombre"
$ less mq20.logHaz esta consulta mientras el nombre siga presente. En Linux puedes observar mq_open, mq_getsetattr y close: el nombre de la llamada del sistema no siempre coincide con el de la función de biblioteca.
Repite aperturas y cierres para comprobar que no aumenta la cantidad de referencias del proceso. El laboratorio aperturas_mq debe terminar sin dejar su nombre. Una terminación abrupta entre crear y desvincular puede dejar un objeto nombrado; antes de retirarlo verifica que pertenece a tu ejecución y que no hay un servicio activo usando ese nombre.
17. Resumen
- mq_open crea o abre una cola y devuelve un mqd_t; el fallo se compara con (mqd_t)-1.
- O_CREAT | O_EXCL permite exigir un objeto nuevo sin sobrescribir uno existente.
- mq_maxmsg y mq_msgsize configuran los límites al crear el objeto.
- Abrir una cola existente no reemplaza sus atributos ni sus permisos.
- mq_getattr permite observar el contrato real antes de usar la cola.
- O_NONBLOCK pertenece a la apertura; las referencias heredadas por fork comparten ese estado.
- mq_setattr no cambia la capacidad ni el tamaño máximo de mensaje.
- mq_close libera una referencia y mq_unlink retira un nombre.
- Una cola desvinculada puede coexistir con otra nueva bajo el mismo nombre.
18. Preguntas de repaso y práctica
Responde antes de desplegar las explicaciones.
1. ¿Una cola POSIX se abre con /dev/mqueue/nombre?
No en los ejemplos de la API. Se pasa /nombre a mq_open; /dev/mqueue es una vista de administración de Linux.
2. ¿Cuál es el valor de fallo de mq_open?
(mqd_t)-1. No se debe comprobar únicamente si el retorno vale cero.
3. ¿Qué evita O_EXCL junto con O_CREAT?
Evita continuar sobre una cola preexistente suponiendo que se creó una nueva con la configuración solicitada.
4. ¿O_CREAT con otros atributos redimensiona una cola existente?
No. La apertura utiliza el objeto ya existente y sus límites; hay que consultarlos y validar la compatibilidad.
5. ¿Cómo se activa el modo no bloqueante al abrir?
Con O_NONBLOCK en el argumento de flags de mq_open, no fijando mq_flags en la estructura de creación.
6. ¿Se puede cambiar mq_msgsize con mq_setattr?
No. Esa función permite modificar O_NONBLOCK, no los límites de tamaño y cantidad.
7. ¿Por qué B no cambia cuando el hijo cambia el modo de A?
Porque B proviene de otra llamada a mq_open. El hijo comparte la descripción de apertura heredada de A, no la de B.
8. ¿Cerrar la última referencia elimina una cola nombrada?
No. El nombre conserva el objeto hasta que se retire según su ciclo de vida.
9. ¿Desvincular el nombre invalida los descriptores abiertos?
No. Pueden seguir usándose sobre el objeto anterior hasta que se cierren.
10. ¿Qué cola utiliza una referencia antigua después de recrear el nombre?
La antigua. El nuevo nombre identifica un objeto distinto y no modifica referencias ya existentes.
11. ¿mq_curmsgs permite garantizar que el siguiente envío no esperará?
No. Es una observación; otro proceso puede modificar la ocupación antes de la siguiente operación.
12. ¿Quién debe ejecutar mq_unlink en un servicio?
El responsable de su ciclo de vida en el momento acordado. Los clientes normalmente cierran sus referencias sin retirar el nombre compartido.
Para practicar
- Crea una cola con mq_admin, termina el creador y ábrela desde otro proceso. Comprueba la persistencia del nombre.
- Intenta crear de nuevo el mismo nombre con otros atributos. Verifica que el objeto original no cambia.
- Prueba nombres inválidos y valores cero, negativos y fuera del rango de long. Comprueba que la herramienta los rechaza sin crear objetos.
- Compara la creación bajo dos máscaras usando subshells. Si mqueue está montado, inspecciona los permisos desde su vista de Linux.
- Ejecuta aperturas_mq y explica por qué la propuesta de ocho bytes no aparece en B.
- Dibuja qué referencias apuntan a cada generación después de retirar el nombre y crear C.
- En el explorador, cierra todas las referencias conservando el nombre; después vuelve a abrir B. Compara con retirar el nombre antes.
- Añade a mq_admin una orden de comprobación de atributos esperados que cierre su referencia sin retirar una cola incompatible.
- Diseña el orden de parada y retirada del nombre de un servicio que todavía tenga clientes abiertos.
El tema 21 utilizará las colas preparadas aquí para enviar y recibir mensajes POSIX, aplicar prioridades y gestionar esperas con límite de tiempo.