Skip to content

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

Your vault is empty.

Free Fix 0x0000001D

NO_SPIN_LOCK_AVAILABLE 0x0000001D and kernel spinlock deadlock bugchecks

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

Fix it now

These stop codes fire when kernel synchronisation is used in a way that cannot be valid, and only a corrected driver fixes them. Start by reading the dump for the module name, because for three of the five codes in this group Microsoft publishes nothing beyond the name of the bug check, so the driver on the stack is the whole of the evidence.

Run these in an elevated Command Prompt before changing anything

verifier /querysettings
fltmc
pnputil /enum-drivers
  1. Open the newest file in %SystemRoot%\Minidump in WinDbg and run !analyze -v. Note the module it names and whether that name is the same across several dumps.
  2. Set that against your own timeline. What driver or product was installed or updated shortly before the crashes started?
  3. Roll that driver back through Device Manager, on the device’s Properties, Driver tab, or uninstall the product that supplied it.
  4. If roll back is greyed out, the previous package was not kept. Install the last build you know was stable from the vendor’s own archive.
  5. If the named module is a core Windows file, treat it as a starting point rather than a verdict and move to Driver Verifier – on a test machine, not on this one.

Microsoft states that Driver Verifier should only be run on computers you use for testing and debugging, because it deliberately bugchecks the machine when it catches a violation. Set verifier /bootmode resetonbootfail before you enable anything, and clear it with verifier /reset the moment you have your answer.

If the machine is stable with that driver rolled back or gone, stop here. If not, the next section explains what each of these codes does and does not tell you.

Why it happens

A spinlock is the smallest synchronisation primitive the kernel has. A processor that wants one loops until it gets it, with IRQL raised so nothing on that core can interrupt the holder. That design is fast precisely because it is minimal, and minimal means it cannot tolerate misuse: a processor that asks for a lock it already holds will spin waiting for itself, forever.

Rather than let that happen, the kernel checks what it can check and stops when a check fails. 0x0000000F is the one Microsoft documents properly. Its published meaning is that a request for a spin lock was initiated when the spin lock was already owned, and it gives three causes: a thread acquiring a lock it already holds, a thread acquiring a lock and then calling a function that acquires one too, and – the one people miss – a thread that holds a spin lock lowering its IRQL below the lock’s IRQL, which lets another thread be scheduled on that processor and contend for the same lock.

0x000000BF is the mutex equivalent and is also documented: a thread attempted to acquire ownership of a mutex it already owned. Parameter 1 is the address of the mutex and parameter 2 is the thread that did it, which between them identify the object and the caller without any guesswork.

The other three are honest gaps. Microsoft’s pages for 0x0000001D, 0x00000010 and 0x00000011 carry the symbolic name, the statement that the bug check appears very infrequently, and nothing else – no description, no parameters, no cause, no resolution. NO_SPIN_LOCK_AVAILABLE, SPIN_LOCK_NOT_OWNED and THREAD_NOT_MUTEX_OWNER are names, and the names are all you get. Treat any source that tells you what 0x1D counts, or over what interval, as making it up. The consequence for you is practical: for these three, the module on the stack and your own change history are the entire evidence base, and there is no parameter to decode.

A driver that changed just before the crashes did

You have this one if The dump names the same non-Microsoft module every time and the crashes date from a specific update or installation.

  1. Roll the driver back on the device’s Properties, Driver tab in Device Manager.
  2. If that option is unavailable, remove the package properly – pnputil /enum-drivers lists installed third-party packages so you can identify the right one.
  3. Install the last build you know was stable, taken from the vendor’s own archive where they publish one.
  4. Send the dump to the vendor. A synchronisation defect is fixed in source, and your report may be the one that prompts it.

Two products doing the same job in the same path

You have this one if The crashes began after a second security, backup, virtualisation or storage product was added, and the named module belongs to one of them.

  1. List filter drivers with fltmc and look for two products doing similar work.
  2. Take one out of the path for a test with fltmc unload <name>, then reproduce the workload.
  3. Remove the one you need least with its vendor’s own removal utility, not through Installed apps.
  4. If both are genuinely required, follow each vendor’s documented coexistence and exclusion guidance rather than removing either.

Wider memory corruption surfacing as a lock error

You have this one if The named module differs between crashes, and other unrelated stop codes appear as well.

  1. Run the Windows Memory Diagnostics tool and read the MemoryDiagnostics-Results entry in the System log afterwards.
  2. Clear any memory profile in firmware and test at the board default speed.
  3. Run sfc /scannow, then DISM /Online /Cleanup-Image /RestoreHealth.
  4. If memory tests clean, move to Driver Verifier with special pool against third-party drivers – on a test machine.

A locking defect with no vendor fix available

You have this one if You have identified the driver, the vendor has no newer build, and the product is still needed.

  1. Establish which workload triggers it and avoid that path while you decide.
  2. Look for a maintained alternative; most functions offered by abandoned kernel-level utilities now exist natively.
  3. Where the software is essential and unmaintained, run it inside a virtual machine so its driver is confined there.
  4. Report the defect to the vendor with the dump attached, and put a date on how long you will wait.

There is no configuration change that corrects a locking defect. The lock either has one owner or it does not, and only the driver’s source decides which.

Full reference

What is published, and what is not

Code Symbolic name What Microsoft publishes
0x0000001D NO_SPIN_LOCK_AVAILABLE The name, and that this bug check appears very infrequently. Nothing more
0x0000000F SPIN_LOCK_ALREADY_OWNED Full description, no parameters, three causes and three resolutions
0x00000010 SPIN_LOCK_NOT_OWNED The name, and that this bug check appears very infrequently
0x00000011 THREAD_NOT_MUTEX_OWNER The name, and that this bug check appears very infrequently
0x000000BF MUTEX_ALREADY_OWNED Full description and four parameters: the mutex address and the offending thread

Saying so plainly is more useful than filling the gaps. If your stop code is one of the three undocumented ones, you know from the name which primitive is involved and nothing else, so the investigation is entirely about the module on the stack. If it is 0x0F or 0xBF, you have a documented mechanism and, for 0xBF, an object address and a thread to look at.

The IRQL rule behind 0x0000000F

Microsoft’s third documented cause for 0x0F is the one that catches developers out. Spin lock IRQLs are always at or above dispatch level, and a thread holding a spin lock must keep its IRQL at or above the lock’s IRQL. Drop below it and the thread can be scheduled off the processor while still holding the lock, another thread runs and asks for the same lock, and the kernel sees a recursive acquisition. The published resolutions follow directly: do not acquire the same lock recursively, do not lower IRQL below the lock’s IRQL while holding it, and audit call chains so a function that takes a lock does not call something that takes it again.

Driver Verifier, used the way Microsoft describes it

Command What it does
verifier /standard /driver name.sys Applies the standard option set – special pool, IRQL checking, pool tracking, I/O verification, deadlock detection, DMA verification and the rest – to named drivers only
verifier /flags 0x20 /driver name.sys Deadlock detection alone, which is the option aimed at lock ordering
verifier /querysettings Shows what will be verified after the next boot
verifier /bootmode resetonbootfail Disables Verifier if the system fails to start. Set this before enabling anything
verifier /reset Clears all settings. Reboot afterwards

Microsoft states that running Driver Verifier could cause the computer to crash and that you should only run it on computers you use for testing and debugging. Treat that literally. If you have to use it on a machine that matters, take a backup, set verifier /bootmode resetonbootfail first, and clear it with verifier /reset as soon as you have a name.

Deadlock detection versus special pool

These two Verifier options answer different questions and it is worth choosing rather than enabling everything. Deadlock detection watches lock acquisition order and catches the class of defect these stop codes describe. Special pool puts each allocation on its own page with a guard page after it and catches memory corruption instead. If the module name is consistent and the stop code is a lock code, deadlock detection is the targeted choice. If the module name changes between crashes, you are probably looking at corruption and special pool is the right tool.

When the machine only crashes after long uptime

This is worth addressing because it is the claim most often attached to 0x0000001D, and it is not published anywhere. If your machine runs for days and then stops, the honest position is that you have a timing observation and no vendor mechanism to hang it on. Use it the way any other observation is used – note the interval, check whether the same module is named each time, and see whether pool or handle counts climb across that interval – but do not let a story about lock exhaustion decide which driver you remove. The module name in the dump is better evidence than the clock.

Before you conclude it is the named driver

  1. Collect at least three dumps. One name repeated is evidence; three different names is a different problem.
  2. Check whether Windows Update substituted a driver for the one you installed – Device Manager shows the version actually loaded.
  3. Rule out memory first if the names vary, because failing memory imitates almost every kernel defect there is.
  4. Confirm the product is supported on the Windows build you are running before you spend time on its driver.
  5. Where two products overlap, remove one and run without it long enough to be convincing rather than long enough to be hopeful.

Every code this article covers

Code What it points at Source
0x0000001D NO_SPIN_LOCK_AVAILABLE. Microsoft publishes the name and that this bug check appears very infrequently; no meaning, parameters or cause are published, so read the module on the stack not published by the vendor
0x0000000F A request for a spin lock was initiated when the spin lock was already owned – directly, indirectly through a call chain, or because the holder lowered IRQL below the lock’s IRQL Microsoft Learn
0x00000010 SPIN_LOCK_NOT_OWNED. Microsoft publishes the name and that it appears very infrequently; nothing further is published not published by the vendor
0x00000011 THREAD_NOT_MUTEX_OWNER. Microsoft publishes the name and that it appears very infrequently; nothing further is published not published by the vendor
0x000000BF A thread attempted to acquire ownership of a mutex it already owned. Parameter 1 is the mutex address and parameter 2 the offending thread Microsoft Learn

Confirm the fix worked

  1. Confirm verifier /querysettings reports no drivers under verification before the machine goes back into normal use.
  2. Run the machine past the uptime at which it previously crashed, without a restart.
  3. Confirm Device Manager shows the driver version you intended and that Windows Update has not substituted another.
  4. Run fltmc and confirm every filter listed belongs to a product that is installed and current.
  5. Check the System log after several days and confirm no new BugCheck events have been written.

Questions people ask about this

What does 0x0000001D actually count?

Microsoft does not say. The page carries the symbolic name NO_SPIN_LOCK_AVAILABLE and the statement that the bug check appears very infrequently, and nothing else – no description, no parameters, no cause. Anything more specific you read about it is somebody’s inference presented as fact.

Can I fix this myself if the vendor has no update?

Not in the driver. Your options are the last version that was stable, removing the product and using an alternative, or avoiding the workload that triggers the path. A locking defect is corrected in source code.

Does this cost anything to resolve?

No purchase is required. Driver rollbacks, the debugger, Driver Verifier and the memory and system file checks are all free. The only expense would be replacing hardware whose driver is abandoned.

The dump names a Microsoft driver. What then?

Treat it as a starting point. Core kernel and class drivers routinely appear at the top of the stack when a third-party driver below them corrupted state or held a lock it should not have. Verifier against third-party drivers – on a test machine – is how you find the real source.

Is Safe Mode a valid workaround?

It is a diagnostic rather than a workaround. Safe Mode loads a minimal driver set, so a machine that is stable there tells you the fault is in a driver Safe Mode does not load, which narrows the field usefully. It is not a state to work in.

Related error codes

Was this article helpful?

Your feedback helps us improve our documentation.

Related articles

License Error FLTMGR_FILE_SYSTEM 0x000000F5 – antivirus minifilter crashes the kernel Free Fix MANUALLY_INITIATED_CRASH 0x000000E2 and missing memory dump files Free Fix KERNEL_SECURITY_CHECK_FAILURE 0x00000139 and heap corruption crashes Free Fix DISM RestoreHealth fails with 0x800F081F or 0x80073712 during recovery
โ† Back to Knowledge Base