FUSE: un sistema de archivos en el espacio de usuario

Los cuatro niveles anteriores escribían el sistema de archivos dentro del kernel, donde un puntero mal calculado es un pánico y donde todo el código debe ser C bajo la licencia GPL. FUSE ofrece el camino opuesto: escribir la lógica en un programa de usuario corriente, en cualquier lenguaje, sin privilegios, que puede fallar sin llevarse el sistema por delante. El truco es un módulo genérico del kernel, fuse, que no implementa ningún sistema de archivos concreto: implementa un puente. Cada operación del VFS sobre un montaje FUSE se convierte en un mensaje que cruza a userspace, se resuelve allí y regresa. Este último nivel del track diseca ese puente, lo pone en marcha con libfuse y establece cuándo vale la pena cruzar la frontera.

El puente kernel-usuario

Del lado del kernel, FUSE es un sistema de archivos como cualquiera de los que escribimos: registra un file_system_type, rellena las cuatro tablas. La diferencia es que sus operaciones no resuelven nada por sí mismas. Cuando el VFS invoca, digamos, el read_folio de un inodo FUSE, el módulo empaqueta la petición en un mensaje con una cabecera fija, le asigna un identificador único y lo encola en el dispositivo de carácter /dev/fuse. Al otro lado, un daemon de usuario lee ese mensaje, lo resuelve y escribe la respuesta con el mismo identificador; el módulo la casa con la petición y despierta a la tarea que dormía. El protocolo es una estructura de la ABI del kernel:

/* include/uapi/linux/fuse.h (recortado) */
struct fuse_in_header {
	uint32_t	len;
	uint32_t	opcode;   /* FUSE_LOOKUP, FUSE_GETATTR, FUSE_READ, FUSE_WRITE... */
	uint64_t	unique;   /* casa la respuesta con esta peticion */
	uint64_t	nodeid;   /* el inodo destino, referido por un numero opaco */
	uint32_t	uid;
	uint32_t	gid;
	uint32_t	pid;
	/* ... */
};

struct fuse_out_header {
	uint32_t	len;
	int32_t		error;    /* 0 en exito, o -errno */
	uint64_t	unique;   /* el mismo unique de la peticion */
};

El primer mensaje que cruza siempre es FUSE_INIT, que negocia la versión del protocolo y las capacidades. A partir de ahí, cada open, lookup, read o write del proceso se traduce en su opcode y viaja por el mismo canal.

flowchart TD
APP[Proceso lee un archivo FUSE] --> VFS[Capa VFS]
VFS --> KMOD[Modulo fuse del kernel]
KMOD -->|encola FUSE_READ con unique| DEV[Cola en dev fuse]
DEV --> D[Daemon libfuse en userspace]
D --> LOGIC[Ejecuta el callback read]
LOGIC -->|escribe fuse_out_header| DEV
DEV --> KMOD
KMOD -->|despierta la tarea bloqueada| VFS
VFS --> APP

Un sistema de archivos FUSE mínimo

Nadie escribe ese protocolo a mano: libfuse lo encapsula. Su API de alto nivel te deja pensar en rutas y devolver estructuras stat, ocultando por completo los inodos y los mensajes. Un sistema de archivos que expone un único archivo de solo lectura cabe en una pantalla:

#define FUSE_USE_VERSION 314
#include <fuse.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>

static const char *hello_path = "/hola";
static const char *hello_str  = "hola desde userspace\n";

static int hello_getattr(const char *path, struct stat *st,
			 struct fuse_file_info *fi)
{
	memset(st, 0, sizeof(*st));
	if (strcmp(path, "/") == 0) {
		st->st_mode = S_IFDIR | 0755;
		st->st_nlink = 2;
	} else if (strcmp(path, hello_path) == 0) {
		st->st_mode = S_IFREG | 0444;
		st->st_nlink = 1;
		st->st_size = strlen(hello_str);
	} else {
		return -ENOENT;
	}
	return 0;
}

static int hello_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
			 off_t off, struct fuse_file_info *fi,
			 enum fuse_readdir_flags flags)
{
	if (strcmp(path, "/") != 0)
		return -ENOENT;
	filler(buf, ".",  NULL, 0, 0);
	filler(buf, "..", NULL, 0, 0);
	filler(buf, hello_path + 1, NULL, 0, 0);   /* nombre sin la barra */
	return 0;
}

static int hello_read(const char *path, char *buf, size_t size, off_t off,
		      struct fuse_file_info *fi)
{
	size_t len = strlen(hello_str);

	if (off >= len)
		return 0;
	if (off + size > len)
		size = len - off;
	memcpy(buf, hello_str + off, size);
	return size;
}

static const struct fuse_operations hello_ops = {
	.getattr = hello_getattr,
	.readdir = hello_readdir,
	.read    = hello_read,
};

int main(int argc, char *argv[])
{
	return fuse_main(argc, argv, &hello_ops, NULL);   /* monta y sirve peticiones */
}

fuse_main abre /dev/fuse, monta el sistema y entra en el bucle que lee peticiones y las despacha a tus callbacks. Compilar y montar no requiere ser root:

cc hello.c -o hello $(pkg-config fuse3 --cflags --libs)

mkdir -p /tmp/pt
./hello /tmp/pt            # lanza el daemon y monta en /tmp/pt

cat /tmp/pt/hola          # -> hola desde userspace
ls  /tmp/pt               # -> hola

fusermount3 -u /tmp/pt    # desmonta sin privilegios de root

Cuándo FUSE y cuándo el kernel

La decisión gira en torno a una sola frontera: cada operación FUSE cruza del kernel a userspace y vuelve, con su cambio de contexto y su copia de datos. Ese peaje es la desventaja histórica de FUSE en rendimiento, y la ventaja en todo lo demás.