Windows Stop Code INCONSISTENT_IRP (0x0000002A): Meaning, Parameters, and Debugging

Quick Answer

INCONSISTENT_IRP is Windows bug check 0x0000002A. It describes an I/O request packet (IRP) whose information or state is inconsistent. Microsoft gives an example: an IRP is being completed while it is still marked as queued to a driver’s device queue. Arg1 is the address of the IRP; Arg2–Arg4 are reserved. Microsoft Learn

There is an important qualification: Microsoft says this bug-check code is not currently used by the system, but exists for debugging purposes. If you found 0x2A in a list, do not assume it represents a blue screen likely to occur on a current Windows installation. If an actual dump reports it, preserve the dump and inspect the IRP at Arg1. Microsoft Learn

What Is an IRP?

An I/O request packet is the structure Windows uses to carry many requests through a stack of device drivers. A request may pass through several drivers, each of which handles its part of the operation before forwarding or completing it. The IRP contains the information those drivers need to process the request. Microsoft Learn

Because several components can participate, an IRP’s state must remain consistent with what is actually happening. For example, a request should not be represented as waiting on a driver’s queue while it is also being completed. Microsoft uses precisely that situation to illustrate the meaning of INCONSISTENT_IRP. Microsoft Learn

Documented Status of Bug Check 0x2A

Microsoft’s reference makes two separate points:

1. The name and value exist, and the entry describes an inconsistent IRP state.
2. The bug-check code is not currently used by the system; it remains for debugging purposes.

This differs from a routinely observed stop code with published repair steps. The entry is useful to driver developers and readers of Windows bug-check tables, but it should not be presented as a common end-user blue-screen problem. Microsoft Learn

INCONSISTENT_IRP Parameters

Arg1 is an address, not a Windows error code, file path, or user-facing device ID. A debugger may need a sufficiently complete dump to inspect the object at that address.

What Makes an IRP “Inconsistent”?

Microsoft says the IRP typically has a field that conflicts with its remaining state. Its example is an IRP being completed while still marked as queued to a driver’s device queue. Microsoft Learn

Other contradictions could be considered during a source-level investigation, but Microsoft’s 0x2A page does not provide a comprehensive list. Do not assume that every suspected double completion, cancellation race, or queue-management issue is reported as bug check 0x2A. The code’s current-use qualification makes that assumption particularly misleading.

How to Investigate an Actual 0x2A Dump

1. Confirm the code really is 0x2A

Check the bug-check value in the original dump. A dump for some other stop code can contain an argument equal to 0x2A; that does not turn it into an INCONSISTENT_IRP crash.

If the code came only from a reference list, there is no particular computer or IRP to diagnose.

2. Preserve and open the dump

Keep the original dump and record the Windows build. Open it in WinDbg and run:

!analyze -v

Record the reported BUGCHECK_CODE, Arg1 address, stack trace, and driver modules. Microsoft’s general bug-check reference recommends !analyze for displaying bug-check information. learn.microsoft.com

3. Inspect the IRP at Arg1

WinDbg’s !irp extension displays an I/O request packet. When Arg1 is a valid IRP address in the dump, use:

!irp <Arg1 address> 1

Replace <Arg1 address> with the dump’s actual value. The detail option can show the IRP’s status, owning thread, stack locations, and major and minor I/O function codes. If the dump lacks the necessary memory, the debugger may be unable to display all fields. Microsoft Learn

4. Examine the driver stack and request history

Display the current call stack:

kv

Determine which driver was queueing, cancelling, forwarding, or completing the request. For a driver you maintain, reconstruct the IRP’s lifecycle: where it entered the driver, whether it was queued, which path removed it, and which path completed it.

The driver that discovers the inconsistent state may not be the one that first introduced it. Follow the request’s history rather than relying only on the last stack frame.

Guidance for Driver Developers

When the dump and code show a queued IRP being completed, inspect the synchronization between:

• Queue insertion and removal.
• Cancellation.
• Completion.
• Ownership transfer to another driver.
• Error and teardown paths.

Check that only the appropriate path completes the IRP and that its queue state agrees with that action. These are practical checks derived from Microsoft’s example of inconsistency, not a claim that 0x2A is actively generated for every such defect. Microsoft Learn

For a reproducible driver issue, Driver Verifier’s I/O Verification may help catch misuse closer to the offending operation. Microsoft documents it as a driver-testing tool and notes that verification is most effective when targeted to a small number of drivers. Verifier may report a different bug-check code for the violation it detects. Microsoft Learn

Guidance for End Users

There is no supported, universal 0x2A fix such as reinstalling a device, editing the registry, or replacing RAM. Microsoft says the code is not currently used by the system. If a diagnostic website shows INCONSISTENT_IRP, first verify that the original Windows dump really recorded it. Microsoft Learn

If it did, provide the dump and the operation that triggered the failure to a driver vendor or Windows debugging specialist. An IRP-state problem requires case-specific analysis.

Frequently Asked Questions

What is INCONSISTENT_IRP?

It is the symbolic name for bug check 0x0000002A, describing an IRP with contradictory information or state. Microsoft Learn

Is bug check 0x2A currently used by Windows?

Microsoft says it is not currently used by the system, although the code exists for debugging purposes. Microsoft Learn

What does Parameter 1 contain?

It contains the address of the inconsistent IRP. In a suitable dump, a debugger can inspect that address with !irp. Microsoft Learn

What do Parameters 2–4 mean?

Microsoft marks all three reserved. Do not apply parameter definitions from another IRP-related bug check. Microsoft Learn

Does an inconsistent IRP always mean a double completion?

No. Microsoft gives completion while still queued as an example of inconsistent state. Its 0x2A page does not say every instance is a double completion. Microsoft Learn

Which WinDbg command displays the IRP?

Use !irp <address> 1, substituting the valid Arg1 IRP address from an actual dump. Microsoft Learn

Summary

INCONSISTENT_IRP (0x0000002A) describes an IRP whose fields conflict with its state. Arg1 identifies the IRP, while the other parameters are reserved. Microsoft’s most important qualification is that the bug check is not currently used by the system and remains for debugging purposes. Verify any claimed occurrence in the original dump; if real, inspect the IRP and trace its driver lifecycle. Microsoft Learn

Sources

• Microsoft Learn: Bug Check 0x2A — INCONSISTENT_IRP
• Microsoft Learn: I/O Request Packets
• Microsoft Learn: !irp WinDbg extension
• Microsoft Learn: I/O Verification