The MEMORY_MANAGEMENT bug check has a value of 0x0000001A. This indicates that a severe memory management error occurred.


This topic is for programmers. If you are a customer who has received a blue screen error code while using your computer, see Troubleshoot blue screen errors.


Parameter 1 identifies the exact violation.

Parameter 1 Cause of Error


The fork clone block reference count is corrupt. (This only occurs on checked builds of Windows.)


The image relocation fix-up table or code stream has been corrupted. This is probably a hardware error.


An inpage operation failed with a CRC error. Parameter 2 contains the pagefile offset. Parameter 3 contains the page CRC value. Parameter 4 contains the expected CRC value.


The page table and PFNs are out of sync . This is probably a hardware error, especially if parameters 3 & 4 differ by only a single bit.


A page table entry (PTE) has been corrupted. Parameter 2 is the address of the PTE.


The caller is unlocking a system cache address that is not currently locked. (This address was either never mapped or is being unlocked twice.)


The system is using the very last system cache view address, instead of preserving it.



The PTEs mapping the argument system cache view have been corrupted.


A caller of MmGetSystemAddressForMdl* tried to map a fully-cached physical page as non-cached. This action would cause a conflicting hardware translation buffer entry, and so it was refused by the operating system. Since the caller specified "bug check on failure" in the requesting MDL, the system had no choice but to issue a bug check in this instance.


The caller is unlocking a pageable section that is not currently locked. (This section was either never locked or is being unlocked twice.)


A driver tried to map a physical memory page that was not locked. This is illegal because the contents or attributes of the page can change at any time. This is a bug in the code that made the mapping call. Parameter 2 is the page frame number of the physical page that the driver attempted to map.


The caller is trying lock a nonexistent pageable section.


The caller is trying to protect an MDL with an invalid mapping.


The caller specified an MDL that contains an unlocked (or invalid) physical page. Parameter 2 contains a pointer to the MDL. Parameter 3 contains a pointer to the invalid PFN. Parameter 4 contains the invalid PFN value.


The PTEs of a kernel thread stack that has been swapped out are corrupted.


All the page table pages of an exited process could not be deleted due to outstanding references. This typically indicates corruption in the process’ page table structures.


A driver tried to write to an unallocated address in the user space of the system process. Parameter 2 contains the address of the attempted write.


The working set free list is corrupt. This is probably a hardware error.


The allocation bitmap is corrupt. The memory manager is about to overwrite a virtual address that was already in use.


A page on a free pool SLIST has been corrupted. This can be the result of a write-after-free bug in a driver, or an overrun from a previous page. Parameter 2 contains the address of a free pool block. Parameter 4 contains the value that was expected to be at that address. Parameter 3 contains the actual value that was found.


(Windows 7 only). Two pages on the standby list that were supposed to have identical page priority values do not, in fact, have identical page priority values. The differing values are captured in parameter 4.



Internal memory management structures are corrupted.


Internal memory management structures (likely the PTE or PFN) are corrupted.


A PFN (parameter 2) was encountered with a corrupted linkage no longer connected to its top level process. This indicates corruption in the PFN structures.


An error occurred In the process of un-securing memory that was previously secured. This can happen when the caller mistakenly invoked MmUnsecureVirtualMemory in the wrong process context.


The working set index encoded in the PTE is corrupted.


A PTE or the working set list is corrupted.


The caller is trying to free an invalid pool address.


The working set list is corrupted.


An illegal page fault occurred while holding working set synchronization. Parameter 2 contains the referenced virtual address.


A page table page has been corrupted. On a 64 bit version of Windows, parameter 2 contains the address of the PFN for the corrupted page table page. On a 32 bit version of Windows, parameter 2 contains a pointer to the number of used PTEs, and parameter 3 contains the number of used PTEs.


A corrupted PTE has been detected. Parameter 2 contains the address of the PTE. Parameters 3/4 contain the low/high parts of the PTE.


A page table page has been corrupted. Parameter 2 contains a pointer to the last processed PTE. Parameter 3 contains the number of non-zero PTEs found. Parameter 4 contains the expected number of non-zero PTEs in the page table.

This memory parameter has been deprecated and is no longer available after Windows 10 version 1803.


A PDE has been unexpectedly invalidated.


The paging hierarchy is corrupt. Parameter 2 is a pointer to the virtual address which caused the fault.


The MDL being created is flawed. This almost always means the driver calling MmProbeAndLockPages is at fault. Typically the driver is attempting to create a Write MDL when it is being asked to process a paging Read.


The IoPageFrameNode is null. Parameter 2 is PageFrameIndex.


An error occurred when decrementing the reference counts on I/O space physical pages which are being unmapped. An entry which is not currently referenced is being dereferenced. Parameter 2 and 3 describe the caller’s I/O space range being unmapped, and parameter 4 is the I/O space physical page which is expected to be referenced but is not.


The boot loader is broken. (This value applies only to Intel Itanium machines.)


The range to remove (or truncate) is in use by the loader so it cannot be safely removed, so the system must issue a stop code. Parameter 2 is HighestPhysicalPage.


The !analyze debug extension displays information about the bug check and can be helpful in determining the root cause.

Running the Windows Memory Diagnostic tool could be useful as well to exclude any kind of problem affecting the physical memory modules.