Windows 操作系统架构深度解析
Windows 操作系统是全球最广泛使用的桌面操作系统之一，其架构设计经历了数十年的演进。本文将深入解析 Windows 的核心架构，包括内核结构、子系统、功能模块以及 COM 接口等关键组件。
Windows 架构概览
Windows 采用分层架构设计，主要分为用户模式（User Mode）和内核模式（Kernel Mode）两大层次：
┌─────────────────────────────────────────────────────────────┐
│ 用户模式 (User Mode) │
├─────────────────────────────────────────────────────────────┤
│ 应用程序层 │
│ ├── Win32 应用程序 │
│ ├── UWP 应用程序 │
│ ├── .NET 应用程序 │
│ └── 其他子系统应用 │
├─────────────────────────────────────────────────────────────┤
│ 子系统层 (Subsystems) │
│ ├── Win32 子系统 (CSRSS) │
│ ├── WOW64 子系统 │
│ ├── POSIX 子系统 │
│ └── WSL (Windows Subsystem for Linux) │
├─────────────────────────────────────────────────────────────┤
│ 系统 DLL 层 │
│ ├── NTDLL.DLL (Native API) │
│ ├── KERNEL32.DLL / KERNELBASE.DLL │
│ ├── USER32.DLL / GDI32.DLL │
│ └── COM 运行时 (COM32.DLL / OLE32.DLL) │
├─────────────────────────────────────────────────────────────┤
│ 内核模式 (Kernel Mode) │
├─────────────────────────────────────────────────────────────┤
│ 执行体 (Executive) │
│ ├── 对象管理器 (Object Manager) │
│ ├── 内存管理器 (Memory Manager) │
│ ├── 进程和线程管理器 (Process/Thread Manager) │
│ ├── I/O 管理器 (I/O Manager) │
│ ├── 配置管理器 (Configuration Manager) │
│ ├── 安全引用监视器 (SRM) │
│ └── 即插即用管理器 (PnP Manager) │
├─────────────────────────────────────────────────────────────┤
│ 内核 (Kernel / NTOSKRNL.EXE) │
│ ├── 微内核功能 │
│ │ ├── 线程调度 │
│ │ ├── 中断处理 │
│ │ ├── 多处理器同步 │
│ │ └── 异常分发 │
│ └── 内核支持功能 │
│ ├── 电源管理 │
│ └── 设备驱动支持 │
├─────────────────────────────────────────────────────────────┤
│ 硬件抽象层 (HAL - HAL.DLL) │
├─────────────────────────────────────────────────────────────┤
│ 设备驱动程序 │
│ ├── 内核模式驱动 (KMDF) │
│ ├── 文件系统驱动 │
│ ├── 网络驱动 │
│ └── 硬件设备驱动 │
├─────────────────────────────────────────────────────────────┤
│ 硬件层 │
│ ├── CPU / 内存 │
│ ├── 存储设备 │
│ ├── 网络设备 │
│ └── 其他外设 │
└─────────────────────────────────────────────────────────────┘内核模式详解
执行体 (Executive)
执行体是 Windows 内核的上层部分，提供各种系统服务。它由多个关键组件组成：
1. 对象管理器 (Object Manager)
对象管理器是 Windows 内核的核心组件，负责管理所有内核对象。
// 内核对象类型示例
typedef enum _KOBJECTS {
EventNotificationObject = 0,
EventSynchronizationObject = 1,
MutantObject = 2,
ProcessObject = 3,
QueueObject = 4,
SemaphoreObject = 5,
ThreadObject = 6,
// ... 更多对象类型
} KOBJECTS;
// 对象头结构（简化）
typedef struct _OBJECT_HEADER {
LONG PointerCount;
LONG HandleCount;
POBJECT_TYPE Type;
PVOID ObjectBody;
// ... 其他字段
} OBJECT_HEADER, *POBJECT_HEADER;主要功能：
- 对象的创建、删除和引用计数管理
- 对象命名空间的维护
- 对象类型系统的实现
- 访问控制和安全检查
命名空间层次结构：
\ (根目录)
├── \SystemRoot (系统根目录)
├── \Device (设备对象)
│ ├── \HarddiskVolume1
│ ├── \KeyboardClass0
│ └── \Serial0
├── \Driver (驱动程序对象)
├── \FileSystem (文件系统对象)
├── \KernelObjects (内核对象)
│ ├── \HighMemoryCondition
│ ├── \LowMemoryCondition
│ └── \PowerState
├── \BaseNamedObjects (用户对象)
│ ├── Events
│ ├── Mutexes
│ ├── Semaphores
│ └── Sections
└── \Sessions (会话对象)
└── \0
└── \BaseNamedObjects2. 内存管理器 (Memory Manager)
内存管理器负责虚拟内存管理，是 Windows 最重要的子系统之一。
核心概念：
虚拟地址空间布局 (64位 Windows)
┌──────────────────────────────────────┐ 0x0000000000000000
│ 用户模式空间 │ (128 TB)
│ ┌────────────────────────────────┐ │
│ │ 空指针赋值区 (64KB) │ │
│ ├────────────────────────────────┤ │
│ │ 用户模式代码和数据 │ │
│ ├────────────────────────────────┤ │
│ │ 堆 (Heap) │ │
│ ├────────────────────────────────┤ │
│ │ 栈 (Stack) │ │
│ ├────────────────────────────────┤ │
│ │ DLL 映射区 │ │
│ ├────────────────────────────────┤ │
│ │ 共享内存区 │ │
│ └────────────────────────────────┘ │
├──────────────────────────────────────┤ 0x00007FFFFFFFFFFF
│ 系统保留区 │ (无效区域)
├──────────────────────────────────────┤ 0xFFFF800000000000
│ 内核模式空间 │ (128 TB)
│ ┌────────────────────────────────┐ │
│ │ 系统代码和驱动 │ │
│ ├────────────────────────────────┤ │
│ │ 系统映射视图 │ │
│ ├────────────────────────────────┤ │
│ │ 分页池 (Paged Pool) │ │
│ ├────────────────────────────────┤ │
│ │ 非分页池 (Non-paged Pool) │ │
│ ├────────────────────────────────┤ │
│ │ PFN 数据库 │ │
│ ├────────────────────────────────┤ │
│ │ 系统缓存 │ │
│ └────────────────────────────────┘ │
└──────────────────────────────────────┘ 0xFFFFFFFFFFFFFFFF内存管理数据结构：
// 虚拟地址描述符 (VAD)
typedef struct _MMVAD {
union {
LONG Balance : 2;
struct _MMVAD *Parent;
} u1;
struct _MMVAD *LeftChild;
struct _MMVAD *RightChild;
ULONG StartingVpn;
ULONG EndingVpn;
union {
ULONG LongFlags;
MMVAD_FLAGS VadFlags;
} u;
// ... 其他字段
} MMVAD, *PMMVAD;
// 页帧号数据库条目
typedef struct _MMPFNENTRY {
ULONG Modified : 1;
ULONG ReadInProgress : 1;
ULONG WriteInProgress : 1;
ULONG PrototypePte : 1;
ULONG PageColor : 4;
ULONG ParityError : 1;
ULONG PageLocation : 3;
// ... 其他标志
} MMPFNENTRY;内存管理功能：
- 虚拟地址到物理地址的转换
- 工作集管理（Working Set）
- 页面错误处理
- 内存映射文件
- 物理内存管理（PFN 数据库）
3. 进程和线程管理器
// 进程控制块 (EPROCESS) - 简化版
typedef struct _EPROCESS {
KPROCESS Pcb; // 内核进程块
EX_PUSH_LOCK ProcessLock;
LARGE_INTEGER CreateTime;
LARGE_INTEGER ExitTime;
HANDLE UniqueProcessId;
LIST_ENTRY ActiveProcessLinks;
// ... 内存管理相关
PVOID VirtualSize;
PVOID PeakVirtualSize;
MMSUPPORT Vm;
// ... 安全相关
EX_FAST_REF Token;
// ... 其他字段
} EPROCESS, *PEPROCESS;
// 线程控制块 (ETHREAD) - 简化版
typedef struct _ETHREAD {
KTHREAD Tcb; // 内核线程块
LARGE_INTEGER CreateTime;
LARGE_INTEGER ExitTime;
NTSTATUS ExitStatus;
LIST_ENTRY PostBlockList;
// ... 等待块
PVOID StartAddress;
PEPROCESS ThreadsProcess;
// ... 其他字段
} ETHREAD, *PETHREAD;进程状态转换：
┌─────────────┐
│ 创建中 │
└──────┬──────┘
│
▼
┌─────────────┐
┌─────────│ 就绪态 │◄────────┐
│ └──────┬──────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ ┌───►│ 运行态 │────┐ │
│ │ └─────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────┐ │ │
│ └────│ 等待态 │────┘ │
│ └──────┬──────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
└────────►│ 终止中 │─────────┘
└──────┬──────┘
│
▼
┌─────────────┐
│ 已终止 │
└─────────────┘4. I/O 管理器
I/O 管理器负责管理所有输入/输出操作，是设备驱动程序与系统其他部分之间的接口。
// I/O 请求包 (IRP) - 简化版
typedef struct _IRP {
CSHORT Type;
USHORT Size;
PMDL MdlAddress;
ULONG Flags;
union {
struct _IRP *MasterIrp;
LONG IrpCount;
PVOID SystemBuffer;
} AssociatedIrp;
LIST_ENTRY ThreadListEntry;
IO_STATUS_BLOCK IoStatus;
KPROCESSOR_MODE RequestorMode;
BOOLEAN PendingReturned;
BOOLEAN Cancel;
KIRQL CancelIrql;
PDRIVER_CANCEL CancelRoutine;
PVOID UserBuffer;
union {
struct {
union {
KDEVICE_QUEUE_ENTRY DeviceQueueEntry;
struct {
PVOID DriverContext[4];
};
};
PETHREAD Thread;
PCHAR AuxiliaryBuffer;
LIST_ENTRY ListEntry;
union {
struct _IO_STACK_LOCATION *CurrentStackLocation;
ULONG PacketType;
};
PFILE_OBJECT OriginalFileObject;
} Overlay;
} Tail;
} IRP, *PIRP;
// I/O 堆栈位置
typedef struct _IO_STACK_LOCATION {
UCHAR MajorFunction;
UCHAR MinorFunction;
UCHAR Flags;
UCHAR Control;
union {
// 各种函数特定的参数
struct {
PIO_SECURITY_CONTEXT SecurityContext;
ULONG Options;
USHORT FileAttributes;
USHORT ShareAccess;
ULONG EaLength;
} Create;
struct {
ULONG Length;
ULONG Key;
LARGE_INTEGER ByteOffset;
} Read;
struct {
ULONG Length;
ULONG Key;
LARGE_INTEGER ByteOffset;
} Write;
// ... 其他函数类型
} Parameters;
PDEVICE_OBJECT DeviceObject;
PFILE_OBJECT FileObject;
PIO_COMPLETION_ROUTINE CompletionRoutine;
PVOID Context;
} IO_STACK_LOCATION, *PIO_STACK_LOCATION;I/O 请求流程：
应用程序
│
│ WriteFile()
▼
NTDLL.DLL
│
│ NtWriteFile()
▼
内核模式
│
▼
系统服务调度器
│
▼
I/O 管理器
│
├──► 创建 IRP
│
├──► 调用设备驱动程序
│ │
│ ▼
│ 驱动程序栈
│ ├── 上层过滤器驱动
│ ├── 功能驱动 (FDO)
│ └── 下层过滤器驱动
│ │
│ ▼
│ 总线驱动 (PDO)
│ │
│ ▼
│ 硬件抽象层 (HAL)
│ │
│ ▼
│ 硬件设备
│
▼
完成 I/O 请求
│
▼
返回应用程序微内核 (Kernel)
Windows 内核（微内核部分）提供最基本的操作系统功能：
1. 线程调度
Windows 使用基于优先级的抢占式多任务调度器。
// 调度优先级 (0-31)
#define LOW_PRIORITY 0
#define LOW_REALTIME_PRIORITY 16
#define HIGH_PRIORITY 31
#define MAXIMUM_PRIORITY 32
// 线程调度数据结构
typedef struct _KPRCB {
// 处理器控制块
struct _KTHREAD *CurrentThread;
struct _KTHREAD *NextThread;
struct _KTHREAD *IdleThread;
// 就绪队列 (按优先级)
struct _LIST_ENTRY DispatcherReadyListHead[MAXIMUM_PRIORITY];
// 处理器状态
ULONG Number;
ULONG SetMember;
// ... 其他字段
} KPRCB, *PKPRCB;
// 线程调度器函数
VOID KiScheduler(VOID);
VOID KiDispatchInterrupt(VOID);
VOID KiQuantumEnd(VOID);调度算法：
- 时间片轮转：相同优先级线程之间的时间片分配
- 优先级提升：I/O 完成、信号量等待等情况下临时提升优先级
- 优先级继承：解决优先级反转问题
- 处理器亲和性：控制线程在哪些 CPU 上运行
2. 中断和异常处理
// 中断请求级别 (IRQL)
typedef enum _KIRQL {
PASSIVE_LEVEL = 0, // 被动级别
APC_LEVEL = 1, // APC 级别
DISPATCH_LEVEL = 2, // 调度级别
CMCI_LEVEL = 5, // 可纠正机器检查中断
DEVICE_LEVEL = 3, // 设备中断级别 (3-11)
// ...
PROFILE_LEVEL = 15, // 性能分析定时器
CLOCK_LEVEL = 13, // 时钟中断
IPI_LEVEL = 14, // 处理器间中断
DRS_LEVEL = 14, // 延迟过程调用
POWER_LEVEL = 14, // 电源故障
HIGH_LEVEL = 15, // 最高级别
} KIRQL;
// 异常记录
typedef struct _EXCEPTION_RECORD {
NTSTATUS ExceptionCode;
ULONG ExceptionFlags;
struct _EXCEPTION_RECORD *ExceptionRecord;
PVOID ExceptionAddress;
ULONG NumberParameters;
ULONG_PTR ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS];
} EXCEPTION_RECORD, *PEXCEPTION_RECORD;IRQL 层次结构：
IRQL 15 (HIGH_LEVEL) ─┐
│ 不可屏蔽中断
IRQL 14 (IPI_LEVEL) ─┤
│
IRQL 13 (CLOCK_LEVEL) ─┤
│ 设备中断
IRQL 3-12 (DEVICE_LEVEL) ─┤
│
IRQL 2 (DISPATCH_LEVEL) ─┤ DPC / 调度
│
IRQL 1 (APC_LEVEL) ─┤ APC
│
IRQL 0 (PASSIVE_LEVEL) ─┘ 用户模式 / 普通内核模式硬件抽象层 (HAL)
HAL 提供硬件无关的接口，使内核和驱动程序不需要直接处理硬件差异。
// HAL 提供的核心功能
// 中断管理
BOOLEAN HalEnableSystemInterrupt(
ULONG Vector,
KIRQL Irql,
KINTERRUPT_MODE InterruptMode
);
VOID HalDisableSystemInterrupt(
ULONG Vector,
KIRQL Irql
);
// DMA 操作
PVOID HalAllocateCommonBuffer(
PADAPTER_OBJECT AdapterObject,
ULONG Length,
PPHYSICAL_ADDRESS LogicalAddress,
BOOLEAN CacheEnabled
);
// 处理器间通信
VOID HalRequestIpi(
KAFFINITY TargetProcessors
);
// 电源管理
VOID HalReturnToFirmware(
FIRMWARE_REENTRY Action
);用户模式架构
环境子系统
Windows 支持多种环境子系统，允许运行不同类型的应用程序：
1. Win32 子系统 (CSRSS)
Win32 子系统是 Windows 的主子系统，负责管理控制台窗口、进程/线程创建等。
CSRSS (Client/Server Runtime Subsystem)
├── 控制台管理
│ ├── 控制台窗口创建
│ ├── 输入/输出处理
│ └── 屏幕缓冲区管理
├── 进程/线程管理
│ ├── 创建进程通知
│ └── 线程创建支持
├── 关机管理
│ └── 系统关机协调
└── 其他支持功能
├── DOS 设备映射
└── 临时文件管理2. WOW64 子系统
WOW64 (Windows-on-Windows 64-bit) 允许在 64 位 Windows 上运行 32 位应用程序。
WOW64 架构
┌─────────────────────────────────────┐
│ 32位应用程序 │
├─────────────────────────────────────┤
│ WOW64 DLLs (32位) │
│ ├── WOW64.DLL (核心接口) │
│ ├── WOW64WIN.DLL (窗口管理) │
│ └── WOW64CPU.DLL (CPU 模拟) │
├─────────────────────────────────────┤
│ WOW64 DLLs (64位) │
│ ├── WOW64.DLL (核心转换) │
│ └── 系统调用转换层 │
├─────────────────────────────────────┤
│ 64位内核 │
└─────────────────────────────────────┘地址空间布局：
32位应用程序在64位Windows上的地址空间
┌──────────────────────────────────────┐ 0x00000000
│ 空指针赋值区 (64KB) │
├──────────────────────────────────────┤ 0x00010000
│ 用户代码和数据 │
│ │
│ │
├──────────────────────────────────────┤ ~0x7FFE0000
│ 系统共享页面 │
├──────────────────────────────────────┤ 0x7FFE1000
│ 系统保留区 │
├──────────────────────────────────────┤ 0x80000000
│ 内核模式空间 (WOW64) │
│ (32位内核视图) │
└──────────────────────────────────────┘ 0xFFFFFFFF3. WSL (Windows Subsystem for Linux)
WSL 允许在 Windows 上运行 Linux 二进制可执行文件。
WSL 架构 (WSL2)
┌─────────────────────────────────────┐
│ Linux 用户空间 │
│ ├── Bash / Zsh │
│ ├── GNU 工具链 │
│ └── Linux 应用程序 │
├─────────────────────────────────────┤
│ Linux 内核 (真实内核) │
│ (通过轻量级 VM 运行) │
├─────────────────────────────────────┤
│ 虚拟化层 │
│ ├── Hyper-V │
│ └── 虚拟化设备 │
├─────────────────────────────────────┤
│ Windows 主机 │
└─────────────────────────────────────┘系统 DLL
1. NTDLL.DLL
NTDLL 是 Windows 原生 API 的载体，是所有子系统的基础。
// 原生 API 示例 - 进程创建
NTSTATUS NtCreateUserProcess(
OUT PHANDLE ProcessHandle,
OUT PHANDLE ThreadHandle,
IN ACCESS_MASK ProcessDesiredAccess,
IN ACCESS_MASK ThreadDesiredAccess,
IN POBJECT_ATTRIBUTES ProcessObjectAttributes OPTIONAL,
IN POBJECT_ATTRIBUTES ThreadObjectAttributes OPTIONAL,
IN ULONG ProcessFlags,
IN ULONG ThreadFlags,
IN PRTL_USER_PROCESS_PARAMETERS ProcessParameters,
IN OUT PPS_CREATE_INFO CreateInfo,
IN PPS_ATTRIBUTE_LIST AttributeList OPTIONAL
);
// 内存管理
NTSTATUS NtAllocateVirtualMemory(
IN HANDLE ProcessHandle,
IN OUT PVOID *BaseAddress,
IN ULONG_PTR ZeroBits,
IN OUT PSIZE_T RegionSize,
IN ULONG AllocationType,
IN ULONG Protect
);
// 对象管理
NTSTATUS NtOpenSection(
OUT PHANDLE SectionHandle,
IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes
);2. KERNEL32.DLL / KERNELBASE.DLL
提供 Win32 API 的核心功能。
// 进程和线程
HANDLE CreateProcessW(
LPCWSTR lpApplicationName,
LPWSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL bInheritHandles,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCWSTR lpCurrentDirectory,
LPSTARTUPINFOW lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation
);
// 内存管理
LPVOID VirtualAlloc(
LPVOID lpAddress,
SIZE_T dwSize,
DWORD flAllocationType,
DWORD flProtect
);
// 同步
HANDLE CreateMutexW(
LPSECURITY_ATTRIBUTES lpMutexAttributes,
BOOL bInitialOwner,
LPCWSTR lpName
);
DWORD WaitForSingleObject(
HANDLE hHandle,
DWORD dwMilliseconds
);COM (Component Object Model)
COM 是 Windows 的组件对象模型，是 Windows 编程的核心技术之一。
COM 基础架构
COM 架构
┌─────────────────────────────────────────┐
│ COM 客户端 │
│ (调用 COM 接口的应用程序) │
├─────────────────────────────────────────┤
│ COM 代理/存根 (Proxy/Stub) │
│ (跨进程/跨机器通信支持) │
├─────────────────────────────────────────┤
│ COM 运行库 │
│ ├── 类工厂 (Class Factory) │
│ ├── 接口查询 (QueryInterface) │
│ ├── 引用计数 (AddRef/Release) │
│ └── 封送处理 (Marshaling) │
├─────────────────────────────────────────┤
│ COM 服务器 │
│ (实现 COM 对象的 DLL 或 EXE) │
├─────────────────────────────────────────┤
│ 注册表 │
│ (CLSID、IID、ProgID 等注册信息) │
└─────────────────────────────────────────┘COM 核心接口
// IUnknown - 所有 COM 接口的基接口
interface IUnknown {
HRESULT QueryInterface(
[in] REFIID riid,
[out, iid_is(riid)] void **ppvObject
);
ULONG AddRef(void);
ULONG Release(void);
};
// IClassFactory - 类工厂接口
interface IClassFactory : IUnknown {
HRESULT CreateInstance(
[in, unique] IUnknown *pUnkOuter,
[in] REFIID riid,
[out, iid_is(riid)] void **ppvObject
);
HRESULT LockServer([in] BOOL fLock);
};
// IDispatch - 自动化接口
interface IDispatch : IUnknown {
HRESULT GetTypeInfoCount([out] UINT *pctinfo);
HRESULT GetTypeInfo(
[in] UINT iTInfo,
[in] LCID lcid,
[out] ITypeInfo **ppTInfo
);
HRESULT GetIDsOfNames(
[in] REFIID riid,
[in, size_is(cNames)] LPOLESTR *rgszNames,
[in] UINT cNames,
[in] LCID lcid,
[out, size_is(cNames)] DISPID *rgDispId
);
HRESULT Invoke(
[in] DISPID dispIdMember,
[in] REFIID riid,
[in] LCID lcid,
[in] WORD wFlags,
[in, out] DISPPARAMS *pDispParams,
[out] VARIANT *pVarResult,
[out] EXCEPINFO *pExcepInfo,
[out] UINT *puArgErr
);
}COM 使用示例
// 定义 COM 接口
interface __declspec(uuid("12345678-1234-1234-1234-123456789012"))
IMyInterface : public IUnknown {
virtual HRESULT STDMETHODCALLTYPE DoSomething() = 0;
virtual HRESULT STDMETHODCALLTYPE GetData(
[out] BSTR *data
) = 0;
};
// 实现 COM 类
class CMyObject : public IMyInterface {
private:
LONG m_refCount;
public:
CMyObject() : m_refCount(1) {}
// IUnknown 实现
STDMETHODIMP QueryInterface(REFIID riid, void **ppv) {
if (riid == IID_IUnknown || riid == __uuidof(IMyInterface)) {
*ppv = static_cast<IMyInterface*>(this);
AddRef();
return S_OK;
}
*ppv = nullptr;
return E_NOINTERFACE;
}
STDMETHODIMP_(ULONG) AddRef() {
return InterlockedIncrement(&m_refCount);
}
STDMETHODIMP_(ULONG) Release() {
LONG count = InterlockedDecrement(&m_refCount);
if (count == 0) {
delete this;
}
return count;
}
// IMyInterface 实现
STDMETHODIMP DoSomething() {
// 实现功能
return S_OK;
}
STDMETHODIMP GetData(BSTR *data) {
*data = SysAllocString(L"Hello COM");
return S_OK;
}
};
// 类工厂实现
class CMyClassFactory : public IClassFactory {
// ... 实现 CreateInstance 和 LockServer
};
// 客户端使用 COM 对象
void UseCOMObject() {
HRESULT hr;
IMyInterface *pInterface = nullptr;
// 初始化 COM
hr = CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED);
if (FAILED(hr)) return;
// 创建 COM 对象
hr = CoCreateInstance(
__uuidof(MyObjectClass), // CLSID
nullptr, // 不聚合
CLSCTX_INPROC_SERVER, // 进程内服务器
__uuidof(IMyInterface), // IID
reinterpret_cast<void**>(&pInterface)
);
if (SUCCEEDED(hr)) {
// 使用接口
pInterface->DoSomething();
BSTR data;
pInterface->GetData(&data);
SysFreeString(data);
// 释放接口
pInterface->Release();
}
// 反初始化 COM
CoUninitialize();
}COM 线程模型
COM 线程模型
单线程单元 (STA - Single-Threaded Apartment)
┌─────────────────────────────────────┐
│ 线程 1 (STA) │
│ ├── 消息循环 (用于封送) │
│ └── COM 对象 A, B, C │
└─────────────────────────────────────┘
┌─────────────────────────────────────┐
│ 线程 2 (STA) │
│ ├── 消息循环 │
│ └── COM 对象 D, E │
└─────────────────────────────────────┘
多线程单元 (MTA - Multi-Threaded Apartment)
┌─────────────────────────────────────┐
│ 线程池 (MTA) │
│ ├── 线程 1 ──► COM 对象 A │
│ ├── 线程 2 ──► COM 对象 B │
│ └── 线程 3 ──► COM 对象 C │
│ (直接调用，无需封送) │
└─────────────────────────────────────┘Windows 驱动程序模型
WDM (Windows Driver Model)
WDM 驱动程序栈
┌─────────────────────────────────────┐
│ 用户模式应用程序 │
├─────────────────────────────────────┤
│ I/O 管理器 │
├─────────────────────────────────────┤
│ 过滤器驱动 (Filter Driver) │
│ (可选，如杀毒软件过滤) │
├─────────────────────────────────────┤
│ 功能驱动 (Function Driver - FDO) │
│ (主要设备功能实现) │
├─────────────────────────────────────┤
│ 总线驱动 (Bus Driver - PDO) │
│ (枚举和管理设备) │
├─────────────────────────────────────┤
│ 根总线驱动 (Root Bus Driver) │
├─────────────────────────────────────┤
│ 硬件抽象层 (HAL) │
├─────────────────────────────────────┤
│ 硬件设备 │
└─────────────────────────────────────┘KMDF (Kernel-Mode Driver Framework)
// KMDF 驱动程序基本结构
// 驱动入口
NTSTATUS DriverEntry(
PDRIVER_OBJECT DriverObject,
PUNICODE_STRING RegistryPath
) {
WDF_DRIVER_CONFIG config;
NTSTATUS status;
WDF_DRIVER_CONFIG_INIT(&config, EvtDeviceAdd);
status = WdfDriverCreate(
DriverObject,
RegistryPath,
WDF_NO_OBJECT_ATTRIBUTES,
&config,
WDF_NO_HANDLE
);
return status;
}
// 设备添加回调
NTSTATUS EvtDeviceAdd(
WDFDRIVER Driver,
PWDFDEVICE_INIT DeviceInit
) {
NTSTATUS status;
WDFDEVICE device;
status = WdfDeviceCreate(
&DeviceInit,
WDF_NO_OBJECT_ATTRIBUTES,
&device
);
if (!NT_SUCCESS(status)) {
return status;
}
// 创建 I/O 队列
WDF_IO_QUEUE_CONFIG queueConfig;
WDFQUEUE queue;
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(
&queueConfig,
WdfIoQueueDispatchParallel
);
queueConfig.EvtIoRead = EvtIoRead;
queueConfig.EvtIoWrite = EvtIoWrite;
status = WdfIoQueueCreate(
device,
&queueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&queue
);
return status;
}
// I/O 处理回调
VOID EvtIoRead(
WDFQUEUE Queue,
WDFREQUEST Request,
size_t Length
) {
NTSTATUS status;
PVOID buffer;
size_t bytesRead = 0;
status = WdfRequestRetrieveOutputBuffer(
Request,
Length,
&buffer,
NULL
);
if (NT_SUCCESS(status)) {
// 执行读取操作
// ...
bytesRead = /* 实际读取的字节数 */;
}
WdfRequestCompleteWithInformation(Request, status, bytesRead);
}安全架构
安全引用监视器 (SRM)
SRM 负责执行对象访问的安全检查。
访问检查流程
┌─────────────────────────────────────┐
│ 应用程序请求访问对象 │
│ OpenProcess(PROCESS_ALL_ACCESS, │
│ FALSE, targetPid) │
└─────────────┬───────────────────────┘
│
▼
┌─────────────────────────────────────┐
│ 对象管理器 │
│ 解析对象名，找到对象 │
└─────────────┬───────────────────────┘
│
▼
┌─────────────────────────────────────┐
│ 安全引用监视器 (SRM) │
│ 执行访问检查 │
│ ├── 获取对象的安全描述符 │
│ ├── 获取调用者的访问令牌 │
│ ├── 检查 DACL (自主访问控制列表) │
│ └── 检查 SACL (系统访问控制列表) │
└─────────────┬───────────────────────┘
│
┌─────┴─────┐
│ │
▼ ▼
┌─────────┐ ┌─────────┐
│ 允许 │ │ 拒绝 │
│ 访问 │ │ 访问 │
└─────────┘ └─────────┘访问令牌
// 访问令牌结构（简化）
typedef struct _TOKEN {
TOKEN_SOURCE TokenSource; // 令牌来源
LUID TokenId; // 令牌唯一标识
LUID AuthenticationId; // 认证会话标识
LARGE_INTEGER ExpirationTime; // 过期时间
LUID ModifiedId; // 修改标识
ULONG UserAndGroupCount; // 用户和组数量
ULONG PrivilegeCount; // 特权数量
ULONG VariableLength; // 可变长度数据
// ...
SID_AND_ATTRIBUTES User; // 用户 SID
SID_AND_ATTRIBUTES Groups[ANYSIZE_ARRAY]; // 组 SID 数组
LUID_AND_ATTRIBUTES Privileges[ANYSIZE_ARRAY]; // 特权数组
} TOKEN, *PTOKEN;
// 安全描述符
typedef struct _SECURITY_DESCRIPTOR {
UCHAR Revision;
UCHAR Sbz1;
SECURITY_DESCRIPTOR_CONTROL Control; // 控制标志
PSID Owner; // 所有者 SID
PSID Group; // 主组 SID
PACL Sacl; // 系统 ACL
PACL Dacl; // 自主 ACL
} SECURITY_DESCRIPTOR, *PSECURITY_DESCRIPTOR;总结
Windows 操作系统架构是一个复杂而精密的系统，主要特点包括：
核心设计理念
- 分层架构：清晰的内核模式/用户模式分离，确保系统稳定性
- 对象管理：统一的对象模型，所有资源都是对象
- 可扩展性：通过驱动程序模型和子系统支持多种硬件和应用类型
- 安全性：完善的安全架构，从内核到应用层的全面保护
关键组件回顾
- 执行体：提供高级系统服务（进程、内存、I/O 管理）
- 微内核：核心调度、中断和同步机制
- HAL：硬件抽象，确保可移植性
- 子系统：支持多种应用环境（Win32、WSL、WOW64）
- COM：组件对象模型，实现软件组件化
学习建议
- 阅读官方文档：Windows Driver Kit (WDK) 和 Windows Internals 书籍
- 实践驱动开发：从简单的 KMDF 驱动开始
- 使用调试工具：WinDbg、Process Monitor、Process Explorer
- 研究开源实现：ReactOS 项目提供了 Windows 架构的开源参考
Windows 架构的深入理解对于系统编程、驱动开发、安全研究和性能优化都至关重要。希望本文能为你提供一个全面的技术视角。
参考资源：
- Windows Internals, Part 1 & 2 (Microsoft Press)
- Windows Driver Kit (WDK) 文档
- Microsoft Learn - Windows 开发文档
- ReactOS 项目 (reactos.org)