Skip to content

Est. 2011ยทMicrosoft Partner ID 7033487ยทDelivery under 3 minยทSupport 7 days a week

Your vault is empty.

Free Fix 0x000000D1

DRIVER_IRQL_NOT_LESS_OR_EQUAL 0x000000D1 and IRQL_NOT_LESS_OR_EQUAL 0x0000000A

10 min read Updated October 5, 2026 Windows Crashes & Boot Recovery

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.

The first two in WinDbg with the dump open; verifier at an elevated Command Prompt

!analyze -v
ln <parameter 4 address>
verifier /querysettings
  1. Note the stop code and any file name ending in .sys on the blue screen. That name is the most useful single clue you will get.
  2. 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.
  3. Collect the newest file from C:\Windows\Minidump after the next crash and open it in WinDbg.
  4. Run !analyze -v, then run ln on parameter 4 – Microsoft names that command for resolving the address that referenced memory into a function name.
  5. 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.

  1. 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.
  2. If the crashes stop, reinstall the current supported build from the vendor and re-test.
  3. fltmc lists 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.

  1. Get the driver from the hardware manufacturer’s own download page, not from a driver updater utility.
  2. pnputil /enum-drivers lists what is staged in the driver store, with the oem#.inf name for each.
  3. 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.

  1. 0xD5 is DRIVER_PAGE_FAULT_IN_FREED_SPECIAL_POOL: Special Pool caught a driver referencing memory that was earlier freed.
  2. 0xD6 is DRIVER_PAGE_FAULT_BEYOND_END_OF_ALLOCATION: the driver allocated n bytes and referenced more than n.
  3. Both are results, not mysteries. verifier /querysettings shows what is enabled and verifier /reset clears 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.

  1. 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.
  2. Parameter 1 encodes the current IRQL, the expected IRQL and a unique value, so the debugger can say what was expected where.
  3. 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 !pool reports 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, !address and ln are for.

Driver Verifier without breaking the machine

  1. Verify the smallest possible set of drivers. The overhead is real and verifying everything makes the machine unusable.
  2. Know how to get back before you start: Safe Mode, then verifier /reset from an elevated prompt.
  3. verifier /querysettings tells you what is currently enabled, which matters when you inherit a machine that boot-loops for no obvious reason.
  4. 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, then DISM /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

  1. The machine runs through the workload that used to crash it without a new dump appearing in C:\Windows\Minidump.
  2. verifier /querysettings reports no drivers being verified, if you had turned Verifier on.
  3. Device Manager shows the replaced driver at the version you installed, not the one Windows Update chose.
  4. 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.

Related error codes

Was this article helpful?

Your feedback helps us improve our documentation.

Related articles

Free Fix Windows RE update fails with 0x80070643 – recovery partition too small License Error BAD_POOL_HEADER 0x00000019 and BAD_POOL_CALLER 0x000000C2 explained License Error SYSTEM_THREAD_EXCEPTION_NOT_HANDLED 0x0000007E on Windows 10 and 11 License Error NPFS_FILE_SYSTEM 0x00000025 and cache manager crashes on file servers
โ† Back to Knowledge Base