[arty] 44291: Revert my recent traffic for now. This needs to be approached differently. I'm going in the wrong direction in complexity terms.

Author: arty
Date: Fri Nov 27 02:03:24 2009
New Revision: 44291
URL: http://svn.reactos.org/svn/reactos?rev=44291&view=rev
Log:
Revert my recent traffic for now.  This needs to be approached differently.  I'm going
in the wrong direction in complexity terms.
Modified:
    branches/arty-newcc/ntoskrnl/cache/fssup.c
    branches/arty-newcc/ntoskrnl/cache/lazyrite.c
    branches/arty-newcc/ntoskrnl/include/internal/newmm.h
    branches/arty-newcc/ntoskrnl/io/iomgr/device.c
    branches/arty-newcc/ntoskrnl/io/iomgr/iofunc.c
    branches/arty-newcc/ntoskrnl/io/iomgr/rawfs.c
    branches/arty-newcc/ntoskrnl/mm/anonmem.c
    branches/arty-newcc/ntoskrnl/mm/balance.c
    branches/arty-newcc/ntoskrnl/mm/freelist.c
    branches/arty-newcc/ntoskrnl/mm/mpw.c
    branches/arty-newcc/ntoskrnl/mm/pageop.c
    branches/arty-newcc/ntoskrnl/mm/rmap.c
    branches/arty-newcc/ntoskrnl/mm/section/data.c
    branches/arty-newcc/ntoskrnl/mm/section/image.c
    branches/arty-newcc/ntoskrnl/mm/section/io.c
    branches/arty-newcc/ntoskrnl/mm/section/pagefile.c
Modified: branches/arty-newcc/ntoskrnl/cache/fssup.c
URL:
http://svn.reactos.org/svn/reactos/branches/arty-newcc/ntoskrnl/cache/fssup…
==============================================================================
--- branches/arty-newcc/ntoskrnl/cache/fssup.c [iso-8859-1] (original)
+++ branches/arty-newcc/ntoskrnl/cache/fssup.c [iso-8859-1] Fri Nov 27 02:03:24 2009
@@ -17,7 +17,12 @@
 PFSN_PREFETCHER_GLOBALS CcPfGlobals;
 extern LONG CcOutstandingDeletes;
+extern KEVENT CcpLazyWriteEvent;
 extern KEVENT CcFinalizeEvent;
+extern VOID NTAPI CcpUnmapThread(PVOID Unused);
+extern VOID NTAPI CcpLazyWriteThread(PVOID Unused);
+HANDLE CcUnmapThreadHandle, CcLazyWriteThreadHandle;
+CLIENT_ID CcUnmapThreadId, CcLazyWriteThreadId;
 typedef struct _NOCC_PRIVATE_CACHE_MAP
 {
@@ -43,6 +48,7 @@
        KeInitializeEvent(&CcDeleteEvent, SynchronizationEvent, FALSE);
        KeInitializeEvent(&CcFinalizeEvent, SynchronizationEvent, FALSE);
+       KeInitializeEvent(&CcpLazyWriteEvent, SynchronizationEvent, FALSE);
        CcCacheBitmap->Buffer = ((PULONG)&CcCacheBitmap[1]);
        CcCacheBitmap->SizeOfBitMap = ROUND_UP(CACHE_NUM_SECTIONS, 32);
Modified: branches/arty-newcc/ntoskrnl/cache/lazyrite.c
URL:
http://svn.reactos.org/svn/reactos/branches/arty-newcc/ntoskrnl/cache/lazyr…
==============================================================================
--- branches/arty-newcc/ntoskrnl/cache/lazyrite.c [iso-8859-1] (original)
+++ branches/arty-newcc/ntoskrnl/cache/lazyrite.c [iso-8859-1] Fri Nov 27 02:03:24 2009
@@ -14,15 +14,21 @@
 /* GLOBALS ********************************************************************/
-extern KEVENT MpwCompleteEvent;
+KEVENT CcpLazyWriteEvent;
 /* FUNCTIONS ******************************************************************/
+
+VOID NTAPI
+CcpLazyWriteThread(PVOID Unused)
+{
+       /* Not implemented */
+}
 NTSTATUS
 NTAPI
 CcWaitForCurrentLazyWriterActivity(VOID)
 {
-    KeWaitForSingleObject(&MpwCompleteEvent, Executive, KernelMode, FALSE, NULL);
+    //KeWaitForSingleObject(&CcpLazyWriteEvent, Executive, KernelMode, FALSE, NULL);
     return STATUS_SUCCESS;
 }
Modified: branches/arty-newcc/ntoskrnl/include/internal/newmm.h
URL:
http://svn.reactos.org/svn/reactos/branches/arty-newcc/ntoskrnl/include/int…
==============================================================================
--- branches/arty-newcc/ntoskrnl/include/internal/newmm.h [iso-8859-1] (original)
+++ branches/arty-newcc/ntoskrnl/include/internal/newmm.h [iso-8859-1] Fri Nov 27 02:03:24
2009
@@ -260,7 +260,7 @@
 typedef struct _MM_SECTION_SEGMENT
 {
-    KGUARDED_MUTEX Lock;               /* lock which protects the page directory */
+    FAST_MUTEX Lock;           /* lock which protects the page directory */
        PFILE_OBJECT FileObject;
     ULARGE_INTEGER RawLength;          /* length of the segment which is part of the
mapped file */
     ULARGE_INTEGER Length;                     /* absolute length of the segment */
@@ -1685,8 +1685,7 @@
 NTSTATUS
 NTAPI
-MiReadFilePage
-(PFILE_OBJECT FileObject, PLARGE_INTEGER Offset, PPFN_TYPE Page, BOOLEAN Locked);
+MiReadFilePage(PFILE_OBJECT FileObject, PLARGE_INTEGER Offset, PPFN_TYPE Page);
 VOID
 NTAPI
@@ -1744,15 +1743,11 @@
 VOID
 NTAPI
-_MmLockSectionSegment(PMM_SECTION_SEGMENT Segment, const char *file, int line);
-
-VOID
-NTAPI
-_MmUnlockSectionSegment(PMM_SECTION_SEGMENT Segment, const char *file, int line);
-
-#define MmLockSectionSegment(S)        _MmLockSectionSegment(S,__FILE__,__LINE__)
-
-#define MmUnlockSectionSegment(S) _MmUnlockSectionSegment(S,__FILE__,__LINE__)
+MmLockSectionSegment(PMM_SECTION_SEGMENT Segment);
+
+VOID
+NTAPI
+MmUnlockSectionSegment(PMM_SECTION_SEGMENT Segment);
 VOID
 MmspCompleteAndReleasePageOp(PMM_PAGEOP PageOp);
Modified: branches/arty-newcc/ntoskrnl/io/iomgr/device.c
URL:
http://svn.reactos.org/svn/reactos/branches/arty-newcc/ntoskrnl/io/iomgr/de…
==============================================================================
--- branches/arty-newcc/ntoskrnl/io/iomgr/device.c [iso-8859-1] (original)
+++ branches/arty-newcc/ntoskrnl/io/iomgr/device.c [iso-8859-1] Fri Nov 27 02:03:24 2009
@@ -1150,11 +1150,7 @@
     NTSTATUS Status;
     /* Make sure there's a VPB */
-    if (!FileSystemDeviceObject->Vpb)
-       {
-               DPRINT1("STATUS_INVALID_PARAMETER\n");
-               return STATUS_INVALID_PARAMETER;
-       }
+    if (!FileSystemDeviceObject->Vpb) return STATUS_INVALID_PARAMETER;
     /* Acquire it */
     IoAcquireVpbSpinLock(&OldIrql);
@@ -1186,7 +1182,6 @@
     else
     {
         /* Fail */
-               DPRINT1("STATUS_INVALID_PARAMETER\n");
         Status = STATUS_INVALID_PARAMETER;
     }
Modified: branches/arty-newcc/ntoskrnl/io/iomgr/iofunc.c
URL:
http://svn.reactos.org/svn/reactos/branches/arty-newcc/ntoskrnl/io/iomgr/io…
==============================================================================
--- branches/arty-newcc/ntoskrnl/io/iomgr/iofunc.c [iso-8859-1] (original)
+++ branches/arty-newcc/ntoskrnl/io/iomgr/iofunc.c [iso-8859-1] Fri Nov 27 02:03:24 2009
@@ -278,7 +278,6 @@
     {
         /* Fail */
         ObDereferenceObject(FileObject);
-               DPRINT1("STATUS_INVALID_PARAMETER\n");
         return STATUS_INVALID_PARAMETER;
     }
@@ -1123,7 +1122,6 @@
         /* Check if CompletionFilter is valid */
         if (!CompletionFilter || (CompletionFilter & ~FILE_NOTIFY_VALID_MASK))
         {
-               DPRINT1("STATUS_INVALID_PARAMETER\n");
             return STATUS_INVALID_PARAMETER;
         }
     }
@@ -2052,7 +2050,6 @@
         /* Otherwise, this was async I/O without a byte offset, so fail */
         if (EventObject) ObDereferenceObject(EventObject);
         ObDereferenceObject(FileObject);
-               DPRINT1("STATUS_INVALID_PARAMETER\n");
         return STATUS_INVALID_PARAMETER;
     }
@@ -2427,7 +2424,6 @@
             (FileObject->CompletionContext))
         {
             /* Fail */
-               DPRINT1("STATUS_INVALID_PARAMETER\n");
             Status = STATUS_INVALID_PARAMETER;
         }
         else
@@ -2462,7 +2458,6 @@
                          */
                         ExFreePool(Context);
                         ObDereferenceObject(Queue);
-               DPRINT1("STATUS_INVALID_PARAMETER\n");
                         Status = STATUS_INVALID_PARAMETER;
                     }
                 }
@@ -2908,7 +2903,6 @@
         /* Otherwise, this was async I/O without a byte offset, so fail */
         if (EventObject) ObDereferenceObject(EventObject);
         ObDereferenceObject(FileObject);
-               DPRINT1("STATUS_INVALID_PARAMETER\n");
         return STATUS_INVALID_PARAMETER;
     }
Modified: branches/arty-newcc/ntoskrnl/io/iomgr/rawfs.c
URL:
http://svn.reactos.org/svn/reactos/branches/arty-newcc/ntoskrnl/io/iomgr/ra…
==============================================================================
--- branches/arty-newcc/ntoskrnl/io/iomgr/rawfs.c [iso-8859-1] (original)
+++ branches/arty-newcc/ntoskrnl/io/iomgr/rawfs.c [iso-8859-1] Fri Nov 27 02:03:24 2009
@@ -239,7 +239,6 @@
     else
     {
         /* Invalid create request */
-               DPRINT1("STATUS_INVALID_PARAMETER\n");
         Status = STATUS_INVALID_PARAMETER;
         Irp->IoStatus.Information = 0;
     }
@@ -436,7 +435,6 @@
         default:
             /* Fail */
-               DPRINT1("STATUS_INVALID_PARAMETER\n");
             Status = STATUS_INVALID_PARAMETER;
             break;
     }
@@ -578,7 +576,6 @@
             DeviceObject->AlignmentRequirement))
         {
             /* It's not, fail */
-               DPRINT1("STATUS_INVALID_PARAMETER\n");
             Status = STATUS_INVALID_PARAMETER;
         }
         else
@@ -851,7 +848,6 @@
         default:
             /* Fail it */
-               DPRINT1("STATUS_INVALID_PARAMETER\n");
             Status = STATUS_INVALID_PARAMETER;
             break;
     }
Modified: branches/arty-newcc/ntoskrnl/mm/anonmem.c
URL:
http://svn.reactos.org/svn/reactos/branches/arty-newcc/ntoskrnl/mm/anonmem.…
==============================================================================
--- branches/arty-newcc/ntoskrnl/mm/anonmem.c [iso-8859-1] (original)
+++ branches/arty-newcc/ntoskrnl/mm/anonmem.c [iso-8859-1] Fri Nov 27 02:03:24 2009
@@ -377,10 +377,13 @@
    /*
     * Try to allocate a page
     */
-   MmUnlockAddressSpace(AddressSpace);
-   Status = MmRequestPageMemoryConsumer(MC_USER, TRUE, &Page);
-   MmLockAddressSpace(AddressSpace);
-
+   Status = MmRequestPageMemoryConsumer(MC_USER, FALSE, &Page);
+   if (Status == STATUS_NO_MEMORY)
+   {
+      MmUnlockAddressSpace(AddressSpace);
+      Status = MmRequestPageMemoryConsumer(MC_USER, TRUE, &Page);
+      MmLockAddressSpace(AddressSpace);
+   }
    if (!NT_SUCCESS(Status))
    {
       DPRINT1("MmRequestPageMemoryConsumer failed, status = %x\n", Status);
Modified: branches/arty-newcc/ntoskrnl/mm/balance.c
URL:
http://svn.reactos.org/svn/reactos/branches/arty-newcc/ntoskrnl/mm/balance.…
==============================================================================
--- branches/arty-newcc/ntoskrnl/mm/balance.c [iso-8859-1] (original)
+++ branches/arty-newcc/ntoskrnl/mm/balance.c [iso-8859-1] Fri Nov 27 02:03:24 2009
@@ -32,17 +32,18 @@
 /* GLOBALS ******************************************************************/
 MM_MEMORY_CONSUMER MiMemoryConsumers[MC_MAXIMUM];
-static ULONG MiMinimumAvailablePages = 512;
+static ULONG MiMinimumAvailablePages;
 static ULONG MiNrTotalPages;
 static LIST_ENTRY AllocationListHead;
 static KSPIN_LOCK AllocationListLock;
-static ULONG MiMinimumPagesPerRun = 128;
+static ULONG MiPagesRequired = 0;
+static ULONG MiMinimumPagesPerRun = 10;
 static CLIENT_ID MiBalancerThreadId;
 static HANDLE MiBalancerThreadHandle = NULL;
 static KEVENT MiBalancerEvent;
-static KEVENT MiBalancerContinue;
 static KTIMER MiBalancerTimer;
+static LONG MiBalancerWork = 0;
 /* FUNCTIONS ****************************************************************/
@@ -66,6 +67,7 @@
    MiNrTotalPages = NrAvailablePages;
    /* Set up targets. */
+   MiMinimumAvailablePages = 64;
     if ((NrAvailablePages + NrSystemPages) >= 8192)
     {
         MiMemoryConsumers[MC_CACHE].PagesTarget = NrAvailablePages / 4 * 3;
@@ -115,7 +117,7 @@
    if (MmGetReferenceCountPage(Page) == 1)
    {
       (void)InterlockedDecrementUL(&MiMemoryConsumers[Consumer].PagesUsed);
-      if (IsListEmpty(&AllocationListHead))
+      if (IsListEmpty(&AllocationListHead) || MmAvailablePages <
MiMinimumAvailablePages)
       {
          KeReleaseSpinLock(&AllocationListLock, OldIrql);
          OldIrql = KeAcquireQueuedSpinLock(LockQueuePfnLock);
@@ -127,8 +129,7 @@
          Entry = RemoveHeadList(&AllocationListHead);
          Request = CONTAINING_RECORD(Entry, MM_ALLOCATION_REQUEST, ListEntry);
          KeReleaseSpinLock(&AllocationListLock, OldIrql);
-         if(Consumer == MC_USER || Consumer == MC_PPOOL)
-                        MmRemoveLRUUserPage(Page);
+         if(Consumer == MC_USER) MmRemoveLRUUserPage(Page);
          MiZeroPage(Page);
          Request->Page = Page;
          KeSetEvent(&Request->Event, IO_NO_INCREMENT, FALSE);
@@ -137,10 +138,33 @@
    else
    {
       KeReleaseSpinLock(&AllocationListLock, OldIrql);
+      if(Consumer == MC_USER) MmRemoveLRUUserPage(Page);
+      OldIrql = KeAcquireQueuedSpinLock(LockQueuePfnLock);
       MmDereferencePage(Page);
+      KeReleaseQueuedSpinLock(LockQueuePfnLock, OldIrql);
    }
    return(STATUS_SUCCESS);
+}
+
+VOID
+NTAPI
+MiTrimMemoryConsumer(ULONG Consumer)
+{
+   LONG Target;
+   ULONG NrFreedPages;
+
+   Target = MiMemoryConsumers[Consumer].PagesUsed -
+            MiMemoryConsumers[Consumer].PagesTarget;
+   if (Target < 1)
+   {
+      Target = 1;
+   }
+
+   if (MiMemoryConsumers[Consumer].Trim != NULL)
+   {
+      MiMemoryConsumers[Consumer].Trim(Target, 0, &NrFreedPages);
+   }
 }
 NTSTATUS
@@ -151,35 +175,27 @@
     NTSTATUS Status;
     (*NrFreedPages) = 0;
-       DPRINT("Trimming user memory (want %d)\n", Target);
     CurrentPage = MmGetLRUFirstUserPage();
     while (CurrentPage != 0 && Target > 0)
     {
         NextPage = MmGetLRUNextUserPage(CurrentPage);
-
-               DPRINT("Page Out %x\n", CurrentPage);
+
         Status = MmPageOutPhysicalAddress(CurrentPage);
-               DPRINT("Done %x\n", Status);
         if (NT_SUCCESS(Status))
         {
+            DPRINT("Succeeded\n");
             Target--;
             (*NrFreedPages)++;
         }
         else if (Status == STATUS_PAGEFILE_QUOTA)
         {
-                       MmRemoveLRUUserPage(CurrentPage);
-                       MmInsertLRULastUserPage(CurrentPage);
-                       return STATUS_SUCCESS;
+            MmRemoveLRUUserPage(CurrentPage);
+            MmInsertLRULastUserPage(CurrentPage);
         }
         CurrentPage = NextPage;
     }
-       if (CurrentPage)
-               MmDereferencePage(CurrentPage);
-
-       DPRINT("Done: %d\n", NrFreedPages);
-
     return(STATUS_SUCCESS);
 }
@@ -192,16 +208,14 @@
    ULONG NrFreedPages;
    NTSTATUS Status;
-   Target = (MiMinimumAvailablePages - MmAvailablePages);
+   Target = (MiMinimumAvailablePages - MmAvailablePages) + MiPagesRequired;
    Target = max(Target, (LONG) MiMinimumPagesPerRun);
    for (i = 0; i < MC_MAXIMUM && Target > 0; i++)
    {
       if (MiMemoryConsumers[i].Trim != NULL)
       {
-                DPRINT("Trimming %d\n");
-                Status = MiMemoryConsumers[i].Trim(Target, 0, &NrFreedPages);
-                DPRINT("Got %d pages\n", NrFreedPages);
+         Status = MiMemoryConsumers[i].Trim(Target, 0, &NrFreedPages);
          if (!NT_SUCCESS(Status))
          {
             KeBugCheck(MEMORY_MANAGEMENT);
@@ -215,7 +229,7 @@
 MiIsBalancerThread(VOID)
 {
    return MiBalancerThreadHandle != NULL &&
-          PsGetCurrentThreadId() == MiBalancerThreadId.UniqueThread;
+          PsGetCurrentThread() == MiBalancerThreadId.UniqueThread;
 }
 NTSTATUS
@@ -223,67 +237,106 @@
 MmRequestPageMemoryConsumer(ULONG Consumer, BOOLEAN CanWait,
                             PPFN_TYPE AllocatedPage)
 {
-   PFN_TYPE Page = 0;
+   ULONG OldUsed;
+   PFN_TYPE Page;
    KIRQL OldIrql;
-   (void)InterlockedIncrementUL(&MiMemoryConsumers[Consumer].PagesUsed);
-
-   if (!MiIsBalancerThread() && MmAvailablePages <= MiMinimumAvailablePages
&& CanWait)
-   {
-          DPRINT("MmAvailablePages %d MiMinimumAvailablePages %d\n",
-                          MmAvailablePages, MiMinimumAvailablePages);
-          KeSetEvent(&MiBalancerEvent, IO_NO_INCREMENT, FALSE);
-          KeWaitForSingleObject(&MiBalancerContinue, 0, KernelMode, FALSE, NULL);
+   /*
+    * Make sure we don't exceed our individual target.
+    */
+   OldUsed = InterlockedIncrementUL(&MiMemoryConsumers[Consumer].PagesUsed);
+   if (OldUsed >= (MiMemoryConsumers[Consumer].PagesTarget - 1) &&
+         !MiIsBalancerThread())
+   {
+      if (!CanWait)
+      {
+         (void)InterlockedDecrementUL(&MiMemoryConsumers[Consumer].PagesUsed);
+         return(STATUS_NO_MEMORY);
+      }
+      MiTrimMemoryConsumer(Consumer);
    }
    /*
     * Allocate always memory for the non paged pool and for the pager thread.
     */
-   if ((Consumer == MC_NPPOOL) ||
-          (Consumer == MC_SYSTEM) ||
-          MiIsBalancerThread() ||
-          (MmAvailablePages > MiMinimumAvailablePages))
+   if ((Consumer == MC_NPPOOL) || (Consumer == MC_SYSTEM) || MiIsBalancerThread())
    {
       OldIrql = KeAcquireQueuedSpinLock(LockQueuePfnLock);
       Page = MmAllocPage(Consumer, 0);
       KeReleaseQueuedSpinLock(LockQueuePfnLock, OldIrql);
-      if (!Page && MiIsBalancerThread())
-      {
-                 DPRINT1("Can't allocate for balancer: %d vs %d\n",
-                                 MmAvailablePages, MiMinimumAvailablePages);
+      if (Page == 0)
+      {
          KeBugCheck(NO_PAGES_AVAILABLE);
       }
+      *AllocatedPage = Page;
+      if (MmAvailablePages <= MiMinimumAvailablePages &&
+            MiBalancerThreadHandle != NULL)
+      {
+         KeSetEvent(&MiBalancerEvent, IO_NO_INCREMENT, FALSE);
+      }
+      return(STATUS_SUCCESS);
    }
    /*
     * Make sure we don't exceed global targets.
     */
-   while (!Page)
-   {
-          if (!MiIsBalancerThread() || CanWait)
-          {
-                  KeSetEvent(&MiBalancerEvent, IO_NO_INCREMENT, FALSE);
-                  KeWaitForSingleObject(&MiBalancerContinue, 0, KernelMode, FALSE,
NULL);
-          }
-
-          /*
-               * Actually allocate the page.
-               */
-          OldIrql = KeAcquireQueuedSpinLock(LockQueuePfnLock);
-          Page = MmAllocPage(Consumer, 0);
-          KeReleaseQueuedSpinLock(LockQueuePfnLock, OldIrql);
-
-          if (!Page && !CanWait)
-          {
-
(void)InterlockedDecrementUL(&MiMemoryConsumers[Consumer].PagesUsed);
-                  return(STATUS_NO_MEMORY);
-          }
-   }
-
-   if(Consumer == MC_USER || Consumer == MC_PPOOL)
-          MmInsertLRULastUserPage(Page);
+   if (MmAvailablePages <= MiMinimumAvailablePages)
+   {
+      MM_ALLOCATION_REQUEST Request;
+
+      if (!CanWait)
+      {
+         (void)InterlockedDecrementUL(&MiMemoryConsumers[Consumer].PagesUsed);
+         return(STATUS_NO_MEMORY);
+      }
+
+      /* Insert an allocation request. */
+      Request.Page = 0;
+
+      KeInitializeEvent(&Request.Event, NotificationEvent, FALSE);
+      (void)InterlockedIncrementUL(&MiPagesRequired);
+
+      KeAcquireSpinLock(&AllocationListLock, &OldIrql);
+
+      if (MiBalancerThreadHandle != NULL)
+      {
+         KeSetEvent(&MiBalancerEvent, IO_NO_INCREMENT, FALSE);
+      }
+      InsertTailList(&AllocationListHead, &Request.ListEntry);
+      KeReleaseSpinLock(&AllocationListLock, OldIrql);
+
+      KeWaitForSingleObject(&Request.Event,
+                            0,
+                            KernelMode,
+                            FALSE,
+                            NULL);
+
+      Page = Request.Page;
+      if (Page == 0)
+      {
+         KeBugCheck(NO_PAGES_AVAILABLE);
+      }
+      /* Update the Consumer */
+      MiGetPfnEntry(Page)->u3.e1.PageLocation = Consumer;
+      if(Consumer == MC_USER) MmInsertLRULastUserPage(Page);
+      *AllocatedPage = Page;
+      (void)InterlockedDecrementUL(&MiPagesRequired);
+      return(STATUS_SUCCESS);
+   }
+
+   /*
+    * Actually allocate the page.
+    */
+   OldIrql = KeAcquireQueuedSpinLock(LockQueuePfnLock);
+   Page = MmAllocPage(Consumer, 0);
+   KeReleaseQueuedSpinLock(LockQueuePfnLock, OldIrql);
+   if (Page == 0)
+   {
+      KeBugCheck(NO_PAGES_AVAILABLE);
+   }
+   if(Consumer == MC_USER) MmInsertLRULastUserPage(Page);
    *AllocatedPage = Page;
-
+
    return(STATUS_SUCCESS);
 }
@@ -292,11 +345,15 @@
 {
    PVOID WaitObjects[2];
    NTSTATUS Status;
+   ULONG i;
+   ULONG NrFreedPages;
+   ULONG NrPagesUsed;
+   ULONG Target;
+   BOOLEAN ShouldRun;
+
    WaitObjects[0] = &MiBalancerEvent;
    WaitObjects[1] = &MiBalancerTimer;
-
-   ASSERT(MiIsBalancerThread());
    while (1)
    {
@@ -309,8 +366,61 @@
                                         NULL,
                                         NULL);
-         MmRebalanceMemoryConsumers();
-         KeSetEvent(&MiBalancerContinue, IO_NO_INCREMENT, FALSE);
+      if (Status == STATUS_SUCCESS)
+      {
+         /* MiBalancerEvent */
+         while (MmAvailablePages < MiMinimumAvailablePages + 5)
+         {
+            for (i = 0; i < MC_MAXIMUM; i++)
+            {
+               if (MiMemoryConsumers[i].Trim != NULL)
+               {
+                  NrFreedPages = 0;
+                  Status = MiMemoryConsumers[i].Trim(MiMinimumPagesPerRun, 0,
&NrFreedPages);
+                  if (!NT_SUCCESS(Status))
+                  {
+                     KeBugCheck(MEMORY_MANAGEMENT);
+                  }
+               }
+            }
+         }
+         InterlockedExchange(&MiBalancerWork, 0);
+      }
+      else if (Status == STATUS_SUCCESS + 1)
+      {
+         /* MiBalancerTimer */
+         ShouldRun = MmAvailablePages < MiMinimumAvailablePages + 5 ? TRUE : FALSE;
+         for (i = 0; i < MC_MAXIMUM; i++)
+         {
+            if (MiMemoryConsumers[i].Trim != NULL)
+            {
+               NrPagesUsed = MiMemoryConsumers[i].PagesUsed;
+               if (NrPagesUsed > MiMemoryConsumers[i].PagesTarget || ShouldRun)
+               {
+                  if (NrPagesUsed > MiMemoryConsumers[i].PagesTarget)
+                  {
+                     Target = max (NrPagesUsed - MiMemoryConsumers[i].PagesTarget,
+                                   MiMinimumPagesPerRun);
+                  }
+                  else
+                  {
+                     Target = MiMinimumPagesPerRun;
+                  }
+                  NrFreedPages = 0;
+                  Status = MiMemoryConsumers[i].Trim(Target, 0, &NrFreedPages);
+                  if (!NT_SUCCESS(Status))
+                  {
+                     KeBugCheck(MEMORY_MANAGEMENT);
+                  }
+               }
+            }
+         }
+      }
+      else
+      {
+         DPRINT1("KeWaitForMultipleObjects failed, status = %x\n", Status);
+         KeBugCheck(MEMORY_MANAGEMENT);
+      }
    }
 }
@@ -330,7 +440,6 @@
    KeInitializeEvent(&MiBalancerEvent, SynchronizationEvent, FALSE);
-   KeInitializeEvent(&MiBalancerContinue, SynchronizationEvent, FALSE);
    KeInitializeTimerEx(&MiBalancerTimer, SynchronizationTimer);
    KeSetTimerEx(&MiBalancerTimer,
 #if defined(__GNUC__)
Modified: branches/arty-newcc/ntoskrnl/mm/freelist.c
URL:
http://svn.reactos.org/svn/reactos/branches/arty-newcc/ntoskrnl/mm/freelist…
==============================================================================
--- branches/arty-newcc/ntoskrnl/mm/freelist.c [iso-8859-1] (original)
+++ branches/arty-newcc/ntoskrnl/mm/freelist.c [iso-8859-1] Fri Nov 27 02:03:24 2009
@@ -99,7 +99,6 @@
       return 0;
    }
    PageDescriptor = CONTAINING_RECORD(NextListEntry, PHYSICAL_PAGE, ListEntry);
-   MmReferencePage(PageDescriptor - MmPfnDatabase);
    ASSERT_PFN(PageDescriptor);
    KeReleaseQueuedSpinLock(LockQueuePfnLock, oldIrql);
    return PageDescriptor - MmPfnDatabase;
@@ -116,7 +115,7 @@
    Page = MiGetPfnEntry(Pfn);
    ASSERT(Page);
    ASSERT(Page->Flags.Type == MM_PHYSICAL_PAGE_USED);
-   ASSERT(Page->Flags.Consumer == MC_USER || Page->Flags.Consumer == MC_PPOOL);
+   ASSERT(Page->Flags.Consumer == MC_USER);
    InsertTailList(&UserPageListHead, &Page->ListEntry);
    KeReleaseQueuedSpinLock(LockQueuePfnLock, oldIrql);
 }
@@ -134,17 +133,14 @@
    Page = MiGetPfnEntry(PreviousPfn);
    ASSERT(Page);
    ASSERT(Page->Flags.Type == MM_PHYSICAL_PAGE_USED);
-   ASSERT(Page->Flags.Consumer == MC_USER || Page->Flags.Consumer == MC_PPOOL);
+   ASSERT(Page->Flags.Consumer == MC_USER);
    NextListEntry = (PLIST_ENTRY)Page->ListEntry.Flink;
    if (NextListEntry == &UserPageListHead)
    {
-         MmDereferencePage(PreviousPfn);
          KeReleaseQueuedSpinLock(LockQueuePfnLock, oldIrql);
       return 0;
    }
    PageDescriptor = CONTAINING_RECORD(NextListEntry, PHYSICAL_PAGE, ListEntry);
-   MmReferencePage(PageDescriptor - MmPfnDatabase);
-   MmDereferencePage(PreviousPfn);
    KeReleaseQueuedSpinLock(LockQueuePfnLock, oldIrql);
    return PageDescriptor - MmPfnDatabase;
 }
@@ -910,7 +906,6 @@
 NTAPI
 MmDereferencePage(PFN_TYPE Pfn)
 {
-   KIRQL oldIrql;
    PPHYSICAL_PAGE Page;
    DPRINT("MmDereferencePage(PhysicalAddress %x)\n", Pfn << PAGE_SHIFT);
@@ -933,12 +928,7 @@
    if (Page->ReferenceCount == 0)
    {
       MmAvailablePages++;
-      if (Page->Flags.Consumer == MC_USER)
-         {
-                 oldIrql = KeAcquireQueuedSpinLock(LockQueuePfnLock);
-                 RemoveEntryList(&Page->ListEntry);
-                 KeReleaseQueuedSpinLock(LockQueuePfnLock, oldIrql);
-         }
+      if (Page->Flags.Consumer == MC_USER) RemoveEntryList(&Page->ListEntry);
       if (Page->RmapListHead != (LONG)NULL)
       {
          DPRINT1("Freeing page with rmap entries.\n");
Modified: branches/arty-newcc/ntoskrnl/mm/mpw.c
URL:
http://svn.reactos.org/svn/reactos/branches/arty-newcc/ntoskrnl/mm/mpw.c?re…
==============================================================================
--- branches/arty-newcc/ntoskrnl/mm/mpw.c [iso-8859-1] (original)
+++ branches/arty-newcc/ntoskrnl/mm/mpw.c [iso-8859-1] Fri Nov 27 02:03:24 2009
@@ -17,8 +17,8 @@
 /* GLOBALS *******************************************************************/
 HANDLE MpwThreadHandle;
-CLIENT_ID MpwThreadId;
-KEVENT MpwThreadEvent, MpwCompleteEvent;
+static CLIENT_ID MpwThreadId;
+KEVENT MpwThreadEvent;
 BOOLEAN MpwThreadShouldTerminate;
 /* FUNCTIONS *****************************************************************/
@@ -81,11 +81,12 @@
       }
       PagesWritten = 0;
+#if 0
       /*
        *  FIXME: MmWriteDirtyPages doesn't work correctly.
        */
       MmWriteDirtyPages(128, &PagesWritten);
-         KeSetEvent(&MpwCompleteEvent, IO_NO_INCREMENT, TRUE);
+#endif
    }
 }
@@ -98,7 +99,6 @@
    MpwThreadShouldTerminate = FALSE;
    KeInitializeEvent(&MpwThreadEvent, SynchronizationEvent, FALSE);
-   KeInitializeEvent(&MpwCompleteEvent, SynchronizationEvent, FALSE);
    Status = PsCreateSystemThread(&MpwThreadHandle,
                                  THREAD_ALL_ACCESS,
Modified: branches/arty-newcc/ntoskrnl/mm/pageop.c
URL:
http://svn.reactos.org/svn/reactos/branches/arty-newcc/ntoskrnl/mm/pageop.c…
==============================================================================
--- branches/arty-newcc/ntoskrnl/mm/pageop.c [iso-8859-1] (original)
+++ branches/arty-newcc/ntoskrnl/mm/pageop.c [iso-8859-1] Fri Nov 27 02:03:24 2009
@@ -83,11 +83,11 @@
     */
    if (MArea->Type == MEMORY_AREA_SECTION_VIEW)
    {
-      Hash = (((ULONG_PTR)Segment) ^ (((ULONG_PTR)Offset) / PAGE_SIZE));
+      Hash = (((ULONG_PTR)Segment) | (((ULONG_PTR)Offset) / PAGE_SIZE));
    }
    else
    {
-      Hash = (((ULONG_PTR)Pid) ^ (((ULONG_PTR)Address) / PAGE_SIZE));
+      Hash = (((ULONG_PTR)Pid) | (((ULONG_PTR)Address) / PAGE_SIZE));
    }
    Hash = Hash % PAGEOP_HASH_TABLE_SIZE;
@@ -151,11 +151,11 @@
     */
    if (MArea->Type == MEMORY_AREA_SECTION_VIEW)
    {
-      Hash = (((ULONG_PTR)Segment) ^ (((ULONG_PTR)Offset) / PAGE_SIZE));
+      Hash = (((ULONG_PTR)Segment) | (((ULONG_PTR)Offset) / PAGE_SIZE));
    }
    else
    {
-      Hash = (((ULONG_PTR)Pid) ^ (((ULONG_PTR)Address) / PAGE_SIZE));
+      Hash = (((ULONG_PTR)Pid) | (((ULONG_PTR)Address) / PAGE_SIZE));
    }
    Hash = Hash % PAGEOP_HASH_TABLE_SIZE;
Modified: branches/arty-newcc/ntoskrnl/mm/rmap.c
URL:
http://svn.reactos.org/svn/reactos/branches/arty-newcc/ntoskrnl/mm/rmap.c?r…
==============================================================================
--- branches/arty-newcc/ntoskrnl/mm/rmap.c [iso-8859-1] (original)
+++ branches/arty-newcc/ntoskrnl/mm/rmap.c [iso-8859-1] Fri Nov 27 02:03:24 2009
@@ -32,7 +32,6 @@
 /* GLOBALS ******************************************************************/
-ULONG RmapPagingOut = 0;
 static FAST_MUTEX RmapListLock;
 static NPAGED_LOOKASIDE_LIST RmapLookasideList;
@@ -63,7 +62,7 @@
    ULONG Type;
    PVOID Address;
    PEPROCESS Process;
-   PMM_PAGEOP PageOp = NULL;
+   PMM_PAGEOP PageOp;
    ULONG Offset;
    NTSTATUS Status = STATUS_SUCCESS;
@@ -122,7 +121,6 @@
    {
          Offset = (ULONG_PTR)Address - (ULONG_PTR)MemoryArea->StartingAddress;
-#ifndef _NEWCC_
       /*
        * Get or create a pageop
        */
@@ -139,7 +137,6 @@
          }
          return(STATUS_UNSUCCESSFUL);
       }
-#endif
       /*
        * Release locks now we have a page op.
@@ -208,7 +205,7 @@
    ULONG Type;
    PVOID Address;
    PEPROCESS Process;
-   PMM_PAGEOP PageOp = NULL;
+   PMM_PAGEOP PageOp;
    ULONG Offset;
    NTSTATUS Status = STATUS_SUCCESS;
@@ -258,7 +255,6 @@
    {
          Offset = (ULONG_PTR)Address - (ULONG_PTR)MemoryArea->StartingAddress;
-#ifndef _NEWCC_
       /*
        * Get or create a pageop
        */
@@ -274,7 +270,6 @@
          }
          return(STATUS_UNSUCCESSFUL);
       }
-#endif
       /*
        * Release locks now we have a page op.
@@ -393,8 +388,6 @@
 {
    PMM_RMAP_ENTRY current_entry;
-   ASSERT(Page);
-
    ExAcquireFastMutex(&RmapListLock);
    current_entry = MmGetRmapListHeadPage(Page);
    if (current_entry == NULL)
@@ -416,8 +409,6 @@
 {
    PMM_RMAP_ENTRY current_entry;
-   ASSERT(Page);
-
    ExAcquireFastMutex(&RmapListLock);
    current_entry = MmGetRmapListHeadPage(Page);
    if (current_entry == NULL)
@@ -438,8 +429,6 @@
 MmIsDirtyPageRmap(PFN_TYPE Page)
 {
    PMM_RMAP_ENTRY current_entry;
-
-   ASSERT(Page);
    ExAcquireFastMutex(&RmapListLock);
    current_entry = MmGetRmapListHeadPage(Page);
@@ -470,7 +459,6 @@
    PMM_RMAP_ENTRY new_entry;
    ULONG PrevSize;
-   ASSERT(Page);
    Address = (PVOID)PAGE_ROUND_DOWN(Address);
    new_entry = ExAllocateFromNPagedLookasideList(&RmapLookasideList);
@@ -542,8 +530,6 @@
    PMM_RMAP_ENTRY previous_entry;
    PEPROCESS Process;
-   ASSERT(Page);
-
    ExAcquireFastMutex(&RmapListLock);
    current_entry = MmGetRmapListHeadPage(Page);
    if (current_entry == NULL)
@@ -581,8 +567,6 @@
              PVOID Address)
 {
    PMM_RMAP_ENTRY current_entry, previous_entry;
-
-   ASSERT(Page);
    ExAcquireFastMutex(&RmapListLock);
    previous_entry = NULL;
Modified: branches/arty-newcc/ntoskrnl/mm/section/data.c
URL:
http://svn.reactos.org/svn/reactos/branches/arty-newcc/ntoskrnl/mm/section/…
==============================================================================
--- branches/arty-newcc/ntoskrnl/mm/section/data.c [iso-8859-1] (original)
+++ branches/arty-newcc/ntoskrnl/mm/section/data.c [iso-8859-1] Fri Nov 27 02:03:24 2009
@@ -122,18 +122,18 @@
 VOID
 NTAPI
-_MmLockSectionSegment(PMM_SECTION_SEGMENT Segment, const char *file, int line)
-{
-       DPRINT("MmLockSectionSegment(%p,%s:%d)\n", Segment, file, line);
-       KeAcquireGuardedMutex(&Segment->Lock);
+MmLockSectionSegment(PMM_SECTION_SEGMENT Segment)
+{
+   DPRINT("MmLockSectionSegment(%p)\n", Segment);
+   ExAcquireFastMutex(&Segment->Lock);
 }
 VOID
 NTAPI
-_MmUnlockSectionSegment(PMM_SECTION_SEGMENT Segment, const char *file, int line)
-{
-       DPRINT("MmUnlockSectionSegment(%p,%s:%d)\n", Segment, file, line);
-       KeReleaseGuardedMutex(&Segment->Lock);
+MmUnlockSectionSegment(PMM_SECTION_SEGMENT Segment)
+{
+   ExReleaseFastMutex(&Segment->Lock);
+   DPRINT("MmUnlockSectionSegment(%p)\n", Segment);
 }
 VOID
@@ -233,7 +233,7 @@
 NTSTATUS
 NTAPI
-MiReadFilePage(PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, PPFN_TYPE Page,
BOOLEAN Locked)
+MiReadFilePage(PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, PPFN_TYPE Page)
 {
        PFN_TYPE XPage;
        NTSTATUS Status;
@@ -255,8 +255,7 @@
                return Status;
        }
-       if (!Locked)
-               MmLockAddressSpace(MmGetKernelAddressSpace());
+       MmLockAddressSpace(MmGetKernelAddressSpace());
        Status = MmCreateMemoryArea
                (MmGetKernelAddressSpace(),
                 MEMORY_AREA_VIRTUAL_MEMORY,
@@ -272,8 +271,7 @@
        if (!NT_SUCCESS(Status))
        {
                DPRINT1("STATUS_NO_MEMORY: %x\n", Status);
-               if (!Locked)
-                       MmUnlockAddressSpace(MmGetKernelAddressSpace());
+               MmUnlockAddressSpace(MmGetKernelAddressSpace());
                MmReleasePageMemoryConsumer(MC_USER, *Page);
                return STATUS_NO_MEMORY;
        }
@@ -282,15 +280,13 @@
        if (!NT_SUCCESS(Status))
        {
                MmFreeMemoryArea(MmGetKernelAddressSpace(), TmpArea, NULL, NULL);
-               if (!Locked)
-                       MmUnlockAddressSpace(MmGetKernelAddressSpace());
+               MmUnlockAddressSpace(MmGetKernelAddressSpace());
                MmReleasePageMemoryConsumer(MC_USER, *Page);
                DPRINT1("Status: %x\n", Status);
                return Status;
        }
-       if (!Locked)
-               MmUnlockAddressSpace(MmGetKernelAddressSpace());
+       MmUnlockAddressSpace(MmGetKernelAddressSpace());
        MiZeroPage(*Page);
        Status = MiSimpleRead
@@ -302,13 +298,11 @@
        DPRINT("Read Status %x (Page %x)\n", Status, *Page);
-       if (!Locked)
-               MmLockAddressSpace(MmGetKernelAddressSpace());
+       MmLockAddressSpace(MmGetKernelAddressSpace());
        MmDeleteVirtualMapping(NULL, PageBuf, FALSE, NULL, &XPage);
        ASSERT(XPage == *Page);
        MmFreeMemoryArea(MmGetKernelAddressSpace(), TmpArea, NULL, NULL);
-       if (!Locked)
-               MmUnlockAddressSpace(MmGetKernelAddressSpace());
+       MmUnlockAddressSpace(MmGetKernelAddressSpace());
        if (!NT_SUCCESS(Status))
        {
@@ -383,11 +377,9 @@
                DPRINT("Reading at offset %08x%08x (relative %x)\n",
TotalOffset.HighPart, TotalOffset.LowPart, Offset);
                MmUnlockSectionSegment(Segment);
-               if (!Locked)
-                       MmUnlockAddressSpace(AddressSpace);
-               Status = MiReadFilePage(Segment->FileObject, &TotalOffset,
&Page, Locked);
-               if (!Locked)
-                       MmLockAddressSpace(AddressSpace);
+               MmUnlockAddressSpace(AddressSpace);
+               Status = MiReadFilePage(Segment->FileObject, &TotalOffset,
&Page);
+               MmLockAddressSpace(AddressSpace);
                if (!NT_SUCCESS(Status))
                {
@@ -430,23 +422,10 @@
                SWAPENTRY SwapEntry;
                MmDeletePageFileMapping(Process, (PVOID)PAddress, &SwapEntry);
-               MmUnlockSectionSegment(Segment);
-               if (!Locked)
-                       MmUnlockAddressSpace(AddressSpace);
                Status = MmRequestPageMemoryConsumer(MC_USER, TRUE, &Page);
                if (!NT_SUCCESS(Status))
                {
                        ASSERT(FALSE);
-               }
-
-               MmLockSectionSegment(Segment);
-
-               if (!Locked)
-                       MmLockAddressSpace(AddressSpace);
-               if (!MmIsPageSwapEntry(Process, PAddress))
-               {
-                       // Handled elsewhere
-                       return STATUS_SUCCESS;
                }
                Status = MmReadFromSwapPage(SwapEntry, Page);
@@ -455,7 +434,6 @@
                        DPRINT1("MmReadFromSwapPage failed, status = %x\n",
Status);
                        ASSERT(FALSE);
                }
-
                DPRINT("CreateVirtualMapping: %x -> %x\n", Address,
Attributes);
                Status = MmCreateVirtualMapping(Process,
                                                                                Address,
@@ -590,20 +568,17 @@
 MiCopyFromUserPage(PFN_TYPE DestPage, PVOID SourceAddress)
 {
     PEPROCESS Process;
-    KIRQL PrimaryIrql, Irql;
+    KIRQL Irql;
     PVOID TempAddress;
     Process = PsGetCurrentProcess();
-       PrimaryIrql = KfRaiseIrql(DISPATCH_LEVEL);
     TempAddress = MiMapPageInHyperSpace(Process, DestPage, &Irql);
     if (TempAddress == NULL)
     {
-               KfLowerIrql(PrimaryIrql);
         return(STATUS_NO_MEMORY);
     }
     memcpy(TempAddress, SourceAddress, PAGE_SIZE);
     MiUnmapPageInHyperSpace(Process, TempAddress, Irql);
-       KfLowerIrql(PrimaryIrql);
     return(STATUS_SUCCESS);
 }
@@ -682,9 +657,7 @@
    /*
     * Allocate a page
     */
-   MmUnlockSectionSegment(Segment);
    Status = MmRequestPageMemoryConsumer(MC_USER, TRUE, &NewPage);
-
    if (!NT_SUCCESS(Status))
    {
       ASSERT(FALSE);
@@ -695,15 +668,6 @@
     * Copy the old page
     */
    MiCopyFromUserPage(NewPage, PAddress);
-
-   MmLockSectionSegment(Segment);
-   if (MmGetPfnForProcess(Process, PAddress) != OldPage)
-   {
-          // Handled elsewhere
-          MmReleasePageMemoryConsumer(MC_USER, NewPage);
-          MmUnlockSectionSegment(Segment);
-          return STATUS_SUCCESS;
-   }
    /*
     * Delete the old entry.
@@ -870,39 +834,26 @@
                ("Pulling zero pages for %08x%08x-%08x%08x\n",
                 FileOffset.u.HighPart, FileOffset.u.LowPart,
                 End.u.HighPart, End.u.LowPart);
-
        MmLockSectionSegment(Segment);
        while (FileOffset.QuadPart < End.QuadPart)
        {
                PVOID Address;
                ULONG Entry = MiGetPageEntrySectionSegment(Segment, &FileOffset);
-
                if (Entry == 0)
                {
-                       MmUnlockSectionSegment(Segment);
-                       MmUnlockAddressSpace(AddressSpace);
-
                        if (!NT_SUCCESS(MmRequestPageMemoryConsumer(MC_USER, TRUE,
&Page)))
                        {
+                               MmUnlockSectionSegment(Segment);
+                               MmUnlockAddressSpace(AddressSpace);
                                return STATUS_NO_MEMORY;
                        }
-
-                       MmLockAddressSpace(AddressSpace);
-                       MmLockSectionSegment(Segment);
                        Address = ((PCHAR)MemoryArea->StartingAddress) +
FileOffset.QuadPart - FirstMapped.QuadPart;
-
-                       if (!MmIsPagePresent(NULL, Address) &&
MiGetPageEntrySectionSegment(Segment, &FileOffset) == Entry)
-                       {
-                               MmCreateVirtualMapping(NULL, Address, PAGE_READWRITE,
&Page, 1);
-                               MmInsertRmap(Page, NULL, Address);
-                               MiSetPageEntrySectionSegment(Segment, &FileOffset,
MAKE_SSE(Page << PAGE_SHIFT, 1));
-                       }
-                       else
-                               MmReleasePageMemoryConsumer(MC_USER, Page);
+                       MmCreateVirtualMapping(NULL, Address, PAGE_READWRITE, &Page,
1);
+                       MmInsertRmap(Page, NULL, Address);
+                       MiSetPageEntrySectionSegment(Segment, &FileOffset,
MAKE_SSE(Page << PAGE_SHIFT, 1));
                }
                FileOffset.QuadPart += PAGE_SIZE;
        }
-
        MmUnlockSectionSegment(Segment);
        MmUnlockAddressSpace(AddressSpace);
        return STATUS_SUCCESS;
@@ -1049,6 +1000,8 @@
          }
       MmReleasePageMemoryConsumer(MC_USER, Page);
+      PageOp->Status = STATUS_SUCCESS;
+      MmspCompleteAndReleasePageOp(PageOp);
       return(STATUS_SUCCESS);
    }
    else if (!Context.WasDirty && Context.Private && SwapEntry != 0)
@@ -1064,6 +1017,8 @@
          ASSERT(FALSE);
       }
       MmReleasePageMemoryConsumer(MC_USER, Page);
+      PageOp->Status = STATUS_SUCCESS;
+      MmspCompleteAndReleasePageOp(PageOp);
       return(STATUS_SUCCESS);
    }
@@ -1112,6 +1067,8 @@
             MiSetPageEntrySectionSegment(Context.Segment, &Context.Offset, Entry);
          }
          MmUnlockAddressSpace(AddressSpace);
+         PageOp->Status = STATUS_UNSUCCESSFUL;
+         MmspCompleteAndReleasePageOp(PageOp);
          return(STATUS_PAGEFILE_QUOTA);
       }
    }
@@ -1156,6 +1113,8 @@
          MiSetPageEntrySectionSegment(Context.Segment, &Context.Offset, Entry);
       }
       MmUnlockAddressSpace(AddressSpace);
+      PageOp->Status = STATUS_UNSUCCESSFUL;
+      MmspCompleteAndReleasePageOp(PageOp);
       return(STATUS_UNSUCCESSFUL);
    }
@@ -1184,6 +1143,8 @@
       MiSetPageEntrySectionSegment(Context.Segment, &Context.Offset, Entry);
    }
+   PageOp->Status = STATUS_SUCCESS;
+   MmspCompleteAndReleasePageOp(PageOp);
    return(STATUS_SUCCESS);
 }
@@ -1198,8 +1159,10 @@
    PROS_SECTION_OBJECT Section;
    PMM_SECTION_SEGMENT Segment;
    PFN_TYPE Page;
+   SWAPENTRY SwapEntry;
    ULONG Entry;
-   NTSTATUS Status = STATUS_SUCCESS;
+   BOOLEAN Private;
+   NTSTATUS Status;
    PFILE_OBJECT FileObject;
    PEPROCESS Process = MmGetAddressSpaceOwner(AddressSpace);
@@ -1220,38 +1183,83 @@
    /*
     * Get the section segment entry and the physical address.
     */
-   MmLockAddressSpace(AddressSpace);
-   MmLockSectionSegment(Segment);
-
    Entry = MiGetPageEntrySectionSegment(Segment, &Offset);
+   if (!MmIsPagePresent(Process, Address))
+   {
+      DPRINT1("Trying to page out not-present page at (%d,0x%.8X).\n",
+              Process ? Process->UniqueProcessId : 0, Address);
+      ASSERT(FALSE);
+   }
    Page = MmGetPfnForProcess(Process, Address);
-
-   if (!Page)
-   {
-          // Somebody else already paged it out
-          MmUnlockSectionSegment(Segment);
-          MmUnlockAddressSpace(AddressSpace);
-          return STATUS_SUCCESS;
-   }
+   SwapEntry = MmGetSavedSwapEntryPage(Page);
    /*
     * Check for a private (COWed) page.
     */
-   if (!IS_SWAP_FROM_SSE(Entry) && PFN_FROM_SSE(Entry) == Page &&
MmIsDirtyPageRmap(Page))
-   {
-          MmSetCleanAllRmaps(Page);
-          DPRINT("MiWriteBackPage(%wZ,%08x%08x)\n",
&FileObject->FileName, Offset.u.HighPart, Offset.u.LowPart);
-          MmUnlockSectionSegment(Segment);
-          MmUnlockAddressSpace(AddressSpace);
-          Status = MiWriteBackPage(FileObject, &Offset, PAGE_SIZE, Page);
+   if (IS_SWAP_FROM_SSE(Entry) || PFN_FROM_SSE(Entry) != Page)
+   {
+      Private = TRUE;
    }
    else
    {
-          MmUnlockAddressSpace(AddressSpace);
-          MmUnlockSectionSegment(Segment);
-   }
-
-   return(Status);
+      Private = FALSE;
+   }
+
+   /*
+    * Speculatively set all mappings of the page to clean.
+    */
+   MmSetCleanAllRmaps(Page);
+
+   /*
+    * If this page was direct mapped from the cache then the cache manager
+    * will take care of writing it back to disk.
+    */
+   if (!Private)
+   {
+      ASSERT(SwapEntry == 0);
+         DPRINT("MiWriteBackPage(%wZ,%08x%08x)\n",
&FileObject->FileName, Offset.u.HighPart, Offset.u.LowPart);
+      Status = PageOp->Status = MiWriteBackPage(FileObject, &Offset, PAGE_SIZE,
Page);
+      MmspCompleteAndReleasePageOp(PageOp);
+      return(Status);
+   }
+
+   /*
+    * If necessary, allocate an entry in the paging file for this page
+    */
+   if (SwapEntry == 0)
+   {
+      SwapEntry = MmAllocSwapPage();
+      if (SwapEntry == 0)
+      {
+         MmSetDirtyAllRmaps(Page);
+         PageOp->Status = STATUS_UNSUCCESSFUL;
+         MmspCompleteAndReleasePageOp(PageOp);
+         return(STATUS_PAGEFILE_QUOTA);
+      }
+      MmSetSavedSwapEntryPage(Page, SwapEntry);
+   }
+
+   /*
+    * Write the page to the pagefile
+    */
+   Status = MmWriteToSwapPage(SwapEntry, Page);
+   if (!NT_SUCCESS(Status))
+   {
+      DPRINT1("MM: Failed to write to swap page (Status was 0x%.8X)\n",
+              Status);
+      MmSetDirtyAllRmaps(Page);
+      PageOp->Status = STATUS_UNSUCCESSFUL;
+      MmspCompleteAndReleasePageOp(PageOp);
+      return(STATUS_UNSUCCESSFUL);
+   }
+
+   /*
+    * Otherwise we have succeeded.
+    */
+   DPRINT("MM: Wrote section page 0x%.8X to swap!\n", Page <<
PAGE_SHIFT);
+   PageOp->Status = STATUS_SUCCESS;
+   MmspCompleteAndReleasePageOp(PageOp);
+   return(STATUS_SUCCESS);
 }
 NTSTATUS
@@ -1283,6 +1291,8 @@
        Segment = MemoryArea->Data.SectionData.Segment;
        ViewOffset.QuadPart = MemoryArea->Data.SectionData.ViewOffset.QuadPart;
+       MmLockSectionSegment(Segment);
+
        Pages = ExAllocatePool
                (NonPagedPool,
                 sizeof(PFN_TYPE) *
@@ -1292,8 +1302,6 @@
        {
                ASSERT(FALSE);
        }
-
-       MmLockSectionSegment(Segment);
        for (PageAddress = BeginningAddress;
                 PageAddress < EndingAddress;
@@ -1328,10 +1336,8 @@
                {
                        DPRINT("MiWriteBackPage(%wZ,%08x%08x)\n",
&Segment->FileObject->FileName, FileOffset.u.HighPart, FileOffset.u.LowPart);
                        Status = MiWriteBackPage(Segment->FileObject, &FileOffset,
PAGE_SIZE, Page);
-                       MmLockAddressSpace(AddressSpace);
                        MmUnlockPage(Page);
                        MmSetCleanAllRmaps(Page);
-                       MmUnlockAddressSpace(AddressSpace);
                        if (!NT_SUCCESS(Status))
                        {
                                DPRINT1
@@ -1689,7 +1695,7 @@
        return(STATUS_NO_MEMORY);
    }
-   KeInitializeGuardedMutex(&Segment->Lock);
+   ExInitializeFastMutex(&Segment->Lock);
    Segment->ReferenceCount = 1;
    Section->Segment = Segment;
@@ -1707,7 +1713,7 @@
       /*
        * Set the lock before assigning the segment to the file object
        */
-      KeAcquireGuardedMutex(&Segment->Lock);
+      ExAcquireFastMutex(&Segment->Lock);
       DPRINT("Filling out Segment info (No previous data section)\n");
          ObReferenceObject(FileObject);
@@ -2327,6 +2333,50 @@
    return(STATUS_SUCCESS);
 }
+NTSTATUS
+NTAPI
+MiAwaitPageOps(PMMSUPPORT AddressSpace, PMEMORY_AREA MemoryArea, PVOID BaseAddress)
+{
+       NTSTATUS Status;
+       PMM_PAGEOP PageOp;
+       ULONG Offset;
+
+       while (MemoryArea->PageOpCount)
+       {
+               Offset = PAGE_ROUND_UP((ULONG_PTR)MemoryArea->EndingAddress -
(ULONG_PTR)MemoryArea->StartingAddress);
+
+               while (Offset)
+               {
+                       Offset -= PAGE_SIZE;
+                       PageOp = MmCheckForPageOp(MemoryArea, NULL, NULL,
+
MemoryArea->Data.SectionData.Segment,
+                                                                         Offset);
+                       if (PageOp)
+                       {
+                               MmUnlockAddressSpace(AddressSpace);
+                               Status = MmspWaitForPageOpCompletionEvent(PageOp);
+                               if (Status != STATUS_SUCCESS)
+                               {
+                                       DPRINT1("Failed to wait for page op, status =
%x\n", Status);
+                                       ASSERT(FALSE);
+                               }
+                               MmLockAddressSpace(AddressSpace);
+                               MemoryArea = MmLocateMemoryAreaByAddress(AddressSpace,
+
BaseAddress);
+                               if (MemoryArea == NULL ||
+                                       MemoryArea->Type != MEMORY_AREA_SECTION_VIEW)
+                               {
+                                       MmUnlockAddressSpace(AddressSpace);
+                                       DPRINT("STATUS_NOT_MAPPED_VIEW\n");
+                                       return STATUS_NOT_MAPPED_VIEW;
+                               }
+                               break;
+                       }
+               }
+       }
+       return STATUS_SUCCESS;
+}
+
 /*
  * @implemented
  */
@@ -2359,14 +2409,18 @@
    if (MemoryArea->Type == MEMORY_AREA_IMAGE_SECTION)
    {
           MemoryArea->DeleteInProgress = TRUE;
-          Status = MiUnmapImageSection(AddressSpace, MemoryArea, BaseAddress);
+          Status = MiAwaitPageOps(AddressSpace, MemoryArea, BaseAddress);
+          if (NT_SUCCESS(Status))
+                  Status = MiUnmapImageSection(AddressSpace, MemoryArea, BaseAddress);
    }
    else if (MemoryArea->Type == MEMORY_AREA_PHYSICAL_MEMORY_SECTION ||
                        MemoryArea->Type == MEMORY_AREA_PAGE_FILE_SECTION ||
                        MemoryArea->Type == MEMORY_AREA_SECTION_VIEW)
    {
           MemoryArea->DeleteInProgress = TRUE;
-          Status = MmUnmapViewOfSegment(AddressSpace, BaseAddress);
+          Status = MiAwaitPageOps(AddressSpace, MemoryArea, BaseAddress);
+          if (NT_SUCCESS(Status))
+                  Status = MmUnmapViewOfSegment(AddressSpace, BaseAddress);
    }
    else
    {
Modified: branches/arty-newcc/ntoskrnl/mm/section/image.c
URL:
http://svn.reactos.org/svn/reactos/branches/arty-newcc/ntoskrnl/mm/section/…
==============================================================================
--- branches/arty-newcc/ntoskrnl/mm/section/image.c [iso-8859-1] (original)
+++ branches/arty-newcc/ntoskrnl/mm/section/image.c [iso-8859-1] Fri Nov 27 02:03:24 2009
@@ -233,17 +233,14 @@
        Entry = MiGetPageEntrySectionSegment(Segment, &Offset);
        HasSwapEntry = MmIsPageSwapEntry(Process, (PVOID)PAddress);
-       if (Entry == 0 && !HasSwapEntry &&
-               (Offset.QuadPart < PAGE_ROUND_UP(Segment->RawLength.QuadPart)))
+       if (Entry == 0 && !HasSwapEntry && Offset.QuadPart <
PAGE_ROUND_UP(Segment->RawLength.QuadPart))
        {
                TotalOffset.QuadPart = Offset.QuadPart +
Segment->Image.FileOffset/*.QuadPart*/;
                MmUnlockSectionSegment(Segment);
-               if (!Locked)
-                       MmUnlockAddressSpace(AddressSpace);
-               Status = MiReadFilePage(Section->FileObject, &TotalOffset,
&Page, Locked);
-               if (!Locked)
-                       MmLockAddressSpace(AddressSpace);
+               MmUnlockAddressSpace(AddressSpace);
+               Status = MiReadFilePage(Section->FileObject, &TotalOffset,
&Page);
+               MmLockAddressSpace(AddressSpace);
                if (!NT_SUCCESS(Status))
                {
@@ -285,15 +282,10 @@
                MmDeletePageFileMapping(Process, (PVOID)PAddress, &SwapEntry);
-               MmUnlockSectionSegment(Segment);
-               if (!Locked)
-                       MmUnlockAddressSpace(AddressSpace);
                Status = MmRequestPageMemoryConsumer(MC_USER, TRUE, &Page);
                if (!NT_SUCCESS(Status))
                {
-                       if (!Locked)
-                               MmLockAddressSpace(AddressSpace);
-                       return Status;
+                       ASSERT(FALSE);
                }
                DPRINT("Allocated page %x\n", Page);
@@ -304,14 +296,6 @@
                        ASSERT(FALSE);
                }
                MmLockAddressSpace(AddressSpace);
-               MmLockSectionSegment(Segment);
-               if (MmIsPagePresent(Process, Address))
-               {
-                       // Handled elsewhere
-                       MmReleasePageMemoryConsumer(MC_USER, Page);
-                       MmUnlockSectionSegment(Segment);
-                       return STATUS_SUCCESS;
-               }
                Status = MmCreateVirtualMapping(Process,
                                                                                Address,
Region->Protect,
@@ -351,26 +335,16 @@
         */
        if (Segment->Image.Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA)
        {
-               MmUnlockSectionSegment(Segment);
-               if (!Locked)
-                       MmUnlockAddressSpace(AddressSpace);
+               MmUnlockAddressSpace(AddressSpace);
                Status = MmRequestPageMemoryConsumer(MC_USER, TRUE, &Page);
                if (!NT_SUCCESS(Status))
                {
                        DPRINT("Status %x\n", Status);
-                       if (!Locked)
-                               MmLockAddressSpace(AddressSpace);
+                       MmUnlockSectionSegment(Segment);
                        return Status;
                }
                DPRINT("Allocated page %x\n", Page);
-               if (!Locked)
-                       MmLockAddressSpace(AddressSpace);
-               if (MmIsPagePresent(Process, Address))
-               {
-                       // Handled elsewhere
-                       MmReleasePageMemoryConsumer(MC_USER, Page);
-                       return STATUS_SUCCESS;
-               }
+               MmLockAddressSpace(AddressSpace);
                Status = MmCreateVirtualMapping(Process,
                                                                                Address,
Region->Protect,
@@ -380,6 +354,7 @@
                {
                        MmReleasePageMemoryConsumer(MC_USER, Page);
                        DPRINT("Release page %x\n", Page);
+                       MmUnlockSectionSegment(Segment);
                        return(Status);
                }
                MmInsertRmap(Page, Process, (PVOID)PAddress);
@@ -391,6 +366,7 @@
                /*
                 * Cleanup and release locks
                 */
+               MmUnlockSectionSegment(Segment);
                //DPRINT("Address 0x%.8X\n", Address);
                return(STATUS_SUCCESS);
        }
@@ -410,9 +386,7 @@
                /*
                 * Release all our locks and read in the page from disk
                 */
-               MmUnlockSectionSegment(Segment);
-               if (!Locked)
-                       MmUnlockAddressSpace(AddressSpace);
+               MmUnlockAddressSpace(AddressSpace);
                if (Offset.QuadPart >= PAGE_ROUND_UP(Segment->RawLength.QuadPart))
                {
@@ -420,8 +394,8 @@
                        if (!NT_SUCCESS(Status))
                        {
                                DPRINT1("MmRequestPageMemoryConsumer failed (Status
%x)\n", Status);
-                               if (!Locked)
-                                       MmLockAddressSpace(AddressSpace);
+                               MmLockAddressSpace(AddressSpace);
+                               MmUnlockSectionSegment(Segment);
                                return Status;
                        }
                        DPRINT("Allocated page %x\n", Page);
@@ -435,8 +409,8 @@
                                DPRINT1("Unable to create virtual mapping\n");
                                MmReleasePageMemoryConsumer(MC_USER, Page);
                                DPRINT("Release page %x\n", Page);
-                               if (!Locked)
-                                       MmLockAddressSpace(AddressSpace);
+                               MmLockAddressSpace(AddressSpace);
+                               MmUnlockSectionSegment(Segment);
                                return Status;
                        }
                }
@@ -452,8 +426,8 @@
                                DPRINT1("Unable to create virtual mapping\n");
                                MmReleasePageMemoryConsumer(MC_USER, Page);
                                DPRINT("Release page %x\n", Page);
-                               if (!Locked)
-                                       MmLockAddressSpace(AddressSpace);
+                               MmLockAddressSpace(AddressSpace);
+                               MmUnlockSectionSegment(Segment);
                                return Status;
                        }
@@ -463,21 +437,12 @@
                /*
                 * Relock the address space and segment
                 */
-               if (!Locked)
-                       MmLockAddressSpace(AddressSpace);
+               MmLockAddressSpace(AddressSpace);
                /*
                 * Mark the offset within the section as having valid, in-memory
                 * data
                 */
-               MmLockSectionSegment(Segment);
-               if (Entry != MiGetPageEntrySectionSegment(Segment, &Offset))
-               {
-                       // Handled elsewhere
-                       MmUnlockSectionSegment(Segment);
-                       return STATUS_SUCCESS;
-               }
-
                Entry = MAKE_SSE(Page << PAGE_SHIFT, 1);
                MiSetPageEntrySectionSegment(Segment, &Offset, Entry);
@@ -532,8 +497,6 @@
                //DPRINT("Address 0x%.8X\n", Address);
                return(STATUS_SUCCESS);
        }
-
-       ASSERT(FALSE);
 }
 NTSTATUS
@@ -1437,7 +1400,7 @@
    /* And finish their initialization */
    for ( i = 0; i < ImageSectionObject->NrSegments; ++ i )
    {
-      KeInitializeGuardedMutex(&ImageSectionObject->Segments[i].Lock);
+      ExInitializeFastMutex(&ImageSectionObject->Segments[i].Lock);
          ImageSectionObject->Segments[i].Flags = MM_IMAGE_SEGMENT;
       ImageSectionObject->Segments[i].ReferenceCount = 1;
          MiInitializeSectionPageTable(&ImageSectionObject->Segments[i]);
@@ -1885,6 +1848,8 @@
        //DPRINT("MiUnmapImageSection @ %x\n", BaseAddress);
        MemoryArea->DeleteInProgress = TRUE;
+       MiAwaitPageOps(AddressSpace, MemoryArea, BaseAddress);
+
        Section = MemoryArea->Data.SectionData.Section;
        if (Section->AllocationAttributes & SEC_IMAGE)
Modified: branches/arty-newcc/ntoskrnl/mm/section/io.c
URL:
http://svn.reactos.org/svn/reactos/branches/arty-newcc/ntoskrnl/mm/section/…
==============================================================================
--- branches/arty-newcc/ntoskrnl/mm/section/io.c [iso-8859-1] (original)
+++ branches/arty-newcc/ntoskrnl/mm/section/io.c [iso-8859-1] Fri Nov 27 02:03:24 2009
@@ -54,6 +54,8 @@
 #pragma alloc_text(INIT, MmInitSectionImplementation)
 #endif
+KEVENT CcpLazyWriteEvent;
+
 /*
  * FUNCTION:  Waits in kernel mode indefinitely for a file object lock.
  * ARGUMENTS: PFILE_OBJECT to wait for.
@@ -426,65 +428,82 @@
  ULONG Length,
  PFN_TYPE Page)
 {
-       PFN_TYPE XPage;
        NTSTATUS Status;
+       PVOID Hyperspace;
        IO_STATUS_BLOCK Iosb;
-       PVOID PageBuf = 0;
-       PMEMORY_AREA TmpArea;
-       PHYSICAL_ADDRESS BoundaryAddressMultiple;
-
-       BoundaryAddressMultiple.QuadPart = 0;
-
-       MmLockAddressSpace(MmGetKernelAddressSpace());
-
-       Status = MmCreateMemoryArea
-               (MmGetKernelAddressSpace(),
-                MEMORY_AREA_VIRTUAL_MEMORY,
-                &PageBuf,
-                PAGE_SIZE,
-                PAGE_READWRITE,
-                &TmpArea,
-                FALSE,
-                MEM_TOP_DOWN,
-                BoundaryAddressMultiple);
-
-       if (!NT_SUCCESS(Status))
-       {
-               DPRINT1("STATUS_NO_MEMORY: %x\n", Status);
-               MmUnlockAddressSpace(MmGetKernelAddressSpace());
-               return STATUS_NO_MEMORY;
-       }
-
-       Status = MmCreateVirtualMapping(NULL, PageBuf, PAGE_READWRITE, &Page, 1);
-       if (!NT_SUCCESS(Status))
-       {
-               MmFreeMemoryArea(MmGetKernelAddressSpace(), TmpArea, NULL, NULL);
-               MmUnlockAddressSpace(MmGetKernelAddressSpace());
-               DPRINT1("Status: %x\n", Status);
-               return Status;
-       }
-       MmReferencePage(Page);
-       MmUnlockAddressSpace(MmGetKernelAddressSpace());
+       KIRQL OldIrql;
+       PVOID PageBuffer = ExAllocatePool(NonPagedPool, PAGE_SIZE);
+
+       if (!PageBuffer) return STATUS_NO_MEMORY;
+
+       OldIrql = KfRaiseIrql(DISPATCH_LEVEL);
+       Hyperspace = MmCreateHyperspaceMapping(Page);
+       RtlCopyMemory(PageBuffer, Hyperspace, PAGE_SIZE);
+       MmDeleteHyperspaceMapping(Hyperspace);
+       KfLowerIrql(OldIrql);
        DPRINT("MiWriteBackPage(%wZ,%08x%08x)\n", &FileObject->FileName,
FileOffset->u.HighPart, FileOffset->u.LowPart);
        Status = MiSimpleWrite
                (FileObject,
                 FileOffset,
-                PageBuf,
+                PageBuffer,
                 Length,
                 &Iosb);
+       ExFreePool(PageBuffer);
+
        if (!NT_SUCCESS(Status))
        {
                DPRINT1("MiSimpleWrite failed (%x)\n", Status);
        }
-       MmLockAddressSpace(MmGetKernelAddressSpace());
-       MmDeleteVirtualMapping(NULL, PageBuf, FALSE, NULL, &XPage);
-       ASSERT(XPage == Page);
-       MmFreeMemoryArea(MmGetKernelAddressSpace(), TmpArea, NULL, NULL);
-       MmDereferencePage(Page);
-       MmUnlockAddressSpace(MmGetKernelAddressSpace());
-
        return Status;
 }
+
+VOID
+NTAPI
+MiWriteThread()
+{
+       BOOLEAN Complete;
+       NTSTATUS Status;
+       LIST_ENTRY OldHead;
+       PLIST_ENTRY Entry;
+       PWRITE_SCHEDULE_ENTRY WriteEntry;
+
+       ExAcquireFastMutex(&MiWriteMutex);
+       Complete = IsListEmpty(&MiWriteScheduleListHead);
+       ExReleaseFastMutex(&MiWriteMutex);
+       if (Complete)
+       {
+               DPRINT1("No items await writing\n");
+               KeSetEvent(&CcpLazyWriteEvent, IO_NO_INCREMENT, FALSE);
+       }
+
+       DPRINT1("Lazy write items are available\n");
+       KeResetEvent(&CcpLazyWriteEvent);
+
+       ExAcquireFastMutex(&MiWriteMutex);
+       RtlCopyMemory(&OldHead, &MiWriteScheduleListHead, sizeof(OldHead));
+       OldHead.Flink->Blink = &OldHead;
+       OldHead.Blink->Flink = &OldHead;
+       InitializeListHead(&MiWriteScheduleListHead);
+       ExReleaseFastMutex(&MiWriteMutex);
+
+       for (Entry = OldHead.Flink;
+                !IsListEmpty(&OldHead);
+                Entry = OldHead.Flink)
+       {
+               WriteEntry = CONTAINING_RECORD(Entry, WRITE_SCHEDULE_ENTRY, Entry);
+               Status = MiWriteBackPage(WriteEntry->FileObject,
&WriteEntry->FileOffset, WriteEntry->Length, WriteEntry->Page);
+
+               if (!NT_SUCCESS(Status))
+               {
+                       DPRINT1("MiSimpleWrite failed (%x)\n", Status);
+               }
+
+               MmDereferencePage(WriteEntry->Page);
+               ObDereferenceObject(WriteEntry->FileObject);
+               RemoveEntryList(&WriteEntry->Entry);
+               ExFreePool(WriteEntry);
+       }
+}
Modified: branches/arty-newcc/ntoskrnl/mm/section/pagefile.c
URL:
http://svn.reactos.org/svn/reactos/branches/arty-newcc/ntoskrnl/mm/section/…
==============================================================================
--- branches/arty-newcc/ntoskrnl/mm/section/pagefile.c [iso-8859-1] (original)
+++ branches/arty-newcc/ntoskrnl/mm/section/pagefile.c [iso-8859-1] Fri Nov 27 02:03:24
2009
@@ -69,7 +69,9 @@
        PROS_SECTION_OBJECT Section;
        PMM_SECTION_SEGMENT Segment;
        ULONG Entry;
+       ULONG Entry1;
        ULONG Attributes;
+       PMM_PAGEOP PageOp;
        PMM_REGION Region;
        BOOLEAN HasSwapEntry;
        PEPROCESS Process = MmGetAddressSpaceOwner(AddressSpace);
@@ -98,14 +100,10 @@
        Region = MmFindRegion(MemoryArea->StartingAddress,
&MemoryArea->Data.SectionData.RegionListHead,
                                                  Address, NULL);
-
        /*
         * Lock the segment
         */
        MmLockSectionSegment(Segment);
-
-       Entry = MiGetPageEntrySectionSegment(Segment, &Offset);
-       HasSwapEntry = MmIsPageSwapEntry(Process, (PVOID)PAddress);
        /*
         * Check if this page needs to be mapped COW
@@ -121,63 +119,178 @@
                Attributes = Region->Protect;
        }
+       /*
+        * Get or create a page operation descriptor
+        */
+       PageOp = MmGetPageOp(MemoryArea, NULL, 0, Segment, Offset.QuadPart,
MM_PAGEOP_PAGEIN, FALSE);
+       if (PageOp == NULL)
+       {
+               DPRINT1("MmGetPageOp failed\n");
+               ASSERT(FALSE);
+       }
+
+       /*
+        * Check if someone else is already handling this fault, if so wait
+        * for them
+        */
+       if (PageOp->Thread != PsGetCurrentThread())
+       {
+               MmUnlockSectionSegment(Segment);
+               MmUnlockAddressSpace(AddressSpace);
+               Status = MmspWaitForPageOpCompletionEvent(PageOp);
+               /*
+                * Check for various strange conditions
+                */
+               if (Status != STATUS_SUCCESS)
+               {
+                       DPRINT1("Failed to wait for page op, status = %x\n",
Status);
+                       ASSERT(FALSE);
+               }
+               if (PageOp->Status == STATUS_PENDING)
+               {
+                       DPRINT1("Woke for page op before completion\n");
+                       ASSERT(FALSE);
+               }
+               MmLockAddressSpace(AddressSpace);
+               /*
+                * If this wasn't a pagein then restart the operation
+                */
+               if (PageOp->OpType != MM_PAGEOP_PAGEIN)
+               {
+                       MmspCompleteAndReleasePageOp(PageOp);
+                       DPRINT("Address 0x%.8X\n", Address);
+                       return(STATUS_MM_RESTART_OPERATION);
+               }
+
+               /*
+                * If the thread handling this fault has failed then we don't retry
+                */
+               if (!NT_SUCCESS(PageOp->Status))
+               {
+                       Status = PageOp->Status;
+                       MmspCompleteAndReleasePageOp(PageOp);
+                       DPRINT("Address 0x%.8X\n", Address);
+                       return(Status);
+               }
+               MmLockSectionSegment(Segment);
+               /*
+                * If the completed fault was for another address space then set the
+                * page in this one.
+                */
+               if (!MmIsPagePresent(Process, Address))
+               {
+                       DPRINT("!MmIsPagePresent(%p, %p)\n", Process, Address);
+
+                       Entry = MiGetPageEntrySectionSegment(Segment, &Offset);
+                       HasSwapEntry = MmIsPageSwapEntry(Process, (PVOID)PAddress);
+
+                       if (PAGE_FROM_SSE(Entry) == 0 || HasSwapEntry)
+                       {
+                               /*
+                                * The page was a private page in another or in our
address space
+                                */
+                               MmUnlockSectionSegment(Segment);
+                               MmspCompleteAndReleasePageOp(PageOp);
+                               return(STATUS_MM_RESTART_OPERATION);
+                       }
+
+                       Page = PFN_FROM_SSE(Entry);
+
+                       MmSharePageEntrySectionSegment(Segment, &Offset);
+
+                       /* FIXME: Should we call MmCreateVirtualMappingUnsafe if
+                        * (Section->AllocationAttributes & SEC_PHYSICALMEMORY) is
true?
+                        */
+                       Status = MmCreateVirtualMapping(Process,
+
Address,
+
Attributes,
+
&Page,
+
1);
+                       if (!NT_SUCCESS(Status))
+                       {
+                               DPRINT1("Unable to create virtual mapping\n");
+                               ASSERT(FALSE);
+                       }
+                       MmInsertRmap(Page, Process, (PVOID)PAddress);
+               }
+               if (Locked)
+               {
+                       MmLockPage(Page);
+               }
+               MmUnlockSectionSegment(Segment);
+               PageOp->Status = STATUS_SUCCESS;
+               MmspCompleteAndReleasePageOp(PageOp);
+               DPRINT("Address 0x%.8X\n", Address);
+               return(STATUS_SUCCESS);
+       }
+
+       /*
+        * Get the entry corresponding to the offset within the section
+        */
+       Entry = MiGetPageEntrySectionSegment(Segment, &Offset);
+
        if (Entry == 0)
        {
+               /*
+                * If the entry is zero (and it can't change because we have
+                * locked the segment) then we need to load the page.
+                */
+
+               /*
+                * Release all our locks and read in the page from disk
+                */
                MmUnlockSectionSegment(Segment);
-               if (!Locked)
-                       MmUnlockAddressSpace(AddressSpace);
+               MmUnlockAddressSpace(AddressSpace);
+
                Status = MmRequestPageMemoryConsumer(MC_USER, TRUE, &Page);
                if (!NT_SUCCESS(Status))
                {
                        DPRINT1("MmRequestPageMemoryConsumer failed (Status
%x)\n", Status);
-                       if (!Locked)
-                               MmLockAddressSpace(AddressSpace);
-                       return Status;
-               }
-
-               DPRINT("Allocated page %x\n", Page);
+               }
                Status = MmCreateVirtualMapping(Process,
-                                                                               PAddress,
+                                                                               Address,
Attributes,
                                                                                &Page,
                                                                                1);
                if (!NT_SUCCESS(Status))
                {
                        DPRINT1("Unable to create virtual mapping\n");
-                       MmReleasePageMemoryConsumer(MC_USER, Page);
-                       DPRINT("Release page %x\n", Page);
-                       if (!Locked)
-                               MmLockAddressSpace(AddressSpace);
-                       return Status;
+                       ASSERT(FALSE);
                }
                /*
                 * Relock the address space and segment
                 */
-               if (!Locked)
-                       MmLockAddressSpace(AddressSpace);
-
+               MmLockAddressSpace(AddressSpace);
                MmLockSectionSegment(Segment);
-               if (Entry != MiGetPageEntrySectionSegment(Segment, &Offset))
-               {
-                       // Already handled
-                       MmUnlockSectionSegment(Segment);
-                       return STATUS_SUCCESS;
-               }
+
+               /*
+                * Check the entry. No one should change the status of a page
+                * that has a pending page-in.
+                */
+               Entry1 = MiGetPageEntrySectionSegment(Segment, &Offset);
+               if (Entry != Entry1)
+               {
+                       DPRINT1("Someone changed ppte entry while we slept\n");
+                       ASSERT(FALSE);
+               }
+
                /*
                 * Mark the offset within the section as having valid, in-memory
                 * data
                 */
                Entry = MAKE_SSE(Page << PAGE_SHIFT, 1);
                MiSetPageEntrySectionSegment(Segment, &Offset, Entry);
+               MmUnlockSectionSegment(Segment);
+
                MmInsertRmap(Page, Process, (PVOID)PAddress);
                if (Locked)
                {
                        MmLockPage(Page);
                }
-
-               MmUnlockSectionSegment(Segment);
+               PageOp->Status = STATUS_SUCCESS;
+               MmspCompleteAndReleasePageOp(PageOp);
                DPRINT("Address 0x%.8X\n", Address);
                return(STATUS_SUCCESS);
        }
@@ -189,6 +302,8 @@
                {
                        MmLockPage(Page);
                }
+               PageOp->Status = Status;
+               MmspCompleteAndReleasePageOp(PageOp);
                return Status;
        }
        else
@@ -218,6 +333,8 @@
                {
                        MmLockPage(Page);
                }
+               PageOp->Status = STATUS_SUCCESS;
+               MmspCompleteAndReleasePageOp(PageOp);
                DPRINT("Address 0x%.8X\n", Address);
                return(STATUS_SUCCESS);
        }
@@ -292,7 +409,7 @@
    }
    Section->Segment = Segment;
    Segment->ReferenceCount = 1;
-   KeInitializeGuardedMutex(&Segment->Lock);
+   ExInitializeFastMutex(&Segment->Lock);
    Segment->Protection = SectionPageProtection;
    Segment->RawLength.QuadPart = MaximumSize.QuadPart;
    Segment->Length.QuadPart = PAGE_ROUND_UP(MaximumSize.QuadPart);
@@ -428,6 +545,8 @@
          ASSERT(FALSE);
       }
       MmReleasePageMemoryConsumer(MC_USER, Page);
+      PageOp->Status = STATUS_SUCCESS;
+      MmspCompleteAndReleasePageOp(PageOp);
       return(STATUS_SUCCESS);
    }
    else if (!Context.WasDirty && Context.Private && SwapEntry != 0)
@@ -443,6 +562,8 @@
          ASSERT(FALSE);
       }
       MmReleasePageMemoryConsumer(MC_USER, Page);
+      PageOp->Status = STATUS_SUCCESS;
+      MmspCompleteAndReleasePageOp(PageOp);
       return(STATUS_SUCCESS);
    }
@@ -491,6 +612,8 @@
             MiSetPageEntrySectionSegment(Context.Segment, &Context.Offset, Entry);
          }
          MmUnlockAddressSpace(AddressSpace);
+         PageOp->Status = STATUS_UNSUCCESSFUL;
+         MmspCompleteAndReleasePageOp(PageOp);
          return(STATUS_PAGEFILE_QUOTA);
       }
    }
@@ -535,6 +658,8 @@
          MiSetPageEntrySectionSegment(Context.Segment, &Context.Offset, Entry);
       }
       MmUnlockAddressSpace(AddressSpace);
+      PageOp->Status = STATUS_UNSUCCESSFUL;
+      MmspCompleteAndReleasePageOp(PageOp);
       return(STATUS_UNSUCCESSFUL);
    }
@@ -563,6 +688,8 @@
       MiSetPageEntrySectionSegment(Context.Segment, &Context.Offset, Entry);
    }
+   PageOp->Status = STATUS_SUCCESS;
+   MmspCompleteAndReleasePageOp(PageOp);
    return(STATUS_SUCCESS);
 }
@@ -572,6 +699,8 @@
  PFN_TYPE Page, SWAPENTRY SwapEntry, BOOLEAN Dirty)
 {
    ULONG Entry;
+   PMM_PAGEOP PageOp;
+   NTSTATUS Status;
    LARGE_INTEGER Offset;
    PROS_SECTION_OBJECT Section;
    PMM_SECTION_SEGMENT Segment;
@@ -588,6 +717,26 @@
    Section = MemoryArea->Data.SectionData.Section;
    Segment = MemoryArea->Data.SectionData.Segment;
+
+   PageOp = MmCheckForPageOp(MemoryArea, NULL, NULL, Segment, Offset.QuadPart);
+
+   while (PageOp)
+   {
+      MmUnlockSectionSegment(Segment);
+      MmUnlockAddressSpace(AddressSpace);
+
+      Status = MmspWaitForPageOpCompletionEvent(PageOp);
+      if (Status != STATUS_SUCCESS)
+      {
+         DPRINT1("Failed to wait for page op, status = %x\n", Status);
+         ASSERT(FALSE);
+      }
+
+      MmLockAddressSpace(AddressSpace);
+      MmLockSectionSegment(Segment);
+      MmspCompleteAndReleasePageOp(PageOp);
+      PageOp = MmCheckForPageOp(MemoryArea, NULL, NULL, Segment, Offset.QuadPart);
+   }
    DPRINT("MmFreeSectionPage -> MmGetPageEntrySectionSegment(%p, %x)\n",
Segment, Offset.u.LowPart);
    Entry = MiGetPageEntrySectionSegment(Segment, &Offset);