ReactOS 0.4.15-dev-6644-g539123c
init.c File Reference
#include <ntoskrnl.h>
#include <reactos/buildno.h>
#include "inbv/logo.h"
#include <debug.h>
Include dependency graph for init.c:

Go to the source code of this file.

Classes

struct  _INIT_BUFFER
 

Macros

#define NDEBUG
 
#define LOADER_PARAMETER_EXTENSION_MIN_SIZE    RTL_SIZEOF_THROUGH_FIELD(LOADER_PARAMETER_EXTENSION, AcpiTableSize)
 

Typedefs

typedef struct _INIT_BUFFER INIT_BUFFER
 
typedef struct _INIT_BUFFERPINIT_BUFFER
 

Functions

BOOLEAN NTAPI MmArmInitSystem (IN ULONG Phase, IN PLOADER_PARAMETER_BLOCK LoaderBlock)
 
NTSTATUS NTAPI ExpCreateSystemRootLink (IN PLOADER_PARAMETER_BLOCK LoaderBlock)
 
VOID NTAPI ExpInitNls (IN PLOADER_PARAMETER_BLOCK LoaderBlock)
 
VOID NTAPI ExpLoadInitialProcess (IN PINIT_BUFFER InitBuffer, OUT PRTL_USER_PROCESS_PARAMETERS *ProcessParameters, OUT PCHAR *ProcessEnvironment)
 
ULONG NTAPI ExComputeTickCountMultiplier (IN ULONG ClockIncrement)
 
BOOLEAN NTAPI ExpInitSystemPhase0 (VOID)
 
BOOLEAN NTAPI ExpInitSystemPhase1 (VOID)
 
BOOLEAN NTAPI ExInitSystem (VOID)
 
BOOLEAN NTAPI ExpIsLoaderValid (IN PLOADER_PARAMETER_BLOCK LoaderBlock)
 
VOID NTAPI ExpLoadBootSymbols (IN PLOADER_PARAMETER_BLOCK LoaderBlock)
 
VOID NTAPI ExBurnMemory (IN PLOADER_PARAMETER_BLOCK LoaderBlock, IN ULONG_PTR PagesToDestroy, IN TYPE_OF_MEMORY MemoryType)
 
VOID NTAPI ExpInitializeExecutive (IN ULONG Cpu, IN PLOADER_PARAMETER_BLOCK LoaderBlock)
 
VOID NTAPI MmFreeLoaderBlock (IN PLOADER_PARAMETER_BLOCK LoaderBlock)
 
VOID NTAPI Phase1InitializationDiscard (IN PVOID Context)
 
VOID NTAPI Phase1Initialization (IN PVOID Context)
 

Variables

ULONG NtMajorVersion = VER_PRODUCTMAJORVERSION
 
ULONG NtMinorVersion = VER_PRODUCTMINORVERSION
 
ULONG NtBuildNumber = VER_PRODUCTBUILD
 
ULONG NtGlobalFlag = 0
 
ULONG ExSuiteMask
 
ULONG CmNtSpBuildNumber
 
ULONG CmNtCSDVersion
 
ULONG CmNtCSDReleaseType
 
UNICODE_STRING CmVersionString
 
UNICODE_STRING CmCSDVersionString
 
CHAR NtBuildLab []
 
ULONG ExpInitializationPhase
 
BOOLEAN ExpInTextModeSetup
 
BOOLEAN IoRemoteBootClient
 
ULONG InitSafeBootMode
 
BOOLEAN InitIsWinPEMode
 
BOOLEAN InitWinPEModeType
 
UNICODE_STRING NtSystemRoot
 
WCHAR NtInitialUserProcessBuffer [128] = L"\\SystemRoot\\System32\\smss.exe"
 
ULONG NtInitialUserProcessBufferLength
 
ULONG NtInitialUserProcessBufferType = REG_SZ
 
PVOID ExpNlsTableBase
 
ULONG ExpAnsiCodePageDataOffset
 
ULONG ExpOemCodePageDataOffset
 
ULONG ExpUnicodeCaseTableDataOffset
 
NLSTABLEINFO ExpNlsTableInfo
 
SIZE_T ExpNlsTableSize
 
PVOID ExpNlsSectionPointer
 
BOOLEAN ExCmosClockIsSane = TRUE
 
BOOLEAN ExpRealTimeIsUniversal
 

Macro Definition Documentation

◆ LOADER_PARAMETER_EXTENSION_MIN_SIZE

#define LOADER_PARAMETER_EXTENSION_MIN_SIZE    RTL_SIZEOF_THROUGH_FIELD(LOADER_PARAMETER_EXTENSION, AcpiTableSize)

Definition at line 20 of file init.c.

◆ NDEBUG

#define NDEBUG

Definition at line 16 of file init.c.

Typedef Documentation

◆ INIT_BUFFER

◆ PINIT_BUFFER

Function Documentation

◆ ExBurnMemory()

VOID NTAPI ExBurnMemory ( IN PLOADER_PARAMETER_BLOCK  LoaderBlock,
IN ULONG_PTR  PagesToDestroy,
IN TYPE_OF_MEMORY  MemoryType 
)

Definition at line 876 of file init.c.

879{
880 PLIST_ENTRY ListEntry;
881 PMEMORY_ALLOCATION_DESCRIPTOR MemDescriptor;
882
883 DPRINT1("Burn RAM amount: %lu pages\n", PagesToDestroy);
884
885 /* Loop the memory descriptors, beginning at the end */
886 for (ListEntry = LoaderBlock->MemoryDescriptorListHead.Blink;
887 ListEntry != &LoaderBlock->MemoryDescriptorListHead;
888 ListEntry = ListEntry->Blink)
889 {
890 /* Get the memory descriptor structure */
891 MemDescriptor = CONTAINING_RECORD(ListEntry,
893 ListEntry);
894
895 /* Is memory free there or is it temporary? */
896 if (MemDescriptor->MemoryType == LoaderFree ||
897 MemDescriptor->MemoryType == LoaderFirmwareTemporary)
898 {
899 /* Check if the descriptor has more pages than we want */
900 if (MemDescriptor->PageCount > PagesToDestroy)
901 {
902 /* Change block's page count, ntoskrnl doesn't care much */
903 MemDescriptor->PageCount -= PagesToDestroy;
904 break;
905 }
906 else
907 {
908 /* Change block type */
909 MemDescriptor->MemoryType = MemoryType;
910 PagesToDestroy -= MemDescriptor->PageCount;
911
912 /* Check if we are done */
913 if (PagesToDestroy == 0) break;
914 }
915 }
916 }
917}
#define DPRINT1
Definition: precomp.h:8
@ LoaderFree
Definition: arc.h:176
@ LoaderFirmwareTemporary
Definition: arc.h:179
Definition: typedefs.h:120
struct _LIST_ENTRY * Blink
Definition: typedefs.h:122
TYPE_OF_MEMORY MemoryType
Definition: arc.h:240
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260

Referenced by ExpInitializeExecutive().

◆ ExComputeTickCountMultiplier()

ULONG NTAPI ExComputeTickCountMultiplier ( IN ULONG  ClockIncrement)

Definition at line 605 of file init.c.

606{
607 ULONG MsRemainder = 0, MsIncrement;
608 ULONG IncrementRemainder;
609 ULONG i;
610
611 /* Count the number of milliseconds for each clock interrupt */
612 MsIncrement = ClockIncrement / (10 * 1000);
613
614 /* Count the remainder from the division above, with 24-bit precision */
615 IncrementRemainder = ClockIncrement - (MsIncrement * (10 * 1000));
616 for (i= 0; i < 24; i++)
617 {
618 /* Shift the remainders */
619 MsRemainder <<= 1;
620 IncrementRemainder <<= 1;
621
622 /* Check if we've went past 1 ms */
623 if (IncrementRemainder >= (10 * 1000))
624 {
625 /* Increase the remainder by one, and substract from increment */
626 IncrementRemainder -= (10 * 1000);
627 MsRemainder |= 1;
628 }
629 }
630
631 /* Return the increment */
632 return (MsIncrement << 24) | MsRemainder;
633}
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
uint32_t ULONG
Definition: typedefs.h:59

Referenced by ExpInitializeExecutive().

◆ ExInitSystem()

BOOLEAN NTAPI ExInitSystem ( VOID  )

Definition at line 743 of file init.c.

744{
745 /* Check the initialization phase */
747 {
748 case 0:
749
750 /* Do Phase 0 */
751 return ExpInitSystemPhase0();
752
753 case 1:
754
755 /* Do Phase 1 */
756 return ExpInitSystemPhase1();
757
758 default:
759
760 /* Don't know any other phase! Bugcheck! */
761 KeBugCheck(UNEXPECTED_INITIALIZATION_CALL);
762 return FALSE;
763 }
764}
DECLSPEC_NORETURN VOID NTAPI KeBugCheck(ULONG BugCheckCode)
Definition: bug.c:1431
#define FALSE
Definition: types.h:117
ULONG ExpInitializationPhase
Definition: init.c:68
BOOLEAN NTAPI ExpInitSystemPhase0(VOID)
Definition: init.c:638
BOOLEAN NTAPI ExpInitSystemPhase1(VOID)
Definition: init.c:662

Referenced by ExpInitializeExecutive(), and Phase1InitializationDiscard().

◆ ExpCreateSystemRootLink()

NTSTATUS NTAPI ExpCreateSystemRootLink ( IN PLOADER_PARAMETER_BLOCK  LoaderBlock)

Definition at line 100 of file init.c.

101{
102 UNICODE_STRING LinkName;
104 HANDLE LinkHandle;
106 ANSI_STRING AnsiName;
107 CHAR Buffer[256];
110
111 /* Initialize the ArcName tree */
112 RtlInitUnicodeString(&LinkName, L"\\ArcName");
114 &LinkName,
116 NULL,
118
119 /* Create it */
120 Status = NtCreateDirectoryObject(&LinkHandle,
123 if (!NT_SUCCESS(Status))
124 {
125 /* Failed */
126 KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 1, 0, 0);
127 }
128
129 /* Close the LinkHandle */
130 NtClose(LinkHandle);
131
132 /* Initialize the Device tree */
133 RtlInitUnicodeString(&LinkName, L"\\Device");
135 &LinkName,
137 NULL,
139
140 /* Create it */
141 Status = NtCreateDirectoryObject(&LinkHandle,
144 if (!NT_SUCCESS(Status))
145 {
146 /* Failed */
147 KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 2, 0, 0);
148 }
149
150 /* Close the LinkHandle */
151 ObCloseHandle(LinkHandle, KernelMode);
152
153 /* Create the system root symlink name */
154 RtlInitAnsiString(&AnsiName, "\\SystemRoot");
155 Status = RtlAnsiStringToUnicodeString(&LinkName, &AnsiName, TRUE);
156 if (!NT_SUCCESS(Status))
157 {
158 /* Failed */
159 KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 3, 0, 0);
160 }
161
162 /* Initialize the attributes for the link */
164 &LinkName,
166 NULL,
168
169 /* Build the ARC name */
171 "\\ArcName\\%s%s",
172 LoaderBlock->ArcBootDeviceName,
173 LoaderBlock->NtBootPathName);
175
176 /* Convert it to Unicode */
180 TRUE);
181 if (!NT_SUCCESS(Status))
182 {
183 /* We failed, bugcheck */
184 KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 4, 0, 0);
185 }
186
187 /* Create it */
191 &TargetName);
192
193 /* Free the strings */
194 RtlFreeUnicodeString(&LinkName);
196
197 /* Check if creating the link failed */
198 if (!NT_SUCCESS(Status))
199 {
200 /* Failed */
201 KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 5, 0, 0);
202 }
203
204 /* Close the handle and return success */
205 ObCloseHandle(LinkHandle, KernelMode);
206 return STATUS_SUCCESS;
207}
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
LONG NTSTATUS
Definition: precomp.h:26
_In_z_ PCHAR TargetString
Definition: cdrom.h:954
Definition: bufpool.h:45
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:36
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
Status
Definition: gdiplustypes.h:25
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
#define OBJ_PERMANENT
Definition: winternl.h:226
#define sprintf(buf, format,...)
Definition: sprintf.c:55
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
#define KernelMode
Definition: asm.h:34
#define SYMBOLIC_LINK_ALL_ACCESS
Definition: nt_native.h:1267
NTSYSAPI VOID NTAPI RtlInitString(PSTRING DestinationString, PCSZ SourceString)
NTSYSAPI NTSTATUS NTAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING DestinationString, PANSI_STRING SourceString, BOOLEAN AllocateDestinationString)
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3402
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
#define DIRECTORY_ALL_ACCESS
Definition: nt_native.h:1259
NTSYSAPI VOID NTAPI RtlInitAnsiString(PANSI_STRING DestinationString, PCSZ SourceString)
#define ANSI_NULL
PSECURITY_DESCRIPTOR SePublicDefaultUnrestrictedSd
Definition: sd.c:17
#define L(x)
Definition: ntvdm.h:50
NTSTATUS NTAPI NtCreateDirectoryObject(OUT PHANDLE DirectoryHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes)
Definition: obdir.c:765
NTSTATUS NTAPI ObCloseHandle(IN HANDLE Handle, IN KPROCESSOR_MODE AccessMode)
Definition: obhandle.c:3379
static PCWSTR TargetName
Definition: ping.c:67
VOID NTAPI KeBugCheckEx(_In_ ULONG BugCheckCode, _In_ ULONG_PTR BugCheckParameter1, _In_ ULONG_PTR BugCheckParameter2, _In_ ULONG_PTR BugCheckParameter3, _In_ ULONG_PTR BugCheckParameter4)
Definition: rtlcompat.c:108
#define STATUS_SUCCESS
Definition: shellext.h:65
char CHAR
Definition: xmlstorage.h:175

Referenced by Phase1InitializationDiscard().

◆ ExpInitializeExecutive()

VOID NTAPI ExpInitializeExecutive ( IN ULONG  Cpu,
IN PLOADER_PARAMETER_BLOCK  LoaderBlock 
)

Definition at line 922 of file init.c.

924{
925 PNLS_DATA_BLOCK NlsData;
926 CHAR Buffer[256];
927 ANSI_STRING AnsiPath;
929 PCHAR CommandLine, PerfMem;
930 ULONG PerfMemUsed;
931 PLDR_DATA_TABLE_ENTRY NtosEntry;
933 ANSI_STRING CSDString;
934 size_t Remaining = 0;
935 PCHAR RcEnd = NULL;
936 CHAR VersionBuffer[65];
937
938 /* Validate Loader */
939 if (!ExpIsLoaderValid(LoaderBlock))
940 {
941 /* Invalid loader version */
942 KeBugCheckEx(MISMATCHED_HAL,
943 3,
944 LoaderBlock->Extension->Size,
945 LoaderBlock->Extension->MajorVersion,
946 LoaderBlock->Extension->MinorVersion);
947 }
948
949 /* Initialize PRCB pool lookaside pointers */
951
952 /* Check if this is an application CPU */
953 if (Cpu)
954 {
955 /* Then simply initialize it with HAL */
956 if (!HalInitSystem(ExpInitializationPhase, LoaderBlock))
957 {
958 /* Initialization failed */
959 KeBugCheck(HAL_INITIALIZATION_FAILED);
960 }
961
962 /* We're done */
963 return;
964 }
965
966 /* Assume no text-mode or remote boot */
969
970 /* Check if we have a setup loader block */
971 if (LoaderBlock->SetupLdrBlock)
972 {
973 /* Check if this is text-mode setup */
974 if (LoaderBlock->SetupLdrBlock->Flags & SETUPLDR_TEXT_MODE)
976
977 /* Check if this is network boot */
978 if (LoaderBlock->SetupLdrBlock->Flags & SETUPLDR_REMOTE_BOOT)
979 {
980 /* Set variable */
982
983 /* Make sure we're actually booting off the network */
984 ASSERT(!_memicmp(LoaderBlock->ArcBootDeviceName, "net(0)", 6));
985 }
986 }
987
988 /* Set phase to 0 */
990
991 /* Get boot command line */
992 CommandLine = LoaderBlock->LoadOptions;
993 if (CommandLine)
994 {
995 /* Upcase it for comparison and check if we're in performance mode */
996 _strupr(CommandLine);
997 PerfMem = strstr(CommandLine, "PERFMEM");
998 if (PerfMem)
999 {
1000 /* Check if the user gave a number of bytes to use */
1001 PerfMem = strstr(PerfMem, "=");
1002 if (PerfMem)
1003 {
1004 /* Read the number of pages we'll use */
1005 PerfMemUsed = atol(PerfMem + 1) * (1024 * 1024 / PAGE_SIZE);
1006 if (PerfMemUsed)
1007 {
1008 /* FIXME: TODO */
1009 DPRINT1("BBT performance mode not yet supported."
1010 "/PERFMEM option ignored.\n");
1011 }
1012 }
1013 }
1014
1015 /* Check if we're burning memory */
1016 PerfMem = strstr(CommandLine, "BURNMEMORY");
1017 if (PerfMem)
1018 {
1019 /* Check if the user gave a number of bytes to use */
1020 PerfMem = strstr(PerfMem, "=");
1021 if (PerfMem)
1022 {
1023 /* Read the number of pages we'll use */
1024 PerfMemUsed = atol(PerfMem + 1) * (1024 * 1024 / PAGE_SIZE);
1025 if (PerfMemUsed) ExBurnMemory(LoaderBlock, PerfMemUsed, LoaderBad);
1026 }
1027 }
1028 }
1029
1030 /* Setup NLS Base and offsets */
1031 NlsData = LoaderBlock->NlsData;
1035 (ULONG_PTR)NlsData->AnsiCodePageData);
1037 (ULONG_PTR)NlsData->AnsiCodePageData);
1038
1039 /* Initialize the NLS Tables */
1048
1049 /* Now initialize the HAL */
1050 if (!HalInitSystem(ExpInitializationPhase, LoaderBlock))
1051 {
1052 /* HAL failed to initialize, bugcheck */
1053 KeBugCheck(HAL_INITIALIZATION_FAILED);
1054 }
1055
1056 /* Make sure interrupts are active now */
1057 _enable();
1058
1059 /* Clear the crypto exponent */
1060 SharedUserData->CryptoExponent = 0;
1061
1062 /* Set global flags for the checked build */
1063#if DBG
1066#endif
1067
1068 /* Setup NT System Root Path */
1069 sprintf(Buffer, "C:%s", LoaderBlock->NtBootPathName);
1070
1071 /* Convert to ANSI_STRING and null-terminate it */
1072 RtlInitString(&AnsiPath, Buffer);
1073 Buffer[--AnsiPath.Length] = ANSI_NULL;
1074
1075 /* Get the string from KUSER_SHARED_DATA's buffer */
1076 RtlInitEmptyUnicodeString(&NtSystemRoot,
1077 SharedUserData->NtSystemRoot,
1078 sizeof(SharedUserData->NtSystemRoot));
1079
1080 /* Now fill it in */
1082 if (!NT_SUCCESS(Status)) KeBugCheck(SESSION3_INITIALIZATION_FAILED);
1083
1084 /* Setup bugcheck messages */
1086
1087 /* Setup initial system settings */
1088 CmGetSystemControlValues(LoaderBlock->RegistryBase, CmControlVector);
1089
1090 /* Set the Service Pack Number and add it to the CSD Version number if needed */
1092 if (((CmNtCSDVersion & 0xFFFF0000) == 0) && (CmNtCSDReleaseType == 1))
1093 {
1095 }
1096
1097 /* Add loaded CmNtGlobalFlag value */
1099
1100 /* Initialize the executive at phase 0 */
1101 if (!ExInitSystem()) KeBugCheck(PHASE0_INITIALIZATION_FAILED);
1102
1103 /* Initialize the memory manager at phase 0 */
1104 if (!MmArmInitSystem(0, LoaderBlock)) KeBugCheck(PHASE0_INITIALIZATION_FAILED);
1105
1106 /* Load boot symbols */
1107 ExpLoadBootSymbols(LoaderBlock);
1108
1109 /* Check if we should break after symbol load */
1111
1112 /* Check if this loader is compatible with NT 5.2 */
1113 if (LoaderBlock->Extension->Size >= sizeof(LOADER_PARAMETER_EXTENSION))
1114 {
1115 /* Setup headless terminal settings */
1116 HeadlessInit(LoaderBlock);
1117 }
1118
1119 /* Set system ranges */
1120#ifdef _M_AMD64
1123#else
1126#endif
1127
1128 /* Make a copy of the NLS Tables */
1129 ExpInitNls(LoaderBlock);
1130
1131 /* Get the kernel's load entry */
1132 NtosEntry = CONTAINING_RECORD(LoaderBlock->LoadOrderListHead.Flink,
1134 InLoadOrderLinks);
1135
1136 /* Check if this is a service pack */
1137 if (CmNtCSDVersion & 0xFFFF)
1138 {
1139 /* Get the service pack string */
1140 Status = RtlFindMessage(NtosEntry->DllBase,
1141 11,
1142 0,
1143 WINDOWS_NT_CSD_STRING,
1144 &MsgEntry);
1145 if (NT_SUCCESS(Status))
1146 {
1147 /* Setup the string */
1148 RtlInitAnsiString(&CSDString, (PCHAR)MsgEntry->Text);
1149
1150 /* Remove trailing newline */
1151 while ((CSDString.Length > 0) &&
1152 ((CSDString.Buffer[CSDString.Length - 1] == '\r') ||
1153 (CSDString.Buffer[CSDString.Length - 1] == '\n')))
1154 {
1155 /* Skip the trailing character */
1156 CSDString.Length--;
1157 }
1158
1159 /* Fill the buffer with version information */
1161 sizeof(Buffer),
1162 "%Z %u%c",
1163 &CSDString,
1164 (CmNtCSDVersion & 0xFF00) >> 8,
1165 (CmNtCSDVersion & 0xFF) ?
1166 'A' + (CmNtCSDVersion & 0xFF) - 1 :
1167 ANSI_NULL);
1168 }
1169 else
1170 {
1171 /* Build default string */
1173 sizeof(Buffer),
1174 "CSD %04x",
1176 }
1177
1178 /* Check for success */
1179 if (!NT_SUCCESS(Status))
1180 {
1181 /* Fail */
1182 KeBugCheckEx(PHASE0_INITIALIZATION_FAILED, Status, 0, 0, 0);
1183 }
1184 }
1185 else
1186 {
1187 /* Then this is a beta */
1189 sizeof(Buffer),
1191 NULL,
1192 &Remaining,
1193 0);
1194 if (!NT_SUCCESS(Status))
1195 {
1196 /* Fail */
1197 KeBugCheckEx(PHASE0_INITIALIZATION_FAILED, Status, 0, 0, 0);
1198 }
1199
1200 /* Update length */
1201 CmCSDVersionString.MaximumLength = sizeof(Buffer) - (USHORT)Remaining;
1202 }
1203
1204 /* Check if we have an RC number */
1205 if ((CmNtCSDVersion & 0xFFFF0000) && (CmNtCSDReleaseType == 1))
1206 {
1207 /* Check if we have no version data yet */
1208 if (!(*Buffer))
1209 {
1210 /* Set defaults */
1211 Remaining = sizeof(Buffer);
1212 RcEnd = Buffer;
1213 }
1214 else
1215 {
1216 /* Add comma and space */
1218 sizeof(Buffer),
1219 ", ",
1220 &RcEnd,
1221 &Remaining,
1222 0);
1223 if (!NT_SUCCESS(Status))
1224 {
1225 /* Fail */
1226 KeBugCheckEx(PHASE0_INITIALIZATION_FAILED, Status, 0, 0, 0);
1227 }
1228 }
1229
1230 /* Add the version format string */
1231 Status = RtlStringCbPrintfA(RcEnd,
1232 Remaining,
1233 "v.%u",
1234 (CmNtCSDVersion & 0xFFFF0000) >> 16);
1235 if (!NT_SUCCESS(Status))
1236 {
1237 /* Fail */
1238 KeBugCheckEx(PHASE0_INITIALIZATION_FAILED, Status, 0, 0, 0);
1239 }
1240 }
1241
1242 /* Now setup the final string */
1243 RtlInitAnsiString(&CSDString, Buffer);
1245 &CSDString,
1246 TRUE);
1247 if (!NT_SUCCESS(Status))
1248 {
1249 /* Fail */
1250 KeBugCheckEx(PHASE0_INITIALIZATION_FAILED, Status, 0, 0, 0);
1251 }
1252
1253 /* Add our version */
1254 Status = RtlStringCbPrintfA(VersionBuffer,
1255 sizeof(VersionBuffer),
1256 "%u.%u",
1259 if (!NT_SUCCESS(Status))
1260 {
1261 /* Fail */
1262 KeBugCheckEx(PHASE0_INITIALIZATION_FAILED, Status, 0, 0, 0);
1263 }
1264
1265 /* Build the final version string */
1267
1268 /* Check if the user wants a kernel stack trace database */
1270 {
1271 /* FIXME: TODO */
1272 DPRINT1("Kernel-mode stack trace support not yet present."
1273 "FLG_KERNEL_STACK_TRACE_DB flag ignored.\n");
1274 }
1275
1276 /* Check if he wanted exception logging */
1278 {
1279 /* FIXME: TODO */
1280 DPRINT1("Kernel-mode exception logging support not yet present."
1281 "FLG_ENABLE_EXCEPTION_LOGGING flag ignored.\n");
1282 }
1283
1284 /* Initialize the Handle Table */
1286
1287#if DBG
1288 /* On checked builds, allocate the system call count table */
1291 KiServiceLimit * sizeof(ULONG),
1292 'llaC');
1293
1294 /* Use it for the shadow table too */
1296
1297 /* Make sure allocation succeeded */
1299 {
1300 /* Zero the call counts to 0 */
1302 KiServiceLimit * sizeof(ULONG));
1303 }
1304#endif
1305
1306 /* Create the Basic Object Manager Types to allow new Object Types */
1307 if (!ObInitSystem()) KeBugCheck(OBJECT_INITIALIZATION_FAILED);
1308
1309 /* Load basic Security for other Managers */
1310 if (!SeInitSystem()) KeBugCheck(SECURITY_INITIALIZATION_FAILED);
1311
1312 /* Initialize the Process Manager */
1313 if (!PsInitSystem(LoaderBlock)) KeBugCheck(PROCESS_INITIALIZATION_FAILED);
1314
1315 /* Initialize the PnP Manager */
1316 if (!PpInitSystem()) KeBugCheck(PP0_INITIALIZATION_FAILED);
1317
1318 /* Initialize the User-Mode Debugging Subsystem */
1320
1321 /* Calculate the tick count multiplier */
1323 SharedUserData->TickCountMultiplier = ExpTickCountMultiplier;
1324
1325 /* Set the OS Version */
1326 SharedUserData->NtMajorVersion = NtMajorVersion;
1327 SharedUserData->NtMinorVersion = NtMinorVersion;
1328
1329 /* Set the machine type */
1330 SharedUserData->ImageNumberLow = IMAGE_FILE_MACHINE_NATIVE;
1331 SharedUserData->ImageNumberHigh = IMAGE_FILE_MACHINE_NATIVE;
1332}
char * strstr(char *String1, char *String2)
Definition: utclib.c:653
CM_SYSTEM_CONTROL_VECTOR CmControlVector[]
VOID NTAPI CmGetSystemControlValues(IN PVOID SystemHiveData, IN PCM_SYSTEM_CONTROL_VECTOR ControlVector)
Definition: cmcontrl.c:104
ULONG CmNtGlobalFlag
Definition: cmdata.c:19
VOID NTAPI DbgkInitialize(VOID)
Definition: dbgkobj.c:1498
#define ULONG_PTR
Definition: config.h:101
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define PAGE_SIZE
Definition: env_spec_w32.h:49
#define NonPagedPool
Definition: env_spec_w32.h:307
BOOLEAN NTAPI HalInitSystem(IN ULONG BootPhase, IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: halinit.c:43
VOID NTAPI HeadlessInit(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: hdlsterm.c:189
#define VER_PRODUCTBETA_STR
Definition: ieverp.h:10
_Check_return_ long __cdecl atol(_In_z_ const char *_Str)
#define FLG_KERNEL_STACK_TRACE_DB
Definition: pstypes.h:68
#define FLG_ENABLE_EXCEPTION_LOGGING
Definition: pstypes.h:82
#define FLG_ENABLE_CLOSE_EXCEPTIONS
Definition: pstypes.h:81
#define FLG_ENABLE_KDEBUG_SYMBOL_LOAD
Definition: pstypes.h:73
void __cdecl _enable(void)
Definition: intrin_arm.h:373
BOOLEAN KdBreakAfterSymbolLoad
Definition: kddata.c:80
VOID NTAPI ExInitPoolLookasidePointers(VOID)
Definition: lookas.c:59
#define ASSERT(a)
Definition: mode.c:44
#define DBG_STATUS_CONTROL_C
Definition: kdtypes.h:39
NTSYSAPI VOID NTAPI RtlInitNlsTables(_In_ PUSHORT AnsiTableBase, _In_ PUSHORT OemTableBase, _In_ PUSHORT CaseTableBase, _Out_ PNLSTABLEINFO NlsTable)
NTSYSAPI VOID NTAPI RtlResetRtlTranslations(_In_ PNLSTABLEINFO NlsTable)
NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeStringFromAsciiz(_Out_ PUNICODE_STRING Destination, _In_ PCSZ Source)
NTSYSAPI NTSTATUS NTAPI RtlFindMessage(_In_ PVOID BaseAddress, _In_ ULONG Type, _In_ ULONG Language, _In_ ULONG MessageId, _Out_ PMESSAGE_RESOURCE_ENTRY *MessageResourceEntry)
int Count
Definition: noreturn.cpp:7
VOID NTAPI ExpInitializeHandleTables(VOID)
Definition: handle.c:34
VOID NTAPI ExBurnMemory(IN PLOADER_PARAMETER_BLOCK LoaderBlock, IN ULONG_PTR PagesToDestroy, IN TYPE_OF_MEMORY MemoryType)
Definition: init.c:876
ULONG CmNtCSDReleaseType
Definition: init.c:60
PVOID ExpNlsTableBase
Definition: init.c:84
ULONG NTAPI ExComputeTickCountMultiplier(IN ULONG ClockIncrement)
Definition: init.c:605
BOOLEAN IoRemoteBootClient
Definition: init.c:70
UNICODE_STRING NtSystemRoot
Definition: init.c:75
ULONG ExpOemCodePageDataOffset
Definition: init.c:85
NLSTABLEINFO ExpNlsTableInfo
Definition: init.c:87
BOOLEAN NTAPI ExpIsLoaderValid(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: init.c:769
ULONG NtMajorVersion
Definition: init.c:45
ULONG ExpUnicodeCaseTableDataOffset
Definition: init.c:86
BOOLEAN NTAPI MmArmInitSystem(IN ULONG Phase, IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: mminit.c:2046
ULONG NtGlobalFlag
Definition: init.c:54
UNICODE_STRING CmVersionString
Definition: init.c:61
ULONG CmNtSpBuildNumber
Definition: init.c:58
BOOLEAN ExpInTextModeSetup
Definition: init.c:69
ULONG ExpAnsiCodePageDataOffset
Definition: init.c:85
ULONG NtMinorVersion
Definition: init.c:46
VOID NTAPI ExpLoadBootSymbols(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: init.c:795
ULONG CmNtCSDVersion
Definition: init.c:59
VOID NTAPI ExpInitNls(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: init.c:212
UNICODE_STRING CmCSDVersionString
Definition: init.c:62
BOOLEAN NTAPI ExInitSystem(VOID)
Definition: init.c:743
ULONG ExpTickCountMultiplier
Definition: time.c:26
#define MM_HIGHEST_USER_ADDRESS_WOW64
Definition: mm.h:35
#define MM_SYSTEM_RANGE_START_WOW64
Definition: mm.h:36
#define MmSystemRangeStart
Definition: mm.h:32
BOOLEAN NTAPI PpInitSystem(VOID)
Definition: pnpmgr.c:1142
VOID NTAPI KiInitializeBugCheck(VOID)
Definition: bug.c:300
ULONG KiServiceLimit
Definition: krnlinit.c:26
BOOLEAN NTAPI SeInitSystem(VOID)
Main security manager initialization function.
Definition: semgr.c:285
ULONG KeMaximumIncrement
Definition: clock.c:20
NTSTRSAFEVAPI RtlStringCbPrintfA(_Out_writes_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PSTR pszDest, _In_ size_t cbDest, _In_ _Printf_format_string_ NTSTRSAFE_PCSTR pszFormat,...)
Definition: ntstrsafe.h:1148
NTSTRSAFEAPI RtlStringCbCatExA(_Inout_updates_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PSTR pszDest, _In_ size_t cbDest, _In_ NTSTRSAFE_PCSTR pszSrc, _Outptr_opt_result_bytebuffer_(*pcbRemaining) NTSTRSAFE_PSTR *ppszDestEnd, _Out_opt_ size_t *pcbRemaining, _In_ STRSAFE_DWORD dwFlags)
Definition: ntstrsafe.h:718
NTSTRSAFEAPI RtlStringCbCopyExA(_Out_writes_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PSTR pszDest, _In_ size_t cbDest, _In_ NTSTRSAFE_PCSTR pszSrc, _Outptr_opt_result_bytebuffer_(*pcbRemaining) STRSAFE_LPSTR *ppszDestEnd, _Out_opt_ size_t *pcbRemaining, _In_ STRSAFE_DWORD dwFlags)
Definition: ntstrsafe.h:270
#define VER_PRODUCTMAJORVERSION
Definition: ntverp.h:25
#define VER_PRODUCTBUILD_QFE
Definition: ntverp.h:20
#define VER_PRODUCTMINORVERSION
Definition: ntverp.h:26
BOOLEAN NTAPI ObInitSystem(VOID)
Definition: obinit.c:203
unsigned short USHORT
Definition: pedump.c:61
KSERVICE_TABLE_DESCRIPTOR KeServiceDescriptorTable[SSDT_MAX_ENTRIES]
Definition: procobj.c:23
KSERVICE_TABLE_DESCRIPTOR KeServiceDescriptorTableShadow[SSDT_MAX_ENTRIES]
Definition: procobj.c:24
BOOLEAN NTAPI PsInitSystem(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: psmgr.c:532
PVOID MmHighestUserAddress
Definition: rtlcompat.c:29
_Check_return_ _CRTIMP int __cdecl _memicmp(_In_reads_bytes_opt_(_Size) const void *_Buf1, _In_reads_bytes_opt_(_Size) const void *_Buf2, _In_ size_t _Size)
_CRTIMP char *__cdecl _strupr(_Inout_z_ char *_String)
@ LoaderBad
Definition: arc.h:177
#define SharedUserData
#define SETUPLDR_REMOTE_BOOT
Definition: setupblk.h:8
#define SETUPLDR_TEXT_MODE
Definition: setupblk.h:7
Definition: btrfs_drv.h:1876
PVOID DllBase
Definition: btrfs_drv.h:1880
Definition: rtltypes.h:1896
UCHAR Text[ANYSIZE_ARRAY]
Definition: rtltypes.h:1899
PVOID UnicodeCodePageData
Definition: arc.h:325
PVOID AnsiCodePageData
Definition: arc.h:323
PVOID OemCodePageData
Definition: arc.h:324
USHORT MaximumLength
Definition: env_spec_w32.h:370
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
uint32_t ULONG_PTR
Definition: typedefs.h:65
char * PCHAR
Definition: typedefs.h:51
__analysis_noreturn NTSYSAPI VOID NTAPI DbgBreakPointWithStatus(_In_ ULONG Status)

Referenced by KiInitializeKernel().

◆ ExpInitNls()

VOID NTAPI ExpInitNls ( IN PLOADER_PARAMETER_BLOCK  LoaderBlock)

Definition at line 212 of file init.c.

213{
214 LARGE_INTEGER SectionSize;
216 HANDLE NlsSection;
217 PVOID SectionBase = NULL;
218 SIZE_T ViewSize = 0;
219 LARGE_INTEGER SectionOffset = {{0, 0}};
220 PLIST_ENTRY ListHead, NextEntry;
222 ULONG NlsTablesEncountered = 0;
223 SIZE_T NlsTableSizes[3] = {0, 0, 0}; /* 3 NLS tables */
224
225 /* Check if this is boot-time phase 0 initialization */
227 {
228 /* Loop the memory descriptors */
229 ListHead = &LoaderBlock->MemoryDescriptorListHead;
230 NextEntry = ListHead->Flink;
231 while (NextEntry != ListHead)
232 {
233 /* Get the current block */
234 MdBlock = CONTAINING_RECORD(NextEntry,
236 ListEntry);
237
238 /* Check if this is an NLS block */
239 if (MdBlock->MemoryType == LoaderNlsData)
240 {
241 /* Increase the table size */
242 ExpNlsTableSize += MdBlock->PageCount * PAGE_SIZE;
243
244 /* FreeLdr-specific */
245 NlsTableSizes[NlsTablesEncountered] = MdBlock->PageCount * PAGE_SIZE;
246 NlsTablesEncountered++;
247 ASSERT(NlsTablesEncountered < 4);
248 }
249
250 /* Go to the next block */
251 NextEntry = MdBlock->ListEntry.Flink;
252 }
253
254 /* Allocate the a new buffer since loader memory will be freed */
257 TAG_RTLI);
258 if (!ExpNlsTableBase) KeBugCheck(PHASE0_INITIALIZATION_FAILED);
259
260 /* Copy the codepage data in its new location. */
261 if (NlsTablesEncountered == 1)
262 {
263 /* Ntldr-way boot process */
265 LoaderBlock->NlsData->AnsiCodePageData,
267 }
268 else
269 {
270 /*
271 * In NT, the memory blocks are contiguous, but in ReactOS they aren't,
272 * so unless someone fixes FreeLdr, we'll have to use this icky hack.
273 */
275 LoaderBlock->NlsData->AnsiCodePageData,
276 NlsTableSizes[0]);
277
278 RtlCopyMemory((PVOID)((ULONG_PTR)ExpNlsTableBase + NlsTableSizes[0]),
279 LoaderBlock->NlsData->OemCodePageData,
280 NlsTableSizes[1]);
281
282 RtlCopyMemory((PVOID)((ULONG_PTR)ExpNlsTableBase + NlsTableSizes[0] +
283 NlsTableSizes[1]),
284 LoaderBlock->NlsData->UnicodeCodePageData,
285 NlsTableSizes[2]);
286 /* End of Hack */
287 }
288
289 /* Initialize and reset the NLS TAbles */
298 return;
299 }
300
301 /* Set the section size */
302 SectionSize.QuadPart = ExpNlsTableSize;
303
304 /* Create the NLS Section */
305 Status = ZwCreateSection(&NlsSection,
307 NULL,
308 &SectionSize,
310 SEC_COMMIT | 0x1,
311 NULL);
312 if (!NT_SUCCESS(Status))
313 {
314 /* Failed */
315 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 1, 0, 0);
316 }
317
318 /* Get a pointer to the section */
324 NULL);
325 ObCloseHandle(NlsSection, KernelMode);
326 if (!NT_SUCCESS(Status))
327 {
328 /* Failed */
329 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 2, 0, 0);
330 }
331
332 /* Map the NLS Section in system space */
334 &SectionBase,
336 if (!NT_SUCCESS(Status))
337 {
338 /* Failed */
339 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 3, 0, 0);
340 }
341
342 /* Copy the codepage data in its new location. */
343 ASSERT(SectionBase >= MmSystemRangeStart);
345
346 /* Free the previously allocated buffer and set the new location */
348 ExpNlsTableBase = SectionBase;
349
350 /* Initialize the NLS Tables */
359
360 /* Reset the base to 0 */
361 SectionBase = NULL;
362
363 /* Map the section in the system process */
366 &SectionBase,
367 0L,
368 0L,
370 &ViewSize,
371 ViewShare,
372 0L,
374 if (!NT_SUCCESS(Status))
375 {
376 /* Failed */
377 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 5, 0, 0);
378 }
379
380 /* Copy the table into the system process and set this as the base */
382 ExpNlsTableBase = SectionBase;
383}
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID _In_ ULONG_PTR _In_ SIZE_T _Inout_opt_ PLARGE_INTEGER SectionOffset
Definition: mmfuncs.h:407
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID _In_ ULONG_PTR _In_ SIZE_T _Inout_opt_ PLARGE_INTEGER _Inout_ PSIZE_T ViewSize
Definition: mmfuncs.h:408
#define SEC_COMMIT
Definition: mmtypes.h:100
#define PAGE_READWRITE
Definition: nt_native.h:1304
#define SECTION_ALL_ACCESS
Definition: nt_native.h:1293
@ ViewShare
Definition: nt_native.h:1278
SIZE_T ExpNlsTableSize
Definition: init.c:88
PVOID ExpNlsSectionPointer
Definition: init.c:89
NTSTATUS NTAPI ObReferenceObjectByHandle(IN HANDLE Handle, IN ACCESS_MASK DesiredAccess, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, OUT PVOID *Object, OUT POBJECT_HANDLE_INFORMATION HandleInformation OPTIONAL)
Definition: obref.c:494
@ LoaderNlsData
Definition: arc.h:195
NTSTATUS NTAPI MmMapViewInSystemSpace(IN PVOID SectionObject, OUT PVOID *MappedBase, IN OUT PSIZE_T ViewSize)
Definition: section.c:4435
NTSTATUS NTAPI MmMapViewOfSection(IN PVOID SectionObject, IN PEPROCESS Process, IN OUT PVOID *BaseAddress, IN ULONG_PTR ZeroBits, IN SIZE_T CommitSize, IN OUT PLARGE_INTEGER SectionOffset OPTIONAL, IN OUT PSIZE_T ViewSize, IN SECTION_INHERIT InheritDisposition, IN ULONG AllocationType, IN ULONG Protect)
Definition: section.c:3997
POBJECT_TYPE MmSectionObjectType
Definition: section.c:195
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
#define TAG_RTLI
Definition: tag.h:28
ULONG_PTR SIZE_T
Definition: typedefs.h:80
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
LONGLONG QuadPart
Definition: typedefs.h:114
#define PsGetCurrentProcess
Definition: psfuncs.h:17

Referenced by ExpInitializeExecutive(), and Phase1InitializationDiscard().

◆ ExpInitSystemPhase0()

BOOLEAN NTAPI ExpInitSystemPhase0 ( VOID  )

Definition at line 638 of file init.c.

639{
640 /* Initialize EXRESOURCE Support */
642
643 /* Initialize the environment lock */
645
646 /* Initialize the lookaside lists and locks */
648
649 /* Initialize the Firmware Table resource and listhead */
653
654 /* Set the suite mask to maximum and return */
655 ExSuiteMask = 0xFFFFFFFF;
656 return TRUE;
657}
NTSTATUS ExInitializeResourceLite(PULONG res)
Definition: env_spec_w32.h:641
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
VOID ExpInitLookasideLists()
ULONG ExSuiteMask
Definition: init.c:55
VOID NTAPI ExpResourceInitialization(VOID)
Definition: resource.c:169
LIST_ENTRY ExpFirmwareTableProviderListHead
Definition: sysinfo.c:31
FAST_MUTEX ExpEnvironmentLock
Definition: sysinfo.c:29
ERESOURCE ExpFirmwareTableResource
Definition: sysinfo.c:30
ERESOURCE ExpTimeRefreshLock
Definition: time.c:27
FORCEINLINE VOID ExInitializeFastMutex(_Out_ PFAST_MUTEX FastMutex)
Definition: exfuncs.h:274

Referenced by ExInitSystem().

◆ ExpInitSystemPhase1()

BOOLEAN NTAPI ExpInitSystemPhase1 ( VOID  )

Definition at line 662 of file init.c.

663{
664 /* Initialize worker threads */
666
667 /* Initialize pushlocks */
669
670 /* Initialize events and event pairs */
672 {
673 DPRINT1("Executive: Event initialization failed\n");
674 return FALSE;
675 }
677 {
678 DPRINT1("Executive: Event Pair initialization failed\n");
679 return FALSE;
680 }
681
682 /* Initialize mutants */
684 {
685 DPRINT1("Executive: Mutant initialization failed\n");
686 return FALSE;
687 }
688
689 /* Initialize callbacks */
691 {
692 DPRINT1("Executive: Callback initialization failed\n");
693 return FALSE;
694 }
695
696 /* Initialize semaphores */
698 {
699 DPRINT1("Executive: Semaphore initialization failed\n");
700 return FALSE;
701 }
702
703 /* Initialize timers */
705 {
706 DPRINT1("Executive: Timer initialization failed\n");
707 return FALSE;
708 }
709
710 /* Initialize profiling */
712 {
713 DPRINT1("Executive: Profile initialization failed\n");
714 return FALSE;
715 }
716
717 /* Initialize UUIDs */
719 {
720 DPRINT1("Executive: Uuid initialization failed\n");
721 return FALSE;
722 }
723
724 /* Initialize keyed events */
726 {
727 DPRINT1("Executive: Keyed event initialization failed\n");
728 return FALSE;
729 }
730
731 /* Initialize Win32K */
732 if (ExpWin32kInit() == FALSE)
733 {
734 DPRINT1("Executive: Win32 initialization failed\n");
735 return FALSE;
736 }
737 return TRUE;
738}
BOOLEAN NTAPI ExpInitializeEventPairImplementation(VOID)
Definition: evtpair.c:33
BOOLEAN NTAPI ExpInitializeKeyedEventImplementation(VOID)
BOOLEAN NTAPI ExpInitializeMutantImplementation(VOID)
Definition: mutant.c:52
BOOLEAN NTAPI ExpInitializeCallbacks(VOID)
Definition: callback.c:256
BOOLEAN NTAPI ExpInitializeEventImplementation(VOID)
Definition: event.c:39
BOOLEAN NTAPI ExpInitializeProfileImplementation(VOID)
Definition: profile.c:62
BOOLEAN NTAPI ExpInitializeTimerImplementation(VOID)
Definition: timer.c:223
BOOLEAN NTAPI ExpUuidInitialization(VOID)
Definition: uuid.c:53
VOID NTAPI ExpInitializePushLocks(VOID)
Definition: pushlock.c:45
BOOLEAN NTAPI ExpInitializeSemaphoreImplementation(VOID)
Definition: sem.c:43
BOOLEAN NTAPI ExpWin32kInit(VOID)
Definition: win32k.c:259
VOID NTAPI ExpInitializeWorkerThreads(VOID)
Definition: work.c:522

Referenced by ExInitSystem().

◆ ExpIsLoaderValid()

BOOLEAN NTAPI ExpIsLoaderValid ( IN PLOADER_PARAMETER_BLOCK  LoaderBlock)

Definition at line 769 of file init.c.

770{
772
773 /* Get the loader extension */
774 Extension = LoaderBlock->Extension;
775
776 /* Validate the size (Windows 2003 loader doesn't provide more) */
778
779 /* Don't validate upper versions */
780 if (Extension->MajorVersion > VER_PRODUCTMAJORVERSION) return TRUE;
781
782 /* Fail if this is NT 4 */
783 if (Extension->MajorVersion < VER_PRODUCTMAJORVERSION) return FALSE;
784
785 /* Fail if this is XP */
786 if (Extension->MinorVersion < VER_PRODUCTMINORVERSION) return FALSE;
787
788 /* This is 2003 or newer, approve it */
789 return TRUE;
790}
_Inout_opt_ PUNICODE_STRING Extension
Definition: fltkernel.h:1092
#define LOADER_PARAMETER_EXTENSION_MIN_SIZE
Definition: init.c:20

Referenced by ExpInitializeExecutive().

◆ ExpLoadBootSymbols()

VOID NTAPI ExpLoadBootSymbols ( IN PLOADER_PARAMETER_BLOCK  LoaderBlock)

Definition at line 795 of file init.c.

796{
797 ULONG i = 0;
798 PLIST_ENTRY NextEntry;
800 PWCHAR Name;
801 PLDR_DATA_TABLE_ENTRY LdrEntry;
802 CHAR NameBuffer[256];
803 STRING SymbolString;
805
806 /* Loop the driver list */
807 NextEntry = LoaderBlock->LoadOrderListHead.Flink;
808 while (NextEntry != &LoaderBlock->LoadOrderListHead)
809 {
810 /* Skip the first two images */
811 if (i >= 2)
812 {
813 /* Get the entry */
814 LdrEntry = CONTAINING_RECORD(NextEntry,
816 InLoadOrderLinks);
817 if (LdrEntry->FullDllName.Buffer[0] == L'\\')
818 {
819 /* We have a name, read its data */
820 Name = LdrEntry->FullDllName.Buffer;
821 Length = LdrEntry->FullDllName.Length / sizeof(WCHAR);
822
823 /* Check if our buffer can hold it */
824 if (sizeof(NameBuffer) < Length + sizeof(ANSI_NULL))
825 {
826 /* It's too long */
828 }
829 else
830 {
831 /* Copy the name */
832 Count = 0;
833 do
834 {
835 /* Copy the character */
836 NameBuffer[Count++] = (CHAR)*Name++;
837 } while (Count < Length);
838
839 /* Null-terminate */
840 NameBuffer[Count] = ANSI_NULL;
842 }
843 }
844 else
845 {
846 /* Safely print the string into our buffer */
847 Status = RtlStringCbPrintfA(NameBuffer,
848 sizeof(NameBuffer),
849 "%S\\System32\\Drivers\\%wZ",
850 &SharedUserData->NtSystemRoot[2],
851 &LdrEntry->BaseDllName);
852 }
853
854 /* Check if the buffer was ok */
855 if (NT_SUCCESS(Status))
856 {
857 /* Initialize the STRING for the debugger */
858 RtlInitString(&SymbolString, NameBuffer);
859
860 /* Load the symbols */
861 DbgLoadImageSymbols(&SymbolString,
862 LdrEntry->DllBase,
864 }
865 }
866
867 /* Go to the next entry */
868 i++;
869 NextEntry = NextEntry->Flink;
870 }
871}
struct NameRec_ * Name
Definition: cdprocs.h:460
#define CHAR(Char)
std::wstring STRING
Definition: fontsub.cpp:33
VOID NTAPI DbgLoadImageSymbols(_In_ PSTRING Name, _In_ PVOID Base, _In_ ULONG_PTR ProcessId)
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
HANDLE NTAPI PsGetCurrentProcessId(VOID)
Definition: process.c:1123
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:66
UNICODE_STRING FullDllName
Definition: btrfs_drv.h:1882
UNICODE_STRING BaseDllName
Definition: ldrtypes.h:145
uint16_t * PWCHAR
Definition: typedefs.h:56
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by ExpInitializeExecutive().

◆ ExpLoadInitialProcess()

VOID NTAPI ExpLoadInitialProcess ( IN PINIT_BUFFER  InitBuffer,
OUT PRTL_USER_PROCESS_PARAMETERS ProcessParameters,
OUT PCHAR ProcessEnvironment 
)

Definition at line 388 of file init.c.

391{
393 SIZE_T Size;
394 PWSTR p;
395 UNICODE_STRING NullString = RTL_CONSTANT_STRING(L"");
396 UNICODE_STRING SmssName, Environment, SystemDriveString, DebugString;
397 PVOID EnvironmentPtr = NULL;
398 PRTL_USER_PROCESS_INFORMATION ProcessInformation;
399 PRTL_USER_PROCESS_PARAMETERS ProcessParams = NULL;
400
401 NullString.Length = sizeof(WCHAR);
402
403 /* Use the initial buffer, after the strings */
404 ProcessInformation = &InitBuffer->ProcessInfo;
405
406 /* Allocate memory for the process parameters */
407 Size = sizeof(*ProcessParams) + ((MAX_WIN32_PATH * 6) * sizeof(WCHAR));
408 Status = ZwAllocateVirtualMemory(NtCurrentProcess(),
409 (PVOID*)&ProcessParams,
410 0,
411 &Size,
414 if (!NT_SUCCESS(Status))
415 {
416 /* Failed, display error */
417 _snwprintf(InitBuffer->DebugBuffer,
418 sizeof(InitBuffer->DebugBuffer)/sizeof(WCHAR),
419 L"INIT: Unable to allocate Process Parameters. 0x%lx",
420 Status);
421 RtlInitUnicodeString(&DebugString, InitBuffer->DebugBuffer);
423
424 /* Bugcheck the system */
425 KeBugCheckEx(SESSION1_INITIALIZATION_FAILED, Status, 0, 0, 0);
426 }
427
428 /* Setup the basic header, and give the process the low 1MB to itself */
429 ProcessParams->Length = (ULONG)Size;
430 ProcessParams->MaximumLength = (ULONG)Size;
433
434 /* Allocate a page for the environment */
435 Size = PAGE_SIZE;
436 Status = ZwAllocateVirtualMemory(NtCurrentProcess(),
437 &EnvironmentPtr,
438 0,
439 &Size,
442 if (!NT_SUCCESS(Status))
443 {
444 /* Failed, display error */
445 _snwprintf(InitBuffer->DebugBuffer,
446 sizeof(InitBuffer->DebugBuffer)/sizeof(WCHAR),
447 L"INIT: Unable to allocate Process Environment. 0x%lx",
448 Status);
449 RtlInitUnicodeString(&DebugString, InitBuffer->DebugBuffer);
451
452 /* Bugcheck the system */
453 KeBugCheckEx(SESSION2_INITIALIZATION_FAILED, Status, 0, 0, 0);
454 }
455
456 /* Write the pointer */
457 ProcessParams->Environment = EnvironmentPtr;
458
459 /* Make a buffer for the DOS path */
460 p = (PWSTR)(ProcessParams + 1);
461 ProcessParams->CurrentDirectory.DosPath.Buffer = p;
463 sizeof(WCHAR);
464
465 /* Copy the DOS path */
467 &NtSystemRoot);
468
469 /* Make a buffer for the DLL Path */
470 p = (PWSTR)((PCHAR)ProcessParams->CurrentDirectory.DosPath.Buffer +
471 ProcessParams->CurrentDirectory.DosPath.MaximumLength);
472 ProcessParams->DllPath.Buffer = p;
473 ProcessParams->DllPath.MaximumLength = MAX_WIN32_PATH * sizeof(WCHAR);
474
475 /* Copy the DLL path and append the system32 directory */
476 RtlCopyUnicodeString(&ProcessParams->DllPath,
477 &ProcessParams->CurrentDirectory.DosPath);
478 RtlAppendUnicodeToString(&ProcessParams->DllPath, L"\\System32");
479
480 /* Make a buffer for the image name */
481 p = (PWSTR)((PCHAR)ProcessParams->DllPath.Buffer +
482 ProcessParams->DllPath.MaximumLength);
483 ProcessParams->ImagePathName.Buffer = p;
484 ProcessParams->ImagePathName.MaximumLength = MAX_WIN32_PATH * sizeof(WCHAR);
485
486 /* Make sure the buffer is a valid string which within the given length */
491 sizeof(NtInitialUserProcessBuffer) - sizeof(WCHAR)))))
492 {
493 /* Invalid initial process string, bugcheck */
494 KeBugCheckEx(SESSION2_INITIALIZATION_FAILED,
499 }
500
501 /* Cut out anything after a space */
503 while ((*p) && (*p != L' ')) p++;
504
505 /* Set the image path length */
506 ProcessParams->ImagePathName.Length =
508
509 /* Copy the actual buffer */
510 RtlCopyMemory(ProcessParams->ImagePathName.Buffer,
512 ProcessParams->ImagePathName.Length);
513
514 /* Null-terminate it */
515 ProcessParams->ImagePathName.Buffer[ProcessParams->ImagePathName.Length /
516 sizeof(WCHAR)] = UNICODE_NULL;
517
518 /* Make a buffer for the command line */
519 p = (PWSTR)((PCHAR)ProcessParams->ImagePathName.Buffer +
520 ProcessParams->ImagePathName.MaximumLength);
521 ProcessParams->CommandLine.Buffer = p;
522 ProcessParams->CommandLine.MaximumLength = MAX_WIN32_PATH * sizeof(WCHAR);
523
524 /* Add the image name to the command line */
527
528 /* Create the environment string */
529 RtlInitEmptyUnicodeString(&Environment,
530 ProcessParams->Environment,
531 (USHORT)Size);
532
533 /* Append the DLL path to it */
537
538 /* Create the system drive string */
539 SystemDriveString = NtSystemRoot;
540 SystemDriveString.Length = 2 * sizeof(WCHAR);
541
542 /* Append it to the environment */
543 RtlAppendUnicodeToString(&Environment, L"SystemDrive=");
544 RtlAppendUnicodeStringToString(&Environment, &SystemDriveString);
546
547 /* Append the system root to the environment */
548 RtlAppendUnicodeToString(&Environment, L"SystemRoot=");
551
552 /* Prepare the prefetcher */
553 //CcPfBeginBootPhase(150);
554
555 /* Create SMSS process */
556 SmssName = ProcessParams->ImagePathName;
557 Status = RtlCreateUserProcess(&SmssName,
559 RtlDeNormalizeProcessParams(ProcessParams),
560 NULL,
561 NULL,
562 NULL,
563 FALSE,
564 NULL,
565 NULL,
566 ProcessInformation);
567 if (!NT_SUCCESS(Status))
568 {
569 /* Failed, display error */
570 _snwprintf(InitBuffer->DebugBuffer,
571 sizeof(InitBuffer->DebugBuffer)/sizeof(WCHAR),
572 L"INIT: Unable to create Session Manager. 0x%lx",
573 Status);
574 RtlInitUnicodeString(&DebugString, InitBuffer->DebugBuffer);
576
577 /* Bugcheck the system */
578 KeBugCheckEx(SESSION3_INITIALIZATION_FAILED, Status, 0, 0, 0);
579 }
580
581 /* Resume the thread */
582 Status = ZwResumeThread(ProcessInformation->ThreadHandle, NULL);
583 if (!NT_SUCCESS(Status))
584 {
585 /* Failed, display error */
586 _snwprintf(InitBuffer->DebugBuffer,
587 sizeof(InitBuffer->DebugBuffer)/sizeof(WCHAR),
588 L"INIT: Unable to resume Session Manager. 0x%lx",
589 Status);
590 RtlInitUnicodeString(&DebugString, InitBuffer->DebugBuffer);
592
593 /* Bugcheck the system */
594 KeBugCheckEx(SESSION4_INITIALIZATION_FAILED, Status, 0, 0, 0);
595 }
596
597 /* Return success */
598 *ProcessParameters = ProcessParams;
599 *ProcessEnvironment = EnvironmentPtr;
600}
CCHAR DebugString[256]
Definition: cmdline.c:22
NTSTATUS RtlAppendUnicodeToString(IN PUNICODE_STRING Str1, IN PWSTR Str2)
Definition: string_lib.cpp:62
GLfloat GLfloat p
Definition: glext.h:8902
#define REG_SZ
Definition: layer.c:22
#define PCHAR
Definition: match.c:90
int _snwprintf(wchar_t *buffer, size_t count, const wchar_t *format,...)
PVOID PVOID PWCHAR PVOID Environment
Definition: env.c:47
NTSYSAPI NTSTATUS NTAPI ZwDisplayString(_In_ PUNICODE_STRING DisplayString)
NTSYSAPI NTSTATUS NTAPI ZwResumeThread(_In_ HANDLE ThreadHandle, _Out_opt_ PULONG SuspendCount)
NTSYSAPI NTSTATUS NTAPI RtlCreateUserProcess(_In_ PUNICODE_STRING ImageFileName, _In_ ULONG Attributes, _In_ PRTL_USER_PROCESS_PARAMETERS ProcessParameters, _In_opt_ PSECURITY_DESCRIPTOR ProcessSecutityDescriptor, _In_opt_ PSECURITY_DESCRIPTOR ThreadSecurityDescriptor, _In_opt_ HANDLE ParentProcess, _In_ BOOLEAN CurrentDirectory, _In_opt_ HANDLE DebugPort, _In_opt_ HANDLE ExceptionPort, _Out_ PRTL_USER_PROCESS_INFORMATION ProcessInfo)
NTSYSAPI PRTL_USER_PROCESS_PARAMETERS NTAPI RtlDeNormalizeProcessParams(_In_ PRTL_USER_PROCESS_PARAMETERS ProcessParameters)
#define RTL_USER_PROCESS_PARAMETERS_RESERVE_1MB
Definition: rtltypes.h:46
#define RTL_USER_PROCESS_PARAMETERS_NORMALIZED
Definition: rtltypes.h:41
NTSYSAPI VOID NTAPI RtlCopyUnicodeString(PUNICODE_STRING DestinationString, PUNICODE_STRING SourceString)
NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeStringToString(PUNICODE_STRING Destination, PUNICODE_STRING Source)
#define NtCurrentProcess()
Definition: nt_native.h:1657
#define MEM_RESERVE
Definition: nt_native.h:1314
#define MEM_COMMIT
Definition: nt_native.h:1313
#define UNICODE_NULL
WCHAR NtInitialUserProcessBuffer[128]
Definition: init.c:78
ULONG NtInitialUserProcessBufferType
Definition: init.c:81
ULONG NtInitialUserProcessBufferLength
Definition: init.c:79
#define MAX_WIN32_PATH
Definition: ntoskrnl.h:125
UNICODE_STRING DosPath
Definition: rtltypes.h:1368
UNICODE_STRING CommandLine
Definition: btrfs_drv.h:1902
UNICODE_STRING ImagePathName
Definition: btrfs_drv.h:1901
#define RTL_CONSTANT_STRING(s)
Definition: tunneltest.c:14
uint16_t * PWSTR
Definition: typedefs.h:56
#define MAXULONG
Definition: typedefs.h:251
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533

Referenced by Phase1InitializationDiscard().

◆ MmArmInitSystem()

BOOLEAN NTAPI MmArmInitSystem ( IN ULONG  Phase,
IN PLOADER_PARAMETER_BLOCK  LoaderBlock 
)

Definition at line 2046 of file mminit.c.

2048{
2049 ULONG i;
2050 BOOLEAN IncludeType[LoaderMaximum];
2051 PVOID Bitmap;
2053 PFN_NUMBER PageCount;
2054#if DBG
2055 ULONG j;
2056 PMMPTE PointerPte, TestPte;
2057 MMPTE TempPte;
2058#endif
2059
2060 /* Dump memory descriptors */
2062
2063 //
2064 // Instantiate memory that we don't consider RAM/usable
2065 // We use the same exclusions that Windows does, in order to try to be
2066 // compatible with WinLDR-style booting
2067 //
2068 for (i = 0; i < LoaderMaximum; i++) IncludeType[i] = TRUE;
2069 IncludeType[LoaderBad] = FALSE;
2070 IncludeType[LoaderFirmwarePermanent] = FALSE;
2071 IncludeType[LoaderSpecialMemory] = FALSE;
2072 IncludeType[LoaderBBTMemory] = FALSE;
2073 if (Phase == 0)
2074 {
2075 /* Count physical pages on the system */
2076 MiScanMemoryDescriptors(LoaderBlock);
2077
2078 /* Initialize the phase 0 temporary event */
2080
2081 /* Set all the events to use the temporary event for now */
2088
2089 //
2090 // Default throttling limits for Cc
2091 // May be ajusted later on depending on system type
2092 //
2093 MmThrottleTop = 450;
2094 MmThrottleBottom = 127;
2095
2096 //
2097 // Define the basic user vs. kernel address space separation
2098 //
2102
2103 /* Highest PTE and PDE based on the addresses above */
2106#if (_MI_PAGING_LEVELS >= 3)
2107 MiHighestUserPpe = MiAddressToPpe(MmHighestUserAddress);
2108#if (_MI_PAGING_LEVELS >= 4)
2109 MiHighestUserPxe = MiAddressToPxe(MmHighestUserAddress);
2110#endif
2111#endif
2112 //
2113 // Get the size of the boot loader's image allocations and then round
2114 // that region up to a PDE size, so that any PDEs we might create for
2115 // whatever follows are separate from the PDEs that boot loader might've
2116 // already created (and later, we can blow all that away if we want to).
2117 //
2122
2123 /* Initialize session space address layout */
2125
2126 /* Set the based section highest address */
2128
2129 /* Loop all 8 standby lists */
2130 for (i = 0; i < 8; i++)
2131 {
2132 /* Initialize them */
2137 }
2138
2139 /* Initialize the user mode image list */
2141
2142 /* Initalize the Working set list */
2144
2145 /* Initialize critical section timeout value (relative time is negative) */
2147
2148 /* Initialize the paged pool mutex and the section commit mutex */
2152
2153 /* Initialize the Loader Lock */
2155
2156 /* Set up the zero page event */
2158
2159 /* Initialize the dead stack S-LIST */
2161
2162 //
2163 // Check if this is a machine with less than 19MB of RAM
2164 //
2165 PageCount = MmNumberOfPhysicalPages;
2166 if (PageCount < MI_MIN_PAGES_FOR_SYSPTE_TUNING)
2167 {
2168 //
2169 // Use the very minimum of system PTEs
2170 //
2171 MmNumberOfSystemPtes = 7000;
2172 }
2173 else
2174 {
2175 //
2176 // Use the default
2177 //
2178 MmNumberOfSystemPtes = 11000;
2179 if (PageCount > MI_MIN_PAGES_FOR_SYSPTE_BOOST)
2180 {
2181 //
2182 // Double the amount of system PTEs
2183 //
2185 }
2187 {
2188 //
2189 // Double the amount of system PTEs
2190 //
2192 }
2193 if (MmSpecialPoolTag != 0 && MmSpecialPoolTag != -1)
2194 {
2195 //
2196 // Add some extra PTEs for special pool
2197 //
2198 MmNumberOfSystemPtes += 0x6000;
2199 }
2200 }
2201
2202 DPRINT("System PTE count has been tuned to %lu (%lu bytes)\n",
2204
2205 /* Check if no values are set for the heap limits */
2206 if (MmHeapSegmentReserve == 0)
2207 {
2209 }
2210
2211 if (MmHeapSegmentCommit == 0)
2212 {
2214 }
2215
2217 {
2219 }
2220
2222 {
2224 }
2225
2226 /* Initialize the working set lock */
2228
2229 /* Set commit limit */
2232
2233 /* Has the allocation fragment been setup? */
2235 {
2236 /* Use the default value */
2238 if (PageCount < ((256 * _1MB) / PAGE_SIZE))
2239 {
2240 /* On memory systems with less than 256MB, divide by 4 */
2242 }
2243 else if (PageCount < (_1GB / PAGE_SIZE))
2244 {
2245 /* On systems with less than 1GB, divide by 2 */
2247 }
2248 }
2249 else
2250 {
2251 /* Convert from 1KB fragments to pages */
2254
2255 /* Don't let it past the maximum */
2258
2259 /* Don't let it too small either */
2262 }
2263
2264 /* Check for kernel stack size that's too big */
2266 {
2267 /* Sanitize to default value */
2269 }
2270 else
2271 {
2272 /* Take the registry setting, and convert it into bytes */
2274
2275 /* Now align it to a page boundary */
2277
2278 /* Sanity checks */
2280 ASSERT((MmLargeStackSize & (PAGE_SIZE - 1)) == 0);
2281
2282 /* Make sure it's not too low */
2284 }
2285
2286 /* Compute color information (L2 cache-separated paging lists) */
2288
2289 // Calculate the number of bytes for the PFN database
2290 // then add the color tables and convert to pages
2294
2295 // We have to add one to the count here, because in the process of
2296 // shifting down to the page size, we actually ended up getting the
2297 // lower aligned size (so say, 0x5FFFF bytes is now 0x5F pages).
2298 // Later on, we'll shift this number back into bytes, which would cause
2299 // us to end up with only 0x5F000 bytes -- when we actually want to have
2300 // 0x60000 bytes.
2302
2303 /* Initialize the platform-specific parts */
2304 MiInitMachineDependent(LoaderBlock);
2305
2306#if DBG
2307 /* Prototype PTEs are assumed to be in paged pool, so check if the math works */
2308 PointerPte = (PMMPTE)MmPagedPoolStart;
2309 MI_MAKE_PROTOTYPE_PTE(&TempPte, PointerPte);
2310 TestPte = MiProtoPteToPte(&TempPte);
2311 ASSERT(PointerPte == TestPte);
2312
2313 /* Try the last nonpaged pool address */
2314 PointerPte = (PMMPTE)MI_NONPAGED_POOL_END;
2315 MI_MAKE_PROTOTYPE_PTE(&TempPte, PointerPte);
2316 TestPte = MiProtoPteToPte(&TempPte);
2317 ASSERT(PointerPte == TestPte);
2318
2319 /* Try a bunch of random addresses near the end of the address space */
2320 PointerPte = (PMMPTE)((ULONG_PTR)MI_HIGHEST_SYSTEM_ADDRESS - 0x37FFF);
2321 for (j = 0; j < 20; j += 1)
2322 {
2323 MI_MAKE_PROTOTYPE_PTE(&TempPte, PointerPte);
2324 TestPte = MiProtoPteToPte(&TempPte);
2325 ASSERT(PointerPte == TestPte);
2326 PointerPte++;
2327 }
2328
2329 /* Subsection PTEs are always in nonpaged pool, pick a random address to try */
2331 MI_MAKE_SUBSECTION_PTE(&TempPte, PointerPte);
2333 ASSERT(PointerPte == TestPte);
2334#endif
2335
2336 //
2337 // Build the physical memory block
2338 //
2340 IncludeType);
2341
2342 //
2343 // Allocate enough buffer for the PFN bitmap
2344 // Align it up to a 32-bit boundary
2345 //
2347 (((MmHighestPhysicalPage + 1) + 31) / 32) * 4,
2348 TAG_MM);
2349 if (!Bitmap)
2350 {
2351 //
2352 // This is critical
2353 //
2354 KeBugCheckEx(INSTALL_MORE_MEMORY,
2358 0x101);
2359 }
2360
2361 //
2362 // Initialize it and clear all the bits to begin with
2363 //
2365 Bitmap,
2368
2369 //
2370 // Loop physical memory runs
2371 //
2372 for (i = 0; i < MmPhysicalMemoryBlock->NumberOfRuns; i++)
2373 {
2374 //
2375 // Get the run
2376 //
2378 DPRINT("PHYSICAL RAM [0x%08p to 0x%08p]\n",
2379 Run->BasePage << PAGE_SHIFT,
2380 (Run->BasePage + Run->PageCount) << PAGE_SHIFT);
2381
2382 //
2383 // Make sure it has pages inside it
2384 //
2385 if (Run->PageCount)
2386 {
2387 //
2388 // Set the bits in the PFN bitmap
2389 //
2390 RtlSetBits(&MiPfnBitMap, (ULONG)Run->BasePage, (ULONG)Run->PageCount);
2391 }
2392 }
2393
2394 /* Look for large page cache entries that need caching */
2396
2397 /* Loop for HAL Heap I/O device mappings that need coherency tracking */
2399
2400 /* Set the initial resident page count */
2402
2403 /* Initialize large page structures on PAE/x64, and MmProcessList on x86 */
2405
2406 /* Check if the registry says any drivers should be loaded with large pages */
2408
2409 /* Relocate the boot drivers into system PTE space and fixup their PFNs */
2410 MiReloadBootLoadedDrivers(LoaderBlock);
2411
2412 /* FIXME: Call out into Driver Verifier for initialization */
2413
2414 /* Check how many pages the system has */
2415 if (MmNumberOfPhysicalPages <= ((13 * _1MB) / PAGE_SIZE))
2416 {
2417 /* Set small system */
2420 }
2421 else if (MmNumberOfPhysicalPages <= ((19 * _1MB) / PAGE_SIZE))
2422 {
2423 /* Set small system and add 100 pages for the cache */
2427 }
2428 else
2429 {
2430 /* Set medium system and add 400 pages for the cache */
2434 }
2435
2436 /* Check for less than 24MB */
2437 if (MmNumberOfPhysicalPages < ((24 * _1MB) / PAGE_SIZE))
2438 {
2439 /* No more than 32 pages */
2441 }
2442
2443 /* Check for more than 32MB */
2444 if (MmNumberOfPhysicalPages >= ((32 * _1MB) / PAGE_SIZE))
2445 {
2446 /* Check for product type being "Wi" for WinNT */
2447 if (MmProductType == '\0i\0W')
2448 {
2449 /* Then this is a large system */
2451 }
2452 else
2453 {
2454 /* For servers, we need 64MB to consider this as being large */
2455 if (MmNumberOfPhysicalPages >= ((64 * _1MB) / PAGE_SIZE))
2456 {
2457 /* Set it as large */
2459 }
2460 }
2461 }
2462
2463 /* Check for more than 33 MB */
2464 if (MmNumberOfPhysicalPages > ((33 * _1MB) / PAGE_SIZE))
2465 {
2466 /* Add another 500 pages to the cache */
2468 }
2469
2470 /* Now setup the shared user data fields */
2471 ASSERT(SharedUserData->NumberOfPhysicalPages == 0);
2472 SharedUserData->NumberOfPhysicalPages = MmNumberOfPhysicalPages;
2473 SharedUserData->LargePageMinimum = 0;
2474
2475 /* Check for workstation (Wi for WinNT) */
2476 if (MmProductType == '\0i\0W')
2477 {
2478 /* Set Windows NT Workstation product type */
2479 SharedUserData->NtProductType = NtProductWinNt;
2480 MmProductType = 0;
2481
2482 /* For this product, we wait till the last moment to throttle */
2483 MmThrottleTop = 250;
2484 MmThrottleBottom = 30;
2485 }
2486 else
2487 {
2488 /* Check for LanMan server (La for LanmanNT) */
2489 if (MmProductType == '\0a\0L')
2490 {
2491 /* This is a domain controller */
2492 SharedUserData->NtProductType = NtProductLanManNt;
2493 }
2494 else
2495 {
2496 /* Otherwise it must be a normal server (Se for ServerNT) */
2497 SharedUserData->NtProductType = NtProductServer;
2498 }
2499
2500 /* Set the product type, and make the system more aggressive with low memory */
2501 MmProductType = 1;
2502 MmMinimumFreePages = 81;
2503
2504 /* We will throttle earlier to preserve memory */
2505 MmThrottleTop = 450;
2506 MmThrottleBottom = 80;
2507 }
2508
2509 /* Update working set tuning parameters */
2511
2512 /* Finetune the page count by removing working set and NP expansion */
2516 if (MmResidentAvailablePages <= 0)
2517 {
2518 /* This should not happen */
2519 DPRINT1("System cache working set too big\n");
2520 return FALSE;
2521 }
2522
2523 /* Define limits for system cache */
2524#ifdef _M_AMD64
2526#else
2528#endif
2530#ifdef _M_AMD64
2532#else
2534#endif
2535
2536 /* Initialize the system cache */
2537 //MiInitializeSystemCache(MmSystemCacheWsMinimum, MmAvailablePages);
2538
2539 /* Update the commit limit */
2541 if (MmTotalCommitLimit > 1024) MmTotalCommitLimit -= 1024;
2543
2544 /* Size up paged pool and build the shadow system page directory */
2546
2547 /* Debugger physical memory support is now ready to be used */
2549
2550 /* Initialize the loaded module list */
2551 MiInitializeLoadedModuleList(LoaderBlock);
2552 }
2553
2554 //
2555 // Always return success for now
2556 //
2557 return TRUE;
2558}
SIZE_T MmHeapSegmentReserve
Definition: mminit.c:366
PMMPTE MiHighestUserPte
Definition: mminit.c:233
PFN_NUMBER MmSystemCacheWsMinimum
Definition: mminit.c:336
SIZE_T MmHeapDeCommitFreeBlockThreshold
Definition: mminit.c:369
SIZE_T MmTotalCommitLimitMaximum
Definition: mminit.c:360
PVOID MmPagedPoolStart
Definition: mminit.c:104
SIZE_T MmTotalCommitLimit
Definition: mminit.c:359
MM_SYSTEMSIZE MmSystemSize
Definition: mminit.c:326
SIZE_T MmBootImageSize
Definition: mminit.c:222
PVOID MmSystemRangeStart
Definition: mminit.c:230
PMMPDE MiHighestUserPde
Definition: mminit.c:234
SIZE_T MmHeapDeCommitTotalFreeThreshold
Definition: mminit.c:368
PFN_COUNT MmNumberOfPhysicalPages
Definition: mminit.c:212
ULONG MmThrottleTop
Definition: mminit.c:396
PFN_NUMBER MmMinimumFreePages
Definition: mminit.c:314
SIZE_T MmSizeOfNonPagedPoolInBytes
Definition: mminit.c:26
KEVENT MiTempEvent
Definition: mminit.c:289
ULONG MmSecondaryColors
Definition: mminit.c:256
VOID NTAPI MiAdjustWorkingSetManagerParameters(IN BOOLEAN Client)
Definition: mminit.c:1203
VOID NTAPI MiBuildPagedPool(VOID)
Definition: mminit.c:1751
VOID NTAPI MiScanMemoryDescriptors(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: mminit.c:403
VOID NTAPI MiAddHalIoMappings(VOID)
Definition: mminit.c:1418
VOID NTAPI MiDbgDumpMemoryDescriptors(VOID)
Definition: mminit.c:1994
PFN_NUMBER MmLowestPhysicalPage
Definition: mminit.c:211
PKEVENT MiLowNonPagedPoolEvent
Definition: mminit.c:296
PKEVENT MiHighMemoryEvent
Definition: mminit.c:293
PKEVENT MiLowMemoryEvent
Definition: mminit.c:292
ULONG MmProductType
Definition: mminit.c:325
PPHYSICAL_MEMORY_DESCRIPTOR NTAPI MmInitializeMemoryLimits(IN PLOADER_PARAMETER_BLOCK LoaderBlock, IN PBOOLEAN IncludeType)
Definition: mminit.c:1622
PFN_NUMBER MmHighestPhysicalPage
Definition: mminit.c:211
ULONG_PTR MmSizeOfSystemCacheInPages
Definition: mminit.c:245
ULONG_PTR MmUserProbeAddress
Definition: mminit.c:228
RTL_BITMAP MiPfnBitMap
Definition: mminit.c:201
MMSUPPORT MmSystemCacheWs
Definition: mminit.c:246
ULONG MmLargeStackSize
Definition: mminit.c:262
VOID NTAPI MiComputeColorInformation(VOID)
Definition: mminit.c:508
PKEVENT MiHighPagedPoolEvent
Definition: mminit.c:295
PFN_NUMBER MxPfnAllocation
Definition: mminit.c:187
ULONG MmThrottleBottom
Definition: mminit.c:397
PVOID MmNonPagedPoolStart
Definition: mminit.c:97
BOOLEAN MiDbgEnableMdDump
Definition: mminit.c:373
SIZE_T MmHeapSegmentCommit
Definition: mminit.c:367
SIZE_T MmAllocationFragment
Definition: mminit.c:352
PKEVENT MiLowPagedPoolEvent
Definition: mminit.c:294
LARGE_INTEGER MmCriticalSectionTimeout
Definition: mminit.c:388
PFN_COUNT MmNumberOfSystemPtes
Definition: mminit.c:181
PPHYSICAL_MEMORY_DESCRIPTOR MmPhysicalMemoryBlock
Definition: mminit.c:206
PVOID MmSystemCacheStart
Definition: mminit.c:243
PVOID MmSystemCacheEnd
Definition: mminit.c:244
PKEVENT MiHighNonPagedPoolEvent
Definition: mminit.c:297
PVOID MmHighestUserAddress
Definition: mminit.c:229
ULONG MmCritsectTimeoutSeconds
Definition: mminit.c:387
unsigned char BOOLEAN
HARDWARE_PTE_ARMV6 TempPte
Definition: winldr.c:76
@ NtProductWinNt
Definition: shellpath.c:64
@ NtProductLanManNt
Definition: shellpath.c:65
@ NtProductServer
Definition: shellpath.c:66
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
#define PAGE_SHIFT
Definition: env_spec_w32.h:45
#define ExInitializePushLock
Definition: ex.h:1012
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
VOID FASTCALL KeInitializeGuardedMutex(OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:31
NTSYSAPI void WINAPI RtlInitializeBitMap(PRTL_BITMAP, PULONG, ULONG)
NTSYSAPI void WINAPI RtlClearAllBits(PRTL_BITMAP)
NTSYSAPI void WINAPI RtlSetBits(PRTL_BITMAP, ULONG, ULONG)
PLOADER_PARAMETER_BLOCK KeLoaderBlock
Definition: krnlinit.c:29
VOID NTAPI MiInitializeDriverLargePageList(VOID)
Definition: largepag.c:68
VOID NTAPI MiInitializeLargePageSupport(VOID)
Definition: largepag.c:34
VOID NTAPI MiSyncCachedRanges(VOID)
Definition: largepag.c:54
PFN_COUNT MiExpansionPoolPagesInitialCharge
Definition: pool.c:21
KGUARDED_MUTEX MmSectionBasedMutex
Definition: section.c:110
SLIST_HEADER MmDeadStackSListHead
Definition: procsup.c:22
#define _1GB
Definition: miarm.h:20
struct _MMCOLOR_TABLES MMCOLOR_TABLES
KGUARDED_MUTEX MmPagedPoolMutex
Definition: pool.c:24
PFN_NUMBER MmResidentAvailableAtInit
Definition: freelist.c:28
#define _1MB
Definition: miarm.h:19
MMPFNLIST MmStandbyPageListByPriority[8]
Definition: pfnlist.c:44
PVOID MmHighSectionBase
Definition: section.c:111
ULONG MmSpecialPoolTag
Definition: pool.c:29
KGUARDED_MUTEX MmSectionCommitMutex
Definition: section.c:108
KEVENT MmZeroingPageEvent
Definition: zeropage.c:20
LIST_ENTRY MmWorkingSetExpansionHead
Definition: session.c:30
#define _1KB
Definition: miarm.h:18
ULONG MmMaximumDeadKernelStacks
Definition: procsup.c:21
#define MiAddressToPte(x)
Definition: mmx86.c:19
#define MiAddressToPde(x)
Definition: mmx86.c:20
#define min(a, b)
Definition: monoChain.cc:55
struct _MMPTE * PMMPTE
#define MI_HIGHEST_USER_ADDRESS
Definition: mmtypes.h:43
#define PAGE_ROUND_UP(x)
Definition: mmtypes.h:38
@ StandbyPageList
Definition: mmtypes.h:155
@ NotificationEvent
#define MI_ALLOCATION_FRAGMENT
Definition: mm.h:71
#define MI_PAGED_POOL_START
Definition: mm.h:21
#define MI_USER_PROBE_ADDRESS
Definition: mm.h:10
#define MI_DEFAULT_SYSTEM_RANGE_START
Definition: mm.h:11
#define MiSubsectionPteToSubsection(x)
Definition: mm.h:323
FORCEINLINE VOID MI_MAKE_PROTOTYPE_PTE(IN PMMPTE NewPte, IN PMMPTE PointerPte)
Definition: mm.h:342
#define MI_MIN_PAGES_FOR_SYSPTE_BOOST
Definition: mm.h:56
#define MM_EMPTY_LIST
Definition: mm.h:88
#define MI_MIN_PAGES_FOR_SYSPTE_TUNING
Definition: mm.h:55
FORCEINLINE PMMPTE MiAddressToPpe(PVOID Address)
Definition: mm.h:161
#define MiProtoPteToPte(x)
Definition: mm.h:316
FORCEINLINE PMMPTE MiAddressToPxe(PVOID Address)
Definition: mm.h:171
#define MI_HIGHEST_SYSTEM_ADDRESS
Definition: mm.h:31
#define MI_NONPAGED_POOL_END
Definition: mm.h:29
#define MI_MIN_ALLOCATION_FRAGMENT
Definition: mm.h:70
#define MI_SYSTEM_CACHE_END
Definition: mm.h:27
#define MI_MIN_PAGES_FOR_SYSPTE_BOOST_BOOST
Definition: mm.h:57
FORCEINLINE VOID MI_MAKE_SUBSECTION_PTE(_Out_ PMMPTE NewPte, _In_ PVOID Segment)
Definition: mm.h:328
#define PDE_MAPPED_VA
Definition: mm.h:39
#define MI_SYSTEM_CACHE_START
Definition: mm.h:26
#define MI_MAX_ALLOCATION_FRAGMENT
Definition: mm.h:72
PFN_NUMBER MmResidentAvailablePages
Definition: freelist.c:27
BOOLEAN NTAPI MiInitializeLoadedModuleList(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: sysldr.c:2241
PMMPTE MmDebugPte
Definition: mmdbg.c:31
LIST_ENTRY MmLoadedUserImageList
Definition: sysldr.c:22
VOID NTAPI MiReloadBootLoadedDrivers(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: sysldr.c:1730
PVOID MiDebugMapping
Definition: mmdbg.c:30
PFN_NUMBER MmAvailablePages
Definition: freelist.c:26
KMUTANT MmSystemLoadLock
Definition: sysldr.c:26
VOID NTAPI KeInitializeMutant(IN PKMUTANT Mutant, IN BOOLEAN InitialOwner)
Definition: mutex.c:22
VOID NTAPI MiInitializeSessionSpaceLayout(VOID)
Definition: init.c:63
NTSTATUS NTAPI MiInitMachineDependent(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: init.c:697
@ LoaderFirmwarePermanent
Definition: arc.h:180
@ LoaderSpecialMemory
Definition: arc.h:196
@ LoaderMaximum
Definition: arc.h:203
@ LoaderBBTMemory
Definition: arc.h:197
#define KERNEL_LARGE_STACK_SIZE
#define KERNEL_STACK_SIZE
ULONG PFN_NUMBER
Definition: ke.h:9
#define DPRINT
Definition: sndvol32.h:71
PLOADER_PARAMETER_EXTENSION Extension
Definition: arc.h:559
ULONG_PTR LoaderPagesSpanned
Definition: arc.h:403
PFN_NUMBER Total
Definition: mm.h:443
MMLISTS ListName
Definition: mm.h:444
PFN_NUMBER Blink
Definition: mm.h:446
PFN_NUMBER Flink
Definition: mm.h:445
Definition: mm.h:374
EX_PUSH_LOCK WorkingSetMutex
Definition: mmtypes.h:961
PHYSICAL_MEMORY_RUN Run[1]
Definition: miarm.h:426
Definition: bidi.c:434
#define max(a, b)
Definition: svc.c:63
#define TAG_MM
Definition: tag.h:113
void * PVOID
Definition: typedefs.h:50
struct tagRun Run
#define ROUND_TO_PAGES(Size)
@ MmLargeSystem
Definition: mmtypes.h:147
@ MmMediumSystem
Definition: mmtypes.h:146
@ MmSmallSystem
Definition: mmtypes.h:145
FORCEINLINE VOID InitializeSListHead(_Out_ PSLIST_HEADER SListHead)
Definition: rtlfuncs.h:3351

Referenced by ExpInitializeExecutive(), and Phase1InitializationDiscard().

◆ MmFreeLoaderBlock()

VOID NTAPI MmFreeLoaderBlock ( IN PLOADER_PARAMETER_BLOCK  LoaderBlock)

Definition at line 1093 of file mminit.c.

1094{
1095 PLIST_ENTRY NextMd;
1097 ULONG_PTR i;
1098 PFN_NUMBER BasePage, LoaderPages;
1099 PMMPFN Pfn1;
1100 KIRQL OldIrql;
1102
1103 /* Loop the descriptors in order to count them */
1104 i = 0;
1105 NextMd = LoaderBlock->MemoryDescriptorListHead.Flink;
1106 while (NextMd != &LoaderBlock->MemoryDescriptorListHead)
1107 {
1108 MdBlock = CONTAINING_RECORD(NextMd,
1110 ListEntry);
1111 i++;
1112 NextMd = MdBlock->ListEntry.Flink;
1113 }
1114
1115 /* Allocate a structure to hold the physical runs */
1117 i * sizeof(PHYSICAL_MEMORY_RUN),
1118 'lMmM');
1119 ASSERT(Buffer != NULL);
1120 Entry = Buffer;
1121
1122 /* Loop the descriptors again */
1123 NextMd = LoaderBlock->MemoryDescriptorListHead.Flink;
1124 while (NextMd != &LoaderBlock->MemoryDescriptorListHead)
1125 {
1126 /* Check what kind this was */
1127 MdBlock = CONTAINING_RECORD(NextMd,
1129 ListEntry);
1130 switch (MdBlock->MemoryType)
1131 {
1132 /* Registry, NLS, and heap data */
1133 case LoaderRegistryData:
1134 case LoaderOsloaderHeap:
1135 case LoaderNlsData:
1136 /* Are all a candidate for deletion */
1137 Entry->BasePage = MdBlock->BasePage;
1138 Entry->PageCount = MdBlock->PageCount;
1139 Entry++;
1140
1141 /* We keep the rest */
1142 default:
1143 break;
1144 }
1145
1146 /* Move to the next descriptor */
1147 NextMd = MdBlock->ListEntry.Flink;
1148 }
1149
1150 /* Acquire the PFN lock */
1151 OldIrql = MiAcquirePfnLock();
1152
1153 /* Loop the runs */
1154 LoaderPages = 0;
1155 while (--Entry >= Buffer)
1156 {
1157 /* See how many pages are in this run */
1158 i = Entry->PageCount;
1159 BasePage = Entry->BasePage;
1160
1161 /* Loop each page */
1162 Pfn1 = MiGetPfnEntry(BasePage);
1163 while (i--)
1164 {
1165 /* Check if it has references or is in any kind of list */
1166 if (!(Pfn1->u3.e2.ReferenceCount) && (!Pfn1->u1.Flink))
1167 {
1168 /* Set the new PTE address and put this page into the free list */
1169 Pfn1->PteAddress = (PMMPTE)(BasePage << PAGE_SHIFT);
1170 MiInsertPageInFreeList(BasePage);
1171 LoaderPages++;
1172 }
1173 else if (BasePage)
1174 {
1175 /* It has a reference, so simply drop it */
1177
1178 /* Drop a dereference on this page, which should delete it */
1179 Pfn1->PteAddress->u.Long = 0;
1180 MI_SET_PFN_DELETED(Pfn1);
1181 MiDecrementShareCount(Pfn1, BasePage);
1182 LoaderPages++;
1183 }
1184
1185 /* Move to the next page */
1186 Pfn1++;
1187 BasePage++;
1188 }
1189 }
1190
1191 /* Release the PFN lock and flush the TLB */
1192 DPRINT("Loader pages freed: %lx\n", LoaderPages);
1193 MiReleasePfnLock(OldIrql);
1195
1196 /* Free our run structure */
1197 ExFreePoolWithTag(Buffer, 'lMmM');
1198}
UCHAR KIRQL
Definition: env_spec_w32.h:591
FORCEINLINE BOOLEAN MI_IS_PHYSICAL_ADDRESS(IN PVOID Address)
Definition: miarm.h:945
#define MI_SET_PFN_DELETED(x)
Definition: miarm.h:194
VOID NTAPI MiInsertPageInFreeList(IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:611
VOID NTAPI MiDecrementShareCount(IN PMMPFN Pfn1, IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:1141
#define MiPteToAddress(_Pte)
Definition: mm.h:116
VOID NTAPI KeFlushCurrentTb(VOID)
Definition: cpu.c:401
FORCEINLINE PMMPFN MiGetPfnEntry(IN PFN_NUMBER Pfn)
Definition: mm.h:1047
@ LoaderOsloaderHeap
Definition: arc.h:181
@ LoaderRegistryData
Definition: arc.h:193
base of all file and directory entries
Definition: entries.h:83
union _MMPFN::@1774 u3
struct _MMPFN::@1774::@1780 e2
PMMPTE PteAddress
Definition: mm.h:386
PFN_NUMBER Flink
Definition: mm.h:377
union _MMPFN::@1772 u1
union _MMPTE::@2309 u
ULONG_PTR Long
Definition: mmtypes.h:215
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:792

Referenced by Phase1InitializationDiscard().

◆ Phase1Initialization()

VOID NTAPI Phase1Initialization ( IN PVOID  Context)

Definition at line 2017 of file init.c.

2018{
2019 /* Do the .INIT part of Phase 1 which we can free later */
2021
2022 /* Jump into zero page thread */
2024}
VOID NTAPI Phase1InitializationDiscard(IN PVOID Context)
Definition: init.c:1341
VOID NTAPI MmZeroPageThread(VOID)
Definition: zeropage.c:36

Referenced by PspInitPhase0().

◆ Phase1InitializationDiscard()

VOID NTAPI Phase1InitializationDiscard ( IN PVOID  Context)

Definition at line 1341 of file init.c.

1342{
1343 PLOADER_PARAMETER_BLOCK LoaderBlock = Context;
1344 NTSTATUS Status, MsgStatus;
1346 LARGE_INTEGER SystemBootTime, UniversalBootTime, OldTime, Timeout;
1347 BOOLEAN SosEnabled, NoGuiBoot, ResetBias = FALSE, AlternateShell = FALSE;
1348 PLDR_DATA_TABLE_ENTRY NtosEntry;
1349 PMESSAGE_RESOURCE_ENTRY MsgEntry;
1350 PCHAR CommandLine, Y2KHackRequired, SafeBoot, Environment;
1351 PCHAR StringBuffer, EndBuffer, BeginBuffer, MpString = "";
1352 PINIT_BUFFER InitBuffer;
1353 ANSI_STRING TempString;
1354 ULONG LastTzBias, Length, YearHack = 0, Disposition, MessageCode = 0;
1355 SIZE_T Size;
1356 size_t Remaining;
1358 KEY_VALUE_PARTIAL_INFORMATION KeyPartialInfo;
1361 HANDLE KeyHandle, OptionHandle;
1362 PRTL_USER_PROCESS_PARAMETERS ProcessParameters = NULL;
1363
1364 /* Allocate the initialization buffer */
1366 sizeof(INIT_BUFFER),
1367 TAG_INIT);
1368 if (!InitBuffer)
1369 {
1370 /* Bugcheck */
1371 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, STATUS_NO_MEMORY, 8, 0, 0);
1372 }
1373
1374 /* Set to phase 1 */
1376
1377 /* Set us at maximum priority */
1379
1380 /* Do Phase 1 HAL Initialization */
1381 if (!HalInitSystem(1, LoaderBlock)) KeBugCheck(HAL1_INITIALIZATION_FAILED);
1382
1383 /* Get the command line and upcase it */
1384 CommandLine = (LoaderBlock->LoadOptions ? _strupr(LoaderBlock->LoadOptions) : NULL);
1385
1386 /* Check if GUI Boot is enabled */
1387 NoGuiBoot = (CommandLine && strstr(CommandLine, "NOGUIBOOT") != NULL);
1388
1389 /* Get the SOS setting */
1390 SosEnabled = (CommandLine && strstr(CommandLine, "SOS") != NULL);
1391
1392 /* Setup the boot driver */
1393 InbvEnableBootDriver(!NoGuiBoot);
1395
1396 /* Check if GUI boot is enabled */
1397 if (!NoGuiBoot)
1398 {
1399 /* It is, display the boot logo and enable printing strings */
1402 }
1403 else
1404 {
1405 /* Release display ownership if not using GUI boot */
1407
1408 /* Don't allow boot-time strings */
1410 }
1411
1412 /* Check if this is LiveCD (WinPE) mode */
1413 if (CommandLine && strstr(CommandLine, "MININT") != NULL)
1414 {
1415 /* Setup WinPE Settings */
1417 InitWinPEModeType |= (strstr(CommandLine, "INRAM") != NULL) ? 0x80000000 : 0x00000001;
1418 }
1419
1420 /* Get the kernel's load entry */
1421 NtosEntry = CONTAINING_RECORD(LoaderBlock->LoadOrderListHead.Flink,
1423 InLoadOrderLinks);
1424
1425 /* Find the banner message */
1426 MsgStatus = RtlFindMessage(NtosEntry->DllBase,
1427 11,
1428 0,
1429 WINDOWS_NT_BANNER,
1430 &MsgEntry);
1431
1432 /* Setup defaults and check if we have a version string */
1433 StringBuffer = InitBuffer->VersionBuffer;
1434 BeginBuffer = StringBuffer;
1435 EndBuffer = StringBuffer;
1436 Remaining = sizeof(InitBuffer->VersionBuffer);
1438 {
1439 /* Print the version string */
1441 Remaining,
1442 &EndBuffer,
1443 &Remaining,
1444 0,
1445 ": %wZ",
1447 if (!NT_SUCCESS(Status))
1448 {
1449 /* Bugcheck */
1450 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 7, 0, 0);
1451 }
1452 }
1453 else
1454 {
1455 /* No version */
1456 *EndBuffer = ANSI_NULL; /* Null-terminate the string */
1457 }
1458
1459 /* Skip over the null-terminator to start a new string */
1460 ++EndBuffer;
1461 --Remaining;
1462
1463 /* Build the version number */
1464 StringBuffer = InitBuffer->VersionNumber;
1466 sizeof(InitBuffer->VersionNumber),
1467 "%u.%u",
1470 if (!NT_SUCCESS(Status))
1471 {
1472 /* Bugcheck */
1473 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 7, 0, 0);
1474 }
1475
1476 /* Check if we had found a banner message */
1477 if (NT_SUCCESS(MsgStatus))
1478 {
1479 /* Create the banner message */
1480 /* ReactOS specific: Report ReactOS version, NtBuildLab information and reported NT kernel version */
1481 Status = RtlStringCbPrintfA(EndBuffer,
1482 Remaining,
1483 (PCHAR)MsgEntry->Text,
1484 KERNEL_VERSION_STR,
1485 NtBuildLab,
1487 NtBuildNumber & 0xFFFF,
1488 BeginBuffer);
1489 if (!NT_SUCCESS(Status))
1490 {
1491 /* Bugcheck */
1492 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 7, 0, 0);
1493 }
1494 }
1495 else
1496 {
1497 /* Use hard-coded banner message */
1498 Status = RtlStringCbCopyA(EndBuffer, Remaining, "REACTOS (R)\r\n");
1499 if (!NT_SUCCESS(Status))
1500 {
1501 /* Bugcheck */
1502 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 7, 0, 0);
1503 }
1504 }
1505
1506 /* Display the version string on-screen */
1507 InbvDisplayString(EndBuffer);
1508
1509 /* Initialize Power Subsystem in Phase 0 */
1510 if (!PoInitSystem(0)) KeBugCheck(INTERNAL_POWER_ERROR);
1511
1512 /* Check for Y2K hack */
1513 Y2KHackRequired = CommandLine ? strstr(CommandLine, "YEAR") : NULL;
1514 if (Y2KHackRequired) Y2KHackRequired = strstr(Y2KHackRequired, "=");
1515 if (Y2KHackRequired) YearHack = atol(Y2KHackRequired + 1);
1516
1517 /* Query the clock */
1519 {
1520 /* Check if we're using the Y2K hack */
1521 if (Y2KHackRequired) TimeFields.Year = (CSHORT)YearHack;
1522
1523 /* Convert to time fields */
1524 RtlTimeFieldsToTime(&TimeFields, &SystemBootTime);
1525 UniversalBootTime = SystemBootTime;
1526
1527 /* Check if real time is GMT */
1529 {
1530 /* Check if we don't have a valid bias */
1532 {
1533 /* Reset */
1534 ResetBias = TRUE;
1536 }
1537
1538 /* Calculate the bias in seconds */
1540 10000000);
1541
1542 /* Set the boot time-zone bias */
1543 SharedUserData->TimeZoneBias.High2Time = ExpTimeZoneBias.HighPart;
1544 SharedUserData->TimeZoneBias.LowPart = ExpTimeZoneBias.LowPart;
1545 SharedUserData->TimeZoneBias.High1Time = ExpTimeZoneBias.HighPart;
1546
1547 /* Convert the boot time to local time, and set it */
1548 UniversalBootTime.QuadPart = SystemBootTime.QuadPart +
1550 }
1551
1552 /* Update the system time and notify the system */
1553 KeSetSystemTime(&UniversalBootTime, &OldTime, FALSE, NULL);
1555
1556 /* Remember this as the boot time */
1557 KeBootTime = UniversalBootTime;
1558 KeBootTimeBias = 0;
1559 }
1560
1561 /* Initialize all processors */
1562 if (!HalAllProcessorsStarted()) KeBugCheck(HAL1_INITIALIZATION_FAILED);
1563
1564#ifdef CONFIG_SMP
1565 /* HACK: We should use RtlFindMessage and not only fallback to this */
1566 MpString = "MultiProcessor Kernel\r\n";
1567#endif
1568
1569 /* Setup the "MP" String */
1570 RtlInitAnsiString(&TempString, MpString);
1571
1572 /* Make sure to remove the \r\n if we actually have a string */
1573 while ((TempString.Length > 0) &&
1574 ((TempString.Buffer[TempString.Length - 1] == '\r') ||
1575 (TempString.Buffer[TempString.Length - 1] == '\n')))
1576 {
1577 /* Skip the trailing character */
1578 TempString.Length--;
1579 }
1580
1581 /* Get the information string from our resource file */
1582 MsgStatus = RtlFindMessage(NtosEntry->DllBase,
1583 11,
1584 0,
1585 KeNumberProcessors > 1 ?
1586 WINDOWS_NT_INFO_STRING_PLURAL :
1587 WINDOWS_NT_INFO_STRING,
1588 &MsgEntry);
1589
1590 /* Get total RAM size, in MiB */
1591 /* Round size up. Assumed to better match actual physical RAM size */
1592 Size = ALIGN_UP_BY(MmNumberOfPhysicalPages * PAGE_SIZE, 1024 * 1024) / (1024 * 1024);
1593
1594 /* Create the string */
1595 StringBuffer = InitBuffer->VersionBuffer;
1597 sizeof(InitBuffer->VersionBuffer),
1598 NT_SUCCESS(MsgStatus) ?
1599 (PCHAR)MsgEntry->Text :
1600 "%u System Processor [%Iu MB Memory] %Z\r\n",
1602 Size,
1603 &TempString);
1604 if (!NT_SUCCESS(Status))
1605 {
1606 /* Bugcheck */
1607 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 4, 0, 0);
1608 }
1609
1610 /* Display RAM and CPU count */
1612
1613 /* Update the progress bar */
1615
1616 /* Call OB initialization again */
1617 if (!ObInitSystem()) KeBugCheck(OBJECT1_INITIALIZATION_FAILED);
1618
1619 /* Initialize Basic System Objects and Worker Threads */
1620 if (!ExInitSystem()) KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, 0, 0, 1, 0);
1621
1622 /* Initialize the later stages of the kernel */
1623 if (!KeInitSystem()) KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, 0, 0, 2, 0);
1624
1625 /* Call KD Providers at Phase 1 */
1627 {
1628 /* Failed, bugcheck */
1629 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, 0, 0, 3, 0);
1630 }
1631
1632 /* Initialize the SRM in Phase 1 */
1633 if (!SeInitSystem()) KeBugCheck(SECURITY1_INITIALIZATION_FAILED);
1634
1635 /* Update the progress bar */
1637
1638 /* Create SystemRoot Link */
1639 Status = ExpCreateSystemRootLink(LoaderBlock);
1640 if (!NT_SUCCESS(Status))
1641 {
1642 /* Failed to create the system root link */
1643 KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 0, 0, 0);
1644 }
1645
1646 /* Set up Region Maps, Sections and the Paging File */
1647 if (!MmInitSystem(1, LoaderBlock)) KeBugCheck(MEMORY1_INITIALIZATION_FAILED);
1648
1649 /* Create NLS section */
1650 ExpInitNls(LoaderBlock);
1651
1652 /* Initialize Cache Views */
1653 if (!CcInitializeCacheManager()) KeBugCheck(CACHE_INITIALIZATION_FAILED);
1654
1655 /* Initialize the Registry */
1656 if (!CmInitSystem1()) KeBugCheck(CONFIG_INITIALIZATION_FAILED);
1657
1658 /* Initialize Prefetcher */
1660
1661 /* Update progress bar */
1663
1664 /* Update timezone information */
1665 LastTzBias = ExpLastTimeZoneBias;
1666 ExRefreshTimeZoneInformation(&SystemBootTime);
1667
1668 /* Check if we're resetting timezone data */
1669 if (ResetBias)
1670 {
1671 /* Convert the local time to system time */
1672 ExLocalTimeToSystemTime(&SystemBootTime, &UniversalBootTime);
1673 KeBootTime = UniversalBootTime;
1674 KeBootTimeBias = 0;
1675
1676 /* Set the new time */
1677 KeSetSystemTime(&UniversalBootTime, &OldTime, FALSE, NULL);
1678 }
1679 else
1680 {
1681 /* Check if the timezone switched and update the time */
1682 if (LastTzBias != ExpLastTimeZoneBias)
1684 }
1685
1686 /* Initialize the File System Runtime Library */
1687 if (!FsRtlInitSystem()) KeBugCheck(FILE_INITIALIZATION_FAILED);
1688
1689 /* Initialize range lists */
1691
1692 /* Report all resources used by HAL */
1694
1695 /* Call the debugger DLL */
1696 KdDebuggerInitialize1(LoaderBlock);
1697
1698 /* Setup PnP Manager in phase 1 */
1699 if (!PpInitSystem()) KeBugCheck(PP1_INITIALIZATION_FAILED);
1700
1701 /* Update progress bar */
1703
1704 /* Initialize LPC */
1705 if (!LpcInitSystem()) KeBugCheck(LPC_INITIALIZATION_FAILED);
1706
1707 /* Make sure we have a command line */
1708 if (CommandLine)
1709 {
1710 /* Check if this is a safe mode boot */
1711 SafeBoot = strstr(CommandLine, "SAFEBOOT:");
1712 if (SafeBoot)
1713 {
1714 /* Check what kind of boot this is */
1715 SafeBoot += 9;
1716 if (!strncmp(SafeBoot, "MINIMAL", 7))
1717 {
1718 /* Minimal mode */
1719 InitSafeBootMode = 1;
1720 SafeBoot += 7;
1721 MessageCode = BOOTING_IN_SAFEMODE_MINIMAL;
1722 }
1723 else if (!strncmp(SafeBoot, "NETWORK", 7))
1724 {
1725 /* With Networking */
1726 InitSafeBootMode = 2;
1727 SafeBoot += 7;
1728 MessageCode = BOOTING_IN_SAFEMODE_NETWORK;
1729 }
1730 else if (!strncmp(SafeBoot, "DSREPAIR", 8))
1731 {
1732 /* Domain Server Repair */
1733 InitSafeBootMode = 3;
1734 SafeBoot += 8;
1735 MessageCode = BOOTING_IN_SAFEMODE_DSREPAIR;
1736
1737 }
1738 else
1739 {
1740 /* Invalid */
1741 InitSafeBootMode = 0;
1742 }
1743
1744 /* Check if there's any settings left */
1745 if (*SafeBoot)
1746 {
1747 /* Check if an alternate shell was requested */
1748 if (!strncmp(SafeBoot, "(ALTERNATESHELL)", 16))
1749 {
1750 /* Remember this for later */
1751 AlternateShell = TRUE;
1752 }
1753 }
1754
1755 /* Find the message to print out */
1756 Status = RtlFindMessage(NtosEntry->DllBase,
1757 11,
1758 0,
1759 MessageCode,
1760 &MsgEntry);
1761 if (NT_SUCCESS(Status))
1762 {
1763 /* Display it */
1764 InbvDisplayString((PCHAR)MsgEntry->Text);
1765 }
1766 }
1767 }
1768
1769 /* Make sure we have a command line */
1770 if (CommandLine)
1771 {
1772 /* Check if bootlogging is enabled */
1773 if (strstr(CommandLine, "BOOTLOG"))
1774 {
1775 /* Find the message to print out */
1776 Status = RtlFindMessage(NtosEntry->DllBase,
1777 11,
1778 0,
1779 BOOTLOG_ENABLED,
1780 &MsgEntry);
1781 if (NT_SUCCESS(Status))
1782 {
1783 /* Display it */
1784 InbvDisplayString((PCHAR)MsgEntry->Text);
1785 }
1786
1787 /* Setup boot logging */
1788 //IopInitializeBootLogging(LoaderBlock, InitBuffer->BootlogHeader);
1789 }
1790 }
1791
1792 /* Setup the Executive in Phase 2 */
1793 //ExInitSystemPhase2();
1794
1795 /* Update progress bar */
1797
1798 /* No KD Time Slip is pending */
1800
1801 /* Initialize in-place execution support */
1802 XIPInit(LoaderBlock);
1803
1804 /* Set maximum update to 75% */
1806
1807 /* Initialize the I/O Subsystem */
1808 if (!IoInitSystem(LoaderBlock)) KeBugCheck(IO1_INITIALIZATION_FAILED);
1809
1810 /* Set maximum update to 100% */
1812
1813 /* Are we in safe mode? */
1814 if (InitSafeBootMode)
1815 {
1816 /* Open the safe boot key */
1818 L"\\REGISTRY\\MACHINE\\SYSTEM\\CURRENTCONTROLSET"
1819 L"\\CONTROL\\SAFEBOOT");
1821 &KeyName,
1823 NULL,
1824 NULL);
1826 if (NT_SUCCESS(Status))
1827 {
1828 /* First check if we have an alternate shell */
1829 if (AlternateShell)
1830 {
1831 /* Make sure that the registry has one setup */
1832 RtlInitUnicodeString(&KeyName, L"AlternateShell");
1834 &KeyName,
1836 &KeyPartialInfo,
1837 sizeof(KeyPartialInfo),
1838 &Length);
1840 {
1841 AlternateShell = FALSE;
1842 }
1843 }
1844
1845 /* Create the option key */
1846 RtlInitUnicodeString(&KeyName, L"Option");
1848 &KeyName,
1850 KeyHandle,
1851 NULL);
1852 Status = ZwCreateKey(&OptionHandle,
1855 0,
1856 NULL,
1858 &Disposition);
1860
1861 /* Check if the key create worked */
1862 if (NT_SUCCESS(Status))
1863 {
1864 /* Write the safe boot type */
1865 RtlInitUnicodeString(&KeyName, L"OptionValue");
1866 NtSetValueKey(OptionHandle,
1867 &KeyName,
1868 0,
1869 REG_DWORD,
1871 sizeof(InitSafeBootMode));
1872
1873 /* Check if we have to use an alternate shell */
1874 if (AlternateShell)
1875 {
1876 /* Remember this for later */
1877 Disposition = TRUE;
1878 RtlInitUnicodeString(&KeyName, L"UseAlternateShell");
1879 NtSetValueKey(OptionHandle,
1880 &KeyName,
1881 0,
1882 REG_DWORD,
1883 &Disposition,
1884 sizeof(Disposition));
1885 }
1886
1887 /* Close the options key handle */
1888 NtClose(OptionHandle);
1889 }
1890 }
1891 }
1892
1893 /* Are we in Win PE mode? */
1894 if (InitIsWinPEMode)
1895 {
1896 /* Open the safe control key */
1898 L"\\REGISTRY\\MACHINE\\SYSTEM\\CURRENTCONTROLSET"
1899 L"\\CONTROL");
1901 &KeyName,
1903 NULL,
1904 NULL);
1906 if (!NT_SUCCESS(Status))
1907 {
1908 /* Bugcheck */
1909 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 6, 0, 0);
1910 }
1911
1912 /* Create the MiniNT key */
1913 RtlInitUnicodeString(&KeyName, L"MiniNT");
1915 &KeyName,
1917 KeyHandle,
1918 NULL);
1919 Status = ZwCreateKey(&OptionHandle,
1922 0,
1923 NULL,
1925 &Disposition);
1926 if (!NT_SUCCESS(Status))
1927 {
1928 /* Bugcheck */
1929 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 6, 0, 0);
1930 }
1931
1932 /* Close the handles */
1934 NtClose(OptionHandle);
1935 }
1936
1937 /* FIXME: This doesn't do anything for now */
1938 MmArmInitSystem(2, LoaderBlock);
1939
1940 /* Update progress bar */
1942
1943 /* Initialize VDM support */
1944#if defined(_M_IX86)
1946#endif
1947
1948 /* Initialize Power Subsystem in Phase 1*/
1949 if (!PoInitSystem(1)) KeBugCheck(INTERNAL_POWER_ERROR);
1950
1951 /* Update progress bar */
1953
1954 /* Initialize the Process Manager at Phase 1 */
1955 if (!PsInitSystem(LoaderBlock)) KeBugCheck(PROCESS1_INITIALIZATION_FAILED);
1956
1957 /* Make sure nobody touches the loader block again */
1958 if (LoaderBlock == KeLoaderBlock) KeLoaderBlock = NULL;
1959 MmFreeLoaderBlock(LoaderBlock);
1960 LoaderBlock = Context = NULL;
1961
1962 /* Initialize the SRM in phase 1 */
1963 if (!SeRmInitPhase1()) KeBugCheck(PROCESS1_INITIALIZATION_FAILED);
1964
1965 /* Update progress bar */
1967
1968 /* Clear the screen */
1970
1971 /* Allow strings to be displayed */
1973
1974 /* Launch initial process */
1975 ProcessInfo = &InitBuffer->ProcessInfo;
1976 ExpLoadInitialProcess(InitBuffer, &ProcessParameters, &Environment);
1977
1978 /* Wait 5 seconds for initial process to initialize */
1979 Timeout.QuadPart = Int32x32To64(5, -10000000);
1980 Status = ZwWaitForSingleObject(ProcessInfo->ProcessHandle, FALSE, &Timeout);
1981 if (Status == STATUS_SUCCESS)
1982 {
1983 /* Failed, display error */
1984 DPRINT1("INIT: Session Manager terminated.\n");
1985
1986 /* Bugcheck the system if SMSS couldn't initialize */
1987 KeBugCheck(SESSION5_INITIALIZATION_FAILED);
1988 }
1989
1990 /* Close process handles */
1991 ZwClose(ProcessInfo->ThreadHandle);
1992 ZwClose(ProcessInfo->ProcessHandle);
1993
1994 /* Free the initial process environment */
1995 Size = 0;
1996 ZwFreeVirtualMemory(NtCurrentProcess(),
1997 (PVOID*)&Environment,
1998 &Size,
1999 MEM_RELEASE);
2000
2001 /* Free the initial process parameters */
2002 Size = 0;
2003 ZwFreeVirtualMemory(NtCurrentProcess(),
2004 (PVOID*)&ProcessParameters,
2005 &Size,
2006 MEM_RELEASE);
2007
2008 /* Increase init phase */
2010
2011 /* Free the boot buffer */
2012 ExFreePoolWithTag(InitBuffer, TAG_INIT);
2013}
#define ALIGN_UP_BY(size, align)
int strncmp(const char *String1, const char *String2, ACPI_SIZE Count)
Definition: utclib.c:534
VOID NTAPI FinalizeBootLogo(VOID)
Definition: bootanim.c:754
VOID NTAPI DisplayBootBitmap(_In_ BOOLEAN TextMode)
Definition: bootanim.c:471
BOOLEAN NTAPI CmInitSystem1(VOID)
Definition: cmsysini.c:1505
BOOLEAN RtlTimeFieldsToTime(IN PTIME_FIELDS TimeFields, IN PLARGE_INTEGER Time)
#define ExLocalTimeToSystemTime(LocTime, SysTime)
Definition: env_spec_w32.h:738
BOOLEAN NTAPI FsRtlInitSystem(VOID)
Definition: fsrtlpc.c:161
BOOLEAN NTAPI CcInitializeCacheManager(VOID)
Definition: fssup.c:83
VOID NTAPI CcPfInitializePrefetcher(VOID)
Definition: fssup.c:114
BOOLEAN NTAPI HalAllProcessorsStarted(VOID)
Definition: processor.c:60
VOID NTAPI HalReportResourceUsage(VOID)
Definition: usage.c:67
#define KeGetCurrentThread
Definition: hal.h:55
VOID NTAPI InbvNotifyDisplayOwnershipLost(_In_ INBV_RESET_DISPLAY_PARAMETERS Callback)
Definition: inbv.c:403
BOOLEAN InbvBootDriverInstalled
Definition: inbv.c:39
VOID NTAPI InbvEnableBootDriver(_In_ BOOLEAN Enable)
Definition: inbv.c:257
VOID NTAPI InbvSetProgressBarSubset(_In_ ULONG Floor, _In_ ULONG Ceiling)
Specifies a progress percentage sub-range. Further calls to InbvIndicateProgress() or InbvUpdateProgr...
Definition: inbv.c:663
BOOLEAN NTAPI InbvEnableDisplayString(_In_ BOOLEAN Enable)
Definition: inbv.c:369
BOOLEAN NTAPI InbvDisplayString(_In_ PCHAR String)
Definition: inbv.c:331
BOOLEAN NTAPI InbvDriverInitialize(_In_ PLOADER_PARAMETER_BLOCK LoaderBlock, _In_ ULONG Count)
Definition: inbv.c:175
VOID NTAPI InbvUpdateProgressBar(_In_ ULONG Percentage)
Updates the progress bar percentage, relative to the current percentage sub-range previously set by I...
Definition: inbv.c:689
#define HIGH_PRIORITY
BOOLEAN NTAPI KdInitSystem(_In_ ULONG BootPhase, _In_opt_ PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: kdinit.c:142
LONG KdpTimeSlipPending
Definition: kddata.c:119
NTSTATUS NTAPI KdDebuggerInitialize1(IN PLOADER_PARAMETER_BLOCK LoaderBlock OPTIONAL)
Definition: kdcom.c:283
CCHAR KeNumberProcessors
Definition: krnlinit.c:35
WCHAR StringBuffer[156]
Definition: ldrinit.c:41
BOOLEAN NTAPI LpcInitSystem(VOID)
Definition: port.c:37
static PTIME_FIELDS TimeFields
Definition: time.c:104
_Must_inspect_result_ _Out_ PNDIS_STATUS _In_ NDIS_HANDLE _In_ ULONG _Out_ PNDIS_STRING _Out_ PNDIS_HANDLE KeyHandle
Definition: ndis.h:4715
_In_ ACCESS_MASK _In_ POBJECT_ATTRIBUTES _Reserved_ ULONG _In_opt_ PUNICODE_STRING _In_ ULONG _Out_opt_ PULONG Disposition
Definition: cmfuncs.h:56
NTSYSAPI NTSTATUS NTAPI ZwSetSystemTime(_In_ PLARGE_INTEGER SystemTime, _In_opt_ PLARGE_INTEGER NewSystemTime)
NTSYSAPI NTSTATUS NTAPI ZwClose(_In_ HANDLE Handle)
NTSYSAPI NTSTATUS NTAPI NtSetValueKey(IN HANDLE KeyHandle, IN PUNICODE_STRING ValueName, IN ULONG TitleIndex OPTIONAL, IN ULONG Type, IN PVOID Data, IN ULONG DataSize)
Definition: ntapi.c:859
@ KeyValuePartialInformation
Definition: nt_native.h:1182
#define KEY_ALL_ACCESS
Definition: nt_native.h:1041
NTSYSAPI NTSTATUS NTAPI NtQueryValueKey(IN HANDLE KeyHandle, IN PUNICODE_STRING ValueName, IN KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass, IN PVOID KeyValueInformation, IN ULONG Length, IN PULONG ResultLength)
#define MEM_RELEASE
Definition: nt_native.h:1316
#define REG_OPTION_VOLATILE
Definition: nt_native.h:1060
#define Int32x32To64(a, b)
BOOLEAN InitWinPEModeType
Definition: init.c:72
BOOLEAN ExCmosClockIsSane
Definition: init.c:92
ULONG NtBuildNumber
Definition: init.c:50
NTSTATUS NTAPI ExpCreateSystemRootLink(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: init.c:100
CHAR NtBuildLab[]
Definition: init.c:64
VOID NTAPI MmFreeLoaderBlock(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: mminit.c:1093
VOID NTAPI ExpLoadInitialProcess(IN PINIT_BUFFER InitBuffer, OUT PRTL_USER_PROCESS_PARAMETERS *ProcessParameters, OUT PCHAR *ProcessEnvironment)
Definition: init.c:388
BOOLEAN ExpRealTimeIsUniversal
Definition: init.c:93
ULONG InitSafeBootMode
Definition: init.c:71
BOOLEAN InitIsWinPEMode
Definition: init.c:72
LARGE_INTEGER ExpTimeZoneBias
Definition: time.c:23
ULONG ExpAltTimeZoneBias
Definition: time.c:24
ULONG ExpLastTimeZoneBias
Definition: time.c:22
BOOLEAN NTAPI ExRefreshTimeZoneInformation(IN PLARGE_INTEGER CurrentBootTime)
Definition: time.c:226
VOID NTAPI KeI386VdmInitialize(VOID)
Definition: vdmmain.c:42
BOOLEAN NTAPI IoInitSystem(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: iomgr.c:465
VOID NTAPI KeSetSystemTime(IN PLARGE_INTEGER NewSystemTime, OUT PLARGE_INTEGER OldSystemTime, IN BOOLEAN FixInterruptTime, IN PLARGE_INTEGER HalTime)
Definition: clock.c:28
ULONGLONG KeBootTimeBias
Definition: clock.c:18
BOOLEAN NTAPI KeInitSystem(VOID)
Definition: krnlinit.c:296
LARGE_INTEGER KeBootTime
Definition: clock.c:17
PFN_COUNT MmNumberOfPhysicalPages
Definition: init.c:48
BOOLEAN NTAPI MmInitSystem(IN ULONG Phase, IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: mminit.c:202
VOID NTAPI RtlInitializeRangeListPackage(VOID)
Definition: libsupp.c:62
BOOLEAN NTAPI SeRmInitPhase1(VOID)
Manages the phase 1 initialization of the security reference monitoring module of the kernel.
Definition: srm.c:211
#define IDB_MAX_RESOURCE
Definition: resource.h:46
#define STATUS_NO_MEMORY
Definition: ntstatus.h:260
NTSTRSAFEVAPI RtlStringCbPrintfExA(_Out_writes_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PSTR pszDest, _In_ size_t cbDest, _Outptr_opt_result_bytebuffer_(*pcbRemaining) NTSTRSAFE_PSTR *ppszDestEnd, _Out_opt_ size_t *pcbRemaining, _In_ STRSAFE_DWORD dwFlags, _In_ _Printf_format_string_ NTSTRSAFE_PCSTR pszFormat,...)
Definition: ntstrsafe.h:1294
NTSTRSAFEAPI RtlStringCbCopyA(_Out_writes_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PSTR pszDest, _In_ size_t cbDest, _In_ NTSTRSAFE_PCSTR pszSrc)
Definition: ntstrsafe.h:156
static ULONG Timeout
Definition: ping.c:61
BOOLEAN NTAPI PoInitSystem(IN ULONG BootPhase)
Definition: power.c:397
VOID NTAPI PoNotifySystemTimeSet(VOID)
Definition: events.c:39
BOOLEAN NTAPI HalQueryRealTimeClock(IN PTIME_FIELDS Time)
Definition: rtc.c:24
#define REG_DWORD
Definition: sdbapi.c:596
RTL_USER_PROCESS_INFORMATION ProcessInfo
Definition: init.c:38
CHAR VersionBuffer[256]
Definition: init.c:35
CHAR VersionNumber[24]
Definition: init.c:37
LIST_ENTRY LoadOrderListHead
Definition: arc.h:540
#define TAG_INIT
Definition: tag.h:27
KPRIORITY NTAPI KeSetPriorityThread(IN PKTHREAD Thread, IN KPRIORITY Priority)
Definition: thrdobj.c:1327
short CSHORT
Definition: umtypes.h:127
ULONG LowPart
Definition: typedefs.h:106
_Must_inspect_result_ _In_ WDFDEVICE _In_ PCUNICODE_STRING KeyName
Definition: wdfdevice.h:2699
BOOLEAN SafeBoot
Definition: winldr.c:34
BOOLEAN SosEnabled
Definition: winldr.c:33
VOID NTAPI XIPInit(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: xipdisp.c:55

Referenced by Phase1Initialization().

Variable Documentation

◆ CmCSDVersionString

UNICODE_STRING CmCSDVersionString

◆ CmNtCSDReleaseType

ULONG CmNtCSDReleaseType

Definition at line 60 of file init.c.

Referenced by ExpInitializeExecutive().

◆ CmNtCSDVersion

ULONG CmNtCSDVersion

Definition at line 59 of file init.c.

Referenced by ExpInitializeExecutive(), MmCreatePeb(), and RtlGetVersion().

◆ CmNtSpBuildNumber

ULONG CmNtSpBuildNumber

Definition at line 58 of file init.c.

Referenced by CmpSetVersionData(), and ExpInitializeExecutive().

◆ CmVersionString

UNICODE_STRING CmVersionString

Definition at line 61 of file init.c.

Referenced by CmpSetVersionData(), and ExpInitializeExecutive().

◆ ExCmosClockIsSane

BOOLEAN ExCmosClockIsSane = TRUE

Definition at line 92 of file init.c.

Referenced by KeSetSystemTime(), and Phase1InitializationDiscard().

◆ ExpAnsiCodePageDataOffset

ULONG ExpAnsiCodePageDataOffset

Definition at line 85 of file init.c.

Referenced by ExpInitializeExecutive(), ExpInitNls(), and MmCreatePeb().

◆ ExpInitializationPhase

◆ ExpInTextModeSetup

BOOLEAN ExpInTextModeSetup

◆ ExpNlsSectionPointer

PVOID ExpNlsSectionPointer

Definition at line 89 of file init.c.

Referenced by ExpInitNls(), and MmCreatePeb().

◆ ExpNlsTableBase

PVOID ExpNlsTableBase

Definition at line 84 of file init.c.

Referenced by ExpInitializeExecutive(), and ExpInitNls().

◆ ExpNlsTableInfo

NLSTABLEINFO ExpNlsTableInfo

Definition at line 87 of file init.c.

Referenced by ExpInitializeExecutive(), and ExpInitNls().

◆ ExpNlsTableSize

SIZE_T ExpNlsTableSize

Definition at line 88 of file init.c.

Referenced by ExpInitNls().

◆ ExpOemCodePageDataOffset

ULONG ExpOemCodePageDataOffset

Definition at line 85 of file init.c.

Referenced by ExpInitializeExecutive(), ExpInitNls(), and MmCreatePeb().

◆ ExpRealTimeIsUniversal

BOOLEAN ExpRealTimeIsUniversal

Definition at line 93 of file init.c.

Referenced by Phase1InitializationDiscard().

◆ ExpUnicodeCaseTableDataOffset

ULONG ExpUnicodeCaseTableDataOffset

Definition at line 86 of file init.c.

Referenced by ExpInitializeExecutive(), ExpInitNls(), and MmCreatePeb().

◆ ExSuiteMask

ULONG ExSuiteMask

Definition at line 55 of file init.c.

Referenced by ExpInitSystemPhase0().

◆ InitIsWinPEMode

BOOLEAN InitIsWinPEMode

Definition at line 72 of file init.c.

Referenced by CmInitSystem1(), and Phase1InitializationDiscard().

◆ InitSafeBootMode

◆ InitWinPEModeType

BOOLEAN InitWinPEModeType

Definition at line 72 of file init.c.

Referenced by Phase1InitializationDiscard().

◆ IoRemoteBootClient

BOOLEAN IoRemoteBootClient

Definition at line 70 of file init.c.

Referenced by ExpInitializeExecutive(), IopCreateArcNames(), and xHalIoAssignDriveLetters().

◆ NtBuildLab

CHAR NtBuildLab[]
Initial value:
= KERNEL_VERSION_BUILD_STR "."
REACTOS_COMPILER_NAME "_" REACTOS_COMPILER_VERSION

Definition at line 64 of file init.c.

Referenced by CmpSetVersionData(), and Phase1InitializationDiscard().

◆ NtBuildNumber

◆ NtGlobalFlag

◆ NtInitialUserProcessBuffer

WCHAR NtInitialUserProcessBuffer[128] = L"\\SystemRoot\\System32\\smss.exe"

Definition at line 78 of file init.c.

Referenced by ExpLoadInitialProcess().

◆ NtInitialUserProcessBufferLength

ULONG NtInitialUserProcessBufferLength
Initial value:
sizeof(WCHAR)

Definition at line 79 of file init.c.

Referenced by ExpLoadInitialProcess().

◆ NtInitialUserProcessBufferType

ULONG NtInitialUserProcessBufferType = REG_SZ

Definition at line 81 of file init.c.

Referenced by ExpLoadInitialProcess().

◆ NtMajorVersion

ULONG NtMajorVersion = VER_PRODUCTMAJORVERSION

Definition at line 45 of file init.c.

Referenced by ExpInitializeExecutive(), MmCreatePeb(), PsGetVersion(), and RtlGetVersion().

◆ NtMinorVersion

ULONG NtMinorVersion = VER_PRODUCTMINORVERSION

Definition at line 46 of file init.c.

Referenced by ExpInitializeExecutive(), MmCreatePeb(), PsGetVersion(), and RtlGetVersion().

◆ NtSystemRoot