[NTOSKRNL]
[reactos.git] / reactos / ntoskrnl / mm / pagefile.c
index a1ffb08..e5b88a5 100644 (file)
@@ -44,23 +44,23 @@ MiFindExportedRoutineByName(IN PVOID DllBase,
 
 typedef struct _PAGINGFILE
 {
-   LIST_ENTRY PagingFileListEntry;
-   PFILE_OBJECT FileObject;
-   LARGE_INTEGER MaximumSize;
-   LARGE_INTEGER CurrentSize;
-   PFN_NUMBER FreePages;
-   PFN_NUMBER UsedPages;
-   PULONG AllocMap;
-   KSPIN_LOCK AllocMapLock;
-   ULONG AllocMapSize;
-   PRETRIEVAL_POINTERS_BUFFER RetrievalPointers;
+    LIST_ENTRY PagingFileListEntry;
+    PFILE_OBJECT FileObject;
+    LARGE_INTEGER MaximumSize;
+    LARGE_INTEGER CurrentSize;
+    PFN_NUMBER FreePages;
+    PFN_NUMBER UsedPages;
+    PULONG AllocMap;
+    KSPIN_LOCK AllocMapLock;
+    ULONG AllocMapSize;
+    PRETRIEVAL_POINTERS_BUFFER RetrievalPointers;
 }
 PAGINGFILE, *PPAGINGFILE;
 
 typedef struct _RETRIEVEL_DESCRIPTOR_LIST
 {
-   struct _RETRIEVEL_DESCRIPTOR_LIST* Next;
-   RETRIEVAL_POINTERS_BUFFER RetrievalPointers;
+    struct _RETRIEVEL_DESCRIPTOR_LIST* Next;
+    RETRIEVAL_POINTERS_BUFFER RetrievalPointers;
 }
 RETRIEVEL_DESCRIPTOR_LIST, *PRETRIEVEL_DESCRIPTOR_LIST;
 
@@ -153,67 +153,67 @@ VOID
 NTAPI
 MmShowOutOfSpaceMessagePagingFile(VOID)
 {
-   if (!MmSwapSpaceMessage)
-   {
-      DPRINT1("MM: Out of swap space.\n");
-      MmSwapSpaceMessage = TRUE;
-   }
+    if (!MmSwapSpaceMessage)
+    {
+        DPRINT1("MM: Out of swap space.\n");
+        MmSwapSpaceMessage = TRUE;
+    }
 }
 
 static LARGE_INTEGER
 MmGetOffsetPageFile(PRETRIEVAL_POINTERS_BUFFER RetrievalPointers, LARGE_INTEGER Offset)
 {
-   /* Simple binary search */
-   ULONG first, last, mid;
-   first = 0;
-   last = RetrievalPointers->ExtentCount - 1;
-   while (first <= last)
-   {
-      mid = (last - first) / 2 + first;
-      if (Offset.QuadPart < RetrievalPointers->Extents[mid].NextVcn.QuadPart)
-      {
-         if (mid == 0)
-         {
-            Offset.QuadPart += RetrievalPointers->Extents[0].Lcn.QuadPart - RetrievalPointers->StartingVcn.QuadPart;
-            return Offset;
-         }
-         else
-         {
-            if (Offset.QuadPart >= RetrievalPointers->Extents[mid-1].NextVcn.QuadPart)
+    /* Simple binary search */
+    ULONG first, last, mid;
+    first = 0;
+    last = RetrievalPointers->ExtentCount - 1;
+    while (first <= last)
+    {
+        mid = (last - first) / 2 + first;
+        if (Offset.QuadPart < RetrievalPointers->Extents[mid].NextVcn.QuadPart)
+        {
+            if (mid == 0)
             {
-               Offset.QuadPart += RetrievalPointers->Extents[mid].Lcn.QuadPart - RetrievalPointers->Extents[mid-1].NextVcn.QuadPart;
-               return Offset;
+                Offset.QuadPart += RetrievalPointers->Extents[0].Lcn.QuadPart - RetrievalPointers->StartingVcn.QuadPart;
+                return Offset;
             }
-            last = mid - 1;
-         }
-      }
-      else
-      {
-         if (mid == RetrievalPointers->ExtentCount - 1)
-         {
-            break;
-         }
-         if (Offset.QuadPart < RetrievalPointers->Extents[mid+1].NextVcn.QuadPart)
-         {
-            Offset.QuadPart += RetrievalPointers->Extents[mid+1].Lcn.QuadPart  - RetrievalPointers->Extents[mid].NextVcn.QuadPart;
-            return Offset;
-         }
-         first = mid + 1;
-      }
-   }
-   KeBugCheck(MEMORY_MANAGEMENT);
+            else
+            {
+                if (Offset.QuadPart >= RetrievalPointers->Extents[mid-1].NextVcn.QuadPart)
+                {
+                    Offset.QuadPart += RetrievalPointers->Extents[mid].Lcn.QuadPart - RetrievalPointers->Extents[mid-1].NextVcn.QuadPart;
+                    return Offset;
+                }
+                last = mid - 1;
+            }
+        }
+        else
+        {
+            if (mid == RetrievalPointers->ExtentCount - 1)
+            {
+                break;
+            }
+            if (Offset.QuadPart < RetrievalPointers->Extents[mid+1].NextVcn.QuadPart)
+            {
+                Offset.QuadPart += RetrievalPointers->Extents[mid+1].Lcn.QuadPart  - RetrievalPointers->Extents[mid].NextVcn.QuadPart;
+                return Offset;
+            }
+            first = mid + 1;
+        }
+    }
+    KeBugCheck(MEMORY_MANAGEMENT);
 #if defined(__GNUC__)
 
-   return (LARGE_INTEGER)0LL;
+    return (LARGE_INTEGER)0LL;
 #else
 
-   {
-      const LARGE_INTEGER dummy =
-         {
+    {
+        const LARGE_INTEGER dummy =
+        {
             0
-         };
-      return dummy;
-   }
+        };
+        return dummy;
+    }
 #endif
 }
 
@@ -221,57 +221,57 @@ NTSTATUS
 NTAPI
 MmWriteToSwapPage(SWAPENTRY SwapEntry, PFN_NUMBER Page)
 {
-   ULONG i;
-   ULONG_PTR offset;
-   LARGE_INTEGER file_offset;
-   IO_STATUS_BLOCK Iosb;
-   NTSTATUS Status;
-   KEVENT Event;
-   UCHAR MdlBase[sizeof(MDL) + sizeof(ULONG)];
-   PMDL Mdl = (PMDL)MdlBase;
-
-   DPRINT("MmWriteToSwapPage\n");
-
-   if (SwapEntry == 0)
-   {
-      KeBugCheck(MEMORY_MANAGEMENT);
-      return(STATUS_UNSUCCESSFUL);
-   }
-
-   i = FILE_FROM_ENTRY(SwapEntry);
-   offset = OFFSET_FROM_ENTRY(SwapEntry);
-
-   if (PagingFileList[i]->FileObject == NULL ||
-         PagingFileList[i]->FileObject->DeviceObject == NULL)
-   {
-      DPRINT1("Bad paging file 0x%.8X\n", SwapEntry);
-      KeBugCheck(MEMORY_MANAGEMENT);
-   }
-
-   MmInitializeMdl(Mdl, NULL, PAGE_SIZE);
-   MmBuildMdlFromPages(Mdl, &Page);
-   Mdl->MdlFlags |= MDL_PAGES_LOCKED;
-
-   file_offset.QuadPart = offset * PAGE_SIZE;
-   file_offset = MmGetOffsetPageFile(PagingFileList[i]->RetrievalPointers, file_offset);
-
-   KeInitializeEvent(&Event, NotificationEvent, FALSE);
-   Status = IoSynchronousPageWrite(PagingFileList[i]->FileObject,
-                                   Mdl,
-                                   &file_offset,
-                                   &Event,
-                                   &Iosb);
-   if (Status == STATUS_PENDING)
-   {
-      KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
-      Status = Iosb.Status;
-   }
-
-   if (Mdl->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA)
-   {
-      MmUnmapLockedPages (Mdl->MappedSystemVa, Mdl);
-   }
-   return(Status);
+    ULONG i;
+    ULONG_PTR offset;
+    LARGE_INTEGER file_offset;
+    IO_STATUS_BLOCK Iosb;
+    NTSTATUS Status;
+    KEVENT Event;
+    UCHAR MdlBase[sizeof(MDL) + sizeof(ULONG)];
+    PMDL Mdl = (PMDL)MdlBase;
+
+    DPRINT("MmWriteToSwapPage\n");
+
+    if (SwapEntry == 0)
+    {
+        KeBugCheck(MEMORY_MANAGEMENT);
+        return(STATUS_UNSUCCESSFUL);
+    }
+
+    i = FILE_FROM_ENTRY(SwapEntry);
+    offset = OFFSET_FROM_ENTRY(SwapEntry);
+
+    if (PagingFileList[i]->FileObject == NULL ||
+            PagingFileList[i]->FileObject->DeviceObject == NULL)
+    {
+        DPRINT1("Bad paging file 0x%.8X\n", SwapEntry);
+        KeBugCheck(MEMORY_MANAGEMENT);
+    }
+
+    MmInitializeMdl(Mdl, NULL, PAGE_SIZE);
+    MmBuildMdlFromPages(Mdl, &Page);
+    Mdl->MdlFlags |= MDL_PAGES_LOCKED;
+
+    file_offset.QuadPart = offset * PAGE_SIZE;
+    file_offset = MmGetOffsetPageFile(PagingFileList[i]->RetrievalPointers, file_offset);
+
+    KeInitializeEvent(&Event, NotificationEvent, FALSE);
+    Status = IoSynchronousPageWrite(PagingFileList[i]->FileObject,
+                                    Mdl,
+                                    &file_offset,
+                                    &Event,
+                                    &Iosb);
+    if (Status == STATUS_PENDING)
+    {
+        KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
+        Status = Iosb.Status;
+    }
+
+    if (Mdl->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA)
+    {
+        MmUnmapLockedPages (Mdl->MappedSystemVa, Mdl);
+    }
+    return(Status);
 }
 
 
@@ -279,65 +279,65 @@ NTSTATUS
 NTAPI
 MmReadFromSwapPage(SWAPENTRY SwapEntry, PFN_NUMBER Page)
 {
-       return MiReadPageFile(Page, FILE_FROM_ENTRY(SwapEntry), OFFSET_FROM_ENTRY(SwapEntry));
+    return MiReadPageFile(Page, FILE_FROM_ENTRY(SwapEntry), OFFSET_FROM_ENTRY(SwapEntry));
 }
 
 NTSTATUS
 NTAPI
 MiReadPageFile(
-       _In_ PFN_NUMBER Page,
-       _In_ ULONG PageFileIndex,
-       _In_ ULONG_PTR PageFileOffset)
+    _In_ PFN_NUMBER Page,
+    _In_ ULONG PageFileIndex,
+    _In_ ULONG_PTR PageFileOffset)
 {
-   LARGE_INTEGER file_offset;
-   IO_STATUS_BLOCK Iosb;
-   NTSTATUS Status;
-   KEVENT Event;
-   UCHAR MdlBase[sizeof(MDL) + sizeof(ULONG)];
-   PMDL Mdl = (PMDL)MdlBase;
-   PPAGINGFILE PagingFile;
-
-   DPRINT("MiReadSwapFile\n");
-
-   if (PageFileOffset == 0)
-   {
-      KeBugCheck(MEMORY_MANAGEMENT);
-      return(STATUS_UNSUCCESSFUL);
-   }
-
-   ASSERT(PageFileIndex < MAX_PAGING_FILES);
-
-   PagingFile = PagingFileList[PageFileIndex];
-
-   if (PagingFile->FileObject == NULL || PagingFile->FileObject->DeviceObject == NULL)
-   {
-      DPRINT1("Bad paging file %u\n", PageFileIndex);
-      KeBugCheck(MEMORY_MANAGEMENT);
-   }
-
-   MmInitializeMdl(Mdl, NULL, PAGE_SIZE);
-   MmBuildMdlFromPages(Mdl, &Page);
-   Mdl->MdlFlags |= MDL_PAGES_LOCKED;
-
-   file_offset.QuadPart = PageFileOffset * PAGE_SIZE;
-   file_offset = MmGetOffsetPageFile(PagingFile->RetrievalPointers, file_offset);
-
-   KeInitializeEvent(&Event, NotificationEvent, FALSE);
-   Status = IoPageRead(PagingFile->FileObject,
-                       Mdl,
-                       &file_offset,
-                       &Event,
-                       &Iosb);
-   if (Status == STATUS_PENDING)
-   {
-      KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
-      Status = Iosb.Status;
-   }
-   if (Mdl->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA)
-   {
-      MmUnmapLockedPages (Mdl->MappedSystemVa, Mdl);
-   }
-   return(Status);
+    LARGE_INTEGER file_offset;
+    IO_STATUS_BLOCK Iosb;
+    NTSTATUS Status;
+    KEVENT Event;
+    UCHAR MdlBase[sizeof(MDL) + sizeof(ULONG)];
+    PMDL Mdl = (PMDL)MdlBase;
+    PPAGINGFILE PagingFile;
+
+    DPRINT("MiReadSwapFile\n");
+
+    if (PageFileOffset == 0)
+    {
+        KeBugCheck(MEMORY_MANAGEMENT);
+        return(STATUS_UNSUCCESSFUL);
+    }
+
+    ASSERT(PageFileIndex < MAX_PAGING_FILES);
+
+    PagingFile = PagingFileList[PageFileIndex];
+
+    if (PagingFile->FileObject == NULL || PagingFile->FileObject->DeviceObject == NULL)
+    {
+        DPRINT1("Bad paging file %u\n", PageFileIndex);
+        KeBugCheck(MEMORY_MANAGEMENT);
+    }
+
+    MmInitializeMdl(Mdl, NULL, PAGE_SIZE);
+    MmBuildMdlFromPages(Mdl, &Page);
+    Mdl->MdlFlags |= MDL_PAGES_LOCKED;
+
+    file_offset.QuadPart = PageFileOffset * PAGE_SIZE;
+    file_offset = MmGetOffsetPageFile(PagingFile->RetrievalPointers, file_offset);
+
+    KeInitializeEvent(&Event, NotificationEvent, FALSE);
+    Status = IoPageRead(PagingFile->FileObject,
+                        Mdl,
+                        &file_offset,
+                        &Event,
+                        &Iosb);
+    if (Status == STATUS_PENDING)
+    {
+        KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
+        Status = Iosb.Status;
+    }
+    if (Mdl->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA)
+    {
+        MmUnmapLockedPages (Mdl->MappedSystemVa, Mdl);
+    }
+    return(Status);
 }
 
 VOID
@@ -345,135 +345,135 @@ INIT_FUNCTION
 NTAPI
 MmInitPagingFile(VOID)
 {
-   ULONG i;
+    ULONG i;
 
-   KeInitializeSpinLock(&PagingFileListLock);
+    KeInitializeSpinLock(&PagingFileListLock);
 
-   MiFreeSwapPages = 0;
-   MiUsedSwapPages = 0;
-   MiReservedSwapPages = 0;
+    MiFreeSwapPages = 0;
+    MiUsedSwapPages = 0;
+    MiReservedSwapPages = 0;
 
-   for (i = 0; i < MAX_PAGING_FILES; i++)
-   {
-      PagingFileList[i] = NULL;
-   }
-   MmNumberOfPagingFiles = 0;
+    for (i = 0; i < MAX_PAGING_FILES; i++)
+    {
+        PagingFileList[i] = NULL;
+    }
+    MmNumberOfPagingFiles = 0;
 }
 
 static ULONG
 MiAllocPageFromPagingFile(PPAGINGFILE PagingFile)
 {
-   KIRQL oldIrql;
-   ULONG i, j;
-
-   KeAcquireSpinLock(&PagingFile->AllocMapLock, &oldIrql);
-
-   for (i = 0; i < PagingFile->AllocMapSize; i++)
-   {
-      for (j = 0; j < 32; j++)
-      {
-         if (!(PagingFile->AllocMap[i] & (1 << j)))
-         {
-            PagingFile->AllocMap[i] |= (1 << j);
-            PagingFile->UsedPages++;
-            PagingFile->FreePages--;
-            KeReleaseSpinLock(&PagingFile->AllocMapLock, oldIrql);
-            return((i * 32) + j);
-         }
-      }
-   }
-
-   KeReleaseSpinLock(&PagingFile->AllocMapLock, oldIrql);
-   return(0xFFFFFFFF);
+    KIRQL oldIrql;
+    ULONG i, j;
+
+    KeAcquireSpinLock(&PagingFile->AllocMapLock, &oldIrql);
+
+    for (i = 0; i < PagingFile->AllocMapSize; i++)
+    {
+        for (j = 0; j < 32; j++)
+        {
+            if (!(PagingFile->AllocMap[i] & (1 << j)))
+            {
+                PagingFile->AllocMap[i] |= (1 << j);
+                PagingFile->UsedPages++;
+                PagingFile->FreePages--;
+                KeReleaseSpinLock(&PagingFile->AllocMapLock, oldIrql);
+                return((i * 32) + j);
+            }
+        }
+    }
+
+    KeReleaseSpinLock(&PagingFile->AllocMapLock, oldIrql);
+    return(0xFFFFFFFF);
 }
 
 VOID
 NTAPI
 MmFreeSwapPage(SWAPENTRY Entry)
 {
-   ULONG i;
-   ULONG_PTR off;
-   KIRQL oldIrql;
+    ULONG i;
+    ULONG_PTR off;
+    KIRQL oldIrql;
 
-   i = FILE_FROM_ENTRY(Entry);
-   off = OFFSET_FROM_ENTRY(Entry);
+    i = FILE_FROM_ENTRY(Entry);
+    off = OFFSET_FROM_ENTRY(Entry);
 
-   KeAcquireSpinLock(&PagingFileListLock, &oldIrql);
-   if (PagingFileList[i] == NULL)
-   {
-      KeBugCheck(MEMORY_MANAGEMENT);
-   }
-   KeAcquireSpinLockAtDpcLevel(&PagingFileList[i]->AllocMapLock);
+    KeAcquireSpinLock(&PagingFileListLock, &oldIrql);
+    if (PagingFileList[i] == NULL)
+    {
+        KeBugCheck(MEMORY_MANAGEMENT);
+    }
+    KeAcquireSpinLockAtDpcLevel(&PagingFileList[i]->AllocMapLock);
 
-   PagingFileList[i]->AllocMap[off >> 5] &= (~(1 << (off % 32)));
+    PagingFileList[i]->AllocMap[off >> 5] &= (~(1 << (off % 32)));
 
-   PagingFileList[i]->FreePages++;
-   PagingFileList[i]->UsedPages--;
+    PagingFileList[i]->FreePages++;
+    PagingFileList[i]->UsedPages--;
 
-   MiFreeSwapPages++;
-   MiUsedSwapPages--;
+    MiFreeSwapPages++;
+    MiUsedSwapPages--;
 
-   KeReleaseSpinLockFromDpcLevel(&PagingFileList[i]->AllocMapLock);
-   KeReleaseSpinLock(&PagingFileListLock, oldIrql);
+    KeReleaseSpinLockFromDpcLevel(&PagingFileList[i]->AllocMapLock);
+    KeReleaseSpinLock(&PagingFileListLock, oldIrql);
 }
 
 SWAPENTRY
 NTAPI
 MmAllocSwapPage(VOID)
 {
-   KIRQL oldIrql;
-   ULONG i;
-   ULONG off;
-   SWAPENTRY entry;
-
-   KeAcquireSpinLock(&PagingFileListLock, &oldIrql);
-
-   if (MiFreeSwapPages == 0)
-   {
-      KeReleaseSpinLock(&PagingFileListLock, oldIrql);
-      return(0);
-   }
-
-   for (i = 0; i < MAX_PAGING_FILES; i++)
-   {
-      if (PagingFileList[i] != NULL &&
-            PagingFileList[i]->FreePages >= 1)
-      {
-         off = MiAllocPageFromPagingFile(PagingFileList[i]);
-         if (off == 0xFFFFFFFF)
-         {
-            KeBugCheck(MEMORY_MANAGEMENT);
+    KIRQL oldIrql;
+    ULONG i;
+    ULONG off;
+    SWAPENTRY entry;
+
+    KeAcquireSpinLock(&PagingFileListLock, &oldIrql);
+
+    if (MiFreeSwapPages == 0)
+    {
+        KeReleaseSpinLock(&PagingFileListLock, oldIrql);
+        return(0);
+    }
+
+    for (i = 0; i < MAX_PAGING_FILES; i++)
+    {
+        if (PagingFileList[i] != NULL &&
+                PagingFileList[i]->FreePages >= 1)
+        {
+            off = MiAllocPageFromPagingFile(PagingFileList[i]);
+            if (off == 0xFFFFFFFF)
+            {
+                KeBugCheck(MEMORY_MANAGEMENT);
+                KeReleaseSpinLock(&PagingFileListLock, oldIrql);
+                return(STATUS_UNSUCCESSFUL);
+            }
+            MiUsedSwapPages++;
+            MiFreeSwapPages--;
             KeReleaseSpinLock(&PagingFileListLock, oldIrql);
-            return(STATUS_UNSUCCESSFUL);
-         }
-         MiUsedSwapPages++;
-         MiFreeSwapPages--;
-         KeReleaseSpinLock(&PagingFileListLock, oldIrql);
-
-         entry = ENTRY_FROM_FILE_OFFSET(i, off);
-         return(entry);
-      }
-   }
-
-   KeReleaseSpinLock(&PagingFileListLock, oldIrql);
-   KeBugCheck(MEMORY_MANAGEMENT);
-   return(0);
+
+            entry = ENTRY_FROM_FILE_OFFSET(i, off);
+            return(entry);
+        }
+    }
+
+    KeReleaseSpinLock(&PagingFileListLock, oldIrql);
+    KeBugCheck(MEMORY_MANAGEMENT);
+    return(0);
 }
 
 static PRETRIEVEL_DESCRIPTOR_LIST FASTCALL
 MmAllocRetrievelDescriptorList(ULONG Pairs)
 {
-   ULONG Size;
-   PRETRIEVEL_DESCRIPTOR_LIST RetDescList;
+    ULONG Size;
+    PRETRIEVEL_DESCRIPTOR_LIST RetDescList;
 
-   Size = sizeof(RETRIEVEL_DESCRIPTOR_LIST) + Pairs * 2 * sizeof(LARGE_INTEGER);
-   RetDescList = ExAllocatePool(NonPagedPool, Size);
-   if (RetDescList)
-   {
-      RtlZeroMemory(RetDescList, Size);
-   }
+    Size = sizeof(RETRIEVEL_DESCRIPTOR_LIST) + Pairs * 2 * sizeof(LARGE_INTEGER);
+    RetDescList = ExAllocatePool(NonPagedPool, Size);
+    if (RetDescList)
+    {
+        RtlZeroMemory(RetDescList, Size);
+    }
 
-   return RetDescList;
+    return RetDescList;
 }
 
 NTSTATUS NTAPI
@@ -482,341 +482,341 @@ NtCreatePagingFile(IN PUNICODE_STRING FileName,
                    IN PLARGE_INTEGER MaximumSize,
                    IN ULONG Reserved)
 {
-   NTSTATUS Status;
-   OBJECT_ATTRIBUTES ObjectAttributes;
-   HANDLE FileHandle;
-   IO_STATUS_BLOCK IoStatus;
-   PFILE_OBJECT FileObject;
-   PPAGINGFILE PagingFile;
-   KIRQL oldIrql;
-   ULONG AllocMapSize;
-   FILE_FS_SIZE_INFORMATION FsSizeInformation;
-   PRETRIEVEL_DESCRIPTOR_LIST RetDescList;
-   PRETRIEVEL_DESCRIPTOR_LIST CurrentRetDescList;
-   ULONG i;
-   ULONG BytesPerAllocationUnit;
-   LARGE_INTEGER Vcn;
-   ULONG ExtentCount;
-   LARGE_INTEGER MaxVcn;
-   ULONG Count;
-   ULONG Size;
-   KPROCESSOR_MODE PreviousMode;
-   UNICODE_STRING CapturedFileName;
-   LARGE_INTEGER SafeInitialSize, SafeMaximumSize;
-
-   DPRINT("NtCreatePagingFile(FileName %wZ, InitialSize %I64d)\n",
-          FileName, InitialSize->QuadPart);
-
-   if (MmNumberOfPagingFiles >= MAX_PAGING_FILES)
-   {
-      return(STATUS_TOO_MANY_PAGING_FILES);
-   }
-
-   PreviousMode = ExGetPreviousMode();
-
-   if (PreviousMode != KernelMode)
-   {
-      _SEH2_TRY
-      {
-         SafeInitialSize = ProbeForReadLargeInteger(InitialSize);
-         SafeMaximumSize = ProbeForReadLargeInteger(MaximumSize);
-      }
-      _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
-      {
-          /* Return the exception code */
-          _SEH2_YIELD(return _SEH2_GetExceptionCode());
-      }
-      _SEH2_END;
-   }
-   else
-   {
-      SafeInitialSize = *InitialSize;
-      SafeMaximumSize = *MaximumSize;
-   }
-
-   /* Pagefiles can't be larger than 4GB and ofcourse the minimum should be
-      smaller than the maximum */
-   if (0 != SafeInitialSize.u.HighPart)
-   {
-      return STATUS_INVALID_PARAMETER_2;
-   }
-   if (0 != SafeMaximumSize.u.HighPart)
-   {
-      return STATUS_INVALID_PARAMETER_3;
-   }
-   if (SafeMaximumSize.u.LowPart < SafeInitialSize.u.LowPart)
-   {
-      return STATUS_INVALID_PARAMETER_MIX;
-   }
-
-   Status = ProbeAndCaptureUnicodeString(&CapturedFileName,
-                                         PreviousMode,
-                                         FileName);
-   if (!NT_SUCCESS(Status))
-   {
-      return(Status);
-   }
-
-   InitializeObjectAttributes(&ObjectAttributes,
-                              &CapturedFileName,
-                              0,
-                              NULL,
-                              NULL);
-
-   Status = IoCreateFile(&FileHandle,
-                         FILE_ALL_ACCESS,
-                         &ObjectAttributes,
-                         &IoStatus,
-                         NULL,
-                         0,
-                         0,
-                         FILE_OPEN_IF,
-                         FILE_SYNCHRONOUS_IO_NONALERT,
-                         NULL,
-                         0,
-                         CreateFileTypeNone,
-                         NULL,
-                         SL_OPEN_PAGING_FILE | IO_NO_PARAMETER_CHECKING);
-
-   ReleaseCapturedUnicodeString(&CapturedFileName,
-                                PreviousMode);
-   if (!NT_SUCCESS(Status))
-   {
-      return(Status);
-   }
-
-   Status = ZwQueryVolumeInformationFile(FileHandle,
-                                         &IoStatus,
-                                         &FsSizeInformation,
-                                         sizeof(FILE_FS_SIZE_INFORMATION),
-                                         FileFsSizeInformation);
-   if (!NT_SUCCESS(Status))
-   {
-      ZwClose(FileHandle);
-      return Status;
-   }
-
-   BytesPerAllocationUnit = FsSizeInformation.SectorsPerAllocationUnit *
-                            FsSizeInformation.BytesPerSector;
-   /* FIXME: If we have 2048 BytesPerAllocationUnit (FAT16 < 128MB) there is
-    * a problem if the paging file is fragmented. Suppose the first cluster
-    * of the paging file is cluster 3042 but cluster 3043 is NOT part of the
-    * paging file but of another file. We can't write a complete page (4096
-    * bytes) to the physical location of cluster 3042 then. */
-   if (BytesPerAllocationUnit % PAGE_SIZE)
-   {
-      DPRINT1("BytesPerAllocationUnit %lu is not a multiple of PAGE_SIZE %d\n",
-              BytesPerAllocationUnit, PAGE_SIZE);
-      ZwClose(FileHandle);
-      return STATUS_UNSUCCESSFUL;
-   }
-
-   Status = ZwSetInformationFile(FileHandle,
-                                 &IoStatus,
-                                 &SafeInitialSize,
-                                 sizeof(LARGE_INTEGER),
-                                 FileAllocationInformation);
-   if (!NT_SUCCESS(Status))
-   {
-      ZwClose(FileHandle);
-      return(Status);
-   }
-
-   Status = ObReferenceObjectByHandle(FileHandle,
-                                      FILE_ALL_ACCESS,
-                                      IoFileObjectType,
-                                      PreviousMode,
-                                      (PVOID*)&FileObject,
-                                      NULL);
-   if (!NT_SUCCESS(Status))
-   {
-      ZwClose(FileHandle);
-      return(Status);
-   }
-
-   CurrentRetDescList = RetDescList = MmAllocRetrievelDescriptorList(PAIRS_PER_RUN);
-
-   if (CurrentRetDescList == NULL)
-   {
-      ObDereferenceObject(FileObject);
-      ZwClose(FileHandle);
-      return(STATUS_NO_MEMORY);
-   }
+    NTSTATUS Status;
+    OBJECT_ATTRIBUTES ObjectAttributes;
+    HANDLE FileHandle;
+    IO_STATUS_BLOCK IoStatus;
+    PFILE_OBJECT FileObject;
+    PPAGINGFILE PagingFile;
+    KIRQL oldIrql;
+    ULONG AllocMapSize;
+    FILE_FS_SIZE_INFORMATION FsSizeInformation;
+    PRETRIEVEL_DESCRIPTOR_LIST RetDescList;
+    PRETRIEVEL_DESCRIPTOR_LIST CurrentRetDescList;
+    ULONG i;
+    ULONG BytesPerAllocationUnit;
+    LARGE_INTEGER Vcn;
+    ULONG ExtentCount;
+    LARGE_INTEGER MaxVcn;
+    ULONG Count;
+    ULONG Size;
+    KPROCESSOR_MODE PreviousMode;
+    UNICODE_STRING CapturedFileName;
+    LARGE_INTEGER SafeInitialSize, SafeMaximumSize;
+
+    DPRINT("NtCreatePagingFile(FileName %wZ, InitialSize %I64d)\n",
+           FileName, InitialSize->QuadPart);
+
+    if (MmNumberOfPagingFiles >= MAX_PAGING_FILES)
+    {
+        return(STATUS_TOO_MANY_PAGING_FILES);
+    }
+
+    PreviousMode = ExGetPreviousMode();
+
+    if (PreviousMode != KernelMode)
+    {
+        _SEH2_TRY
+        {
+            SafeInitialSize = ProbeForReadLargeInteger(InitialSize);
+            SafeMaximumSize = ProbeForReadLargeInteger(MaximumSize);
+        }
+        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+        {
+            /* Return the exception code */
+            _SEH2_YIELD(return _SEH2_GetExceptionCode());
+        }
+        _SEH2_END;
+    }
+    else
+    {
+        SafeInitialSize = *InitialSize;
+        SafeMaximumSize = *MaximumSize;
+    }
+
+    /* Pagefiles can't be larger than 4GB and ofcourse the minimum should be
+       smaller than the maximum */
+    if (0 != SafeInitialSize.u.HighPart)
+    {
+        return STATUS_INVALID_PARAMETER_2;
+    }
+    if (0 != SafeMaximumSize.u.HighPart)
+    {
+        return STATUS_INVALID_PARAMETER_3;
+    }
+    if (SafeMaximumSize.u.LowPart < SafeInitialSize.u.LowPart)
+    {
+        return STATUS_INVALID_PARAMETER_MIX;
+    }
+
+    Status = ProbeAndCaptureUnicodeString(&CapturedFileName,
+                                          PreviousMode,
+                                          FileName);
+    if (!NT_SUCCESS(Status))
+    {
+        return(Status);
+    }
+
+    InitializeObjectAttributes(&ObjectAttributes,
+                               &CapturedFileName,
+                               0,
+                               NULL,
+                               NULL);
+
+    Status = IoCreateFile(&FileHandle,
+                          FILE_ALL_ACCESS,
+                          &ObjectAttributes,
+                          &IoStatus,
+                          NULL,
+                          0,
+                          0,
+                          FILE_OPEN_IF,
+                          FILE_SYNCHRONOUS_IO_NONALERT,
+                          NULL,
+                          0,
+                          CreateFileTypeNone,
+                          NULL,
+                          SL_OPEN_PAGING_FILE | IO_NO_PARAMETER_CHECKING);
+
+    ReleaseCapturedUnicodeString(&CapturedFileName,
+                                 PreviousMode);
+    if (!NT_SUCCESS(Status))
+    {
+        return(Status);
+    }
+
+    Status = ZwQueryVolumeInformationFile(FileHandle,
+                                          &IoStatus,
+                                          &FsSizeInformation,
+                                          sizeof(FILE_FS_SIZE_INFORMATION),
+                                          FileFsSizeInformation);
+    if (!NT_SUCCESS(Status))
+    {
+        ZwClose(FileHandle);
+        return Status;
+    }
+
+    BytesPerAllocationUnit = FsSizeInformation.SectorsPerAllocationUnit *
+                             FsSizeInformation.BytesPerSector;
+    /* FIXME: If we have 2048 BytesPerAllocationUnit (FAT16 < 128MB) there is
+     * a problem if the paging file is fragmented. Suppose the first cluster
+     * of the paging file is cluster 3042 but cluster 3043 is NOT part of the
+     * paging file but of another file. We can't write a complete page (4096
+     * bytes) to the physical location of cluster 3042 then. */
+    if (BytesPerAllocationUnit % PAGE_SIZE)
+    {
+        DPRINT1("BytesPerAllocationUnit %lu is not a multiple of PAGE_SIZE %d\n",
+                BytesPerAllocationUnit, PAGE_SIZE);
+        ZwClose(FileHandle);
+        return STATUS_UNSUCCESSFUL;
+    }
+
+    Status = ZwSetInformationFile(FileHandle,
+                                  &IoStatus,
+                                  &SafeInitialSize,
+                                  sizeof(LARGE_INTEGER),
+                                  FileAllocationInformation);
+    if (!NT_SUCCESS(Status))
+    {
+        ZwClose(FileHandle);
+        return(Status);
+    }
+
+    Status = ObReferenceObjectByHandle(FileHandle,
+                                       FILE_ALL_ACCESS,
+                                       IoFileObjectType,
+                                       PreviousMode,
+                                       (PVOID*)&FileObject,
+                                       NULL);
+    if (!NT_SUCCESS(Status))
+    {
+        ZwClose(FileHandle);
+        return(Status);
+    }
+
+    CurrentRetDescList = RetDescList = MmAllocRetrievelDescriptorList(PAIRS_PER_RUN);
+
+    if (CurrentRetDescList == NULL)
+    {
+        ObDereferenceObject(FileObject);
+        ZwClose(FileHandle);
+        return(STATUS_NO_MEMORY);
+    }
 
 #if defined(__GNUC__)
-   Vcn.QuadPart = 0LL;
+    Vcn.QuadPart = 0LL;
 #else
 
-   Vcn.QuadPart = 0;
+    Vcn.QuadPart = 0;
 #endif
 
-   ExtentCount = 0;
-   MaxVcn.QuadPart = (SafeInitialSize.QuadPart + BytesPerAllocationUnit - 1) / BytesPerAllocationUnit;
-   while(1)
-   {
-      Status = ZwFsControlFile(FileHandle,
-                               0,
-                               NULL,
-                               NULL,
-                               &IoStatus,
-                               FSCTL_GET_RETRIEVAL_POINTERS,
-                               &Vcn,
-                               sizeof(LARGE_INTEGER),
-                               &CurrentRetDescList->RetrievalPointers,
-                               sizeof(RETRIEVAL_POINTERS_BUFFER) + PAIRS_PER_RUN * 2 * sizeof(LARGE_INTEGER));
-      if (!NT_SUCCESS(Status))
-      {
-         while (RetDescList)
-         {
-            CurrentRetDescList = RetDescList;
-            RetDescList = RetDescList->Next;
-            ExFreePool(CurrentRetDescList);
-         }
-         ObDereferenceObject(FileObject);
-         ZwClose(FileHandle);
-         return(Status);
-      }
-      ExtentCount += CurrentRetDescList->RetrievalPointers.ExtentCount;
-      if (CurrentRetDescList->RetrievalPointers.Extents[CurrentRetDescList->RetrievalPointers.ExtentCount-1].NextVcn.QuadPart < MaxVcn.QuadPart)
-      {
-         CurrentRetDescList->Next = MmAllocRetrievelDescriptorList(PAIRS_PER_RUN);
-         if (CurrentRetDescList->Next == NULL)
-         {
+    ExtentCount = 0;
+    MaxVcn.QuadPart = (SafeInitialSize.QuadPart + BytesPerAllocationUnit - 1) / BytesPerAllocationUnit;
+    while(1)
+    {
+        Status = ZwFsControlFile(FileHandle,
+                                 0,
+                                 NULL,
+                                 NULL,
+                                 &IoStatus,
+                                 FSCTL_GET_RETRIEVAL_POINTERS,
+                                 &Vcn,
+                                 sizeof(LARGE_INTEGER),
+                                 &CurrentRetDescList->RetrievalPointers,
+                                 sizeof(RETRIEVAL_POINTERS_BUFFER) + PAIRS_PER_RUN * 2 * sizeof(LARGE_INTEGER));
+        if (!NT_SUCCESS(Status))
+        {
             while (RetDescList)
             {
-               CurrentRetDescList = RetDescList;
-               RetDescList = RetDescList->Next;
-               ExFreePool(CurrentRetDescList);
+                CurrentRetDescList = RetDescList;
+                RetDescList = RetDescList->Next;
+                ExFreePool(CurrentRetDescList);
             }
             ObDereferenceObject(FileObject);
             ZwClose(FileHandle);
-            return(STATUS_NO_MEMORY);
-         }
-         Vcn = CurrentRetDescList->RetrievalPointers.Extents[CurrentRetDescList->RetrievalPointers.ExtentCount-1].NextVcn;
-         CurrentRetDescList = CurrentRetDescList->Next;
-      }
-      else
-      {
-         break;
-      }
-   }
-
-   PagingFile = ExAllocatePool(NonPagedPool, sizeof(*PagingFile));
-   if (PagingFile == NULL)
-   {
-      while (RetDescList)
-      {
-         CurrentRetDescList = RetDescList;
-         RetDescList = RetDescList->Next;
-         ExFreePool(CurrentRetDescList);
-      }
-      ObDereferenceObject(FileObject);
-      ZwClose(FileHandle);
-      return(STATUS_NO_MEMORY);
-   }
-
-   RtlZeroMemory(PagingFile, sizeof(*PagingFile));
-
-   PagingFile->FileObject = FileObject;
-   PagingFile->MaximumSize.QuadPart = SafeMaximumSize.QuadPart;
-   PagingFile->CurrentSize.QuadPart = SafeInitialSize.QuadPart;
-   PagingFile->FreePages = (ULONG)(SafeInitialSize.QuadPart / PAGE_SIZE);
-   PagingFile->UsedPages = 0;
-   KeInitializeSpinLock(&PagingFile->AllocMapLock);
-
-   AllocMapSize = (PagingFile->FreePages / 32) + 1;
-   PagingFile->AllocMap = ExAllocatePool(NonPagedPool,
-                                         AllocMapSize * sizeof(ULONG));
-   PagingFile->AllocMapSize = AllocMapSize;
-
-   if (PagingFile->AllocMap == NULL)
-   {
-      while (RetDescList)
-      {
-         CurrentRetDescList = RetDescList;
-         RetDescList = RetDescList->Next;
-         ExFreePool(CurrentRetDescList);
-      }
-      ExFreePool(PagingFile);
-      ObDereferenceObject(FileObject);
-      ZwClose(FileHandle);
-      return(STATUS_NO_MEMORY);
-   }
-   DPRINT("ExtentCount: %lu\n", ExtentCount);
-   Size = sizeof(RETRIEVAL_POINTERS_BUFFER) + ExtentCount * 2 * sizeof(LARGE_INTEGER);
-   PagingFile->RetrievalPointers = ExAllocatePool(NonPagedPool, Size);
-   if (PagingFile->RetrievalPointers == NULL)
-   {
-      while (RetDescList)
-      {
-         CurrentRetDescList = RetDescList;
-         RetDescList = RetDescList->Next;
-         ExFreePool(CurrentRetDescList);
-      }
-      ExFreePool(PagingFile->AllocMap);
-      ExFreePool(PagingFile);
-      ObDereferenceObject(FileObject);
-      ZwClose(FileHandle);
-      return(STATUS_NO_MEMORY);
-   }
-
-   RtlZeroMemory(PagingFile->AllocMap, AllocMapSize * sizeof(ULONG));
-   RtlZeroMemory(PagingFile->RetrievalPointers, Size);
-
-   Count = 0;
-   PagingFile->RetrievalPointers->ExtentCount = ExtentCount;
-   PagingFile->RetrievalPointers->StartingVcn = RetDescList->RetrievalPointers.StartingVcn;
-   CurrentRetDescList = RetDescList;
-   while (CurrentRetDescList)
-   {
-      memcpy(&PagingFile->RetrievalPointers->Extents[Count],
-             CurrentRetDescList->RetrievalPointers.Extents,
-             CurrentRetDescList->RetrievalPointers.ExtentCount * 2 * sizeof(LARGE_INTEGER));
-      Count += CurrentRetDescList->RetrievalPointers.ExtentCount;
-      RetDescList = CurrentRetDescList;
-      CurrentRetDescList = CurrentRetDescList->Next;
-      ExFreePool(RetDescList);
-   }
-
-   if (PagingFile->RetrievalPointers->ExtentCount != ExtentCount ||
-         PagingFile->RetrievalPointers->Extents[ExtentCount - 1].NextVcn.QuadPart != MaxVcn.QuadPart)
-   {
-      ExFreePool(PagingFile->RetrievalPointers);
-      ExFreePool(PagingFile->AllocMap);
-      ExFreePool(PagingFile);
-      ObDereferenceObject(FileObject);
-      ZwClose(FileHandle);
-      return(STATUS_UNSUCCESSFUL);
-   }
-
-   /*
-    * Change the entries from lcn's to volume offset's.
-    */
-   PagingFile->RetrievalPointers->StartingVcn.QuadPart *= BytesPerAllocationUnit;
-   for (i = 0; i < ExtentCount; i++)
-   {
-      PagingFile->RetrievalPointers->Extents[i].Lcn.QuadPart *= BytesPerAllocationUnit;
-      PagingFile->RetrievalPointers->Extents[i].NextVcn.QuadPart *= BytesPerAllocationUnit;
-   }
-
-   KeAcquireSpinLock(&PagingFileListLock, &oldIrql);
-   for (i = 0; i < MAX_PAGING_FILES; i++)
-   {
-      if (PagingFileList[i] == NULL)
-      {
-         PagingFileList[i] = PagingFile;
-         break;
-      }
-   }
-   MiFreeSwapPages = MiFreeSwapPages + PagingFile->FreePages;
-   MmNumberOfPagingFiles++;
-   KeReleaseSpinLock(&PagingFileListLock, oldIrql);
-
-   ZwClose(FileHandle);
-
-   MmSwapSpaceMessage = FALSE;
-
-   return(STATUS_SUCCESS);
+            return(Status);
+        }
+        ExtentCount += CurrentRetDescList->RetrievalPointers.ExtentCount;
+        if (CurrentRetDescList->RetrievalPointers.Extents[CurrentRetDescList->RetrievalPointers.ExtentCount-1].NextVcn.QuadPart < MaxVcn.QuadPart)
+        {
+            CurrentRetDescList->Next = MmAllocRetrievelDescriptorList(PAIRS_PER_RUN);
+            if (CurrentRetDescList->Next == NULL)
+            {
+                while (RetDescList)
+                {
+                    CurrentRetDescList = RetDescList;
+                    RetDescList = RetDescList->Next;
+                    ExFreePool(CurrentRetDescList);
+                }
+                ObDereferenceObject(FileObject);
+                ZwClose(FileHandle);
+                return(STATUS_NO_MEMORY);
+            }
+            Vcn = CurrentRetDescList->RetrievalPointers.Extents[CurrentRetDescList->RetrievalPointers.ExtentCount-1].NextVcn;
+            CurrentRetDescList = CurrentRetDescList->Next;
+        }
+        else
+        {
+            break;
+        }
+    }
+
+    PagingFile = ExAllocatePool(NonPagedPool, sizeof(*PagingFile));
+    if (PagingFile == NULL)
+    {
+        while (RetDescList)
+        {
+            CurrentRetDescList = RetDescList;
+            RetDescList = RetDescList->Next;
+            ExFreePool(CurrentRetDescList);
+        }
+        ObDereferenceObject(FileObject);
+        ZwClose(FileHandle);
+        return(STATUS_NO_MEMORY);
+    }
+
+    RtlZeroMemory(PagingFile, sizeof(*PagingFile));
+
+    PagingFile->FileObject = FileObject;
+    PagingFile->MaximumSize.QuadPart = SafeMaximumSize.QuadPart;
+    PagingFile->CurrentSize.QuadPart = SafeInitialSize.QuadPart;
+    PagingFile->FreePages = (ULONG)(SafeInitialSize.QuadPart / PAGE_SIZE);
+    PagingFile->UsedPages = 0;
+    KeInitializeSpinLock(&PagingFile->AllocMapLock);
+
+    AllocMapSize = (PagingFile->FreePages / 32) + 1;
+    PagingFile->AllocMap = ExAllocatePool(NonPagedPool,
+                                          AllocMapSize * sizeof(ULONG));
+    PagingFile->AllocMapSize = AllocMapSize;
+
+    if (PagingFile->AllocMap == NULL)
+    {
+        while (RetDescList)
+        {
+            CurrentRetDescList = RetDescList;
+            RetDescList = RetDescList->Next;
+            ExFreePool(CurrentRetDescList);
+        }
+        ExFreePool(PagingFile);
+        ObDereferenceObject(FileObject);
+        ZwClose(FileHandle);
+        return(STATUS_NO_MEMORY);
+    }
+    DPRINT("ExtentCount: %lu\n", ExtentCount);
+    Size = sizeof(RETRIEVAL_POINTERS_BUFFER) + ExtentCount * 2 * sizeof(LARGE_INTEGER);
+    PagingFile->RetrievalPointers = ExAllocatePool(NonPagedPool, Size);
+    if (PagingFile->RetrievalPointers == NULL)
+    {
+        while (RetDescList)
+        {
+            CurrentRetDescList = RetDescList;
+            RetDescList = RetDescList->Next;
+            ExFreePool(CurrentRetDescList);
+        }
+        ExFreePool(PagingFile->AllocMap);
+        ExFreePool(PagingFile);
+        ObDereferenceObject(FileObject);
+        ZwClose(FileHandle);
+        return(STATUS_NO_MEMORY);
+    }
+
+    RtlZeroMemory(PagingFile->AllocMap, AllocMapSize * sizeof(ULONG));
+    RtlZeroMemory(PagingFile->RetrievalPointers, Size);
+
+    Count = 0;
+    PagingFile->RetrievalPointers->ExtentCount = ExtentCount;
+    PagingFile->RetrievalPointers->StartingVcn = RetDescList->RetrievalPointers.StartingVcn;
+    CurrentRetDescList = RetDescList;
+    while (CurrentRetDescList)
+    {
+        memcpy(&PagingFile->RetrievalPointers->Extents[Count],
+               CurrentRetDescList->RetrievalPointers.Extents,
+               CurrentRetDescList->RetrievalPointers.ExtentCount * 2 * sizeof(LARGE_INTEGER));
+        Count += CurrentRetDescList->RetrievalPointers.ExtentCount;
+        RetDescList = CurrentRetDescList;
+        CurrentRetDescList = CurrentRetDescList->Next;
+        ExFreePool(RetDescList);
+    }
+
+    if (PagingFile->RetrievalPointers->ExtentCount != ExtentCount ||
+            PagingFile->RetrievalPointers->Extents[ExtentCount - 1].NextVcn.QuadPart != MaxVcn.QuadPart)
+    {
+        ExFreePool(PagingFile->RetrievalPointers);
+        ExFreePool(PagingFile->AllocMap);
+        ExFreePool(PagingFile);
+        ObDereferenceObject(FileObject);
+        ZwClose(FileHandle);
+        return(STATUS_UNSUCCESSFUL);
+    }
+
+    /*
+     * Change the entries from lcn's to volume offset's.
+     */
+    PagingFile->RetrievalPointers->StartingVcn.QuadPart *= BytesPerAllocationUnit;
+    for (i = 0; i < ExtentCount; i++)
+    {
+        PagingFile->RetrievalPointers->Extents[i].Lcn.QuadPart *= BytesPerAllocationUnit;
+        PagingFile->RetrievalPointers->Extents[i].NextVcn.QuadPart *= BytesPerAllocationUnit;
+    }
+
+    KeAcquireSpinLock(&PagingFileListLock, &oldIrql);
+    for (i = 0; i < MAX_PAGING_FILES; i++)
+    {
+        if (PagingFileList[i] == NULL)
+        {
+            PagingFileList[i] = PagingFile;
+            break;
+        }
+    }
+    MiFreeSwapPages = MiFreeSwapPages + PagingFile->FreePages;
+    MmNumberOfPagingFiles++;
+    KeReleaseSpinLock(&PagingFileListLock, oldIrql);
+
+    ZwClose(FileHandle);
+
+    MmSwapSpaceMessage = FALSE;
+
+    return(STATUS_SUCCESS);
 }
 
 /* EOF */