В начале 2000-х нам казалось, что код ядра операционной системы должен выглядеть как обычное приложение на C++. Нам хотелось объектов вместо дескрипторов, конструкторов вместо функций инициализации, деструкторов вместо переходов к меткам cleanup и исключений вместо кодов состояния. Компилятор позволял писать такой код, но ядро не предоставляло механизмов, обеспечивающих этот синтаксис. Поэтому мы создали их сами.
Это не рассказ о небольшой обёртке, позволившей скомпилировать в драйвере несколько классов. Архивная реализация выросла в полноценную среду выполнения собственной разработки внутри ядра: инициализация и завершение, глобальные конструкторы, операторы new и delete, обработчики отказа выделения памяти, записи исключений, контроль стека, обработка кадров, раскрутка стека, создание объектов для catch, RTTI, уничтожение массивов, пути terminate, а также отдельная поддержка x86 и x64. Кроме того, существовали ветви совместимости для Windows NT/2000, драйверов Windows 95 и нативных приложений.
Тогда нам казалось, что мы доказали: язык можно заставить работать где угодно. Теперь этот опыт доказывает другое: если платформа не предоставляет среду выполнения языка, её воссоздание внутри самой чувствительной к сбоям части системы почти никогда нельзя считать победой.
Компилятор видел один оператор
throw. Мы видели целую внутреннюю среду выполнения, которая должна была безупречно работать ещё до того, как этому оператору можно было доверять.
1. Мечта: один язык от приложения до ядра
Мотивация была понятной. Мы разрабатывали фильтры устройств хранения, виртуальные диски, слои шифрования, абстракции устройств и код драйверов для разных версий Windows. C++ обещал единую объектную модель для пользовательского режима и ядра. Устройство могло стать классом, IRP — объектом-обёрткой, а управление счётчиком ссылок — частью конструкторов и деструкторов. Общий код можно было собирать для нескольких поколений Windows.
В большой кодовой базе соблазн только усиливается. Как только в проекте появляются классы, следом возникают новые требования: глобальные объекты должны конструироваться автоматически; память — выделяться через new; типы — проверяться через RTTI; ошибки — передаваться через исключения; ресурсы — освобождаться деструкторами при раскрутке стека. В исходном коде каждая функция языка кажется локальной. На уровне двоичного кода локальной не является ни одна из них.
Компилятор C++ не реализует эти возможности набором изолированных инструкций. Он генерирует вызовы среды выполнения с ABI конкретного компилятора. В пользовательском режиме такая среда — штатная инфраструктура. В драйвере ядра её нет, пока кто-то не реализует её самостоятельно.
2. До исключений пришлось изобрести инициализацию и завершение
Даже драйвер, в котором нет ни одного throw, может незаметно зависеть от среды выполнения C++. Для глобального объекта с конструктором загрузчик должен найти и вызвать функции инициализации. Глобальному деструктору нужен путь завершения. Локальной статической переменной может потребоваться механизм однократной инициализации, а вызову чисто виртуальной функции — обработчик ошибки. Обычная точка входа драйвера не выполняет роль стартового кода C++-процесса.
Поэтому библиотека создала собственные диапазоны инициализаторов на основе привычных семейств секций .CRT: инициализаторы C и C++, предзавершающие и завершающие обработчики. Небольшая функция обходила таблицы указателей и вызывала каждую ненулевую функцию. В 32-разрядных сборках секция CRT объединялась с секцией данных, а в 64-разрядных — с секцией данных только для чтения.
DriverEntry явно вызывал собственный CRT-инициализатор до обращения к объекту драйвера. В процедуре выгрузки так же явно вызывался соответствующий код завершения. Аналогичные вызовы были встроены в критическую инициализацию Windows 95, динамическую инициализацию и завершение устройства, запуск нативного EXE, запуск нативной DLL и выгрузку минифильтра.
Упрощённая схема жизненного цикла среды выполнения
extern "C" NTSTATUS DriverEntry(...)
{
kernel_crt_initialize(); // global C and C++ initializers
NTSTATUS status = driver_on_load();
if (!NT_SUCCESS(status))
driver_unload();
return status;
}
void driver_unload()
{
driver_on_unload();
kernel_crt_shutdown(); // atexit, destructors, terminators
}Код завершения поддерживал и собственный список atexit. При каждой регистрации выделялся узел связного списка; во время завершения узлы извлекались в порядке LIFO, зарегистрированные функции вызывались, узлы освобождались, после чего выполнялись таблицы предзавершения и завершения. Иными словами, корректная выгрузка драйвера теперь зависела от безошибочной работы внутри ядра собственной процессоподобной модели жизненного цикла.
Были и заглушки совместимости. В некоторых сборках _purecall просто возвращал ноль, а проверка стека _chkesp сводилась к пустому return. Эти решения позволяли линковать код старыми компиляторами и линкерами, но одновременно показывали истинный масштаб проекта: мы не просто использовали C++. Мы имитировали окружение, которого ожидал компилятор.
Скрытая зависимость № 1: время жизни объектов
Ещё до первого пойманного исключения среда выполнения должна была гарантировать порядок конструкторов и деструкторов, интеграцию с выгрузкой драйвера, работуatexitи обработку ошибочного виртуального вызова.
3. Оператор new не существовал, пока мы его не реализовали
Компилятор также предполагал наличие операторов выделения памяти. Библиотека предоставляла operator new, operator new[], operator delete и operator delete[] для режима ядра, Windows 95 и нативных приложений. В драйверах ядра NT оператор new выделял память из пула настраиваемого типа и помечал блок тегом. По умолчанию использовался выгружаемый пул, хотя вызывающий код мог выбрать другой тип.
Отказ выделения памяти не сводился к простому возврату null. Реализация поддерживала настраиваемое число повторных попыток, включая бесконечный режим, и пользовательский new-handler. Обработчик был привязан к текущему драйверу, а в ядре отслеживался через ресурсы, связанные с контекстом потока. В отладочных сборках подсчитывались неосвобождённые блоки, чтобы при выгрузке можно было сообщить об утечках.
На деле аллокатор был сложнее одного вызова функции пула
void* operator new(size_t bytes)
{
void* p = pool_allocate(current_pool, bytes, allocation_tag);
for (unsigned attempt = 0; !p && retry_allowed(attempt); ++attempt)
p = pool_allocate(current_pool, bytes, allocation_tag);
if (!p)
if (auto handler = current_new_handler())
handler();
return p;
}В результате безобидное на вид создание объекта зависело от выбора пула, текущего контекста выполнения, политики повторов и обработчика, который мог сработать, когда система уже испытывала нехватку памяти. Обработка исключений переплеталась с управлением памятью: создание объекта исключения, копирование пойманного объекта или раскрутка массива могли выделять и освобождать память через этот внутренний слой.
Вывод не в том, что собственные аллокаторы плохи: в ядре они часто необходимы. Проблема в другом — синтаксис C++ способен скрыть намного больше решений и политик, чем видно из одной строки исходного кода. В системном коде такая скрытая сложность обходится дорого.
4. throw — это протокол, а не инструкция
В исходном коде операция выглядит крошечной: создать объект и выполнить throw. На уровне машинного кода это целый протокол между метаданными компилятора, функциями среды выполнения, системным механизмом раскрутки стека и каждым кадром, которому может потребоваться очистка.
Библиотека предоставляла путь, совместимый с RaiseException. Она формировала запись исключения, копировала переданные параметры, проверяла остаток стека ядра и, если оставалось меньше трёх страниц, пыталась расширить стек перед вызовом RtlRaiseException. Ветка abort не возвращала управление: в ядре NT она намеренно выполняла аварийную остановку системы с кодом KMODE_EXCEPTION_NOT_HANDLED.
Упрощённый путь генерации исключения
EXCEPTION_RECORD record = {};
record.ExceptionCode = code;
record.ExceptionFlags = flags;
record.ExceptionAddress = raise_exception;
record.NumberParameters = count;
copy_parameters(record.ExceptionInformation, info, count);
if (remaining_kernel_stack() < 3 * PAGE_SIZE)
try_to_grow_kernel_stack();
RtlRaiseException(&record);Но вызов системного механизма исключений был лишь первым шагом. Среда C++ всё ещё должна была найти подходящий catch, сопоставить типы, создать объект для обработчика, запомнить активное исключение, раскрутить промежуточные кадры, вызвать деструкторы, обеспечить повторный throw и передать управление в точку продолжения, выбранную компилятором.
Статическая библиотека исключений содержала _CxxThrowException, __CxxFrameHandler, __CxxFrameHandler2, __InternalCxxFrameHandler, процедуры раскрутки кадров, вспомогательные функции для блоков catch, регистрацию и уничтожение объектов исключений, раскрутку вложенных кадров, функции для работы с массивами и состояние для отслеживания текущего исключения и контекста.
5. Что на самом деле приходилось делать среде обработки исключений
Перечень механизмов среды выполнения — именно та часть, которую большинство разработчиков никогда не видит. Архивные библиотеки показывают, что полная поддержка исключений C++ требовала всех перечисленных ниже компонентов.
| Область среды выполнения | Основные механизмы | Зачем это было нужно |
|---|---|---|
| Генерация и диспетчеризация | _CxxThrowException, записи исключений, отслеживание текущего исключения и контекста | Преобразовать оператор throw в системную операцию диспетчеризации исключения. |
| Обработчики кадров | __CxxFrameHandler, __CxxFrameHandler2, __InternalCxxFrameHandler | Интерпретировать метаданные функций, созданные компилятором, и находить области try/catch. |
| Сопоставление типов | ThrowInfo, CatchableType, поиск обработчика, создание catch-объекта | Определить, подходит ли обработчик catch для брошенного объекта, и создать объект для обработчика. |
| Раскрутка | __FrameUnwindToState, вспомогательные функции деструкторов и векторных деструкторов | Уничтожать полностью сконструированные объекты при выходе из частично выполненных кадров. |
| Время жизни исключения | регистрация, снятие регистрации, уничтожение, определение размера, обнаружение повторного throw | Сохранять объект исключения ровно столько, сколько требуют правила языка. |
RTTI | type_info, dynamic_cast, typeid, cast-to-void, bad_cast, bad_typeid | Поддерживать операции динамических типов, используемые при сопоставлении и в пользовательском коде. |
| Политика отказа | terminate, unexpected, abort, фильтры необработанных исключений | Определить поведение, когда штатно продолжить обработку исключения невозможно. |
| Массивы | векторные конструкторы, векторные деструкторы, раскрутка массива | Очищать только те элементы, которые успели успешно сконструироваться. |
| Валидация и трансляция | проверка чтения, записи и исполнения; хуки транслятора SEH | Связать структурированные исключения SEH с C++ и проверять доступ к метаданным среды выполнения. |
| Диагностика и имена | имена типов и декодирование (undecoration) | Представлять и форматировать сгенерированную компилятором информацию о типах. |
После этого фраза «мы включили исключения» звучит иначе. Мы включили не одну функцию языка, а взяли на себя ответственность за ABI компилятора, жизненный цикл объектов, метаданные кадров, архитектурно-зависимую раскрутку стека и все аварийные пути, возникающие при их взаимодействии.
6. x86: кроличья нора FS:[0]
В 32-разрядной модели x86 регистрация исключений представляла собой связную цепочку, доступную через FS:[0]. Ветка библиотеки для Windows 95 реализовывала собственные записи исключений, структуру контекста, регистрационные узлы, коды возврата обработчиков (disposition), диспетчер, обёртки обработчиков и процедуру раскрутки.
RtlRaiseException вручную сохранял машинный контекст: регистры общего назначения, сегментные регистры, флаги, адрес возврата как указатель команды, на которой возникло исключение, значение указателя стека до вызова и указатель кадра вызывающей функции. Затем RtlDispatchException обходил регистрационную цепочку до значения-сентинела либо до обнаружения повреждённой записи.
Для вызова обработчика небольшой регистрационный кадр временно включался в цепочку FS:[0]; затем вызывался обработчик, после чего кадр удалялся из цепочки. Раскрутка проходила по той же цепочке, помечала запись исключения как находящуюся в состоянии раскрутки, обрабатывала вложенную и пересекающуюся раскрутку (collided unwind), удаляла кадры и в конце восстанавливала сохранённый контекст.
Концептуальная работа с регистрационным кадром x86
registration.previous = read_fs0();
registration.handler = compiler_frame_handler;
write_fs0(®istration);
result = registration.handler(exception, frame, context, dispatcher);
write_fs0(registration.previous);Реализация показывает и момент, когда амбиции столкнулись с реальностью. Несколько ветвей обработки invalid unwind, invalid disposition и bad stack выводили сообщение о необходимости сгенерировать исключение, но сам код генерации оставался закомментированным. SetUnhandledExceptionFilter возвращал null. Часть функций совместимости оставалась заглушками. Это не следствие небрежности, а закономерный результат попытки воспроизвести недокументированное или лишь частично документированное поведение среды выполнения на старых ядрах и компиляторах. Объём работы оказался слишком велик.
Все редкие сценарии, которые штатная среда C++ отрабатывала и исправляла годами, теперь стали ответственностью команды драйвера, хотя её настоящим продуктом были системы хранения и системное ПО, а не механизм обработки исключений.
7. x64: другая архитектура — другой кошмар
Переход на x64 не устранил проблему, а лишь изменил её модель. 64-разрядная библиотека содержала табличную информацию о раскрутке в секциях .pdata и .xdata и предоставляла функции для определения состояния по указателю команд (instruction pointer) или control PC, поиска базового кадра (establisher frame), отслеживания базы образа и интерпретации контекста диспетчера.
Это требовало второй самостоятельной реализации среды выполнения, а не простого переноса x86-кода обхода цепочки. В 64-разрядном архиве были собственный объект исключения, обработчик кадра, функции определения состояния, обёртки обработчиков, заглушки уведомлений, RTTI, создание и уничтожение векторов, логика необработанных исключений и функции проверки.
Поддержка двух архитектур удвоила не только объём ассемблерного кода. Вдвое выросло число допущений о форматах метаданных, состоянии кадров, таблицах раскрутки, передаче управления и поведении компилятора. Обновление компилятора могло изменить сам контракт, от которого зависел драйвер.
Скрытая зависимость № 2: версия компилятора
Исключения — не только обещание языка C++. Это ABI конкретного поколения компилятора и среды выполнения. Замена компилятора может изменить форматы метаданных, требования к вспомогательным функциям и поведение раскрутки стека, даже если исходный код по-прежнему собирается.
8. Вместе с исключениями пришла RTTI
После появления типизированных исключений избежать RTTI стало трудно. Библиотеки включали type_info, работу с именами типов, dynamic_cast, typeid, приведение к void и стандартные классы исключений для неудачных приведений и недопустимых операций typeid.
Это было полезно. Обработчик базового типа мог принять объект производного исключения. Пользовательский код получал динамическую информацию о типе. Та же среда позволяла писать код так, словно он выполнялся в обычном приложении.
Но двоичный контракт снова расширился. RTTI требует генерируемых компилятором дескрипторов типов, метаданных иерархии классов, локаторов объектов, массивов базовых классов, правил смещения указателей и служебных объектов ошибок. При множественном и виртуальном наследовании dynamic_cast намного сложнее простой проверки таблицы виртуальных функций. В архиве существовали отдельные пути поиска для одиночного, множественного и виртуального наследования.
И снова небольшая функция языка на уровне исходного кода превращалась в отдельную подсистему со своими проверками, метаданными, обработкой ошибок и зависимостью от архитектуры.
9. Безопасность исключений в драйвере — совсем не то же, что в приложении
В приложении исключение может подняться по стеку до границы, которая запишет ошибку в журнал, превратит её в понятное пользователю сообщение или завершит один процесс. В ядре тот же переход управления способен пройти через кадры, владеющие спин-блокировками, IRP, MDL, блокировками удаления (remove lock), выделениями из пула, отображёнными буферами, ссылками на устройства, функциями завершения или состоянием оборудования.
Чтобы исключения были безопасны, каждый кадр на пути их распространения должен корректно работать при исключениях. Необходимо учитывать состояние каждого частично сконструированного объекта. Каждый деструктор обязан быть допустим на текущем IRQL и в текущем контексте выполнения. Он не должен неожиданно блокироваться, обращаться к выгружаемой памяти или вызывать API, запрещённый в этом контексте. Порядок очистки должен соответствовать протоколам ядра, а не только вложенности объектов C++.
Сама среда выполнения расходует стек во время обработки сбоя. Реализация явно проверяла остаток стека ядра и пыталась расширить его перед генерацией исключения. Эта проверка — признание, оставленное прямо в коде: механизм восстановления после ошибки сам рисковал исчерпать один из самых дефицитных ресурсов ядра.
Самые опасные ошибки — не очевидные необработанные исключения. Хуже пути, которые кажутся успешно восстановившимися, но освобождают ресурсы в порядке, нарушающем контракт драйвера, оставили IRP с неясным владельцем или выполнили деструктор в условиях, которые его автор не предусмотрел.
10. Что мы получили
Было бы нечестно утверждать, что эксперимент не дал преимуществ. Кодовая база получила единую объектную модель. Конструкторы и деструкторы сократили часть рутинного кода управления жизненным циклом. Общие абстракции можно было использовать в разных поколениях драйверов. Типизированные ошибки могли нести больше контекста, чем один целочисленный код состояния. Одна библиотека поддерживала драйверы NT/2000, VxD Windows 95, нативные приложения, x86, а позднее и компоненты x64.
Реализация заставила нас понять компилятор и операционную систему на уровне, который большинству разработчиков никогда не требуется. Мы увидели, как в сгенерированном коде представлены блоки try, состояния раскрутки, типы, допустимые для catch, копирование объектов, конструирование массивов, вложенные исключения и RTTI. Эти знания оставались полезными ещё долго после того, как сама архитектура перестала казаться привлекательной.
И да, код работал достаточно хорошо, чтобы им пользовались. Именно успех сделал его опаснее. Механизм, который ломается сразу, легко отвергнуть. Механизм, который годами проходит обычное тестирование, успевает стать архитектурной зависимостью до того, как проявится редкий, но самый тяжёлый сценарий.
11. Во что это обошлось
Очевидной ценой был объём кода. Но ещё важнее была принятая на себя ответственность. Драйвер стал зависеть от поведения, за которое обычно отвечают поставщик компилятора и разработчики штатной среды выполнения.
- Привязка к ABI компилятора. Внутренние имена вспомогательных функций, форматы метаданных, прологи, обработчики кадров и структуры
RTTIстали частью архитектуры драйвера. - Дублирование архитектурной реализации. Связные регистрационные цепочки x86 и табличная раскрутка x64 требовали принципиально разного кода.
- Непрозрачный поток управления. Один
throwмог вызвать множество деструкторов и вспомогательных функций, невидимых в месте отказа. - Нагрузка на стек ядра. Механизму восстановления требовался стек для анализа кадров, сопоставления типов, создания объектов для
catchи раскрутки. - Сложность жизненного цикла. Глобальные конструкторы, обработчики
atexitи глобальные деструкторы требовалось безошибочно встроить в загрузку и выгрузку для каждой целевой платформы. - Скрытая политика выделения памяти. Поведение
newзависело от типа пула, повторных попыток, обработчиков текущего потока и аварийных путей при нехватке памяти. - Сложность отладки. Сбой мог возникнуть в прикладном коде драйвера, сгенерированных метаданных, функции среды выполнения, деструкторе или мосте к системной диспетчеризации исключений.
- Ложная уверенность. Знакомый синтаксис C++ делал код ядра более обычным и безопасным на вид, чем была реальная среда выполнения.
Реализация была техническим достижением и одновременно дорогим способом убедиться: удобство языка не становится бесплатным лишь потому, что компилятор принимает его синтаксис.
12. Момент прозрения
С опытом работы в низкоуровневых системах становится очевидна закономерность: чем ближе код к оборудованию, планированию, владению памятью и механизмам восстановления после сбоев, тем важнее прозрачность.
C делает путь распространения ошибки видимым. Функция возвращает код состояния. Вызывающий код видит, перешло ли владение ресурсом. Очистка централизована и выполняется в явном порядке. В двоичном коде меньше скрытых зависимостей от среды выполнения. Интерфейс естественно соответствует API операционной системы. Код может быть длиннее, но эта многословность документирует поток управления, который обязан оставаться корректным под нагрузкой и при сбое.
Скучный C делает владение и порядок очистки явными
NTSTATUS process_request(REQUEST* request)
{
NTSTATUS status;
RESOURCE_A* a = NULL;
RESOURCE_B* b = NULL;
status = acquire_a(&a);
if (!NT_SUCCESS(status))
goto cleanup;
status = acquire_b(a, &b);
if (!NT_SUCCESS(status))
goto cleanup;
status = execute_request(request, a, b);
cleanup:
if (b) release_b(b);
if (a) release_a(a);
return status;
}Метка cleanup не в моде. Зато она не скрывает управляемый компилятором обход метаданных и деструкторов. Ревьюер видит каждый ресурс, каждое освобождение и их точный порядок. Отладчик может остановиться на каждой ветви. Статический анализатор — проследить значение статуса. При разборе дампа не приходится сначала восстанавливать ещё одну собственную среду выполнения, прежде чем добраться до логики драйвера.
C не предотвращает ошибки — их не предотвращает ничто. Но в системной разработке он сокращает количество скрытых механизмов между кодом, который мы проверяем, и поведением машины, которое обязаны гарантировать.
C скучен. В коде ядра скука — преимущество.
13. Использовали бы мы C++ в ядре сегодня?
Ограниченное подмножество C++ может быть полезно в контролируемых условиях: классы без исключений, предсказуемые конструкторы, отсутствие RTTI, глобальных объектов со сложным жизненным циклом, неявного выделения памяти и зависимостей от стандартной библиотеки, а также сборка, в которой виден каждый сгенерированный символ среды выполнения. Но тогда главная ценность C++ — пространства имён, шаблоны и структурирование кода на этапе компиляции, а не среда уровня приложения, которую мы когда-то пытались воссоздать.
Наш выбор по умолчанию сегодня проще: ядровую часть системы писать на C. Интерфейсы делать явными. Возвращать коды состояния. Владение ресурсами показывать явно. Небольшие обёртки и генерацию кода применять только там, где они сокращают повторение, не создавая скрытого потока управления. Более богатые абстракции C++ размещать по другую сторону границы ядра — в пользовательском режиме, где есть изоляция процессов и поддерживаемая среда выполнения.
Это не ностальгия по старому синтаксису, а результат понимания того, сколько механизмов потребовалось, чтобы одна элегантная функция языка заработала в среде, которая никогда не обещала её поддерживать.
14. Советы самим себе в молодости
- Не путайте «компилятор это принимает» с «платформа это поддерживает».
- Перед включением функции языка перечислите все символы среды выполнения и форматы метаданных, которые она добавляет.
- Считайте глобальную инициализацию и уничтожение частью архитектуры ядра, а не удобством.
- Не стройте механизм обработки отказа так, чтобы ему требовалось больше стека, памяти или скрытого управления, чем штатному пути.
- Не берите на себя ответственность за ABI компилятора, если этот ABI не является вашим продуктом.
- В ядровой части системы предпочитайте явную передачу кодов состояния и явную очистку.
- Если код должен переживать смену компилятора, архитектуры и ОС, сводите нестандартные допущения о среде выполнения к минимуму.
Вывод: это работало — никогда не повторяйте
Когда мы были молодыми и глупыми, нам хотелось, чтобы на C++ работало всё, включая ядро. И мы этого добились. Мы построили инициализацию и завершение, аллокаторы, обработчики, диспетчер исключений, раскрутку стека, систему типов, очистку массивов, стандартные объекты исключений и архитектурно-зависимую обвязку, наличие которой молча предполагал компилятор.
Результат был впечатляющим, познавательным и гораздо более хрупким, чем выглядел исходный код. Мы решили проблему языка, перенеся проблему среды выполнения внутрь ядра.
Поэтому финальный совет намеренно прямой: не повторяйте это. Для системной разработки C остаётся лучшим выбором по умолчанию. Он близок к контракту операционной системы, честно показывает поток управления, устойчив к смене инструментария и проще для анализа, когда система уже находится в аварийном состоянии.
Используйте C++ там, где его среда выполнения поддерживается, а последствия сбоя изолированы. Используйте C там, где каждый байт, каждая блокировка, каждый кадр стека и каждый переход владения могут определить, останется ли жива вся система.