← Comunicación entre ProcesosBloque 9 · Multiplexación y bucles de eventos · Tema 39 de 52

Tema 39

Escalar el bucle con epoll en Linux

Vas a mantener los intereses de tus conexiones dentro del núcleo y recibir lotes de eventos preparados. Aprenderás a crear una instancia de epoll, registrar altas y cambios, retirar recursos y relacionar cada evento con la sesión correcta. El servidor conservará los cuerpos parciales, las respuestas pendientes y una generación que permite reconocer eventos antiguos de posiciones reutilizadas.

1. Contrato y alcance del servidor

El tema 38 presentó un servidor con poll que reconstruía un arreglo de intereses antes de cada espera. Ahora mantendremos el mismo protocolo y trasladaremos el registro de intereses a una instancia epoll.

El cliente envía hasta 256 bytes y termina su envío con SHUT_WR. El servidor lee hasta EOF, convierte las letras ASCII minúsculas, envía la respuesta y cierra. Hay cuatro posiciones activas, hasta veinte aceptaciones por ejecución y un plazo global de sesenta segundos.

epoll conserva una colección de intereses registrados y entrega una colección de resultados preparados. La aplicación conserva el estado del protocolo, la identidad de la sesión y la propiedad de cada descriptor.

DecisiónRegla del ejemploConsecuencia
Plataforma.Linux, sockets AF_UNIX no bloqueantes.Las API epoll no son una interfaz POSIX portable.
Modo de notificación.Level-triggered, sin EPOLLET ni EPOLLONESHOT.Una condición que persiste puede notificarse otra vez.
Estado.Posición, generación, fase y contadores.No se confunde una sesión nueva con un evento antiguo.
Lote de salida.Hasta dos eventos por epoll_wait.El lote es menor que el máximo de registros posibles.
Escritura.EPOLLOUT solo cuando hay respuesta pendiente.No se despierta por capacidad que no tiene trabajo asociado.
Admisión.Retirar temporalmente la escucha si no hay posiciones.La conexión pendiente no provoca un giro continuo.

El límite de cuatro sesiones mantiene el código revisable. epoll permite trabajar con colecciones mayores, pero aumentar un número no basta para construir un servidor de gran capacidad: también importan memoria, procesamiento, admisión y límites.

2. Intereses registrados y lista de preparados

Con poll se entrega de nuevo el arreglo de entradas en cada llamada. Con epoll se registra cada recurso y solo se actualiza cuando cambia el interés o su vida útil. La espera devuelve eventos sin que el programa tenga que recorrer una entrada de resultado por cada conexión inactiva.

Estado de aplicación, intereses del núcleo y lote de resultadosLa aplicación conserva las conexiones. ADD, MOD y DEL actualizan los intereses de una instancia epoll. epoll_wait devuelve un lote de eventos con la identidad guardada, y el bucle actualiza el estado de las conexiones correspondientes. Aplicaciónsesiones y pendientesInstancia epollintereses registradosepoll_waitlote de preparadosADD / MOD / DEL cuando cambia el registroCada resultado se valida antes de tocar el estado de una sesión
El núcleo informa condiciones; no completa el protocolo ni administra los búferes de aplicación.

La lista de preparados no es una cola de peticiones de negocio. Varias escrituras remotas pueden aparecer como una condición de lectura, y una lectura parcial puede dejar la misma conexión preparada para otra vuelta. El modelo de listas se explica en epoll(7).

3. Crear y cerrar la instancia

C en Linux · descriptor de la instancia
#include <sys/epoll.h>

int epfd = epoll_create1(EPOLL_CLOEXEC);
if (epfd == -1) {
    /* Informar el error y limpiar lo ya creado. */
}
/* Usar epfd con epoll_ctl y epoll_wait. */
/* Al finalizar: close(epfd). */

El resultado es un descriptor adicional del proceso. EPOLL_CLOEXEC marca esa entrada para cierre cuando se completa exec; no convierte en no bloqueantes los sockets vigilados ni instala CLOEXEC en ellos. Esas propiedades se configuran al crear o aceptar cada socket.

epoll_create1 recibe flags, no la cantidad prevista de conexiones. El viejo argumento size de epoll_create no reserva una capacidad de clientes para el programa. La creación y la liberación de la instancia se documentan en epoll_create1(2).

Cerrar la instancia libera su registro cuando desaparecen sus referencias, pero no cierra automáticamente los sockets que la aplicación había registrado. El programa conserva la obligación de retirar y cerrar sus clientes y su escucha.

4. Registrar ADD, MOD y DEL

C · actualizar el registro del núcleo
struct epoll_event evento = {0};
evento.events = EPOLLIN | EPOLLRDHUP;
evento.data.u64 = identificador;

int r = epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &evento);
/* MOD reemplaza la mascara y los datos guardados de un registro. */
/* DEL retira el registro; su argumento event puede ser NULL. */
OperaciónPropósitoSituación típica
EPOLL_CTL_ADD.Incorporar un registro.Nueva conexión aceptada.
EPOLL_CTL_MOD.Reemplazar máscara y datos asociados.Pasar de recibir petición a enviar respuesta.
EPOLL_CTL_DEL.Retirar un registro.Cerrar sesión o pausar la escucha.

Cambiar una estructura local no modifica por sí solo el registro. Hay que ejecutar epoll_ctl y comprobar su resultado. MOD tampoco agrega bits implícitamente: prepara la máscara completa que quieres conservar y el dato de identidad que debe seguir asociado.

Una alta duplicada puede fallar con EEXIST; MOD o DEL de un recurso no registrado pueden fallar con ENOENT. EBADF, EPERM o ENOSPC representan otros problemas de recursos, soporte o límites. No se deben ocultar indiscriminadamente como si todas las operaciones hubieran tenido éxito. Véase epoll_ctl(2).

5. Esperar un lote con epoll_wait

C · búfer de salida de eventos
struct epoll_event listos[16];
int n = epoll_wait(epfd, listos, 16, timeout_ms);
if (n > 0) {
    for (int i = 0; i < n; ++i) {
        /* Examinar listos[i].events y listos[i].data. */
    }
}

El tercer argumento es la capacidad positiva del búfer de resultados. No es la cantidad de registros, el mayor descriptor más uno ni la capacidad total del servicio. Si hay más preparados que espacios, otras esperas podrán obtener más resultados.

RetornoInterpretaciónTratamiento
n > 0.Hay n elementos válidos en el lote.Recorrer solo ese prefijo.
n == 0.Timeout sin resultados.Revisar plazos y cancelación.
−1, EINTR.La espera fue interrumpida.No despachar el búfer; recalcular el restante.
−1, otro error.Falló la espera.Aplicar la política de fallo del bucle.

El timeout usa milisegundos: −1 permite esperar sin límite y cero consulta sin dormir. El código utiliza un plazo monotónico y esperas de hasta 250 ms para revisar la bandera de cancelación. La semántica del lote y sus datos está en epoll_wait(2).

6. Identidad de sesión en epoll_event.data

data es una unión que permite guardar, entre otras opciones, un entero de 64 bits, un descriptor o un puntero. El núcleo devuelve el valor asociado al registro. No verifica que tu puntero siga vivo ni que un número reutilizado siga perteneciendo a la misma conversación.

El servidor codifica la posición y una generación. La parte baja contiene índice + 1, reservando cero para la escucha; la parte alta contiene la generación de la sesión. Cuando se reutiliza una posición se aumenta esa generación.

token de 64 bits · identidad de una sesión
bits 63..32: generacion
bits 31..0:  indice + 1

token = ((uint64_t)generacion << 32) | (indice + 1)

al despachar:
    comprobar indice dentro de la tabla
    comprobar posicion activa
    comprobar generacion del evento == generacion actual
    solo entonces utilizar el descriptor y sus buffers

El índice permite localizar el estado directamente. Una generación antigua se ignora aunque coincidan el índice o el número de descriptor de una sesión nueva. El ejemplo admite como máximo veinte altas, de modo que no puede agotar el contador de 32 bits; un servicio indefinido debe definir también su política de agotamiento.

Si se utiliza data.ptr, el objeto apuntado debe sobrevivir a todos los eventos que aún puedan referenciarlo. Liberar memoria al recibir un cierre y procesar después otro evento del mismo lote puede producir un acceso a memoria liberada. El token con validación evita depender de punteros a objetos ya retirados.

7. Lectura, salida, medio cierre y errores

CondiciónUsoRegla del servidor
EPOLLIN.Intentar recibir entrada.Una llamada de hasta 64 bytes y contador persistente.
EPOLLOUT.Intentar enviar salida pendiente.Avanzar solo por los bytes realmente aceptados.
EPOLLRDHUP.El interlocutor terminó su envío.Seguir retirando datos hasta recv igual a cero.
EPOLLHUP.Cierre de la conexión.Drenar entrada pendiente; resolver o cancelar salida.
EPOLLERR.Error del recurso.Consultar SO_ERROR y fallar esa sesión.

EPOLLERR y EPOLLHUP pueden informarse sin agregarlos a la máscara. EPOLLRDHUP sí se solicita como aviso de medio cierre. Ninguno sustituye los retornos de recv y send: puede haber datos antes de EOF, EAGAIN, envíos parciales o errores.

Al pasar a salida se reemplaza la máscara por EPOLLOUT. Ya se reconoció EOF de entrada y no interesa repetir avisos de RDHUP en esa fase. Mantenerlos innecesariamente podría despertar el bucle por una condición que ya no tiene trabajo de lectura.

El ejemplo conserva la política del tema 38: un error de sesión no cancela las demás. Un fallo de epoll_ctl sí es fatal para el servicio porque la aplicación ya no puede asumir que su registro coincide con el estado esperado.

8. Estado, admisión y plazos

Copia apoyo32.h del tema 32 y plazo37.h del tema 37. Aportan direcciones y retirada por identidad, y el cálculo del tiempo restante. No necesitas ejecutar los programas de esos temas.

La tabla tiene cuatro estados activos posibles. Cada alta se registra una sola vez con ADD; la transición de entrada a salida utiliza MOD; el final utiliza DEL antes de close. La escucha usa el token cero y se retira del registro cuando no hay capacidad.

La aplicación cuenta las sesiones activas para saber cuándo pausar o reanudar la escucha. Solo busca un hueco al aceptar; no reconstruye una máscara para todos los clientes antes de cada espera.

Los eventos de escucha se acumulan durante el recorrido del lote y se atienden al final. Así las conexiones nuevas no se despachan dentro de los resultados anteriores. La generación agrega otra comprobación para descartar resultados obsoletos.

9. Servidor completo con generaciones

Guarda servidor39.c. El protocolo es compatible con cliente38.c. Usa el modo level-triggered predeterminado y un lote de dos eventos, aunque puede tener registrados cuatro clientes y una escucha.

servidor39.c · intereses persistentes y estado identificado por generación
#define _GNU_SOURCE
#include "apoyo32.h"
#include "plazo37.h"
#include <sys/epoll.h>
#include <stdint.h>

#define POSICIONES39 4u
#define MAX_CUERPO39 256u
#define LOTE39 2
#define PLAZO39 60

enum fase39 { ENTRADA39, SALIDA39 };
struct cliente39 {
    int fd;
    uint32_t generacion;
    enum fase39 fase;
    unsigned char datos[MAX_CUERPO39];
    size_t usados, enviados;
};

static volatile sig_atomic_t parar39;
static void solicitar39(int signo) { parar39 = signo; }

static uint64_t token39(unsigned i, const struct cliente39 *c)
{
    return ((uint64_t)c->generacion << 32) | (uint64_t)(i + 1u);
}

static int registrar39(int epfd, int op, int fd, uint32_t mascara, uint64_t token)
{
    struct epoll_event ev = {0};
    ev.events = mascara;
    ev.data.u64 = token;
    if (epoll_ctl(epfd, op, fd, op == EPOLL_CTL_DEL ? NULL : &ev) == -1) {
        perror("epoll_ctl"); return -1;
    }
    return 0;
}

static int baja39(int epfd, struct cliente39 *c)
{
    if (c->fd == -1) return 0;
    int fallo = registrar39(epfd, EPOLL_CTL_DEL, c->fd, 0, 0) == -1;
    if (cerrar(&c->fd) == -1) fallo = 1;
    return fallo ? -1 : 0;
}

static int escucha39(int epfd, int fd, int *registrada, int habilitar)
{
    if (*registrada == habilitar) return 0;
    int op = habilitar ? EPOLL_CTL_ADD : EPOLL_CTL_DEL;
    if (registrar39(epfd, op, fd, EPOLLIN, 0) == -1) return -1;
    *registrada = habilitar;
    return 0;
}

static int temporal39(void)
{
    return errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK;
}

/* 0: pendiente; 1: salida completa; -1: fallo de sesion; -2: fallo de registro. */
static int atender39(int epfd, unsigned i, struct cliente39 *c, uint32_t rev)
{
    if (rev & EPOLLERR) {
        int error = 0;
        socklen_t n = sizeof error;
        if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, &error, &n) == -1)
            perror("SO_ERROR");
        else fprintf(stderr, "EPOLLERR: %s\n", error ? strerror(error) : "sin codigo pendiente");
        return -1;
    }
    if (c->fase == ENTRADA39 && (rev & (EPOLLIN | EPOLLRDHUP | EPOLLHUP))) {
        unsigned char bloque[64];
        ssize_t n = recv(c->fd, bloque, sizeof bloque, 0);
        if (n > 0) {
            if ((size_t)n > MAX_CUERPO39 - c->usados) {
                fprintf(stderr, "Peticion mayor que 256 bytes\n"); return -1;
            }
            memcpy(c->datos + c->usados, bloque, (size_t)n);
            c->usados += (size_t)n;
        } else if (n == 0) {
            if (c->usados == 0) return 1;
            for (size_t k = 0; k < c->usados; ++k)
                if (c->datos[k] >= 'a' && c->datos[k] <= 'z')
                    c->datos[k] = (unsigned char)(c->datos[k] - 'a' + 'A');
            if (registrar39(epfd, EPOLL_CTL_MOD, c->fd,
                            EPOLLOUT, token39(i, c)) == -1) return -2;
            c->fase = SALIDA39;
        } else if (!temporal39() || ((rev & EPOLLHUP) && errno != EINTR)) {
            perror("recv sesion"); return -1;
        }
        return 0;
    }
    if (c->fase == SALIDA39 && (rev & (EPOLLOUT | EPOLLHUP))) {
        ssize_t n = send(c->fd, c->datos + c->enviados,
                         c->usados - c->enviados, MSG_NOSIGNAL);
        if (n > 0) {
            c->enviados += (size_t)n;
            if (c->enviados == c->usados) return 1;
        } else if (n == 0) {
            fprintf(stderr, "send sin progreso\n"); return -1;
        } else if (!temporal39() || ((rev & EPOLLHUP) && errno != EINTR)) {
            perror("send sesion"); return -1;
        }
    }
    return 0;
}

int main(int argc, char **argv)
{
    unsigned maximo = 3;
    if ((argc != 2 && argc != 3) ||
        (argc == 3 && cantidad_clientes(argv[2], &maximo) == -1)) {
        fprintf(stderr, "Uso: %s /directorio/privado/servicio.sock [sesiones(1..20)]\n", argv[0]);
        return EXIT_FAILURE;
    }
    struct sockaddr_un a;
    socklen_t longitud;
    if (direccion(argv[1], &a, &longitud) == -1 || directorio_privado(argv[1]) == -1) {
        perror("direccion o directorio privado"); return EXIT_FAILURE;
    }
    struct sigaction accion = {0};
    accion.sa_handler = solicitar39;
    if (sigemptyset(&accion.sa_mask) == -1 ||
        sigaction(SIGINT, &accion, NULL) == -1 ||
        sigaction(SIGTERM, &accion, NULL) == -1) {
        perror("sigaction"); return EXIT_FAILURE;
    }
    struct cliente39 clientes[POSICIONES39] = {0};
    for (unsigned i = 0; i < POSICIONES39; ++i) clientes[i].fd = -1;
    int epfd = -1, escucha = -1, registrada = 0;
    int vinculado = 0, identificado = 0, salida = EXIT_FAILURE;
    unsigned aceptadas = 0, activos = 0, completadas = 0, fallos = 0;
    struct stat propia;
    epfd = epoll_create1(EPOLL_CLOEXEC);
    if (epfd == -1) { perror("epoll_create1"); goto fin; }
    escucha = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
    if (escucha == -1) { perror("socket"); goto fin; }
    mode_t mascara = umask(0177);
    int r = bind(escucha, (struct sockaddr *)&a, longitud);
    int motivo = errno;
    umask(mascara); errno = motivo;
    if (r == -1) { perror("bind"); goto fin; }
    vinculado = 1;
    if (lstat(argv[1], &propia) == -1) { perror("lstat propio"); goto fin; }
    if (!S_ISSOCK(propia.st_mode) || propia.st_uid != geteuid()) {
        fprintf(stderr, "No se identifico un socket propio\n"); goto fin;
    }
    identificado = 1;
    if ((propia.st_mode & 0777) != 0600) {
        fprintf(stderr, "Se requiere modo efectivo 0600\n"); goto fin;
    }
    if (listen(escucha, 8) == -1) { perror("listen"); goto fin; }
    if (escucha39(epfd, escucha, &registrada, 1) == -1) goto fin;
    struct timespec limite;
    if (fijar_plazo37(&limite, PLAZO39) == -1) goto fin;
    printf("Epoll39 listo: cuatro posiciones; lote %d; limite %u; plazo %d s\n",
           LOTE39, maximo, PLAZO39);
    if (fflush(stdout) == EOF) goto fin;

    for (;;) {
        if (parar39) { salida = 128 + (int)parar39; break; }
        if (aceptadas == maximo && activos == 0) {
            salida = fallos ? EXIT_FAILURE : EXIT_SUCCESS; break;
        }
        if (escucha != -1 &&
            escucha39(epfd, escucha, &registrada, activos < POSICIONES39) == -1)
            goto fin;
        struct timeval tv;
        int tiempo = restante37(&limite, &tv);
        if (tiempo == -1) goto fin;
        if (tiempo == 0) { fprintf(stderr, "Plazo global agotado\n"); goto fin; }
        int ms = tv.tv_sec >= 1 ? 250 : (int)((tv.tv_usec + 999) / 1000);
        if (ms > 250) ms = 250;
        struct epoll_event listos[LOTE39];
        int n = epoll_wait(epfd, listos, LOTE39, ms);
        if (n == -1) {
            if (errno == EINTR) continue;
            perror("epoll_wait"); goto fin;
        }
        uint32_t aviso_escucha = 0;
        for (int k = 0; k < n; ++k) {
            uint64_t token = listos[k].data.u64;
            if (token == 0) { aviso_escucha |= listos[k].events; continue; }
            uint32_t posicion = (uint32_t)token;
            uint32_t generacion = (uint32_t)(token >> 32);
            if (posicion == 0 || posicion > POSICIONES39) {
                fprintf(stderr, "Token fuera de la tabla\n"); goto fin;
            }
            unsigned i = posicion - 1u;
            struct cliente39 *c = &clientes[i];
            if (c->fd == -1 || c->generacion != generacion) continue;
            int paso = atender39(epfd, i, c, listos[k].events);
            if (paso == -2) goto fin;
            if (paso != 0) {
                if (paso == 1) ++completadas;
                else ++fallos;
                if (baja39(epfd, c) == -1) goto fin;
                --activos;
            }
        }
        if (aviso_escucha & (EPOLLERR | EPOLLHUP)) {
            fprintf(stderr, "Fallo de escucha\n"); goto fin;
        }
        /* Altas despues de todos los eventos del lote ya capturado. */
        if ((aviso_escucha & EPOLLIN) && escucha != -1 &&
            activos < POSICIONES39 && aceptadas < maximo) {
            int fd = accept4(escucha, NULL, NULL, SOCK_NONBLOCK | SOCK_CLOEXEC);
            if (fd == -1) {
                if (temporal39() || errno == ECONNABORTED) continue;
                perror("accept4"); goto fin;
            }
            ++aceptadas;
            unsigned i = 0;
            while (i < POSICIONES39 && clientes[i].fd != -1) ++i;
            if (i == POSICIONES39 || clientes[i].generacion == UINT32_MAX) {
                fprintf(stderr, "Posicion o generacion agotada\n");
                cerrar(&fd); goto fin;
            }
            struct cliente39 nuevo = {
                .fd = fd, .generacion = clientes[i].generacion + 1u,
                .fase = ENTRADA39
            };
            if (registrar39(epfd, EPOLL_CTL_ADD, fd, EPOLLIN | EPOLLRDHUP,
                            token39(i, &nuevo)) == -1) {
                cerrar(&fd); goto fin;
            }
            clientes[i] = nuevo;
            ++activos;
            if (aceptadas == maximo) {
                if (escucha39(epfd, escucha, &registrada, 0) == -1) goto fin;
                if (cerrar(&escucha) == -1) goto fin;
            }
        }
    }
fin:
    for (unsigned i = 0; i < POSICIONES39; ++i)
        if (baja39(epfd, &clientes[i]) == -1) salida = EXIT_FAILURE;
    if (registrada && escucha39(epfd, escucha, &registrada, 0) == -1)
        salida = EXIT_FAILURE;
    if (cerrar(&escucha) == -1) salida = EXIT_FAILURE;
    if (cerrar(&epfd) == -1) salida = EXIT_FAILURE;
    if (vinculado) {
        if (identificado) {
            if (retirar_propia(argv[1], &propia) == -1) salida = EXIT_FAILURE;
        } else {
            fprintf(stderr, "No se retira una ruta sin identidad confirmada\n");
            salida = EXIT_FAILURE;
        }
    }
    printf("Aceptadas: %u; salidas completas: %u; fallos de sesion: %u\n",
           aceptadas, completadas, fallos);
    if (fflush(stdout) == EOF) salida = EXIT_FAILURE;
    return salida;
}

Los errores de control no dejan al programa funcionando con un registro supuesto: se entra en limpieza. baja39 intenta DEL y después cierra la referencia incluso si retirar falló. Las cabeceras utilizadas no crean alias de los conectados.

El registro de una nueva conexión se completa antes de instalar su estado en la tabla. Si ADD falla, se cierra el descriptor recién aceptado y se termina el servicio. La generación anterior no se pierde al retirar una sesión: servirá para construir la identidad de la siguiente alta.

Las salidas completas solo acreditan envío local, incluida una respuesta vacía. La verificación de contenido y EOF corresponde al cliente. El servidor mantiene las precondiciones de directorio privado y retirada por identidad del tema 32.

10. Compilar y comparar con el cliente anterior

Usa cliente38.c del tema 38, sin modificarlo. Que el cliente no cambie muestra que la multiplexación es una decisión interna del servidor, mientras el contrato de bytes permanece compatible.

Bash en Linux · servidor epoll y cliente de prueba
$ gcc -std=c11 -Wall -Wextra -Wpedantic -O2 servidor39.c -o servidor39
$ gcc -std=c11 -Wall -Wextra -Wpedantic -O2 cliente38.c -o cliente39
$ sesion=$(mktemp -d /tmp/epoll39.XXXXXX)
$ ruta="$sesion/servicio.sock"
$ printf 'Ruta para los clientes: %s\n' "$ruta"
$ ./servidor39 "$ruta" 3
Epoll39 listo: cuatro posiciones; lote 2; limite 3; plazo 60 s

En otra terminal asigna ruta al valor absoluto que imprimió la primera y ejecuta los clientes dentro del plazo. Las variables no se comparten automáticamente entre terminales.

Bash · sesiones compatibles y contenido vacío
$ ruta=/tmp/epoll39.XXXXXX/servicio.sock  # Reemplazar por la ruta real.
$ ./cliente39 "$ruta" "hola" &
$ p1=$!
$ ./cliente39 "$ruta" "mundo" &
$ p2=$!
$ ./cliente39 "$ruta" ""
$ wait "$p1"
$ wait "$p2"
Respuesta verificada: 4 bytes y EOF
Respuesta verificada: 5 bytes y EOF
Respuesta verificada: 0 bytes y EOF

El orden puede variar. Cada cliente debe retornar cero. El servidor debe terminar con tres aceptaciones, tres salidas completas, cero fallos y sin dejar su socket de ruta.

Bash · limpieza del directorio en la primera terminal
Aceptadas: 3; salidas completas: 3; fallos de sesion: 0
$ test ! -e "$ruta" && echo "Socket propio retirado"
Socket propio retirado
$ rmdir -- "$sesion"

Para comparar resultados con poll, utiliza las mismas peticiones y las mismas condiciones externas en servidores ejecutados por separado. No atribuyas una diferencia de tiempos de unos pocos clientes únicamente a la API de espera.

11. Laboratorio de registros persistentes

Guarda registro39.c. Es autónomo y utiliza un par ya conectado. Comprueba que ADD duplicado falla, que la lectura parcial sigue preparada en el modo predeterminado y que MOD actualiza tanto la máscara como el dato devuelto.

registro39.c · ADD, MOD, medio cierre y DEL sin cerrar el socket
#define _GNU_SOURCE
#include <sys/epoll.h>
#include <sys/socket.h>
#include <unistd.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>

static int consultar(int epfd, struct epoll_event *salida)
{
    int n;
    do { n = epoll_wait(epfd, salida, 1, 0); } while (n == -1 && errno == EINTR);
    return n;
}

static ssize_t recibir_uno(int fd, char *b)
{
    ssize_t n;
    do { n = recv(fd, b, 1, 0); } while (n == -1 && errno == EINTR);
    return n;
}

int main(void)
{
    int par[2], epfd = -1, fallo = 1;
    if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC,
                   0, par) == -1) { perror("socketpair"); return EXIT_FAILURE; }
    epfd = epoll_create1(EPOLL_CLOEXEC);
    if (epfd == -1) { perror("epoll_create1"); goto fin; }
    struct epoll_event ev = { .events = EPOLLIN, .data.u64 = 3901 };
    struct epoll_event listo;
    if (epoll_ctl(epfd, EPOLL_CTL_ADD, par[1], &ev) == -1) goto fin;
    if (epoll_ctl(epfd, EPOLL_CTL_ADD, par[1], &ev) != -1 || errno != EEXIST) goto fin;
    puts("ADD duplicado: EEXIST");
    ssize_t n;
    do { n = send(par[0], "ab", 2, MSG_NOSIGNAL); }
    while (n == -1 && errno == EINTR);
    if (n != 2) goto fin;
    char b;
    if (consultar(epfd, &listo) != 1 || listo.data.u64 != 3901 ||
        !(listo.events & EPOLLIN) || recibir_uno(par[1], &b) != 1 || b != 'a') goto fin;
    if (consultar(epfd, &listo) != 1 || !(listo.events & EPOLLIN)) goto fin;
    puts("Level-triggered: el byte restante vuelve a estar preparado");
    ev.events = 0;
    ev.data.u64 = 3902;
    if (epoll_ctl(epfd, EPOLL_CTL_MOD, par[1], &ev) == -1 ||
        consultar(epfd, &listo) != 0) goto fin;
    ev.events = EPOLLIN | EPOLLRDHUP;
    if (epoll_ctl(epfd, EPOLL_CTL_MOD, par[1], &ev) == -1 ||
        consultar(epfd, &listo) != 1 || listo.data.u64 != 3902 ||
        recibir_uno(par[1], &b) != 1 || b != 'b') goto fin;
    puts("MOD: nueva mascara y nuevo dato devuelto");
    if (shutdown(par[0], SHUT_WR) == -1 || consultar(epfd, &listo) != 1 ||
        !(listo.events & EPOLLRDHUP) || recibir_uno(par[1], &b) != 0) goto fin;
    puts("EPOLLRDHUP: el receptor reconoce EOF despues de drenar");
    if (epoll_ctl(epfd, EPOLL_CTL_DEL, par[1], NULL) == -1 ||
        consultar(epfd, &listo) != 0) goto fin;
    if (recibir_uno(par[1], &b) != 0) goto fin;
    puts("DEL: deja de notificarse, pero el socket sigue abierto");
    fallo = 0;
fin:
    if (fallo) fprintf(stderr, "Fallo una comprobacion del laboratorio\n");
    if (epfd != -1 && close(epfd) == -1) fallo = 1;
    if (close(par[0]) == -1) fallo = 1;
    if (close(par[1]) == -1) fallo = 1;
    return fallo ? EXIT_FAILURE : EXIT_SUCCESS;
}
Bash · resultados sin pausas artificiales
$ gcc -std=c11 -Wall -Wextra -Wpedantic -O2 registro39.c -o registro39
$ ./registro39
ADD duplicado: EEXIST
Level-triggered: el byte restante vuelve a estar preparado
MOD: nueva mascara y nuevo dato devuelto
EPOLLRDHUP: el receptor reconoce EOF despues de drenar
DEL: deja de notificarse, pero el socket sigue abierto

La máscara cero del experimento no solicita lectura, pero no elimina el registro ni garantiza ausencia de eventos de error o cierre. DEL sí retira el interés de esa instancia. El control tampoco vacía o modifica un lote que ya se hubiera copiado en memoria de usuario.

12. Cierres, alias y lotes ya devueltos

Retirar un registro y cerrar un descriptor son operaciones diferentes. La primera cambia qué observa la instancia; la segunda libera una referencia de la aplicación. El ejemplo ejecuta DEL antes de close y conserva la identidad de generación en el estado.

El registro se relaciona con el descriptor y su descripción abierta. Si existen alias creados con dup, fork o transferencia, cerrar una sola referencia no debe usarse como garantía general de que ya no habrá observaciones de esa descripción. Antes de duplicar o delegar un recurso vigilado hay que diseñar su retirada explícita.

Los eventos ya devueltos por epoll_wait son datos locales del proceso. DEL no recorre tus arreglos para borrarlos. Una generación, un registro de conexiones activas y una política de liberación de memoria permiten decidir si esos resultados siguen siendo aplicables.

Tampoco existe EPOLLNVAL como equivalente de POLLNVAL para resolver todos los errores de propiedad. El programa comprueba los fallos de control y no interpreta un descriptor cerrado o un puntero inválido como una desconexión ordinaria.

13. Qué mejora y qué sigue costando

Aspectopoll del tema 38epoll de este tema
Intereses.Se entrega el arreglo en cada llamada.Se conservan en la instancia y cambian con ctl.
Resultados.Se recorre el arreglo para localizar revents.Se recorre el lote devuelto por wait.
Alta y baja.Actualizar las posiciones del arreglo.Actualizar estado y ejecutar ADD/DEL.
Salida pendiente.Cambiar events de la posición.Ejecutar MOD con la máscara completa.
Identidad.Asociación entre índice y estado.Dato guardado en el registro y validado al volver.
Portabilidad.Interfaz disponible en sistemas POSIX.Interfaz específica de Linux.

No reduzcas esta comparación a «epoll siempre es más rápido» ni a una promesa de costo constante para cualquier escenario. Hay trabajo de registro, administración de preparados, copia de eventos y llamadas de E/S. El costo real depende de cuántas conexiones están activas y de qué hace el servicio con ellas.

La aplicación del ejemplo aún utiliza una tabla pequeña y la recorre para buscar huecos y limpiar. En un servicio grande se pueden mantener listas de posiciones libres, estructuras de plazos y colas de tareas listas. epoll no proporciona esas estructuras de negocio.

También se consumen descriptores y memoria del núcleo para registros. La admisión debe considerar límites de archivos abiertos y de intereses vigilados. Eliminar fd_set no crea capacidad ilimitada de clientes.

14. Base level-triggered para el siguiente tema

Sin EPOLLET se utiliza level-triggered. Si quedan bytes por recibir, otra espera puede informar la misma conexión. Eso permite al servidor hacer una sola operación por evento y repartir turnos sin tener que vaciar toda la entrada de una vez.

Esta política todavía necesita sockets no bloqueantes: una observación puede quedar desactualizada y una escritura puede ser parcial. La aplicación conserva los contadores y vuelve a intentar cuando obtiene otra condición apropiada.

El tema 40 estudiará EPOLLET y la obligación de coordinar el drenaje hasta EAGAIN con presupuestos y trabajo pendiente. No agregues EPOLLET al ejemplo actual sin cambiar también la lógica de lectura, aceptación y salida: podría dejar bytes o conexiones pendientes sin otra notificación esperada.

EPOLLONESHOT también requiere un diseño propio de rearme y propiedad del trabajo. No está activado aquí. Primero conviene dominar el registro persistente, los estados y las bajas seguras con el modo predeterminado.

15. Explorar registros y generaciones

El modelo tiene una posición y un descriptor didáctico 7. ADD y MOD guardan su máscara y generación; esperar captura un evento en un lote local; despachar lo aplica solo si todavía pertenece a la sesión vigente. Las lecturas retiran hasta dos bytes.

Estado actual de la sesiónPosición 1; fd 7; generación 1

Interés guardado en el modelo del núcleoSin registro

Bytes de entrada / salida pendiente0 / 4

Lote local ya capturadoNinguno

Última operaciónSin llamada

Generación asociada al registroSin token

La máscara elegida no se registra hasta ejecutar ADD o MOD.

Registra lectura, entrega cuatro bytes y captura un evento. Despacha dos bytes y espera otra vez sin recibir más entrada: la condición persiste. Cambiar el selector solo prepara una máscara local; ejecuta MOD para modificar el registro.

Para probar un evento obsoleto, captura uno, reutiliza la posición y registra la sesión nueva. Después despacha el lote antiguo: su generación ya no coincide y no debe consumir datos ni salida de la sesión nueva.

DEL no borra el lote local mostrado. El modelo decide no despachar una posición sin registro; es una política de esta aplicación didáctica, además de la comprobación de generación. La capacidad de escritura se considera disponible y la salida inicial de cuatro bytes sirve para explorar sus intereses; no se representa un protocolo completo, cierres de transporte ni errores reales del núcleo.

16. Pruebas y diagnóstico

Compatibilidad, capacidad y límites

Fragmentación, eventos antiguos y fallos de control

Limita las llamadas reales de send y recv a un byte e introduce EINTR o EAGAIN antes de algunas operaciones. La salida debe conservarse completa; un error de epoll_wait no habilita a despachar el búfer de resultados que haya quedado en memoria.

Un controlador puede conservar un token de una sesión terminada y devolverlo en un lote posterior, después de reutilizar la misma posición. Debe comprobarse que el evento se ignora y que la nueva petición no se lee ni modifica por ese resultado obsoleto.

Inyecta fallos en ADD de un cliente y en MOD al pasar a salida. El servidor debe fallar, cerrar las referencias que conserva y retirar su ruta. Un fallo de DEL tampoco debe quedar oculto, aunque la limpieza intente cerrar el socket de todos modos.

Ejecuta registro39 para observar ADD duplicado, lectura parcial persistente, actualización de data y diferencia entre DEL y close. Con un controlador adicional verifica MOD o DEL de una entrada inexistente, sin asumir que el registro fue creado por una llamada que falló.

Prueba un cierre completo con entrada pendiente para revisar drenaje y fallo de respuesta; contrástalo con SHUT_WR, que conserva al cliente esperando el resultado. Un bit de RDHUP no autoriza a transformar un cuerpo que todavía no se terminó de recibir.

Recursos, plazo y publicación

Ejecuta con números de descriptor superiores a FD_SETSIZE si el entorno lo permite. Prueba también SIGTERM después del mensaje de arranque, el vencimiento con PLAZO39 reducido y una colisión de ruta que debe conservarse. El controlador externo debe cerrar sus clientes y recoger el proceso aunque falle una aserción.

Bash · traza sobre una ruta privada real preparada para el ensayo
$ strace -s 64 -e trace=epoll_create1,epoll_ctl,epoll_wait,epoll_pwait,accept4,sendto,recvfrom,close,unlink ./servidor39 "$ruta" 3

Busca ADD al aceptar, MOD al preparar respuesta, DEL antes del cierre y retirada o reinserción de la escucha según la capacidad. Las máscaras combinadas y el orden de los lotes pueden variar; exige resultados y recursos correctos en vez de una secuencia exacta de notificaciones.

En Linux, /proc/PID/fdinfo/EPFD permite inspeccionar registros de la instancia usando los valores reales de PID y EPFD. Los datos observados ayudan a contrastar la tabla de aplicación con los intereses del núcleo; no reemplazan las comprobaciones de retorno del programa.

17. Errores frecuentes

ErrorConsecuenciaCorrección
Confundir maxevents con cantidad total de clientes.Se limita mal el servicio o se recorre memoria no devuelta.Tratarlo como capacidad positiva del lote de salida.
Cambiar la máscara local sin MOD.El núcleo mantiene el interés anterior.Ejecutar ctl y comprobar éxito.
Omitir data al hacer MOD.La identidad devuelta deja de ser la esperada.Preparar máscara y token completos en cada cambio.
Guardar solo un número reutilizable sin validar sesión.Un evento antiguo puede aplicarse a otro cliente.Identidad con generación y comprobación de estado activo.
Liberar inmediatamente un objeto de data.ptr.Otro resultado ya capturado puede acceder a memoria liberada.Política de vida útil o token validado.
Suponer que DEL borra el lote local.Se despachan copias obsoletas sin comprobarlas.Validar identidad al recorrer cada resultado.
Mantener EPOLLOUT sin salida.El bucle puede despertar continuamente.Interés asociado solo a trabajo pendiente.
Mantener avisos de entrada después de su EOF.Se repite una condición ya procesada.Actualizar la máscara según la fase.
Cerrar la instancia y olvidar los sockets.La aplicación conserva referencias abiertas.Retirar y cerrar cada recurso propio.
Ocultar cualquier error de ctl.El estado supuesto y el registro pueden divergir.Diagnosticar y aplicar una política explícita.
Agregar EPOLLET al código sin cambiar sus turnos.Puede quedar trabajo sin una nueva notificación esperada.Estudiar y adaptar drenaje, aceptación y salida.
Prometer rendimiento constante para todo el servicio.Se ignoran procesamiento, memoria y recursos limitados.Medir el sistema completo bajo cargas representativas.

18. Resumen

19. Preguntas de repaso y práctica

Responde separando la instancia, los registros, el lote local y la identidad de cada sesión.

1. ¿Qué crea epoll_create1?

Una instancia de epoll referenciada por un descriptor. No crea clientes ni convierte sus sockets en no bloqueantes.

2. ¿EPOLL_CLOEXEC se aplica también a los sockets vigilados?

No. Marca el descriptor de la instancia; cada socket conserva su propia configuración.

3. ¿Cambiar una máscara en memoria actualiza el registro?

No. Se ejecuta EPOLL_CTL_MOD y se comprueba su retorno.

4. ¿MOD conserva data si no se vuelve a preparar?

La operación usa los ajustes nuevos, incluidos los datos asociados. El programa debe proporcionar el token correcto junto a la máscara.

5. ¿Un lote de dos eventos permite solo dos conexiones?

No. Es la capacidad del resultado de una espera. La instancia puede contener más registros y devolverlos en otras esperas.

6. ¿Por qué se usa una generación además del índice?

Porque una posición puede reutilizarse para otra sesión. La generación permite reconocer que un resultado anterior ya no le pertenece.

7. ¿data.ptr mantiene vivo el objeto apuntado?

No. La aplicación debe garantizar su vida útil frente a eventos pendientes o usar otro esquema de identidad.

8. ¿DEL cierra el descriptor?

No. Retira un registro de esa instancia. El recurso se cierra por separado cuando corresponde.

9. ¿DEL elimina los eventos que ya retornaron al proceso?

No. Son copias locales que deben validarse antes de aplicarse.

10. ¿EPOLLRDHUP permite omitir la lectura de bytes pendientes?

No. Indica cierre de envío remoto; aún hay que drenar y reconocer EOF mediante recv.

11. ¿Por qué se reemplaza la máscara al preparar una respuesta?

Porque la entrada ya terminó y ahora existe salida pendiente. Se observa EPOLLOUT y se dejan de solicitar avisos de entrada ya procesados.

12. ¿La escucha se cierra cuando se llenan las posiciones?

Se retira temporalmente del registro y se conserva su descriptor real. Se vuelve a agregar cuando hay capacidad, salvo que ya se alcanzó el máximo de aceptaciones.

13. ¿Por qué puede leerse solo una vez por evento en este ejemplo?

Porque utiliza level-triggered y la condición pendiente puede notificarse otra vez. Se conserva el estado y cada operación es no bloqueante.

14. ¿Basta con agregar EPOLLET para mejorar el ejemplo?

No. Cambia las obligaciones de drenaje y programación del trabajo pendiente; requiere adaptar también la lógica.

15. ¿epoll sustituye el control de memoria y consumidores lentos?

No. Sigue siendo necesario acotar colas, recursos, tiempos y trabajo por conexión y del servicio completo.

Para practicar y ampliar

  1. Ejecuta el servidor con el cliente del tema 38 y compara contenido y cierre.
  2. Prueba vacío, binario, 256 bytes y rechazo de 257.
  3. Reduce LOTE39 a uno y comprueba varias sesiones activas.
  4. Completa ocho sesiones y registra qué generaciones se reutilizaron por posición.
  5. Conserva un token antiguo en un controlador y verifica que no modifica una sesión nueva.
  6. Fuerza llamadas de un byte y retornos temporales sin perder el progreso.
  7. Provoca fallos de ADD y MOD y comprueba la limpieza completa.
  8. Observa fdinfo y relaciona cada registro con la fase de su conexión.
  9. Diseña una lista de posiciones libres y plazos individuales para aumentar la capacidad.
  10. Explica qué partes del código tendrían que cambiar antes de activar edge-triggered.
Próximo paso

El tema 40 comparará level-triggered y edge-triggered. Vas a estudiar EPOLLET, drenar hasta EAGAIN y mantener escrituras pendientes y contrapresión sin perder trabajo ni consumir turnos sin límite.