El espacio de direcciones: mm_struct, VMAs y el maple tree

Todo proceso cree poseer la máquina entera: un espacio de direcciones plano, privado, que arranca cerca de cero y llega hasta el techo del hardware. Es la gran mentira del kernel, y mm_struct es el libro de contabilidad donde la sostiene. Dentro viven las VMAs: los tramos reales y homogéneos que el proceso sí tiene mapeados. Entender esta estructura es entender de qué está hecha, literalmente, la memoria de un proceso.

mm_struct: el descriptor del espacio

Cada proceso tiene un struct mm_struct (definido en include/linux/mm_types.h) que describe todo su espacio de direcciones. task_struct->mm apunta a él. Los hilos de un mismo proceso comparten el mismo mm_struct —eso es exactamente lo que significa CLONE_VM en clone—, mientras que un proceso independiente tiene el suyo.

struct mm_struct {
	struct {
		struct maple_tree mm_mt;       /* arbol de VMAs: antes mm_rb + lista */
		pgd_t *pgd;                    /* raiz de la tabla de paginas */
		atomic_t mm_users;             /* hilos que usan este espacio */
		atomic_t mm_count;             /* referencias al propio mm_struct */
		int map_count;                 /* numero de VMAs */
		struct rw_semaphore mmap_lock; /* protege el arbol de VMAs */
		unsigned long mmap_base;       /* base donde crece mmap */
		unsigned long task_size;       /* limite del espacio de usuario */
		unsigned long start_code, end_code, start_data, end_data;
		unsigned long start_brk, brk;  /* el heap: brk lo mueve sbrk/brk */
		unsigned long start_stack;
		/* ...decenas de campos mas: rss, exe_file, context... */
	} __randomize_layout;
};

Dos detalles cruciales. pgd es la raíz de la tabla de páginas: al cambiar de proceso, el planificador carga su dirección física en CR3 (x86) o TTBR0 (arm64), y con eso la MMU ve otro espacio. Y hay dos contadores de referencia: mm_users cuenta los hilos que ejecutan en este espacio; mm_count cuenta las referencias a la estructura en sí. Cuando mm_users llega a cero se desmontan las VMAs; cuando mm_count llega a cero se libera el mm_struct. Un mm_count extra lo toma, por ejemplo, un kthread que usa mmget_not_zero para pisar temporalmente un espacio ajeno.

La VMA: una región homogénea

El espacio de direcciones no es un bloque único: es un conjunto de regiones, cada una con permisos y respaldo uniformes. Una vm_area_struct describe un intervalo semiabierto de direcciones virtuales, vm_start incluido y vm_end excluido, con las mismas propiedades en toda su extensión.

struct vm_area_struct {
	unsigned long vm_start;        /* primera direccion, inclusive */
	unsigned long vm_end;          /* primera fuera, exclusive */
	struct mm_struct *vm_mm;       /* el espacio al que pertenece */
	pgprot_t vm_page_prot;         /* permisos de hardware para las PTE */
	vm_flags_t vm_flags;           /* VM_READ, VM_WRITE, VM_EXEC, VM_SHARED... */
	struct anon_vma *anon_vma;     /* mapeo inverso para paginas anonimas */
	const struct vm_operations_struct *vm_ops; /* callbacks: fault, open... */
	unsigned long vm_pgoff;        /* desplazamiento en vm_file, en paginas */
	struct file *vm_file;          /* fichero mapeado, o NULL si es anonimo */
	void *vm_private_data;
};

Cada línea de /proc/PID/maps es una VMA. Los límites, los permisos rwxp y el fichero de respaldo salen directos de estos campos:

cat /proc/self/maps
# 5623a1c00000-5623a1c01000 r-xp 00000000 08:02 1310795 /usr/bin/cat  <- una VMA
# 7f3b2a4c0000-7f3b2a4e2000 r--p 00000000 08:02 2097550 .../libc.so.6 <- otra VMA
# 7ffde3a00000-7ffde3a21000 rw-p 00000000 00:00 0       [stack]        <- otra VMA

La p final significa privado (respaldo copy-on-write); una s sería MAP_SHARED. La distinción entre respaldo por fichero y anónimo la marca vm_file, y la trataremos a fondo en el nivel 23.5.

Del rbtree con lista al maple tree

Durante casi veinte años, cada mm_struct mantenía dos estructuras redundantes: una lista doblemente enlazada (vma->vm_next, vma->vm_prev) para recorrer las VMAs en orden, y un árbol rojo-negro (mm->mm_rb) para buscar por dirección en tiempo logarítmico. Dos estructuras que había que mantener sincronizadas en cada inserción y borrado: fuente perpetua de bugs sutiles y de contención.

Linux 6.1 (2022) las sustituyó por una sola: el maple tree (mm->mm_mt). Es un árbol tipo B optimizado para almacenar rangos no solapados, con nodos anchos que aprovechan la línea de caché y, sobre todo, con lectura segura bajo RCU. Las VMAs perdieron sus punteros vm_next/vm_prev: ya no hay lista.

flowchart TB
MM[mm_struct] --> MT[maple_tree mm_mt]
MT --> N0[nodo raiz: rangos ordenados]
N0 --> V1[VMA 0x5623 codigo r-x]
N0 --> V2[VMA 0x7f3b libc r--]
N0 --> V3[VMA 0x7ffd pila rw-]
style MT fill:#89b4fa,color:#11111b
style N0 fill:#f9e2af,color:#11111b

La ganancia no es solo elegancia: una sola estructura significa una sola invalidación de caché por operación, búsqueda por rango nativa, y lectores que consultan sin bloquear al escritor. Es la infraestructura sobre la que se construyeron después los locks por-VMA que veremos en el nivel 23.3.

Recorrer las VMAs

Con el maple tree, el idioma para iterar es el VMA_ITERATOR y la macro for_each_vma. Para localizar la VMA que cubre una dirección concreta —lo primero que hace un page fault— está find_vma, que devuelve la primera VMA con vm_end > addr.

struct vm_area_struct *vma;
VMA_ITERATOR(vmi, mm, 0);              /* iterador desde la direccion 0 */

mmap_read_lock(mm);                    /* toma el mmap_lock en lectura */
for_each_vma(vmi, vma)
	pr_info("%lx-%lx flags=%lx\n", vma->vm_start, vma->vm_end, vma->vm_flags);
mmap_read_unlock(mm);

/* Buscar la VMA de una direccion concreta: */
vma = find_vma(mm, address);
if (vma && address >= vma->vm_start)
	; /* la direccion cae dentro de esta VMA */

Toda travesía o modificación del árbol exige el mmap_lock (un rw_semaphore, renombrado en su día desde mmap_sem): en lectura para consultar, en escritura para mmap, munmap o mprotect. Sostener este cerrojo global en cada fallo de página fue durante años un cuello de botella para cargas con muchos hilos; el nivel 23.3 mostrará cómo los locks por-VMA lo esquivan en el camino rápido.