Scatter-gather y la máscara de DMA

Los buffers reales rara vez son un bloque físico contiguo. Un buffer de usuario abarca decenas de páginas dispersas por toda la RAM; una E/S de disco reúne fragmentos de aquí y de allá. Mapear y transferir cada trozo por separado sería absurdo. El scatter-gather describe todo el buffer como una lista de segmentos y lo entrega al dispositivo en una única operación lógica. Y la máscara de DMA declara hasta qué dirección puede llegar el dispositivo, para que la API respete sus límites.

El problema: memoria dispersa

La memoria virtual crea una ilusión de continuidad que la física no comparte. Un buffer de 256 KiB que un proceso ve contiguo puede estar repartido en 64 páginas físicas esparcidas por toda la RAM. Un dispositivo que hiciera DMA necesitaría 64 transferencias con 64 direcciones distintas. El scatter-gather (SG) resuelve esto: se describe el buffer como una lista de segmentos, cada uno un par de dirección y longitud, y el motor de DMA del dispositivo recorre la lista —gather al leer, scatter al escribir— en una sola operación.

struct scatterlist y sg_table

El kernel representa cada segmento con un struct scatterlist, y la lista completa con un struct sg_table que agrupa el array y su cuenta. Se inicializa con sg_alloc_table y se rellena apuntando cada entrada a una página con sg_set_page (o a un buffer con sg_set_buf):

#include <linux/scatterlist.h>
#include <linux/dma-mapping.h>

struct sg_table sgt;
struct scatterlist *sg;
int i, ret;

ret = sg_alloc_table(&sgt, nr_pages, GFP_KERNEL);
if (ret)
	return ret;

for_each_sgtable_sg(&sgt, sg, i)
	sg_set_page(sg, pages[i], PAGE_SIZE, 0);   /* lado CPU: pagina, longitud, offset */

En esta fase la lista describe el lado de la CPU: qué páginas físicas componen el buffer. Todavía no hay ninguna dirección de bus; eso lo produce el mapeo.

Mapear la lista y la fusión del IOMMU

dma_map_sgtable mapea la lista entera de una vez. Es la API moderna, preferible al viejo dma_map_sg: devuelve 0 o un -errno limpio en lugar de la ambigua cuenta que devolvía su antecesor. Tras mapear, no recorres los segmentos originales, sino los segmentos DMA, que pueden ser menos, y se leen con sg_dma_address y sg_dma_len:

ret = dma_map_sgtable(dev, &sgt, DMA_TO_DEVICE, 0);
if (ret)
	goto free_table;

/* recorrer los SEGMENTOS DMA: pueden ser menos que las paginas de entrada */
for_each_sgtable_dma_sg(&sgt, sg, i) {
	dma_addr_t seg = sg_dma_address(sg);
	unsigned int  n = sg_dma_len(sg);
	programar_descriptor(dev, seg, n);   /* un descriptor de hardware por segmento */
}

La razón de que haya menos segmentos es preciosa: cuando hay un IOMMU (nivel 27.4), páginas físicamente dispersas pueden mapearse a IOVA contiguas, y entonces la API las fusiona (coalesce) en un solo segmento DMA. Sesenta y cuatro páginas sueltas pueden convertirse en un único segmento que el dispositivo ve como una extensión continua: un solo descriptor en lugar de sesenta y cuatro. Por eso jamás debes leer sg->length ni asumir que el número de segmentos DMA iguala al de páginas; usa siempre los descriptores DMA y la cuenta que quedó tras el mapeo.

El desmontaje es simétrico y usa la tabla original; la API sabe deshacer la fusión:

dma_unmap_sgtable(dev, &sgt, DMA_TO_DEVICE, 0);
sg_free_table(&sgt);

flowchart LR
P0[Pagina fisica 3] --> IO[IOMMU]
P1[Pagina fisica 9] --> IO
P2[Pagina fisica 1] --> IO
IO -->|un solo segmento contiguo| DEV[El dispositivo ve una extension unica]

La máscara de DMA: hasta dónde alcanza el dispositivo

No todo dispositivo puede direccionar toda la RAM. Uno legado de 32 bits no llega por encima de los 4 GiB. El dispositivo declara su alcance con la máscara de DMA, y la API la respeta: si un buffer cae fuera, recurre a un buffer de rebote o, con IOMMU, entrega una IOVA dentro del alcance. Se fija con dma_set_mask_and_coherent, que además comprueba que la plataforma puede satisfacerlo:

/* declarar 64 bits, con reserva a 32 si la plataforma no da mas */
ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(64));
if (ret) {
	ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32));
	if (ret) {
		dev_err(dev, "sin DMA de 32 bits utilizable\n");
		return ret;
	}
	dev_info(dev, "limitado a DMA de 32 bits\n");
}

Si no fijas nada, el valor por defecto es 32 bits, conservador y a menudo subóptimo en máquinas con mucha RAM porque fuerza rebotes innecesarios. Declarar la máscara real es de las primeras cosas que hace un driver en su probe, y comprobar el retorno es obligatorio: en algunas plataformas ni siquiera los 32 bits están garantizados.