Fix it now
0x000000D1 is a kernel-mode driver accessing pageable memory while the IRQL was too high. 0x0000000A is Windows or a driver accessing paged memory at an invalid address at a raised IRQL, and Microsoft attributes it to drivers using improper addresses. Either way the work is to name the driver from the dump and replace it.
!analyze -v
ln <parameter 4 address>
verifier /querysettings
- Note the stop code and any file name ending in
.syson the blue screen. That name is the most useful single clue you will get. - Confirm dumps are being written: Settings, System, About, Advanced system settings, Startup and Recovery, and set Write debugging information to a small or automatic memory dump.
- Collect the newest file from
C:\Windows\Minidumpafter the next crash and open it in WinDbg. - Run
!analyze -v, then runlnon parameter 4 – Microsoft names that command for resolving the address that referenced memory into a function name. - Update that driver from the hardware manufacturer’s own download page. If it belongs to add-on software such as a VPN client, backup agent or security product, uninstall the product as a test rather than only updating it.
If you get 0x000000D5 or 0x000000D6, Driver Verifier’s Special Pool is switched on. Check with verifier /querysettings and clear it with verifier /reset when the testing is finished.
If the crashes stop after the driver is replaced, you are done. If not, the next section covers how to read the parameters and narrow it further.
Why it happens
Windows runs kernel code at different interrupt request levels. Above DISPATCH_LEVEL the memory manager cannot service a page fault, because the code that would fetch the page from disk cannot itself run. A driver that touches pageable memory at that level therefore causes an immediate unrecoverable fault: there is no way to satisfy the access and no safe way to continue.
Microsoft lists three ways a driver gets there: dereferencing a bad pointer such as a NULL or freed pointer while executing at or above DISPATCH_LEVEL, accessing pageable data at or above DISPATCH_LEVEL, and executing pageable code at or above DISPATCH_LEVEL. The page fault behind it usually comes from a function marked pageable that ran at an elevated IRQL, a call into another driver that had been unloaded, or a call made through an invalid function pointer.
The parameters are readable. For 0xD1: parameter 1 is the memory referenced, parameter 2 the IRQL at the time, parameter 3 the operation (0 read, 1 write, 2 execute, 8 execute), and parameter 4 the address that referenced the memory – which is what ln turns into a function name. For 0xA the shape is slightly different: parameter 3 is a bit field where bit 0 is read or write and bit 3 is execute, so the combined values are 0x0 read, 0x1 write and 0x8 execute.
One triage rule is worth memorising because it costs nothing. If parameter 1 is less than 0x1000, the issue is likely a NULL pointer dereference. That will not tell you which driver, but it does tell you the fault is a coding error rather than the memory going bad, which changes what you do next.
A third-party filter driver is at fault
You have this one if !analyze -v names a .sys file belonging to a security product, VPN client, backup agent or disk encryption tool.
- Uninstall that product as a test rather than updating it. A driver from a half-removed or expired product does not stop loading because the product stopped working.
- If the crashes stop, reinstall the current supported build from the vendor and re-test.
fltmclists the loaded minifilter drivers, which is a quick way to see what is layered into the file system.
A hardware driver is stale or mismatched
You have this one if The named module belongs to a network adapter, storage controller or graphics adapter, and the machine was recently updated.
- Get the driver from the hardware manufacturer’s own download page, not from a driver updater utility.
pnputil /enum-driverslists what is staged in the driver store, with the oem#.inf name for each.- Remove a bad one with
pnputil /delete-driver <oem#.inf> /uninstall, then install the vendor’s package.
Driver Verifier is on and doing its job
You have this one if 0x000000D5 or 0x000000D6 rather than 0xD1, possibly with a boot loop.
- 0xD5 is DRIVER_PAGE_FAULT_IN_FREED_SPECIAL_POOL: Special Pool caught a driver referencing memory that was earlier freed.
- 0xD6 is DRIVER_PAGE_FAULT_BEYOND_END_OF_ALLOCATION: the driver allocated n bytes and referenced more than n.
- Both are results, not mysteries.
verifier /querysettingsshows what is enabled andverifier /resetclears it.
These two identify a genuinely defective driver. Clearing Verifier stops the crashes but does not make the driver correct – report it to the vendor.
The IRQL itself is wrong
You have this one if 0x000000C8, IRQL_UNEXPECTED_VALUE, rather than either of the above.
- Microsoft’s cause is a driver or lower-level program that changed the IRQL for some period and did not restore it – the classic case being acquiring a spin lock and failing to release it.
- Parameter 1 encodes the current IRQL, the expected IRQL and a unique value, so the debugger can say what was expected where.
- There is no configuration fix. Identify the driver and replace it.
Full reference
Parameters, by bug check
| Bug check | Parameter 1 | Parameter 2 | Parameter 3 | Parameter 4 |
|---|---|---|---|---|
0x000000D1 |
Memory referenced | IRQL at time of reference | 0 read, 1 write, 2 execute, 8 execute | Address that referenced memory – use ln on it |
0x0000000A |
Virtual address that could not be accessed | IRQL at the fault | Bit field: 0x0 read, 0x1 write, 0x8 execute | Instruction pointer at the fault – use ln on it |
0x000000D5 |
Memory address referenced | 0 read, 1 write | Address that referenced memory, if known | Reserved |
0x000000D6 |
Memory address referenced | 0 read, 1 write | Address that referenced memory, if known | Reserved |
0x000000C8 |
(Current IRQL << 16) | (Expected IRQL << 8) | UniqueValue | Depends on UniqueValue | Depends on UniqueValue | Depends on UniqueValue |
Debugger commands that earn their keep
| Command | What it gives you |
|---|---|
!analyze -v |
The bug check breakdown, including the module it holds probably responsible |
ln <address> |
The nearest symbols to an address – the documented way to turn parameter 4 into a function name |
!pool <address> |
Whether parameter 1 is paged pool, which tells you the IRQL was too high to touch it |
!pte <address> |
The page table entry, for judging whether an address is valid at all |
!address <address> |
What region of memory an address belongs to |
k, kb |
The call stack, which is where the driver actually shows itself |
Microsoft’s own way to categorise the fault
- Parameter 1 below 0x1000 is likely a NULL pointer dereference.
- If
!poolreports parameter 1 as paged pool or other pageable memory, the IRQL was too high to access that data. - If parameter 3 indicates an attempt to execute pageable code, the IRQL was too high to call that function.
- Otherwise it may be a bad pointer from use-after-free or bit-flipping, which is what
!pte,!addressandlnare for.
Driver Verifier without breaking the machine
- Verify the smallest possible set of drivers. The overhead is real and verifying everything makes the machine unusable.
- Know how to get back before you start: Safe Mode, then
verifier /resetfrom an elevated prompt. verifier /querysettingstells you what is currently enabled, which matters when you inherit a machine that boot-loops for no obvious reason.- Treat a 0xD5 or 0xD6 as a finding to report to the driver’s vendor, not as a machine fault to work around.
When the dump blames a different module every time
- Suspect memory. Windows Memory Diagnostic (
mdsched) is built in; run the manufacturer’s own diagnostics as well where the machine has them. - Repair the system files:
sfc /scannow, thenDISM /Online /Cleanup-Image /RestoreHealth. - Check for an overclock or an XMP/EXPO memory profile and take the machine back to defaults for the test.
- Look at what all the named modules have in common – several different drivers failing at once often means one filter sitting underneath all of them.
- Check the System log in Event Viewer for errors in the same time window. A storage or firmware error there reframes the whole investigation.
Every code this article covers
| Code | What it points at | Source |
|---|---|---|
0x000000D1 |
DRIVER_IRQL_NOT_LESS_OR_EQUAL: a kernel-mode driver attempted to access pageable memory while the process IRQL was too high | Microsoft Learn |
0x0000000A |
IRQL_NOT_LESS_OR_EQUAL: Windows or a kernel-mode driver accessed paged memory at an invalid address while at a raised IRQL. Microsoft attributes it to kernel-mode device drivers that use improper addresses | Microsoft Learn |
0x000000D5 |
DRIVER_PAGE_FAULT_IN_FREED_SPECIAL_POOL: a driver referenced memory that was earlier freed, caught by Driver Verifier’s Special Pool option | Microsoft Learn |
0x000000D6 |
DRIVER_PAGE_FAULT_BEYOND_END_OF_ALLOCATION: the driver allocated n bytes and referenced more than n, caught by Special Pool | Microsoft Learn |
0x000000C8 |
IRQL_UNEXPECTED_VALUE: the processor’s IRQL is not what it should be, usually because a driver changed it and did not restore it – the classic case being an unreleased spin lock | Microsoft Learn |
Confirm the fix worked
- The machine runs through the workload that used to crash it without a new dump appearing in
C:\Windows\Minidump. verifier /querysettingsreports no drivers being verified, if you had turned Verifier on.- Device Manager shows the replaced driver at the version you installed, not the one Windows Update chose.
- The System log has no new errors from the same device in the window you tested.
Questions people ask about this
The blue screen names a Windows file like ntoskrnl.exe. Is Windows the problem?
Usually not. The module on the screen is where the fault surfaced, not necessarily where it originated – a driver can corrupt state that a kernel routine then trips over. Read the call stack in the dump rather than the name on the screen.
What is the difference between 0xD1 and 0xA?
0xD1 is specifically attributed to a kernel-mode driver accessing pageable memory at too high an IRQL. 0xA is the broader case: Windows or a driver accessing paged memory at an invalid address at a raised IRQL, with a bad pointer or a pageability problem as the typical cause. The triage is the same; the parameter 3 encoding differs.
Should I use a driver updater utility?
No. Get drivers from the hardware manufacturer for the exact model. Third-party updaters routinely install a generic driver for a similar chipset, which is a good way to turn one crash into a different one.
I keep getting 0xD5 and I never turned Verifier on.
Somebody did, or a support process left it enabled. Special Pool is a Driver Verifier option and 0xD5 comes from it. Run verifier /querysettings from an elevated prompt to see what is enabled, and verifier /reset to clear it.
