Zero-copy en red: MSG_ZEROCOPY e io_uring

En el envío de red queda una copia que ni sendfile ni splice eliminan cuando el dato nace en userspace: la del buffer del proceso al sk_buff del kernel. MSG_ZEROCOPY la borra fijando las páginas del usuario y dejando que la NIC lea de ellas por DMA. Pero esa copia cero no es gratis: introduce un modelo asíncrono de finalización que complica el código y solo gana por encima de cierto tamaño. Este último nivel une las dos piezas —MSG_ZEROCOPY e io_uring— y cierra el círculo entendiendo que el zero-copy no elimina el coste, lo desplaza.

MSG_ZEROCOPY: send sin copiar el payload

Se activa por socket y se pide por envío. El kernel fija las páginas del buffer, apunta a ellas desde el sk_buff y la NIC las lee por DMA directamente.

/* Una vez por socket: habilitar zero-copy */
int one = 1;
setsockopt(fd, SOL_SOCKET, SO_ZEROCOPY, &one, sizeof one);

/* Por envio: el kernel NO copia; fija las paginas de 'buf' */
ssize_t n = send(fd, buf, len, MSG_ZEROCOPY);

Aquí aparece la sutileza que lo cambia todo. send regresa antes de que la NIC haya terminado de transmitir. Como el kernel no copió el dato, las páginas de buf siguen siendo la fuente de la transmisión: el proceso no debe reescribirlas hasta que el hardware las haya leído y la red haya confirmado el envío. ¿Cómo sabe el proceso que ya puede reutilizar el buffer? Con una notificación asíncrona que el kernel deposita en la cola de errores del socket.

La notificación de finalización: MSG_ERRQUEUE

Cada send con MSG_ZEROCOPY lleva un número de secuencia. Cuando el kernel termina con esas páginas, encola un aviso que lees con recvmsg sobre MSG_ERRQUEUE.

#include <linux/errqueue.h>

/* El kernel avisa cuando ya no necesita las paginas fijadas */
char control[128];
struct msghdr msg = { .msg_control = control, .msg_controllen = sizeof control };

recvmsg(fd, &msg, MSG_ERRQUEUE);

struct cmsghdr *cm = CMSG_FIRSTHDR(&msg);
struct sock_extended_err *serr = (void *)CMSG_DATA(cm);

if (serr->ee_origin == SO_EE_ORIGIN_ZEROCOPY) {
	/* ee_data..ee_info: rango de numeros de envio ya completados */
	uint32_t lo = serr->ee_info, hi = serr->ee_data;
	liberar_buffers_en_rango(lo, hi);   /* ya puedo reusar esas paginas */
}

El kernel agrupa completados por rangos para amortizar el coste. Y hay un detalle honesto: si en el último tramo la copia habría sido más barata que fijar las páginas, el kernel puede decidir copiar de todos modos y marcarlo con el bit SO_EE_CODE_ZEROCOPY_COPIED. El zero-copy es una petición, no una garantía.

io_uring: elimina también la syscall

io_uring (niveles 40 y 41) lleva el zero-copy un paso más allá: no solo evita la copia del payload, sino que elimina la propia llamada al sistema por operación mediante sus anillos de submission y completion. La operación de envío zero-copy es IORING_OP_SEND_ZC.

/* Fijar los buffers UNA vez: el kernel los mapea de forma persistente */
struct iovec iov = { .iov_base = buf, .iov_len = len };
io_uring_register_buffers(&ring, &iov, 1);

/* Envio zero-copy encolado en el anillo, sin syscall por operacion */
struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
io_uring_prep_send_zc(sqe, fd, buf, len, 0, 0);
io_uring_submit(&ring);

Con io_uring_register_buffers, las páginas se fijan una sola vez al arrancar en lugar de en cada envío: el coste de pinning que penalizaba a MSG_ZEROCOPY se paga una vez y se amortiza sobre millones de operaciones. Y la finalización, que en sockets exigía leer la cola de errores, aquí llega como un evento de completado ordinario: por cada send_zc recibes dos CQE, una con IORING_CQE_F_MORE (el envío se aceptó) y otra con IORING_CQE_F_NOTIF (el kernel ya soltó las páginas y puedes reusarlas).

struct io_uring_cqe *cqe;
io_uring_wait_cqe(&ring, &cqe);

if (cqe->flags & IORING_CQE_F_NOTIF) {
	/* el kernel ya no necesita el buffer: reutilizable */
	reciclar_buffer();
}
io_uring_cqe_seen(&ring, cqe);

El equilibrio: complejidad contra rendimiento

flowchart TD
Q[Cuanto mide el envio y cuanta complejidad toleras] -->|Pequeno o simple| A[send normal con una copia]
Q -->|Grande y toleras async| B[MSG_ZEROCOPY con errqueue]
Q -->|Grande y maximo rendimiento| C[io_uring send_zc con buffers registrados]
style A fill:#89b4fa,color:#11111b
style B fill:#f9e2af,color:#11111b
style C fill:#a6e3a1,color:#11111b