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  *                  Pierre Schweitzer
  25  * UPDATE HISTORY:
  26  *                  Created 22/05/98
  27  */
  28
  29 /* INCLUDES *****************************************************************/
  30
  31 #include <ntoskrnl.h>
  32 #define NDEBUG
  33 #include <debug.h>
  34
  35 #if defined (ALLOC_PRAGMA)
  36 #pragma alloc_text(INIT, MmInitPagingFile)
  37 #endif
  38
  39 /* GLOBALS *******************************************************************/
  40
  41 #define PAIRS_PER_RUN (1024)
  42
  43 /* List of paging files, both used and free */
  44 PMMPAGING_FILE MmPagingFile[MAX_PAGING_FILES];
  45
  46 /* Lock for examining the list of paging files */
  47 static KSPIN_LOCK PagingFileListLock;
  48
  49 /* Number of paging files */
  50 ULONG MmNumberOfPagingFiles;
  51
  52 /* Number of pages that are available for swapping */
  53 PFN_COUNT MiFreeSwapPages;
  54
  55 /* Number of pages that have been allocated for swapping */
  56 PFN_COUNT MiUsedSwapPages;
  57
  58 BOOLEAN MmZeroPageFile;
  59
  60 /*
  61  * Number of pages that have been reserved for swapping but not yet allocated
  62  */
  63 static PFN_COUNT MiReservedSwapPages;
  64
  65 /*
  66  * Ratio between reserved and available swap pages, e.g. setting this to five
  67  * forces one swap page to be available for every five swap pages that are
  68  * reserved. Setting this to zero turns off commit checking altogether.
  69  */
  70 #define MM_PAGEFILE_COMMIT_RATIO      (1)
  71
  72 /*
  73  * Number of pages that can be used for potentially swapable memory without
  74  * pagefile space being reserved. The intention is that this allows smss
  75  * to start up and create page files while ordinarily having a commit
  76  * ratio of one.
  77  */
  78 #define MM_PAGEFILE_COMMIT_GRACE      (256)
  79
  80 /*
  81  * Translate between a swap entry and a file and offset pair.
  82  */
  83 #define FILE_FROM_ENTRY(i) ((i) & 0x0f)
  84 #define OFFSET_FROM_ENTRY(i) ((i) >> 11)
  85 #define ENTRY_FROM_FILE_OFFSET(i, j) ((i) | ((j) << 11) | 0x400)
  86
  87 /* Make sure there can be only 16 paging files */
  88 C_ASSERT(FILE_FROM_ENTRY(0xffffffff) < MAX_PAGING_FILES);
  89
  90 static BOOLEAN MmSwapSpaceMessage = FALSE;
  91
  92 /* FUNCTIONS *****************************************************************/
  93
  94 VOID
  95 NTAPI
  96 MmBuildMdlFromPages(PMDL Mdl, PPFN_NUMBER Pages)
  97 {
  98     memcpy(Mdl + 1, Pages, sizeof(PFN_NUMBER) * (PAGE_ROUND_UP(Mdl->ByteOffset+Mdl->ByteCount)/PAGE_SIZE));
  99
 100     /* FIXME: this flag should be set by the caller perhaps? */
 101     Mdl->MdlFlags |= MDL_IO_PAGE_READ;
 102 }
 103
 104
 105 BOOLEAN
 106 NTAPI
 107 MmIsFileObjectAPagingFile(PFILE_OBJECT FileObject)
 108 {
 109     ULONG i;
 110
 111     /* Loop through all the paging files */
 112     for (i = 0; i < MmNumberOfPagingFiles; i++)
 113     {
 114         /* Check if this is one of them */
 115         if (MmPagingFile[i]->FileObject == FileObject) return TRUE;
 116     }
 117
 118     /* Nothing found */
 119     return FALSE;
 120 }
 121
 122 VOID
 123 NTAPI
 124 MmShowOutOfSpaceMessagePagingFile(VOID)
 125 {
 126     if (!MmSwapSpaceMessage)
 127     {
 128         DPRINT1("MM: Out of swap space.\n");
 129         MmSwapSpaceMessage = TRUE;
 130     }
 131 }
 132
 133 NTSTATUS
 134 NTAPI
 135 MmWriteToSwapPage(SWAPENTRY SwapEntry, PFN_NUMBER Page)
 136 {
 137     ULONG i;
 138     ULONG_PTR offset;
 139     LARGE_INTEGER file_offset;
 140     IO_STATUS_BLOCK Iosb;
 141     NTSTATUS Status;
 142     KEVENT Event;
 143     UCHAR MdlBase[sizeof(MDL) + sizeof(ULONG)];
 144     PMDL Mdl = (PMDL)MdlBase;
 145
 146     DPRINT("MmWriteToSwapPage\n");
 147
 148     if (SwapEntry == 0)
 149     {
 150         KeBugCheck(MEMORY_MANAGEMENT);
 151         return(STATUS_UNSUCCESSFUL);
 152     }
 153
 154     i = FILE_FROM_ENTRY(SwapEntry);
 155     offset = OFFSET_FROM_ENTRY(SwapEntry) - 1;
 156
 157     if (MmPagingFile[i]->FileObject == NULL ||
 158             MmPagingFile[i]->FileObject->DeviceObject == NULL)
 159     {
 160         DPRINT1("Bad paging file 0x%.8X\n", SwapEntry);
 161         KeBugCheck(MEMORY_MANAGEMENT);
 162     }
 163
 164     MmInitializeMdl(Mdl, NULL, PAGE_SIZE);
 165     MmBuildMdlFromPages(Mdl, &Page);
 166     Mdl->MdlFlags |= MDL_PAGES_LOCKED;
 167
 168     file_offset.QuadPart = offset * PAGE_SIZE;
 169
 170     KeInitializeEvent(&Event, NotificationEvent, FALSE);
 171     Status = IoSynchronousPageWrite(MmPagingFile[i]->FileObject,
 172                                     Mdl,
 173                                     &file_offset,
 174                                     &Event,
 175                                     &Iosb);
 176     if (Status == STATUS_PENDING)
 177     {
 178         KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
 179         Status = Iosb.Status;
 180     }
 181
 182     if (Mdl->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA)
 183     {
 184         MmUnmapLockedPages (Mdl->MappedSystemVa, Mdl);
 185     }
 186     return(Status);
 187 }
 188
 189
 190 NTSTATUS
 191 NTAPI
 192 MmReadFromSwapPage(SWAPENTRY SwapEntry, PFN_NUMBER Page)
 193 {
 194     return MiReadPageFile(Page, FILE_FROM_ENTRY(SwapEntry), OFFSET_FROM_ENTRY(SwapEntry) - 1);
 195 }
 196
 197 NTSTATUS
 198 NTAPI
 199 MiReadPageFile(
 200     _In_ PFN_NUMBER Page,
 201     _In_ ULONG PageFileIndex,
 202     _In_ ULONG_PTR PageFileOffset)
 203 {
 204     LARGE_INTEGER file_offset;
 205     IO_STATUS_BLOCK Iosb;
 206     NTSTATUS Status;
 207     KEVENT Event;
 208     UCHAR MdlBase[sizeof(MDL) + sizeof(ULONG)];
 209     PMDL Mdl = (PMDL)MdlBase;
 210     PMMPAGING_FILE PagingFile;
 211
 212     DPRINT("MiReadSwapFile\n");
 213
 214     if (PageFileOffset == 0)
 215     {
 216         KeBugCheck(MEMORY_MANAGEMENT);
 217         return(STATUS_UNSUCCESSFUL);
 218     }
 219
 220     ASSERT(PageFileIndex < MAX_PAGING_FILES);
 221
 222     PagingFile = MmPagingFile[PageFileIndex];
 223
 224     if (PagingFile->FileObject == NULL || PagingFile->FileObject->DeviceObject == NULL)
 225     {
 226         DPRINT1("Bad paging file %u\n", PageFileIndex);
 227         KeBugCheck(MEMORY_MANAGEMENT);
 228     }
 229
 230     MmInitializeMdl(Mdl, NULL, PAGE_SIZE);
 231     MmBuildMdlFromPages(Mdl, &Page);
 232     Mdl->MdlFlags |= MDL_PAGES_LOCKED;
 233
 234     file_offset.QuadPart = PageFileOffset * PAGE_SIZE;
 235
 236     KeInitializeEvent(&Event, NotificationEvent, FALSE);
 237     Status = IoPageRead(PagingFile->FileObject,
 238                         Mdl,
 239                         &file_offset,
 240                         &Event,
 241                         &Iosb);
 242     if (Status == STATUS_PENDING)
 243     {
 244         KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
 245         Status = Iosb.Status;
 246     }
 247     if (Mdl->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA)
 248     {
 249         MmUnmapLockedPages (Mdl->MappedSystemVa, Mdl);
 250     }
 251     return(Status);
 252 }
 253
 254 VOID
 255 INIT_FUNCTION
 256 NTAPI
 257 MmInitPagingFile(VOID)
 258 {
 259     ULONG i;
 260
 261     KeInitializeSpinLock(&PagingFileListLock);
 262
 263     MiFreeSwapPages = 0;
 264     MiUsedSwapPages = 0;
 265     MiReservedSwapPages = 0;
 266
 267     for (i = 0; i < MAX_PAGING_FILES; i++)
 268     {
 269         MmPagingFile[i] = NULL;
 270     }
 271     MmNumberOfPagingFiles = 0;
 272 }
 273
 274 VOID
 275 NTAPI
 276 MmFreeSwapPage(SWAPENTRY Entry)
 277 {
 278     ULONG i;
 279     ULONG_PTR off;
 280     KIRQL oldIrql;
 281     PMMPAGING_FILE PagingFile;
 282
 283     i = FILE_FROM_ENTRY(Entry);
 284     off = OFFSET_FROM_ENTRY(Entry) - 1;
 285
 286     KeAcquireSpinLock(&PagingFileListLock, &oldIrql);
 287
 288     PagingFile = MmPagingFile[i];
 289     if (PagingFile == NULL)
 290     {
 291         KeBugCheck(MEMORY_MANAGEMENT);
 292     }
 293
 294     RtlClearBit(PagingFile->AllocMap, off >> 5);
 295
 296     PagingFile->FreePages++;
 297     PagingFile->UsedPages--;
 298
 299     MiFreeSwapPages++;
 300     MiUsedSwapPages--;
 301
 302     KeReleaseSpinLock(&PagingFileListLock, oldIrql);
 303 }
 304
 305 SWAPENTRY
 306 NTAPI
 307 MmAllocSwapPage(VOID)
 308 {
 309     KIRQL oldIrql;
 310     ULONG i;
 311     ULONG off;
 312     SWAPENTRY entry;
 313
 314     KeAcquireSpinLock(&PagingFileListLock, &oldIrql);
 315
 316     if (MiFreeSwapPages == 0)
 317     {
 318         KeReleaseSpinLock(&PagingFileListLock, oldIrql);
 319         return(0);
 320     }
 321
 322     for (i = 0; i < MAX_PAGING_FILES; i++)
 323     {
 324         if (MmPagingFile[i] != NULL &&
 325                 MmPagingFile[i]->FreePages >= 1)
 326         {
 327             off = RtlFindClearBitsAndSet(MmPagingFile[i]->AllocMap, 1, 0);
 328             if (off == 0xFFFFFFFF)
 329             {
 330                 KeBugCheck(MEMORY_MANAGEMENT);
 331                 KeReleaseSpinLock(&PagingFileListLock, oldIrql);
 332                 return(STATUS_UNSUCCESSFUL);
 333             }
 334             MiUsedSwapPages++;
 335             MiFreeSwapPages--;
 336             KeReleaseSpinLock(&PagingFileListLock, oldIrql);
 337
 338             entry = ENTRY_FROM_FILE_OFFSET(i, off + 1);
 339             return(entry);
 340         }
 341     }
 342
 343     KeReleaseSpinLock(&PagingFileListLock, oldIrql);
 344     KeBugCheck(MEMORY_MANAGEMENT);
 345     return(0);
 346 }
 347
 348 NTSTATUS NTAPI
 349 NtCreatePagingFile(IN PUNICODE_STRING FileName,
 350                    IN PLARGE_INTEGER InitialSize,
 351                    IN PLARGE_INTEGER MaximumSize,
 352                    IN ULONG Reserved)
 353 {
 354     NTSTATUS Status;
 355     OBJECT_ATTRIBUTES ObjectAttributes;
 356     HANDLE FileHandle;
 357     IO_STATUS_BLOCK IoStatus;
 358     PFILE_OBJECT FileObject;
 359     PMMPAGING_FILE PagingFile;
 360     KIRQL oldIrql;
 361     ULONG AllocMapSize;
 362     ULONG Count;
 363     KPROCESSOR_MODE PreviousMode;
 364     UNICODE_STRING PageFileName;
 365     LARGE_INTEGER SafeInitialSize, SafeMaximumSize, AllocationSize;
 366     FILE_FS_DEVICE_INFORMATION FsDeviceInfo;
 367     SECURITY_DESCRIPTOR SecurityDescriptor;
 368     PACL Dacl;
 369     PWSTR Buffer;
 370
 371     DPRINT("NtCreatePagingFile(FileName %wZ, InitialSize %I64d)\n",
 372            FileName, InitialSize->QuadPart);
 373
 374     if (MmNumberOfPagingFiles >= MAX_PAGING_FILES)
 375     {
 376         return STATUS_TOO_MANY_PAGING_FILES;
 377     }
 378
 379     PreviousMode = ExGetPreviousMode();
 380
 381     if (PreviousMode != KernelMode)
 382     {
 383         if (SeSinglePrivilegeCheck(SeCreatePagefilePrivilege, PreviousMode) != TRUE)
 384         {
 385             return STATUS_PRIVILEGE_NOT_HELD;
 386         }
 387
 388         _SEH2_TRY
 389         {
 390             SafeInitialSize = ProbeForReadLargeInteger(InitialSize);
 391             SafeMaximumSize = ProbeForReadLargeInteger(MaximumSize);
 392
 393             PageFileName.Length = FileName->Length;
 394             PageFileName.MaximumLength = FileName->MaximumLength;
 395             PageFileName.Buffer = FileName->Buffer;
 396         }
 397         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 398         {
 399             /* Return the exception code */
 400             _SEH2_YIELD(return _SEH2_GetExceptionCode());
 401         }
 402         _SEH2_END;
 403     }
 404     else
 405     {
 406         SafeInitialSize = *InitialSize;
 407         SafeMaximumSize = *MaximumSize;
 408
 409         PageFileName.Length = FileName->Length;
 410         PageFileName.MaximumLength = FileName->MaximumLength;
 411         PageFileName.Buffer = FileName->Buffer;
 412     }
 413
 414     /* Pagefiles can't be larger than 4GB and ofcourse the minimum should be
 415        smaller than the maximum */
 416     if (0 != SafeInitialSize.u.HighPart)
 417     {
 418         return STATUS_INVALID_PARAMETER_2;
 419     }
 420     if (0 != SafeMaximumSize.u.HighPart)
 421     {
 422         return STATUS_INVALID_PARAMETER_3;
 423     }
 424     if (SafeMaximumSize.u.LowPart < SafeInitialSize.u.LowPart)
 425     {
 426         return STATUS_INVALID_PARAMETER_MIX;
 427     }
 428
 429     /* Validate name length */
 430     if (PageFileName.Length > 128 * sizeof(WCHAR))
 431     {
 432         return STATUS_OBJECT_NAME_INVALID;
 433     }
 434
 435     /* We won't care about any potential UNICODE_NULL */
 436     PageFileName.MaximumLength = PageFileName.Length;
 437     /* Allocate a buffer to keep name copy */
 438     Buffer = ExAllocatePoolWithTag(PagedPool, PageFileName.Length, TAG_MM);
 439     if (Buffer == NULL)
 440     {
 441         return STATUS_INSUFFICIENT_RESOURCES;
 442     }
 443
 444     /* Copy name */
 445     if (PreviousMode != KernelMode)
 446     {
 447         _SEH2_TRY
 448         {
 449             if (PageFileName.Length != 0)
 450             {
 451                 ProbeForRead(PageFileName.Buffer, PageFileName.Length, sizeof(WCHAR));
 452             }
 453
 454             RtlCopyMemory(Buffer, PageFileName.Buffer, PageFileName.Length);
 455         }
 456         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 457         {
 458             ExFreePoolWithTag(Buffer, TAG_MM);
 459
 460             /* Return the exception code */
 461             _SEH2_YIELD(return _SEH2_GetExceptionCode());
 462         }
 463         _SEH2_END;
 464     }
 465     else
 466     {
 467         RtlCopyMemory(Buffer, PageFileName.Buffer, PageFileName.Length);
 468     }
 469
 470     /* Erase caller's buffer with ours */
 471     PageFileName.Buffer = Buffer;
 472
 473     /* Create the security descriptor for the page file */
 474     Status = RtlCreateSecurityDescriptor(&SecurityDescriptor, SECURITY_DESCRIPTOR_REVISION);
 475     if (!NT_SUCCESS(Status))
 476     {
 477         ExFreePoolWithTag(Buffer, TAG_MM);
 478         return Status;
 479     }
 480
 481     /* Create the DACL: we will only allow two SIDs */
 482     Count = sizeof(ACL) + (sizeof(ACE) + RtlLengthSid(SeLocalSystemSid)) +
 483                           (sizeof(ACE) + RtlLengthSid(SeAliasAdminsSid));
 484     Dacl = ExAllocatePoolWithTag(PagedPool, Count, 'lcaD');
 485     if (Dacl == NULL)
 486     {
 487         ExFreePoolWithTag(Buffer, TAG_MM);
 488         return STATUS_INSUFFICIENT_RESOURCES;
 489     }
 490
 491     /* Initialize the DACL */
 492     Status = RtlCreateAcl(Dacl, Count, ACL_REVISION);
 493     if (!NT_SUCCESS(Status))
 494     {
 495         ExFreePoolWithTag(Dacl, 'lcaD');
 496         ExFreePoolWithTag(Buffer, TAG_MM);
 497         return Status;
 498     }
 499
 500     /* Grant full access to admins */
 501     Status = RtlAddAccessAllowedAce(Dacl, ACL_REVISION, FILE_ALL_ACCESS, SeAliasAdminsSid);
 502     if (!NT_SUCCESS(Status))
 503     {
 504         ExFreePoolWithTag(Dacl, 'lcaD');
 505         ExFreePoolWithTag(Buffer, TAG_MM);
 506         return Status;
 507     }
 508
 509     /* Grant full access to SYSTEM */
 510     Status = RtlAddAccessAllowedAce(Dacl, ACL_REVISION, FILE_ALL_ACCESS, SeLocalSystemSid);
 511     if (!NT_SUCCESS(Status))
 512     {
 513         ExFreePoolWithTag(Dacl, 'lcaD');
 514         ExFreePoolWithTag(Buffer, TAG_MM);
 515         return Status;
 516     }
 517
 518     /* Attach the DACL to the security descriptor */
 519     Status = RtlSetDaclSecurityDescriptor(&SecurityDescriptor, TRUE, Dacl, FALSE);
 520     if (!NT_SUCCESS(Status))
 521     {
 522         ExFreePoolWithTag(Dacl, 'lcaD');
 523         ExFreePoolWithTag(Buffer, TAG_MM);
 524         return Status;
 525     }
 526
 527     InitializeObjectAttributes(&ObjectAttributes,
 528                                &PageFileName,
 529                                OBJ_KERNEL_HANDLE,
 530                                NULL,
 531                                &SecurityDescriptor);
 532
 533     /* Make sure we can at least store a complete page:
 534      * If we have 2048 BytesPerAllocationUnit (FAT16 < 128MB) there is
 535      * a problem if the paging file is fragmented. Suppose the first cluster
 536      * of the paging file is cluster 3042 but cluster 3043 is NOT part of the
 537      * paging file but of another file. We can't write a complete page (4096
 538      * bytes) to the physical location of cluster 3042 then. */
 539     AllocationSize.QuadPart = SafeInitialSize.QuadPart + PAGE_SIZE;
 540
 541     /* First, attempt to replace the page file, if existing */
 542     Status = IoCreateFile(&FileHandle,
 543                           SYNCHRONIZE | WRITE_DAC | FILE_READ_DATA | FILE_WRITE_DATA,
 544                           &ObjectAttributes,
 545                           &IoStatus,
 546                           &AllocationSize,
 547                           FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN,
 548                           FILE_SHARE_WRITE,
 549                           FILE_SUPERSEDE,
 550                           FILE_DELETE_ON_CLOSE | FILE_NO_COMPRESSION | FILE_NO_INTERMEDIATE_BUFFERING,
 551                           NULL,
 552                           0,
 553                           CreateFileTypeNone,
 554                           NULL,
 555                           SL_OPEN_PAGING_FILE | IO_NO_PARAMETER_CHECKING);
 556     /* If we failed, relax a bit constraints, someone may be already holding the
 557      * the file, so share write, don't attempt to replace and don't delete on close
 558      * (basically, don't do anything conflicting)
 559      * This can happen if the caller attempts to extend a page file.
 560      */
 561     if (!NT_SUCCESS(Status))
 562     {
 563         ULONG i;
 564
 565         Status = IoCreateFile(&FileHandle,
 566                               SYNCHRONIZE | FILE_WRITE_DATA,
 567                               &ObjectAttributes,
 568                               &IoStatus,
 569                               &AllocationSize,
 570                               FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN,
 571                               FILE_SHARE_WRITE | FILE_SHARE_READ,
 572                               FILE_OPEN,
 573                               FILE_NO_COMPRESSION | FILE_NO_INTERMEDIATE_BUFFERING,
 574                               NULL,
 575                               0,
 576                               CreateFileTypeNone,
 577                               NULL,
 578                               SL_OPEN_PAGING_FILE | IO_NO_PARAMETER_CHECKING);
 579         if (!NT_SUCCESS(Status))
 580         {
 581             ExFreePoolWithTag(Dacl, 'lcaD');
 582             ExFreePoolWithTag(Buffer, TAG_MM);
 583             return Status;
 584         }
 585
 586         /* We opened it! Check we are that "someone" ;-)
 587          * First, get the opened file object.
 588          */
 589         Status = ObReferenceObjectByHandle(FileHandle,
 590                                            FILE_READ_DATA | FILE_WRITE_DATA,
 591                                            IoFileObjectType,
 592                                            KernelMode,
 593                                            (PVOID*)&FileObject,
 594                                            NULL);
 595         if (!NT_SUCCESS(Status))
 596         {
 597             ZwClose(FileHandle);
 598             ExFreePoolWithTag(Dacl, 'lcaD');
 599             ExFreePoolWithTag(Buffer, TAG_MM);
 600             return Status;
 601         }
 602
 603         /* Find if it matches a previous page file */
 604         PagingFile = NULL;
 605         if (MmNumberOfPagingFiles > 0)
 606         {
 607             i = 0;
 608
 609             while (MmPagingFile[i]->FileObject->SectionObjectPointer != FileObject->SectionObjectPointer)
 610             {
 611                 ++i;
 612                 if (i >= MmNumberOfPagingFiles)
 613                 {
 614                     break;
 615                 }
 616             }
 617
 618             /* This is the matching page file */
 619             PagingFile = MmPagingFile[i];
 620         }
 621
 622         /* If we didn't find the page file, fail */
 623         if (PagingFile == NULL)
 624         {
 625             ObDereferenceObject(FileObject);
 626             ZwClose(FileHandle);
 627             ExFreePoolWithTag(Dacl, 'lcaD');
 628             ExFreePoolWithTag(Buffer, TAG_MM);
 629             return STATUS_NOT_FOUND;
 630         }
 631
 632         /* FIXME: implement parameters checking and page file extension */
 633         UNIMPLEMENTED;
 634
 635         ObDereferenceObject(FileObject);
 636         ZwClose(FileHandle);
 637         ExFreePoolWithTag(Dacl, 'lcaD');
 638         ExFreePoolWithTag(Buffer, TAG_MM);
 639         return STATUS_NOT_IMPLEMENTED;
 640     }
 641
 642     if (!NT_SUCCESS(Status))
 643     {
 644         DPRINT1("Failed creating page file: %lx\n", Status);
 645         ExFreePoolWithTag(Dacl, 'lcaD');
 646         ExFreePoolWithTag(Buffer, TAG_MM);
 647         return Status;
 648     }
 649
 650     /* Set the security descriptor */
 651     if (NT_SUCCESS(IoStatus.Status))
 652     {
 653         Status = ZwSetSecurityObject(FileHandle, DACL_SECURITY_INFORMATION, &SecurityDescriptor);
 654         if (!NT_SUCCESS(Status))
 655         {
 656             ExFreePoolWithTag(Dacl, 'lcaD');
 657             ZwClose(FileHandle);
 658             ExFreePoolWithTag(Buffer, TAG_MM);
 659             return Status;
 660         }
 661     }
 662
 663     /* DACL is no longer needed, free it */
 664     ExFreePoolWithTag(Dacl, 'lcaD');
 665
 666     /* Set its end of file to initial size */
 667     Status = ZwSetInformationFile(FileHandle,
 668                                   &IoStatus,
 669                                   &SafeInitialSize,
 670                                   sizeof(LARGE_INTEGER),
 671                                   FileEndOfFileInformation);
 672     if (!NT_SUCCESS(Status) || !NT_SUCCESS(IoStatus.Status))
 673     {
 674         ZwClose(FileHandle);
 675         ExFreePoolWithTag(Buffer, TAG_MM);
 676         return Status;
 677     }
 678
 679     Status = ObReferenceObjectByHandle(FileHandle,
 680                                        FILE_ALL_ACCESS,
 681                                        IoFileObjectType,
 682                                        KernelMode,
 683                                        (PVOID*)&FileObject,
 684                                        NULL);
 685     if (!NT_SUCCESS(Status))
 686     {
 687         ZwClose(FileHandle);
 688         ExFreePoolWithTag(Buffer, TAG_MM);
 689         return Status;
 690     }
 691
 692     /* Deny page file creation on a floppy disk */
 693     FsDeviceInfo.Characteristics = 0;
 694     IoQueryVolumeInformation(FileObject, FileFsDeviceInformation, sizeof(FsDeviceInfo), &FsDeviceInfo, &Count);
 695     if (BooleanFlagOn(FsDeviceInfo.Characteristics, FILE_FLOPPY_DISKETTE))
 696     {
 697         ObDereferenceObject(FileObject);
 698         ZwClose(FileHandle);
 699         ExFreePoolWithTag(Buffer, TAG_MM);
 700         return STATUS_FLOPPY_VOLUME;
 701     }
 702
 703     PagingFile = ExAllocatePoolWithTag(NonPagedPool, sizeof(*PagingFile), TAG_MM);
 704     if (PagingFile == NULL)
 705     {
 706         ObDereferenceObject(FileObject);
 707         ZwClose(FileHandle);
 708         ExFreePoolWithTag(Buffer, TAG_MM);
 709         return STATUS_INSUFFICIENT_RESOURCES;
 710     }
 711
 712     RtlZeroMemory(PagingFile, sizeof(*PagingFile));
 713
 714     PagingFile->FileHandle = FileHandle;
 715     PagingFile->FileObject = FileObject;
 716     PagingFile->MaximumSize.QuadPart = SafeMaximumSize.QuadPart;
 717     PagingFile->CurrentSize.QuadPart = SafeInitialSize.QuadPart;
 718     PagingFile->FreePages = (ULONG)(SafeInitialSize.QuadPart / PAGE_SIZE);
 719     PagingFile->UsedPages = 0;
 720     PagingFile->PageFileName = PageFileName;
 721
 722     AllocMapSize = sizeof(RTL_BITMAP) + (((PagingFile->FreePages + 31) / 32) * sizeof(ULONG));
 723     PagingFile->AllocMap = ExAllocatePoolWithTag(NonPagedPool,
 724                                                  AllocMapSize,
 725                                                  TAG_MM);
 726     if (PagingFile->AllocMap == NULL)
 727     {
 728         ExFreePoolWithTag(PagingFile, TAG_MM);
 729         ObDereferenceObject(FileObject);
 730         ZwClose(FileHandle);
 731         ExFreePoolWithTag(Buffer, TAG_MM);
 732         return STATUS_INSUFFICIENT_RESOURCES;
 733     }
 734
 735     RtlInitializeBitMap(PagingFile->AllocMap,
 736                         (PULONG)(PagingFile->AllocMap + 1),
 737                         (ULONG)(PagingFile->FreePages));
 738     RtlClearAllBits(PagingFile->AllocMap);
 739
 740     KeAcquireSpinLock(&PagingFileListLock, &oldIrql);
 741     ASSERT(MmPagingFile[MmNumberOfPagingFiles] == NULL);
 742     MmPagingFile[MmNumberOfPagingFiles] = PagingFile;
 743     MmNumberOfPagingFiles++;
 744     MiFreeSwapPages = MiFreeSwapPages + PagingFile->FreePages;
 745     KeReleaseSpinLock(&PagingFileListLock, oldIrql);
 746
 747     MmSwapSpaceMessage = FALSE;
 748
 749     return STATUS_SUCCESS;
 750 }
 751
 752 /* EOF */