[NDK][NTOS] Add global definition of INIT_FUNCTION/INIT_SECTION (#779)
[reactos.git] / ntoskrnl / ps / psmgr.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/ps/psmgr.c
5 * PURPOSE: Process Manager: Initialization Code
6 * PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
7 */
8
9 /* INCLUDES ******************************************************************/
10
11 #include <ntoskrnl.h>
12 #define NDEBUG
13 #include <debug.h>
14
15 extern ULONG ExpInitializationPhase;
16
17 PVOID KeUserPopEntrySListEnd;
18 PVOID KeUserPopEntrySListFault;
19 PVOID KeUserPopEntrySListResume;
20
21 GENERIC_MAPPING PspProcessMapping =
22 {
23 STANDARD_RIGHTS_READ | PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
24 STANDARD_RIGHTS_WRITE | PROCESS_CREATE_PROCESS | PROCESS_CREATE_THREAD |
25 PROCESS_VM_OPERATION | PROCESS_VM_WRITE | PROCESS_DUP_HANDLE |
26 PROCESS_TERMINATE | PROCESS_SET_QUOTA | PROCESS_SET_INFORMATION |
27 PROCESS_SUSPEND_RESUME,
28 STANDARD_RIGHTS_EXECUTE | SYNCHRONIZE,
29 PROCESS_ALL_ACCESS
30 };
31
32 GENERIC_MAPPING PspThreadMapping =
33 {
34 STANDARD_RIGHTS_READ | THREAD_GET_CONTEXT | THREAD_QUERY_INFORMATION,
35 STANDARD_RIGHTS_WRITE | THREAD_TERMINATE | THREAD_SUSPEND_RESUME |
36 THREAD_ALERT | THREAD_SET_INFORMATION | THREAD_SET_CONTEXT,
37 STANDARD_RIGHTS_EXECUTE | SYNCHRONIZE,
38 THREAD_ALL_ACCESS
39 };
40
41 PVOID PspSystemDllBase;
42 PVOID PspSystemDllSection;
43 PVOID PspSystemDllEntryPoint;
44
45 UNICODE_STRING PsNtDllPathName =
46 RTL_CONSTANT_STRING(L"\\SystemRoot\\System32\\ntdll.dll");
47
48 PHANDLE_TABLE PspCidTable;
49
50 PEPROCESS PsInitialSystemProcess = NULL;
51 PEPROCESS PsIdleProcess = NULL;
52 HANDLE PspInitialSystemProcessHandle = NULL;
53
54 ULONG PsMinimumWorkingSet, PsMaximumWorkingSet;
55 struct
56 {
57 LIST_ENTRY List;
58 KGUARDED_MUTEX Lock;
59 } PspWorkingSetChangeHead;
60 ULONG PspDefaultPagedLimit, PspDefaultNonPagedLimit, PspDefaultPagefileLimit;
61 BOOLEAN PspDoingGiveBacks;
62
63 /* PRIVATE FUNCTIONS *********************************************************/
64
65 INIT_FUNCTION
66 USHORT
67 NTAPI
68 NameToOrdinal(IN PCHAR Name,
69 IN PVOID DllBase,
70 IN ULONG NumberOfNames,
71 IN PULONG NameTable,
72 IN PUSHORT OrdinalTable)
73 {
74 ULONG Mid;
75 LONG Ret;
76
77 /* Fail if no names */
78 if (!NumberOfNames) return -1;
79
80 /* Do binary search */
81 Mid = NumberOfNames >> 1;
82 Ret = strcmp(Name, (PCHAR)((ULONG_PTR)DllBase + NameTable[Mid]));
83
84 /* Check if we found it */
85 if (!Ret) return OrdinalTable[Mid];
86
87 /* We didn't. Check if we only had one name to check */
88 if (NumberOfNames == 1) return -1;
89
90 /* Check if we should look up or down */
91 if (Ret < 0)
92 {
93 /* Loop down */
94 NumberOfNames = Mid;
95 }
96 else
97 {
98 /* Look up, update tables */
99 NameTable = &NameTable[Mid + 1];
100 OrdinalTable = &OrdinalTable[Mid + 1];
101 NumberOfNames -= (Mid - 1);
102 }
103
104 /* Call us recursively */
105 return NameToOrdinal(Name, DllBase, NumberOfNames, NameTable, OrdinalTable);
106 }
107
108 INIT_FUNCTION
109 NTSTATUS
110 NTAPI
111 LookupEntryPoint(IN PVOID DllBase,
112 IN PCHAR Name,
113 OUT PVOID *EntryPoint)
114 {
115 PULONG NameTable;
116 PUSHORT OrdinalTable;
117 PIMAGE_EXPORT_DIRECTORY ExportDirectory;
118 ULONG ExportSize;
119 CHAR Buffer[64];
120 USHORT Ordinal;
121 PULONG ExportTable;
122
123 /* Get the export directory */
124 ExportDirectory = RtlImageDirectoryEntryToData(DllBase,
125 TRUE,
126 IMAGE_DIRECTORY_ENTRY_EXPORT,
127 &ExportSize);
128
129 /* Validate the name and copy it */
130 if (strlen(Name) > sizeof(Buffer) - 2) return STATUS_INVALID_PARAMETER;
131 strcpy(Buffer, Name);
132
133 /* Setup name tables */
134 NameTable = (PULONG)((ULONG_PTR)DllBase +
135 ExportDirectory->AddressOfNames);
136 OrdinalTable = (PUSHORT)((ULONG_PTR)DllBase +
137 ExportDirectory->AddressOfNameOrdinals);
138
139 /* Get the ordinal */
140 Ordinal = NameToOrdinal(Buffer,
141 DllBase,
142 ExportDirectory->NumberOfNames,
143 NameTable,
144 OrdinalTable);
145
146 /* Make sure the ordinal is valid */
147 if (Ordinal >= ExportDirectory->NumberOfFunctions)
148 {
149 /* It's not, fail */
150 return STATUS_PROCEDURE_NOT_FOUND;
151 }
152
153 /* Resolve the address and write it */
154 ExportTable = (PULONG)((ULONG_PTR)DllBase +
155 ExportDirectory->AddressOfFunctions);
156 *EntryPoint = (PVOID)((ULONG_PTR)DllBase + ExportTable[Ordinal]);
157 return STATUS_SUCCESS;
158 }
159
160 INIT_FUNCTION
161 NTSTATUS
162 NTAPI
163 PspLookupSystemDllEntryPoint(IN PCHAR Name,
164 IN PVOID *EntryPoint)
165 {
166 /* Call the LDR Routine */
167 return LookupEntryPoint(PspSystemDllBase, Name, EntryPoint);
168 }
169
170 INIT_FUNCTION
171 NTSTATUS
172 NTAPI
173 PspLookupKernelUserEntryPoints(VOID)
174 {
175 NTSTATUS Status;
176
177 /* Get user-mode APC trampoline */
178 Status = PspLookupSystemDllEntryPoint("KiUserApcDispatcher",
179 &KeUserApcDispatcher);
180 if (!NT_SUCCESS(Status)) return Status;
181
182 /* Get user-mode exception dispatcher */
183 Status = PspLookupSystemDllEntryPoint("KiUserExceptionDispatcher",
184 &KeUserExceptionDispatcher);
185 if (!NT_SUCCESS(Status)) return Status;
186
187 /* Get user-mode callback dispatcher */
188 Status = PspLookupSystemDllEntryPoint("KiUserCallbackDispatcher",
189 &KeUserCallbackDispatcher);
190 if (!NT_SUCCESS(Status)) return Status;
191
192 /* Get user-mode exception raise trampoline */
193 Status = PspLookupSystemDllEntryPoint("KiRaiseUserExceptionDispatcher",
194 &KeRaiseUserExceptionDispatcher);
195 if (!NT_SUCCESS(Status)) return Status;
196
197 /* Get user-mode SLIST exception functions for page fault rollback race hack */
198 Status = PspLookupSystemDllEntryPoint("ExpInterlockedPopEntrySListEnd",
199 &KeUserPopEntrySListEnd);
200 if (!NT_SUCCESS(Status)) { DPRINT1("this not found\n"); return Status; }
201 Status = PspLookupSystemDllEntryPoint("ExpInterlockedPopEntrySListFault",
202 &KeUserPopEntrySListFault);
203 if (!NT_SUCCESS(Status)) { DPRINT1("this not found\n"); return Status; }
204 Status = PspLookupSystemDllEntryPoint("ExpInterlockedPopEntrySListResume",
205 &KeUserPopEntrySListResume);
206 if (!NT_SUCCESS(Status)) { DPRINT1("this not found\n"); return Status; }
207
208 /* On x86, there are multiple ways to do a system call, find the right stubs */
209 #if defined(_X86_)
210 /* Check if this is a machine that supports SYSENTER */
211 if (KeFeatureBits & KF_FAST_SYSCALL)
212 {
213 /* Get user-mode sysenter stub */
214 SharedUserData->SystemCall = (PsNtosImageBase >> (PAGE_SHIFT + 1));
215 Status = PspLookupSystemDllEntryPoint("KiFastSystemCall",
216 (PVOID)&SharedUserData->
217 SystemCall);
218 if (!NT_SUCCESS(Status)) return Status;
219
220 /* Get user-mode sysenter return stub */
221 Status = PspLookupSystemDllEntryPoint("KiFastSystemCallRet",
222 (PVOID)&SharedUserData->
223 SystemCallReturn);
224 if (!NT_SUCCESS(Status)) return Status;
225 }
226 else
227 {
228 /* Get the user-mode interrupt stub */
229 Status = PspLookupSystemDllEntryPoint("KiIntSystemCall",
230 (PVOID)&SharedUserData->
231 SystemCall);
232 if (!NT_SUCCESS(Status)) return Status;
233 }
234
235 /* Set the test instruction */
236 SharedUserData->TestRetInstruction = 0xC3;
237 #endif
238
239 /* Return the status */
240 return Status;
241 }
242
243 NTSTATUS
244 NTAPI
245 PspMapSystemDll(IN PEPROCESS Process,
246 IN PVOID *DllBase,
247 IN BOOLEAN UseLargePages)
248 {
249 NTSTATUS Status;
250 LARGE_INTEGER Offset = {{0, 0}};
251 SIZE_T ViewSize = 0;
252 PVOID ImageBase = 0;
253
254 /* Map the System DLL */
255 Status = MmMapViewOfSection(PspSystemDllSection,
256 Process,
257 (PVOID*)&ImageBase,
258 0,
259 0,
260 &Offset,
261 &ViewSize,
262 ViewShare,
263 0,
264 PAGE_READWRITE);
265 if (Status != STATUS_SUCCESS)
266 {
267 /* Normalize status code */
268 Status = STATUS_CONFLICTING_ADDRESSES;
269 }
270
271 /* Write the image base and return status */
272 if (DllBase) *DllBase = ImageBase;
273 return Status;
274 }
275
276 INIT_FUNCTION
277 NTSTATUS
278 NTAPI
279 PsLocateSystemDll(VOID)
280 {
281 OBJECT_ATTRIBUTES ObjectAttributes;
282 IO_STATUS_BLOCK IoStatusBlock;
283 HANDLE FileHandle, SectionHandle;
284 NTSTATUS Status;
285 ULONG_PTR HardErrorParameters;
286 ULONG HardErrorResponse;
287
288 /* Locate and open NTDLL to determine ImageBase and LdrStartup */
289 InitializeObjectAttributes(&ObjectAttributes,
290 &PsNtDllPathName,
291 0,
292 NULL,
293 NULL);
294 Status = ZwOpenFile(&FileHandle,
295 FILE_READ_ACCESS,
296 &ObjectAttributes,
297 &IoStatusBlock,
298 FILE_SHARE_READ,
299 0);
300 if (!NT_SUCCESS(Status))
301 {
302 /* Failed, bugcheck */
303 KeBugCheckEx(PROCESS1_INITIALIZATION_FAILED, Status, 2, 0, 0);
304 }
305
306 /* Check if the image is valid */
307 Status = MmCheckSystemImage(FileHandle, TRUE);
308 if (Status == STATUS_IMAGE_CHECKSUM_MISMATCH)
309 {
310 /* Raise a hard error */
311 HardErrorParameters = (ULONG_PTR)&PsNtDllPathName;
312 NtRaiseHardError(Status,
313 1,
314 1,
315 &HardErrorParameters,
316 OptionOk,
317 &HardErrorResponse);
318 return Status;
319 }
320
321 /* Create a section for NTDLL */
322 Status = ZwCreateSection(&SectionHandle,
323 SECTION_ALL_ACCESS,
324 NULL,
325 NULL,
326 PAGE_EXECUTE,
327 SEC_IMAGE,
328 FileHandle);
329 ZwClose(FileHandle);
330 if (!NT_SUCCESS(Status))
331 {
332 /* Failed, bugcheck */
333 KeBugCheckEx(PROCESS1_INITIALIZATION_FAILED, Status, 3, 0, 0);
334 }
335
336 /* Reference the Section */
337 Status = ObReferenceObjectByHandle(SectionHandle,
338 SECTION_ALL_ACCESS,
339 MmSectionObjectType,
340 KernelMode,
341 (PVOID*)&PspSystemDllSection,
342 NULL);
343 ZwClose(SectionHandle);
344 if (!NT_SUCCESS(Status))
345 {
346 /* Failed, bugcheck */
347 KeBugCheckEx(PROCESS1_INITIALIZATION_FAILED, Status, 4, 0, 0);
348 }
349
350 /* Map it */
351 Status = PspMapSystemDll(PsGetCurrentProcess(), &PspSystemDllBase, FALSE);
352 if (!NT_SUCCESS(Status))
353 {
354 /* Failed, bugcheck */
355 KeBugCheckEx(PROCESS1_INITIALIZATION_FAILED, Status, 5, 0, 0);
356 }
357
358 /* Return status */
359 return Status;
360 }
361
362 INIT_FUNCTION
363 NTSTATUS
364 NTAPI
365 PspInitializeSystemDll(VOID)
366 {
367 NTSTATUS Status;
368
369 /* Get user-mode startup thunk */
370 Status = PspLookupSystemDllEntryPoint("LdrInitializeThunk",
371 &PspSystemDllEntryPoint);
372 if (!NT_SUCCESS(Status))
373 {
374 /* Failed, bugcheck */
375 KeBugCheckEx(PROCESS1_INITIALIZATION_FAILED, Status, 7, 0, 0);
376 }
377
378 /* Get all the other entrypoints */
379 Status = PspLookupKernelUserEntryPoints();
380 if (!NT_SUCCESS(Status))
381 {
382 /* Failed, bugcheck */
383 KeBugCheckEx(PROCESS1_INITIALIZATION_FAILED, Status, 8, 0, 0);
384 }
385
386 #ifdef _WINKD_
387 /* Let KD know we are done */
388 KdUpdateDataBlock();
389 #endif
390
391 /* Return status */
392 return Status;
393 }
394
395 INIT_FUNCTION
396 BOOLEAN
397 NTAPI
398 PspInitPhase1(VOID)
399 {
400 /* Initialize the System DLL and return status of operation */
401 if (!NT_SUCCESS(PspInitializeSystemDll())) return FALSE;
402 return TRUE;
403 }
404
405 INIT_FUNCTION
406 BOOLEAN
407 NTAPI
408 PspInitPhase0(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
409 {
410 NTSTATUS Status;
411 OBJECT_ATTRIBUTES ObjectAttributes;
412 HANDLE SysThreadHandle;
413 PETHREAD SysThread;
414 MM_SYSTEMSIZE SystemSize;
415 UNICODE_STRING Name;
416 OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
417 ULONG i;
418
419 /* Get the system size */
420 SystemSize = MmQuerySystemSize();
421
422 /* Setup some memory options */
423 PspDefaultPagefileLimit = -1;
424 switch (SystemSize)
425 {
426 /* Medimum systems */
427 case MmMediumSystem:
428
429 /* Increase the WS sizes a bit */
430 PsMinimumWorkingSet += 10;
431 PsMaximumWorkingSet += 100;
432
433 /* Large systems */
434 case MmLargeSystem:
435
436 /* Increase the WS sizes a bit more */
437 PsMinimumWorkingSet += 30;
438 PsMaximumWorkingSet += 300;
439
440 /* Small and other systems */
441 default:
442 break;
443 }
444
445 /* Setup callbacks */
446 for (i = 0; i < PSP_MAX_CREATE_THREAD_NOTIFY; i++)
447 {
448 ExInitializeCallBack(&PspThreadNotifyRoutine[i]);
449 }
450 for (i = 0; i < PSP_MAX_CREATE_PROCESS_NOTIFY; i++)
451 {
452 ExInitializeCallBack(&PspProcessNotifyRoutine[i]);
453 }
454 for (i = 0; i < PSP_MAX_LOAD_IMAGE_NOTIFY; i++)
455 {
456 ExInitializeCallBack(&PspLoadImageNotifyRoutine[i]);
457 }
458
459 /* Setup the quantum table */
460 PsChangeQuantumTable(FALSE, PsRawPrioritySeparation);
461
462 /* Set quota settings */
463 if (!PspDefaultPagedLimit) PspDefaultPagedLimit = 0;
464 if (!PspDefaultNonPagedLimit) PspDefaultNonPagedLimit = 0;
465 if (!(PspDefaultNonPagedLimit) && !(PspDefaultPagedLimit))
466 {
467 /* Enable give-backs */
468 PspDoingGiveBacks = TRUE;
469 }
470 else
471 {
472 /* Disable them */
473 PspDoingGiveBacks = FALSE;
474 }
475
476 /* Now multiply limits by 1MB */
477 PspDefaultPagedLimit <<= 20;
478 PspDefaultNonPagedLimit <<= 20;
479 if (PspDefaultPagefileLimit != MAXULONG) PspDefaultPagefileLimit <<= 20;
480
481 /* Initialize the Active Process List */
482 InitializeListHead(&PsActiveProcessHead);
483 KeInitializeGuardedMutex(&PspActiveProcessMutex);
484
485 /* Get the idle process */
486 PsIdleProcess = PsGetCurrentProcess();
487
488 /* Setup the locks */
489 PsIdleProcess->ProcessLock.Value = 0;
490 ExInitializeRundownProtection(&PsIdleProcess->RundownProtect);
491
492 /* Initialize the thread list */
493 InitializeListHead(&PsIdleProcess->ThreadListHead);
494
495 /* Clear kernel time */
496 PsIdleProcess->Pcb.KernelTime = 0;
497
498 /* Initialize Object Initializer */
499 RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
500 ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
501 ObjectTypeInitializer.InvalidAttributes = OBJ_PERMANENT |
502 OBJ_EXCLUSIVE |
503 OBJ_OPENIF;
504 ObjectTypeInitializer.PoolType = NonPagedPool;
505 ObjectTypeInitializer.SecurityRequired = TRUE;
506
507 /* Initialize the Process type */
508 RtlInitUnicodeString(&Name, L"Process");
509 ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(EPROCESS);
510 ObjectTypeInitializer.GenericMapping = PspProcessMapping;
511 ObjectTypeInitializer.ValidAccessMask = PROCESS_ALL_ACCESS;
512 ObjectTypeInitializer.DeleteProcedure = PspDeleteProcess;
513 ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &PsProcessType);
514
515 /* Initialize the Thread type */
516 RtlInitUnicodeString(&Name, L"Thread");
517 ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
518 ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(ETHREAD);
519 ObjectTypeInitializer.GenericMapping = PspThreadMapping;
520 ObjectTypeInitializer.ValidAccessMask = THREAD_ALL_ACCESS;
521 ObjectTypeInitializer.DeleteProcedure = PspDeleteThread;
522 ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &PsThreadType);
523
524 /* Initialize the Job type */
525 RtlInitUnicodeString(&Name, L"Job");
526 ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
527 ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(EJOB);
528 ObjectTypeInitializer.GenericMapping = PspJobMapping;
529 ObjectTypeInitializer.InvalidAttributes = 0;
530 ObjectTypeInitializer.ValidAccessMask = JOB_OBJECT_ALL_ACCESS;
531 ObjectTypeInitializer.DeleteProcedure = PspDeleteJob;
532 ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &PsJobType);
533
534 /* Initialize job structures external to this file */
535 PspInitializeJobStructures();
536
537 /* Initialize the Working Set data */
538 InitializeListHead(&PspWorkingSetChangeHead.List);
539 KeInitializeGuardedMutex(&PspWorkingSetChangeHead.Lock);
540
541 /* Create the CID Handle table */
542 PspCidTable = ExCreateHandleTable(NULL);
543 if (!PspCidTable) return FALSE;
544
545 /* FIXME: Initialize LDT/VDM support */
546
547 /* Setup the reaper */
548 ExInitializeWorkItem(&PspReaperWorkItem, PspReapRoutine, NULL);
549
550 /* Set the boot access token */
551 PspBootAccessToken = (PTOKEN)(PsIdleProcess->Token.Value & ~MAX_FAST_REFS);
552
553 /* Setup default object attributes */
554 InitializeObjectAttributes(&ObjectAttributes,
555 NULL,
556 0,
557 NULL,
558 NULL);
559
560 /* Create the Initial System Process */
561 Status = PspCreateProcess(&PspInitialSystemProcessHandle,
562 PROCESS_ALL_ACCESS,
563 &ObjectAttributes,
564 0,
565 FALSE,
566 0,
567 0,
568 0,
569 FALSE);
570 if (!NT_SUCCESS(Status)) return FALSE;
571
572 /* Get a reference to it */
573 ObReferenceObjectByHandle(PspInitialSystemProcessHandle,
574 0,
575 PsProcessType,
576 KernelMode,
577 (PVOID*)&PsInitialSystemProcess,
578 NULL);
579
580 /* Copy the process names */
581 strcpy(PsIdleProcess->ImageFileName, "Idle");
582 strcpy(PsInitialSystemProcess->ImageFileName, "System");
583
584 /* Allocate a structure for the audit name */
585 PsInitialSystemProcess->SeAuditProcessCreationInfo.ImageFileName =
586 ExAllocatePoolWithTag(PagedPool,
587 sizeof(OBJECT_NAME_INFORMATION),
588 TAG_SEPA);
589 if (!PsInitialSystemProcess->SeAuditProcessCreationInfo.ImageFileName)
590 {
591 /* Allocation failed */
592 return FALSE;
593 }
594
595 /* Zero it */
596 RtlZeroMemory(PsInitialSystemProcess->
597 SeAuditProcessCreationInfo.ImageFileName,
598 sizeof(OBJECT_NAME_INFORMATION));
599
600 /* Setup the system initialization thread */
601 Status = PsCreateSystemThread(&SysThreadHandle,
602 THREAD_ALL_ACCESS,
603 &ObjectAttributes,
604 0,
605 NULL,
606 Phase1Initialization,
607 LoaderBlock);
608 if (!NT_SUCCESS(Status)) return FALSE;
609
610 /* Create a handle to it */
611 ObReferenceObjectByHandle(SysThreadHandle,
612 0,
613 PsThreadType,
614 KernelMode,
615 (PVOID*)&SysThread,
616 NULL);
617 ObCloseHandle(SysThreadHandle, KernelMode);
618
619 /* Return success */
620 return TRUE;
621 }
622
623 INIT_FUNCTION
624 BOOLEAN
625 NTAPI
626 PsInitSystem(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
627 {
628 /* Check the initialization phase */
629 switch (ExpInitializationPhase)
630 {
631 case 0:
632
633 /* Do Phase 0 */
634 return PspInitPhase0(LoaderBlock);
635
636 case 1:
637
638 /* Do Phase 1 */
639 return PspInitPhase1();
640
641 default:
642
643 /* Don't know any other phase! Bugcheck! */
644 KeBugCheckEx(UNEXPECTED_INITIALIZATION_CALL,
645 1,
646 ExpInitializationPhase,
647 0,
648 0);
649 return FALSE;
650 }
651 }
652
653 /* PUBLIC FUNCTIONS **********************************************************/
654
655 /*
656 * @implemented
657 */
658 BOOLEAN
659 NTAPI
660 PsGetVersion(OUT PULONG MajorVersion OPTIONAL,
661 OUT PULONG MinorVersion OPTIONAL,
662 OUT PULONG BuildNumber OPTIONAL,
663 OUT PUNICODE_STRING CSDVersion OPTIONAL)
664 {
665 if (MajorVersion) *MajorVersion = NtMajorVersion;
666 if (MinorVersion) *MinorVersion = NtMinorVersion;
667 if (BuildNumber ) *BuildNumber = NtBuildNumber & 0x3FFF;
668
669 if (CSDVersion)
670 {
671 CSDVersion->Length = CmCSDVersionString.Length;
672 CSDVersion->MaximumLength = CmCSDVersionString.MaximumLength;
673 CSDVersion->Buffer = CmCSDVersionString.Buffer;
674 }
675
676 /* Return TRUE if this is a Checked Build */
677 return (NtBuildNumber >> 28) == 0xC;
678 }
679
680 /* EOF */