PFN_LIST_CORRUPT!!!!

[mo_frap]

Hi can any one help me? I have recently built a pc for my mother oops, big mistake!
It was running fine for about a week, but now just keeps going to Blue Screen at boot up, saying: “a problem has been detected and Windows has been Shut Down to Prevent Damage to your computer”….: “PFN_LIST_CORRUPT”!!
(***STOP: 0x0000008f, 0x00003B1E, 0x00003B5E, 0x00000000)

Now the last thing she said she did was to change the DeskTop Wallpaper! And now when you boot up the PC, it says the last time you started your pc windows didn’t load or some thing, do you want to load in safe mode? YES…So it starts to load in windows then the Blue Screen appears for a split second saying PFN_LIST_CORRUPT! And then ReBoots and crashes and just stays in a loop of start up and shut down.
So I thought I would reformat the hard drive, because I thought Windows might be Corrupt! And the same thing happens after I get to the point where you choose if you want to Repair or install a fresh windows,,, Blue Screen. On the rare time when windows does boot up, every thing is fine until I shut down and restart the pc the same thing again..CRASH AND LOOP!

Can any one tell me what: “PFN_LIST_CORRUPT”!!
(***STOP: 0x0000008f, 0x00003B1E, 0x00003B5E, 0x00000000) means??
And also how do you turn off Windows start up shut down loop??

AMD2200xp, IBM40GIG, ASROCK MBoard (cheep one) and 256DDR
THANKS for your time..
Steve@London

 

[Crashman]

Get a copy of Memtest86 (the one that creats a bootable floppy) and run it, you might have a RAM failure.

<font color=blue>Only a place as big as the internet could be home to a hero as big as Crashman!</font color=blue>
<font color=red>Only a place as big as the internet could be home to an ego as large as Crashman's!</font color=red>

 

[RichPLS]

Windows tracks physical pages of memory using a table called the Page Frame Database. This database (which actually is just a big one-dimensional array) is indexed by physical page number. As a result, the page frame database is typically referred to as the Page Frame Number list or PFN.

Every page of physical memory has an associated PFN entry. Each PFN entry contains information about the state of its corresponding physical page in the system. This state includes information about whether the corresponding physical page is in use, how it’s being used, a count of active users of the page, and a count of pending I/O operations on the page.

Depending on the pages state, a PFN entry may be on one of several lists that the Memory Manager maintains. The listheads for these lists are simple global variables that are used for quick access to PFN entries of certain types. For example, one such list would be the list that contains all the modified pages that need to be written to disk.

Because all the PFN lists and entries are present in the high half of kernel virtual address space, they are subject to corruption through stray pointer accesses (such as by errant drivers or other similar kernel-mode modules). Also, the count in the PFN that tracks the number of I/O related accesses to a given physical page can be corrupted by improper MDL handling.

Whenever Windows detects that any of the PFN lists or any of the PFN entries themselves have become invalid, the system halts with a PFN_LIST_CORRUPT bugcheck.

This bugcheck usually occurs for one of two reasons, the first reason being memory corruption. If there is a buggy driver in the system that is writing on memory that it does not own, it could easily corrupt one of the PFN lists or entries. In order to rule this out, you should run Driver Verifier with Special Pool enabled for suspect drivers in the system. This will hopefully allow you to catch the misbehaving driver in the act of scribbling memory, instead of receiving a crash sometime later when the O/S discovers the damage.

The second cause for this bugcheck is incorrect MDL handling. For example, one use of MDLs is to allow you to "lock" the physical memory that backs a virtual address range so that the memory stays resident while your driver is accessing it. This is achieved by using the MmProbeAndLockPages DDI. One of the things that this DDI does is take out a reference on the PFN entries of the underlying physical pages, ensuring that the Memory Manager does not page them out. The corresponding DDI to undo this operation, MmUnlockPages, is responsible for decrementing the reference counts taken out in the previous call. If a driver happens to call MmUnlockPages too many times on an MDL, the reference count on the underlying PFN entries could drop to below zero (to 0xFFFFFFFF). The system considers this to be a critical error, as one or more of the PFN entries is obviously invalid. Therefore, this bugcheck will occur.

If your driver or a driver in your stack is being blamed for a PFN_LIST_CORRUPT bugcheck, go over your code and make sure that you are properly handling your MDLs . Remember that even if you do not create or destroy any MDLs directly, you play a part in the creation and destruction of them if you handle IRPs whose buffers are described with DIRECT_IO. Driver Verifier and the checked build of Windows can help pinpoint IRP and MDL handling errors.

How this is fixed varies depending on the reason of the bugcheck. Using Driver Verifier and the checked build of the O/S should allow you to pinpoint the driver that is either corrupting memory or mishandling MDLs. If the offending driver is not a driver that you have any control over, the only available option is disabling the driver until a fixed version is available.

This behavior can occur because a driver or other problem damaged the input/output (I/O) driver structures.


========================
Try everything...
Do not be afraid of failure, for this is how we learn and grow...
Live life to the fullest...
Do not regret what you have not yet done!!!