bfa68ab904ed3701280eba5b029cee3562108925
[reactos.git] / boot / freeldr / freeldr / windows / wlmemory.c
1 /*
2 * PROJECT: EFI Windows Loader
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: freeldr/winldr/wlmemory.c
5 * PURPOSE: Memory related routines
6 * PROGRAMMERS: Aleksey Bragin (aleksey@reactos.org)
7 */
8
9 /* INCLUDES ***************************************************************/
10
11 #include <freeldr.h>
12
13 #include <ndk/asm.h>
14 #include <debug.h>
15
16 extern ULONG LoaderPagesSpanned;
17
18 PCHAR MemTypeDesc[] = {
19 "ExceptionBlock ", // ?
20 "SystemBlock ", // ?
21 "Free ",
22 "Bad ", // used
23 "LoadedProgram ", // == Free
24 "FirmwareTemporary ", // == Free
25 "FirmwarePermanent ", // == Bad
26 "OsloaderHeap ", // used
27 "OsloaderStack ", // == Free
28 "SystemCode ",
29 "HalCode ",
30 "BootDriver ", // not used
31 "ConsoleInDriver ", // ?
32 "ConsoleOutDriver ", // ?
33 "StartupDpcStack ", // ?
34 "StartupKernelStack", // ?
35 "StartupPanicStack ", // ?
36 "StartupPcrPage ", // ?
37 "StartupPdrPage ", // ?
38 "RegistryData ", // used
39 "MemoryData ", // not used
40 "NlsData ", // used
41 "SpecialMemory ", // == Bad
42 "BBTMemory " // == Bad
43 };
44
45 VOID
46 WinLdrpDumpMemoryDescriptors(PLOADER_PARAMETER_BLOCK LoaderBlock);
47
48
49 VOID
50 MempAddMemoryBlock(IN OUT PLOADER_PARAMETER_BLOCK LoaderBlock,
51 ULONG BasePage,
52 ULONG PageCount,
53 ULONG Type);
54 VOID
55 WinLdrInsertDescriptor(IN OUT PLOADER_PARAMETER_BLOCK LoaderBlock,
56 IN PMEMORY_ALLOCATION_DESCRIPTOR NewDescriptor);
57
58 VOID
59 WinLdrRemoveDescriptor(IN PMEMORY_ALLOCATION_DESCRIPTOR Descriptor);
60
61 VOID
62 WinLdrSetProcessorContext(PVOID GdtIdt, IN ULONG_PTR Pcr, IN ULONG_PTR Tss);
63
64 BOOLEAN
65 MempAllocatePageTables();
66
67 BOOLEAN
68 MempSetupPaging(IN ULONG StartPage,
69 IN ULONG NumberOfPages);
70
71 BOOLEAN
72 WinLdrMapSpecialPages(ULONG PcrBasePage);
73
74 VOID
75 MempUnmapPage(ULONG Page);
76
77 VOID
78 MempDump();
79
80 /* GLOBALS ***************************************************************/
81
82 MEMORY_ALLOCATION_DESCRIPTOR *Mad;
83 ULONG MadCount = 0;
84
85 /* FUNCTIONS **************************************************************/
86
87 VOID
88 MempDisablePages()
89 {
90 ULONG i;
91
92 //
93 // We need to delete kernel mapping from memory areas which are
94 // marked as Special or Permanent memory (thus non-accessible)
95 //
96
97 for (i=0; i<MadCount; i++)
98 {
99 ULONG StartPage, EndPage, Page;
100
101 StartPage = Mad[i].BasePage;
102 EndPage = Mad[i].BasePage + Mad[i].PageCount;
103
104 if (Mad[i].MemoryType == LoaderFirmwarePermanent ||
105 Mad[i].MemoryType == LoaderSpecialMemory ||
106 Mad[i].MemoryType == LoaderFree ||
107 (Mad[i].MemoryType == LoaderFirmwareTemporary && EndPage <= LoaderPagesSpanned) ||
108 Mad[i].MemoryType == LoaderOsloaderStack ||
109 Mad[i].MemoryType == LoaderLoadedProgram)
110 {
111 //
112 // But, the first megabyte of memory always stays!
113 // And, to tell the truth, we don't care about what's higher
114 // than LoaderPagesSpanned
115 if (Mad[i].MemoryType == LoaderFirmwarePermanent ||
116 Mad[i].MemoryType == LoaderSpecialMemory)
117 {
118 if (StartPage < 0x100)
119 StartPage = 0x100;
120
121 if (EndPage > LoaderPagesSpanned)
122 EndPage = LoaderPagesSpanned;
123 }
124
125 for (Page = StartPage; Page < EndPage; Page++)
126 {
127 MempUnmapPage(Page);
128 }
129 }
130 }
131 }
132
133 VOID
134 MempAddMemoryBlock(IN OUT PLOADER_PARAMETER_BLOCK LoaderBlock,
135 ULONG BasePage,
136 ULONG PageCount,
137 ULONG Type)
138 {
139 BOOLEAN Status;
140
141 //
142 // Check for some weird stuff at the top
143 //
144 if (BasePage + PageCount > 0xF0000)
145 {
146 //
147 // Just skip this, without even adding to MAD list
148 //
149 return;
150 }
151
152 //
153 // Set Base page, page count and type
154 //
155 Mad[MadCount].BasePage = BasePage;
156 Mad[MadCount].PageCount = PageCount;
157 Mad[MadCount].MemoryType = Type;
158
159 //
160 // Check if it's more than the allowed for OS loader
161 // if yes - don't map the pages, just add as FirmwareTemporary
162 //
163 if (BasePage + PageCount > LoaderPagesSpanned)
164 {
165 if (Mad[MadCount].MemoryType != LoaderSpecialMemory &&
166 Mad[MadCount].MemoryType != LoaderFirmwarePermanent &&
167 Mad[MadCount].MemoryType != LoaderFree)
168 {
169 DPRINTM(DPRINT_WINDOWS, "Setting page %x %x to Temporary from %d\n",
170 BasePage, PageCount, Mad[MadCount].MemoryType);
171 Mad[MadCount].MemoryType = LoaderFirmwareTemporary;
172 }
173
174 WinLdrInsertDescriptor(LoaderBlock, &Mad[MadCount]);
175 MadCount++;
176
177 return;
178 }
179
180 //
181 // Add descriptor
182 //
183 WinLdrInsertDescriptor(LoaderBlock, &Mad[MadCount]);
184 MadCount++;
185
186 //
187 // Map it (don't map low 1Mb because it was already contiguously
188 // mapped in WinLdrTurnOnPaging)
189 //
190 if (BasePage >= 0x100)
191 {
192 Status = MempSetupPaging(BasePage, PageCount);
193 if (!Status)
194 {
195 DPRINTM(DPRINT_WINDOWS, "Error during MempSetupPaging\n");
196 return;
197 }
198 }
199 }
200
201 #ifdef _M_ARM
202 #define PKTSS PVOID
203 #endif
204
205 BOOLEAN
206 WinLdrTurnOnPaging(IN OUT PLOADER_PARAMETER_BLOCK LoaderBlock,
207 ULONG PcrBasePage,
208 ULONG TssBasePage,
209 PVOID GdtIdt)
210 {
211 ULONG i, PagesCount, MemoryMapSizeInPages;
212 ULONG LastPageIndex, LastPageType, MemoryMapStartPage;
213 PPAGE_LOOKUP_TABLE_ITEM MemoryMap;
214 ULONG NoEntries;
215 PKTSS Tss;
216 BOOLEAN Status;
217
218 //
219 // Creating a suitable memory map for the Windows can be tricky, so let's
220 // give a few advices:
221 // 1) One must not map the whole available memory pages to PDE!
222 // Map only what's needed - 16Mb, 24Mb, 32Mb max I think,
223 // thus occupying 4, 6 or 8 PDE entries for identical mapping,
224 // the same quantity for KSEG0_BASE mapping, one more entry for
225 // hyperspace and one more entry for HAL physical pages mapping.
226 // 2) Memory descriptors must map *the whole* physical memory
227 // showing any memory above 16/24/32 as FirmwareTemporary
228 //
229 // 3) Overall memory blocks count must not exceed 30 (?? why?)
230 //
231
232 //
233 // During MmInitMachineDependent, the kernel zeroes PDE at the following address
234 // 0xC0300000 - 0xC03007FC
235 //
236 // Then it finds the best place for non-paged pool:
237 // StartPde C0300F70, EndPde C0300FF8, NumberOfPages C13, NextPhysPage 3AD
238 //
239
240 // Before we start mapping pages, create a block of memory, which will contain
241 // PDE and PTEs
242 if (MempAllocatePageTables() == FALSE)
243 return FALSE;
244
245 // Allocate memory for memory allocation descriptors
246 Mad = MmHeapAlloc(sizeof(MEMORY_ALLOCATION_DESCRIPTOR) * 1024);
247
248 // Setup an entry for each descriptor
249 MemoryMap = MmGetMemoryMap(&NoEntries);
250 if (MemoryMap == NULL)
251 {
252 UiMessageBox("Can not retrieve the current memory map");
253 return FALSE;
254 }
255
256 // Calculate parameters of the memory map
257 MemoryMapStartPage = (ULONG_PTR)MemoryMap >> MM_PAGE_SHIFT;
258 MemoryMapSizeInPages = NoEntries * sizeof(PAGE_LOOKUP_TABLE_ITEM);
259
260 DPRINTM(DPRINT_WINDOWS, "Got memory map with %d entries\n", NoEntries);
261
262 // Always contiguously map low 1Mb of memory
263 Status = MempSetupPaging(0, 0x100);
264 if (!Status)
265 {
266 DPRINTM(DPRINT_WINDOWS, "Error during MempSetupPaging of low 1Mb\n");
267 return FALSE;
268 }
269
270 // Construct a good memory map from what we've got,
271 // but mark entries which the memory allocation bitmap takes
272 // as free entries (this is done in order to have the ability
273 // to place mem alloc bitmap outside lower 16Mb zone)
274 PagesCount = 1;
275 LastPageIndex = 0;
276 LastPageType = MemoryMap[0].PageAllocated;
277 for (i = 1; i < NoEntries; i++)
278 {
279 // Check if its memory map itself
280 if (i >= MemoryMapStartPage &&
281 i < (MemoryMapStartPage+MemoryMapSizeInPages))
282 {
283 // Exclude it if current page belongs to the memory map
284 MemoryMap[i].PageAllocated = LoaderFree;
285 }
286
287 // Process entry
288 if (MemoryMap[i].PageAllocated == LastPageType &&
289 (i != NoEntries-1) )
290 {
291 PagesCount++;
292 }
293 else
294 {
295 // Add the resulting region
296 MempAddMemoryBlock(LoaderBlock, LastPageIndex, PagesCount, LastPageType);
297
298 // Reset our counter vars
299 LastPageIndex = i;
300 LastPageType = MemoryMap[i].PageAllocated;
301 PagesCount = 1;
302 }
303 }
304
305 // TEMP, DEBUG!
306 // adding special reserved memory zones for vmware workstation
307 #if 0
308 {
309 Mad[MadCount].BasePage = 0xfec00;
310 Mad[MadCount].PageCount = 0x10;
311 Mad[MadCount].MemoryType = LoaderSpecialMemory;
312 WinLdrInsertDescriptor(LoaderBlock, &Mad[MadCount]);
313 MadCount++;
314
315 Mad[MadCount].BasePage = 0xfee00;
316 Mad[MadCount].PageCount = 0x1;
317 Mad[MadCount].MemoryType = LoaderSpecialMemory;
318 WinLdrInsertDescriptor(LoaderBlock, &Mad[MadCount]);
319 MadCount++;
320
321 Mad[MadCount].BasePage = 0xfffe0;
322 Mad[MadCount].PageCount = 0x20;
323 Mad[MadCount].MemoryType = LoaderSpecialMemory;
324 WinLdrInsertDescriptor(LoaderBlock, &Mad[MadCount]);
325 MadCount++;
326 }
327 #endif
328
329 DPRINTM(DPRINT_WINDOWS, "MadCount: %d\n", MadCount);
330
331 WinLdrpDumpMemoryDescriptors(LoaderBlock); //FIXME: Delete!
332
333 // Map our loader image, so we can continue running
334 /*Status = MempSetupPaging(OsLoaderBase >> MM_PAGE_SHIFT, OsLoaderSize >> MM_PAGE_SHIFT);
335 if (!Status)
336 {
337 UiMessageBox("Error during MempSetupPaging");
338 return;
339 }*/
340
341 /* Map stuff like PCR, KI_USER_SHARED_DATA and Apic */
342 WinLdrMapSpecialPages(PcrBasePage);
343
344 Tss = (PKTSS)(KSEG0_BASE | (TssBasePage << MM_PAGE_SHIFT));
345
346 // Unmap what is not needed from kernel page table
347 MempDisablePages();
348
349 // Fill the memory descriptor list and
350 //PrepareMemoryDescriptorList();
351 DPRINTM(DPRINT_WINDOWS, "Memory Descriptor List prepared, printing PDE\n");
352 List_PaToVa(&LoaderBlock->MemoryDescriptorListHead);
353
354 #if DBG
355 MempDump();
356 #endif
357
358 // Set processor context
359 WinLdrSetProcessorContext(GdtIdt, KIP0PCRADDRESS, KSEG0_BASE | (TssBasePage << MM_PAGE_SHIFT));
360
361 // Zero KI_USER_SHARED_DATA page
362 memset((PVOID)KI_USER_SHARED_DATA, 0, MM_PAGE_SIZE);
363
364 return TRUE;
365 }
366
367 // Two special things this func does: it sorts descriptors,
368 // and it merges free ones
369 VOID
370 WinLdrInsertDescriptor(IN OUT PLOADER_PARAMETER_BLOCK LoaderBlock,
371 IN PMEMORY_ALLOCATION_DESCRIPTOR NewDescriptor)
372 {
373 PLIST_ENTRY ListHead = &LoaderBlock->MemoryDescriptorListHead;
374 PLIST_ENTRY PreviousEntry, NextEntry;
375 PMEMORY_ALLOCATION_DESCRIPTOR PreviousDescriptor = NULL, NextDescriptor = NULL;
376
377 DPRINTM(DPRINT_WINDOWS, "BP=0x%X PC=0x%X %s\n", NewDescriptor->BasePage,
378 NewDescriptor->PageCount, MemTypeDesc[NewDescriptor->MemoryType]);
379
380 /* Find a place where to insert the new descriptor to */
381 PreviousEntry = ListHead;
382 NextEntry = ListHead->Flink;
383 while (NextEntry != ListHead)
384 {
385 NextDescriptor = CONTAINING_RECORD(NextEntry,
386 MEMORY_ALLOCATION_DESCRIPTOR,
387 ListEntry);
388 if (NewDescriptor->BasePage < NextDescriptor->BasePage)
389 break;
390
391 PreviousEntry = NextEntry;
392 PreviousDescriptor = NextDescriptor;
393 NextEntry = NextEntry->Flink;
394 }
395
396 /* Don't forget about merging free areas */
397 if (NewDescriptor->MemoryType != LoaderFree)
398 {
399 /* Just insert, nothing to merge */
400 InsertHeadList(PreviousEntry, &NewDescriptor->ListEntry);
401 }
402 else
403 {
404 /* Previous block also free? */
405 if ((PreviousEntry != ListHead) && (PreviousDescriptor->MemoryType == LoaderFree) &&
406 ((PreviousDescriptor->BasePage + PreviousDescriptor->PageCount) ==
407 NewDescriptor->BasePage))
408 {
409 /* Just enlarge previous descriptor's PageCount */
410 PreviousDescriptor->PageCount += NewDescriptor->PageCount;
411 NewDescriptor = PreviousDescriptor;
412 }
413 else
414 {
415 /* Nope, just insert */
416 InsertHeadList(PreviousEntry, &NewDescriptor->ListEntry);
417 }
418
419 /* Next block is free ?*/
420 if ((NextEntry != ListHead) &&
421 (NextDescriptor->MemoryType == LoaderFree) &&
422 ((NewDescriptor->BasePage + NewDescriptor->PageCount) == NextDescriptor->BasePage))
423 {
424 /* Enlarge next descriptor's PageCount */
425 NewDescriptor->PageCount += NextDescriptor->PageCount;
426 RemoveEntryList(&NextDescriptor->ListEntry);
427 }
428 }
429
430 return;
431 }
432