[CMAKE]

[reactos.git] / ntoskrnl / mm / ARM3 / pfnlist.c

diff --git a/ntoskrnl/mm/ARM3/pfnlist.c b/ntoskrnl/mm/ARM3/pfnlist.c
index fb24d9f..9c2f5bd 100644 (file)
--- a/ntoskrnl/mm/ARM3/pfnlist.c
+++ b/ntoskrnl/mm/ARM3/pfnlist.c
@@ -34,6 +34,7 @@ do { \
 
 BOOLEAN MmDynamicPfn;
 BOOLEAN MmMirroring;
 
 BOOLEAN MmDynamicPfn;
 BOOLEAN MmMirroring;

+ULONG MmSystemPageColor;

 
 MMPFNLIST MmZeroedPageListHead = {0, ZeroedPageList, LIST_HEAD, LIST_HEAD};
 MMPFNLIST MmFreePageListHead = {0, FreePageList, LIST_HEAD, LIST_HEAD};
 
 MMPFNLIST MmZeroedPageListHead = {0, ZeroedPageList, LIST_HEAD, LIST_HEAD};
 MMPFNLIST MmFreePageListHead = {0, FreePageList, LIST_HEAD, LIST_HEAD};


@@ -54,6 +55,10 @@ PMMPFNLIST MmPageLocationList[] =
     NULL,
     NULL
 };
     NULL,
     NULL
 };

+
+ULONG MI_PFN_CURRENT_USAGE;
+CHAR MI_PFN_CURRENT_PROCESS_NAME[16] = "None yet";
+

 /* FUNCTIONS ******************************************************************/
 
 VOID
 /* FUNCTIONS ******************************************************************/
 
 VOID


@@ -66,141 +71,11 @@ MiZeroPhysicalPage(IN PFN_NUMBER PageFrameIndex)
 
     /* Map in hyperspace, then wipe it using XMMI or MEMSET */
     VirtualAddress = MiMapPageInHyperSpace(Process, PageFrameIndex, &OldIrql);
 
     /* Map in hyperspace, then wipe it using XMMI or MEMSET */
     VirtualAddress = MiMapPageInHyperSpace(Process, PageFrameIndex, &OldIrql);

+    ASSERT(VirtualAddress);

     KeZeroPages(VirtualAddress, PAGE_SIZE);
     MiUnmapPageInHyperSpace(Process, VirtualAddress, OldIrql);
 }
 
     KeZeroPages(VirtualAddress, PAGE_SIZE);
     MiUnmapPageInHyperSpace(Process, VirtualAddress, OldIrql);
 }
 

-VOID
-NTAPI
-MiInsertInListTail(IN PMMPFNLIST ListHead,
-                   IN PMMPFN Entry)
-{
-    PFN_NUMBER OldBlink, EntryIndex = MiGetPfnEntryIndex(Entry);
-    ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
-    ASSERT_LIST_INVARIANT(ListHead);
-
-    /* Get the back link */
-    OldBlink = ListHead->Blink;
-    if (OldBlink != LIST_HEAD)
-    {
-        /* Set the back pointer to point to us now */
-        MiGetPfnEntry(OldBlink)->u1.Flink = EntryIndex;
-    }
-    else
-    {
-        /* Set the list to point to us */
-        ListHead->Flink = EntryIndex;
-    }
-    
-    /* Set the entry to point to the list head forwards, and the old page backwards */
-    Entry->u1.Flink = LIST_HEAD;
-    Entry->u2.Blink = OldBlink;
-    
-    /* And now the head points back to us, since we are last */
-    ListHead->Blink = EntryIndex;
-    ListHead->Total++;
-       ASSERT_LIST_INVARIANT(ListHead);
-}
-
-VOID
-NTAPI
-MiInsertZeroListAtBack(IN PFN_NUMBER EntryIndex)
-{
-    PFN_NUMBER OldBlink;
-    PMMPFNLIST ListHead;
-    PMMPFN Pfn1;
-#if 0
-    PMMPFN Blink;
-    ULONG Color;
-    PMMCOLOR_TABLES ColorHead;
-#endif
-
-    /* Make sure the PFN lock is held */
-    ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
-    
-    /* Get the descriptor */
-    Pfn1 = MiGetPfnEntry(EntryIndex);
-    ASSERT(Pfn1->u3.e2.ReferenceCount == 0);
-    ASSERT(Pfn1->u4.MustBeCached == 0);
-    ASSERT(Pfn1->u3.e1.Rom == 0);
-    ASSERT(Pfn1->u3.e1.RemovalRequested == 0);
-    ASSERT(Pfn1->u4.InPageError == 0);
-    
-    /* Use the zero list */
-    ListHead = &MmZeroedPageListHead;
-    ASSERT_LIST_INVARIANT(ListHead);
-    ListHead->Total++;
-
-    /* Get the back link */
-    OldBlink = ListHead->Blink;
-    if (OldBlink != LIST_HEAD)
-    {
-        /* Set the back pointer to point to us now */
-        MiGetPfnEntry(OldBlink)->u1.Flink = EntryIndex;
-    }
-    else
-    {
-        /* Set the list to point to us */
-        ListHead->Flink = EntryIndex;
-    }
-    
-    /* Set the entry to point to the list head forwards, and the old page backwards */
-    Pfn1->u1.Flink = LIST_HEAD;
-    Pfn1->u2.Blink = OldBlink;
-    
-    /* And now the head points back to us, since we are last */
-    ListHead->Blink = EntryIndex;
-       ASSERT_LIST_INVARIANT(ListHead);
-    
-    /* Update the page location */
-    Pfn1->u3.e1.PageLocation = ZeroedPageList;
-
-    /* FIXME: NOT YET Due to caller semantics: Update the available page count */
-    //MmAvailablePages++;
-
-    /* Check if we've reached the configured low memory threshold */
-    if (MmAvailablePages == MmLowMemoryThreshold)
-    {
-        /* Clear the event, because now we're ABOVE the threshold */
-        KeClearEvent(MiLowMemoryEvent);
-    }
-    else if (MmAvailablePages == MmHighMemoryThreshold)
-    {
-        /* Otherwise check if we reached the high threshold and signal the event */
-        KeSetEvent(MiHighMemoryEvent, 0, FALSE);
-    }
-
-#if 0
-    /* Get the page color */
-    Color = EntryIndex & MmSecondaryColorMask;
-
-    /* Get the first page on the color list */
-    ColorHead = &MmFreePagesByColor[ZeroedPageList][Color];
-    if (ColorHead->Flink == LIST_HEAD)
-    {
-        /* The list is empty, so we are the first page */
-        Pfn1->u4.PteFrame = -1;
-        ColorHead->Flink = EntryIndex;
-    }
-    else
-    {
-        /* Get the previous page */
-        Blink = (PMMPFN)ColorHead->Blink;
-        
-        /* Make it link to us */
-        Pfn1->u4.PteFrame = MiGetPfnEntryIndex(Blink);
-        Blink->OriginalPte.u.Long = EntryIndex;
-    }
-    
-    /* Now initialize our own list pointers */
-    ColorHead->Blink = Pfn1;
-    Pfn1->OriginalPte.u.Long = LIST_HEAD;
-    
-    /* And increase the count in the colored list */
-    ColorHead->Count++;
-#endif
-}
-

 VOID
 NTAPI
 MiUnlinkFreeOrZeroedPage(IN PMMPFN Entry)
 VOID
 NTAPI
 MiUnlinkFreeOrZeroedPage(IN PMMPFN Entry)


@@ -208,6 +83,9 @@ MiUnlinkFreeOrZeroedPage(IN PMMPFN Entry)
     PFN_NUMBER OldFlink, OldBlink;
     PMMPFNLIST ListHead;
     MMLISTS ListName;
     PFN_NUMBER OldFlink, OldBlink;
     PMMPFNLIST ListHead;
     MMLISTS ListName;

+    ULONG Color;
+    PMMCOLOR_TABLES ColorTable;
+    PMMPFN Pfn1;

     
     /* Make sure the PFN lock is held */
     ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
     
     /* Make sure the PFN lock is held */
     ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);


@@ -235,7 +113,7 @@ MiUnlinkFreeOrZeroedPage(IN PMMPFN Entry)
     if (OldFlink != LIST_HEAD)
     {
         /* It is not, so set the backlink of the actual entry, to our backlink */
     if (OldFlink != LIST_HEAD)
     {
         /* It is not, so set the backlink of the actual entry, to our backlink */

-        MiGetPfnEntry(OldFlink)->u2.Blink = OldBlink;
+        MI_PFN_ELEMENT(OldFlink)->u2.Blink = OldBlink;

     }
     else
     {
     }
     else
     {


@@ -247,20 +125,72 @@ MiUnlinkFreeOrZeroedPage(IN PMMPFN Entry)
     if (OldBlink != LIST_HEAD)
     {
         /* It is not, so set the backlink of the actual entry, to our backlink */
     if (OldBlink != LIST_HEAD)
     {
         /* It is not, so set the backlink of the actual entry, to our backlink */

-        MiGetPfnEntry(OldBlink)->u1.Flink = OldFlink;
+        MI_PFN_ELEMENT(OldBlink)->u1.Flink = OldFlink;

     }
     else
     {
         /* Set the list head's backlink instead */
         ListHead->Flink = OldFlink;
     }
     }
     else
     {
         /* Set the list head's backlink instead */
         ListHead->Flink = OldFlink;
     }

+
+    /* Get the page color */
+    OldBlink = MiGetPfnEntryIndex(Entry);
+    Color = OldBlink & MmSecondaryColorMask;
+
+    /* Get the first page on the color list */
+    ColorTable = &MmFreePagesByColor[ListName][Color];
+
+    /* Check if this was was actually the head */
+    OldFlink = ColorTable->Flink;
+    if (OldFlink == OldBlink)
+    {
+        /* Make the table point to the next page this page was linking to */
+        ColorTable->Flink = Entry->OriginalPte.u.Long;
+        if (ColorTable->Flink != LIST_HEAD)
+        {
+            /* And make the previous link point to the head now */
+            MI_PFN_ELEMENT(ColorTable->Flink)->u4.PteFrame = COLORED_LIST_HEAD;
+        }
+        else
+        {
+            /* And if that page was the head, loop the list back around */
+            ColorTable->Blink = (PVOID)LIST_HEAD;
+        }
+    }
+    else
+    {
+        /* This page shouldn't be pointing back to the head */
+        ASSERT(Entry->u4.PteFrame != COLORED_LIST_HEAD);
+
+        /* Make the back link point to whoever the next page is */
+        Pfn1 = MI_PFN_ELEMENT(Entry->u4.PteFrame);
+        Pfn1->OriginalPte.u.Long = Entry->OriginalPte.u.Long;
+
+        /* Check if this page was pointing to the head */
+        if (Entry->OriginalPte.u.Long != LIST_HEAD)
+        {
+            /* Make the back link point to the head */
+            Pfn1 = MI_PFN_ELEMENT(Entry->OriginalPte.u.Long);
+            Pfn1->u4.PteFrame = Entry->u4.PteFrame;
+        }
+        else
+        {
+            /* Then the table is directly back pointing to this page now */
+            ColorTable->Blink = Pfn1;
+        }
+    }
+
+    /* One less colored page */
+    ASSERT(ColorTable->Count >= 1);
+    ColorTable->Count--;

     
     

+    /* ReactOS Hack */
+    Entry->OriginalPte.u.Long = 0;
+

     /* We are not on a list anymore */
     Entry->u1.Flink = Entry->u2.Blink = 0;
     ASSERT_LIST_INVARIANT(ListHead);
 
     /* We are not on a list anymore */
     Entry->u1.Flink = Entry->u2.Blink = 0;
     ASSERT_LIST_INVARIANT(ListHead);
 

-    /* FIXME: Deal with color list */
-    

     /* See if we hit any thresholds */
     if (MmAvailablePages == MmHighMemoryThreshold)
     {
     /* See if we hit any thresholds */
     if (MmAvailablePages == MmHighMemoryThreshold)
     {


@@ -278,6 +208,14 @@ MiUnlinkFreeOrZeroedPage(IN PMMPFN Entry)
     {
         /* FIXME: Should wake up the MPW and working set manager, if we had one */
     }
     {
         /* FIXME: Should wake up the MPW and working set manager, if we had one */
     }

+    
+#if MI_TRACE_PFNS
+    ASSERT(MI_PFN_CURRENT_USAGE != MI_USAGE_NOT_SET);
+    Entry->PfnUsage = MI_PFN_CURRENT_USAGE;
+    memcpy(Entry->ProcessName, MI_PFN_CURRENT_PROCESS_NAME, 16);
+//    MI_PFN_CURRENT_USAGE = MI_USAGE_NOT_SET;
+//    memcpy(MI_PFN_CURRENT_PROCESS_NAME, "Not Set", 16);
+#endif

 }
 
 PFN_NUMBER
 }
 
 PFN_NUMBER


@@ -290,15 +228,14 @@ MiRemovePageByColor(IN PFN_NUMBER PageIndex,
     MMLISTS ListName;
     PFN_NUMBER OldFlink, OldBlink;
     ULONG OldColor, OldCache;
     MMLISTS ListName;
     PFN_NUMBER OldFlink, OldBlink;
     ULONG OldColor, OldCache;

-#if 0

     PMMCOLOR_TABLES ColorTable;
     PMMCOLOR_TABLES ColorTable;

-#endif   
+

     /* Make sure PFN lock is held */
     ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
     ASSERT(Color < MmSecondaryColors);
 
     /* Get the PFN entry */
     /* Make sure PFN lock is held */
     ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
     ASSERT(Color < MmSecondaryColors);
 
     /* Get the PFN entry */

-    Pfn1 = MiGetPfnEntry(PageIndex);
+    Pfn1 = MI_PFN_ELEMENT(PageIndex);

     ASSERT(Pfn1->u3.e1.RemovalRequested == 0);
     ASSERT(Pfn1->u3.e1.Rom == 0);
     
     ASSERT(Pfn1->u3.e1.RemovalRequested == 0);
     ASSERT(Pfn1->u3.e1.Rom == 0);
     


@@ -323,19 +260,19 @@ MiRemovePageByColor(IN PFN_NUMBER PageIndex,
     if (OldFlink != LIST_HEAD)
     {
         /* It is not, so set the backlink of the actual entry, to our backlink */
     if (OldFlink != LIST_HEAD)
     {
         /* It is not, so set the backlink of the actual entry, to our backlink */

-        MiGetPfnEntry(OldFlink)->u2.Blink = OldBlink;
+        MI_PFN_ELEMENT(OldFlink)->u2.Blink = OldBlink;

     }
     else
     {
         /* Set the list head's backlink instead */
     }
     else
     {
         /* Set the list head's backlink instead */

-        ListHead->Blink = OldFlink;
+        ListHead->Blink = OldBlink;

     }
     
     /* Check if the back entry is the list head */
     if (OldBlink != LIST_HEAD)
     {
         /* It is not, so set the backlink of the actual entry, to our backlink */
     }
     
     /* Check if the back entry is the list head */
     if (OldBlink != LIST_HEAD)
     {
         /* It is not, so set the backlink of the actual entry, to our backlink */

-        MiGetPfnEntry(OldBlink)->u1.Flink = OldFlink;
+        MI_PFN_ELEMENT(OldBlink)->u1.Flink = OldFlink;

     }
     else
     {
     }
     else
     {


@@ -352,27 +289,32 @@ MiRemovePageByColor(IN PFN_NUMBER PageIndex,
     Pfn1->u3.e1.PageColor = OldColor;
     Pfn1->u3.e1.CacheAttribute = OldCache;
 
     Pfn1->u3.e1.PageColor = OldColor;
     Pfn1->u3.e1.CacheAttribute = OldCache;
 

-#if 0 // When switching to ARM3

     /* Get the first page on the color list */
     /* Get the first page on the color list */

+    ASSERT(Color < MmSecondaryColors);

     ColorTable = &MmFreePagesByColor[ListName][Color];
     ASSERT(ColorTable->Count >= 1);
     
     /* Set the forward link to whoever we were pointing to */
     ColorTable->Flink = Pfn1->OriginalPte.u.Long;
     ColorTable = &MmFreePagesByColor[ListName][Color];
     ASSERT(ColorTable->Count >= 1);
     
     /* Set the forward link to whoever we were pointing to */
     ColorTable->Flink = Pfn1->OriginalPte.u.Long;

+    
+    /* Get the first page on the color list */

     if (ColorTable->Flink == LIST_HEAD)
     {
         /* This is the beginning of the list, so set the sentinel value */
     if (ColorTable->Flink == LIST_HEAD)
     {
         /* This is the beginning of the list, so set the sentinel value */

-        ColorTable->Blink = LIST_HEAD;    
+        ColorTable->Blink = (PVOID)LIST_HEAD;    

     }
     else
     {
         /* The list is empty, so we are the first page */
     }
     else
     {
         /* The list is empty, so we are the first page */

-        MiGetPfnEntry(ColorTable->Flink)->u4.PteFrame = -1;
+        MI_PFN_ELEMENT(ColorTable->Flink)->u4.PteFrame = COLORED_LIST_HEAD;

     }
     
     }
     

-    /* One more page */
-    ColorTable->Total++;
-#endif
+    /* One less page */
+    ColorTable->Count--;
+    
+    /* ReactOS Hack */
+    Pfn1->OriginalPte.u.Long = 0;
+

     /* See if we hit any thresholds */
     if (MmAvailablePages == MmHighMemoryThreshold)
     {
     /* See if we hit any thresholds */
     if (MmAvailablePages == MmHighMemoryThreshold)
     {


@@ -391,6 +333,14 @@ MiRemovePageByColor(IN PFN_NUMBER PageIndex,
         /* FIXME: Should wake up the MPW and working set manager, if we had one */
     }
 
         /* FIXME: Should wake up the MPW and working set manager, if we had one */
     }
 

+#if MI_TRACE_PFNS
+    //ASSERT(MI_PFN_CURRENT_USAGE != MI_USAGE_NOT_SET);
+    Pfn1->PfnUsage = MI_PFN_CURRENT_USAGE;
+    memcpy(Pfn1->ProcessName, MI_PFN_CURRENT_PROCESS_NAME, 16);
+    //MI_PFN_CURRENT_USAGE = MI_USAGE_NOT_SET;
+    //memcpy(MI_PFN_CURRENT_PROCESS_NAME, "Not Set", 16);
+#endif
+

     /* Return the page */
     return PageIndex;
 }
     /* Return the page */
     return PageIndex;
 }


@@ -406,9 +356,8 @@ MiRemoveAnyPage(IN ULONG Color)
     ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
     ASSERT(MmAvailablePages != 0);
     ASSERT(Color < MmSecondaryColors);
     ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
     ASSERT(MmAvailablePages != 0);
     ASSERT(Color < MmSecondaryColors);

-    
+

     /* Check the colored free list */
     /* Check the colored free list */

-#if 0 // Enable when using ARM3 database */

     PageIndex = MmFreePagesByColor[FreePageList][Color].Flink;
     if (PageIndex == LIST_HEAD)
     {
     PageIndex = MmFreePagesByColor[FreePageList][Color].Flink;
     if (PageIndex == LIST_HEAD)
     {


@@ -416,7 +365,6 @@ MiRemoveAnyPage(IN ULONG Color)
         PageIndex = MmFreePagesByColor[ZeroedPageList][Color].Flink;
         if (PageIndex == LIST_HEAD)
         {
         PageIndex = MmFreePagesByColor[ZeroedPageList][Color].Flink;
         if (PageIndex == LIST_HEAD)
         {

-#endif

             /* Check the free list */
             ASSERT_LIST_INVARIANT(&MmFreePageListHead);
             PageIndex = MmFreePageListHead.Flink;
             /* Check the free list */
             ASSERT_LIST_INVARIANT(&MmFreePageListHead);
             PageIndex = MmFreePageListHead.Flink;


@@ -434,16 +382,14 @@ MiRemoveAnyPage(IN ULONG Color)
                     ASSERT(MmZeroedPageListHead.Total == 0);
                 }
             }
                     ASSERT(MmZeroedPageListHead.Total == 0);
                 }
             }

-#if 0 // Enable when using ARM3 database */

         }
     }
         }
     }

-#endif

 
     /* Remove the page from its list */
     PageIndex = MiRemovePageByColor(PageIndex, Color);
 
     /* Sanity checks */
 
     /* Remove the page from its list */
     PageIndex = MiRemovePageByColor(PageIndex, Color);
 
     /* Sanity checks */

-    Pfn1 = MiGetPfnEntry(PageIndex);
+    Pfn1 = MI_PFN_ELEMENT(PageIndex);

     ASSERT((Pfn1->u3.e1.PageLocation == FreePageList) ||
            (Pfn1->u3.e1.PageLocation == ZeroedPageList));
     ASSERT(Pfn1->u3.e2.ReferenceCount == 0);
     ASSERT((Pfn1->u3.e1.PageLocation == FreePageList) ||
            (Pfn1->u3.e1.PageLocation == ZeroedPageList));
     ASSERT(Pfn1->u3.e2.ReferenceCount == 0);


@@ -469,25 +415,23 @@ MiRemoveZeroPage(IN ULONG Color)
     ASSERT(Color < MmSecondaryColors);
 
     /* Check the colored zero list */
     ASSERT(Color < MmSecondaryColors);
 
     /* Check the colored zero list */

-#if 0 // Enable when using ARM3 database */

     PageIndex = MmFreePagesByColor[ZeroedPageList][Color].Flink;
     if (PageIndex == LIST_HEAD)
     {
     PageIndex = MmFreePagesByColor[ZeroedPageList][Color].Flink;
     if (PageIndex == LIST_HEAD)
     {

-#endif

         /* Check the zero list */
         ASSERT_LIST_INVARIANT(&MmZeroedPageListHead);
         PageIndex = MmZeroedPageListHead.Flink;
         Color = PageIndex & MmSecondaryColorMask;
         if (PageIndex == LIST_HEAD)
         {
         /* Check the zero list */
         ASSERT_LIST_INVARIANT(&MmZeroedPageListHead);
         PageIndex = MmZeroedPageListHead.Flink;
         Color = PageIndex & MmSecondaryColorMask;
         if (PageIndex == LIST_HEAD)
         {

+            /* This means there's no zero pages, we have to look for free ones */

             ASSERT(MmZeroedPageListHead.Total == 0);
             Zero = TRUE;
             ASSERT(MmZeroedPageListHead.Total == 0);
             Zero = TRUE;

-#if 0 // Enable when using ARM3 database */
+

             /* Check the colored free list */
             /* Check the colored free list */

-            PageIndex = MmFreePagesByColor[ZeroedPageList][Color].Flink;
+            PageIndex = MmFreePagesByColor[FreePageList][Color].Flink;

             if (PageIndex == LIST_HEAD)
             {
             if (PageIndex == LIST_HEAD)
             {

-#endif

                 /* Check the free list */
                 ASSERT_LIST_INVARIANT(&MmFreePageListHead);
                 PageIndex = MmFreePageListHead.Flink;
                 /* Check the free list */
                 ASSERT_LIST_INVARIANT(&MmFreePageListHead);
                 PageIndex = MmFreePageListHead.Flink;


@@ -498,21 +442,18 @@ MiRemoveZeroPage(IN ULONG Color)
                     /* FIXME: Should check the standby list */
                     ASSERT(MmZeroedPageListHead.Total == 0);
                 }
                     /* FIXME: Should check the standby list */
                     ASSERT(MmZeroedPageListHead.Total == 0);
                 }

-#if 0 // Enable when using ARM3 database */

             }
             }

-#endif

         }
         }

-#if 0 // Enable when using ARM3 database */

     }
     }

-#endif
+

     /* Sanity checks */
     /* Sanity checks */

-    Pfn1 = MiGetPfnEntry(PageIndex);
+    Pfn1 = MI_PFN_ELEMENT(PageIndex);

     ASSERT((Pfn1->u3.e1.PageLocation == FreePageList) ||
            (Pfn1->u3.e1.PageLocation == ZeroedPageList));
 
     /* Remove the page from its list */
     PageIndex = MiRemovePageByColor(PageIndex, Color);
     ASSERT((Pfn1->u3.e1.PageLocation == FreePageList) ||
            (Pfn1->u3.e1.PageLocation == ZeroedPageList));
 
     /* Remove the page from its list */
     PageIndex = MiRemovePageByColor(PageIndex, Color);

-    ASSERT(Pfn1 == MiGetPfnEntry(PageIndex));
+    ASSERT(Pfn1 == MI_PFN_ELEMENT(PageIndex));

     
     /* Zero it, if needed */
     if (Zero) MiZeroPhysicalPage(PageIndex);
     
     /* Zero it, if needed */
     if (Zero) MiZeroPhysicalPage(PageIndex);


@@ -526,45 +467,6 @@ MiRemoveZeroPage(IN ULONG Color)
     /* Return the page */
     return PageIndex;
 }
     /* Return the page */
     return PageIndex;
 }

-\f
-
-PMMPFN
-NTAPI
-MiRemoveHeadList(IN PMMPFNLIST ListHead)
-{
-    PFN_NUMBER Entry, Flink;
-    PMMPFN Pfn1;
-    ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
-    ASSERT_LIST_INVARIANT(ListHead);
-
-    /* Get the entry that's currently first on the list */
-    Entry = ListHead->Flink;
-    Pfn1 = MiGetPfnEntry(Entry);
-    
-    /* Make the list point to the entry following the first one */
-    Flink = Pfn1->u1.Flink;
-    ListHead->Flink = Flink;
-
-    /* Check if the next entry is actually the list head */
-    if (ListHead->Flink != LIST_HEAD)
-    {
-        /* It isn't, so therefore whoever is coming next points back to the head */
-        MiGetPfnEntry(Flink)->u2.Blink = LIST_HEAD;
-    }
-    else
-    {
-        /* Then the list is empty, so the backlink should point back to us */
-        ListHead->Blink = LIST_HEAD;
-    }
-  
-    /* We are not on a list anymore */
-    Pfn1->u1.Flink = Pfn1->u2.Blink = 0;
-    ListHead->Total--;
-       ASSERT_LIST_INVARIANT(ListHead);
-
-    /* Return the head element */
-    return Pfn1;
-}

 
 VOID
 NTAPI
 
 VOID
 NTAPI


@@ -573,11 +475,10 @@ MiInsertPageInFreeList(IN PFN_NUMBER PageFrameIndex)
     PMMPFNLIST ListHead;
     PFN_NUMBER LastPage;
     PMMPFN Pfn1;
     PMMPFNLIST ListHead;
     PFN_NUMBER LastPage;
     PMMPFN Pfn1;

-#if 0

     ULONG Color;
     PMMPFN Blink;
     PMMCOLOR_TABLES ColorTable;
     ULONG Color;
     PMMPFN Blink;
     PMMCOLOR_TABLES ColorTable;

-#endif
+

     /* Make sure the page index is valid */
     ASSERT(KeGetCurrentIrql() >= DISPATCH_LEVEL);
     ASSERT((PageFrameIndex != 0) &&
     /* Make sure the page index is valid */
     ASSERT(KeGetCurrentIrql() >= DISPATCH_LEVEL);
     ASSERT((PageFrameIndex != 0) &&


@@ -585,7 +486,7 @@ MiInsertPageInFreeList(IN PFN_NUMBER PageFrameIndex)
            (PageFrameIndex >= MmLowestPhysicalPage));
 
     /* Get the PFN entry */
            (PageFrameIndex >= MmLowestPhysicalPage));
 
     /* Get the PFN entry */

-    Pfn1 = MiGetPfnEntry(PageFrameIndex);
+    Pfn1 = MI_PFN_ELEMENT(PageFrameIndex);

 
     /* Sanity checks that a right kind of page is being inserted here */
     ASSERT(Pfn1->u4.MustBeCached == 0);
 
     /* Sanity checks that a right kind of page is being inserted here */
     ASSERT(Pfn1->u4.MustBeCached == 0);


@@ -604,7 +505,7 @@ MiInsertPageInFreeList(IN PFN_NUMBER PageFrameIndex)
     if (LastPage != LIST_HEAD)
     {
         /* Link us with the previous page, so we're at the end now */
     if (LastPage != LIST_HEAD)
     {
         /* Link us with the previous page, so we're at the end now */

-        MiGetPfnEntry(LastPage)->u1.Flink = PageFrameIndex;
+        MI_PFN_ELEMENT(LastPage)->u1.Flink = PageFrameIndex;

     }
     else
     {
     }
     else
     {


@@ -643,7 +544,6 @@ MiInsertPageInFreeList(IN PFN_NUMBER PageFrameIndex)
         KeSetEvent(MiHighMemoryEvent, 0, FALSE);
     }
 
         KeSetEvent(MiHighMemoryEvent, 0, FALSE);
     }
 

-#if 0 // When using ARM3 PFN

     /* Get the page color */
     Color = PageFrameIndex & MmSecondaryColorMask;
 
     /* Get the page color */
     Color = PageFrameIndex & MmSecondaryColorMask;
 


@@ -652,7 +552,7 @@ MiInsertPageInFreeList(IN PFN_NUMBER PageFrameIndex)
     if (ColorTable->Flink == LIST_HEAD)
     {
         /* The list is empty, so we are the first page */
     if (ColorTable->Flink == LIST_HEAD)
     {
         /* The list is empty, so we are the first page */

-        Pfn1->u4.PteFrame = -1;
+        Pfn1->u4.PteFrame = COLORED_LIST_HEAD;

         ColorTable->Flink = PageFrameIndex;
     }
     else
         ColorTable->Flink = PageFrameIndex;
     }
     else


@@ -660,26 +560,151 @@ MiInsertPageInFreeList(IN PFN_NUMBER PageFrameIndex)
         /* Get the previous page */
         Blink = (PMMPFN)ColorTable->Blink;
         
         /* Get the previous page */
         Blink = (PMMPFN)ColorTable->Blink;
         

-        /* Make it link to us */
-        Pfn1->u4.PteFrame = MI_PFNENTRY_TO_PFN(Blink);
+        /* Make it link to us, and link back to it */

         Blink->OriginalPte.u.Long = PageFrameIndex;
         Blink->OriginalPte.u.Long = PageFrameIndex;

+        Pfn1->u4.PteFrame = MiGetPfnEntryIndex(Blink);

     }
     
     /* Now initialize our own list pointers */
     ColorTable->Blink = Pfn1;
     }
     
     /* Now initialize our own list pointers */
     ColorTable->Blink = Pfn1;

+
+    /* This page is now the last */

     Pfn1->OriginalPte.u.Long = LIST_HEAD;
     
     /* And increase the count in the colored list */
     ColorTable->Count++;
     Pfn1->OriginalPte.u.Long = LIST_HEAD;
     
     /* And increase the count in the colored list */
     ColorTable->Count++;

+
+    /* Notify zero page thread if enough pages are on the free list now */
+    if ((ListHead->Total >= 8) && !(MmZeroingPageThreadActive))
+    {
+        /* Set the event */
+        MmZeroingPageThreadActive = TRUE;
+        KeSetEvent(&MmZeroingPageEvent, IO_NO_INCREMENT, FALSE);
+    }
+    
+#if MI_TRACE_PFNS
+    Pfn1->PfnUsage = MI_USAGE_FREE_PAGE;
+    RtlZeroMemory(Pfn1->ProcessName, 16);

 #endif
 #endif

+}
+
+/* Note: This function is hardcoded only for the zeroed page list, for now */
+VOID
+NTAPI
+MiInsertPageInList(IN PMMPFNLIST ListHead,
+                   IN PFN_NUMBER PageFrameIndex)
+{
+    PFN_NUMBER Flink;
+    PMMPFN Pfn1, Pfn2;
+    MMLISTS ListName;
+    PMMCOLOR_TABLES ColorHead;
+    ULONG Color;
+
+    /* For free pages, use MiInsertPageInFreeList */
+    ASSERT(ListHead != &MmFreePageListHead);
+
+    /* Make sure the lock is held */
+    ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);

     
     

-    /* Notify zero page thread if enough pages are on the free list now */
-    extern KEVENT ZeroPageThreadEvent;
-    if ((MmFreePageListHead.Total > 8) && !(KeReadStateEvent(&ZeroPageThreadEvent)))
+    /* Make sure the PFN is valid */
+    ASSERT((PageFrameIndex) &&
+           (PageFrameIndex <= MmHighestPhysicalPage) &&
+           (PageFrameIndex >= MmLowestPhysicalPage));
+ 
+    /* Page should be unused */
+    Pfn1 = MI_PFN_ELEMENT(PageFrameIndex);
+    ASSERT(Pfn1->u3.e2.ReferenceCount == 0);
+    ASSERT(Pfn1->u3.e1.Rom != 1);
+
+    /* Only used for zero pages in ReactOS */
+    ListName = ListHead->ListName;
+    ASSERT(ListName == ZeroedPageList);
+    ListHead->Total++;
+
+    /* Don't handle bad pages yet yet */
+    ASSERT(Pfn1->u3.e1.RemovalRequested == 0);
+
+    /* Make the head of the list point to this page now */
+    Flink = ListHead->Flink;
+    ListHead->Flink = PageFrameIndex;
+
+    /* Make the page point to the previous head, and back to the list */
+    Pfn1->u1.Flink = Flink;
+    Pfn1->u2.Blink = LIST_HEAD;
+
+    /* Was the list empty? */
+    if (Flink != LIST_HEAD)

     {
     {

-        /* This is ReactOS-specific */
-        KeSetEvent(&ZeroPageThreadEvent, IO_NO_INCREMENT, FALSE);
+        /* It wasn't, so update the backlink of the previous head page */
+        Pfn2 = MI_PFN_ELEMENT(Flink);
+        Pfn2->u2.Blink = PageFrameIndex;

     }
     }

+    else
+    {
+        /* It was empty, so have it loop back around to this new page */
+        ListHead->Blink = PageFrameIndex;
+    }
+
+    /* Move the page onto its new location */
+    Pfn1->u3.e1.PageLocation = ListName;
+
+    /* One more page on the system */
+    MmAvailablePages++;
+ 
+    /* Check if we've reached the configured low memory threshold */
+    if (MmAvailablePages == MmLowMemoryThreshold)
+    {
+        /* Clear the event, because now we're ABOVE the threshold */
+        KeClearEvent(MiLowMemoryEvent);
+    }
+    else if (MmAvailablePages == MmHighMemoryThreshold)
+    {
+        /* Otherwise check if we reached the high threshold and signal the event */
+        KeSetEvent(MiHighMemoryEvent, 0, FALSE);
+    }
+
+    /* Sanity checks */
+    ASSERT(ListName == ZeroedPageList);
+    ASSERT(Pfn1->u4.InPageError == 0);
+
+    /* Get the page color */
+    Color = PageFrameIndex & MmSecondaryColorMask;
+
+    /* Get the list for this color */
+    ColorHead = &MmFreePagesByColor[ZeroedPageList][Color];
+
+    /* Get the old head */
+    Flink = ColorHead->Flink;
+
+    /* Make this page point back to the list, and point forwards to the old head */
+    Pfn1->OriginalPte.u.Long = Flink;
+    Pfn1->u4.PteFrame = COLORED_LIST_HEAD;
+
+    /* Set the new head */
+    ColorHead->Flink = PageFrameIndex;
+
+    /* Was the head empty? */
+    if (Flink != LIST_HEAD)
+    {
+        /* No, so make the old head point to this page */
+        Pfn2 = MI_PFN_ELEMENT(Flink);
+        Pfn2->u4.PteFrame = PageFrameIndex;
+    }
+    else
+    {
+        /* Yes, make it loop back to this page */
+        ColorHead->Blink = (PVOID)Pfn1;
+    }
+
+    /* One more paged on the colored list */
+    ColorHead->Count++;
+    
+#if MI_TRACE_PFNS
+    //ASSERT(MI_PFN_CURRENT_USAGE == MI_USAGE_NOT_SET);
+    Pfn1->PfnUsage = MI_USAGE_FREE_PAGE;
+    MI_PFN_CURRENT_USAGE = MI_USAGE_NOT_SET;
+    RtlZeroMemory(Pfn1->ProcessName, 16);
+#endif

 }
 
 VOID
 }
 
 VOID


@@ -694,14 +719,24 @@ MiInitializePfn(IN PFN_NUMBER PageFrameIndex,
     ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
 
     /* Setup the PTE */
     ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
 
     /* Setup the PTE */

-    Pfn1 = MiGetPfnEntry(PageFrameIndex);
+    Pfn1 = MI_PFN_ELEMENT(PageFrameIndex);

     Pfn1->PteAddress = PointerPte;
 
     /* Check if this PFN is part of a valid address space */
     if (PointerPte->u.Hard.Valid == 1)
     {
     Pfn1->PteAddress = PointerPte;
 
     /* Check if this PFN is part of a valid address space */
     if (PointerPte->u.Hard.Valid == 1)
     {

-        /* FIXME: TODO */
-        ASSERT(FALSE);
+        /* Only valid from MmCreateProcessAddressSpace path */
+        ASSERT(PsGetCurrentProcess()->Vm.WorkingSetSize == 0);
+        
+        /* Make this a demand zero PTE */
+        MI_MAKE_SOFTWARE_PTE(&Pfn1->OriginalPte, MM_READWRITE);
+    }
+    else
+    {
+        /* Copy the PTE data */
+        Pfn1->OriginalPte = *PointerPte;
+        ASSERT(!((Pfn1->OriginalPte.u.Soft.Prototype == 0) &&
+                 (Pfn1->OriginalPte.u.Soft.Transition == 1)));

     }
 
     /* Otherwise this is a fresh page -- set it up */
     }
 
     /* Otherwise this is a fresh page -- set it up */


@@ -735,7 +770,7 @@ MiInitializePfn(IN PFN_NUMBER PageFrameIndex,
     Pfn1->u4.PteFrame = PageFrameIndex;
 
     /* Increase its share count so we don't get rid of it */
     Pfn1->u4.PteFrame = PageFrameIndex;
 
     /* Increase its share count so we don't get rid of it */

-    Pfn1 = MiGetPfnEntry(PageFrameIndex);
+    Pfn1 = MI_PFN_ELEMENT(PageFrameIndex);

     Pfn1->u2.ShareCount++;
 }
 
     Pfn1->u2.ShareCount++;
 }
 


@@ -767,7 +802,7 @@ MiAllocatePfn(IN PMMPTE PointerPte,
     /* Grab a page */
     ASSERT_LIST_INVARIANT(&MmFreePageListHead);
     ASSERT_LIST_INVARIANT(&MmZeroedPageListHead);
     /* Grab a page */
     ASSERT_LIST_INVARIANT(&MmFreePageListHead);
     ASSERT_LIST_INVARIANT(&MmZeroedPageListHead);

-    PageFrameIndex = MiRemoveAnyPage(0);
+    PageFrameIndex = MiRemoveAnyPage(MI_GET_NEXT_COLOR());

 
     /* Write the software PTE */
     MI_WRITE_INVALID_PTE(PointerPte, TempPte);
 
     /* Write the software PTE */
     MI_WRITE_INVALID_PTE(PointerPte, TempPte);


@@ -789,8 +824,9 @@ MiDecrementShareCount(IN PMMPFN Pfn1,
                       IN PFN_NUMBER PageFrameIndex)
 {
     ASSERT(PageFrameIndex > 0);
                       IN PFN_NUMBER PageFrameIndex)
 {
     ASSERT(PageFrameIndex > 0);

-    ASSERT(MiGetPfnEntry(PageFrameIndex) != NULL);
-    ASSERT(Pfn1 == MiGetPfnEntry(PageFrameIndex));
+    ASSERT(MI_PFN_ELEMENT(PageFrameIndex) != NULL);
+    ASSERT(Pfn1 == MI_PFN_ELEMENT(PageFrameIndex));
+    ASSERT(MI_IS_ROS_PFN(Pfn1) == FALSE);

 
     /* Page must be in-use */
     if ((Pfn1->u3.e1.PageLocation != ActiveAndValid) &&
 
     /* Page must be in-use */
     if ((Pfn1->u3.e1.PageLocation != ActiveAndValid) &&


@@ -826,13 +862,7 @@ MiDecrementShareCount(IN PMMPFN Pfn1,
 
             /* Clear the last reference */
             Pfn1->u3.e2.ReferenceCount = 0;
 
             /* Clear the last reference */
             Pfn1->u3.e2.ReferenceCount = 0;

-
-            /*
-             * OriginalPte is used by AweReferenceCount in ReactOS, but either 
-             * ways we shouldn't be seeing RMAP entries at this point
-             */

             ASSERT(Pfn1->OriginalPte.u.Soft.Prototype == 0);
             ASSERT(Pfn1->OriginalPte.u.Soft.Prototype == 0);

-            ASSERT(Pfn1->OriginalPte.u.Long == 0);

 
             /* Mark the page temporarily as valid, we're going to make it free soon */
             Pfn1->u3.e1.PageLocation = ActiveAndValid;
 
             /* Mark the page temporarily as valid, we're going to make it free soon */
             Pfn1->u3.e1.PageLocation = ActiveAndValid;


@@ -848,6 +878,49 @@ MiDecrementShareCount(IN PMMPFN Pfn1,
     }
 }
 
     }
 }
 

+VOID
+NTAPI
+MiDecrementReferenceCount(IN PMMPFN Pfn1,
+                          IN PFN_NUMBER PageFrameIndex)
+{
+    /* PFN lock must be held */
+    ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
+
+    /* Sanity checks on the page */
+    ASSERT(PageFrameIndex < MmHighestPhysicalPage);
+    ASSERT(Pfn1 == MI_PFN_ELEMENT(PageFrameIndex));
+    ASSERT(Pfn1->u3.e2.ReferenceCount != 0);
+
+    /* Dereference the page, bail out if it's still alive */
+    InterlockedDecrement16((PSHORT)&Pfn1->u3.e2.ReferenceCount);
+    if (Pfn1->u3.e2.ReferenceCount) return;
+
+    /* Nobody should still have reference to this page */
+    if (Pfn1->u2.ShareCount != 0)
+    {
+        /* Otherwise something's really wrong */
+        KeBugCheckEx(PFN_LIST_CORRUPT, 7, PageFrameIndex, Pfn1->u2.ShareCount, 0);
+    }
+
+    /* And it should be lying on some page list */
+    ASSERT(Pfn1->u3.e1.PageLocation != ActiveAndValid);
+
+    /* Did someone set the delete flag? */
+    if (MI_IS_PFN_DELETED(Pfn1))
+    {
+        /* Insert it into the free list, there's nothing left to do */
+        MiInsertPageInFreeList(PageFrameIndex);
+        return;
+    }
+
+    /* We don't have a modified list yet */
+    ASSERT(Pfn1->u3.e1.Modified == 0);
+    ASSERT(Pfn1->u3.e1.RemovalRequested == 0);
+
+    /* FIXME: Normally it would go on the standby list, but we're pushing it on the free list */
+    MiInsertPageInFreeList(PageFrameIndex);
+}
+

 VOID
 NTAPI
 MiInitializePfnForOtherProcess(IN PFN_NUMBER PageFrameIndex,
 VOID
 NTAPI
 MiInitializePfnForOtherProcess(IN PFN_NUMBER PageFrameIndex,


@@ -857,13 +930,11 @@ MiInitializePfnForOtherProcess(IN PFN_NUMBER PageFrameIndex,
     PMMPFN Pfn1;
     
     /* Setup the PTE */
     PMMPFN Pfn1;
     
     /* Setup the PTE */

-    Pfn1 = MiGetPfnEntry(PageFrameIndex);
+    Pfn1 = MI_PFN_ELEMENT(PageFrameIndex);

     Pfn1->PteAddress = PointerPte;
     Pfn1->PteAddress = PointerPte;

-    
-#if 0 // When using ARM3 PFN
+

     /* Make this a software PTE */
     MI_MAKE_SOFTWARE_PTE(&Pfn1->OriginalPte, MM_READWRITE);
     /* Make this a software PTE */
     MI_MAKE_SOFTWARE_PTE(&Pfn1->OriginalPte, MM_READWRITE);

-#endif

     
     /* Setup the page */
     ASSERT(Pfn1->u3.e2.ReferenceCount == 0);
     
     /* Setup the page */
     ASSERT(Pfn1->u3.e2.ReferenceCount == 0);


@@ -880,7 +951,7 @@ MiInitializePfnForOtherProcess(IN PFN_NUMBER PageFrameIndex,
         Pfn1->u4.PteFrame = PteFrame;
         
         /* Increase its share count so we don't get rid of it */    
         Pfn1->u4.PteFrame = PteFrame;
         
         /* Increase its share count so we don't get rid of it */    

-        Pfn1 = MiGetPfnEntry(PteFrame);
+        Pfn1 = MI_PFN_ELEMENT(PteFrame);

         Pfn1->u2.ShareCount++;
     }
 }
         Pfn1->u2.ShareCount++;
     }
 }