ReactOS 0.4.15-dev-7677-g8209aa5
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
 
BOOLEAN SosEnabled
 
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 877 of file init.c.

880{
881 PLIST_ENTRY ListEntry;
882 PMEMORY_ALLOCATION_DESCRIPTOR MemDescriptor;
883
884 DPRINT1("Burn RAM amount: %lu pages\n", PagesToDestroy);
885
886 /* Loop the memory descriptors, beginning at the end */
887 for (ListEntry = LoaderBlock->MemoryDescriptorListHead.Blink;
888 ListEntry != &LoaderBlock->MemoryDescriptorListHead;
889 ListEntry = ListEntry->Blink)
890 {
891 /* Get the memory descriptor structure */
892 MemDescriptor = CONTAINING_RECORD(ListEntry,
894 ListEntry);
895
896 /* Is memory free there or is it temporary? */
897 if (MemDescriptor->MemoryType == LoaderFree ||
898 MemDescriptor->MemoryType == LoaderFirmwareTemporary)
899 {
900 /* Check if the descriptor has more pages than we want */
901 if (MemDescriptor->PageCount > PagesToDestroy)
902 {
903 /* Change block's page count, ntoskrnl doesn't care much */
904 MemDescriptor->PageCount -= PagesToDestroy;
905 break;
906 }
907 else
908 {
909 /* Change block type */
910 MemDescriptor->MemoryType = MemoryType;
911 PagesToDestroy -= MemDescriptor->PageCount;
912
913 /* Check if we are done */
914 if (PagesToDestroy == 0) break;
915 }
916 }
917 }
918}
#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 606 of file init.c.

607{
608 ULONG MsRemainder = 0, MsIncrement;
609 ULONG IncrementRemainder;
610 ULONG i;
611
612 /* Count the number of milliseconds for each clock interrupt */
613 MsIncrement = ClockIncrement / (10 * 1000);
614
615 /* Count the remainder from the division above, with 24-bit precision */
616 IncrementRemainder = ClockIncrement - (MsIncrement * (10 * 1000));
617 for (i= 0; i < 24; i++)
618 {
619 /* Shift the remainders */
620 MsRemainder <<= 1;
621 IncrementRemainder <<= 1;
622
623 /* Check if we've went past 1 ms */
624 if (IncrementRemainder >= (10 * 1000))
625 {
626 /* Increase the remainder by one, and substract from increment */
627 IncrementRemainder -= (10 * 1000);
628 MsRemainder |= 1;
629 }
630 }
631
632 /* Return the increment */
633 return (MsIncrement << 24) | MsRemainder;
634}
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 744 of file init.c.

745{
746 /* Check the initialization phase */
748 {
749 case 0:
750
751 /* Do Phase 0 */
752 return ExpInitSystemPhase0();
753
754 case 1:
755
756 /* Do Phase 1 */
757 return ExpInitSystemPhase1();
758
759 default:
760
761 /* Don't know any other phase! Bugcheck! */
762 KeBugCheck(UNEXPECTED_INITIALIZATION_CALL);
763 return FALSE;
764 }
765}
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:639
BOOLEAN NTAPI ExpInitSystemPhase1(VOID)
Definition: init.c:663

Referenced by ExpInitializeExecutive(), and Phase1InitializationDiscard().

◆ ExpCreateSystemRootLink()

NTSTATUS NTAPI ExpCreateSystemRootLink ( IN PLOADER_PARAMETER_BLOCK  LoaderBlock)

Definition at line 101 of file init.c.

102{
103 UNICODE_STRING LinkName;
105 HANDLE LinkHandle;
107 ANSI_STRING AnsiName;
108 CHAR Buffer[256];
111
112 /* Initialize the ArcName tree */
113 RtlInitUnicodeString(&LinkName, L"\\ArcName");
115 &LinkName,
117 NULL,
119
120 /* Create it */
121 Status = NtCreateDirectoryObject(&LinkHandle,
124 if (!NT_SUCCESS(Status))
125 {
126 /* Failed */
127 KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 1, 0, 0);
128 }
129
130 /* Close the LinkHandle */
131 NtClose(LinkHandle);
132
133 /* Initialize the Device tree */
134 RtlInitUnicodeString(&LinkName, L"\\Device");
136 &LinkName,
138 NULL,
140
141 /* Create it */
142 Status = NtCreateDirectoryObject(&LinkHandle,
145 if (!NT_SUCCESS(Status))
146 {
147 /* Failed */
148 KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 2, 0, 0);
149 }
150
151 /* Close the LinkHandle */
152 ObCloseHandle(LinkHandle, KernelMode);
153
154 /* Create the system root symlink name */
155 RtlInitAnsiString(&AnsiName, "\\SystemRoot");
156 Status = RtlAnsiStringToUnicodeString(&LinkName, &AnsiName, TRUE);
157 if (!NT_SUCCESS(Status))
158 {
159 /* Failed */
160 KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 3, 0, 0);
161 }
162
163 /* Initialize the attributes for the link */
165 &LinkName,
167 NULL,
169
170 /* Build the ARC name */
172 "\\ArcName\\%s%s",
173 LoaderBlock->ArcBootDeviceName,
174 LoaderBlock->NtBootPathName);
176
177 /* Convert it to Unicode */
181 TRUE);
182 if (!NT_SUCCESS(Status))
183 {
184 /* We failed, bugcheck */
185 KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 4, 0, 0);
186 }
187
188 /* Create it */
192 &TargetName);
193
194 /* Free the strings */
195 RtlFreeUnicodeString(&LinkName);
197
198 /* Check if creating the link failed */
199 if (!NT_SUCCESS(Status))
200 {
201 /* Failed */
202 KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 5, 0, 0);
203 }
204
205 /* Close the handle and return success */
206 ObCloseHandle(LinkHandle, KernelMode);
207 return STATUS_SUCCESS;
208}
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 923 of file init.c.

925{
926 PNLS_DATA_BLOCK NlsData;
927 CHAR Buffer[256];
928 ANSI_STRING AnsiPath;
930 PCHAR CommandLine, PerfMem;
931 ULONG PerfMemUsed;
932 PLDR_DATA_TABLE_ENTRY NtosEntry;
934 ANSI_STRING CSDString;
935 size_t Remaining = 0;
936 PCHAR RcEnd = NULL;
937 CHAR VersionBuffer[65];
938
939 /* Validate Loader */
940 if (!ExpIsLoaderValid(LoaderBlock))
941 {
942 /* Invalid loader version */
943 KeBugCheckEx(MISMATCHED_HAL,
944 3,
945 LoaderBlock->Extension->Size,
946 LoaderBlock->Extension->MajorVersion,
947 LoaderBlock->Extension->MinorVersion);
948 }
949
950 /* Initialize PRCB pool lookaside pointers */
952
953 /* Check if this is an application CPU */
954 if (Cpu)
955 {
956 /* Then simply initialize it with HAL */
957 if (!HalInitSystem(ExpInitializationPhase, LoaderBlock))
958 {
959 /* Initialization failed */
960 KeBugCheck(HAL_INITIALIZATION_FAILED);
961 }
962
963 /* We're done */
964 return;
965 }
966
967 /* Assume no text-mode or remote boot */
970
971 /* Check if we have a setup loader block */
972 if (LoaderBlock->SetupLdrBlock)
973 {
974 /* Check if this is text-mode setup */
975 if (LoaderBlock->SetupLdrBlock->Flags & SETUPLDR_TEXT_MODE)
977
978 /* Check if this is network boot */
979 if (LoaderBlock->SetupLdrBlock->Flags & SETUPLDR_REMOTE_BOOT)
980 {
981 /* Set variable */
983
984 /* Make sure we're actually booting off the network */
985 ASSERT(!_memicmp(LoaderBlock->ArcBootDeviceName, "net(0)", 6));
986 }
987 }
988
989 /* Set phase to 0 */
991
992 /* Get boot command line */
993 CommandLine = LoaderBlock->LoadOptions;
994 if (CommandLine)
995 {
996 /* Upcase it for comparison and check if we're in performance mode */
997 _strupr(CommandLine);
998 PerfMem = strstr(CommandLine, "PERFMEM");
999 if (PerfMem)
1000 {
1001 /* Check if the user gave a number of bytes to use */
1002 PerfMem = strstr(PerfMem, "=");
1003 if (PerfMem)
1004 {
1005 /* Read the number of pages we'll use */
1006 PerfMemUsed = atol(PerfMem + 1) * (1024 * 1024 / PAGE_SIZE);
1007 if (PerfMemUsed)
1008 {
1009 /* FIXME: TODO */
1010 DPRINT1("BBT performance mode not yet supported."
1011 "/PERFMEM option ignored.\n");
1012 }
1013 }
1014 }
1015
1016 /* Check if we're burning memory */
1017 PerfMem = strstr(CommandLine, "BURNMEMORY");
1018 if (PerfMem)
1019 {
1020 /* Check if the user gave a number of bytes to use */
1021 PerfMem = strstr(PerfMem, "=");
1022 if (PerfMem)
1023 {
1024 /* Read the number of pages we'll use */
1025 PerfMemUsed = atol(PerfMem + 1) * (1024 * 1024 / PAGE_SIZE);
1026 if (PerfMemUsed) ExBurnMemory(LoaderBlock, PerfMemUsed, LoaderBad);
1027 }
1028 }
1029 }
1030
1031 /* Setup NLS Base and offsets */
1032 NlsData = LoaderBlock->NlsData;
1036 (ULONG_PTR)NlsData->AnsiCodePageData);
1038 (ULONG_PTR)NlsData->AnsiCodePageData);
1039
1040 /* Initialize the NLS Tables */
1049
1050 /* Now initialize the HAL */
1051 if (!HalInitSystem(ExpInitializationPhase, LoaderBlock))
1052 {
1053 /* HAL failed to initialize, bugcheck */
1054 KeBugCheck(HAL_INITIALIZATION_FAILED);
1055 }
1056
1057 /* Make sure interrupts are active now */
1058 _enable();
1059
1060 /* Clear the crypto exponent */
1061 SharedUserData->CryptoExponent = 0;
1062
1063 /* Set global flags for the checked build */
1064#if DBG
1067#endif
1068
1069 /* Setup NT System Root Path */
1070 sprintf(Buffer, "C:%s", LoaderBlock->NtBootPathName);
1071
1072 /* Convert to ANSI_STRING and null-terminate it */
1073 RtlInitString(&AnsiPath, Buffer);
1074 Buffer[--AnsiPath.Length] = ANSI_NULL;
1075
1076 /* Get the string from KUSER_SHARED_DATA's buffer */
1077 RtlInitEmptyUnicodeString(&NtSystemRoot,
1078 SharedUserData->NtSystemRoot,
1079 sizeof(SharedUserData->NtSystemRoot));
1080
1081 /* Now fill it in */
1083 if (!NT_SUCCESS(Status)) KeBugCheck(SESSION3_INITIALIZATION_FAILED);
1084
1085 /* Setup bugcheck messages */
1087
1088 /* Setup initial system settings */
1089 CmGetSystemControlValues(LoaderBlock->RegistryBase, CmControlVector);
1090
1091 /* Set the Service Pack Number and add it to the CSD Version number if needed */
1093 if (((CmNtCSDVersion & 0xFFFF0000) == 0) && (CmNtCSDReleaseType == 1))
1094 {
1096 }
1097
1098 /* Add loaded CmNtGlobalFlag value */
1100
1101 /* Initialize the executive at phase 0 */
1102 if (!ExInitSystem()) KeBugCheck(PHASE0_INITIALIZATION_FAILED);
1103
1104 /* Initialize the memory manager at phase 0 */
1105 if (!MmArmInitSystem(0, LoaderBlock)) KeBugCheck(PHASE0_INITIALIZATION_FAILED);
1106
1107 /* Load boot symbols */
1108 ExpLoadBootSymbols(LoaderBlock);
1109
1110 /* Check if we should break after symbol load */
1112
1113 /* Check if this loader is compatible with NT 5.2 */
1114 if (LoaderBlock->Extension->Size >= sizeof(LOADER_PARAMETER_EXTENSION))
1115 {
1116 /* Setup headless terminal settings */
1117 HeadlessInit(LoaderBlock);
1118 }
1119
1120 /* Set system ranges */
1121#ifdef _M_AMD64
1124#else
1127#endif
1128
1129 /* Make a copy of the NLS Tables */
1130 ExpInitNls(LoaderBlock);
1131
1132 /* Get the kernel's load entry */
1133 NtosEntry = CONTAINING_RECORD(LoaderBlock->LoadOrderListHead.Flink,
1135 InLoadOrderLinks);
1136
1137 /* Check if this is a service pack */
1138 if (CmNtCSDVersion & 0xFFFF)
1139 {
1140 /* Get the service pack string */
1141 Status = RtlFindMessage(NtosEntry->DllBase,
1142 11,
1143 0,
1144 WINDOWS_NT_CSD_STRING,
1145 &MsgEntry);
1146 if (NT_SUCCESS(Status))
1147 {
1148 /* Setup the string */
1149 RtlInitAnsiString(&CSDString, (PCHAR)MsgEntry->Text);
1150
1151 /* Remove trailing newline */
1152 while ((CSDString.Length > 0) &&
1153 ((CSDString.Buffer[CSDString.Length - 1] == '\r') ||
1154 (CSDString.Buffer[CSDString.Length - 1] == '\n')))
1155 {
1156 /* Skip the trailing character */
1157 CSDString.Length--;
1158 }
1159
1160 /* Fill the buffer with version information */
1162 sizeof(Buffer),
1163 "%Z %u%c",
1164 &CSDString,
1165 (CmNtCSDVersion & 0xFF00) >> 8,
1166 (CmNtCSDVersion & 0xFF) ?
1167 'A' + (CmNtCSDVersion & 0xFF) - 1 :
1168 ANSI_NULL);
1169 }
1170 else
1171 {
1172 /* Build default string */
1174 sizeof(Buffer),
1175 "CSD %04x",
1177 }
1178
1179 /* Check for success */
1180 if (!NT_SUCCESS(Status))
1181 {
1182 /* Fail */
1183 KeBugCheckEx(PHASE0_INITIALIZATION_FAILED, Status, 0, 0, 0);
1184 }
1185 }
1186 else
1187 {
1188 /* Then this is a beta */
1190 sizeof(Buffer),
1192 NULL,
1193 &Remaining,
1194 0);
1195 if (!NT_SUCCESS(Status))
1196 {
1197 /* Fail */
1198 KeBugCheckEx(PHASE0_INITIALIZATION_FAILED, Status, 0, 0, 0);
1199 }
1200
1201 /* Update length */
1202 CmCSDVersionString.MaximumLength = sizeof(Buffer) - (USHORT)Remaining;
1203 }
1204
1205 /* Check if we have an RC number */
1206 if ((CmNtCSDVersion & 0xFFFF0000) && (CmNtCSDReleaseType == 1))
1207 {
1208 /* Check if we have no version data yet */
1209 if (!(*Buffer))
1210 {
1211 /* Set defaults */
1212 Remaining = sizeof(Buffer);
1213 RcEnd = Buffer;
1214 }
1215 else
1216 {
1217 /* Add comma and space */
1219 sizeof(Buffer),
1220 ", ",
1221 &RcEnd,
1222 &Remaining,
1223 0);
1224 if (!NT_SUCCESS(Status))
1225 {
1226 /* Fail */
1227 KeBugCheckEx(PHASE0_INITIALIZATION_FAILED, Status, 0, 0, 0);
1228 }
1229 }
1230
1231 /* Add the version format string */
1232 Status = RtlStringCbPrintfA(RcEnd,
1233 Remaining,
1234 "v.%u",
1235 (CmNtCSDVersion & 0xFFFF0000) >> 16);
1236 if (!NT_SUCCESS(Status))
1237 {
1238 /* Fail */
1239 KeBugCheckEx(PHASE0_INITIALIZATION_FAILED, Status, 0, 0, 0);
1240 }
1241 }
1242
1243 /* Now setup the final string */
1244 RtlInitAnsiString(&CSDString, Buffer);
1246 &CSDString,
1247 TRUE);
1248 if (!NT_SUCCESS(Status))
1249 {
1250 /* Fail */
1251 KeBugCheckEx(PHASE0_INITIALIZATION_FAILED, Status, 0, 0, 0);
1252 }
1253
1254 /* Add our version */
1255 Status = RtlStringCbPrintfA(VersionBuffer,
1256 sizeof(VersionBuffer),
1257 "%u.%u",
1260 if (!NT_SUCCESS(Status))
1261 {
1262 /* Fail */
1263 KeBugCheckEx(PHASE0_INITIALIZATION_FAILED, Status, 0, 0, 0);
1264 }
1265
1266 /* Build the final version string */
1268
1269 /* Check if the user wants a kernel stack trace database */
1271 {
1272 /* FIXME: TODO */
1273 DPRINT1("Kernel-mode stack trace support not yet present."
1274 "FLG_KERNEL_STACK_TRACE_DB flag ignored.\n");
1275 }
1276
1277 /* Check if he wanted exception logging */
1279 {
1280 /* FIXME: TODO */
1281 DPRINT1("Kernel-mode exception logging support not yet present."
1282 "FLG_ENABLE_EXCEPTION_LOGGING flag ignored.\n");
1283 }
1284
1285 /* Initialize the Handle Table */
1287
1288#if DBG
1289 /* On checked builds, allocate the system call count table */
1292 KiServiceLimit * sizeof(ULONG),
1293 'llaC');
1294
1295 /* Use it for the shadow table too */
1297
1298 /* Make sure allocation succeeded */
1300 {
1301 /* Zero the call counts to 0 */
1303 KiServiceLimit * sizeof(ULONG));
1304 }
1305#endif
1306
1307 /* Create the Basic Object Manager Types to allow new Object Types */
1308 if (!ObInitSystem()) KeBugCheck(OBJECT_INITIALIZATION_FAILED);
1309
1310 /* Load basic Security for other Managers */
1311 if (!SeInitSystem()) KeBugCheck(SECURITY_INITIALIZATION_FAILED);
1312
1313 /* Initialize the Process Manager */
1314 if (!PsInitSystem(LoaderBlock)) KeBugCheck(PROCESS_INITIALIZATION_FAILED);
1315
1316 /* Initialize the PnP Manager */
1317 if (!PpInitSystem()) KeBugCheck(PP0_INITIALIZATION_FAILED);
1318
1319 /* Initialize the User-Mode Debugging Subsystem */
1321
1322 /* Calculate the tick count multiplier */
1324 SharedUserData->TickCountMultiplier = ExpTickCountMultiplier;
1325
1326 /* Set the OS Version */
1327 SharedUserData->NtMajorVersion = NtMajorVersion;
1328 SharedUserData->NtMinorVersion = NtMinorVersion;
1329
1330 /* Set the machine type */
1331 SharedUserData->ImageNumberLow = IMAGE_FILE_MACHINE_NATIVE;
1332 SharedUserData->ImageNumberHigh = IMAGE_FILE_MACHINE_NATIVE;
1333}
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:877
ULONG CmNtCSDReleaseType
Definition: init.c:60
PVOID ExpNlsTableBase
Definition: init.c:85
ULONG NTAPI ExComputeTickCountMultiplier(IN ULONG ClockIncrement)
Definition: init.c:606
BOOLEAN IoRemoteBootClient
Definition: init.c:70
UNICODE_STRING NtSystemRoot
Definition: init.c:76
ULONG ExpOemCodePageDataOffset
Definition: init.c:86
NLSTABLEINFO ExpNlsTableInfo
Definition: init.c:88
BOOLEAN NTAPI ExpIsLoaderValid(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: init.c:770
ULONG NtMajorVersion
Definition: init.c:45
ULONG ExpUnicodeCaseTableDataOffset
Definition: init.c:87
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:86
ULONG NtMinorVersion
Definition: init.c:46
VOID NTAPI ExpLoadBootSymbols(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: init.c:796
ULONG CmNtCSDVersion
Definition: init.c:59
VOID NTAPI ExpInitNls(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: init.c:213
UNICODE_STRING CmCSDVersionString
Definition: init.c:62
BOOLEAN NTAPI ExInitSystem(VOID)
Definition: init.c:744
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 213 of file init.c.

214{
215 LARGE_INTEGER SectionSize;
217 HANDLE NlsSection;
218 PVOID SectionBase = NULL;
219 SIZE_T ViewSize = 0;
220 LARGE_INTEGER SectionOffset = {{0, 0}};
221 PLIST_ENTRY ListHead, NextEntry;
223 ULONG NlsTablesEncountered = 0;
224 SIZE_T NlsTableSizes[3] = {0, 0, 0}; /* 3 NLS tables */
225
226 /* Check if this is boot-time phase 0 initialization */
228 {
229 /* Loop the memory descriptors */
230 ListHead = &LoaderBlock->MemoryDescriptorListHead;
231 NextEntry = ListHead->Flink;
232 while (NextEntry != ListHead)
233 {
234 /* Get the current block */
235 MdBlock = CONTAINING_RECORD(NextEntry,
237 ListEntry);
238
239 /* Check if this is an NLS block */
240 if (MdBlock->MemoryType == LoaderNlsData)
241 {
242 /* Increase the table size */
243 ExpNlsTableSize += MdBlock->PageCount * PAGE_SIZE;
244
245 /* FreeLdr-specific */
246 NlsTableSizes[NlsTablesEncountered] = MdBlock->PageCount * PAGE_SIZE;
247 NlsTablesEncountered++;
248 ASSERT(NlsTablesEncountered < 4);
249 }
250
251 /* Go to the next block */
252 NextEntry = MdBlock->ListEntry.Flink;
253 }
254
255 /* Allocate the a new buffer since loader memory will be freed */
258 TAG_RTLI);
259 if (!ExpNlsTableBase) KeBugCheck(PHASE0_INITIALIZATION_FAILED);
260
261 /* Copy the codepage data in its new location. */
262 if (NlsTablesEncountered == 1)
263 {
264 /* Ntldr-way boot process */
266 LoaderBlock->NlsData->AnsiCodePageData,
268 }
269 else
270 {
271 /*
272 * In NT, the memory blocks are contiguous, but in ReactOS they aren't,
273 * so unless someone fixes FreeLdr, we'll have to use this icky hack.
274 */
276 LoaderBlock->NlsData->AnsiCodePageData,
277 NlsTableSizes[0]);
278
279 RtlCopyMemory((PVOID)((ULONG_PTR)ExpNlsTableBase + NlsTableSizes[0]),
280 LoaderBlock->NlsData->OemCodePageData,
281 NlsTableSizes[1]);
282
283 RtlCopyMemory((PVOID)((ULONG_PTR)ExpNlsTableBase + NlsTableSizes[0] +
284 NlsTableSizes[1]),
285 LoaderBlock->NlsData->UnicodeCodePageData,
286 NlsTableSizes[2]);
287 /* End of Hack */
288 }
289
290 /* Initialize and reset the NLS TAbles */
299 return;
300 }
301
302 /* Set the section size */
303 SectionSize.QuadPart = ExpNlsTableSize;
304
305 /* Create the NLS Section */
306 Status = ZwCreateSection(&NlsSection,
308 NULL,
309 &SectionSize,
311 SEC_COMMIT | 0x1,
312 NULL);
313 if (!NT_SUCCESS(Status))
314 {
315 /* Failed */
316 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 1, 0, 0);
317 }
318
319 /* Get a pointer to the section */
325 NULL);
326 ObCloseHandle(NlsSection, KernelMode);
327 if (!NT_SUCCESS(Status))
328 {
329 /* Failed */
330 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 2, 0, 0);
331 }
332
333 /* Map the NLS Section in system space */
335 &SectionBase,
337 if (!NT_SUCCESS(Status))
338 {
339 /* Failed */
340 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 3, 0, 0);
341 }
342
343 /* Copy the codepage data in its new location. */
344 ASSERT(SectionBase >= MmSystemRangeStart);
346
347 /* Free the previously allocated buffer and set the new location */
349 ExpNlsTableBase = SectionBase;
350
351 /* Initialize the NLS Tables */
360
361 /* Reset the base to 0 */
362 SectionBase = NULL;
363
364 /* Map the section in the system process */
367 &SectionBase,
368 0L,
369 0L,
371 &ViewSize,
372 ViewShare,
373 0L,
375 if (!NT_SUCCESS(Status))
376 {
377 /* Failed */
378 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 5, 0, 0);
379 }
380
381 /* Copy the table into the system process and set this as the base */
383 ExpNlsTableBase = SectionBase;
384}
#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:89
PVOID ExpNlsSectionPointer
Definition: init.c:90
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:4447
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:3996
POBJECT_TYPE MmSectionObjectType
Definition: section.c:194
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 639 of file init.c.

640{
641 /* Initialize EXRESOURCE Support */
643
644 /* Initialize the environment lock */
646
647 /* Initialize the lookaside lists and locks */
649
650 /* Initialize the Firmware Table resource and listhead */
654
655 /* Set the suite mask to maximum and return */
656 ExSuiteMask = 0xFFFFFFFF;
657 return TRUE;
658}
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:173
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 663 of file init.c.

664{
665 /* Initialize worker threads */
667
668 /* Initialize pushlocks */
670
671 /* Initialize events and event pairs */
673 {
674 DPRINT1("Executive: Event initialization failed\n");
675 return FALSE;
676 }
678 {
679 DPRINT1("Executive: Event Pair initialization failed\n");
680 return FALSE;
681 }
682
683 /* Initialize mutants */
685 {
686 DPRINT1("Executive: Mutant initialization failed\n");
687 return FALSE;
688 }
689
690 /* Initialize callbacks */
692 {
693 DPRINT1("Executive: Callback initialization failed\n");
694 return FALSE;
695 }
696
697 /* Initialize semaphores */
699 {
700 DPRINT1("Executive: Semaphore initialization failed\n");
701 return FALSE;
702 }
703
704 /* Initialize timers */
706 {
707 DPRINT1("Executive: Timer initialization failed\n");
708 return FALSE;
709 }
710
711 /* Initialize profiling */
713 {
714 DPRINT1("Executive: Profile initialization failed\n");
715 return FALSE;
716 }
717
718 /* Initialize UUIDs */
720 {
721 DPRINT1("Executive: Uuid initialization failed\n");
722 return FALSE;
723 }
724
725 /* Initialize keyed events */
727 {
728 DPRINT1("Executive: Keyed event initialization failed\n");
729 return FALSE;
730 }
731
732 /* Initialize Win32K */
733 if (ExpWin32kInit() == FALSE)
734 {
735 DPRINT1("Executive: Win32 initialization failed\n");
736 return FALSE;
737 }
738 return TRUE;
739}
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 770 of file init.c.

771{
773
774 /* Get the loader extension */
775 Extension = LoaderBlock->Extension;
776
777 /* Validate the size (Windows 2003 loader doesn't provide more) */
779
780 /* Don't validate upper versions */
781 if (Extension->MajorVersion > VER_PRODUCTMAJORVERSION) return TRUE;
782
783 /* Fail if this is NT 4 */
784 if (Extension->MajorVersion < VER_PRODUCTMAJORVERSION) return FALSE;
785
786 /* Fail if this is XP */
787 if (Extension->MinorVersion < VER_PRODUCTMINORVERSION) return FALSE;
788
789 /* This is 2003 or newer, approve it */
790 return TRUE;
791}
_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 796 of file init.c.

797{
798 ULONG i = 0;
799 PLIST_ENTRY NextEntry;
801 PWCHAR Name;
802 PLDR_DATA_TABLE_ENTRY LdrEntry;
803 CHAR NameBuffer[256];
804 STRING SymbolString;
806
807 /* Loop the driver list */
808 NextEntry = LoaderBlock->LoadOrderListHead.Flink;
809 while (NextEntry != &LoaderBlock->LoadOrderListHead)
810 {
811 /* Skip the first two images */
812 if (i >= 2)
813 {
814 /* Get the entry */
815 LdrEntry = CONTAINING_RECORD(NextEntry,
817 InLoadOrderLinks);
818 if (LdrEntry->FullDllName.Buffer[0] == L'\\')
819 {
820 /* We have a name, read its data */
821 Name = LdrEntry->FullDllName.Buffer;
822 Length = LdrEntry->FullDllName.Length / sizeof(WCHAR);
823
824 /* Check if our buffer can hold it */
825 if (sizeof(NameBuffer) < Length + sizeof(ANSI_NULL))
826 {
827 /* It's too long */
829 }
830 else
831 {
832 /* Copy the name */
833 Count = 0;
834 do
835 {
836 /* Copy the character */
837 NameBuffer[Count++] = (CHAR)*Name++;
838 } while (Count < Length);
839
840 /* Null-terminate */
841 NameBuffer[Count] = ANSI_NULL;
843 }
844 }
845 else
846 {
847 /* Safely print the string into our buffer */
848 Status = RtlStringCbPrintfA(NameBuffer,
849 sizeof(NameBuffer),
850 "%S\\System32\\Drivers\\%wZ",
851 &SharedUserData->NtSystemRoot[2],
852 &LdrEntry->BaseDllName);
853 }
854
855 /* Check if the buffer was ok */
856 if (NT_SUCCESS(Status))
857 {
858 /* Initialize the STRING for the debugger */
859 RtlInitString(&SymbolString, NameBuffer);
860
861 /* Load the symbols */
862 DbgLoadImageSymbols(&SymbolString,
863 LdrEntry->DllBase,
865 }
866 }
867
868 /* Go to the next entry */
869 i++;
870 NextEntry = NextEntry->Flink;
871 }
872}
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 389 of file init.c.

392{
394 SIZE_T Size;
395 PWSTR p;
396 UNICODE_STRING NullString = RTL_CONSTANT_STRING(L"");
397 UNICODE_STRING SmssName, Environment, SystemDriveString, DebugString;
398 PVOID EnvironmentPtr = NULL;
399 PRTL_USER_PROCESS_INFORMATION ProcessInformation;
400 PRTL_USER_PROCESS_PARAMETERS ProcessParams = NULL;
401
402 NullString.Length = sizeof(WCHAR);
403
404 /* Use the initial buffer, after the strings */
405 ProcessInformation = &InitBuffer->ProcessInfo;
406
407 /* Allocate memory for the process parameters */
408 Size = sizeof(*ProcessParams) + ((MAX_WIN32_PATH * 6) * sizeof(WCHAR));
409 Status = ZwAllocateVirtualMemory(NtCurrentProcess(),
410 (PVOID*)&ProcessParams,
411 0,
412 &Size,
415 if (!NT_SUCCESS(Status))
416 {
417 /* Failed, display error */
418 _snwprintf(InitBuffer->DebugBuffer,
419 sizeof(InitBuffer->DebugBuffer)/sizeof(WCHAR),
420 L"INIT: Unable to allocate Process Parameters. 0x%lx",
421 Status);
422 RtlInitUnicodeString(&DebugString, InitBuffer->DebugBuffer);
424
425 /* Bugcheck the system */
426 KeBugCheckEx(SESSION1_INITIALIZATION_FAILED, Status, 0, 0, 0);
427 }
428
429 /* Setup the basic header, and give the process the low 1MB to itself */
430 ProcessParams->Length = (ULONG)Size;
431 ProcessParams->MaximumLength = (ULONG)Size;
434
435 /* Allocate a page for the environment */
436 Size = PAGE_SIZE;
437 Status = ZwAllocateVirtualMemory(NtCurrentProcess(),
438 &EnvironmentPtr,
439 0,
440 &Size,
443 if (!NT_SUCCESS(Status))
444 {
445 /* Failed, display error */
446 _snwprintf(InitBuffer->DebugBuffer,
447 sizeof(InitBuffer->DebugBuffer)/sizeof(WCHAR),
448 L"INIT: Unable to allocate Process Environment. 0x%lx",
449 Status);
450 RtlInitUnicodeString(&DebugString, InitBuffer->DebugBuffer);
452
453 /* Bugcheck the system */
454 KeBugCheckEx(SESSION2_INITIALIZATION_FAILED, Status, 0, 0, 0);
455 }
456
457 /* Write the pointer */
458 ProcessParams->Environment = EnvironmentPtr;
459
460 /* Make a buffer for the DOS path */
461 p = (PWSTR)(ProcessParams + 1);
462 ProcessParams->CurrentDirectory.DosPath.Buffer = p;
464 sizeof(WCHAR);
465
466 /* Copy the DOS path */
468 &NtSystemRoot);
469
470 /* Make a buffer for the DLL Path */
471 p = (PWSTR)((PCHAR)ProcessParams->CurrentDirectory.DosPath.Buffer +
472 ProcessParams->CurrentDirectory.DosPath.MaximumLength);
473 ProcessParams->DllPath.Buffer = p;
474 ProcessParams->DllPath.MaximumLength = MAX_WIN32_PATH * sizeof(WCHAR);
475
476 /* Copy the DLL path and append the system32 directory */
477 RtlCopyUnicodeString(&ProcessParams->DllPath,
478 &ProcessParams->CurrentDirectory.DosPath);
479 RtlAppendUnicodeToString(&ProcessParams->DllPath, L"\\System32");
480
481 /* Make a buffer for the image name */
482 p = (PWSTR)((PCHAR)ProcessParams->DllPath.Buffer +
483 ProcessParams->DllPath.MaximumLength);
484 ProcessParams->ImagePathName.Buffer = p;
485 ProcessParams->ImagePathName.MaximumLength = MAX_WIN32_PATH * sizeof(WCHAR);
486
487 /* Make sure the buffer is a valid string which within the given length */
492 sizeof(NtInitialUserProcessBuffer) - sizeof(WCHAR)))))
493 {
494 /* Invalid initial process string, bugcheck */
495 KeBugCheckEx(SESSION2_INITIALIZATION_FAILED,
500 }
501
502 /* Cut out anything after a space */
504 while ((*p) && (*p != L' ')) p++;
505
506 /* Set the image path length */
507 ProcessParams->ImagePathName.Length =
509
510 /* Copy the actual buffer */
511 RtlCopyMemory(ProcessParams->ImagePathName.Buffer,
513 ProcessParams->ImagePathName.Length);
514
515 /* Null-terminate it */
516 ProcessParams->ImagePathName.Buffer[ProcessParams->ImagePathName.Length /
517 sizeof(WCHAR)] = UNICODE_NULL;
518
519 /* Make a buffer for the command line */
520 p = (PWSTR)((PCHAR)ProcessParams->ImagePathName.Buffer +
521 ProcessParams->ImagePathName.MaximumLength);
522 ProcessParams->CommandLine.Buffer = p;
523 ProcessParams->CommandLine.MaximumLength = MAX_WIN32_PATH * sizeof(WCHAR);
524
525 /* Add the image name to the command line */
528
529 /* Create the environment string */
530 RtlInitEmptyUnicodeString(&Environment,
531 ProcessParams->Environment,
532 (USHORT)Size);
533
534 /* Append the DLL path to it */
538
539 /* Create the system drive string */
540 SystemDriveString = NtSystemRoot;
541 SystemDriveString.Length = 2 * sizeof(WCHAR);
542
543 /* Append it to the environment */
544 RtlAppendUnicodeToString(&Environment, L"SystemDrive=");
545 RtlAppendUnicodeStringToString(&Environment, &SystemDriveString);
547
548 /* Append the system root to the environment */
549 RtlAppendUnicodeToString(&Environment, L"SystemRoot=");
552
553 /* Prepare the prefetcher */
554 //CcPfBeginBootPhase(150);
555
556 /* Create SMSS process */
557 SmssName = ProcessParams->ImagePathName;
558 Status = RtlCreateUserProcess(&SmssName,
560 RtlDeNormalizeProcessParams(ProcessParams),
561 NULL,
562 NULL,
563 NULL,
564 FALSE,
565 NULL,
566 NULL,
567 ProcessInformation);
568 if (!NT_SUCCESS(Status))
569 {
570 /* Failed, display error */
571 _snwprintf(InitBuffer->DebugBuffer,
572 sizeof(InitBuffer->DebugBuffer)/sizeof(WCHAR),
573 L"INIT: Unable to create Session Manager. 0x%lx",
574 Status);
575 RtlInitUnicodeString(&DebugString, InitBuffer->DebugBuffer);
577
578 /* Bugcheck the system */
579 KeBugCheckEx(SESSION3_INITIALIZATION_FAILED, Status, 0, 0, 0);
580 }
581
582 /* Resume the thread */
583 Status = ZwResumeThread(ProcessInformation->ThreadHandle, NULL);
584 if (!NT_SUCCESS(Status))
585 {
586 /* Failed, display error */
587 _snwprintf(InitBuffer->DebugBuffer,
588 sizeof(InitBuffer->DebugBuffer)/sizeof(WCHAR),
589 L"INIT: Unable to resume Session Manager. 0x%lx",
590 Status);
591 RtlInitUnicodeString(&DebugString, InitBuffer->DebugBuffer);
593
594 /* Bugcheck the system */
595 KeBugCheckEx(SESSION4_INITIALIZATION_FAILED, Status, 0, 0, 0);
596 }
597
598 /* Return success */
599 *ProcessParameters = ProcessParams;
600 *ProcessEnvironment = EnvironmentPtr;
601}
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:79
ULONG NtInitialUserProcessBufferType
Definition: init.c:82
ULONG NtInitialUserProcessBufferLength
Definition: init.c:80
#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:1013
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:526
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
PMMPTE PteAddress
Definition: mm.h:386
PFN_NUMBER Flink
Definition: mm.h:377
union _MMPFN::@1791 u3
struct _MMPFN::@1791::@1797 e2
union _MMPFN::@1789 u1
union _MMPTE::@2326 u
ULONG_PTR Long
Definition: mmtypes.h:215
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:778

Referenced by Phase1InitializationDiscard().

◆ Phase1Initialization()

VOID NTAPI Phase1Initialization ( IN PVOID  Context)

Definition at line 2023 of file init.c.

2024{
2025 /* Do the .INIT part of Phase 1 which we can free later */
2027
2028 /* Jump into zero page thread */
2030}
VOID NTAPI Phase1InitializationDiscard(IN PVOID Context)
Definition: init.c:1342
VOID NTAPI MmZeroPageThread(VOID)
Definition: zeropage.c:36

Referenced by PspInitPhase0().

◆ Phase1InitializationDiscard()

VOID NTAPI Phase1InitializationDiscard ( IN PVOID  Context)

Definition at line 1342 of file init.c.

1343{
1344 PLOADER_PARAMETER_BLOCK LoaderBlock = Context;
1345 NTSTATUS Status, MsgStatus;
1347 LARGE_INTEGER SystemBootTime, UniversalBootTime, OldTime, Timeout;
1348 BOOLEAN NoGuiBoot, ResetBias = FALSE, AlternateShell = FALSE;
1349 PLDR_DATA_TABLE_ENTRY NtosEntry;
1350 PMESSAGE_RESOURCE_ENTRY MsgEntry;
1351 PCHAR CommandLine, Y2KHackRequired, SafeBoot, Environment;
1352 PCHAR StringBuffer, EndBuffer, BeginBuffer, MpString = "";
1353 PINIT_BUFFER InitBuffer;
1354 ANSI_STRING TempString;
1355 ULONG LastTzBias, Length, YearHack = 0, Disposition, MessageCode = 0;
1356 SIZE_T Size;
1357 size_t Remaining;
1359 KEY_VALUE_PARTIAL_INFORMATION KeyPartialInfo;
1362 HANDLE KeyHandle, OptionHandle;
1363 PRTL_USER_PROCESS_PARAMETERS ProcessParameters = NULL;
1364
1365 /* Allocate the initialization buffer */
1367 sizeof(INIT_BUFFER),
1368 TAG_INIT);
1369 if (!InitBuffer)
1370 {
1371 /* Bugcheck */
1372 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, STATUS_NO_MEMORY, 8, 0, 0);
1373 }
1374
1375 /* Set to phase 1 */
1377
1378 /* Set us at maximum priority */
1380
1381 /* Do Phase 1 HAL Initialization */
1382 if (!HalInitSystem(1, LoaderBlock)) KeBugCheck(HAL1_INITIALIZATION_FAILED);
1383
1384 /* Get the command line and upcase it */
1385 CommandLine = (LoaderBlock->LoadOptions ? _strupr(LoaderBlock->LoadOptions) : NULL);
1386
1387 /* Check if GUI Boot is enabled */
1388 NoGuiBoot = (CommandLine && strstr(CommandLine, "NOGUIBOOT") != NULL);
1389
1390 /* Get the SOS setting */
1391 SosEnabled = (CommandLine && strstr(CommandLine, "SOS") != NULL);
1392
1393 /* Setup the boot video driver */
1394 InbvEnableBootDriver(!NoGuiBoot);
1396
1397 /* Check if GUI boot is enabled */
1398 if (!NoGuiBoot)
1399 {
1400 /* It is, display the boot logo and enable printing strings */
1403 }
1404 else
1405 {
1406 /* Release display ownership if not using GUI boot */
1408
1409 /* Don't allow boot-time strings */
1411 }
1412
1413 /* Check if this is LiveCD (WinPE) mode */
1414 if (CommandLine && strstr(CommandLine, "MININT") != NULL)
1415 {
1416 /* Setup WinPE Settings */
1418 InitWinPEModeType |= (strstr(CommandLine, "INRAM") != NULL) ? 0x80000000 : 0x00000001;
1419 }
1420
1421 /* Get the kernel's load entry */
1422 NtosEntry = CONTAINING_RECORD(LoaderBlock->LoadOrderListHead.Flink,
1424 InLoadOrderLinks);
1425
1426 /* Find the banner message */
1427 MsgStatus = RtlFindMessage(NtosEntry->DllBase,
1428 11,
1429 0,
1430 WINDOWS_NT_BANNER,
1431 &MsgEntry);
1432
1433 /* Setup defaults and check if we have a version string */
1434 StringBuffer = InitBuffer->VersionBuffer;
1435 BeginBuffer = StringBuffer;
1436 EndBuffer = StringBuffer;
1437 Remaining = sizeof(InitBuffer->VersionBuffer);
1439 {
1440 /* Print the version string */
1442 Remaining,
1443 &EndBuffer,
1444 &Remaining,
1445 0,
1446 ": %wZ",
1448 if (!NT_SUCCESS(Status))
1449 {
1450 /* Bugcheck */
1451 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 7, 0, 0);
1452 }
1453 }
1454 else
1455 {
1456 /* No version */
1457 *EndBuffer = ANSI_NULL; /* Null-terminate the string */
1458 }
1459
1460 /* Skip over the null-terminator to start a new string */
1461 ++EndBuffer;
1462 --Remaining;
1463
1464 /* Build the version number */
1465 StringBuffer = InitBuffer->VersionNumber;
1467 sizeof(InitBuffer->VersionNumber),
1468 "%u.%u",
1471 if (!NT_SUCCESS(Status))
1472 {
1473 /* Bugcheck */
1474 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 7, 0, 0);
1475 }
1476
1477 /* Check if we had found a banner message */
1478 if (NT_SUCCESS(MsgStatus))
1479 {
1480 /* Create the banner message */
1481 /* ReactOS specific: Report ReactOS version, NtBuildLab information and reported NT kernel version */
1482 Status = RtlStringCbPrintfA(EndBuffer,
1483 Remaining,
1484 (PCHAR)MsgEntry->Text,
1485 KERNEL_VERSION_STR,
1486 NtBuildLab,
1488 NtBuildNumber & 0xFFFF,
1489 BeginBuffer);
1490 if (!NT_SUCCESS(Status))
1491 {
1492 /* Bugcheck */
1493 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 7, 0, 0);
1494 }
1495 }
1496 else
1497 {
1498 /* Use hard-coded banner message */
1499 Status = RtlStringCbCopyA(EndBuffer, Remaining, "REACTOS (R)\r\n");
1500 if (!NT_SUCCESS(Status))
1501 {
1502 /* Bugcheck */
1503 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 7, 0, 0);
1504 }
1505 }
1506
1507 /* Display the version string on-screen */
1508 InbvDisplayString(EndBuffer);
1509
1510 /* Initialize Power Subsystem in Phase 0 */
1511 if (!PoInitSystem(0)) KeBugCheck(INTERNAL_POWER_ERROR);
1512
1513 /* Check for Y2K hack */
1514 Y2KHackRequired = CommandLine ? strstr(CommandLine, "YEAR") : NULL;
1515 if (Y2KHackRequired) Y2KHackRequired = strstr(Y2KHackRequired, "=");
1516 if (Y2KHackRequired) YearHack = atol(Y2KHackRequired + 1);
1517
1518 /* Query the clock */
1520 {
1521 /* Check if we're using the Y2K hack */
1522 if (Y2KHackRequired) TimeFields.Year = (CSHORT)YearHack;
1523
1524 /* Convert to time fields */
1525 RtlTimeFieldsToTime(&TimeFields, &SystemBootTime);
1526 UniversalBootTime = SystemBootTime;
1527
1528 /* Check if real time is GMT */
1530 {
1531 /* Check if we don't have a valid bias */
1533 {
1534 /* Reset */
1535 ResetBias = TRUE;
1537 }
1538
1539 /* Calculate the bias in seconds */
1541 10000000);
1542
1543 /* Set the boot time-zone bias */
1544 SharedUserData->TimeZoneBias.High2Time = ExpTimeZoneBias.HighPart;
1545 SharedUserData->TimeZoneBias.LowPart = ExpTimeZoneBias.LowPart;
1546 SharedUserData->TimeZoneBias.High1Time = ExpTimeZoneBias.HighPart;
1547
1548 /* Convert the boot time to local time, and set it */
1549 UniversalBootTime.QuadPart = SystemBootTime.QuadPart +
1551 }
1552
1553 /* Update the system time and notify the system */
1554 KeSetSystemTime(&UniversalBootTime, &OldTime, FALSE, NULL);
1556
1557 /* Remember this as the boot time */
1558 KeBootTime = UniversalBootTime;
1559 KeBootTimeBias = 0;
1560 }
1561
1562#ifdef CONFIG_SMP
1563 /* Start Application Processors */
1565#endif
1566
1567 /* Initialize all processors */
1568 if (!HalAllProcessorsStarted()) KeBugCheck(HAL1_INITIALIZATION_FAILED);
1569
1570#ifdef CONFIG_SMP
1571 /* HACK: We should use RtlFindMessage and not only fallback to this */
1572 MpString = "MultiProcessor Kernel\r\n";
1573#endif
1574
1575 /* Setup the "MP" String */
1576 RtlInitAnsiString(&TempString, MpString);
1577
1578 /* Make sure to remove the \r\n if we actually have a string */
1579 while ((TempString.Length > 0) &&
1580 ((TempString.Buffer[TempString.Length - 1] == '\r') ||
1581 (TempString.Buffer[TempString.Length - 1] == '\n')))
1582 {
1583 /* Skip the trailing character */
1584 TempString.Length--;
1585 }
1586
1587 /* Get the information string from our resource file */
1588 MsgStatus = RtlFindMessage(NtosEntry->DllBase,
1589 11,
1590 0,
1591 KeNumberProcessors > 1 ?
1592 WINDOWS_NT_INFO_STRING_PLURAL :
1593 WINDOWS_NT_INFO_STRING,
1594 &MsgEntry);
1595
1596 /* Get total RAM size, in MiB */
1597 /* Round size up. Assumed to better match actual physical RAM size */
1598 Size = ALIGN_UP_BY(MmNumberOfPhysicalPages * PAGE_SIZE, 1024 * 1024) / (1024 * 1024);
1599
1600 /* Create the string */
1601 StringBuffer = InitBuffer->VersionBuffer;
1603 sizeof(InitBuffer->VersionBuffer),
1604 NT_SUCCESS(MsgStatus) ?
1605 (PCHAR)MsgEntry->Text :
1606 "%u System Processor [%Iu MB Memory] %Z\r\n",
1608 Size,
1609 &TempString);
1610 if (!NT_SUCCESS(Status))
1611 {
1612 /* Bugcheck */
1613 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 4, 0, 0);
1614 }
1615
1616 /* Display RAM and CPU count */
1618
1619 /* Update the progress bar */
1621
1622 /* Call OB initialization again */
1623 if (!ObInitSystem()) KeBugCheck(OBJECT1_INITIALIZATION_FAILED);
1624
1625 /* Initialize Basic System Objects and Worker Threads */
1626 if (!ExInitSystem()) KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, 0, 0, 1, 0);
1627
1628 /* Initialize the later stages of the kernel */
1629 if (!KeInitSystem()) KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, 0, 0, 2, 0);
1630
1631 /* Call KD Providers at Phase 1 */
1633 {
1634 /* Failed, bugcheck */
1635 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, 0, 0, 3, 0);
1636 }
1637
1638 /* Initialize the SRM in Phase 1 */
1639 if (!SeInitSystem()) KeBugCheck(SECURITY1_INITIALIZATION_FAILED);
1640
1641 /* Update the progress bar */
1643
1644 /* Create SystemRoot Link */
1645 Status = ExpCreateSystemRootLink(LoaderBlock);
1646 if (!NT_SUCCESS(Status))
1647 {
1648 /* Failed to create the system root link */
1649 KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 0, 0, 0);
1650 }
1651
1652 /* Set up Region Maps, Sections and the Paging File */
1653 if (!MmInitSystem(1, LoaderBlock)) KeBugCheck(MEMORY1_INITIALIZATION_FAILED);
1654
1655 /* Create NLS section */
1656 ExpInitNls(LoaderBlock);
1657
1658 /* Initialize Cache Views */
1659 if (!CcInitializeCacheManager()) KeBugCheck(CACHE_INITIALIZATION_FAILED);
1660
1661 /* Initialize the Registry */
1662 if (!CmInitSystem1()) KeBugCheck(CONFIG_INITIALIZATION_FAILED);
1663
1664 /* Initialize Prefetcher */
1666
1667 /* Update progress bar */
1669
1670 /* Update timezone information */
1671 LastTzBias = ExpLastTimeZoneBias;
1672 ExRefreshTimeZoneInformation(&SystemBootTime);
1673
1674 /* Check if we're resetting timezone data */
1675 if (ResetBias)
1676 {
1677 /* Convert the local time to system time */
1678 ExLocalTimeToSystemTime(&SystemBootTime, &UniversalBootTime);
1679 KeBootTime = UniversalBootTime;
1680 KeBootTimeBias = 0;
1681
1682 /* Set the new time */
1683 KeSetSystemTime(&UniversalBootTime, &OldTime, FALSE, NULL);
1684 }
1685 else
1686 {
1687 /* Check if the timezone switched and update the time */
1688 if (LastTzBias != ExpLastTimeZoneBias)
1690 }
1691
1692 /* Initialize the File System Runtime Library */
1693 if (!FsRtlInitSystem()) KeBugCheck(FILE_INITIALIZATION_FAILED);
1694
1695 /* Initialize range lists */
1697
1698 /* Report all resources used by HAL */
1700
1701 /* Call the debugger DLL */
1702 KdDebuggerInitialize1(LoaderBlock);
1703
1704 /* Setup PnP Manager in phase 1 */
1705 if (!PpInitSystem()) KeBugCheck(PP1_INITIALIZATION_FAILED);
1706
1707 /* Update progress bar */
1709
1710 /* Initialize LPC */
1711 if (!LpcInitSystem()) KeBugCheck(LPC_INITIALIZATION_FAILED);
1712
1713 /* Make sure we have a command line */
1714 if (CommandLine)
1715 {
1716 /* Check if this is a safe mode boot */
1717 SafeBoot = strstr(CommandLine, "SAFEBOOT:");
1718 if (SafeBoot)
1719 {
1720 /* Check what kind of boot this is */
1721 SafeBoot += 9;
1722 if (!strncmp(SafeBoot, "MINIMAL", 7))
1723 {
1724 /* Minimal mode */
1725 InitSafeBootMode = 1;
1726 SafeBoot += 7;
1727 MessageCode = BOOTING_IN_SAFEMODE_MINIMAL;
1728 }
1729 else if (!strncmp(SafeBoot, "NETWORK", 7))
1730 {
1731 /* With Networking */
1732 InitSafeBootMode = 2;
1733 SafeBoot += 7;
1734 MessageCode = BOOTING_IN_SAFEMODE_NETWORK;
1735 }
1736 else if (!strncmp(SafeBoot, "DSREPAIR", 8))
1737 {
1738 /* Domain Server Repair */
1739 InitSafeBootMode = 3;
1740 SafeBoot += 8;
1741 MessageCode = BOOTING_IN_SAFEMODE_DSREPAIR;
1742
1743 }
1744 else
1745 {
1746 /* Invalid */
1747 InitSafeBootMode = 0;
1748 }
1749
1750 /* Check if there's any settings left */
1751 if (*SafeBoot)
1752 {
1753 /* Check if an alternate shell was requested */
1754 if (!strncmp(SafeBoot, "(ALTERNATESHELL)", 16))
1755 {
1756 /* Remember this for later */
1757 AlternateShell = TRUE;
1758 }
1759 }
1760
1761 /* Find the message to print out */
1762 Status = RtlFindMessage(NtosEntry->DllBase,
1763 11,
1764 0,
1765 MessageCode,
1766 &MsgEntry);
1767 if (NT_SUCCESS(Status))
1768 {
1769 /* Display it */
1770 InbvDisplayString((PCHAR)MsgEntry->Text);
1771 }
1772 }
1773 }
1774
1775 /* Make sure we have a command line */
1776 if (CommandLine)
1777 {
1778 /* Check if bootlogging is enabled */
1779 if (strstr(CommandLine, "BOOTLOG"))
1780 {
1781 /* Find the message to print out */
1782 Status = RtlFindMessage(NtosEntry->DllBase,
1783 11,
1784 0,
1785 BOOTLOG_ENABLED,
1786 &MsgEntry);
1787 if (NT_SUCCESS(Status))
1788 {
1789 /* Display it */
1790 InbvDisplayString((PCHAR)MsgEntry->Text);
1791 }
1792
1793 /* Setup boot logging */
1794 //IopInitializeBootLogging(LoaderBlock, InitBuffer->BootlogHeader);
1795 }
1796 }
1797
1798 /* Setup the Executive in Phase 2 */
1799 //ExInitSystemPhase2();
1800
1801 /* Update progress bar */
1803
1804 /* No KD Time Slip is pending */
1806
1807 /* Initialize in-place execution support */
1808 XIPInit(LoaderBlock);
1809
1810 /* Set maximum update to 75% */
1812
1813 /* Initialize the I/O Subsystem */
1814 if (!IoInitSystem(LoaderBlock)) KeBugCheck(IO1_INITIALIZATION_FAILED);
1815
1816 /* Set maximum update to 100% */
1818
1819 /* Are we in safe mode? */
1820 if (InitSafeBootMode)
1821 {
1822 /* Open the safe boot key */
1824 L"\\REGISTRY\\MACHINE\\SYSTEM\\CURRENTCONTROLSET"
1825 L"\\CONTROL\\SAFEBOOT");
1827 &KeyName,
1829 NULL,
1830 NULL);
1832 if (NT_SUCCESS(Status))
1833 {
1834 /* First check if we have an alternate shell */
1835 if (AlternateShell)
1836 {
1837 /* Make sure that the registry has one setup */
1838 RtlInitUnicodeString(&KeyName, L"AlternateShell");
1840 &KeyName,
1842 &KeyPartialInfo,
1843 sizeof(KeyPartialInfo),
1844 &Length);
1846 {
1847 AlternateShell = FALSE;
1848 }
1849 }
1850
1851 /* Create the option key */
1852 RtlInitUnicodeString(&KeyName, L"Option");
1854 &KeyName,
1856 KeyHandle,
1857 NULL);
1858 Status = ZwCreateKey(&OptionHandle,
1861 0,
1862 NULL,
1864 &Disposition);
1866
1867 /* Check if the key create worked */
1868 if (NT_SUCCESS(Status))
1869 {
1870 /* Write the safe boot type */
1871 RtlInitUnicodeString(&KeyName, L"OptionValue");
1872 NtSetValueKey(OptionHandle,
1873 &KeyName,
1874 0,
1875 REG_DWORD,
1877 sizeof(InitSafeBootMode));
1878
1879 /* Check if we have to use an alternate shell */
1880 if (AlternateShell)
1881 {
1882 /* Remember this for later */
1883 Disposition = TRUE;
1884 RtlInitUnicodeString(&KeyName, L"UseAlternateShell");
1885 NtSetValueKey(OptionHandle,
1886 &KeyName,
1887 0,
1888 REG_DWORD,
1889 &Disposition,
1890 sizeof(Disposition));
1891 }
1892
1893 /* Close the options key handle */
1894 NtClose(OptionHandle);
1895 }
1896 }
1897 }
1898
1899 /* Are we in Win PE mode? */
1900 if (InitIsWinPEMode)
1901 {
1902 /* Open the safe control key */
1904 L"\\REGISTRY\\MACHINE\\SYSTEM\\CURRENTCONTROLSET"
1905 L"\\CONTROL");
1907 &KeyName,
1909 NULL,
1910 NULL);
1912 if (!NT_SUCCESS(Status))
1913 {
1914 /* Bugcheck */
1915 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 6, 0, 0);
1916 }
1917
1918 /* Create the MiniNT key */
1919 RtlInitUnicodeString(&KeyName, L"MiniNT");
1921 &KeyName,
1923 KeyHandle,
1924 NULL);
1925 Status = ZwCreateKey(&OptionHandle,
1928 0,
1929 NULL,
1931 &Disposition);
1932 if (!NT_SUCCESS(Status))
1933 {
1934 /* Bugcheck */
1935 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 6, 0, 0);
1936 }
1937
1938 /* Close the handles */
1940 NtClose(OptionHandle);
1941 }
1942
1943 /* FIXME: This doesn't do anything for now */
1944 MmArmInitSystem(2, LoaderBlock);
1945
1946 /* Update progress bar */
1948
1949 /* Initialize VDM support */
1950#if defined(_M_IX86)
1952#endif
1953
1954 /* Initialize Power Subsystem in Phase 1*/
1955 if (!PoInitSystem(1)) KeBugCheck(INTERNAL_POWER_ERROR);
1956
1957 /* Update progress bar */
1959
1960 /* Initialize the Process Manager at Phase 1 */
1961 if (!PsInitSystem(LoaderBlock)) KeBugCheck(PROCESS1_INITIALIZATION_FAILED);
1962
1963 /* Make sure nobody touches the loader block again */
1964 if (LoaderBlock == KeLoaderBlock) KeLoaderBlock = NULL;
1965 MmFreeLoaderBlock(LoaderBlock);
1966 LoaderBlock = Context = NULL;
1967
1968 /* Initialize the SRM in phase 1 */
1969 if (!SeRmInitPhase1()) KeBugCheck(PROCESS1_INITIALIZATION_FAILED);
1970
1971 /* Update progress bar */
1973
1974 /* Clear the screen */
1976
1977 /* Allow strings to be displayed */
1979
1980 /* Launch initial process */
1981 ProcessInfo = &InitBuffer->ProcessInfo;
1982 ExpLoadInitialProcess(InitBuffer, &ProcessParameters, &Environment);
1983
1984 /* Wait 5 seconds for initial process to initialize */
1985 Timeout.QuadPart = Int32x32To64(5, -10000000);
1986 Status = ZwWaitForSingleObject(ProcessInfo->ProcessHandle, FALSE, &Timeout);
1987 if (Status == STATUS_SUCCESS)
1988 {
1989 /* Failed, display error */
1990 DPRINT1("INIT: Session Manager terminated.\n");
1991
1992 /* Bugcheck the system if SMSS couldn't initialize */
1993 KeBugCheck(SESSION5_INITIALIZATION_FAILED);
1994 }
1995
1996 /* Close process handles */
1997 ZwClose(ProcessInfo->ThreadHandle);
1998 ZwClose(ProcessInfo->ProcessHandle);
1999
2000 /* Free the initial process environment */
2001 Size = 0;
2002 ZwFreeVirtualMemory(NtCurrentProcess(),
2003 (PVOID*)&Environment,
2004 &Size,
2005 MEM_RELEASE);
2006
2007 /* Free the initial process parameters */
2008 Size = 0;
2009 ZwFreeVirtualMemory(NtCurrentProcess(),
2010 (PVOID*)&ProcessParameters,
2011 &Size,
2012 MEM_RELEASE);
2013
2014 /* Increase init phase */
2016
2017 /* Free the boot buffer */
2018 ExFreePoolWithTag(InitBuffer, TAG_INIT);
2019}
#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:799
VOID NTAPI DisplayBootBitmap(_In_ BOOLEAN TextMode)
Definition: bootanim.c:507
BOOLEAN NTAPI CmInitSystem1(VOID)
Definition: cmsysini.c:1618
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:93
ULONG NtBuildNumber
Definition: init.c:50
NTSTATUS NTAPI ExpCreateSystemRootLink(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: init.c:101
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:389
BOOLEAN ExpRealTimeIsUniversal
Definition: init.c:94
BOOLEAN SosEnabled
Definition: init.c:73
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
VOID NTAPI KeStartAllProcessors(VOID)
Definition: mproc.c:20
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:206
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_RESOURCES
Definition: resource.h:55
#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:1319
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
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 93 of file init.c.

Referenced by KeSetSystemTime(), and Phase1InitializationDiscard().

◆ ExpAnsiCodePageDataOffset

ULONG ExpAnsiCodePageDataOffset

Definition at line 86 of file init.c.

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

◆ ExpInitializationPhase

◆ ExpInTextModeSetup

BOOLEAN ExpInTextModeSetup

Definition at line 69 of file init.c.

Referenced by CmpGetRegistryPath(), DisplayBootBitmap(), and ExpInitializeExecutive().

◆ ExpNlsSectionPointer

PVOID ExpNlsSectionPointer

Definition at line 90 of file init.c.

Referenced by ExpInitNls(), and MmCreatePeb().

◆ ExpNlsTableBase

PVOID ExpNlsTableBase

Definition at line 85 of file init.c.

Referenced by ExpInitializeExecutive(), and ExpInitNls().

◆ ExpNlsTableInfo

NLSTABLEINFO ExpNlsTableInfo

Definition at line 88 of file init.c.

Referenced by ExpInitializeExecutive(), and ExpInitNls().

◆ ExpNlsTableSize

SIZE_T ExpNlsTableSize

Definition at line 89 of file init.c.

Referenced by ExpInitNls().

◆ ExpOemCodePageDataOffset

ULONG ExpOemCodePageDataOffset

Definition at line 86 of file init.c.

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

◆ ExpRealTimeIsUniversal

BOOLEAN ExpRealTimeIsUniversal

Definition at line 94 of file init.c.

Referenced by Phase1InitializationDiscard().

◆ ExpUnicodeCaseTableDataOffset

ULONG ExpUnicodeCaseTableDataOffset

Definition at line 87 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 79 of file init.c.

Referenced by ExpLoadInitialProcess().

◆ NtInitialUserProcessBufferLength

ULONG NtInitialUserProcessBufferLength
Initial value:
sizeof(WCHAR)

Definition at line 80 of file init.c.

Referenced by ExpLoadInitialProcess().

◆ NtInitialUserProcessBufferType

ULONG NtInitialUserProcessBufferType = REG_SZ

Definition at line 82 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

◆ SosEnabled

BOOLEAN SosEnabled

Definition at line 73 of file init.c.

Referenced by Phase1InitializationDiscard().