Bajo nivel · C++

Ring -1: el hipervisor que vigila a tu kernel

En esta página
  1. "Virtualization support not detected"
  2. Qué es un hipervisor
  3. Cómo lo hace el hardware: VT-x y AMD-V
  4. La memoria de la memoria: EPT y NPT
  5. El hipervisor como guardián del kernel
  6. Compruébalo tú mismo con CPUID
  7. ¿Tu CPU soporta virtualización?
  8. ¿Hay un hipervisor debajo de ti?
  9. El cloud es esto
  10. Una regla que se aprende por las malas
  11. Y todavía hay más abajo

"Virtualization support not detected"#

Preparando esta entrada, Docker Desktop se negó a arrancar en mi equipo con un mensaje seco: Virtualization support not detected. Curioso, porque el procesador es un Intel Core i9-14900KF, que soporta virtualización por hardware de sobra, y la BIOS la tiene activada. Windows lo confirma:

salida
PS> Get-CimInstance Win32_Processor |
>>     Format-List Virtualization*, VMMonitor*, SecondLevel*
VirtualizationFirmwareEnabled           : True
VMMonitorModeExtensions                 : True
SecondLevelAddressTranslationExtensions : True

PS> (Get-CimInstance Win32_ComputerSystem).HypervisorPresent
False

La clave está en la última línea. El hardware está listo, pero no hay ningún hipervisor cargado: nadie ocupa el nivel que hay por debajo del kernel. Docker Desktop en Windows funciona normalmente sobre WSL2, y WSL2 es una máquina virtual ligera que necesita que Windows arranque su propio hipervisor. Sin él, no hay contenedores.

En la entrada anterior bajamos de Ring 3 a Ring 0 y dijimos que el kernel es quien manda. Hoy toca matizarlo: por debajo del kernel puede haber alguien más. Informalmente se le llama Ring -1.

Qué es un hipervisor#

Un hipervisor es el software que crea y gestiona máquinas virtuales: reparte la CPU, la memoria y los dispositivos entre varios sistemas operativos y hace creer a cada uno que tiene la máquina para él solo. Se suelen distinguir dos tipos:

Tipo 1 (bare metal)Tipo 2 (alojado)
Dónde se ejecutaDirectamente sobre el hardwareComo una aplicación dentro de otro sistema operativo
EjemplosHyper-V, VMware ESXi, XenVirtualBox, VMware Workstation
Uso típicoServidores, cloud, seguridad del propio sistemaEscritorio, pruebas, desarrollo

La frontera no es tan nítida como parece. KVM, por ejemplo, es un módulo del kernel que convierte al propio Linux en hipervisor. Y cuando activas Hyper-V en Windows ocurre algo que sorprende a mucha gente: tu Windows deja de ejecutarse directamente sobre el hardware y pasa a ser la partición raíz, una máquina virtual con privilegios especiales que corre encima de Hyper-V.

RING 3 aplicaciones del invitado RING 0 kernel del invitado (Windows, Linux...) ▲ VMX non-root VM exit ▼ ▲ VM entry VMX root ▼ RING -1 hipervisor · VMCS/VMCB · tablas EPT/NPT HARDWARE CPU con VT-x o AMD-V · memoria · dispositivos
Fig. 1 — El sistema invitado conserva sus anillos 3 y 0, pero todo él vive en VMX non-root. El hipervisor está por debajo.

Cómo lo hace el hardware: VT-x y AMD-V#

Virtualizar x86 solo por software era lento y complicado, porque el sistema invitado espera ejecutarse en Ring 0 y tocar a su antojo registros de control, tablas de páginas e interrupciones. Desde 2005–2006, Intel (VT-x) y AMD (AMD-V, también llamado SVM) lo resuelven en hardware con un modo de ejecución nuevo, independiente de los anillos:

  • VMX root: donde vive el hipervisor. Es lo que llamamos Ring -1, aunque técnicamente no es un anillo nuevo, sino un modo de la CPU.
  • VMX non-root: donde vive el sistema invitado, con sus Ring 0 y Ring 3 intactos. El kernel invitado sigue en Ring 0, pero bajo supervisión.

El hipervisor describe cada máquina virtual en una estructura de memoria (la VMCS en Intel, la VMCB en AMD) con el estado de los registros del invitado y, sobre todo, qué operaciones del invitado quiere interceptar. Cuando el invitado hace una de ellas —acceder a ciertos registros de la CPU, a un puerto de E/S o a memoria que no le corresponde—, la CPU lo detiene y salta al hipervisor. Eso es un VM exit. El hipervisor decide qué hacer y le devuelve el control con un VM entry.

El coste de un VM exit

Cada VM exit guarda el estado del invitado, carga el del hipervisor y hace después el camino de vuelta. Según la CPU y el trabajo que tenga que hacer el hipervisor, eso cuesta del orden de cientos a unos pocos miles de ciclos, frente a los pocos ciclos de una instrucción normal. Algunas instrucciones, como CPUID en Intel VT-x, provocan siempre un VM exit. Por eso buena parte del trabajo de un hipervisor moderno consiste en evitar salidas: cuanto menos interviene, más rápido va el invitado.

La memoria de la memoria: EPT y NPT#

En la entrada anterior vimos que cada proceso usa direcciones virtuales que el kernel traduce a físicas con sus tablas de páginas. En una máquina virtual eso ya no basta: la "memoria física" que ve el invitado tampoco es real. Hace falta una segunda traducción:

  1. Dirección virtual del invitado → dirección física del invitado. La hace el kernel invitado, con sus propias tablas de páginas, como siempre.
  2. Dirección física del invitado → dirección física real. La hace el hipervisor, con una segunda tabla que el invitado ni ve ni puede tocar.

Intel llama a esa segunda tabla EPT (Extended Page Tables) y AMD, NPT (Nested Page Tables); el nombre genérico es SLAT. Antes de que existiera, hacia 2007–2008, los hipervisores mantenían por software unas "tablas sombra" que había que resincronizar cada vez que el invitado cambiaba las suyas, y eso era carísimo. Con SLAT, el hardware recorre las dos tablas por sí solo. No es gratis: en el peor caso, un fallo de TLB con paginación de cuatro niveles puede requerir hasta 24 accesos a memoria en lugar de 4. Por eso las cachés de traducción importan tanto en virtualización.

Lo interesante para la seguridad es que cada entrada de EPT tiene sus propios permisos de lectura, escritura y ejecución, independientes de los que ponga el invitado. El hipervisor puede decidir que una página no se puede modificar, aunque el kernel invitado, desde su Ring 0, diga lo contrario.

El hipervisor como guardián del kernel#

Esa última idea es la base de la Seguridad basada en virtualización (VBS) de Windows. Con VBS activado, Hyper-V divide el sistema en dos niveles de confianza virtuales: el Windows de siempre, con su kernel, en el nivel 0 (VTL0), y un pequeño kernel seguro en el nivel 1 (VTL1), aislado por el hipervisor. Sobre esa base funcionan dos de las defensas más importantes del Windows actual:

  • HVCI (Integridad de memoria): la verificación de firmas del código del kernel se hace en VTL1, y el hipervisor usa SLAT para que ninguna página del kernel sea a la vez escribible y ejecutable. Aunque un atacante consiga ejecutar código en Ring 0, no puede inyectar código nuevo en el kernel: la página no se deja.
  • Credential Guard: los secretos de autenticación se guardan en un proceso aislado en VTL1, fuera del alcance incluso del propio kernel de Windows.

Es la respuesta directa a la idea con la que cerramos la entrada anterior: si Ring 0 no perdona, pon a alguien por debajo que vigile a Ring 0. En muchos equipos nuevos con Windows 11, VBS e HVCI vienen activados de serie.

Compruébalo tú mismo con CPUID#

CPUID es la instrucción con la que cualquier programa pregunta a la CPU qué es y qué sabe hacer. No requiere privilegios, así que podemos usarla desde Ring 3. Primero, una pequeña cabecera portable para GCC, Clang y MSVC:

cpuid.hpp
// lectura portable de CPUID (GCC/Clang y MSVC)
#pragma once
#include <cstdint>
#include <cstring>
#include <string>
#if defined(_MSC_VER)
#include <intrin.h>
#else
#include <cpuid.h>
#endif

struct CpuidRegs { std::uint32_t eax, ebx, ecx, edx; };

inline CpuidRegs cpuid(std::uint32_t leaf) {
    CpuidRegs r{};
#if defined(_MSC_VER)
    int out[4];
    __cpuid(out, static_cast<int>(leaf));
    std::memcpy(&r, out, sizeof out);
#else
    __cpuid(leaf, r.eax, r.ebx, r.ecx, r.edx);
#endif
    return r;
}

// Une tres registros en el texto ASCII de 12 bytes que codifican.
inline std::string cpuid_text(std::uint32_t a, std::uint32_t b,
                              std::uint32_t c) {
    char s[12];
    std::memcpy(s, &a, 4);
    std::memcpy(s + 4, &b, 4);
    std::memcpy(s + 8, &c, 4);
    std::string t(s, sizeof s);
    t.erase(t.find_last_not_of('\0') + 1);   // quita el relleno final
    return t;
}

¿Tu CPU soporta virtualización?#

virt.cpp
// g++ -std=c++20 virt.cpp -o virt
#include "cpuid.hpp"
#include <format>
#include <iostream>

int main() {
    const CpuidRegs v = cpuid(0);                         // fabricante
    const bool vmx = cpuid(1).ecx & (1u << 5);            // Intel VT-x
    const bool svm = cpuid(0x8000'0001).ecx & (1u << 2);  // AMD-V
    const std::string vendor = cpuid_text(v.ebx, v.edx, v.ecx);
    auto yes = [](bool b) { return b ? "soportado" : "no soportado"; };

    std::cout << std::format("CPU:         {}\n", vendor)
              << std::format("VT-x (VMX):  {}\n", yes(vmx))
              << std::format("AMD-V (SVM): {}\n", yes(svm));
}

Estas son las salidas reales en mi equipo y dentro de un runner de GitHub Actions, que es una máquina virtual en Azure:

salida
# Intel Core i9-14900KF (hardware físico)
CPU:         GenuineIntel
VT-x (VMX):  soportado
AMD-V (SVM): no soportado

# Runner de GitHub Actions (VM en Azure, AMD EPYC 7763)
CPU:         AuthenticAMD
VT-x (VMX):  no soportado
AMD-V (SVM): soportado

Hay dos matices importantes. El primero: que la CPU soporte la virtualización no significa que esté activada. Eso lo decide la BIOS en un registro especial de la CPU (un MSR) que solo se puede leer desde Ring 0; por eso Windows lo consulta desde el kernel y te lo enseña en el Administrador de tareas, en Rendimiento → CPU → Virtualización. El segundo: dentro de una máquina virtual, CPUID responde lo que el hipervisor decida exponer. Que el runner de Azure muestre AMD-V significa que ese hipervisor permite virtualización anidada: crear máquinas virtuales dentro de la máquina virtual.

¿Hay un hipervisor debajo de ti?#

hv.cpp
// g++ -std=c++20 hv.cpp -o hv
#include "cpuid.hpp"
#include <format>
#include <iostream>

int main() {
    // Hoja 1, ECX bit 31: reservado para que el hipervisor se anuncie.
    if (!(cpuid(1).ecx & (1u << 31))) {
        std::cout << "Sin hipervisor anunciado: corre sobre el hardware.\n";
        return 0;
    }
    // Hoja 0x40000000: firma de 12 caracteres del hipervisor.
    const CpuidRegs h = cpuid(0x4000'0000);
    std::cout << std::format("Hipervisor: \"{}\"\n",
                             cpuid_text(h.ebx, h.ecx, h.edx));
}
salida
# Intel Core i9-14900KF (hardware físico)
Sin hipervisor anunciado: corre sobre el hardware.

# Runner de GitHub Actions (VM en Azure)
Hipervisor: "Microsoft Hv"

"Microsoft Hv" es la firma de Hyper-V: Azure funciona sobre una versión adaptada de Hyper-V. En un Linux con KVM verías KVMKVMKVM, y en VMware, VMwareVMware. Y si lo ejecutas en tu propio Windows con VBS activado, también verás "Microsoft Hv": tu sistema "real" es la partición raíz de Hyper-V.

Fíjate en que el programa comprueba primero el bit 31: sin hipervisor, la hoja 0x40000000 no está definida y lo que devuelve no significa nada. Ese bit es, además, una declaración voluntaria. Los hipervisores lo activan para que el sistema invitado sepa que está virtualizado y use mecanismos pensados para ello (lo que se conoce como paravirtualización), como relojes y dispositivos que no necesitan simular hardware antiguo.

El cloud es esto#

Cuando alquilas una máquina en la nube, tu sistema operativo entero vive en VMX non-root. Azure funciona sobre Hyper-V, como acabamos de ver; AWS usa Nitro, un hipervisor basado en KVM, y Google Cloud también usa KVM. Tu "servidor" es en realidad un invitado, y el Ring -1 de otro es quien garantiza que tu máquina y la del cliente de al lado no puedan verse.

Una regla que se aprende por las malas#

Nota personal

Hace un tiempo escribí un hipervisor académico sobre Intel VT-x como driver de kernel de Windows: activa VMX en cada núcleo, virtualiza el propio sistema que ya está en marcha y le pone debajo una tabla EPT que, de momento, traduce cada dirección a sí misma. Es el enfoque de proyectos de investigación como HyperPlatform y, en el fondo, el mismo que usa VBS, solo que Windows lo hace desde el arranque. La lección que más me costó asumir está en mi propia guía de laboratorio, en un recuadro de advertencia: en VMX root solo cabe un hipervisor. Si Hyper-V, WSL2 o VBS ya están activos, el tuyo no puede entrar; y si apagas el de Windows para hacerle sitio (bcdedit /set hypervisorlaunchtype off), te quedas sin WSL2 y sin Docker. No es un fallo, es una decisión que hay que tomar. Por eso las pruebas se hacían dentro de una máquina virtual con virtualización anidada.

Si Docker o WSL2 dicen que no hay virtualización
  1. Comprueba en el Administrador de tareas (Rendimiento → CPU) que la virtualización aparece como habilitada. Si no, actívala en la BIOS/UEFI.
  2. Activa la Plataforma de máquina virtual de Windows, por ejemplo con wsl --install desde una terminal de administrador, y reinicia.
  3. Si alguna vez desactivaste el hipervisor de Windows, vuelve a activarlo con bcdedit /set hypervisorlaunchtype auto y reinicia.

Y todavía hay más abajo#

Ring -1 tampoco es el fondo. Por debajo del hipervisor está el System Management Mode (SMM), a veces llamado Ring -2: un modo de la CPU reservado al firmware, que se activa con interrupciones especiales y ejecuta código en una zona de memoria que ni siquiera el hipervisor puede ver. Y fuera de la CPU principal viven microcontroladores como Intel ME o AMD PSP, a los que algunos llaman Ring -3. Pero eso ya es otra historia.

La próxima vez que Docker te diga que no encuentra virtualización, ya sabes lo que significa: el hardware está ahí, pero nadie ocupa el Ring -1.

Referencias

  1. Intel® 64 and IA-32 Architectures Software Developer's ManualsIntel · intel.com
  2. Hypervisor Top Level Functional Specification: Feature and Interface DiscoveryMicrosoft · learn.microsoft.com
  3. Hypervisor Top Level Functional Specification: Virtual Secure ModeMicrosoft · learn.microsoft.com
  4. KVM CPUID bitsLinux kernel documentation · docs.kernel.org

Compartir

Sigue leyendo

Bajo nivel

Anatomía de un driver de Windows: del DriverEntry al IRP

Qué pasa dentro de un driver de Windows: DriverEntry, IRQL, el viaje de un IRP, la tabla de dispatch, los IOCTL y por qué un spinlock mal usado tumba el sistema. Con código real.

· 12 min

Bajo nivel · Parte 3

Ring -2: SMI, SMRAM y RSM, cómo el firmware toma la CPU por debajo del hipervisor

Qué hay por debajo del hipervisor: System Management Mode, el código del firmware que se ejecuta a escondidas del sistema, y cómo comprobar desde C++ qué protecciones declara tu firmware.

· 12 min

¿Tu proyecto necesita ir por debajo de la capa de aplicación?

Software de sistemas, rendimiento y seguridad en Windows y Linux: diagnóstico, herramientas a medida y revisión de código de bajo nivel.

Hablemos→

Comentarios

Para comentar necesitas una cuenta de GitHub. Los comentarios se guardan en GitHub Discussions (SoftDryzz/blog-comments) y se moderan: no se publican enlaces promocionales.