Binarios de Linux, sin recompilar.
Otro kernel debajo.

Rinux es un kernel nuevo, escrito en Rust y pensado para servidores, que ejecuta binarios de Linux ya compilados, tal cual, dentro de dominios: cada uno con su memoria, su CPU, su raíz y sus fallos. Cuando algo cae dentro de un dominio, el resto de la máquina no se entera.

rinux-1 Google Cloud n2-standard-2kernel en pie 0 s


          
fallos contenidos 0

Pulsa un dominio para provocarle un fallo: el kernel lo reinicia con la generación siguiente y los demás siguen. La sesión es real, copiada del puerto serial de la VM y de SSH.

Este mismo nodo Rinux sirve también hullcondorstilapollo11bakeroxidestore x3
PostgreSQL 17, GCE200/ 200

transacciones confirmadas que siguen ahí después de cortar la energía con carga en curso

arranque, GCE129ms

desde que entra el kernel hasta que está listo para trabajar

Linux 6.12, x86_64252/ 375

llamadas al sistema implementadas, cada una con su estado escrito

Rinux es el sistema operativo, no algo que corre encima de uno. Arranca directo en el servidor o en la VM de la nube, en lugar de Linux.

Debian 13, desde una imagen OCI verificada capa por capa con SHA-256, arranca con systemd en un dominio de Rinux. Por SSH, apt instala paquetes y curl habla HTTPS. Todo lo que hacen por debajo lo resuelve Rinux.

Más fuerte que un contenedor, más liviano que una máquina virtual.

Un dominio no es un truco de espacios de nombres sobre un kernel compartido. Es un objeto del propio kernel, que posee sus recursos y responde por sus fallos.

docker dockerd Linux compartido rinux kernel Rinux un fallo del kernelalcanza a todos cada dominio poseesus recursos y fallos

No es Docker

Docker necesita un Linux debajo y sus contenedores comparten ese kernel. Aquí no hay Linux: Rinux toma imágenes de Docker tal cual y corre cada una en un dominio aislado por el propio kernel.

VMs linuxlinuxlinux hipervisor rinux kernel Rinux un kernel invitadopor cada carga un kernel aíslaa todos los dominios

No es una máquina virtual

No hay un Linux invitado por cada carga. Un solo kernel aísla a todos los dominios, y arranca en 129 ms.

apt, sshd, postgres openat() personalidad Linux 6.12 vfs, rfs, red de Rinux el programa no sabe la diferencia

Sí es compatible con Linux

Debian, systemd, apt y sshd no saben que no están sobre Linux, porque Rinux habla su mismo idioma de llamadas al sistema.

Esta página la sirve Rinux.

Un nodo en producción, sin Linux en ninguna capa

Esta página y otros sitios propios corren en un nodo Rinux en Google Cloud. En la misma máquina corren el plano de control de Mentat, que decide qué carga va dónde, y Cóndor, el proxy que termina TLS y obtiene los certificados de Let's Encrypt. Cada sitio vive en su propio dominio.

15a 21 ssin servicio al reiniciar la VM entera
463mspara traer esta página desde Santiago, TLS completo
13cargas y el plano de control en 2 CPUs y 8 GiB

Reset duro de la VM desde Google Cloud, con un sondeo cada medio segundo a cada dominio: seis volvieron a los 15 s y el más pesado, de 60 MB, a los 21 s. Los 463 ms son la mediana de 20 conexiones nuevas, con 148 ms de ida y vuelta hasta la nube.

Cargador con dos ranuras

Un kernel nuevo arranca una vez a prueba y, si el nodo no lo confirma, el cargador vuelve al anterior. Solo acepta imágenes firmadas.

Red cerrada por defecto

Cada dominio abre solo los puertos y la salida que se le conceden. Una carga con salida a internet no alcanza el servidor de metadatos.

Salida por lista, aviso y cuarentena

Una carga sale solo a los destinos que se le nombran; el kernel filtra también sus consultas DNS. Cada intento hacia otro lado se niega y llega como aviso al teléfono en segundos. En producción, una carga de prueba insistió seis veces en un minuto: quedó sin salida y siguió atendiendo. Ninguna carga del nodo tiene salida abierta a internet.

Lo que encontró el tráfico real

Tres fallas, cada una con su prueba: un segmento TCP retenido, un lock que hacía girar un hilo y un plano de control lento al reponer cargas.

Probamos encerrar a un atacante.

Desplegamos nosotros una carga de prueba en el nodo de producción y la pusimos a actuar como un atacante que ya hubiera tomado una aplicación. Nadie entró de afuera: la carga es nuestra, y el punto era ver qué puede hacer desde su dominio. Intentó salir a internet, llegar al servidor de metadatos —donde están las llaves del nodo—, saltar a las otras cargas y hasta verlas. No pudo nada de eso.

0destinos alcanzados fuera del único que se le permitió
0otras cargas vistas, alcanzadas o sus llaves leídas
segen negar, avisar al teléfono y cortarle la salida sola

La carga solo tenía permiso de salir a un destino. Intentó internet por IP y por nombre, el servidor de metadatos, la puerta de enlace, los puertos de las otras cargas y del plano de control, y leer sus datos: el kernel lo negó todo y contó cada intento; al sexto en un minuto, Mentat le quitó la salida mientras seguía atendiendo. Lo que probamos es que una carga ya tomada no se puede mover ni sacar nada. Cómo se toma una aplicación en primer lugar depende de cada aplicación, no del kernel: eso es otra prueba, no esta.

Un almacén de 7,8 GB, mudado a este nodo.

OxideStore, nuestro almacén compatible con S3, corre aquí como tres dominios con Raft entre ellos. Le copiamos 1.147 objetos desde tres máquinas virtuales con Linux. La copia encontró lo que las pruebas no habían encontrado: límites del kernel que solo aparecen con datos de verdad, cada uno arreglado y con su prueba.

28min

para copiar los 7,8 GB con cuatro subidas en paralelo, con los mismos objetos y tamaños en los tres nodos

15,9a 4,6 s

para escribir, releer y juntar 100 MiB en un disco de red, antes y después del arreglo

789a 1.856 MiB

el límite de memoria de un nodo del almacén, subido y devuelto por Mentat sin reiniciarlo

El disco, de a tramos

El sistema de archivos pedía al disco 4 KiB por petición, y en un disco de red cada petición cuesta medio milisegundo. Ahora lee en una sola petición los bloques vecinos de un archivo. Cerrar una subida de 92 MiB pasó de 13 s a 3 s.

Memoria que se cobra al usarla

Reservar memoria ya no cuesta: cada página se cobra al dominio cuando se toca, y lo que un programa devuelve deja de contar. En reposo, cada nodo del almacén figura con 43 MB en vez de 92.

Memoria elástica

El kernel deja cambiar el límite de un dominio en marcha y cuenta cada vez que le niega memoria. Mentat lo mira cada 5 segundos: sube el límite de la carga que se acerca a él y lo devuelve cuando baja el uso.

Un dominio detenido no retiene memoria

Al detenerse suelta todo: su sistema de archivos en memoria y, desde este kernel, también la memoria compartida y los semáforos System V que nadie borró. Después del fuzzer, uno sin procesos seguía cobrando 55 MiB; ahora todos los dominios detenidos juntos suman menos de medio MiB.

Una tabla que solo crecía

Los procesos terminados quedaban anotados hasta que alguien listaba su dominio, y esa limpieza detenía al resto del nodo. Ahora cada proceso sale de la tabla al terminar: tras 2.000 que nacen y mueren quedan 2 entradas, no 2.002.

Antes de producción, la máquina real

Cada arreglo pasó por las 40 pruebas en aarch64 y por un nodo Rinux x86_64 en Google Cloud antes de llegar aquí; los del disco, medidos con discos iguales a los de este nodo.

PostgreSQL, con cortes de energía de verdad.

Una base de datos es la prueba más dura para un kernel: cada transacción confirmada espera un fsync, y ese dato tiene que estar ahí después de cualquier apagón. PostgreSQL 17 de Debian corre sin modificar en un dominio de Rinux, y le cortamos la energía en plena carga.

200/ 200

transacciones confirmadas que sobreviven al corte con carga en curso

368

transacciones por segundo con 50 clientes en Google Cloud, sin una sola fallida

7,5ms

por transacción con un cliente: casi todo es el fsync del disco

El corte en la prueba

Con pgbench escribiendo, se confirman 200 transacciones marcadas y se apaga la VM sin aviso. Al volver, las 200 marcas están, los saldos cuadran y pg_amcheck no encuentra corrupción. En x86_64 y aarch64.

Colgado a propósito

Se congela el proceso principal: el puerto sigue abierto pero nadie responde. La prueba de vida del kernel lo detecta y reinicia el dominio; vuelve con las 200 marcas en menos de un minuto.

El corte en la nube

Reset duro de la VM desde la consola de Google Cloud: 200 de 200 marcas, saldos cuadrados sobre casi 80.000 transacciones y pg_amcheck limpio.

Lo que pidió PostgreSQL

Siete fallas del kernel, cada una con su prueba: memoria compartida System V, E/S vectorial, montajes apilados, red local por dominio y una lectura del disco que fallaba bajo carga.

Medido en la nube

n2-standard-2 con disco pd-balanced, pgbench escala 10: 133 tps con 1 cliente, unas 314 con 8 y 368 con 50.

Oracle Database, sin cambiarle nada.

Oracle es de lo más exigente que se le puede pedir a un kernel que no es Linux: un ejecutable de 434 MB, decenas de procesos que comparten memoria, hilos que se avisan con señales y un listener que revisa la red del nodo antes de aceptar a nadie. Oracle Free 26ai corre en un dominio de Rinux desde su imagen de contenedor, con su propio usuario, y abre la base.

1.000/ 1.000

filas escritas y leídas de vuelta por el listener, por TCP

191s

desde que arranca el dominio hasta la base abierta, usada y cerrada en orden

5,5GiB

de memoria en el momento de mayor uso, con un límite de 6,5

Qué hace la prueba

Arranca la máquina, espera a que Oracle abra la base, crea una tabla, inserta 1.000 filas a través del listener y las lee. Si el arranque falla, deja en la consola el registro de alertas de Oracle. Hoy corre en aarch64.

Un ejecutable que no se copia

Cada proceso tenía su copia privada del programa, y uno de más de 256 MiB no arrancaba. Ahora sus páginas se toman de la caché del sistema de archivos y solo se copian las que el proceso escribe, como hace Linux.

El hilo que no nacía

Cada hilo nuevo de Oracle lee su propia entrada en /proc. Rinux respondía por procesos, no por hilos: el hilo se rendía y Oracle informaba que no podía crearlo. Fue la falla más difícil de ver.

Lo demás que pidió

El usuario de la imagen para el primer proceso, /dev/shm donde cualquiera puede escribir, señales que llevan un valor, las direcciones del nodo por netlink y por ioctl, y enviar varios mensajes en una sola llamada.

Dónde está hoy

En la prueba, no en producción. De los 5,5 GiB, 2,9 son las capas de la imagen, que todavía se guardan en memoria: llevarlas a disco es lo que sigue.

El kernel se revisa a sí mismo.

Al terminar cada prueba, el kernel comprueba sus propias cuentas. Si una no cierra, la prueba falla aunque el programa de adentro haya terminado bien. Así cada carga real que corre sobre Rinux prueba también al kernel.

43

pruebas de arranque en aarch64 que terminan con el veredicto del kernel limpio

55MiB

que un dominio detenido seguía cobrando: lo primero que encontró

100/ 100

corridas idénticas de un clúster de tres nodos en el kernel determinista

Qué revisa

Recorre cada volumen entero y lo compara con su mapa de bloques: ninguno perdido, ninguno usado dos veces, cada nombre con su archivo. Que lo cobrado a los dominios no supere la memoria del nodo. Que cada proceso esté en el dominio al que pertenece.

Lo primero que encontró

Después del fuzzer, un dominio sin procesos conservaba la memoria compartida System V que nadie había borrado. Ahora la devuelve al terminar. El arreglo ya corre en el nodo que sirve esta página.

La hora que se colaba

En el kernel determinista, la misma semilla tiene que dar la misma ejecución. Un clúster con systemd daba una traza antes de la hora en punto y otra después: el primer proceso de cada dominio leía el reloj de la máquina sin pasar por el kernel.

Cien veces lo mismo

Con eso cerrado, 100 corridas con una semilla dieron la misma traza de 844.211 eventos. La mitad se hizo con el reloj de la máquina en fechas entre 2024 y 2032. Desde entonces cada prueba determinista se repite con otro reloj.

También en x86_64 real

Antes de producción, siete pruebas y el fuzzer determinista corrieron en un nodo Rinux de Google Cloud: todas con el veredicto limpio, y dos arranques del mismo disco con la misma traza.

Hecho para que nadie tenga que ir a arreglarlo.

Rinux apunta a nodos a los que no se puede ir: la red parte cerrada y todo pasa por el plano de control. Un nodo así tiene que volver solo de lo que lo deje sin servicio.

129ms

desde que entra el kernel hasta que está listo para trabajar

40s

hasta SSH en Debian, con PostgreSQL y el disco cifrado

18s

de una falla a SSH otra vez: el dominio de Debian se reinicia entero, solo

Disco que sobrevive al apagón

Copy-on-write y registro de intención: un corte deja el último estado confirmado, nunca una mezcla.

Cifrado por dominio

Cada volumen con su propia llave, sellada en el TPM. Borrar un dominio destruye su llave.

Actualizaciones con vuelta atrás

Si el kernel nuevo no arranca bien dos veces, o se cae tres veces en 10 minutos, el cargador vuelve solo al anterior.

Detector de bloqueo

Una CPU 20 segundos atrapada en el kernel se detecta, deja el motivo en el log y reinicia el nodo.

Prueba de vida por dominio

Cada 10 segundos el kernel verifica que el servicio acepte conexiones. Uno colgado se reinicia; uno detenido a propósito, no.

Watchdog en dos niveles

El de hardware reinicia la VM si el kernel se congela; cada dominio tiene su propio /dev/watchdog para systemd.

Un canal de control aparte

Un segundo SSH en un dominio independiente responde cuando Debian no. fail2ban bloquea en el propio kernel.

Escaneos que no cierran la puerta

Miles de conexiones a medias no dejan sin SSH al nodo: vencen, y la más vieja cede su lugar.

Memoria con límite claro

Cada dominio paga la memoria que usa, no la que reserva. Si se pasa de su límite muere solo el proceso que tocó la página de más; el resto del nodo no se entera.

Cada afirmación tiene una prueba que arranca la máquina.

Nada cuenta como hecho hasta que una prueba arranca Rinux en QEMU, en x86_64 y en aarch64, corre programas Linux reales dentro de un dominio y verifica el resultado desde adentro.

252/ 375

llamadas al sistema de Linux 6.12 en x86_64, cada una con su estado escrito

220/ 318

en aarch64, con la tabla de números propia de esa arquitectura

42

pruebas de arranque completo, en las dos arquitecturas

Las pruebas, en el orden en que se fueron sumando
PruebaQué verificaChecksx86_64aarch64
bootUEFI, sobre firmado, rinuxd en modo usuario, apagado1pasapasa
mmframes, heap, paginación, fallos, scheduler, timer8pasapasa
elf-static64 procesos estáticos en 4 CPUs1pasapasa
domainsaislamiento de fallos, capabilities, límites de memoria y CPU8pasapasa
vfstmpfs, devfs, procfs, syscalls de archivos10pasapasa
procfork, execve, wait4, pipes, posix_spawn, /proc/self/exe17pasapasa
signalsmanejadores, máscaras, marcos de señal de Linux11pasapasa
ttyterminales, pseudoterminales, control de trabajos11pasapasa
dynamicBusyBox dinámico de Alpine como init15pasapasa
alpineimagen OCI desde un disco virtio, digest alterado rechazado21pasapasa
threadspthread, futex, copy-on-write, páginas perezosas, TLB, mremap, stack que crece15pasapasa
ipcmmap compartido, FIFOs, permisos, memoria compartida y semáforos System V, E/S vectorial, AIO nativo18pasapasa
eventsepoll, eventfd, timerfd, signalfd, temporizadores POSIX15pasapasa
socketsAF_UNIX, paso de descriptores, credenciales, netlink12pasapasa
systemmontajes apilados, opciones de tmpfs, sysfs, cgroup2, inotify15pasapasa
systemdDebian 13 con systemd como init, journal, login, nombre del nodo, SSH solo con llave, memoria según el nodo, hora de inicio de los procesos, watchdog, avisos de licencia15pasapasa
netvirtio-net, DHCP, ARP, ICMP, TCP3pasapasa
inetsockets TCP y UDP, red cerrada por defecto, DNS, netlink, entrantes, red local propia de cada dominio, salida solo a metadatos17pasapasa
gceimagen de Google Cloud: PCI sin MCFG, virtio legacy, login, SSH y actualización real4pasano aplica
blkwescritura en disco por virtio-blk, virtio-scsi y NVMe, verificada desde el host3pasapasa
rfssistema de archivos propio en disco, revisado desde el host al apagar9pasapasa
crypt-persistvolúmenes cifrados que sobreviven reinicios y se destruyen con su llave13pasapasa
tpmllaves selladas en el TPM, en tres arranques11pasapasa
loadercargador propio con ranuras A/B1pasapasa
updateactualización en caliente, firma, kernel que no arranca y vuelta atrás sola18pasapasa
load128 procesos escribiendo a la vez en un volumen cifrado2pasapasa
persistDebian instalado en disco: lo cambiado sobrevive al reinicio27pasapasa
pgPostgreSQL 17 con corte de energía en plena carga, y colgado a propósito15pasapasa
lockupuna CPU atrapada se detecta y el nodo se reinicia solo2pasapasa
unstableun kernel que se cae tres veces vuelve solo al anterior13pasapasa
healthun servicio colgado se reinicia; uno sano o detenido no; watchdog de cada dominio6pasapasa
watchdogel kernel entero congelado: el watchdog de hardware reinicia la máquina1pasapasa
synun escaneo de conexiones a medias no deja el puerto sin atender1pasapasa
keysllaves SSH desde el servidor de metadatos, usuarios, cambios en caliente12pasapasa
hvimagen para Proxmox y KVM: sin TPM lo explica; con TPM instala cifrado y vuelve a arrancar3pasapasa
sysfuzz144.000 llamadas al sistema con número y argumentos al azar desde una semilla: el kernel no entra en pánico ni se bloquea, y sigue atendiendo4pasapasa
sysfuzz-detel mismo fuzzer en el kernel determinista: la misma semilla da la misma traza del kernel, llamada por llamada2pasapasa
oracleOracle Free 26ai desde su imagen de contenedor: abre la base, y 1.000 filas escritas y leídas por el listener1sin probarpasa
cluster-dettres nodos con systemd y un generador de carga en el kernel determinista: la misma semilla da la misma traza, con el reloj de la máquina en otra fecha2sin probarpasa

Todo el código inseguro vive en un solo lugar.

Rust no impide tocar el hardware; lo obliga a declararlo. En Rinux, todo lo que necesita unsafe (tablas de páginas, registros de dispositivos, DMA, cambio de contexto) está en un único crate con sus invariantes escritas. El resto del kernel tiene prohibido usarlo.

Dominios

Programas Linux sin modificar, con musl o glibc, y rinuxd, el controlador del nodo. Corren en modo usuario.

ring 3 en x86_64, EL0 en aarch64

rinux-kernel

Memoria virtual, scheduler multiprocesador, dominios y capabilities, sistema de archivos, sockets, red TCP/IP, señales y la personalidad Linux que traduce cada syscall.

ring 0 / EL1, sin unsafe

rinux-frame

Paginación, interrupciones, contexto de CPU, MMIO y DMA, expuestos al kernel como tipos seguros.

el único crate con unsafe

Firmware

UEFI arranca una sola imagen, RINUX.EFI. El kernel descubre la máquina por ACPI y verifica la firma Ed25519 del sobre de arranque antes de ejecutar nada.

x86_64 y aarch64 desde la misma fuente

Capabilities con generación

Cuando un dominio se reinicia, su generación avanza y todo permiso viejo deja de servir.

Límites que se cumplen

Cuotas de CPU y memoria. Pasarse es un error del dominio, nunca del nodo.

Perfil de syscalls

Lo que no está permitido se niega con el error que Linux daría y queda en la traza.

Red local propia

Cada dominio tiene su localhost; ninguno alcanza la red local de otro.

Dónde corre.

Rinux arranca como el sistema operativo de la máquina virtual. Todavía no está publicado: el código y las imágenes salen con la primera versión, bajo licencia MPL-2.0.

Google Cloud

Hoy en VMs n2-standard-2, con disco de arranque firmado y actualizaciones con vuelta atrás. C3, C4 y N4 necesitan el driver gVNIC, que viene.

Proxmox, QEMU/KVM, libvirt

Imagen lista: tres discos qcow2 y un TPM virtual, probada en x86_64 y aarch64.

AWS y Azure

En camino. AWS necesita el driver ENA; Azure, los dispositivos de Hyper-V.

Llaves desde la nube

La imagen no trae llaves ni contraseñas: las toma del servidor de metadatos.

La base de nuestro stack.

Cada pieza corre en su propio dominio, con su propia autoridad, en el mismo nodo.

  • Hullorquesta cargas sobre dominios Rinux.
  • Cóndorproxy inverso, con colas de red directas.
  • OxideStorealmacenamiento de objetos y registro de imágenes.
  • Bakerpruebas deterministas de sistemas distribuidos sobre Rinux.
  • Melangerecibe la telemetría de cada nodo y cada dominio.
  • Loaproxy de PostgreSQL delante de bases en dominios.
Mascota de Rinux: un rinoceronte de smoking