Эмуляция процессоров перестала быть экзотикой: одна рабочая станция сегодня собирает пакеты для ARM, тестирует прошивку RISC-V и держит продакшн-нагрузку со скоростью, близкой к нативной. В центре этого мира стоит QEMU, проект, который совмещает две противоположные задачи. Он умеет честно исполнять код чужой архитектуры на любом железе и одновременно разгонять гостевые системы родной архитектуры через аппаратную виртуализацию. Разберём, как устроена динамическая бинарная трансляция, чем KVM-ускорение отличается от полной эмуляции, что дают qemu-user, virtio и живая миграция и какие приёмы пригодятся в ежедневной работе администратора и разработчика.

Полная эмуляция и KVM ускорение в одном инструменте

Для гостевой системы QEMU выглядит как целый компьютер: процессор, память, чипсет, контроллеры дисков, сетевые карты. При этом сам QEMU остаётся обычным процессом пользовательского пространства Linux, BSD, Windows или macOS. Инструмент поддерживает два принципиально разных режима. В режиме полной эмуляции он сам переводит машинные команды гостя в команды хоста, поэтому гостевая система ничего не знает о реальном процессоре и может быть собрана под x86, ARM, AArch64, RISC-V, PowerPC, s390x, MIPS и десятки других целей. Скорость ниже нативной, порой на порядки, зато платформа не имеет значения: ARM-образ запустится и на сервере с AMD EPYC, и на ноутбуке с Apple Silicon.

Второй режим опирается на аппаратную виртуализацию. Модуль KVM в ядре Linux исполняет гостевой код прямо на физическом процессоре в изолированном контексте, а QEMU остаётся моделью устройств и планировщиком виртуальных CPU. Такой симбиоз называют KVM-ускорением и включают одной опцией -enable-kvm; производительность приближается к нативной, накладные расходы заметны в основном на вводе-выводе и частых системных вызовах. Похожие бэкенды есть и в других системах: Hyper-V в Windows, Hypervisor.framework в macOS, Xen в отдельных связках. Практический вывод прост: для сервисов на родной архитектуре берут KVM, для чужой архитектуры, реверс-инжиниринга и отладки низкоуровневого кода остаётся полная эмуляция.

Отдельный слой абстракции добавляет libvirt: он хранит описание машины в XML, управляет сетями, пулами хранения и правами доступа, а QEMU служит исполнительным движком. Тип машины тоже выбирается осознанно, например q35 для современного чипсета с PCI Express, а загрузка всё чаще идёт через UEFI-прошивку OVMF вместо классического BIOS. Эти детали не меняют сути, но определяют, какие диски и устройства вообще доступны гостю.

Первый запуск гостевой машины укладывается в несколько шагов:

  1. создать пустой образ диска утилитой qemu-img;
  2. загрузить установочный ISO через опцию -cdrom и пройти установку системы;
  3. переключить диск и сеть на паравиртуальные устройства virtio;
  4. вынести параметры запуска в скрипт или описание домена libvirt.
qemu-img create -f qcow2 disk.qcow2 40G
qemu-system-x86_64 -enable-kvm -cpu host -smp 4 -m 4096 \
  -drive file=disk.qcow2,if=virtio \
  -netdev user,id=n0,hostfwd=tcp::2222-:22 \
  -device virtio-net-pci,netdev=n0 \
  -cdrom debian-12-amd64-netinst.iso -boot d

Опция hostfwd пробрасывает порт 2222 хоста на SSH гостя, и машина сразу доступна для управления без сетевых настроек внутри.

TCG динамическая бинарная трансляция блоков кода

Сердце полной эмуляции в QEMU это TCG, Tiny Code Generator. Наивный интерпретатор читал бы каждую гостевую команду и выполнял её по одной, расходуя десятки инструкций хоста на одну гостевую. TCG работает иначе. Гостевой код делится на базовые блоки, линейные участки без переходов внутри. Каждый блок один раз компилируется в машинный код хоста и попадает в кэш трансляций; повторные вызовы исполняются уже без перевода, а частые переходы между соседними блоками сцепляются в длинные цепочки, экономящие даже проверку выхода из кэша. Ранние версии проекта опирались на dyngen, хрупкий механизм, собиравший хостовый код из шаблонов вывода компилятора, но позже его сменил самостоятельный генератор TCG.

Внутри транслятор опирается на промежуточное представление: гостевые команды разбираются в микрооперации над виртуальными регистрами TCG, затем бэкенд конкретной архитектуры, от x86_64 до ARM64 и RISC-V, превращает их в хостовый ассемблер. При трансляции отслеживается живость значений, поэтому лишних пересылок почти не остаётся. Память гостя обслуживает мягкий MMU: запись в страницу, по которой лежит транслированный код, сбрасывает соответствующие записи кэша, что делает корректным даже самомодифицирующийся код и JIT-компиляторы внутри гостя.

Для многопроцессорных гостей доступен многопоточный TCG, известный как MTTCG, где каждый виртуальный CPU живёт в собственном потоке хоста. Скорость TCG обычно в разы уступает KVM, но она предсказуема и не зависит от совпадения архитектур, а сам транслятор остаётся одним из самых изящных примеров runtime-компиляции в открытом коде.

Пользовательский режим qemu-user и chroot для чужой архитектуры

Второй режим QEMU обходится без целой машины. qemu-user запускает отдельный бинарник, собранный под чужую архитектуру, транслирует его команды на лету и перенаправляет системные вызовы в родное ядро хоста. Никакой гостевой ОС нет: процесс считает, что живёт в своей системе, а его памятью и файлами ведает Linux хоста. Регистрация через binfmt_misc позволяет ядру прозрачно запускать чужие ELF-файлы, как будто это обычные программы той же архитектуры.

Связка с chroot даёт полноценную кросс-среду: берётся дерево пакетов целевой архитектуры, внутрь кладётся статический qemu-бинарник, и окружение ведёт себя как машина с чужим процессором. Пакетные менеджеры, компиляторы и тесты работают без кросс-компиляции, что экономит недели настройки тулчейнов. Скорость выше, чем у полной системы, ведь трансляция покрывает только пользовательский код, а не весь компьютер. Ограничения тоже стоит знать: qemu-user не является границей безопасности, отдельные системные вызовы и функции вроде ptrace поддерживаются с оговорками, а отладка достигается опцией -g, поднимающей GDB-порт для удалённого подключения.

Практические мелочи ускоряют работу: статические сборки qemu-riscv64 и qemu-ppc64le идут в комплекте с большинством дистрибутивов, отладчик gdb-multiarch понимает архитектуры гостя, а переменная QEMU_STRACE печатает трассировку системных вызовов вместо strace, который внутри чужого бинарника бесполезен.

sudo debootstrap --arch=arm64 bookworm /srv/arm64-root \
  http://deb.debian.org/debian
sudo cp /usr/bin/qemu-aarch64-static /srv/arm64-root/usr/bin/
sudo chroot /srv/arm64-root
# uname -m inside chroot prints aarch64
qemu-aarch64 -L /usr/aarch64-linux-gnu ./hello

qemu-img и работа с образами дисков виртуальных машин

Образ диска это хранилище содержимого гостя, и для него у QEMU есть отдельный инструмент. Главный формат qcow2 хранит блоки по мере записи, поддерживает снапшоты, сжатие, шифрование и слои: новый образ наследует базовый и дописывает только отличия, что удобно для шаблонов, тестовых стендов и массового развертывания одинаковых машин. Формат raw проще и быстрее на запись, зато не умеет ни внутренних снапшотов, ни экономии места без внешних средств.

qemu-img create создаёт образ, info показывает размер, формат и цепочку слоёв, convert переливает содержимое между форматами и заодно сжимает разросшийся qcow2, resize расширяет или сужает диск, measure заранее оценивает, сколько места займёт конвертация. Внутренние снапшоты снимаются подкомандой snapshot, внешние создаются на основе файла-родителя. Золотое правило: не запускать qemu-img над образом работающей машины, иначе файл легко привести в негодность.

Инструмент дружит и с чужими форматами: vmdk от VMware, vdi от VirtualBox, vhd из мира Windows читаются и конвертируются без промежуточных уловок, что упрощает переезд между гипервизорами. Для тонкой работы образ подключается к ядру через qemu-nbd: диск появляется как обычное блочное устройство, его можно монтировать, править конфигурацию гостя или вытаскивать файлы без запуска самой машины.

qemu-img create -f qcow2 -b base.qcow2 -F qcow2 clone.qcow2
qemu-img snapshot -c before-update disk.qcow2
qemu-img convert -O qcow2 -c disk.qcow2 disk-compact.qcow2
qemu-img resize disk.qcow2 80G

virtio паравиртуальные устройства вместо эмулируемого железа

Когда QEMU эмулирует, скажем, контроллер IDE или сетевую карту e1000, каждая операция гостя превращается в перехват и воспроизведение протокола настоящего устройства. Это универсально, но медленно. Решение называется virtio: семейство паравиртуальных устройств, для которых гость заранее знает, что общается с гипервизором, и разговаривает с ним напрямую через кольцевые буферы virtqueues. virtio-blk и virtio-scsi обслуживают диски, virtio-net сеть, virtio-gpu графику, virtio-fs общие каталоги, virtio-balloon отдаёт гипервизору ненужную гостю память, а virtio-rng подмешивает ему честные случайные числа.

Дальше обработка выносится из самого QEMU: vhost-net передаёт сетевые пакеты отдельному потоку ядра, vhost-user подключает фреймворки вроде DPDK и SPDK, vDPA позволяет сбросить трафик прямо на поддерживающее virtio оборудование. В командной строке такие устройства задаются опциями вида -device virtio-net-pci, на стороне гостя нужны драйверы, давно встроенные в Linux, BSD и большинство современных систем. Разница ощутима на практике: замена эмулируемой сетевой карты на virtio заметно поднимает пропускную способность той же машины.

Выбор дискового варианта тоже не случаен: virtio-blk быстрее и проще, virtio-scsi даёт очередь команд, трим и десятки LUN на контроллер. Отдельная опция discard=unmap позволяет гостю честно освобождать место в тонком образе, иначе удалённые файлы внутри машины не уменьшают файл на хосте.

Живая миграция машин между хостами без остановки сервисов

Одна из самых востребованных возможностей связки QEMU и KVM это живая миграция: работающая машина переезжает с одного физического хоста на другой без выключения. Механика выглядит так. Пока гость продолжает работать, страницы его памяти передаются на приёмник; гипервизор помечает изменённые страницы, и они досылаются повторными проходами, пока остаток не станет мал. Затем на короткую долю секунды гость приостанавливается, передаётся финальный фрагмент состояния и машина запускается уже на новом хосте. Для внешнего наблюдателя сервис лишь чуть дрогнул.

Существует и посткопия: после первого прохода гость стартует на приёмнике сразу, а недостающие страницы запрашивает по мере обращений, что сокращает паузу при больших объёмах памяти. Приёмник стартует с опцией -incoming и ждёт поток состояния, источник получает команду migrate в мониторе QEMU или через libvirt. Нужны общее хранилище образов либо перенос самого диска, согласованные версии протокола миграции и явно зафиксированная модель CPU вроде Nehalem или EPYC вместо -cpu host, чтобы гость переезжал между разными процессорами. Миграция требует и сети с запасом: если канал медленнее скорости изменения памяти гостя, переезд превращается в бесконечную гонку грязных страниц, поэтому libvirt добавляет ограничение полосы и сжатие трафика. На этом механизме стоят платформы управления вроде OpenStack, Proxmox и обычного libvirt, обновляющие хосты, не трогая гостей.

# receiver
qemu-system-x86_64 -enable-kvm -m 4096 -drive file=disk.qcow2,if=virtio \
  -incoming tcp:0.0.0.0:4444
# source, QEMU monitor
migrate -d tcp:10.0.0.5:4444
info migrate

Практические сценарии кроссплатформенной разработки и отладки

Низкоуровневому разработчику QEMU даёт стенды, которые физикой не получить или дорого. Образ embedded-платы эмулируется командой qemu-system-aarch64 с машиной virt, и тесты прошивки гоняются в CI без парка железа. Загрузка ядра и firmware проверяется через OVMF или прямой запуск ядра, а паники ловятся раньше и безопаснее, чем на реальной плате. Отладка встроена: опции -s -S останавливают гостя на старте и открывают GDB-порт, после чего gdb подключается к виртуальному CPU и ставит точки останова ещё до первой инструкции.

qemu-system-aarch64 -M virt -cpu cortex-a53 -m 512 -nographic \
  -kernel Image -drive file=rootfs.ext4,if=virtio,format=raw \
  -append "console=ttyAMA0 root=/dev/vda"
qemu-system-x86_64 -enable-kvm -s -S -m 2048 -drive file=disk.qcow2
gdb -ex "target remote :1234" vmlinux

Матрица CI собирается из дешёвых эмулируемых раннеров: пакеты проверяются на s390x и ARM до того, как их увидит реальное железо, а флаги сборки для разных целей держатся в одном скрипте. Эмуляция медленнее кросс-компиляции, зато исключает целый класс ошибок, где бинарник собирается, но не запускается.

Администратору те же механизмы служат на обороте: старый софт, привязанный к исчезнувшей архитектуре, продолжает жить в полной эмуляции; сборочная ферма для нескольких архитектур поднимается на qemu-user без устройств; снапшоты qcow2 откатывают рискованные обновления за секунды; Android-эмулятор, кстати, построен на том же QEMU, что лишний раз говорит о зрелости проекта. Понимание того, где кончается бинарная трансляция и начинается аппаратная виртуализация, отличает уверенную работу с QEMU от копирования команд из мануалов: выбор режима, формата образа и типа устройств определяет и скорость, и надёжность всей инфраструктуры.