Skip to content

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

Your vault is empty.

Free Fix 0x0000009E

USER_MODE_HEALTH_MONITOR 0x0000009E on clustered Hyper-V and SQL hosts

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

Fix it now

0x0000009E means one or more critical user mode components failed a health check inside their configured timeout, so the kernel stopped the machine rather than leave it half alive. The process did not crash; it stopped being able to run. Microsoft names resource starvation as the cause, and on a clustered host that usually means storage.

Run this on the node in an elevated PowerShell session after the stop

Get-ClusterLog -TimeSpan 20 -Destination C:\temp
  1. Read the stop parameters from the System log event. Parameter 1 is the process that failed the check, parameter 2 the timeout in seconds and parameter 3 the watchdog source, which together tell you what was being watched and for how long.
  2. Read the cluster log entries immediately before the stop, and the System log around the same minute, for a resource that stopped responding or a resource host subsystem process that was terminated.
  3. Check storage first: multipath configuration, host bus adapter firmware and driver versions against the storage vendor’s matrix, and any device reset or path failure events at the same timestamp.
  4. Confirm the node was not out of memory or paging heavily. A host with no headroom cannot page a critical process back in promptly, which is the same failure by another route.
  5. Fix the stall. Do not start by raising cluster timeouts.

Microsoft’s own advice for this stop is to read the events that immediately precede it in the System log. The bugcheck is the report; the cause is in the minute before it.

If the storage or memory problem you found explains the timing, fix it and the stops go with it. If nothing lines up, the next section covers what the watchdog is actually watching and the other three codes that travel with it.

Why it happens

Hardware watchdogs can tell that basic kernel services have stopped executing. They cannot tell that a user mode process has been starved, because starvation of that kind blocks a process without blocking deferred procedure calls or draining the non-paged pool. Everything looks alive from below. So kernel components extend the watchdog idea upwards: they register critical user mode processes and check periodically that those processes are still responding.

0x0000009E is that check failing in a way that rules out a graceful shutdown. The documented purpose is to restore the service by restarting or by allowing failover to another server, which is why the workloads have usually come back somewhere else before anyone notices the stop. On a failover cluster the watched processes are the ones the cluster cannot function without, and the timeout that was missed is handed to you in parameter 2.

That makes this a symptom report rather than a diagnosis. The process was not scheduled, or it was blocked on I/O that never returned. In rough order of frequency the candidates are storage latency from a flapping path or a saturated array, a resource DLL blocking inside the resource host subsystem, an interrupt storm from a misbehaving device, and a host so short of memory that critical processes could not be paged back in.

The three codes that keep company with it are worth reading properly, because two of them name a component outright. 0x000000F0 says a storage miniport failed to complete an SRB request, with the driver name in parameter 2. 0x000000F2 says the kernel detected an interrupt storm, which it defines precisely as a level triggered interrupt signal staying in the asserted state. 0x00000143 says the processor power management driver hit a fatal error during an idle or performance state change.

Storage stalls

You have this one if Device reset or path failure events appear in the System log just before the stop, or the array reports errors or saturation across the same window.

  1. Check the multipath configuration on the node and confirm it matches the storage vendor’s documented policy for that array.
  2. Bring host bus adapter firmware and driver into line with the vendor’s supported combination, and apply the identical combination to every node.
  3. Ask the storage team to check the array and the fabric for errors, queue full conditions and saturation over the same window.
  4. Once the path is stable, run Test-Cluster before returning the node to normal service.

A 0x000000F0 alongside this one removes the guesswork: parameter 2 is the driver name of the miniport that failed to complete its request.

A resource is blocking inside the resource host subsystem

You have this one if Failover clustering events name a specific resource as having stopped responding, and the same resource appears every time.

  1. Identify the resource from the event, then look at what it depends on: a script resource, a file share, an application resource or a third-party resource DLL.
  2. Ask the application vendor whether that resource can be isolated into its own monitor process so its failures cannot take the subsystem down with it.
  3. Review its timeouts and change only what the vendor recommends.
  4. Fix the underlying application behaviour. Isolation limits the damage; it does not remove the hang.

Memory pressure on the host

You have this one if Available memory was very low at the time, a SQL instance was running without a configured maximum server memory, or every gigabyte on a Hyper-V host was committed to virtual machines.

  1. On a SQL host, set a maximum server memory that leaves the operating system real headroom.
  2. On a Hyper-V host, leave capacity free for the parent partition.
  3. Check dynamic memory settings on guests that may be ballooning aggressively during peak periods.
  4. Add memory where the workload has genuinely outgrown the host.

An interrupt storm from a device

You have this one if 0x000000F2 appears alongside or instead of 0x0000009E, or interrupt time on one processor is pinned at the moment of the fault.

  1. Take the interrupt service routine address from parameter 1 of the 0x000000F2 and identify its driver from the dump.
  2. Look for devices sharing that IRQ, which is where Microsoft’s own guidance points for this bugcheck.
  3. Update the device firmware and driver, and remove or disable the device temporarily to confirm.

Antivirus scanning cluster and virtualisation paths

You have this one if Stops coincide with backup windows or heavy virtual machine I/O, and no exclusions have been configured on the node.

  1. Apply the documented exclusions for failover clustering: the cluster database and its logs, the cluster shared volume mount points and the witness location.
  2. For Hyper-V, exclude the virtual hard disk, checkpoint and configuration paths and the virtualisation processes.
  3. Apply the endpoint vendor’s own exclusion guidance as well; the two lists are not identical.
  4. Apply identical exclusions on every node so behaviour does not change after a failover.

Full reference

The stop parameters, and what to do with each

Parameter Contents Use
1 The process that failed the health check within the timeout Tells you what was being watched. Match it to a cluster or application process before anything else
2 The health monitoring timeout, in seconds Tells you how long the stall lasted. A stall longer than this is a storage or scheduling problem, not a blip
3 Watchdog source With the process address, identifies which sub-component created this watchdog
4 Reserved

The companion codes, read properly

Stop code Name What it states
0x000000F0 STORAGE_MINIPORT_ERROR A storage miniport failed to complete an SRB request. Parameter 1 says whether it failed after a reset, after an abort, on timeout or on a crypto operation; parameter 2 is the driver name
0x000000F2 HARDWARE_INTERRUPT_STORM The kernel detected an interrupt storm, defined as a level triggered interrupt signal staying asserted. Parameter 1 is the address of the interrupt service routine
0x00000143 PROCESSOR_DRIVER_INTERNAL The processor power management driver hit a fatal error, usually during an idle or performance state change involving the platform’s power engine plugin

None of the three is a generic companion code. If you have one of them in the dump alongside the health monitor stop, it names the layer for you and you should start there rather than with the cluster.

Cluster evidence worth collecting before you change anything

  1. Generate the cluster log across every node: Get-ClusterLog -TimeSpan 20 -Destination C:\temp. The cmdlet collects from all nodes into one directory on the node you run it from.
  2. Read the last two minutes before the stop rather than the moment itself. The stall starts earlier than the bugcheck.
  3. Cross-reference the System log on the same node for storage, path and device reset events in that window.
  4. Run Test-Cluster afterwards, and keep the report. It is the record that the storage and network configuration was sound when you handed the node back.

Raising cluster timeouts or weakening the hang recovery behaviour makes the bugcheck stop without making the hang stop. A node that hangs and is left running holds storage reservations and resource ownership, which is a considerably worse outage than a fast, clean failover. Treat any timeout change as temporary, and write down that it has to be reversed.

When storage, memory and devices are all ruled out

  • Compare nodes. A stop that only ever happens on one node of an otherwise identical cluster is a hardware or firmware difference, and the fastest way to find it is a diff of driver and firmware versions.
  • Look at what runs on a schedule. A stop that arrives at the same time each night is being caused by something that runs at the same time each night, and the cluster log will show what was in flight.
  • Check the paging file configuration. A host that cannot write a dump gives you nothing to work with next time, and on a large-memory host the default settings are worth confirming rather than assuming.
  • Keep the dumps. Microsoft’s own guidance for this bugcheck is to work back through the events preceding it, and a series of dumps with the same preceding events is a far stronger case than one.

Every code this article covers

Code What it points at Source
0x0000009E USER_MODE_HEALTH_MONITOR: one or more critical user mode components failed to satisfy a health check within the configured timeout Microsoft Learn
0x000000F0 STORAGE_MINIPORT_ERROR: a storage miniport driver failed to complete an SRB request; parameter 2 holds the driver name Microsoft Learn
0x000000F2 HARDWARE_INTERRUPT_STORM: the kernel detected an interrupt storm, meaning a level triggered interrupt signal stayed in the asserted state Microsoft Learn
0x00000143 PROCESSOR_DRIVER_INTERNAL: the processor power management driver encountered a fatal error, typically during an idle or performance state change Microsoft Learn

Confirm the fix worked

  1. Run the node through a full backup cycle and a live migration in both directions without a stop.
  2. Run Test-Cluster and confirm the storage, network and system configuration tests pass on every node.
  3. Confirm no new bugcheck event appears in the System log over a full week of normal operation.
  4. Confirm the storage driver logs no further device reset or path failure events during peak periods.
  5. Confirm any timeout you changed as a stopgap has been put back.

Questions people ask about this

Can I just turn the health monitoring off?

You can change the recovery behaviour and you should not treat that as a fix. The monitor exists so a stalled node gets out of the way quickly. Weakening it converts a clean failover into a node that sits there holding storage while your service is down.

Did my cluster actually work correctly here?

Almost certainly yes. Microsoft describes this bugcheck as restoring critical services by restarting or enabling failover to other servers. If the workloads came back on another node within moments, that is the mechanism doing its job.

Is this a Windows bug?

Rarely. It is a deliberate action taken because something else stalled. Treat it as an instruction to look at storage latency, firmware levels, memory headroom and third-party agents, in that order.

The dump also shows 0x000000F0. Which do I investigate?

The 0x000000F0, and immediately. It names the storage miniport driver that failed to complete a request, which is a far more specific starting point than the health monitor stop it caused.

Does resolving this involve buying anything?

Usually not. The work is firmware and driver alignment, multipath configuration, memory headroom and exclusions, all from vendors you already deal with. If the node genuinely lacks memory you are buying capacity, and no licence change would have helped.

Related error codes

Was this article helpful?

Your feedback helps us improve our documentation.

Related articles

License Error ELAM_DRIVER_DETECTED_FATAL_ERROR 0x00000178 and security subsystem crashes Free Fix STATUS_SYSTEM_PROCESS_TERMINATED 0xC000021A and CRITICAL_PROCESS_DIED 0x000000EF Free Fix VIDEO_TDR_FAILURE 0x00000116 – display driver stopped responding Free Fix MEMORY_MANAGEMENT 0x0000001A and PFN_LIST_CORRUPT 0x0000004E blue screens
โ† Back to Knowledge Base