Fix it now
0x000000C4 is Driver Verifier stopping the machine on purpose because a driver it was told to watch broke a rule. Clearing Verifier gets the machine booting again; the driver it named still needs dealing with afterwards.
verifier /querysettings
verifier /reset
- Note the stop code and, if the screen shows one, the What failed module. Current Windows 10 and 11 stop screens do not display the four bug check parameters, so do not expect them.
- Get to the recovery menu. After two consecutive failed starts Windows brings up the recovery environment on its own, so a boot loop usually offers it without media. From a machine that still starts, hold Shift while choosing Restart.
- Choose Troubleshoot, then Advanced options, then Startup Settings, then Restart, and press 4 for Safe Mode.
- Run the two commands above.
verifier /querysettingsrecords what was configured before you destroy the evidence;verifier /resetclears it. - Restart normally. Verifier settings only change on a restart, so the loop stops on the next boot rather than immediately.
- Confirm with
verifier /querysettingsonce Windows is up. It should report that no settings are active.
Do not type verifier /reset at the recovery environment command prompt. It acts on the recovery image that is running, not on the installed Windows, and it will look like it worked.
If the machine boots and querysettings comes back empty, the emergency is over. The next section explains what Verifier caught and why Safe Mode sometimes crashes too.
Why it happens
Driver Verifier is a test harness built into Windows. It does not load drivers and it is not a scanner. It wraps drivers you nominate in extra checking: allocations come from special pool with a guard page after them, IRQL use is audited, I/O request packets are tracked, DMA operations are validated, and cleanup is checked. When one of those rules is broken it stops the machine immediately, on purpose, so the guilty driver is still on the stack. Microsoft is explicit that it should only be run on computers used for testing and debugging.
0x000000C4 is the general code for fatal errors Verifier finds. Parameter 1 identifies which rule was broken and the meaning of parameters 2 to 4 changes with it, which is why the number on its own tells you very little. Those parameters are in the dump, not on the stop screen: open %SystemRoot%\MEMORY.DMP or the newest file in %SystemRoot%\Minidump and run !analyze -v. Where the violation is a DDI compliance rule, the debugger prints a !ruleinfo link that names the rule outright.
Verifier’s configuration lives in the registry and is read early in startup, which is why an ordinary restart does not escape it. Safe Mode usually does, but not for the reason most guides give. Verifier is still enabled in Safe Mode; what helps is that Safe Mode loads only a minimal set of drivers, so a flagged third-party driver never loads and so is never verified. If the flagged driver is one Safe Mode does load – a storage or volume filter, for instance – Safe Mode bug checks as well, and you need the offline route below.
Verifier was left switched on after a debugging session
You have this one if You or a support engineer enabled it to chase an earlier crash, nobody turned it off, and now every boot ends in 0xC4.
- Boot Safe Mode and run
verifier /querysettingsto record what was configured. - Run
verifier /resetand restart. The change only takes effect on the next boot. - Write down the driver that was flagged before you move on. It was flagged for a reason.
- If you will run Verifier again, add
verifier /bootmode resetonbootfailwhen you enable it, so Verifier turns itself off if the machine fails to start.
verifier /bootmode oneboot enables the settings for the next start only, and resetonunusualshutdown keeps them until an unusual shutdown. Both are documented, and both remove the risk of arriving here again.
Safe Mode bug checks as well, so you cannot reach a prompt
You have this one if Every startup option ends in the same stop code, Safe Mode included. That means the flagged driver is one Safe Mode loads.
- Boot the recovery environment and try System Restore first. A restore point from before Verifier was enabled rolls the registry back and needs no hand editing.
- If there is no restore point, open a recovery Command Prompt and run
diskpart, thenlist volume, to find the letter your Windows partition has been given. In recovery it is often not C. - Open
regedit, select HKEY_LOCAL_MACHINE, and use File then Load Hive to load<OSdrive>:\Windows\System32\config\SYSTEMunder a temporary name. - Read Select\Default in the loaded hive to see which ControlSet is live, then clear
VerifyDriversandVerifyDriverLevelunder that ControlSet’s Control\Session Manager\Memory Management key. - Unload the hive before restarting, then confirm with
verifier /querysettingsonce Windows boots.
The driver really is broken and Verifier is right
You have this one if The same third-party driver is named every time, and the machine was already unstable before anyone enabled Verifier.
- Install the current build from the hardware or software vendor.
- If there is no newer build, roll back to the version that was stable, or remove the product that supplies the driver.
- Remove the package rather than just disabling the device:
pnputil /enum-driverslists installed driver packages by their published oem name, andpnputil /delete-driver <oem#.inf> /uninstallremoves one. - Once it is replaced, verify that one driver deliberately with
verifier /standard /driver name.syson a test machine and confirm the violation has gone.
Verifier was pointed at every driver at once
You have this one if The machine crashes almost immediately at start-up and the flagged module differs between attempts. verifier /querysettings shows *.sys or an all-drivers configuration.
- Reset, then re-enable against named third-party drivers only rather than using
verifier /all. - Use
verifier /standard /driver name.sys. The standard set already includes special pool, IRQL checking, pool tracking, I/O verification, deadlock detection, DMA verification, WDF verification, security checks and DDI compliance checking. - Add the aggressive options such as randomised low resources simulation only after the standard set has found nothing.
Verifying Microsoft’s own drivers alongside everything else adds heavy overhead and produces noise. Microsoft’s advice is to verify the smallest number of drivers you can.
Full reference
The verifier command, in the forms worth knowing
| Command | What it does | Takes effect |
|---|---|---|
verifier |
Opens Driver Verifier Manager | On restart |
verifier /querysettings |
Reports which drivers and options are configured | Immediately, read-only |
verifier /reset |
Clears all settings; no drivers verified afterwards | After the next boot |
verifier /standard /driver name.sys |
Standard checks against one named driver | After the next boot |
verifier /all |
Verifies every installed driver | After the next boot |
verifier /bootmode resetonbootfail |
Disables Verifier for subsequent reboots if the system failed to start | On restart |
verifier /bootmode oneboot |
Enables the settings for the next start only | On restart |
verifier /volatile /flags <options> |
Changes settings without a reboot, for a limited set of flags | Immediately |
/volatile only accepts a handful of options – randomised low resources simulation, deadlock detection, DMA checking, force pending I/O requests and IRP logging. Everything else needs a restart, and /querysettings does not show what /volatile added.
Where the settings actually live
Two values under HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Memory Management hold the whole configuration. VerifyDrivers is a string listing the driver binaries to verify, and it accepts *.sys to mean all of them. VerifyDriverLevel is a DWORD holding the combined option flags. Clearing both is what an offline fix amounts to, and it is why editing the right hive matters more than typing the right command.
The rest of the Verifier bug check family
| Code | What it covers | How to read it |
|---|---|---|
0x000000C4 |
All fatal errors found by Driver Verifier | Parameter 1 is the violation type; parameters 2 to 4 change meaning with it |
0x000000C9 |
All I/O Verification violations | Parameter 1 is the violation type; parameter 2 is usually the address in the driver where it was detected |
0x000000E6 |
All DMA Verification violations | Parameter 1 is the only one of interest and names the exact violation |
0x000000F1 |
All SCSI Verification violations | Parameter 1 is the violation type, in the 0x1000 to 0x2005 range |
0x000000C1 |
Special pool caught a write to an invalid section of it | Parameter 4 says which kind |
0x000000F6 |
An error in the BIOS or a device being verified by the PCI driver | Parameter 1 is 0x01, 0x02 or 0x03 |
Reading 0x000000C1 and 0x000000F6 properly
These two get misdescribed more than the rest, usually narrowed to whichever meaning fits the story being told. 0x000000C1’s parameter 4 covers freeing pool that was never allocated (0x20), freeing a bad address (0x21 and 0x22), corruption near a freed address (0x23), an overrun past the end of an allocation (0x24), allocating or freeing at an incorrect IRQL (0x30 and 0x31), and a single-bit error in bytes near a freed address (0x32). Only 0x24 is the classic buffer overrun.
0x000000F6 has three documented parameter 1 values: 0x01, an active bridge reprogrammed by the BIOS during a docking event; 0x02, the PMCSR register not updated within the time the specification allows; and 0x03, a driver writing to Windows-controlled parts of a PCI device’s configuration space. Two of the three point at firmware rather than at a driver.
When you cannot tell whether the named driver is guilty
- Run
!analyze -von the dump and read the DV_VIOLATED_CONDITION line rather than the module name alone. - Where the violation is a DDI compliance rule, follow the
!ruleinfolink the debugger prints. It names the rule and what it requires. - For a leaked-allocation violation,
!verifier 3 drivername.syslists the allocations the driver did not free. - If the flagged driver changes between crashes, you are probably looking at pool corruption by a driver you have not identified. That is a different investigation.
- Keep the
verifier /querysettingsoutput. Knowing which options were enabled tells you which class of rule can have fired.
Getting back to a supported state
Clearing Verifier restores the machine; it does not fix the driver. A machine that was bug checking before anyone enabled Verifier is still going to bug check. The honest sequence is: clear Verifier, get the machine usable, replace or remove the flagged driver, and only then re-run Verifier against that one driver, on a test machine, to prove the violation has gone. Leaving it enabled on a machine somebody depends on is how most people arrive at this stop code in the first place.
Every code this article covers
| Code | What it points at | Source |
|---|---|---|
0x000000C4 |
DRIVER_VERIFIER_DETECTED_VIOLATION: the general bug check code for fatal errors found by Driver Verifier. Parameter 1 identifies the type of violation, and the meaning of parameters 2 to 4 varies with it | Microsoft Learn |
0x000000C9 |
DRIVER_VERIFIER_IOMANAGER_VIOLATION: the code for all Driver Verifier I/O Verification violations. Parameter 1 identifies the type | Microsoft Learn |
0x000000E6 |
DRIVER_VERIFIER_DMA_VIOLATION: the code for all Driver Verifier DMA Verification violations. Parameter 1 is the only one of interest and identifies the exact violation | Microsoft Learn |
0x000000C1 |
SPECIAL_POOL_DETECTED_MEMORY_CORRUPTION: a driver wrote to an invalid section of the special pool. Parameter 4 distinguishes freeing unallocated pool, freeing a bad address, an overrun past the end of an allocation, and allocating or freeing at an incorrect IRQL | Microsoft Learn |
0x000000F1 |
SCSI_VERIFIER_DETECTED_VIOLATION: the code for all Driver Verifier SCSI Verification violations. Parameter 1 identifies the type | Microsoft Learn |
0x000000F6 |
PCI_VERIFIER_DETECTED_VIOLATION: an error in the BIOS or another device being verified by the PCI driver. 0x01 is a bridge reprogrammed by the BIOS during docking, 0x02 a PMCSR register not updated in time, 0x03 a driver writing to Windows-controlled PCI configuration space | Microsoft Learn |
Confirm the fix worked
verifier /querysettingsreports that no drivers are being verified.- The machine reaches the desktop on two consecutive cold starts.
- Device Manager shows the driver that was flagged at the version you installed.
- No new files appear in
%SystemRoot%\Minidumpover several days of normal use. - If you re-enabled Verifier deliberately,
verifier /querysettingslists only the drivers you named and only the options you meant.
Questions people ask about this
I never turned Driver Verifier on. Why is it running?
Either a support engineer enabled it remotely, a diagnostic tool switched it on, or it has been on since an investigation months ago and only started crashing now because the flagged driver changed. verifier /querysettings tells you what is configured once you are booted.
Does clearing Verifier fix the underlying problem?
No. It stops the deliberate crashes and makes the machine usable. The driver Verifier flagged genuinely broke a rule and is a likely source of whatever instability preceded this. Update or replace it.
Why does Safe Mode usually work if Verifier is still enabled there?
Because Safe Mode loads a minimal driver set. A flagged third-party driver simply never loads, so it is never verified. If the flagged driver is one Safe Mode does load, Safe Mode bug checks too – that is the case for the offline registry route.
Does resolving this cost anything?
Nothing. Driver Verifier ships with Windows, the recovery environment costs nothing, and replacement drivers come from your hardware vendor at no charge.
How long should Verifier run when I am hunting a driver?
Long enough to reproduce the fault under normal use on a test machine, then turn it off. Microsoft is clear that it belongs on machines used for testing and debugging, and verifier /bootmode resetonbootfail means a failed boot clears it for you.
