Skip to content

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

Your vault is empty.

Free Fix 0x000000FC

ATTEMPTED_EXECUTE_OF_NOEXECUTE_MEMORY 0x000000FC and DEP blue screens

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

Fix it now

Kernel-mode code tried to execute an address whose page table entry marks it as non-executable, and the kernel stopped instead of running it. Microsoft publishes no cause for this code, but it does publish where the answer is: the name of the driver that made the attempt is written to the stop screen and saved in KiBugCheckDriver.

Run these in an elevated Command Prompt, in order

sfc /scannow
DISM /Online /Cleanup-Image /RestoreHealth
driverquery /si /fo table
pnputil /enum-drivers
  1. Get the driver name. Open the newest file in %SystemRoot%\Minidump in WinDbg and run !analyze -v. Without a debugger, the BugCheck event in Event Viewer under Windows Logs then System gives you the stop code and the four parameters; current stop screens no longer show them.
  2. Match that module against the pnputil /enum-drivers output to find which package and which vendor it came from, then install the current build from that vendor rather than from Windows Update.
  3. If the module belongs to software you no longer need, remove the product with the vendor’s own removal utility, since an ordinary uninstall often leaves the kernel component loaded.
  4. Run a full offline scan from Windows Security. Kernel-level tampering is one real explanation for code running from a data page, and the scan costs you nothing but time.

Do not switch off no-execute protection in the boot configuration, even as a test. It removes the check that caught this, leaves the defect running, and Microsoft’s published resolution for the code is to identify the driver, not to disable the protection.

If the machine is stable with that driver updated or gone, you are done. If it is not, the next section explains what the processor actually refused to do and which explanations fit.

Why it happens

Page table entries carry a no-execute bit. Windows sets it on memory that holds data – pool allocations, stacks, buffers – so the processor will refuse to fetch instructions from those pages. A driver that keeps code where code belongs never touches that bit. When something does, the processor faults, and the kernel raises 0x000000FC rather than execute whatever happened to be sitting at that address.

Microsoft’s page for this bug check is short and worth reading literally. It gives the description, four parameters – parameter 1 is the virtual address whose execution was attempted, parameter 2 the contents of the page table entry – and a resolution consisting of !analyze, the driver name saved in KiBugCheckDriver, and a stack trace with the instruction pointer if that name is not available. It publishes no list of causes. Anything you read that assigns this code a definite culprit is inference, including what follows here, and you should test it against your own dump rather than assume it.

Two neighbouring codes describe the same enforcement catching a different operation. 0x000000BE is a driver attempting to write to a read-only memory segment. 0x0000011C is narrower still: an attempt to write to the configuration manager’s read-only protected storage. Both, like 0xFC, print the offending driver’s name where they can. 0x000000D3 is the odd one in this group – it fires when the system accesses pageable memory at too high an IRQL, and Microsoft attributes it to drivers that have marked their own code or data pageable when it has to be resident.

A driver that is old enough to predate the enforcement

You have this one if The dump names the same non-Microsoft module every time, and it belongs to software you rarely think about – a peripheral utility, a licensing component, a monitoring agent.

  1. Find the package it came from: pnputil /enum-drivers lists third-party driver packages with their provider and version.
  2. Install the current build from that vendor. If the product is abandoned, remove it and see whether you miss it.
  3. If the driver came with hardware you still use, check whether a current in-box driver can serve the same device.
  4. Reboot and confirm the module is no longer loaded before you decide it is fixed.

Two kernel-level products fighting over the same paths

You have this one if The machine carries more than one product that hooks kernel code – a security agent plus an anti-cheat driver, a dongle protection layer plus an old endpoint suite – and crashes began when the second one arrived.

  1. List loaded file system filters with fltmc from an elevated prompt and account for every entry.
  2. Remove the one you need least, using its vendor’s removal utility rather than Installed apps.
  3. Reboot, run fltmc again, and confirm the filter has actually gone rather than merely leaving the installed programs list.
  4. Run the workload that used to crash before reinstalling anything.

This is a pattern worth checking, not a Microsoft attribution. Microsoft publishes no cause for 0xFC at all.

Damaged system files or a partly applied update

You have this one if The dump points into core Windows components, or the crashes started around an update that did not complete cleanly.

  1. Run sfc /scannow and read the summary it prints.
  2. Run DISM /Online /Cleanup-Image /RestoreHealth so the component store has a clean source, then run sfc /scannow again.
  3. If an update is stuck part-applied, remove it from the recovery environment: hold Shift while selecting Restart, then Troubleshoot, Advanced options.
  4. Reboot and re-test before drawing any conclusion.

Kernel-level malware

You have this one if Alongside the crashes there is traffic you cannot explain, security tools that will not start, or a driver in the signing list you cannot account for.

  1. Run a full offline scan from Windows Security so the running system cannot interfere with it.
  2. Check driverquery /si /fo table and account for anything unsigned.
  3. Confirm Secure Boot is on in firmware, and check memory integrity under Windows Security, Device security, Core isolation details.
  4. If the machine holds sensitive data and an infection is confirmed, rebuild it rather than clean it.

Full reference

What the record actually tells you

Parameter What it holds What you do with it
1 The virtual address whose execution was attempted Tells you where, not who. Useful once you have symbols
2 The contents of the page table entry for that address Confirms the page was marked non-executable rather than simply unmapped
3 and 4 Reserved Nothing

The name of the driver that attempted the execute is printed on the bug check screen and stored in memory at KiBugCheckDriver. Where it is not available, Microsoft’s published route is a stack trace and the current instruction pointer. That is the whole documented method for this code, which is why an article that opens by telling you which vendor is at fault is guessing.

The three codes people arrive here with

Code Published meaning Where that points
0x000000BE A driver attempted to write to a read-only memory segment Same class of enforcement, write instead of execute. Parameter 1 is the attempted write address
0x0000011C An attempt was made to write to the configuration manager’s read-only protected storage Something tried to modify protected registry storage directly
0x000000D3 The system attempted to access pageable memory at a process IRQL that was too high A driver marked code or data pageable that has to stay resident. Parameter 2 is the IRQL, parameter 3 says read or write

Reading a dump without a full debugger

The BugCheck event in the System log carries the stop code and all four parameters, which is enough to tell 0xFC from 0xBE and to see whether the same address recurs. It does not carry the module name. For that you need the Windows debugging tools, which are a free download from Microsoft, and a dump larger than nothing – check that the machine is configured to write one before you wait for the next crash.

Commands used in this investigation

Command What it gives you
!analyze -v Automated analysis, including the module that attempted the execute where it can be resolved
pnputil /enum-drivers Third-party driver packages in the driver store, with provider and version
driverquery /si /fo table Signed-driver information. Microsoft documents /v as not valid for signed drivers, so use /si for this question
fltmc Loaded file system filter drivers. fltmc unload <name> takes one out of the path for a test
sfc /scannow Checks and repairs protected system files

When the module changes between crashes

A different name in every dump is not four broken drivers. It is the signature of something corrupting memory that other components then use, and the driver that dies is whichever one read the damaged value. At that point stop chasing the name and go after the corruption: test memory, and enable Driver Verifier’s special pool against third-party drivers on a machine you can afford to have crash repeatedly. Microsoft is explicit that Driver Verifier should only be run on computers used for testing and debugging, so do not leave it enabled on anything anyone depends on.

What not to do

  • Do not disable no-execute enforcement in the boot configuration. It converts a clean, diagnosable stop into silent execution of code from a data page, and it makes the machine materially easier to exploit.
  • Do not reinstall Windows first. The stop names a driver, and a reinstall that puts the same driver back reproduces the crash.
  • Do not accept a Windows Update driver as ‘the current build’ when the vendor publishes a newer one. For kernel components the vendor’s own download is usually ahead.
  • Do not run two products that both hook the same kernel paths and then troubleshoot the crash. Remove one first, then decide.

Every code this article covers

Code What it points at Source
0x000000FC An attempt was made to execute non-executable memory. Parameter 1 is the address, parameter 2 the page table entry contents, and the offending driver’s name is saved in KiBugCheckDriver Microsoft Learn
0x000000BE Issued when a driver attempts to write to a read-only memory segment. Parameter 1 is the attempted write address Microsoft Learn
0x0000011C An attempt was made to write to the read-only protected storage of the configuration manager Microsoft Learn
0x000000D3 The system attempted to access pageable memory at a process IRQL that was too high, usually because a driver marked its own code or data pageable when it must be resident Microsoft Learn

Confirm the fix worked

  1. Run the machine through its normal workload for a full day with no new file appearing in %SystemRoot%\Minidump.
  2. Confirm the module named in the old dumps is no longer loaded, or is now at the vendor’s current version.
  3. Confirm sfc /scannow completes with no integrity violations.
  4. Check driverquery /si /fo table and confirm you can account for everything unsigned.
  5. Confirm the protections you expect are still on under Windows Security, Device security, Core isolation details.

Questions people ask about this

Can I disable DEP and carry on?

You should not. The no-execute bit is what turned an attempt to run code from a data page into a clean stop you can diagnose. Turning it off does not fix the driver; it removes the evidence and the protection at the same time. Microsoft’s published resolution for this code is to identify the driver.

Is this always malware?

No, and assuming so wastes a day. Microsoft publishes no cause for 0xFC at all. Legacy drivers and kernel-hooking commercial software account for most cases people actually resolve. Scan for malware because it is cheap and it is one genuine possibility, but read the dump before you conclude anything.

Does resolving this require buying software?

No. Every step here uses tools that ship with Windows or free vendor drivers, and Microsoft Defender is included for the offline scan. Money only enters if a product you already own needs a current build.

Why did it start immediately after a Windows update?

The most useful answer is that the driver did not change and the enforcement did. That is a reasonable reading rather than a documented one – Microsoft does not publish causes for this code – so treat it as a hypothesis and check whether the vendor has published a build for your Windows version.

The stop screen did not show me any parameters. Where are they?

Current Windows stop screens show the stop code, a QR code and sometimes a failing module name, not the four bugcheck parameters. Read them from the BugCheck event under Windows Logs then System, or from the dump.

Related error codes

Was this article helpful?

Your feedback helps us improve our documentation.

Related articles

Free Fix REGISTRY_ERROR 0x00000051 and BAD_SYSTEM_CONFIG_INFO 0x00000074 at startup License Error BAD_POOL_HEADER 0x00000019 and BAD_POOL_CALLER 0x000000C2 explained Free Fix System Restore failed with 0x80070091 or 0x81000203 on Windows 10 and 11 Free Fix UNEXPECTED_KERNEL_MODE_TRAP 0x0000007F – double fault and stack overflow
← Back to Knowledge Base