[SMSS]
[reactos.git] / reactos / base / system / smss / initpage.c
1 /*
2 * PROJECT: ReactOS Session Manager
3 * LICENSE: GPL v2 or later - See COPYING in the top level directory
4 * FILE: base/system/smss/initpage.c
5 * PURPOSE: Paging file support.
6 * PROGRAMMERS: ReactOS Development Team
7 */
8
9 /* INCLUDES ******************************************************************/
10 #include "smss.h"
11
12 #define NDEBUG
13 #include <debug.h>
14
15 #define GIGABYTE (1024 * 1024 * 1024) /* One Gigabyte */
16
17 static NTSTATUS NTAPI
18 SmpPagingFilesQueryRoutine(PWSTR ValueName,
19 ULONG ValueType,
20 PVOID ValueData,
21 ULONG ValueLength,
22 PVOID Context,
23 PVOID EntryContext)
24 {
25 UNICODE_STRING FileName;
26 LARGE_INTEGER InitialSize = {{0, 0}};
27 LARGE_INTEGER MaximumSize = {{0, 0}};
28 NTSTATUS Status = STATUS_SUCCESS;
29 PWSTR p, ValueString = (PWSTR)ValueData;
30 WCHAR RootDriveLetter[5] = {0};
31
32 if (ValueLength > 3 * sizeof(WCHAR) &&
33 (ValueLength % sizeof(WCHAR) != 0 ||
34 ValueString[(ValueLength / sizeof(WCHAR)) - 1] != L'\0'))
35 {
36 return STATUS_INVALID_PARAMETER;
37 }
38
39 if (ValueType != REG_SZ)
40 {
41 return STATUS_INVALID_PARAMETER_2;
42 }
43
44 /*
45 * Format: "<path>[ <initial_size>[ <maximum_size>]]"
46 */
47 if ((p = wcschr(ValueString, L' ')) != NULL)
48 {
49 *p = L'\0';
50 InitialSize.QuadPart = wcstoul(p + 1, &p, 0) * 256 * 4096;
51 if (*p == ' ')
52 {
53 MaximumSize.QuadPart = wcstoul(p + 1, NULL, 0) * 256 * 4096;
54 }
55 else
56 {
57 MaximumSize = InitialSize;
58 }
59 }
60
61 if (!RtlDosPathNameToNtPathName_U (ValueString,
62 &FileName,
63 NULL,
64 NULL))
65 {
66 return STATUS_OBJECT_PATH_INVALID;
67 }
68
69 /* If there is only a file name or if initial and max are both 0
70 * the system will pick the sizes. Then it makes intial the size of phyical memory
71 * and makes max the size of 1.5 * initial. If there isnt enough free space then it will
72 * fall back to intial 20% of free space and max 25%. There is a max of 1 gig before
73 * it doesnt make it bigger. */
74 if ((InitialSize.QuadPart == 0 && MaximumSize.QuadPart == 0) || p == NULL)
75 {
76 FILE_FS_SIZE_INFORMATION FileFsSize;
77 IO_STATUS_BLOCK IoStatusBlock;
78 HANDLE hFile;
79 SYSTEM_BASIC_INFORMATION SysBasicInfo;
80 UNICODE_STRING NtPathU;
81 LARGE_INTEGER FreeBytes = {{0, 0}};
82 OBJECT_ATTRIBUTES ObjectAttributes;
83
84 DPRINT("System managed pagefile...\n");
85 /* Make sure the path that is given for the file actually has the drive in it.
86 At this point if there is not file name, no sizes will be set therefore no page
87 file will be created */
88 if (wcslen(ValueString) <= 3 ||
89 ValueString[1] != L':' ||
90 ValueString[2] != L'\\')
91 {
92 DPRINT1("Invalid path for pagefile.\n");
93 goto Cleanup;
94 }
95
96 Status = NtQuerySystemInformation(SystemBasicInformation,
97 &SysBasicInfo,
98 sizeof(SysBasicInfo),
99 NULL);
100 if (!NT_SUCCESS(Status))
101 {
102 DPRINT1("Could not query for physical memory size.\n");
103 goto Cleanup;
104 }
105 DPRINT("PageSize: %d, PhysicalPages: %d, TotalMem: %d\n", SysBasicInfo.PageSize, SysBasicInfo.NumberOfPhysicalPages, (SysBasicInfo.NumberOfPhysicalPages * SysBasicInfo.PageSize) / 1024);
106
107 InitialSize.QuadPart = SysBasicInfo.NumberOfPhysicalPages *
108 SysBasicInfo.PageSize;
109 MaximumSize.QuadPart = InitialSize.QuadPart * 2;
110
111 DPRINT("InitialSize: %I64d PhysicalPages: %lu PageSize: %lu\n",InitialSize.QuadPart,SysBasicInfo.NumberOfPhysicalPages,SysBasicInfo.PageSize);
112
113 /* copy the drive letter, the colon and the slash,
114 tack a null on the end */
115 RootDriveLetter[0] = ValueString[0];
116 RootDriveLetter[1] = L':';
117 RootDriveLetter[2] = L'\\';
118 RootDriveLetter[3] = L'\0';
119 DPRINT("Root drive X:\\...\"%S\"\n",RootDriveLetter);
120
121 if (!RtlDosPathNameToNtPathName_U(RootDriveLetter,
122 &NtPathU,
123 NULL,
124 NULL))
125 {
126 DPRINT1("Invalid path to root of drive\n");
127 Status = STATUS_OBJECT_PATH_INVALID;
128 goto Cleanup;
129 }
130
131 InitializeObjectAttributes(&ObjectAttributes,
132 &NtPathU,
133 OBJ_CASE_INSENSITIVE,
134 NULL,
135 NULL);
136
137 /* Get a handle to the root to find the free space on the drive */
138 Status = NtCreateFile(&hFile,
139 0,
140 &ObjectAttributes,
141 &IoStatusBlock,
142 NULL,
143 0,
144 FILE_SHARE_READ | FILE_SHARE_WRITE,
145 FILE_OPEN,
146 0,
147 NULL,
148 0);
149
150 RtlFreeHeap(RtlGetProcessHeap(),
151 0,
152 NtPathU.Buffer);
153
154 if (!NT_SUCCESS(Status))
155 {
156 DPRINT1("Could not open a handle to the volume.\n");
157 goto Cleanup;
158 }
159
160 Status = NtQueryVolumeInformationFile(hFile,
161 &IoStatusBlock,
162 &FileFsSize,
163 sizeof(FILE_FS_SIZE_INFORMATION),
164 FileFsSizeInformation);
165
166 NtClose(hFile);
167
168 if (!NT_SUCCESS(Status))
169 {
170 DPRINT1("Querying the volume free space failed!\n");
171 goto Cleanup;
172 }
173
174 FreeBytes.QuadPart = FileFsSize.BytesPerSector *
175 FileFsSize.SectorsPerAllocationUnit *
176 FileFsSize.AvailableAllocationUnits.QuadPart;
177
178 DPRINT("Free bytes: %I64d Inital Size based on memory: %I64d \n",FreeBytes.QuadPart,InitialSize.QuadPart);
179
180
181 if (InitialSize.QuadPart > (FreeBytes.QuadPart / 4) || InitialSize.QuadPart == 0)
182 {
183 DPRINT("Inital Size took more then 25%% of free space\n");
184 /* Set by percentage of free space
185 * intial is 20%, and max is 25% */
186 InitialSize.QuadPart = FreeBytes.QuadPart / 5;
187 MaximumSize.QuadPart = FreeBytes.QuadPart / 4;
188 /* The page file is more then a gig, size it down */
189 if (InitialSize.QuadPart > GIGABYTE)
190 {
191 InitialSize.QuadPart = GIGABYTE;
192 MaximumSize.QuadPart = GIGABYTE * 1.5;
193 }
194 }
195
196
197 }
198
199 /* Make sure that max is not smaller then initial */
200 if (InitialSize.QuadPart > MaximumSize.QuadPart)
201 {
202 DPRINT("Max page file size was bigger then inital.\n");
203 MaximumSize.QuadPart = InitialSize.QuadPart;
204 }
205
206 DPRINT("Creating paging file %wZ with size %I64d KB\n",
207 &FileName, InitialSize.QuadPart / 1024);
208
209 Status = NtCreatePagingFile(&FileName,
210 &InitialSize,
211 &MaximumSize,
212 0);
213 if (! NT_SUCCESS(Status))
214 {
215 PrintString("Creation of paging file %wZ with size %I64d KB failed (status 0x%x)\n",
216 &FileName, InitialSize.QuadPart / 1024, Status);
217 }
218
219 Cleanup:
220 RtlFreeHeap(RtlGetProcessHeap(),
221 0,
222 FileName.Buffer);
223
224 return STATUS_SUCCESS;
225 }
226
227
228 static NTSTATUS
229 SmpGetFreeDiskSpace(IN PWSTR PageFileName,
230 OUT PLARGE_INTEGER FreeDiskSpaceInMB)
231 {
232 FILE_FS_SIZE_INFORMATION FileFsSize;
233 IO_STATUS_BLOCK IoStatusBlock;
234 HANDLE hFile;
235 UNICODE_STRING NtPathU;
236 LARGE_INTEGER FreeBytes;
237 OBJECT_ATTRIBUTES ObjectAttributes;
238 WCHAR RootPath[5];
239 NTSTATUS Status;
240
241 /*
242 * copy the drive letter, the colon and the slash,
243 * tack a null on the end
244 */
245 RootPath[0] = PageFileName[0];
246 RootPath[1] = L':';
247 RootPath[2] = L'\\';
248 RootPath[3] = L'\0';
249
250 DPRINT("Root drive X:\\...\"%S\"\n",RootPath);
251
252 if (!RtlDosPathNameToNtPathName_U(RootPath,
253 &NtPathU,
254 NULL,
255 NULL))
256 {
257 DPRINT1("Invalid path to root of drive\n");
258 return STATUS_OBJECT_PATH_INVALID;
259 }
260
261 InitializeObjectAttributes(&ObjectAttributes,
262 &NtPathU,
263 OBJ_CASE_INSENSITIVE,
264 NULL,
265 NULL);
266
267 /* Get a handle to the root to find the free space on the drive */
268 Status = NtCreateFile(&hFile,
269 0,
270 &ObjectAttributes,
271 &IoStatusBlock,
272 NULL,
273 0,
274 FILE_SHARE_READ | FILE_SHARE_WRITE,
275 FILE_OPEN,
276 0,
277 NULL,
278 0);
279
280 RtlFreeHeap(RtlGetProcessHeap(),
281 0,
282 NtPathU.Buffer);
283
284 if (!NT_SUCCESS(Status))
285 {
286 DPRINT1("Could not open a handle to the volume.\n");
287 return Status;
288 }
289
290 Status = NtQueryVolumeInformationFile(hFile,
291 &IoStatusBlock,
292 &FileFsSize,
293 sizeof(FILE_FS_SIZE_INFORMATION),
294 FileFsSizeInformation);
295
296 NtClose(hFile);
297
298 if (!NT_SUCCESS(Status))
299 {
300 DPRINT1("Querying the volume free space failed!\n");
301 return Status;
302 }
303
304 FreeBytes.QuadPart = FileFsSize.BytesPerSector *
305 FileFsSize.SectorsPerAllocationUnit *
306 FileFsSize.AvailableAllocationUnits.QuadPart;
307
308 FreeDiskSpaceInMB->QuadPart = FreeBytes.QuadPart >> 20;
309
310 return STATUS_SUCCESS;
311 }
312
313
314 static NTSTATUS
315 SmpSetDefaultPageFileData(IN PWSTR PageFileName,
316 IN PLARGE_INTEGER InitialSizeInMB,
317 IN PLARGE_INTEGER MaximumSizeInMB)
318 {
319 WCHAR ValueString[MAX_PATH * 2];
320 ULONG ValueLength;
321
322 /* Format the value string */
323 swprintf(ValueString,
324 L"%s %I64u %I64u",
325 PageFileName,
326 InitialSizeInMB->QuadPart,
327 MaximumSizeInMB->QuadPart);
328
329 /*
330 * Append another zero character because it is a multi string value
331 * (REG_MULTI_SZ) and calculate the total string length.
332 */
333 ValueLength = wcslen(ValueString) + 1;
334 ValueString[ValueLength] = 0;
335 ValueLength++;
336
337 /* Write the page file data */
338 return RtlWriteRegistryValue(RTL_REGISTRY_CONTROL,
339 L"\\Session Manager\\Memory Management",
340 L"PagingFiles",
341 REG_MULTI_SZ,
342 ValueString,
343 ValueLength * sizeof(WCHAR));
344 }
345
346
347 static NTSTATUS
348 SmpCreatePageFile(IN PWSTR PageFileName,
349 IN PLARGE_INTEGER InitialSizeInMB,
350 IN PLARGE_INTEGER MaximumSizeInMB)
351 {
352 LARGE_INTEGER InitialSize;
353 LARGE_INTEGER MaximumSize;
354 UNICODE_STRING FileName;
355 NTSTATUS Status;
356
357 /* Get the NT path name of the page file */
358 if (!RtlDosPathNameToNtPathName_U(PageFileName,
359 &FileName,
360 NULL,
361 NULL))
362 {
363 return STATUS_OBJECT_PATH_INVALID;
364 }
365
366 /* Convert sizes in megabytes to sizes in bytes */
367 InitialSize.QuadPart = InitialSizeInMB->QuadPart << 20;
368 MaximumSize.QuadPart = MaximumSizeInMB->QuadPart << 20;
369
370 /* Create the pageing file */
371 Status = NtCreatePagingFile(&FileName,
372 &InitialSize,
373 &MaximumSize,
374 0);
375 if (! NT_SUCCESS(Status))
376 {
377 DPRINT("Creation of paging file %wZ with size %I64d MB failed (status 0x%x)\n",
378 &FileName, InitialSizeInMB->QuadPart, Status);
379 }
380
381 /* Release the file name */
382 RtlFreeHeap(RtlGetProcessHeap(),
383 0,
384 FileName.Buffer);
385
386 return Status;
387 }
388
389
390 static NTSTATUS
391 SmpCreateDefaultPagingFile(VOID)
392 {
393 SYSTEM_BASIC_INFORMATION SysBasicInfo;
394 LARGE_INTEGER MemorySizeInMB;
395 LARGE_INTEGER FreeDiskSpaceInMB;
396 LARGE_INTEGER InitialSizeInMB;
397 LARGE_INTEGER MaximumSizeInMB;
398 NTSTATUS Status = STATUS_SUCCESS;
399 WCHAR PageFileName[MAX_PATH];
400
401 DPRINT("Creating a default paging file\n");
402
403 Status = NtQuerySystemInformation(SystemBasicInformation,
404 &SysBasicInfo,
405 sizeof(SysBasicInfo),
406 NULL);
407 if (!NT_SUCCESS(Status))
408 {
409 DPRINT1("Could not query for physical memory size.\n");
410 return Status;
411 }
412
413 DPRINT("PageSize: %d, PhysicalPages: %d, TotalMem: %d\n",
414 SysBasicInfo.PageSize,
415 SysBasicInfo.NumberOfPhysicalPages,
416 (SysBasicInfo.NumberOfPhysicalPages * SysBasicInfo.PageSize) / 1024);
417
418 MemorySizeInMB.QuadPart = (SysBasicInfo.NumberOfPhysicalPages * SysBasicInfo.PageSize) >> 20;
419
420 DPRINT("MemorySize %I64u MB\n",
421 MemorySizeInMB.QuadPart);
422
423 /* Build the default page file name */
424 PageFileName[0] = SharedUserData->NtSystemRoot[0];
425 PageFileName[1] = 0;
426 wcscat(PageFileName, L":\\pagefile.sys");
427
428 Status = SmpGetFreeDiskSpace(PageFileName,
429 &FreeDiskSpaceInMB);
430 if (!NT_SUCCESS(Status))
431 {
432 return Status;
433 }
434
435 DPRINT("FreeDiskSpace %I64u MB\n",
436 FreeDiskSpaceInMB.QuadPart);
437
438 InitialSizeInMB.QuadPart = MemorySizeInMB.QuadPart + (MemorySizeInMB.QuadPart / 2);
439 MaximumSizeInMB.QuadPart = InitialSizeInMB.QuadPart * 2;
440
441 if (InitialSizeInMB.QuadPart > (FreeDiskSpaceInMB.QuadPart / 4))
442 {
443 DPRINT("Inital Size took more then 25%% of free disk space\n");
444
445 /*
446 * Set by percentage of free space
447 * intial is 20%, and max is 25%
448 */
449 InitialSizeInMB.QuadPart = FreeDiskSpaceInMB.QuadPart / 5;
450 MaximumSizeInMB.QuadPart = FreeDiskSpaceInMB.QuadPart / 4;
451
452 /* The page file is more then a gig, size it down */
453 if (InitialSizeInMB.QuadPart > 1024)
454 {
455 InitialSizeInMB.QuadPart = 1024; /* 1GB */
456 MaximumSizeInMB.QuadPart = 1536; /* 1.5GB */
457 }
458 }
459
460 DPRINT("InitialSize %I64u MB MaximumSize %I64u MB\n",
461 InitialSizeInMB.QuadPart,
462 MaximumSizeInMB.QuadPart);
463
464 Status = SmpSetDefaultPageFileData(PageFileName,
465 &InitialSizeInMB,
466 &MaximumSizeInMB);
467 if (!NT_SUCCESS(Status))
468 {
469 return Status;
470 }
471
472 return SmpCreatePageFile(PageFileName,
473 &InitialSizeInMB,
474 &MaximumSizeInMB);
475 }
476
477
478 NTSTATUS
479 SmCreatePagingFiles(VOID)
480 {
481 RTL_QUERY_REGISTRY_TABLE QueryTable[2];
482 NTSTATUS Status;
483
484 DPRINT("creating system paging files\n");
485
486 /* Disable paging file on MiniNT/Live CD. */
487 if (RtlCheckRegistryKey(RTL_REGISTRY_CONTROL, L"MiniNT") == STATUS_SUCCESS)
488 {
489 return STATUS_SUCCESS;
490 }
491
492 RtlZeroMemory(&QueryTable,
493 sizeof(QueryTable));
494
495 QueryTable[0].Name = L"PagingFiles";
496 QueryTable[0].QueryRoutine = SmpPagingFilesQueryRoutine;
497 QueryTable[0].Flags = RTL_QUERY_REGISTRY_REQUIRED;
498
499 Status = RtlQueryRegistryValues(RTL_REGISTRY_CONTROL,
500 L"\\Session Manager\\Memory Management",
501 QueryTable,
502 NULL,
503 NULL);
504 if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
505 {
506 Status = SmpCreateDefaultPagingFile();
507 }
508
509 return Status;
510 }
511
512
513 /* EOF */