El lado escritor: publicar, synchronize_rcu, call_rcu y listas RCU

Si el lector es un fantasma, el escritor es un contable meticuloso: copia, publica de forma atómica y luego espera —o difiere la espera— hasta que sea seguro liberar la versión vieja. Aquí está el patrón que da nombre a RCU: Read, Copy, Update.

El patrón copy-update

El nombre lo dice todo. Para modificar una estructura protegida por RCU, el escritor no la edita in situ (eso rompería a los lectores en vuelo). En su lugar: lee el objeto actual (Read), lo copia en uno nuevo (Copy), actualiza la copia (Update), publica la copia y difiere la liberación del viejo.

Un detalle crucial: RCU coordina lectores-contra-escritores, no escritores-contra-escritores. Si hay varios escritores, siguen necesitando exclusión mutua entre ellos, típicamente un spinlock o un mutex.

static DEFINE_SPINLOCK(cfg_lock);        /* serializa escritores entre si */
static struct config __rcu *cfg;

static int actualizar(int nuevo_valor)
{
	struct config *viejo, *nuevo;

	nuevo = kmalloc(sizeof(*nuevo), GFP_KERNEL);
	if (!nuevo)
		return -ENOMEM;

	spin_lock(&cfg_lock);
	viejo = rcu_dereference_protected(cfg, lockdep_is_held(&cfg_lock));
	*nuevo = *viejo;                 /* Copy */
	nuevo->valor = nuevo_valor;      /* Update */
	rcu_assign_pointer(cfg, nuevo);  /* publica de forma atomica */
	spin_unlock(&cfg_lock);

	synchronize_rcu();               /* espera a los lectores del viejo */
	kfree(viejo);                    /* seguro: nadie lo mira ya */
	return 0;
}

Los lectores en vuelo cuando se ejecutó rcu_assign_pointer siguen usando viejo; los que llegan después ven nuevo. Nunca hay un estado intermedio visible.

synchronize_rcu vs call_rcu

Hay dos formas de esperar el grace period, y elegir bien define el rendimiento.

synchronize_rcu() bloquea al llamante hasta que transcurre un grace period completo —que puede durar milisegundos. Es simple y correcto, pero exige un contexto donde puedas dormir: nada de spinlocks tomados, nada de contexto de interrupción.

call_rcu() no bloquea: registra un callback que se ejecutará tras el próximo grace period y devuelve el control de inmediato. El objeto debe embeber un struct rcu_head. El callback corre más tarde, en softirq. Úsalo cuando no puedes dormir o cuando el throughput importa.

struct nodo {
	u32 clave;
	int valor;
	struct list_head lista;
	struct rcu_head rcu;         /* necesario para call_rcu/kfree_rcu */
};

static void liberar_nodo(struct rcu_head *head)
{
	struct nodo *n = container_of(head, struct nodo, rcu);

	kfree(n);
}

/* ...tras desenlazar n bajo el lock de escritura... */
call_rcu(&n->rcu, liberar_nodo);   /* difiere la liberacion, no bloquea */

/* Si el callback solo hace kfree, hay un atajo sin escribir funcion: */
kfree_rcu(n, rcu);                 /* equivalente idiomatico */

Hay más azúcar en esta familia. kvfree_rcu() cubre memoria reservada con kvmalloc; y existe una forma de un solo argumento, kfree_rcu(ptr), que espera el grace period sin necesidad de un struct rcu_head embebido, a costa de poder bloquear brevemente. Como regla: usa synchronize_rcu() cuando actualizas rara vez y puedes permitirte esperar, y call_rcu/kfree_rcu cuando el contexto es atómico o el throughput manda.

Listas RCU

Casi nunca proteges un solo puntero: proteges colecciones. linux/rculist.h ofrece variantes RCU de las listas del nivel 10, y su diseño esconde una sutileza preciosa.

• Lado lector: list_for_each_entry_rcu(), siempre dentro de rcu_read_lock().
• Insertar: list_add_rcu(), list_add_tail_rcu() — publican el nodo con rcu_assign_pointer por debajo.
• Borrar: list_del_rcu() — desenlaza para que ningún lector nuevo alcance el nodo, pero conserva su puntero next válido.
• Reemplazar: list_replace_rcu().

La sutileza: list_del_rcu() no envenena el puntero next como hace list_del(). ¿Por qué? Porque un lector concurrente puede estar parado sobre ese nodo justo ahora, y necesita seguir next para continuar el recorrido. Envenenarlo lo mandaría a LIST_POISON y provocaría un crash. El nodo sigue apuntando hacia adelante hasta que el grace period garantiza que nadie lo pisa.

static LIST_HEAD(lista);
static DEFINE_SPINLOCK(lista_lock);

/* Lector: sin bloqueo */
rcu_read_lock();
list_for_each_entry_rcu(n, &lista, lista) {
	if (n->clave == k)
		usar(n->valor);
}
rcu_read_unlock();

/* Escritor: insertar */
spin_lock(&lista_lock);
list_add_rcu(&nuevo->lista, &lista);
spin_unlock(&lista_lock);

/* Escritor: borrar y diferir liberacion */
spin_lock(&lista_lock);
list_del_rcu(&n->lista);
spin_unlock(&lista_lock);
kfree_rcu(n, rcu);

flowchart LR
W[Escritor copia y actualiza] --> P[rcu_assign_pointer publica el nuevo]
P --> O[Lectores en vuelo siguen en la version vieja]
P --> N[Lectores nuevos ven la version nueva]
O --> G[Grace period]
G --> F[call_rcu o kfree libera la version vieja]
style P fill:#f9e2af,color:#11111b
style G fill:#cba6f7,color:#11111b
style F fill:#89b4fa,color:#11111b