nos_
ENRU

Живая миграция: как работающая ВМ переезжает на другой хост

Работающая ВМ в кластере nos теперь может переехать на другой хост, не останавливаясь. Как копируется память, которую гость продолжает менять, как два хоста договариваются, кто из них запустит машину, что происходит с её сетью и процессором, как мы это проверяли и чего миграция пока не умеет.

17 мин чтения
ГипервизорХранилищеСетьБезопасностьТестирование
Read in English

С появлением NBS диск ВМ перестал принадлежать одному серверу, а с vnet то же случилось с её сетью. К хосту, на котором машину запустили, её привязывало только одно: память и состояние процессоров и устройств. Теперь нет и этого. Работающую ВМ можно перенести на другой хост кластера, не останавливая её. Вот так Debian с 1 ГиБ памяти переезжает с одного хоста нашего демо-стенда на другой:

> hv migrate mt-deb ax41b
hv: mt-deb offered to ax41b: 1024 MiB, 1 cpu, 3 files of its folder
hv: mt-deb round 0: 279 MiB of its memory (190489 pages of zeros) and
    118 KiB of files in 2820 ms, the pages it wrote meanwhile marked
hv: mt-deb sent in 2 rounds: 281 MiB of its memory, 118 KiB of files,
    its state 2 KiB, 6 flows of its firewall -- paused 508 ms so far
hv: mt-deb runs on ax41b -- paused 860 ms; its folder here taken away

Гость не перезагружается. Его процессы продолжают работать, открытые файлы остаются открытыми, а TCP-соединения с другими ВМ переживают переезд. Один раз, в самом конце, машина встаёт на паузу: на нашем стенде от полусекунды до двух с половиной секунд. В панели управления то же самое делает кнопка на странице ВМ.

Ниже о том, как это устроено, где мы ошиблись по дороге и чего миграция пока не умеет.

Что на самом деле нужно перевезти

Меньше, чем кажется. Диск остаётся на месте: это том NBS, он и так хранится на трёх хостах, и меняется только то, какой хост в него пишет. Адрес машины тоже не меняется, потому что vnet выдаёт ВМ адрес и MAC на весь кластер, а не на один хост. Ехать должна память, на неё приходятся почти все байты (у гостя с 1 ГиБ памяти 262 144 страницы), регистры каждого виртуального процессора и состояние каждого эмулируемого устройства, вместе это несколько килобайт, и папка ВМ: её vm.toml и журнал консоли.

Переезд начинается с предложения. Старый хост отправляет новому конфигурацию ВМ и описание процессора, который видит гость, а новый решает, может ли он её принять: такой ли у него процессор, с той же ли скоростью идут часы, есть ли у него сеть этой ВМ, лежат ли все её диски в томах NBS, хватит ли места. Если что-то не так, он отказывает и объясняет почему, и ВМ продолжает работать там, где работала. Если всё в порядке, новый хост сразу собирает машину, с пустой памятью и с заглушками на месте дисков и сетевой карты, и только после этого начинается копирование. Когда приходят последние байты, остаётся немного: загрузить состояние, подставить настоящие диски и запустить.

Как копировать память, которая всё время меняется

Проще всего было бы поставить гостя на паузу, скопировать его память и запустить на другой стороне. Для гигабайта по гигабитной сети это около десяти секунд замороженной машины. За это время её TCP-собеседники начнут перепосылать пакеты, а всё, что следит за её пульсом, решит, что она умерла. Поэтому мы копируем на ходу, а потом копируем ещё раз то, что гость успел поменять. Так делают почти все гипервизоры.

Первый раунд отправляет все страницы. Страница из одних нулей едет короткой пометкой без своих байтов, а гость, который проработал недолго, в основном состоит из нулей, так что первый раунд обычно гораздо меньше памяти гостя. Пока он идёт, гость продолжает писать, и нужно знать, в какие страницы.

Этим занимается журнал грязных страниц. В начале переезда каждая страница памяти гостя становится доступной только для чтения во вложенной таблице страниц, той, по которой процессор переводит физические адреса гостя в адреса хоста (NPT у AMD, EPT у Intel). Память, отображённая блоками по 2 МиБ, сначала дробится на страницы по 4 КиБ, чтобы запись помечала четыре килобайта, а не два мегабайта. Первая запись гостя в страницу вызывает выход в гипервизор, тот отмечает страницу в битовой карте и снова разрешает в неё писать, и гость работает дальше. Собственные записи гипервизора в память гостя выхода не вызывают: когда завершается чтение с диска или приходит сетевой кадр, эмулируемое устройство само пишет в буферы гостя, поэтому такие страницы отмечаются прямо там, где делается запись.

Каждый раунд забирает отметки, снова закрывает эти страницы на запись, одним шагом под блокировкой таблицы, и отправляет их. Дольше всего мы думали над TLB. Процессор кэширует трансляции адресов, и виртуальный процессор, который недавно писал в страницу, может держать для неё разрешение на запись и после того, как таблица уже говорит «только чтение». Следующая его запись пройдёт без выхода в гипервизор и в журнал не попадёт, а копия на другом хосте тихо разойдётся с оригиналом. Ничего не упадёт. Просто у переехавшего гостя где-то окажется одна устаревшая страница, и такую ошибку потом искать тяжелее всего. Поэтому каждый раунд даёт вложенной таблице новый номер и ждёт, пока каждый виртуальный процессор гостя пройдёт начало своего цикла, где он выбрасывает всё, что его TLB помнит о старой таблице: под AMD-V он берёт новый ASID, под VT-x выполняет INVEPT. Только после этого страницы раунда читаются.

Раунды идут, пока остаток нельзя отправить меньше чем за 300 мс на скорости последнего раунда. Гость, который пишет быстрее, чем пропускает сеть, туда никогда не доберётся, поэтому после пятого раунда мы начинаем его притормаживать: его виртуальные процессоры теряют 30% своего времени, и ещё по 10% с каждым следующим раундом, до 90%. После тридцатого раунда переезд отменяется, и ВМ остаётся там, где была.

Потом последний раунд. Гость встаёт на паузу, дисковые запросы, которые уже в пути, доделываются, и сразу снимается его состояние. Следом едут страницы, записанные с прошлого раунда, и страницы колец virtio: устройства пишут в них через собственные отображения, которых журнал не видит. В первый раз мы перепутали порядок. Состояние снималось после того, как ушли последние страницы, и гость просыпался на новом хосте с часами, убежавшими вперёд ровно на то время, пока эти страницы ехали. Linux это заметил и написал в свой журнал («clocksource: Long readout interval»). Теперь состояние снимается в тот момент, когда гость останавливается.

Состояние

Состоянием мы называем всё, кроме памяти. Для каждого виртуального процессора это его регистры в виде, который умеют давать и AMD-V, и VT-x: общие и управляющие регистры, сегменты, системные MSR, отладочные регистры, область XSAVE с векторными регистрами, событие, которое ждёт доставки, тень прерываний. Дальше каждый локальный APIC и каждое эмулируемое устройство: таймеры, последовательный порт, контроллеры прерываний, очереди virtio. Время хранится относительно момента паузы, а TSC гостя едет как смещение, поэтому часы гостя идут дальше с того места, где остановились, а сама пауза из них выпадает.

Новый хост читает состояние как входные данные, которым не доверяет: оно пришло с другой машины. Каждое поле при чтении проверяется на допустимые значения, а область XSAVE проверяется ещё раз, когда загружается в процессор. В том же формате hv save и hv restore записывают состояние и память ВМ в файл на одном хосте и потом запускают её из него. Так и проверялась большая часть кода состояния, ещё до того, как в деле появился второй хост.

Кто из двух хостов её запускает

Над этим вопросом мы думали дольше всего. Если сообщения между хостами потеряются в неудачный момент или один из них умрёт на полпути, оба могут решить запустить ВМ, и тогда две копии одного гостя будут писать в один диск. Или не запустит никто. Второе плохо. Первое гораздо хуже.

Поэтому решение принимается ровно в одном месте, в метаданных NBS, которые сами по себе отдельная группа Raft. У каждого тома есть писатель, а у писателя поколение. Отправив всё, старый хост сообщает новому, какое поколение первого тома принадлежит ему. Новый хост подтверждает переезд тем, что подключает этот том на запись, но только при условии, что писатель всё ещё ровно этого поколения. Это атомарная операция «сравнить и записать» в журнале NBS. Старый хост, если за минуту ничего не услышит, сам забирает том обратно, с того же поколения. Кто успел первым, тот и выиграл, а второй получает отказ NotTheWriter. Такой отказ отличается от отсутствия ответа: запрос, на который ответа не было, отправляется снова с тем же токеном, а NBS отвечает на повторный запрос так же, как на первый, поэтому повтор не может выиграть второй раз.

Хост, который не может узнать, чем всё кончилось, ничего не запускает. ВМ остаётся остановленной, её том принадлежит той стороне, которая его забрала, и человек запускает hv start <vm> force на том хосте, где машина должна работать. Пусть лучше ВМ стоит и ждёт человека, чем работает на двух хостах сразу.

Сеть

Эта часть короче, потому что большую часть работы vnet уже сделал. Адрес и MAC машины выдаёт vnet, и они одинаковы на всех хостах, поэтому ARP-кэш гостя остаётся верным, а его шлюз тоже есть на каждом хосте. Подтверждая переезд, новый хост сообщает vnet, что порт ВМ теперь его. Раньше гипервизор каждого хоста раз в секунду спрашивал у vnet свою таблицу. Теперь vnet сам сообщает гипервизору на каждом хосте о каждом изменении, как только его применит, и не ждёт, пока его спросят.

Пока хост об этом не узнал, он продолжает слать пакеты ВМ на старый хост, а старый ещё десять секунд пересылает их новому. Для этого понадобилось одно исключение в туннеле. Обычно хост принимает пакет, только если адрес его отправителя принадлежит порту на том хосте, который этот пакет запечатал, чтобы ни один хост не мог говорить от имени чужих ВМ. Теперь новый хост принимает пакеты и от старого: для порта, который только что от него приехал, в течение этих десяти секунд, даже если отправитель сидит на третьем хосте. Старый хост мгновение назад держал всю эту ВМ у себя в памяти, так что ничего сверх этого исключение ему не даёт.

Состояние фаервола тоже переезжает. Фаервол ВМ помнит её соединения, чтобы пропускать ответы на них, и эти потоки едут вместе с состоянием и попадают в новый порт ВМ до того, как она запустится. Без них ответы на собственные соединения гостя отбрасывались бы на новом хосте, пока он сам что-нибудь не отправит.

Не переживают переезд соединения через маскарадинг старого хоста. ВМ без публичного адреса ходит в интернет через NAT того хоста, где работает, а таблица этого NAT остаётся на старом месте. Долгие соединения гостя с внешним миром рвутся, и их придётся открыть заново.

Процессор

При загрузке Linux спрашивает у процессора, что тот умеет (инструкция CPUID), и один раз решает, чем пользоваться: какими инструкциями, какими векторными регистрами, какого размера область для их сохранения. Если бы новый хост ответил иначе, гость продолжал бы полагаться на то, что обещал старый, и мог бы упасть на инструкции, которой у нового нет. Поэтому предложение несёт ответы старого хоста на все вопросы CPUID, которые может задать гость такой формы. Новый хост сравнивает их со своими, отказывает, если хоть один отличается, и называет первый такой. AMD и Intel никогда не смешиваются, а TSC обоих хостов должны идти с одной скоростью, с точностью до 250 миллионных долей.

Тут нас кое-чему научил EX44, наш единственный сервер на Intel. В его Core i5-13500 шесть быстрых ядер и восемь энергоэффективных, а наш гипервизор отвечает на CPUID гостя с того ядра, на котором гость спросил. Ядра двух видов по-разному описывают свои кэши и называют разные частоты в листе 0x16. Поэтому в первый раз ВМ, сохранённая на быстром ядре, не смогла восстановиться на энергоэффективном, на той же самой машине. Теперь эти листы в сравнение не входят. Они описывают процессор и ничего не включают, гость читает их один раз при загрузке, а время считает по листу 0x15, который на всех ядрах одинаков. И hv info теперь проверяет, что все процессоры хоста отвечают одинаково:

cpu model  c99c33c85afad94a -- what a guest moving here is held to,
           alike on the 20 CPUs

Как едут байты

Всё идёт по собственному каналу сообщений кластера, тому же, которым пользуются NBS и vnet: TCP между хостами, поверх него TLS, ключи обеих сторон закреплены. Так что память ВМ шифруется в пути без всякой дополнительной работы. Одно ограничение этого канала повлияло на протокол. Почтовый ящик отбрасывает любое сообщение больше 512 КиБ, поэтому сообщение миграции не больше 496 КиБ, а одно сообщение со страницами везёт байты не больше чем 112 из них. Старый хост держит в пути не больше 2 МиБ или 32 сообщений и ждёт, пока новый их подтвердит. Наша первая версия считала только байты, и пачка мелких сообщений могла переполнить почтовый ящик нового хоста, который ограничивает и число сообщений.

В панели

На странице работающей ВМ теперь есть кнопка «Перенести на другой хост». Она спрашивает, на какой хост (из списка хостов кластера), и не остановить ли ВМ на всё время копирования вместо живого переезда. Переезд идёт как задача: в её журнале те же строки, что печатает команда, прогресс показывает, какая доля памяти уже отправлена, а отмена до конца последнего раунда оставляет ВМ работать там, где она была. После последнего раунда отменить уже нельзя, потому что дальше решает NBS.

Как мы это проверяли

Большую часть логики мы проверили на рабочем компьютере ещё до того, как она заработала на сервере. У фаззера есть цели для формата состояния (враждебные байты отвергаются без паники, а каждое состояние читается обратно таким, каким его записали) и для сообщений. Есть цель для передачи машины: она играет за обе стороны поверх модели писателя NBS, теряет, задерживает и повторяет любое сообщение, убивает любой из хостов на любом шаге и проверяет, что два хоста никогда не запускают ВМ одновременно. У журнала грязных страниц своя цель, с модельными TLB на нескольких процессорах, которые пишут, пока раунды копируются: когда гость стоит на паузе и последний раунд отправлен, копия должна совпадать с памятью страница в страницу. Для сети добавились ещё две. Цель туннеля, которая гоняет настоящие коммутаторы и туннели трёх хостов по проводу, теряющему и переставляющему датаграммы, теперь ещё и переносит порты между хостами, пока таблицы остальных устарели. Другая цель переносит потоки фаервола порта на второй коммутатор и проверяет, что новый порт не отвергает ничего, что пропустил бы старый. Самые важные правила мы ещё и вынимали из кода по одному и проверяли, что фаззер это замечает.

Дальше сквозной тест: три экземпляра nos под QEMU на Mac, гость с Linux на томе NBS и в сети vnet. Гость всё время считает в памяти и пишет файлы из случайных байтов с их контрольными суммами, а проба на третьем хосте пингует его каждые 0,3 секунды. Его переносят с a на b живьём, обратно на a с паузой на всё копирование и снова на b живьём. После каждого переезда каждый файл должен быть цел, счётчик должен продолжиться, аптайм гостя вырасти, его ядро не должно жаловаться на часы, пинги пробы должны снова получать ответ, а NBS должен называть писателем тома новый хост.

hv logcheck проверяет журнал грязных страниц на настоящей машине, ничего никуда не перенося. Он гоняет раунды копирования по работающему гостю на одном хосте, потом ставит гостя на паузу и сравнивает каждую скопированную страницу с тем, что лежит в его памяти. На EX44 проверка прошла с одним виртуальным процессором и с двумя, на VT-x, до которого наши эмулированные тесты не достают. Там же три раза подряд прошли сохранение и восстановление ВМ.

Тесты нашли настоящие ошибки и одну ненастоящую. Первую «порчу данных», о которой сообщил сквозной тест, устроил сам тест: он читал файл дважды, пока гость переименовывал поверх него другой. Когда мы добавили в этот тест сеть, он нашёл, что ВМ с сетевой картой приезжала на новый хост без сети: имя сети по дороге дважды теряло префикс vnet:. А цель туннеля, научившись переносить порты, нашла старую ошибку, с миграцией не связанную: если терялось сообщение с ключом, туннель объявлял, что канал не пропускает MTU сетей, а потом молчал о канале, который его действительно не пропускал.

На демо-стенде

Цифры в начале статьи сняты на нашем демо-стенде, а он немного необычный. Из трёх его хостов только EX44 работает прямо на своём железе. Два других, ax41a и ax41b, работают как ВМ с nos под Linux KVM на одной машине с AMD Ryzen 5 3600, так что гость на них работает под нашим AMD-V, который сам работает внутри KVM, а байты между ними идут по TLS-соединениям кластера между двумя ВМ на одном сервере. EX44 на Intel, поэтому между ним и двумя другими ничего не переезжает. Переезжают машины между ax41a и ax41b, а во время переезда они разговаривают с ВМ на EX44.

Debian из начала статьи, клон образа NBS с 1 ГиБ памяти и одним процессором, переехал четыре раза. Два переезда, которые мы засекли, заняли семь и восемь секунд от предложения до запуска на другой стороне. Первый раунд каждый раз отправлял около 279 МиБ за время от 2,4 до 2,8 секунды, остальная память была нулями. Второго раунда в несколько сотен страниц хватало всегда. Пауза была 860, 2418, 1736 и 939 мс. Во время двух переездов ВМ на EX44 пинговала его каждые 0,2 секунды: в первый раз без ответа остались 5 пингов из 100, во второй, с длинной паузой, 12.

На последнем переезде мы включили точки трассировки миграции на обоих хостах, чтобы понять, куда ушли 939 мс. Пауза, отправка последних 409 страниц и состояния заняли около 15 мс. Остальные 920 мс ушли на ожидание сообщений: около трети секунды прошло между приходом последней страницы на новый хост и последним сообщением старого, больше полсекунды NBS передавал том, и 50 мс заняло начало работы гостя. Так что пауза уже совсем не про память, и сокращать её надо в обменах сообщениями при передаче машины.

Вторым делом нужно было проверить TCP. Маленькая тестовая ВМ на ax41a каждые 50 мс отправляла строку с номером на ВМ на EX44 по одному TCP-соединению, и мы перенесли её на ax41b. Её фаервол не пропускал внутрь ничего, кроме потоков её собственных соединений, поэтому на новом хосте ответы могли пройти только через потоки, переехавшие вместе с ней. Все 3869 строк дошли по порядку, ни одна не пропала, а на ax41b это было всё то же соединение. Для обратного переезда мы попросили получателя записывать время прихода каждой строки: дольше всего он ждал строку 1,25 секунды, а гость стоял на паузе 1,2.

Стенд нашёл и ошибку, которой не нашёл ни один тест. На ax41b никогда не было ВМ, поэтому у него не было и папки для ВМ, и первый переезд туда был отвергнут: новый хост создавал папку машины, не создав сначала папку над ней. В эмулированном тесте каждый хост к этому моменту уже создавал ВМ.

Чего миграция пока не умеет

Обоим хостам нужен одинаковый, насколько это видно гостю, процессор одного производителя. Каждый диск, в который ВМ пишет, должен быть томом NBS: файл или диск самого хоста за ней не поедет. Её сетевая карта должна быть в одной из сетей кластера, а не в собственной сети хоста. ВМ, на которую с хоста проброшен порт (forward= или hv forward), или ВМ с публичным адресом через NAT хоста (public=) остаётся на месте. Хост принимает по одной ВМ за раз. Соединения через маскарадинг старого хоста рвутся. Пауза растёт вместе с тем, как быстро гость пишет и как медленна сеть, а гость, который обгоняет сеть, даже притормозив до десятой доли своего времени, не переедет совсем.

Сервер на Intel у нас один, поэтому живого переезда между двумя хостами с VT-x ещё не было: VT-x проверен сам по себе, сохранением и восстановлением и проверкой журнала грязных страниц, а сами переезды шли между хостами на AMD. И пока ничто не переносит ВМ само. Следующим поверх этого мы сделаем освобождение хоста перед обслуживанием и распределение машин между хостами.