[CMAKE]
[reactos.git] / 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_NUMBER MiFreeSwapPages;
85
86 /* Number of pages that have been allocated for swapping */
87 PFN_NUMBER 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_NUMBER 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 static BOOLEAN MmSwapSpaceMessage = FALSE;
119
120 /* FUNCTIONS *****************************************************************/
121
122 VOID
123 NTAPI
124 MmBuildMdlFromPages(PMDL Mdl, PPFN_NUMBER Pages)
125 {
126 memcpy(Mdl + 1, Pages, sizeof(PFN_NUMBER) * (PAGE_ROUND_UP(Mdl->ByteOffset+Mdl->ByteCount)/PAGE_SIZE));
127
128 /* FIXME: this flag should be set by the caller perhaps? */
129 Mdl->MdlFlags |= MDL_IO_PAGE_READ;
130 }
131
132
133 BOOLEAN
134 NTAPI
135 MmIsFileAPagingFile(PFILE_OBJECT FileObject)
136 {
137 ULONG i;
138
139 /* Loop through all the paging files */
140 for (i = 0; i < MiPagingFileCount; i++)
141 {
142 /* Check if this is one of them */
143 if (PagingFileList[i]->FileObject == FileObject) return TRUE;
144 }
145
146 /* Nothing found */
147 return FALSE;
148 }
149
150 VOID
151 NTAPI
152 MmShowOutOfSpaceMessagePagingFile(VOID)
153 {
154 if (!MmSwapSpaceMessage)
155 {
156 DPRINT1("MM: Out of swap space.\n");
157 MmSwapSpaceMessage = TRUE;
158 }
159 }
160
161 static LARGE_INTEGER
162 MmGetOffsetPageFile(PRETRIEVAL_POINTERS_BUFFER RetrievalPointers, LARGE_INTEGER Offset)
163 {
164 /* Simple binary search */
165 ULONG first, last, mid;
166 first = 0;
167 last = RetrievalPointers->ExtentCount - 1;
168 while (first <= last)
169 {
170 mid = (last - first) / 2 + first;
171 if (Offset.QuadPart < RetrievalPointers->Extents[mid].NextVcn.QuadPart)
172 {
173 if (mid == 0)
174 {
175 Offset.QuadPart += RetrievalPointers->Extents[0].Lcn.QuadPart - RetrievalPointers->StartingVcn.QuadPart;
176 return Offset;
177 }
178 else
179 {
180 if (Offset.QuadPart >= RetrievalPointers->Extents[mid-1].NextVcn.QuadPart)
181 {
182 Offset.QuadPart += RetrievalPointers->Extents[mid].Lcn.QuadPart - RetrievalPointers->Extents[mid-1].NextVcn.QuadPart;
183 return Offset;
184 }
185 last = mid - 1;
186 }
187 }
188 else
189 {
190 if (mid == RetrievalPointers->ExtentCount - 1)
191 {
192 break;
193 }
194 if (Offset.QuadPart < RetrievalPointers->Extents[mid+1].NextVcn.QuadPart)
195 {
196 Offset.QuadPart += RetrievalPointers->Extents[mid+1].Lcn.QuadPart - RetrievalPointers->Extents[mid].NextVcn.QuadPart;
197 return Offset;
198 }
199 first = mid + 1;
200 }
201 }
202 KeBugCheck(MEMORY_MANAGEMENT);
203 #if defined(__GNUC__)
204
205 return (LARGE_INTEGER)0LL;
206 #else
207
208 {
209 const LARGE_INTEGER dummy =
210 {
211 0
212 };
213 return dummy;
214 }
215 #endif
216 }
217
218 NTSTATUS
219 NTAPI
220 MmWriteToSwapPage(SWAPENTRY SwapEntry, PFN_NUMBER Page)
221 {
222 ULONG i, offset;
223 LARGE_INTEGER file_offset;
224 IO_STATUS_BLOCK Iosb;
225 NTSTATUS Status;
226 KEVENT Event;
227 UCHAR MdlBase[sizeof(MDL) + sizeof(ULONG)];
228 PMDL Mdl = (PMDL)MdlBase;
229
230 DPRINT("MmWriteToSwapPage\n");
231
232 if (SwapEntry == 0)
233 {
234 KeBugCheck(MEMORY_MANAGEMENT);
235 return(STATUS_UNSUCCESSFUL);
236 }
237
238 i = FILE_FROM_ENTRY(SwapEntry);
239 offset = OFFSET_FROM_ENTRY(SwapEntry);
240
241 if (i >= MAX_PAGING_FILES)
242 {
243 DPRINT1("Bad swap entry 0x%.8X\n", SwapEntry);
244 KeBugCheck(MEMORY_MANAGEMENT);
245 }
246 if (PagingFileList[i]->FileObject == NULL ||
247 PagingFileList[i]->FileObject->DeviceObject == NULL)
248 {
249 DPRINT1("Bad paging file 0x%.8X\n", SwapEntry);
250 KeBugCheck(MEMORY_MANAGEMENT);
251 }
252
253 MmInitializeMdl(Mdl, NULL, PAGE_SIZE);
254 MmBuildMdlFromPages(Mdl, &Page);
255 MmReferencePage(Page);
256 Mdl->MdlFlags |= MDL_PAGES_LOCKED;
257
258 file_offset.QuadPart = offset * PAGE_SIZE;
259 file_offset = MmGetOffsetPageFile(PagingFileList[i]->RetrievalPointers, file_offset);
260
261 KeInitializeEvent(&Event, NotificationEvent, FALSE);
262 Status = IoSynchronousPageWrite(PagingFileList[i]->FileObject,
263 Mdl,
264 &file_offset,
265 &Event,
266 &Iosb);
267 if (Status == STATUS_PENDING)
268 {
269 KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
270 Status = Iosb.Status;
271 }
272
273 if (Mdl->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA)
274 {
275 MmUnmapLockedPages (Mdl->MappedSystemVa, Mdl);
276 }
277 return(Status);
278 }
279
280 NTSTATUS
281 NTAPI
282 MmReadFromSwapPage(SWAPENTRY SwapEntry, PFN_NUMBER Page)
283 {
284 ULONG i, offset;
285 LARGE_INTEGER file_offset;
286 IO_STATUS_BLOCK Iosb;
287 NTSTATUS Status;
288 KEVENT Event;
289 UCHAR MdlBase[sizeof(MDL) + sizeof(ULONG)];
290 PMDL Mdl = (PMDL)MdlBase;
291
292 DPRINT("MmReadFromSwapPage\n");
293
294 if (SwapEntry == 0)
295 {
296 KeBugCheck(MEMORY_MANAGEMENT);
297 return(STATUS_UNSUCCESSFUL);
298 }
299
300 i = FILE_FROM_ENTRY(SwapEntry);
301 offset = OFFSET_FROM_ENTRY(SwapEntry);
302
303 if (i >= MAX_PAGING_FILES)
304 {
305 DPRINT1("Bad swap entry 0x%.8X\n", SwapEntry);
306 KeBugCheck(MEMORY_MANAGEMENT);
307 }
308 if (PagingFileList[i]->FileObject == NULL ||
309 PagingFileList[i]->FileObject->DeviceObject == NULL)
310 {
311 DPRINT1("Bad paging file 0x%.8X\n", SwapEntry);
312 KeBugCheck(MEMORY_MANAGEMENT);
313 }
314
315 MmInitializeMdl(Mdl, NULL, PAGE_SIZE);
316 MmBuildMdlFromPages(Mdl, &Page);
317 MmReferencePage(Page);
318 Mdl->MdlFlags |= MDL_PAGES_LOCKED;
319
320 file_offset.QuadPart = offset * PAGE_SIZE;
321 file_offset = MmGetOffsetPageFile(PagingFileList[i]->RetrievalPointers, file_offset);
322
323 KeInitializeEvent(&Event, NotificationEvent, FALSE);
324 Status = IoPageRead(PagingFileList[i]->FileObject,
325 Mdl,
326 &file_offset,
327 &Event,
328 &Iosb);
329 if (Status == STATUS_PENDING)
330 {
331 KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
332 Status = Iosb.Status;
333 }
334 if (Mdl->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA)
335 {
336 MmUnmapLockedPages (Mdl->MappedSystemVa, Mdl);
337 }
338 return(Status);
339 }
340
341 VOID
342 INIT_FUNCTION
343 NTAPI
344 MmInitPagingFile(VOID)
345 {
346 ULONG i;
347
348 KeInitializeSpinLock(&PagingFileListLock);
349
350 MiFreeSwapPages = 0;
351 MiUsedSwapPages = 0;
352 MiReservedSwapPages = 0;
353
354 for (i = 0; i < MAX_PAGING_FILES; i++)
355 {
356 PagingFileList[i] = NULL;
357 }
358 MiPagingFileCount = 0;
359 }
360
361 BOOLEAN
362 NTAPI
363 MmReserveSwapPages(ULONG Nr)
364 {
365 KIRQL oldIrql;
366 ULONG MiAvailSwapPages;
367
368 KeAcquireSpinLock(&PagingFileListLock, &oldIrql);
369 MiAvailSwapPages =
370 (MiFreeSwapPages * MM_PAGEFILE_COMMIT_RATIO) + MM_PAGEFILE_COMMIT_GRACE;
371 MiReservedSwapPages = MiReservedSwapPages + Nr;
372 if ((MM_PAGEFILE_COMMIT_RATIO != 0) && (MiAvailSwapPages < MiReservedSwapPages))
373 {
374 KeReleaseSpinLock(&PagingFileListLock, oldIrql);
375 return(FALSE);
376 }
377 KeReleaseSpinLock(&PagingFileListLock, oldIrql);
378 return(TRUE);
379 }
380
381 VOID
382 NTAPI
383 MmDereserveSwapPages(ULONG Nr)
384 {
385 KIRQL oldIrql;
386
387 KeAcquireSpinLock(&PagingFileListLock, &oldIrql);
388 MiReservedSwapPages = MiReservedSwapPages - Nr;
389 KeReleaseSpinLock(&PagingFileListLock, oldIrql);
390 }
391
392 static ULONG
393 MiAllocPageFromPagingFile(PPAGINGFILE PagingFile)
394 {
395 KIRQL oldIrql;
396 ULONG i, j;
397
398 KeAcquireSpinLock(&PagingFile->AllocMapLock, &oldIrql);
399
400 for (i = 0; i < PagingFile->AllocMapSize; i++)
401 {
402 for (j = 0; j < 32; j++)
403 {
404 if (!(PagingFile->AllocMap[i] & (1 << j)))
405 {
406 PagingFile->AllocMap[i] |= (1 << j);
407 PagingFile->UsedPages++;
408 PagingFile->FreePages--;
409 KeReleaseSpinLock(&PagingFile->AllocMapLock, oldIrql);
410 return((i * 32) + j);
411 }
412 }
413 }
414
415 KeReleaseSpinLock(&PagingFile->AllocMapLock, oldIrql);
416 return(0xFFFFFFFF);
417 }
418
419 VOID
420 NTAPI
421 MmFreeSwapPage(SWAPENTRY Entry)
422 {
423 ULONG i;
424 ULONG off;
425 KIRQL oldIrql;
426
427 i = FILE_FROM_ENTRY(Entry);
428 off = OFFSET_FROM_ENTRY(Entry);
429
430 if (i >= MAX_PAGING_FILES)
431 {
432 DPRINT1("Bad swap entry 0x%.8X\n", Entry);
433 KeBugCheck(MEMORY_MANAGEMENT);
434 }
435
436 KeAcquireSpinLock(&PagingFileListLock, &oldIrql);
437 if (PagingFileList[i] == NULL)
438 {
439 KeBugCheck(MEMORY_MANAGEMENT);
440 }
441 KeAcquireSpinLockAtDpcLevel(&PagingFileList[i]->AllocMapLock);
442
443 PagingFileList[i]->AllocMap[off >> 5] &= (~(1 << (off % 32)));
444
445 PagingFileList[i]->FreePages++;
446 PagingFileList[i]->UsedPages--;
447
448 MiFreeSwapPages++;
449 MiUsedSwapPages--;
450
451 KeReleaseSpinLockFromDpcLevel(&PagingFileList[i]->AllocMapLock);
452 KeReleaseSpinLock(&PagingFileListLock, oldIrql);
453 }
454
455 BOOLEAN
456 NTAPI
457 MmIsAvailableSwapPage(VOID)
458 {
459 return(MiFreeSwapPages > 0);
460 }
461
462 SWAPENTRY
463 NTAPI
464 MmAllocSwapPage(VOID)
465 {
466 KIRQL oldIrql;
467 ULONG i;
468 ULONG off;
469 SWAPENTRY entry;
470
471 KeAcquireSpinLock(&PagingFileListLock, &oldIrql);
472
473 if (MiFreeSwapPages == 0)
474 {
475 KeReleaseSpinLock(&PagingFileListLock, oldIrql);
476 return(0);
477 }
478
479 for (i = 0; i < MAX_PAGING_FILES; i++)
480 {
481 if (PagingFileList[i] != NULL &&
482 PagingFileList[i]->FreePages >= 1)
483 {
484 off = MiAllocPageFromPagingFile(PagingFileList[i]);
485 if (off == 0xFFFFFFFF)
486 {
487 KeBugCheck(MEMORY_MANAGEMENT);
488 KeReleaseSpinLock(&PagingFileListLock, oldIrql);
489 return(STATUS_UNSUCCESSFUL);
490 }
491 MiUsedSwapPages++;
492 MiFreeSwapPages--;
493 KeReleaseSpinLock(&PagingFileListLock, oldIrql);
494
495 entry = ENTRY_FROM_FILE_OFFSET(i, off);
496 return(entry);
497 }
498 }
499
500 KeReleaseSpinLock(&PagingFileListLock, oldIrql);
501 KeBugCheck(MEMORY_MANAGEMENT);
502 return(0);
503 }
504
505 static PRETRIEVEL_DESCRIPTOR_LIST FASTCALL
506 MmAllocRetrievelDescriptorList(ULONG Pairs)
507 {
508 ULONG Size;
509 PRETRIEVEL_DESCRIPTOR_LIST RetDescList;
510
511 Size = sizeof(RETRIEVEL_DESCRIPTOR_LIST) + Pairs * 2 * sizeof(LARGE_INTEGER);
512 RetDescList = ExAllocatePool(NonPagedPool, Size);
513 if (RetDescList)
514 {
515 RtlZeroMemory(RetDescList, Size);
516 }
517
518 return RetDescList;
519 }
520
521 NTSTATUS NTAPI
522 NtCreatePagingFile(IN PUNICODE_STRING FileName,
523 IN PLARGE_INTEGER InitialSize,
524 IN PLARGE_INTEGER MaximumSize,
525 IN ULONG Reserved)
526 {
527 NTSTATUS Status;
528 OBJECT_ATTRIBUTES ObjectAttributes;
529 HANDLE FileHandle;
530 IO_STATUS_BLOCK IoStatus;
531 PFILE_OBJECT FileObject;
532 PPAGINGFILE PagingFile;
533 KIRQL oldIrql;
534 ULONG AllocMapSize;
535 FILE_FS_SIZE_INFORMATION FsSizeInformation;
536 PRETRIEVEL_DESCRIPTOR_LIST RetDescList;
537 PRETRIEVEL_DESCRIPTOR_LIST CurrentRetDescList;
538 ULONG i;
539 ULONG BytesPerAllocationUnit;
540 LARGE_INTEGER Vcn;
541 ULONG ExtentCount;
542 LARGE_INTEGER MaxVcn;
543 ULONG Count;
544 ULONG Size;
545 KPROCESSOR_MODE PreviousMode;
546 UNICODE_STRING CapturedFileName;
547 LARGE_INTEGER SafeInitialSize, SafeMaximumSize;
548
549 DPRINT("NtCreatePagingFile(FileName %wZ, InitialSize %I64d)\n",
550 FileName, InitialSize->QuadPart);
551
552 if (MiPagingFileCount >= MAX_PAGING_FILES)
553 {
554 return(STATUS_TOO_MANY_PAGING_FILES);
555 }
556
557 PreviousMode = ExGetPreviousMode();
558
559 if (PreviousMode != KernelMode)
560 {
561 _SEH2_TRY
562 {
563 SafeInitialSize = ProbeForReadLargeInteger(InitialSize);
564 SafeMaximumSize = ProbeForReadLargeInteger(MaximumSize);
565 }
566 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
567 {
568 /* Return the exception code */
569 _SEH2_YIELD(return _SEH2_GetExceptionCode());
570 }
571 _SEH2_END;
572 }
573 else
574 {
575 SafeInitialSize = *InitialSize;
576 SafeMaximumSize = *MaximumSize;
577 }
578
579 /* Pagefiles can't be larger than 4GB and ofcourse the minimum should be
580 smaller than the maximum */
581 if (0 != SafeInitialSize.u.HighPart)
582 {
583 return STATUS_INVALID_PARAMETER_2;
584 }
585 if (0 != SafeMaximumSize.u.HighPart)
586 {
587 return STATUS_INVALID_PARAMETER_3;
588 }
589 if (SafeMaximumSize.u.LowPart < SafeInitialSize.u.LowPart)
590 {
591 return STATUS_INVALID_PARAMETER_MIX;
592 }
593
594 Status = ProbeAndCaptureUnicodeString(&CapturedFileName,
595 PreviousMode,
596 FileName);
597 if (!NT_SUCCESS(Status))
598 {
599 return(Status);
600 }
601
602 InitializeObjectAttributes(&ObjectAttributes,
603 &CapturedFileName,
604 0,
605 NULL,
606 NULL);
607
608 Status = IoCreateFile(&FileHandle,
609 FILE_ALL_ACCESS,
610 &ObjectAttributes,
611 &IoStatus,
612 NULL,
613 0,
614 0,
615 FILE_OPEN_IF,
616 FILE_SYNCHRONOUS_IO_NONALERT,
617 NULL,
618 0,
619 CreateFileTypeNone,
620 NULL,
621 SL_OPEN_PAGING_FILE | IO_NO_PARAMETER_CHECKING);
622
623 ReleaseCapturedUnicodeString(&CapturedFileName,
624 PreviousMode);
625 if (!NT_SUCCESS(Status))
626 {
627 return(Status);
628 }
629
630 Status = ZwQueryVolumeInformationFile(FileHandle,
631 &IoStatus,
632 &FsSizeInformation,
633 sizeof(FILE_FS_SIZE_INFORMATION),
634 FileFsSizeInformation);
635 if (!NT_SUCCESS(Status))
636 {
637 ZwClose(FileHandle);
638 return Status;
639 }
640
641 BytesPerAllocationUnit = FsSizeInformation.SectorsPerAllocationUnit *
642 FsSizeInformation.BytesPerSector;
643 /* FIXME: If we have 2048 BytesPerAllocationUnit (FAT16 < 128MB) there is
644 * a problem if the paging file is fragmented. Suppose the first cluster
645 * of the paging file is cluster 3042 but cluster 3043 is NOT part of the
646 * paging file but of another file. We can't write a complete page (4096
647 * bytes) to the physical location of cluster 3042 then. */
648 if (BytesPerAllocationUnit % PAGE_SIZE)
649 {
650 DPRINT1("BytesPerAllocationUnit %d is not a multiple of PAGE_SIZE %d\n",
651 BytesPerAllocationUnit, PAGE_SIZE);
652 ZwClose(FileHandle);
653 return STATUS_UNSUCCESSFUL;
654 }
655
656 Status = ZwSetInformationFile(FileHandle,
657 &IoStatus,
658 &SafeInitialSize,
659 sizeof(LARGE_INTEGER),
660 FileAllocationInformation);
661 if (!NT_SUCCESS(Status))
662 {
663 ZwClose(FileHandle);
664 return(Status);
665 }
666
667 Status = ObReferenceObjectByHandle(FileHandle,
668 FILE_ALL_ACCESS,
669 IoFileObjectType,
670 PreviousMode,
671 (PVOID*)&FileObject,
672 NULL);
673 if (!NT_SUCCESS(Status))
674 {
675 ZwClose(FileHandle);
676 return(Status);
677 }
678
679 CurrentRetDescList = RetDescList = MmAllocRetrievelDescriptorList(PAIRS_PER_RUN);
680
681 if (CurrentRetDescList == NULL)
682 {
683 ObDereferenceObject(FileObject);
684 ZwClose(FileHandle);
685 return(STATUS_NO_MEMORY);
686 }
687
688 #if defined(__GNUC__)
689 Vcn.QuadPart = 0LL;
690 #else
691
692 Vcn.QuadPart = 0;
693 #endif
694
695 ExtentCount = 0;
696 MaxVcn.QuadPart = (SafeInitialSize.QuadPart + BytesPerAllocationUnit - 1) / BytesPerAllocationUnit;
697 while(1)
698 {
699 Status = ZwFsControlFile(FileHandle,
700 0,
701 NULL,
702 NULL,
703 &IoStatus,
704 FSCTL_GET_RETRIEVAL_POINTERS,
705 &Vcn,
706 sizeof(LARGE_INTEGER),
707 &CurrentRetDescList->RetrievalPointers,
708 sizeof(RETRIEVAL_POINTERS_BUFFER) + PAIRS_PER_RUN * 2 * sizeof(LARGE_INTEGER));
709 if (!NT_SUCCESS(Status))
710 {
711 while (RetDescList)
712 {
713 CurrentRetDescList = RetDescList;
714 RetDescList = RetDescList->Next;
715 ExFreePool(CurrentRetDescList);
716 }
717 ObDereferenceObject(FileObject);
718 ZwClose(FileHandle);
719 return(Status);
720 }
721 ExtentCount += CurrentRetDescList->RetrievalPointers.ExtentCount;
722 if (CurrentRetDescList->RetrievalPointers.Extents[CurrentRetDescList->RetrievalPointers.ExtentCount-1].NextVcn.QuadPart < MaxVcn.QuadPart)
723 {
724 CurrentRetDescList->Next = MmAllocRetrievelDescriptorList(PAIRS_PER_RUN);
725 if (CurrentRetDescList->Next == NULL)
726 {
727 while (RetDescList)
728 {
729 CurrentRetDescList = RetDescList;
730 RetDescList = RetDescList->Next;
731 ExFreePool(CurrentRetDescList);
732 }
733 ObDereferenceObject(FileObject);
734 ZwClose(FileHandle);
735 return(STATUS_NO_MEMORY);
736 }
737 Vcn = CurrentRetDescList->RetrievalPointers.Extents[CurrentRetDescList->RetrievalPointers.ExtentCount-1].NextVcn;
738 CurrentRetDescList = CurrentRetDescList->Next;
739 }
740 else
741 {
742 break;
743 }
744 }
745
746 PagingFile = ExAllocatePool(NonPagedPool, sizeof(*PagingFile));
747 if (PagingFile == NULL)
748 {
749 while (RetDescList)
750 {
751 CurrentRetDescList = RetDescList;
752 RetDescList = RetDescList->Next;
753 ExFreePool(CurrentRetDescList);
754 }
755 ObDereferenceObject(FileObject);
756 ZwClose(FileHandle);
757 return(STATUS_NO_MEMORY);
758 }
759
760 RtlZeroMemory(PagingFile, sizeof(*PagingFile));
761
762 PagingFile->FileObject = FileObject;
763 PagingFile->MaximumSize.QuadPart = SafeMaximumSize.QuadPart;
764 PagingFile->CurrentSize.QuadPart = SafeInitialSize.QuadPart;
765 PagingFile->FreePages = (ULONG)(SafeInitialSize.QuadPart / PAGE_SIZE);
766 PagingFile->UsedPages = 0;
767 KeInitializeSpinLock(&PagingFile->AllocMapLock);
768
769 AllocMapSize = (PagingFile->FreePages / 32) + 1;
770 PagingFile->AllocMap = ExAllocatePool(NonPagedPool,
771 AllocMapSize * sizeof(ULONG));
772 PagingFile->AllocMapSize = AllocMapSize;
773
774 if (PagingFile->AllocMap == NULL)
775 {
776 while (RetDescList)
777 {
778 CurrentRetDescList = RetDescList;
779 RetDescList = RetDescList->Next;
780 ExFreePool(CurrentRetDescList);
781 }
782 ExFreePool(PagingFile);
783 ObDereferenceObject(FileObject);
784 ZwClose(FileHandle);
785 return(STATUS_NO_MEMORY);
786 }
787 DPRINT("ExtentCount: %d\n", ExtentCount);
788 Size = sizeof(RETRIEVAL_POINTERS_BUFFER) + ExtentCount * 2 * sizeof(LARGE_INTEGER);
789 PagingFile->RetrievalPointers = ExAllocatePool(NonPagedPool, Size);
790 if (PagingFile->RetrievalPointers == NULL)
791 {
792 while (RetDescList)
793 {
794 CurrentRetDescList = RetDescList;
795 RetDescList = RetDescList->Next;
796 ExFreePool(CurrentRetDescList);
797 }
798 ExFreePool(PagingFile->AllocMap);
799 ExFreePool(PagingFile);
800 ObDereferenceObject(FileObject);
801 ZwClose(FileHandle);
802 return(STATUS_NO_MEMORY);
803 }
804
805 RtlZeroMemory(PagingFile->AllocMap, AllocMapSize * sizeof(ULONG));
806 RtlZeroMemory(PagingFile->RetrievalPointers, Size);
807
808 Count = 0;
809 PagingFile->RetrievalPointers->ExtentCount = ExtentCount;
810 PagingFile->RetrievalPointers->StartingVcn = RetDescList->RetrievalPointers.StartingVcn;
811 CurrentRetDescList = RetDescList;
812 while (CurrentRetDescList)
813 {
814 memcpy(&PagingFile->RetrievalPointers->Extents[Count],
815 CurrentRetDescList->RetrievalPointers.Extents,
816 CurrentRetDescList->RetrievalPointers.ExtentCount * 2 * sizeof(LARGE_INTEGER));
817 Count += CurrentRetDescList->RetrievalPointers.ExtentCount;
818 RetDescList = CurrentRetDescList;
819 CurrentRetDescList = CurrentRetDescList->Next;
820 ExFreePool(RetDescList);
821 }
822
823 if (PagingFile->RetrievalPointers->ExtentCount != ExtentCount ||
824 PagingFile->RetrievalPointers->Extents[ExtentCount - 1].NextVcn.QuadPart != MaxVcn.QuadPart)
825 {
826 ExFreePool(PagingFile->RetrievalPointers);
827 ExFreePool(PagingFile->AllocMap);
828 ExFreePool(PagingFile);
829 ObDereferenceObject(FileObject);
830 ZwClose(FileHandle);
831 return(STATUS_UNSUCCESSFUL);
832 }
833
834 /*
835 * Change the entries from lcn's to volume offset's.
836 */
837 PagingFile->RetrievalPointers->StartingVcn.QuadPart *= BytesPerAllocationUnit;
838 for (i = 0; i < ExtentCount; i++)
839 {
840 PagingFile->RetrievalPointers->Extents[i].Lcn.QuadPart *= BytesPerAllocationUnit;
841 PagingFile->RetrievalPointers->Extents[i].NextVcn.QuadPart *= BytesPerAllocationUnit;
842 }
843
844 KeAcquireSpinLock(&PagingFileListLock, &oldIrql);
845 for (i = 0; i < MAX_PAGING_FILES; i++)
846 {
847 if (PagingFileList[i] == NULL)
848 {
849 PagingFileList[i] = PagingFile;
850 break;
851 }
852 }
853 MiFreeSwapPages = MiFreeSwapPages + PagingFile->FreePages;
854 MiPagingFileCount++;
855 KeReleaseSpinLock(&PagingFileListLock, oldIrql);
856
857 ZwClose(FileHandle);
858
859 MmSwapSpaceMessage = FALSE;
860
861 return(STATUS_SUCCESS);
862 }
863
864 /* EOF */