DMA-BUF: compartir buffers entre dispositivos

Una cámara captura un fotograma, una GPU lo procesa, un codificador lo comprime y una pantalla lo muestra. Cuatro dispositivos, un mismo fotograma. Copiarlo entre cada etapa —a 4K y 60 fps— fundiría el ancho de banda de memoria de cualquier sistema. DMA-BUF es la respuesta del kernel: un framework para que esos dispositivos compartan el mismo buffer físico, pasándose no los datos sino un descriptor de fichero que los representa. Es el zero-copy elevado de un proceso a todo un pipeline de hardware.

El problema: un buffer, muchos dispositivos

Sin un marco común, cada driver reserva su propia memoria y compartir significa copiar de una a otra, a menudo pasando por userspace. DMA-BUF define un objeto —struct dma_buf— que envuelve un buffer y lo hace transferible entre subsistemas. Un lado lo exporta (es el dueño, quien lo reservó); otros lo importan para leer o escribir por DMA. Y el vínculo entre ambos no es un puntero de kernel: es un descriptor de fichero, que puede viajar por userspace y cruzar procesos.

El exportador: dma_buf_ops y dma_buf_export

El dueño del buffer implementa un puñado de callbacks. Los dos centrales, map_dma_buf y unmap_dma_buf, se ejecutan cuando un importador quiere acceso: devuelven una sg_table con las direcciones DMA vistas desde ese dispositivo concreto.

#include <linux/dma-buf.h>

static struct sg_table *exp_map(struct dma_buf_attachment *att,
                                enum dma_data_direction dir)
{
	struct my_buf *b = att->dmabuf->priv;
	/* Mapea las paginas de 'b' para el dispositivo importador (att->dev)
	   y devuelve su tabla scatter-gather con direcciones DMA validas. */
	return my_build_sgt(b, att->dev, dir);
}

static void exp_unmap(struct dma_buf_attachment *att,
                      struct sg_table *sgt, enum dma_data_direction dir)
{
	dma_unmap_sgtable(att->dev, sgt, dir, 0);
	sg_free_table(sgt);
	kfree(sgt);
}

static const struct dma_buf_ops exp_ops = {
	.map_dma_buf   = exp_map,
	.unmap_dma_buf = exp_unmap,
	.release       = exp_release,   /* liberar el buffer cuando nadie lo usa */
	.mmap          = exp_mmap,       /* opcional: exponerlo tambien a userspace */
};

Con los callbacks listos, creas el dma_buf y obtienes su fd:

DEFINE_DMA_BUF_EXPORT_INFO(info);
info.ops   = &exp_ops;
info.size  = b->size;
info.flags = O_RDWR | O_CLOEXEC;
info.priv  = b;                     /* tu buffer, recuperable via dmabuf->priv */

struct dma_buf *dmabuf = dma_buf_export(&info);
if (IS_ERR(dmabuf))
	return PTR_ERR(dmabuf);

int fd = dma_buf_fd(dmabuf, O_CLOEXEC);   /* el fd que viaja a userspace */

Ese fd es todo lo que hace falta compartir. Un proceso lo recibe, lo pasa a otro driver por un ioctl, y el buffer entero queda accesible al segundo dispositivo sin haber copiado un byte.

El importador: dma_buf_get, attach y map

El otro lado recupera el objeto desde el fd, se adjunta como consumidor y pide el mapeo para su propio dispositivo.

struct dma_buf *dmabuf = dma_buf_get(fd);        /* fd -> struct dma_buf */
struct dma_buf_attachment *att = dma_buf_attach(dmabuf, importer_dev);

/* Mapea para MI dispositivo: obtengo direcciones DMA que mi motor entiende */
struct sg_table *sgt =
	dma_buf_map_attachment_unlocked(att, DMA_FROM_DEVICE);

program_dma_engine(importer_dev, sgt->sgl);      /* mi hardware lee de ahi */

/* al terminar, en orden inverso */
dma_buf_unmap_attachment_unlocked(att, sgt, DMA_FROM_DEVICE);
dma_buf_detach(dmabuf, att);
dma_buf_put(dmabuf);

La belleza del attach es que cada importador obtiene la sg_table traducida a su propia vista: si el dispositivo está detrás de una IOMMU (nivel 27), las direcciones que recibe son las de su espacio DMA, no las físicas crudas. El mismo buffer, direcciones distintas para cada consumidor, y ni una copia. En Linux 7.x los ayudantes con sufijo _unlocked son la interfaz para quien no sostiene ya el dma_resv del buffer.

Sincronizar y el papel en gráficos: dma_fence

Compartir el buffer no basta: hay que sincronizar cuándo cada dispositivo puede tocarlo. Ese es el trabajo de dma_fence, una promesa de “esta operación habrá terminado”. Se guardan en el dma_resv asociado al dma_buf: la GPU adjunta una fence al terminar de renderizar, y la pantalla espera esa fence antes de escanear el fotograma. Así se encadenan etapas sin copias y sin bloqueos activos.

/* La pantalla espera a que la GPU termine antes de leer el buffer */
struct dma_resv *resv = dmabuf->resv;
dma_resv_wait_timeout(resv, DMA_RESV_USAGE_READ, true,
                      msecs_to_jiffies(100));

Sobre esta base se construyen los gráficos modernos. En DRM, la extensión PRIME convierte un buffer de GPU en un fd DMA-BUF (DRM_IOCTL_PRIME_HANDLE_TO_FD) y de vuelta. Wayland pasa esos fds del cliente al compositor por el protocolo linux-dmabuf, y Vulkan los importa y exporta con VK_KHR_external_memory_fd. El resultado es un pipeline de extremo a extremo —cámara, GPU, codificador, pantalla, compositor— donde el fotograma vive en un solo sitio y todos lo miran a través de su propio fd.

flowchart LR
C[Camara exportador] -->|dma_buf_fd| FD[Descriptor de fichero]
FD -->|dma_buf_get| G[GPU importador]
FD -->|dma_buf_get| V[Codificador de video]
FD -->|dma_buf_get| D[Pantalla]
style C fill:#89b4fa,color:#11111b
style FD fill:#f9e2af,color:#11111b
style G fill:#a6e3a1,color:#11111b
style V fill:#cba6f7,color:#11111b
style D fill:#94e2d5,color:#11111b