WINDOWS 内核 / C++ 运行库 · 2026

年轻犯傻时:我们把 C++ 异常带进了 Windows 内核

我们想让类、构造函数、RTTI 和 throw/catch 无处不在。为此,我们在驱动程序内部重建了大半套 C++ 运行库。它确实能运行。问题也正在于此。

2000 年代初,我们曾相信,内核代码也应该像普通的 C++ 应用程序一样编写。我们想用对象取代句柄,用构造函数取代初始化函数,用析构函数取代 cleanup 标签,用异常取代状态码。编译器接受这些语法,Windows 内核却没有提供背后的运行时支持。于是,我们决定自己补齐。

这不是给驱动套上一层薄薄的封装、让几个类顺利编译那么简单。归档中的实现最终长成了一套私有的内核态 C++ 运行库:启动与退出、全局对象构造、new 与 delete、内存分配失败处理、异常记录、栈检查、栈帧分派、栈展开、catch 对象构造、RTTI、数组析构、terminate 处理,以及相互独立的 x86 和 x64 支持。它还包含面向 Windows NT/2000、Windows 95 驱动和 Native 应用程序的兼容路径。

当时,这似乎证明了 C++ 可以被带到任何环境。现在回头看,它证明的是另一件事:如果平台没有提供某种语言运行库,那么在系统中最经不起失败的地方重新实现一套,通常并不值得庆祝。

编译器只看到一条 throw;我们看到的却是一整套私有运行环境。只有这套环境完整存在,那条语句才值得信任。

1. 理想:从应用层到内核只用一种语言

这种想法并不难理解。我们当时在开发存储过滤驱动、虚拟磁盘、加密层、设备抽象,以及需要跨多个 Windows 版本维护的驱动代码。C++ 看起来能够为用户态和内核态提供一致的对象模型:设备可以表示为类,IRP 可以封装成对象,引用计数可以由构造函数和析构函数管理,同一套公共代码也可以面向多个 Windows 版本编译。

代码库越大,这种诱惑越强。一旦接受了类,后续需求几乎会自然出现:全局对象应当自动构造;内存分配应当使用 new;类型检查应当依赖 RTTI;失败应当通过 throw 传播;资源则应在栈展开过程中由析构函数释放。每项功能在源代码中都像是局部改动,但到了二进制层面,没有一项真正局部。

C++ 编译器并不是用几条独立指令实现这些语言特性。它会按照特定的编译器 ABI,生成对运行库辅助函数的调用。在用户态,这些支持属于理所当然的基础设施;在内核驱动中,如果没有人主动提供,它们就不存在。

2. 还没谈异常,我们先得重建启动与退出

即使驱动程序从不执行 throw,也可能已经暗中依赖 C++ 运行库。带构造函数的全局对象要求加载过程发现并调用初始化函数;全局析构函数需要终止路径;函数内静态对象可能需要初始化守卫;纯虚函数调用也需要失败处理函数。普通的内核入口点不会自动完成 C++ 进程启动代码所做的工作。

因此,这套库借助熟悉的 .CRT 节系列建立了自己的初始化区间,包括 C 初始化函数、C++ 初始化函数、预终止函数和终止函数。一个小型遍历器扫描函数指针表,调用其中所有非空项。32 位目标把 CRT 节合并到数据段,64 位目标则合并到只读数据段。

DriverEntry 在使用驱动对象之前显式调用私有 CRT 初始化函数,卸载路径则显式调用与之对应的终止例程。类似的挂钩还被接入 Windows 95 的关键初始化、动态设备初始化与退出、Native 可执行文件启动、Native 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 链表。每次注册都会分配一个链表节点;驱动卸载时,节点按后进先出的顺序弹出,已注册函数依次执行,节点随后被释放,最后再运行预终止函数表和终止函数表。换句话说,驱动能否正确卸载,开始依赖一套仿照进程生命周期设计的私有机制能否在内核中始终无误地工作。

其中也存在一些兼容性折中。在部分目标上,_purecall 只是返回 0;栈检查辅助函数 _chkesp 被简化为直接返回。这些实现足以让旧工具链完成链接,却也揭示了项目的本质:我们并不只是在“使用 C++”,而是在模拟编译器默认假定存在的整套运行环境。

隐藏依赖 #1:对象生命周期
在第一个异常能够被捕获之前,运行库就必须保证构造和析构顺序、驱动卸载集成、atexit 行为,以及非法虚函数分派时的失败处理。

3. 只有自己实现了 new,new 才真正存在

编译器同样默认分配运算符已经存在。于是,这套库分别为内核态、Windows 95 和 Native 应用程序实现了 operator new、operator new[]、operator delete 和 operator delete[]。在 NT 内核目标上,new 从可配置的内存池中分配空间,并为分配写入标签。默认使用可分页池,但调用方可以改变池类型。

分配失败也不只是返回一次空指针。实现支持可配置的重试次数,包括无限重试模式,还支持自定义 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;
}

于是,一次看似普通的对象创建,实际上取决于内存池选择、当前执行上下文、重试策略,以及一个可能在系统已经承受内存压力时被调用的处理函数。异常处理与内存管理也因此纠缠在一起:构造异常对象、复制 catch 对象,或在数组展开期间销毁元素,都可能通过这层私有实现分配或释放内存。

这里的教训不是“自定义分配器不好”。内核软件经常需要自定义分配策略。真正的问题在于,C++ 语法会把远超一行源代码所体现的策略和约束隐藏起来。在系统代码中,这种隐藏成本很高。

4. throw 是一套协议,不是一条指令

源代码中的动作极其简单:构造一个对象,然后执行 throw。编译后,它却变成了一套由编译器元数据、运行库辅助函数、操作系统栈展开机制,以及传播路径上所有可能需要清理的栈帧共同参与的协议。

这套库实现了一条与 RaiseException 兼容的路径。它构造异常记录、复制调用方参数并检查剩余的内核栈空间;如果可用空间不足三页,就在调用 RtlRaiseException 前尝试扩展内核栈。abort 路径不会返回:在 NT 内核目标上,它会以 KMODE_EXCEPTION_NOT_HANDLED 主动触发 bugcheck。

简化后的异常抛出路径

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 处理器、完成类型匹配、构造捕获对象、记录当前异常、展开中间栈帧、调用析构函数、支持重新抛出,并最终把控制权转移到编译器选定的继续执行位置。

静态异常库中包含 _CxxThrowException、__CxxFrameHandler、__CxxFrameHandler2、__InternalCxxFrameHandler、栈帧展开例程、catch 块辅助函数、异常对象注册与销毁逻辑、嵌套栈帧展开、数组展开辅助函数,以及跟踪当前异常和当前上下文所需的状态。

5. 异常运行库究竟要做多少事

多数开发者从未真正见过异常运行库的完整清单。归档中的代码表明,要完整支持 C++ 异常,至少需要覆盖以下所有方面。

运行库模块代表性机制作用
抛出与分派_CxxThrowException、异常记录、当前异常与上下文跟踪把语言层面的 throw 转换为操作系统层面的异常分派。
栈帧处理器__CxxFrameHandler、__CxxFrameHandler2、__InternalCxxFrameHandler解释编译器生成的函数元数据,并定位 try/catch 区域。
类型匹配ThrowInfo、CatchableType、处理器匹配、catch 对象构造判断某个 catch 是否能够接收被抛出的对象,并构造捕获对象。
栈展开__FrameUnwindToState、析构函数与向量析构辅助函数在展开尚未执行完的栈帧时,销毁已经完成构造的对象。
异常对象生命周期注册、注销、销毁、大小查询、重新抛出检测确保异常对象只在语言规则要求的时间范围内保持有效。
RTTItype_info、dynamic_cast、typeid、转换为 void*、bad_cast、bad_typeid支持异常类型匹配以及用户代码需要的运行时类型操作。
失败处理策略terminate、unexpected、abort、未处理异常过滤器定义运行库无法继续维持正常异常语义时应采取的动作。
数组处理向量构造、向量析构、数组展开只清理那些已经成功完成构造的数组元素。
校验与转换读/写/执行校验、SEH 转换器挂钩衔接结构化异常,并校验对运行库元数据的访问。
诊断与命名类型名称与符号反修饰支持表示和格式化由编译器生成的类型信息。

看到这份清单之后,“我们启用了异常”这句话的含义就完全不同了。我们并不是打开了一个语言开关,而是接手了编译器 ABI、对象生命周期、栈帧元数据、与架构相关的展开规则,以及这些机制相互作用后产生的所有失败路径。

6. x86:一路钻进 FS:[0] 的兔子洞

在 32 位 x86 上,异常注册记录组成一条链表,可通过 FS:[0] 访问。库中的 Windows 95 路径自行实现了异常记录、上下文结构、注册节点、异常处置结果(disposition)、分派器、处理器包装以及展开例程。

RtlRaiseException 手工捕获机器上下文,包括通用寄存器、段寄存器、标志位、作为异常指令地址使用的返回地址、调用前的栈指针,以及调用方的帧指针。随后,RtlDispatchException 沿注册链遍历,直到遇到哨兵值或发现损坏的记录。

执行异常处理器时,代码需要先把一个小型注册帧临时链接到 FS:[0],调用处理函数,再将该帧从链表中移除。栈展开沿着同一条链进行:把异常记录标记为正在展开,处理嵌套展开和冲突展开,移除栈帧,并最终恢复此前捕获的机器上下文。

x86 注册帧操作示意

registration.previous = read_fs0();
registration.handler = compiler_frame_handler;
write_fs0(&registration);

result = registration.handler(exception, frame, context, dispatcher);

write_fs0(registration.previous);

这份实现也清楚记录了理想与现实发生碰撞的地方。若干无效展开、非法异常处置结果和损坏栈分支只会记录“此处应当再次引发异常”,真正的抛出代码却仍被注释掉。SetUnhandledExceptionFilter 返回空指针,部分兼容辅助函数也只是占位实现。这并非简单的粗心,而是在旧内核与旧编译器之间重建未公开或半公开运行库行为时几乎不可避免的结果:需要覆盖的边界条件实在太多。

标准 C++ 运行库多年积累的每一个极端情况,如今都成了驱动团队的责任;而这支团队真正要交付的是存储和系统软件,并不是一套异常处理引擎。

7. x64:架构变了,噩梦也换了形态

迁移到 x64 并没有消除问题,只是换了一套模型。x64 版本依赖 .pdata 和 .xdata 节中的表驱动展开信息,并提供一系列辅助函数,用于根据指令指针或 control PC 推导状态、定位 establisher frame、跟踪 image base,以及解释 dispatcher context。

这意味着必须实现第二套运行库,而不是简单移植 x86 的注册链遍历器。64 位归档中包含独立的异常对象抛出逻辑、栈帧处理器、状态辅助函数、处理器包装、通知占位函数、RTTI 代码、向量构造与析构、未处理异常逻辑和校验辅助函数。

因此,支持两种架构增加的远不只是几段汇编代码。对元数据格式、栈帧状态、展开表、控制转移和编译器行为的假设也随之成倍增加。一次编译器升级,就可能改变驱动所依赖的底层契约。

隐藏依赖 #2:编译器版本
异常处理不只是 C++ 语言层面的承诺,它还是由特定编译器和特定运行库版本实现的一套 ABI。即使源代码仍能编译,更换编译器也可能使元数据布局、辅助函数约定和栈展开行为失效。

8. RTTI 也跟着进来了

一旦支持带类型的异常,运行时类型信息就很难再被排除。库中实现了 type_info、类型名处理、dynamic_cast、typeid、转换为 void*,以及 bad_cast、bad_typeid 等标准异常类。

这些功能确实有价值。针对基类的 catch 处理器可以捕获派生类异常,用户代码也可以查询对象的动态类型。同一套运行库因此能够支持那些写法与普通应用程序几乎没有区别的代码。

代价是二进制契约进一步扩大。RTTI 依赖编译器生成的类型描述符、类层次结构元数据、对象定位器、基类数组、指针调整规则,以及转换失败时使用的异常对象。遇到多重继承和虚继承时,dynamic_cast 远不是比较两个 vtable 指针那么简单。归档中分别存在面向单继承、多重继承和虚继承的搜索路径。

又一次,源代码中看似很小的语言特性,在运行时层面扩张成了另一套具有自身校验逻辑、元数据、错误处理和架构依赖的子系统。

9. 驱动中的异常安全,与应用程序不是一回事

在应用程序中,异常可以展开到某个边界,由该边界记录错误、转换为用户可见的失败,或终止当前进程。在内核中,同样的控制转移可能跨过持有自旋锁、IRP、MDL、remove lock、内存池分配、映射缓冲区、设备引用、完成回调或硬件状态的栈帧。

要让异常真正安全,传播路径上的每个栈帧都必须满足异常安全要求;每个部分构造的对象都必须处于明确且可安全清理的状态;每个析构函数都必须能在当前 IRQL 和执行上下文中合法运行。析构函数不能意外阻塞,不能在错误的 IRQL 访问可分页内存,也不能调用当前上下文禁止使用的 API。清理顺序仍必须符合驱动的所有权规则和 I/O 协议,而不能只遵循 C++ 对象的嵌套关系。

运行库在处理失败时本身也会消耗栈空间。实现会显式检查剩余内核栈,并在抛出异常前尝试扩展它。这段检查几乎像是一句写进代码的自白:在试图从失败中恢复时,运行库本身也可能耗尽内核中最稀缺的资源之一。

最危险的问题并不是显眼的未处理异常,而是那些表面上恢复成功、实际却按错误顺序释放资源,令 IRP 的所有权变得含糊,或在作者从未考虑过的条件下执行析构函数的路径。

10. 我们得到了什么

说这场实验毫无收益并不公平。它为代码库提供了一致的对象模型;构造函数和析构函数减少了一部分常规生命周期代码;公共抽象可以跨不同代际的驱动复用;带类型的异常也能比单纯的状态码携带更多上下文。同一套库支持 Windows NT/2000 驱动、Windows 95 VxD、Native 应用程序、x86,以及后来的 x64 组件。

这项实现还迫使我们以前所未有的深度理解编译器和操作系统。我们弄清了编译器生成的代码如何表示 try 块、展开状态、可捕获类型、对象复制、数组构造、嵌套异常和 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. 给当年的自己几条建议

  1. 不要把“编译器接受这段代码”误认为“平台支持这种机制”。
  2. 启用某项语言特性之前,先列出它引入的每个运行库符号和元数据格式。
  3. 把全局初始化与析构视为内核架构的一部分,而不是便利功能。
  4. 不要让故障处理机制比正常路径依赖更多栈空间、内存或隐藏控制流。
  5. 除非编译器 ABI 本身就是你的产品,否则不要主动接管它。
  6. 在系统级核心中,优先使用显式状态传播和显式清理。
  7. 如果代码必须经受编译器、架构和操作系统的长期变化,就把对私有运行库行为的假设降到最低。

结论:它确实能运行,但千万别再来一次

年轻犯傻时,我们希望所有东西都能用 C++ 编写,内核代码也不例外。我们真的把它做成了:启动路径、退出路径、分配器、栈帧处理器、异常分派器、栈展开器、类型系统、数组清理、标准异常对象,以及编译器默认假定存在的架构相关运行时支持。

结果令人印象深刻,也让我们学到了很多,但它远比源代码表面所呈现的更加脆弱。我们解决了一个语言层面的问题,却把运行库层面的问题搬进了内核。

所以,最后的建议刻意说得直白:不要重来。对系统级开发而言,C 仍然是最可靠的默认选择。它贴近操作系统契约,真实呈现控制流,对工具链变化更稳定,也更容易在系统已经出错时进行审计。

在运行库受到平台支持、失败能够被隔离的地方使用 C++;在一次错误的内存写入、锁操作、栈帧假设或所有权转移就可能决定整台系统能否继续运行的地方使用 C。

内核架构与遗留代码审计

遗留驱动是否依赖一套无人敢动的私有运行库?

KernelSoft 可以还原缺少文档的 Windows 与 Linux 内核架构,审计编译器和运行库依赖,并在高风险改造开始前制定分阶段的现代化方案。

讨论驱动与遗留代码审计