ntoskrnl/mm/pagefile.c

   1 /*
   2  *  ReactOS kernel
   3  *  Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License along
  16  *  with this program; if not, write to the Free Software Foundation, Inc.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  */
  19 /*
  20  * PROJECT:         ReactOS kernel
  21  * FILE:            ntoskrnl/mm/pagefile.c
  22  * PURPOSE:         Paging file functions
  23  * PROGRAMMER:      David Welch (welch@mcmail.com)
  24  * UPDATE HISTORY:
  25  *                  Created 22/05/98
  26  */
  27
  28 /* INCLUDES *****************************************************************/
  29
  30 #include <ntoskrnl.h>
  31 #define NDEBUG
  32 #include <debug.h>
  33
  34 #if defined (ALLOC_PRAGMA)
  35 #pragma alloc_text(INIT, MmInitPagingFile)
  36 #endif
  37
  38 PVOID
  39 NTAPI
  40 MiFindExportedRoutineByName(IN PVOID DllBase,
  41                             IN PANSI_STRING ExportName);
  42
  43 /* TYPES *********************************************************************/
  44
  45 typedef struct _PAGINGFILE
  46 {
  47    LIST_ENTRY PagingFileListEntry;
  48    PFILE_OBJECT FileObject;
  49    LARGE_INTEGER MaximumSize;
  50    LARGE_INTEGER CurrentSize;
  51    ULONG FreePages;
  52    ULONG UsedPages;
  53    PULONG AllocMap;
  54    KSPIN_LOCK AllocMapLock;
  55    ULONG AllocMapSize;
  56    PRETRIEVAL_POINTERS_BUFFER RetrievalPointers;
  57 }
  58 PAGINGFILE, *PPAGINGFILE;
  59
  60 typedef struct _RETRIEVEL_DESCRIPTOR_LIST
  61 {
  62    struct _RETRIEVEL_DESCRIPTOR_LIST* Next;
  63    RETRIEVAL_POINTERS_BUFFER RetrievalPointers;
  64 }
  65 RETRIEVEL_DESCRIPTOR_LIST, *PRETRIEVEL_DESCRIPTOR_LIST;
  66
  67 /* GLOBALS *******************************************************************/
  68
  69 #define PAIRS_PER_RUN (1024)
  70
  71 #define MAX_PAGING_FILES  (32)
  72
  73 /* List of paging files, both used and free */
  74 static PPAGINGFILE PagingFileList[MAX_PAGING_FILES];
  75
  76 /* Lock for examining the list of paging files */
  77 static KSPIN_LOCK PagingFileListLock;
  78
  79 /* Number of paging files */
  80 static ULONG MiPagingFileCount;
  81 ULONG MmNumberOfPagingFiles;
  82
  83 /* Number of pages that are available for swapping */
  84 PFN_COUNT MiFreeSwapPages;
  85
  86 /* Number of pages that have been allocated for swapping */
  87 PFN_COUNT MiUsedSwapPages;
  88
  89 BOOLEAN MmZeroPageFile;
  90
  91 /*
  92  * Number of pages that have been reserved for swapping but not yet allocated
  93  */
  94 static PFN_COUNT MiReservedSwapPages;
  95
  96 /*
  97  * Ratio between reserved and available swap pages, e.g. setting this to five
  98  * forces one swap page to be available for every five swap pages that are
  99  * reserved. Setting this to zero turns off commit checking altogether.
 100  */
 101 #define MM_PAGEFILE_COMMIT_RATIO      (1)
 102
 103 /*
 104  * Number of pages that can be used for potentially swapable memory without
 105  * pagefile space being reserved. The intention is that this allows smss
 106  * to start up and create page files while ordinarily having a commit
 107  * ratio of one.
 108  */
 109 #define MM_PAGEFILE_COMMIT_GRACE      (256)
 110
 111 /*
 112  * Translate between a swap entry and a file and offset pair.
 113  */
 114 #define FILE_FROM_ENTRY(i) ((i) & 0x0f)
 115 #define OFFSET_FROM_ENTRY(i) ((i) >> 11)
 116 #define ENTRY_FROM_FILE_OFFSET(i, j) ((i) | ((j) << 11) | 0x400)
 117
 118 /* Make sure there can be only 16 paging files */
 119 C_ASSERT(FILE_FROM_ENTRY(0xffffffff) < MAX_PAGING_FILES);
 120
 121 static BOOLEAN MmSwapSpaceMessage = FALSE;
 122
 123 /* FUNCTIONS *****************************************************************/
 124
 125 VOID
 126 NTAPI
 127 MmBuildMdlFromPages(PMDL Mdl, PPFN_NUMBER Pages)
 128 {
 129     memcpy(Mdl + 1, Pages, sizeof(PFN_NUMBER) * (PAGE_ROUND_UP(Mdl->ByteOffset+Mdl->ByteCount)/PAGE_SIZE));
 130
 131     /* FIXME: this flag should be set by the caller perhaps? */
 132     Mdl->MdlFlags |= MDL_IO_PAGE_READ;
 133 }
 134
 135
 136 BOOLEAN
 137 NTAPI
 138 MmIsFileObjectAPagingFile(PFILE_OBJECT FileObject)
 139 {
 140     ULONG i;
 141
 142     /* Loop through all the paging files */
 143     for (i = 0; i < MiPagingFileCount; i++)
 144     {
 145         /* Check if this is one of them */
 146         if (PagingFileList[i]->FileObject == FileObject) return TRUE;
 147     }
 148
 149     /* Nothing found */
 150     return FALSE;
 151 }
 152
 153 VOID
 154 NTAPI
 155 MmShowOutOfSpaceMessagePagingFile(VOID)
 156 {
 157    if (!MmSwapSpaceMessage)
 158    {
 159       DPRINT1("MM: Out of swap space.\n");
 160       MmSwapSpaceMessage = TRUE;
 161    }
 162 }
 163
 164 static LARGE_INTEGER
 165 MmGetOffsetPageFile(PRETRIEVAL_POINTERS_BUFFER RetrievalPointers, LARGE_INTEGER Offset)
 166 {
 167    /* Simple binary search */
 168    ULONG first, last, mid;
 169    first = 0;
 170    last = RetrievalPointers->ExtentCount - 1;
 171    while (first <= last)
 172    {
 173       mid = (last - first) / 2 + first;
 174       if (Offset.QuadPart < RetrievalPointers->Extents[mid].NextVcn.QuadPart)
 175       {
 176          if (mid == 0)
 177          {
 178             Offset.QuadPart += RetrievalPointers->Extents[0].Lcn.QuadPart - RetrievalPointers->StartingVcn.QuadPart;
 179             return Offset;
 180          }
 181          else
 182          {
 183             if (Offset.QuadPart >= RetrievalPointers->Extents[mid-1].NextVcn.QuadPart)
 184             {
 185                Offset.QuadPart += RetrievalPointers->Extents[mid].Lcn.QuadPart - RetrievalPointers->Extents[mid-1].NextVcn.QuadPart;
 186                return Offset;
 187             }
 188             last = mid - 1;
 189          }
 190       }
 191       else
 192       {
 193          if (mid == RetrievalPointers->ExtentCount - 1)
 194          {
 195             break;
 196          }
 197          if (Offset.QuadPart < RetrievalPointers->Extents[mid+1].NextVcn.QuadPart)
 198          {
 199             Offset.QuadPart += RetrievalPointers->Extents[mid+1].Lcn.QuadPart  - RetrievalPointers->Extents[mid].NextVcn.QuadPart;
 200             return Offset;
 201          }
 202          first = mid + 1;
 203       }
 204    }
 205    KeBugCheck(MEMORY_MANAGEMENT);
 206 #if defined(__GNUC__)
 207
 208    return (LARGE_INTEGER)0LL;
 209 #else
 210
 211    {
 212       const LARGE_INTEGER dummy =
 213          {
 214             0
 215          };
 216       return dummy;
 217    }
 218 #endif
 219 }
 220
 221 NTSTATUS
 222 NTAPI
 223 MmWriteToSwapPage(SWAPENTRY SwapEntry, PFN_NUMBER Page)
 224 {
 225    ULONG i;
 226    ULONG_PTR offset;
 227    LARGE_INTEGER file_offset;
 228    IO_STATUS_BLOCK Iosb;
 229    NTSTATUS Status;
 230    KEVENT Event;
 231    UCHAR MdlBase[sizeof(MDL) + sizeof(ULONG)];
 232    PMDL Mdl = (PMDL)MdlBase;
 233
 234    DPRINT("MmWriteToSwapPage\n");
 235
 236    if (SwapEntry == 0)
 237    {
 238       KeBugCheck(MEMORY_MANAGEMENT);
 239       return(STATUS_UNSUCCESSFUL);
 240    }
 241
 242    i = FILE_FROM_ENTRY(SwapEntry);
 243    offset = OFFSET_FROM_ENTRY(SwapEntry);
 244
 245    if (PagingFileList[i]->FileObject == NULL ||
 246          PagingFileList[i]->FileObject->DeviceObject == NULL)
 247    {
 248       DPRINT1("Bad paging file 0x%.8X\n", SwapEntry);
 249       KeBugCheck(MEMORY_MANAGEMENT);
 250    }
 251
 252    MmInitializeMdl(Mdl, NULL, PAGE_SIZE);
 253    MmBuildMdlFromPages(Mdl, &Page);
 254    Mdl->MdlFlags |= MDL_PAGES_LOCKED;
 255
 256    file_offset.QuadPart = offset * PAGE_SIZE;
 257    file_offset = MmGetOffsetPageFile(PagingFileList[i]->RetrievalPointers, file_offset);
 258
 259    KeInitializeEvent(&Event, NotificationEvent, FALSE);
 260    Status = IoSynchronousPageWrite(PagingFileList[i]->FileObject,
 261                                    Mdl,
 262                                    &file_offset,
 263                                    &Event,
 264                                    &Iosb);
 265    if (Status == STATUS_PENDING)
 266    {
 267       KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
 268       Status = Iosb.Status;
 269    }
 270
 271    if (Mdl->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA)
 272    {
 273       MmUnmapLockedPages (Mdl->MappedSystemVa, Mdl);
 274    }
 275    return(Status);
 276 }
 277
 278 NTSTATUS
 279 NTAPI
 280 MmReadFromSwapPage(SWAPENTRY SwapEntry, PFN_NUMBER Page)
 281 {
 282    ULONG i;
 283    ULONG_PTR offset;
 284    LARGE_INTEGER file_offset;
 285    IO_STATUS_BLOCK Iosb;
 286    NTSTATUS Status;
 287    KEVENT Event;
 288    UCHAR MdlBase[sizeof(MDL) + sizeof(ULONG)];
 289    PMDL Mdl = (PMDL)MdlBase;
 290
 291    DPRINT("MmReadFromSwapPage\n");
 292
 293    if (SwapEntry == 0)
 294    {
 295       KeBugCheck(MEMORY_MANAGEMENT);
 296       return(STATUS_UNSUCCESSFUL);
 297    }
 298
 299    i = FILE_FROM_ENTRY(SwapEntry);
 300    offset = OFFSET_FROM_ENTRY(SwapEntry);
 301
 302    if (PagingFileList[i]->FileObject == NULL ||
 303          PagingFileList[i]->FileObject->DeviceObject == NULL)
 304    {
 305       DPRINT1("Bad paging file 0x%.8X\n", SwapEntry);
 306       KeBugCheck(MEMORY_MANAGEMENT);
 307    }
 308
 309    MmInitializeMdl(Mdl, NULL, PAGE_SIZE);
 310    MmBuildMdlFromPages(Mdl, &Page);
 311    Mdl->MdlFlags |= MDL_PAGES_LOCKED;
 312
 313    file_offset.QuadPart = offset * PAGE_SIZE;
 314    file_offset = MmGetOffsetPageFile(PagingFileList[i]->RetrievalPointers, file_offset);
 315
 316    KeInitializeEvent(&Event, NotificationEvent, FALSE);
 317    Status = IoPageRead(PagingFileList[i]->FileObject,
 318                        Mdl,
 319                        &file_offset,
 320                        &Event,
 321                        &Iosb);
 322    if (Status == STATUS_PENDING)
 323    {
 324       KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
 325       Status = Iosb.Status;
 326    }
 327    if (Mdl->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA)
 328    {
 329       MmUnmapLockedPages (Mdl->MappedSystemVa, Mdl);
 330    }
 331    return(Status);
 332 }
 333
 334 VOID
 335 INIT_FUNCTION
 336 NTAPI
 337 MmInitPagingFile(VOID)
 338 {
 339    ULONG i;
 340
 341    KeInitializeSpinLock(&PagingFileListLock);
 342
 343    MiFreeSwapPages = 0;
 344    MiUsedSwapPages = 0;
 345    MiReservedSwapPages = 0;
 346
 347    for (i = 0; i < MAX_PAGING_FILES; i++)
 348    {
 349       PagingFileList[i] = NULL;
 350    }
 351    MiPagingFileCount = 0;
 352 }
 353
 354 BOOLEAN
 355 NTAPI
 356 MmReserveSwapPages(ULONG Nr)
 357 {
 358    KIRQL oldIrql;
 359    ULONG MiAvailSwapPages;
 360
 361    KeAcquireSpinLock(&PagingFileListLock, &oldIrql);
 362    MiAvailSwapPages =
 363       (MiFreeSwapPages * MM_PAGEFILE_COMMIT_RATIO) + MM_PAGEFILE_COMMIT_GRACE;
 364    MiReservedSwapPages = MiReservedSwapPages + Nr;
 365    if ((MM_PAGEFILE_COMMIT_RATIO != 0) && (MiAvailSwapPages < MiReservedSwapPages))
 366    {
 367       KeReleaseSpinLock(&PagingFileListLock, oldIrql);
 368       return(FALSE);
 369    }
 370    KeReleaseSpinLock(&PagingFileListLock, oldIrql);
 371    return(TRUE);
 372 }
 373
 374 VOID
 375 NTAPI
 376 MmDereserveSwapPages(ULONG Nr)
 377 {
 378    KIRQL oldIrql;
 379
 380    KeAcquireSpinLock(&PagingFileListLock, &oldIrql);
 381    MiReservedSwapPages = MiReservedSwapPages - Nr;
 382    KeReleaseSpinLock(&PagingFileListLock, oldIrql);
 383 }
 384
 385 static ULONG
 386 MiAllocPageFromPagingFile(PPAGINGFILE PagingFile)
 387 {
 388    KIRQL oldIrql;
 389    ULONG i, j;
 390
 391    KeAcquireSpinLock(&PagingFile->AllocMapLock, &oldIrql);
 392
 393    for (i = 0; i < PagingFile->AllocMapSize; i++)
 394    {
 395       for (j = 0; j < 32; j++)
 396       {
 397          if (!(PagingFile->AllocMap[i] & (1 << j)))
 398          {
 399             PagingFile->AllocMap[i] |= (1 << j);
 400             PagingFile->UsedPages++;
 401             PagingFile->FreePages--;
 402             KeReleaseSpinLock(&PagingFile->AllocMapLock, oldIrql);
 403             return((i * 32) + j);
 404          }
 405       }
 406    }
 407
 408    KeReleaseSpinLock(&PagingFile->AllocMapLock, oldIrql);
 409    return(0xFFFFFFFF);
 410 }
 411
 412 VOID
 413 NTAPI
 414 MmFreeSwapPage(SWAPENTRY Entry)
 415 {
 416    ULONG i;
 417    ULONG_PTR off;
 418    KIRQL oldIrql;
 419
 420    i = FILE_FROM_ENTRY(Entry);
 421    off = OFFSET_FROM_ENTRY(Entry);
 422
 423    KeAcquireSpinLock(&PagingFileListLock, &oldIrql);
 424    if (PagingFileList[i] == NULL)
 425    {
 426       KeBugCheck(MEMORY_MANAGEMENT);
 427    }
 428    KeAcquireSpinLockAtDpcLevel(&PagingFileList[i]->AllocMapLock);
 429
 430    PagingFileList[i]->AllocMap[off >> 5] &= (~(1 << (off % 32)));
 431
 432    PagingFileList[i]->FreePages++;
 433    PagingFileList[i]->UsedPages--;
 434
 435    MiFreeSwapPages++;
 436    MiUsedSwapPages--;
 437
 438    KeReleaseSpinLockFromDpcLevel(&PagingFileList[i]->AllocMapLock);
 439    KeReleaseSpinLock(&PagingFileListLock, oldIrql);
 440 }
 441
 442 BOOLEAN
 443 NTAPI
 444 MmIsAvailableSwapPage(VOID)
 445 {
 446    return(MiFreeSwapPages > 0);
 447 }
 448
 449 SWAPENTRY
 450 NTAPI
 451 MmAllocSwapPage(VOID)
 452 {
 453    KIRQL oldIrql;
 454    ULONG i;
 455    ULONG off;
 456    SWAPENTRY entry;
 457
 458    KeAcquireSpinLock(&PagingFileListLock, &oldIrql);
 459
 460    if (MiFreeSwapPages == 0)
 461    {
 462       KeReleaseSpinLock(&PagingFileListLock, oldIrql);
 463       return(0);
 464    }
 465
 466    for (i = 0; i < MAX_PAGING_FILES; i++)
 467    {
 468       if (PagingFileList[i] != NULL &&
 469             PagingFileList[i]->FreePages >= 1)
 470       {
 471          off = MiAllocPageFromPagingFile(PagingFileList[i]);
 472          if (off == 0xFFFFFFFF)
 473          {
 474             KeBugCheck(MEMORY_MANAGEMENT);
 475             KeReleaseSpinLock(&PagingFileListLock, oldIrql);
 476             return(STATUS_UNSUCCESSFUL);
 477          }
 478          MiUsedSwapPages++;
 479          MiFreeSwapPages--;
 480          KeReleaseSpinLock(&PagingFileListLock, oldIrql);
 481
 482          entry = ENTRY_FROM_FILE_OFFSET(i, off);
 483          return(entry);
 484       }
 485    }
 486
 487    KeReleaseSpinLock(&PagingFileListLock, oldIrql);
 488    KeBugCheck(MEMORY_MANAGEMENT);
 489    return(0);
 490 }
 491
 492 static PRETRIEVEL_DESCRIPTOR_LIST FASTCALL
 493 MmAllocRetrievelDescriptorList(ULONG Pairs)
 494 {
 495    ULONG Size;
 496    PRETRIEVEL_DESCRIPTOR_LIST RetDescList;
 497
 498    Size = sizeof(RETRIEVEL_DESCRIPTOR_LIST) + Pairs * 2 * sizeof(LARGE_INTEGER);
 499    RetDescList = ExAllocatePool(NonPagedPool, Size);
 500    if (RetDescList)
 501    {
 502       RtlZeroMemory(RetDescList, Size);
 503    }
 504
 505    return RetDescList;
 506 }
 507
 508 NTSTATUS NTAPI
 509 NtCreatePagingFile(IN PUNICODE_STRING FileName,
 510                    IN PLARGE_INTEGER InitialSize,
 511                    IN PLARGE_INTEGER MaximumSize,
 512                    IN ULONG Reserved)
 513 {
 514    NTSTATUS Status;
 515    OBJECT_ATTRIBUTES ObjectAttributes;
 516    HANDLE FileHandle;
 517    IO_STATUS_BLOCK IoStatus;
 518    PFILE_OBJECT FileObject;
 519    PPAGINGFILE PagingFile;
 520    KIRQL oldIrql;
 521    ULONG AllocMapSize;
 522    FILE_FS_SIZE_INFORMATION FsSizeInformation;
 523    PRETRIEVEL_DESCRIPTOR_LIST RetDescList;
 524    PRETRIEVEL_DESCRIPTOR_LIST CurrentRetDescList;
 525    ULONG i;
 526    ULONG BytesPerAllocationUnit;
 527    LARGE_INTEGER Vcn;
 528    ULONG ExtentCount;
 529    LARGE_INTEGER MaxVcn;
 530    ULONG Count;
 531    ULONG Size;
 532    KPROCESSOR_MODE PreviousMode;
 533    UNICODE_STRING CapturedFileName;
 534    LARGE_INTEGER SafeInitialSize, SafeMaximumSize;
 535
 536    DPRINT("NtCreatePagingFile(FileName %wZ, InitialSize %I64d)\n",
 537           FileName, InitialSize->QuadPart);
 538
 539    if (MiPagingFileCount >= MAX_PAGING_FILES)
 540    {
 541       return(STATUS_TOO_MANY_PAGING_FILES);
 542    }
 543
 544    PreviousMode = ExGetPreviousMode();
 545
 546    if (PreviousMode != KernelMode)
 547    {
 548       _SEH2_TRY
 549       {
 550          SafeInitialSize = ProbeForReadLargeInteger(InitialSize);
 551          SafeMaximumSize = ProbeForReadLargeInteger(MaximumSize);
 552       }
 553       _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 554       {
 555           /* Return the exception code */
 556           _SEH2_YIELD(return _SEH2_GetExceptionCode());
 557       }
 558       _SEH2_END;
 559    }
 560    else
 561    {
 562       SafeInitialSize = *InitialSize;
 563       SafeMaximumSize = *MaximumSize;
 564    }
 565
 566    /* Pagefiles can't be larger than 4GB and ofcourse the minimum should be
 567       smaller than the maximum */
 568    if (0 != SafeInitialSize.u.HighPart)
 569    {
 570       return STATUS_INVALID_PARAMETER_2;
 571    }
 572    if (0 != SafeMaximumSize.u.HighPart)
 573    {
 574       return STATUS_INVALID_PARAMETER_3;
 575    }
 576    if (SafeMaximumSize.u.LowPart < SafeInitialSize.u.LowPart)
 577    {
 578       return STATUS_INVALID_PARAMETER_MIX;
 579    }
 580
 581    Status = ProbeAndCaptureUnicodeString(&CapturedFileName,
 582                                          PreviousMode,
 583                                          FileName);
 584    if (!NT_SUCCESS(Status))
 585    {
 586       return(Status);
 587    }
 588
 589    InitializeObjectAttributes(&ObjectAttributes,
 590                               &CapturedFileName,
 591                               0,
 592                               NULL,
 593                               NULL);
 594
 595    Status = IoCreateFile(&FileHandle,
 596                          FILE_ALL_ACCESS,
 597                          &ObjectAttributes,
 598                          &IoStatus,
 599                          NULL,
 600                          0,
 601                          0,
 602                          FILE_OPEN_IF,
 603                          FILE_SYNCHRONOUS_IO_NONALERT,
 604                          NULL,
 605                          0,
 606                          CreateFileTypeNone,
 607                          NULL,
 608                          SL_OPEN_PAGING_FILE | IO_NO_PARAMETER_CHECKING);
 609
 610    ReleaseCapturedUnicodeString(&CapturedFileName,
 611                                 PreviousMode);
 612    if (!NT_SUCCESS(Status))
 613    {
 614       return(Status);
 615    }
 616
 617    Status = ZwQueryVolumeInformationFile(FileHandle,
 618                                          &IoStatus,
 619                                          &FsSizeInformation,
 620                                          sizeof(FILE_FS_SIZE_INFORMATION),
 621                                          FileFsSizeInformation);
 622    if (!NT_SUCCESS(Status))
 623    {
 624       ZwClose(FileHandle);
 625       return Status;
 626    }
 627
 628    BytesPerAllocationUnit = FsSizeInformation.SectorsPerAllocationUnit *
 629                             FsSizeInformation.BytesPerSector;
 630    /* FIXME: If we have 2048 BytesPerAllocationUnit (FAT16 < 128MB) there is
 631     * a problem if the paging file is fragmented. Suppose the first cluster
 632     * of the paging file is cluster 3042 but cluster 3043 is NOT part of the
 633     * paging file but of another file. We can't write a complete page (4096
 634     * bytes) to the physical location of cluster 3042 then. */
 635    if (BytesPerAllocationUnit % PAGE_SIZE)
 636    {
 637       DPRINT1("BytesPerAllocationUnit %lu is not a multiple of PAGE_SIZE %d\n",
 638               BytesPerAllocationUnit, PAGE_SIZE);
 639       ZwClose(FileHandle);
 640       return STATUS_UNSUCCESSFUL;
 641    }
 642
 643    Status = ZwSetInformationFile(FileHandle,
 644                                  &IoStatus,
 645                                  &SafeInitialSize,
 646                                  sizeof(LARGE_INTEGER),
 647                                  FileAllocationInformation);
 648    if (!NT_SUCCESS(Status))
 649    {
 650       ZwClose(FileHandle);
 651       return(Status);
 652    }
 653
 654    Status = ObReferenceObjectByHandle(FileHandle,
 655                                       FILE_ALL_ACCESS,
 656                                       IoFileObjectType,
 657                                       PreviousMode,
 658                                       (PVOID*)&FileObject,
 659                                       NULL);
 660    if (!NT_SUCCESS(Status))
 661    {
 662       ZwClose(FileHandle);
 663       return(Status);
 664    }
 665
 666    CurrentRetDescList = RetDescList = MmAllocRetrievelDescriptorList(PAIRS_PER_RUN);
 667
 668    if (CurrentRetDescList == NULL)
 669    {
 670       ObDereferenceObject(FileObject);
 671       ZwClose(FileHandle);
 672       return(STATUS_NO_MEMORY);
 673    }
 674
 675 #if defined(__GNUC__)
 676    Vcn.QuadPart = 0LL;
 677 #else
 678
 679    Vcn.QuadPart = 0;
 680 #endif
 681
 682    ExtentCount = 0;
 683    MaxVcn.QuadPart = (SafeInitialSize.QuadPart + BytesPerAllocationUnit - 1) / BytesPerAllocationUnit;
 684    while(1)
 685    {
 686       Status = ZwFsControlFile(FileHandle,
 687                                0,
 688                                NULL,
 689                                NULL,
 690                                &IoStatus,
 691                                FSCTL_GET_RETRIEVAL_POINTERS,
 692                                &Vcn,
 693                                sizeof(LARGE_INTEGER),
 694                                &CurrentRetDescList->RetrievalPointers,
 695                                sizeof(RETRIEVAL_POINTERS_BUFFER) + PAIRS_PER_RUN * 2 * sizeof(LARGE_INTEGER));
 696       if (!NT_SUCCESS(Status))
 697       {
 698          while (RetDescList)
 699          {
 700             CurrentRetDescList = RetDescList;
 701             RetDescList = RetDescList->Next;
 702             ExFreePool(CurrentRetDescList);
 703          }
 704          ObDereferenceObject(FileObject);
 705          ZwClose(FileHandle);
 706          return(Status);
 707       }
 708       ExtentCount += CurrentRetDescList->RetrievalPointers.ExtentCount;
 709       if (CurrentRetDescList->RetrievalPointers.Extents[CurrentRetDescList->RetrievalPointers.ExtentCount-1].NextVcn.QuadPart < MaxVcn.QuadPart)
 710       {
 711          CurrentRetDescList->Next = MmAllocRetrievelDescriptorList(PAIRS_PER_RUN);
 712          if (CurrentRetDescList->Next == NULL)
 713          {
 714             while (RetDescList)
 715             {
 716                CurrentRetDescList = RetDescList;
 717                RetDescList = RetDescList->Next;
 718                ExFreePool(CurrentRetDescList);
 719             }
 720             ObDereferenceObject(FileObject);
 721             ZwClose(FileHandle);
 722             return(STATUS_NO_MEMORY);
 723          }
 724          Vcn = CurrentRetDescList->RetrievalPointers.Extents[CurrentRetDescList->RetrievalPointers.ExtentCount-1].NextVcn;
 725          CurrentRetDescList = CurrentRetDescList->Next;
 726       }
 727       else
 728       {
 729          break;
 730       }
 731    }
 732
 733    PagingFile = ExAllocatePool(NonPagedPool, sizeof(*PagingFile));
 734    if (PagingFile == NULL)
 735    {
 736       while (RetDescList)
 737       {
 738          CurrentRetDescList = RetDescList;
 739          RetDescList = RetDescList->Next;
 740          ExFreePool(CurrentRetDescList);
 741       }
 742       ObDereferenceObject(FileObject);
 743       ZwClose(FileHandle);
 744       return(STATUS_NO_MEMORY);
 745    }
 746
 747    RtlZeroMemory(PagingFile, sizeof(*PagingFile));
 748
 749    PagingFile->FileObject = FileObject;
 750    PagingFile->MaximumSize.QuadPart = SafeMaximumSize.QuadPart;
 751    PagingFile->CurrentSize.QuadPart = SafeInitialSize.QuadPart;
 752    PagingFile->FreePages = (ULONG)(SafeInitialSize.QuadPart / PAGE_SIZE);
 753    PagingFile->UsedPages = 0;
 754    KeInitializeSpinLock(&PagingFile->AllocMapLock);
 755
 756    AllocMapSize = (PagingFile->FreePages / 32) + 1;
 757    PagingFile->AllocMap = ExAllocatePool(NonPagedPool,
 758                                          AllocMapSize * sizeof(ULONG));
 759    PagingFile->AllocMapSize = AllocMapSize;
 760
 761    if (PagingFile->AllocMap == NULL)
 762    {
 763       while (RetDescList)
 764       {
 765          CurrentRetDescList = RetDescList;
 766          RetDescList = RetDescList->Next;
 767          ExFreePool(CurrentRetDescList);
 768       }
 769       ExFreePool(PagingFile);
 770       ObDereferenceObject(FileObject);
 771       ZwClose(FileHandle);
 772       return(STATUS_NO_MEMORY);
 773    }
 774    DPRINT("ExtentCount: %lu\n", ExtentCount);
 775    Size = sizeof(RETRIEVAL_POINTERS_BUFFER) + ExtentCount * 2 * sizeof(LARGE_INTEGER);
 776    PagingFile->RetrievalPointers = ExAllocatePool(NonPagedPool, Size);
 777    if (PagingFile->RetrievalPointers == NULL)
 778    {
 779       while (RetDescList)
 780       {
 781          CurrentRetDescList = RetDescList;
 782          RetDescList = RetDescList->Next;
 783          ExFreePool(CurrentRetDescList);
 784       }
 785       ExFreePool(PagingFile->AllocMap);
 786       ExFreePool(PagingFile);
 787       ObDereferenceObject(FileObject);
 788       ZwClose(FileHandle);
 789       return(STATUS_NO_MEMORY);
 790    }
 791
 792    RtlZeroMemory(PagingFile->AllocMap, AllocMapSize * sizeof(ULONG));
 793    RtlZeroMemory(PagingFile->RetrievalPointers, Size);
 794
 795    Count = 0;
 796    PagingFile->RetrievalPointers->ExtentCount = ExtentCount;
 797    PagingFile->RetrievalPointers->StartingVcn = RetDescList->RetrievalPointers.StartingVcn;
 798    CurrentRetDescList = RetDescList;
 799    while (CurrentRetDescList)
 800    {
 801       memcpy(&PagingFile->RetrievalPointers->Extents[Count],
 802              CurrentRetDescList->RetrievalPointers.Extents,
 803              CurrentRetDescList->RetrievalPointers.ExtentCount * 2 * sizeof(LARGE_INTEGER));
 804       Count += CurrentRetDescList->RetrievalPointers.ExtentCount;
 805       RetDescList = CurrentRetDescList;
 806       CurrentRetDescList = CurrentRetDescList->Next;
 807       ExFreePool(RetDescList);
 808    }
 809
 810    if (PagingFile->RetrievalPointers->ExtentCount != ExtentCount ||
 811          PagingFile->RetrievalPointers->Extents[ExtentCount - 1].NextVcn.QuadPart != MaxVcn.QuadPart)
 812    {
 813       ExFreePool(PagingFile->RetrievalPointers);
 814       ExFreePool(PagingFile->AllocMap);
 815       ExFreePool(PagingFile);
 816       ObDereferenceObject(FileObject);
 817       ZwClose(FileHandle);
 818       return(STATUS_UNSUCCESSFUL);
 819    }
 820
 821    /*
 822     * Change the entries from lcn's to volume offset's.
 823     */
 824    PagingFile->RetrievalPointers->StartingVcn.QuadPart *= BytesPerAllocationUnit;
 825    for (i = 0; i < ExtentCount; i++)
 826    {
 827       PagingFile->RetrievalPointers->Extents[i].Lcn.QuadPart *= BytesPerAllocationUnit;
 828       PagingFile->RetrievalPointers->Extents[i].NextVcn.QuadPart *= BytesPerAllocationUnit;
 829    }
 830
 831    KeAcquireSpinLock(&PagingFileListLock, &oldIrql);
 832    for (i = 0; i < MAX_PAGING_FILES; i++)
 833    {
 834       if (PagingFileList[i] == NULL)
 835       {
 836          PagingFileList[i] = PagingFile;
 837          break;
 838       }
 839    }
 840    MiFreeSwapPages = MiFreeSwapPages + PagingFile->FreePages;
 841    MiPagingFileCount++;
 842    KeReleaseSpinLock(&PagingFileListLock, oldIrql);
 843
 844    ZwClose(FileHandle);
 845
 846    MmSwapSpaceMessage = FALSE;
 847
 848    return(STATUS_SUCCESS);
 849 }
 850
 851 /* EOF */