mmap en un driver: exponer memoria sin copiar

La forma más pura de zero-copy en un driver es no mover nada: hacer que el proceso de usuario y el kernel toquen exactamente los mismos marcos físicos. Cuando implementas file_operations.mmap, dejas de servir bytes con read y write y empiezas a compartir memoria. El usuario mapea una vez y, a partir de ahí, cada acceso es un desreferenciado de puntero que llega directo al buffer del driver o al registro del hardware. Aquí está la técnica, sus tres variantes, y la trampa de coherencia que todas comparten.

El gancho: file_operations.mmap

Cuando un proceso llama a mmap sobre el fichero de dispositivo, el camino do_mmap a call_mmap (nivel 23) desemboca en tu método. Recibes la VMA ya construida y tu trabajo es poblar la tabla de páginas del rango [vma->vm_start, vma->vm_end) con tus marcos físicos, o instalar un vm_ops que los provea bajo demanda.

static int mydev_mmap(struct file *filp, struct vm_area_struct *vma);

static const struct file_operations mydev_fops = {
	.owner = THIS_MODULE,
	.open  = mydev_open,
	.mmap  = mydev_mmap,       /* lo invoca el kernel en mmap(2) */
};

dma_mmap_coherent: el buffer que comparten hardware y usuario

El caso estrella del nivel 42 es un buffer DMA que llena el dispositivo y consume el proceso sin intermediarios. No uses remap_pfn_range a pelo sobre memoria DMA: la API de DMA (nivel 27) tiene su propio ayudante de mapeo que respeta la coherencia y la IOMMU.

/* En probe: reservar un buffer coherente que el dispositivo llenara por DMA */
dev->vaddr = dma_alloc_coherent(&pdev->dev, dev->size,
                                &dev->dma_handle, GFP_KERNEL);
/* dev->vaddr : direccion virtual del kernel
   dev->dma_handle : direccion que el motor DMA del dispositivo entiende */

static int mydev_mmap(struct file *filp, struct vm_area_struct *vma)
{
	struct mydev *dev = filp->private_data;
	unsigned long size = vma->vm_end - vma->vm_start;

	if (size > dev->size)
		return -EINVAL;

	vm_flags_set(vma, VM_DONTEXPAND | VM_DONTDUMP);

	/* Mapea el MISMO buffer DMA al usuario, con los atributos de cache
	   correctos para la plataforma. Sin copia: el proceso ve lo que el
	   hardware escribe. */
	return dma_mmap_coherent(&dev->pdev->dev, vma, dev->vaddr,
	                         dev->dma_handle, size);
}

Ahora el flujo es de copia cero de extremo a extremo: el dispositivo escribe por DMA en el buffer coherente, y el proceso lo lee desde su propio espacio de direcciones sin que la CPU toque un solo byte de tránsito. Es el patrón de las cámaras, las capturadoras y los aceleradores que vuelcan datos a un anillo compartido con el software.

remap_pfn_range: cablear una región contigua de golpe

Si expones registros MMIO o un buffer físicamente contiguo reservado, remap_pfn_range instala de una vez las traducciones de todo el rango. Trabaja en page frame numbers: la dirección física desplazada PAGE_SHIFT bits.

static int mydev_mmap(struct file *filp, struct vm_area_struct *vma)
{
	struct mydev *dev = filp->private_data;
	unsigned long size = vma->vm_end - vma->vm_start;
	unsigned long pfn  = dev->phys_base >> PAGE_SHIFT;   /* marco fisico base */

	if (size > dev->len)
		return -EINVAL;

	/* Memoria de dispositivo: sin struct page, no cacheable, no volcar */
	vm_flags_set(vma, VM_IO | VM_PFNMAP | VM_DONTEXPAND | VM_DONTDUMP);
	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);

	return remap_pfn_range(vma, vma->vm_start,
	                       pfn + vma->vm_pgoff,   /* respeta el offset de mmap */
	                       size, vma->vm_page_prot);
}

VM_IO marca espacio de E/S; VM_PFNMAP declara que detrás de estas PFN no hay un struct page gestionado; VM_DONTEXPAND frena un mremap que la agrande; VM_DONTDUMP la excluye del core. Para MMIO real, io_remap_pfn_range ajusta atributos de bus en algunas arquitecturas.

.fault: poblar página a página un buffer disperso

remap_pfn_range exige contigüidad física. Un buffer de vmalloc es contiguo en el espacio virtual del kernel pero disperso en el físico, así que hay que mapearlo perezosamente: instalas un vm_operations_struct con .fault y el kernel te llama una vez por cada página que el usuario toque.

static vm_fault_t mydev_fault(struct vm_fault *vmf)
{
	struct mydev *dev = vmf->vma->vm_private_data;
	unsigned long offset = vmf->pgoff << PAGE_SHIFT;   /* byte dentro del buffer */
	struct page *page;

	if (offset >= dev->len)
		return VM_FAULT_SIGBUS;            /* fuera de rango: senal al proceso */

	page = vmalloc_to_page(dev->buf + offset);
	get_page(page);                            /* referencia que sostiene el mapeo */
	vmf->page = page;                          /* el core instala la PTE */
	return 0;
}

static const struct vm_operations_struct mydev_vm_ops = {
	.fault = mydev_fault,
};

static int mydev_mmap(struct file *filp, struct vm_area_struct *vma)
{
	vma->vm_ops = &mydev_vm_ops;
	vma->vm_private_data = filp->private_data;
	vm_flags_set(vma, VM_DONTEXPAND | VM_DONTDUMP);
	return 0;                              /* nada mapeado aun: sera perezoso */
}