[MOUNTMGR] Fix invalid WorkerReferences check in QueueWorkItem()
[reactos.git] / boot / freeldr / freeldr / arch / i386 / pcmem.c
1 /*
2 * FreeLoader
3 *
4 * Copyright ... ... (See below.)
5 * Copyright 2017 Serge Gautherie <reactos-git_serge_171003@gautherie.fr>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Note: Most of this code comes from the old file "i386mem.c", which
22 * was Copyright (C) 1998-2003 Brian Palmer <brianp@sginet.com>
23 */
24
25 #include <freeldr.h>
26 #include <arch/pc/x86common.h>
27
28 #include <debug.h>
29 DBG_DEFAULT_CHANNEL(MEMORY);
30
31 #define ULONGLONG_ALIGN_DOWN_BY(size, align) \
32 ((ULONGLONG)(size) & ~((ULONGLONG)(align) - 1))
33
34 #define ULONGLONG_ALIGN_UP_BY(size, align) \
35 (ULONGLONG_ALIGN_DOWN_BY(((ULONGLONG)(size) + align - 1), align))
36
37 BIOS_MEMORY_MAP PcBiosMemoryMap[MAX_BIOS_DESCRIPTORS];
38 ULONG PcBiosMapCount;
39
40 FREELDR_MEMORY_DESCRIPTOR PcMemoryMap[MAX_BIOS_DESCRIPTORS + 1];
41 ULONG PcMapCount;
42
43 ULONG
44 AddMemoryDescriptor(
45 IN OUT PFREELDR_MEMORY_DESCRIPTOR List,
46 IN ULONG MaxCount,
47 IN PFN_NUMBER BasePage,
48 IN PFN_NUMBER PageCount,
49 IN TYPE_OF_MEMORY MemoryType);
50
51 static
52 BOOLEAN
53 GetExtendedMemoryConfiguration(ULONG* pMemoryAtOneMB /* in KB */, ULONG* pMemoryAtSixteenMB /* in 64KB */)
54 {
55 REGS RegsIn;
56 REGS RegsOut;
57
58 TRACE("GetExtendedMemoryConfiguration()\n");
59
60 *pMemoryAtOneMB = 0;
61 *pMemoryAtSixteenMB = 0;
62
63 // Int 15h AX=E801h
64 // Phoenix BIOS v4.0 - GET MEMORY SIZE FOR >64M CONFIGURATIONS
65 //
66 // AX = E801h
67 // Return:
68 // CF clear if successful
69 // AX = extended memory between 1M and 16M, in K (max 3C00h = 15MB)
70 // BX = extended memory above 16M, in 64K blocks
71 // CX = configured memory 1M to 16M, in K
72 // DX = configured memory above 16M, in 64K blocks
73 // CF set on error
74 RegsIn.w.ax = 0xE801;
75 Int386(0x15, &RegsIn, &RegsOut);
76
77 TRACE("Int15h AX=E801h\n");
78 TRACE("AX = 0x%x\n", RegsOut.w.ax);
79 TRACE("BX = 0x%x\n", RegsOut.w.bx);
80 TRACE("CX = 0x%x\n", RegsOut.w.cx);
81 TRACE("DX = 0x%x\n", RegsOut.w.dx);
82 TRACE("CF set = %s\n", (RegsOut.x.eflags & EFLAGS_CF) ? "TRUE" : "FALSE");
83
84 if (INT386_SUCCESS(RegsOut))
85 {
86 // If AX=BX=0000h the use CX and DX
87 if (RegsOut.w.ax == 0)
88 {
89 // Return extended memory size in K
90 *pMemoryAtSixteenMB = RegsOut.w.dx;
91 *pMemoryAtOneMB = RegsOut.w.cx;
92 return TRUE;
93 }
94 else
95 {
96 // Return extended memory size in K
97 *pMemoryAtSixteenMB = RegsOut.w.bx;
98 *pMemoryAtOneMB = RegsOut.w.ax;
99 return TRUE;
100 }
101 }
102
103 // If we get here then Int15 Func E801h didn't work
104 // So try Int15 Func 88h
105 // Int 15h AH=88h
106 // SYSTEM - GET EXTENDED MEMORY SIZE (286+)
107 //
108 // AH = 88h
109 // Return:
110 // CF clear if successful
111 // AX = number of contiguous KB starting at absolute address 100000h
112 // CF set on error
113 // AH = status
114 // 80h invalid command (PC,PCjr)
115 // 86h unsupported function (XT,PS30)
116 RegsIn.b.ah = 0x88;
117 Int386(0x15, &RegsIn, &RegsOut);
118
119 TRACE("Int15h AH=88h\n");
120 TRACE("AX = 0x%x\n", RegsOut.w.ax);
121 TRACE("CF set = %s\n", (RegsOut.x.eflags & EFLAGS_CF) ? "TRUE" : "FALSE");
122
123 if (INT386_SUCCESS(RegsOut) && RegsOut.w.ax != 0)
124 {
125 *pMemoryAtOneMB = RegsOut.w.ax;
126 return TRUE;
127 }
128
129 // If we get here then Int15 Func 88h didn't work
130 // So try reading the CMOS
131 WRITE_PORT_UCHAR((PUCHAR)0x70, 0x31);
132 *pMemoryAtOneMB = READ_PORT_UCHAR((PUCHAR)0x71);
133 *pMemoryAtOneMB = (*pMemoryAtOneMB & 0xFFFF);
134 *pMemoryAtOneMB = (*pMemoryAtOneMB << 8);
135
136 TRACE("Int15h Failed\n");
137 TRACE("CMOS reports: 0x%lx\n", *pMemoryAtOneMB);
138
139 if (*pMemoryAtOneMB != 0)
140 {
141 return TRUE;
142 }
143
144 return FALSE;
145 }
146
147 static
148 ULONG
149 PcMemGetConventionalMemorySize(VOID)
150 {
151 REGS Regs;
152
153 TRACE("PcMemGetConventionalMemorySize()\n");
154
155 /* Int 12h
156 * BIOS - GET MEMORY SIZE
157 *
158 * Return:
159 * AX = kilobytes of contiguous memory starting at absolute address 00000h
160 *
161 * This call returns the contents of the word at 0040h:0013h;
162 * in PC and XT, this value is set from the switches on the motherboard
163 */
164 Regs.w.ax = 0;
165 Int386(0x12, &Regs, &Regs);
166
167 TRACE("Int12h\n");
168 TRACE("AX = 0x%x\n", Regs.w.ax);
169
170 return (ULONG)Regs.w.ax;
171 }
172
173 static
174 BOOLEAN
175 GetEbdaLocation(
176 PULONG BaseAddress,
177 PULONG Size)
178 {
179 REGS Regs;
180
181 TRACE("GetEbdaLocation()\n");
182
183 /* Get the address of the Extended BIOS Data Area (EBDA).
184 * Int 15h, AH=C1h
185 * SYSTEM - RETURN EXTENDED-BIOS DATA-AREA SEGMENT ADDRESS (PS)
186 *
187 * Return:
188 * CF set on error
189 * CF clear if successful
190 * ES = segment of data area
191 */
192 Regs.x.eax = 0x0000C100;
193 Int386(0x15, &Regs, &Regs);
194
195 /* If the function fails, there is no EBDA */
196 if (!INT386_SUCCESS(Regs))
197 {
198 return FALSE;
199 }
200
201 /* Get Base address and (maximum) size */
202 *BaseAddress = (ULONG)Regs.w.es << 4;
203 *Size = 0xA0000 - *BaseAddress;
204 return TRUE;
205 }
206
207 static
208 VOID
209 PcMemCheckUsableMemorySize(VOID)
210 {
211 ULONG Size, RequiredSize;
212
213 TRACE("PcMemCheckUsableMemorySize()\n");
214
215 /* Make sure the usable memory is large enough. To do this we check the 16
216 bit value at address 0x413 inside the BDA, which gives us the usable size
217 in KB */
218 Size = (*(PUSHORT)(ULONG_PTR)0x413) * 1024;
219 RequiredSize = FREELDR_BASE + FrLdrImageSize + PAGE_SIZE;
220 if (Size < RequiredSize)
221 {
222 FrLdrBugCheckWithMessage(
223 MEMORY_INIT_FAILURE,
224 __FILE__,
225 __LINE__,
226 "The BIOS reported a usable memory range up to 0x%lx, which is too small!\n"
227 "Required size is 0x%lx\n\n"
228 "If you see this, please report to the ReactOS team!",
229 Size, RequiredSize);
230 }
231 }
232
233 static
234 ULONG
235 PcMemGetBiosMemoryMap(PFREELDR_MEMORY_DESCRIPTOR MemoryMap, ULONG MaxMemoryMapSize)
236 {
237 REGS Regs;
238 ULONGLONG RealBaseAddress, EndAddress, RealSize;
239 TYPE_OF_MEMORY MemoryType;
240
241 ASSERT(PcBiosMapCount == 0);
242
243 TRACE("PcMemGetBiosMemoryMap()\n");
244
245 /* Int 15h AX=E820h
246 * Newer BIOSes - GET SYSTEM MEMORY MAP
247 *
248 * AX = E820h
249 * EAX = 0000E820h
250 * EDX = 534D4150h ('SMAP')
251 * EBX = continuation value or 00000000h to start at beginning of map
252 * ECX = size of buffer for result, in bytes (should be >= 20 bytes)
253 * ES:DI -> buffer for result
254 * Return:
255 * CF clear if successful
256 * EAX = 534D4150h ('SMAP')
257 * ES:DI buffer filled
258 * EBX = next offset from which to copy or 00000000h if all done
259 * ECX = actual length returned in bytes
260 * CF set on error
261 * AH = error code (86h)
262 */
263 Regs.x.ebx = 0x00000000;
264
265 while (PcBiosMapCount < MAX_BIOS_DESCRIPTORS)
266 {
267 /* ACPI 3.0/4.0: Set Extended Attributes to enabled/valid by default, in case entry has no E.A.. */
268 ((PBIOS_MEMORY_MAP)BIOSCALLBUFFER)->ExtendedAttributesAsULONG = 0;
269 ((PBIOS_MEMORY_MAP)BIOSCALLBUFFER)->ExtendedAttributes.Enabled_Reserved = 1;
270
271 /* Setup the registers for the BIOS call */
272 Regs.x.eax = 0x0000E820;
273 Regs.x.edx = 0x534D4150; /* ('SMAP') */
274 /* Regs.x.ebx = 0x00000001; Continuation value already set */
275 Regs.x.ecx = sizeof(BIOS_MEMORY_MAP);
276 Regs.w.es = BIOSCALLBUFSEGMENT;
277 Regs.w.di = BIOSCALLBUFOFFSET;
278 Int386(0x15, &Regs, &Regs);
279
280 TRACE("Memory Map Entry %lu\n", PcBiosMapCount);
281 TRACE("Int15h AX=E820h\n");
282 TRACE("EAX = 0x%lx\n", Regs.x.eax);
283 TRACE("EBX = 0x%lx\n", Regs.x.ebx);
284 TRACE("ECX = %lu\n", Regs.x.ecx);
285 TRACE("CF set = %s\n", (Regs.x.eflags & EFLAGS_CF) ? "TRUE" : "FALSE");
286
287 /* If the BIOS didn't return 'SMAP' in EAX then
288 * it doesn't support this call. */
289 if (Regs.x.eax != 0x534D4150)
290 {
291 WARN("BIOS doesn't support Int15h AX=E820h!\n");
292 break;
293 }
294
295 /* If the carry flag is set,
296 * then this call was past the last entry, so we're done. */
297 if (!INT386_SUCCESS(Regs))
298 {
299 TRACE("End of System Memory Map! (Past last)\n");
300 break;
301 }
302
303 if (Regs.x.ecx == 0)
304 {
305 TRACE("Discard empty entry. (would-be-PcBiosMapCount = %lu)\n",
306 PcBiosMapCount);
307 goto nextRange;
308 }
309
310 /* Extra safety: unexpected entry length.
311 * All in-between values are valid too, as x86 is little-indian
312 * and only lower byte is used per ACPI 6.2-A.
313 */
314 if (Regs.x.ecx < RTL_SIZEOF_THROUGH_FIELD(BIOS_MEMORY_MAP, Type) ||
315 Regs.x.ecx > sizeof(BIOS_MEMORY_MAP))
316 {
317 ERR("Int 15h AX=E820h returned an invalid entry length! (would-be-PcBiosMapCount = %lu, Entry length = (%Iu <=) %lu (<= %Iu))\n",
318 PcBiosMapCount, RTL_SIZEOF_THROUGH_FIELD(BIOS_MEMORY_MAP, Type), Regs.x.ecx, sizeof(BIOS_MEMORY_MAP));
319 /* Warn user, unless wrong case is "first and not too big entry", which is otherwise harmless. */
320 if (PcBiosMapCount > 0 || Regs.x.ecx > sizeof(BIOS_MEMORY_MAP))
321 {
322 ASSERTMSG("Int 15h AX=E820h returned an invalid entry length!\n", FALSE);
323 }
324 /* We keep previous entries (if any), but do not dare trying next entries.
325 * We assume these entries are good to use as is. If they are not, we are in trouble...
326 * (And don't ask what happens if BIOS actually overflowed our entry buffer...)
327 *
328 * FIXME: Safer = revert previous entries, Safest = blacklist this BIOS.
329 */
330 break;
331 }
332
333 if (((PBIOS_MEMORY_MAP)BIOSCALLBUFFER)->ExtendedAttributes.Enabled_Reserved == 0)
334 {
335 WARN("Discard disabled/invalid entry. (would-be-PcBiosMapCount = %lu)\n",
336 PcBiosMapCount);
337 /* This unlikely case was correct between ACPI 3.0 and 4.0, so assume all is fine.
338 * Unless we would be ready to drop ACPI 3.0 compatibility.
339 */
340 goto nextRange;
341 }
342
343 /* Copy data to global buffer */
344 RtlCopyMemory(&PcBiosMemoryMap[PcBiosMapCount], (PVOID)BIOSCALLBUFFER, sizeof(BIOS_MEMORY_MAP));
345
346 TRACE("BaseAddress: 0x%llx\n", PcBiosMemoryMap[PcBiosMapCount].BaseAddress);
347 TRACE("Length: 0x%llx\n", PcBiosMemoryMap[PcBiosMapCount].Length);
348 TRACE("Type: 0x%lx\n", PcBiosMemoryMap[PcBiosMapCount].Type);
349 TRACE("ExtendedAttributesAsULONG: 0x%08lx\n", PcBiosMemoryMap[PcBiosMapCount].ExtendedAttributesAsULONG);
350
351 if (PcBiosMemoryMap[PcBiosMapCount].ExtendedAttributes.ErrorLog == 1)
352 {
353 FIXME("EA.ErrorLog = 1. Please report this to CORE-14150. "
354 "(PcBiosMapCount = %lu, BaseAddress = 0x%llx, Length = 0x%llx, Type = 0x%lx, ExtendedAttributesAsULONG = 0x%08lx)\n",
355 PcBiosMapCount,
356 PcBiosMemoryMap[PcBiosMapCount].BaseAddress,
357 PcBiosMemoryMap[PcBiosMapCount].Length,
358 PcBiosMemoryMap[PcBiosMapCount].Type,
359 PcBiosMemoryMap[PcBiosMapCount].ExtendedAttributesAsULONG);
360 // NotWantedForPublicBuilds: ASSERTMSG("EA.ErrorLog = 1. Check/Report then CONTinue.\n", FALSE);
361 }
362
363 if (PcBiosMemoryMap[PcBiosMapCount].Length == 0)
364 {
365 TRACE("Discard empty range. (would-be-PcBiosMapCount = %lu, BaseAddress = 0x%llx, Length = 0)\n",
366 PcBiosMapCount, PcBiosMemoryMap[PcBiosMapCount].BaseAddress);
367 goto nextRange;
368 }
369
370 /* Check if this is free memory */
371 if (PcBiosMemoryMap[PcBiosMapCount].Type == BiosMemoryUsable)
372 {
373 MemoryType = LoaderFree;
374
375 /* Align up base of memory range */
376 RealBaseAddress = ULONGLONG_ALIGN_UP_BY(
377 PcBiosMemoryMap[PcBiosMapCount].BaseAddress,
378 PAGE_SIZE);
379
380 /* Calculate aligned EndAddress */
381 EndAddress = PcBiosMemoryMap[PcBiosMapCount].BaseAddress +
382 PcBiosMemoryMap[PcBiosMapCount].Length;
383 EndAddress = ULONGLONG_ALIGN_DOWN_BY(EndAddress, PAGE_SIZE);
384
385 /* Check if there is anything left */
386 if (EndAddress <= RealBaseAddress)
387 {
388 /* This doesn't span any page, so continue with next range */
389 TRACE("Skipping aligned range < PAGE_SIZE. (would-be-PcBiosMapCount = %lu, BaseAddress = 0x%llx, Length = 0x%llx)\n",
390 PcBiosMapCount,
391 PcBiosMemoryMap[PcBiosMapCount].BaseAddress,
392 PcBiosMemoryMap[PcBiosMapCount].Length);
393 goto nextRange;
394 }
395
396 /* Calculate the length of the aligned range */
397 RealSize = EndAddress - RealBaseAddress;
398 }
399 else
400 {
401 if (PcBiosMemoryMap[PcBiosMapCount].Type == BiosMemoryReserved)
402 {
403 MemoryType = LoaderFirmwarePermanent;
404 }
405 else
406 {
407 MemoryType = LoaderSpecialMemory;
408 }
409
410 /* Align down base of memory area */
411 RealBaseAddress = ULONGLONG_ALIGN_DOWN_BY(
412 PcBiosMemoryMap[PcBiosMapCount].BaseAddress,
413 PAGE_SIZE);
414
415 /* Calculate the length after aligning the base */
416 RealSize = PcBiosMemoryMap[PcBiosMapCount].BaseAddress +
417 PcBiosMemoryMap[PcBiosMapCount].Length - RealBaseAddress;
418 RealSize = ULONGLONG_ALIGN_UP_BY(RealSize, PAGE_SIZE);
419 }
420
421 /* Check if we can add this descriptor */
422 if (RealSize < MM_PAGE_SIZE)
423 {
424 TRACE("Skipping aligned range < MM_PAGE_SIZE. (PcBiosMapCount = %lu, BaseAddress = 0x%llx, Length = 0x%llx)\n",
425 PcBiosMapCount,
426 PcBiosMemoryMap[PcBiosMapCount].BaseAddress,
427 PcBiosMemoryMap[PcBiosMapCount].Length);
428 }
429 else if (PcMapCount >= MaxMemoryMapSize)
430 {
431 ERR("PcMemoryMap is already full! (PcBiosMapCount = %lu, PcMapCount = %lu (>= %lu))\n",
432 PcBiosMapCount, PcMapCount, MaxMemoryMapSize);
433 // NotWantedForPublicBuilds: ASSERTMSG("PcMemoryMap is already full!\n", FALSE);
434 /* We keep previous entries, and half-retrieve current/next entries.
435 * We assume all these entries are good to use as is. If they are not, we are in trouble...
436 *
437 * FIXME: Safer = revert (half-)retrieved entries, Safest = increase MaxMemoryMapSize.
438 */
439 }
440 else
441 {
442 /* Add the descriptor */
443 PcMapCount = AddMemoryDescriptor(PcMemoryMap,
444 MAX_BIOS_DESCRIPTORS,
445 (PFN_NUMBER)(RealBaseAddress / MM_PAGE_SIZE),
446 (PFN_NUMBER)(RealSize / MM_PAGE_SIZE),
447 MemoryType);
448 }
449
450 PcBiosMapCount++;
451
452 nextRange:
453 /* If the continuation value is zero,
454 * then this was the last entry, so we're done. */
455 if (Regs.x.ebx == 0x00000000)
456 {
457 TRACE("End of System Memory Map! (Reset)\n");
458 break;
459 }
460 }
461 /* Check whether there would be more entries to process. */
462 if (PcBiosMapCount >= MAX_BIOS_DESCRIPTORS && Regs.x.ebx != 0x00000000)
463 {
464 ERR("PcBiosMemoryMap is already full! (PcBiosMapCount = %lu (>= %lu), PcMapCount = %lu)\n",
465 PcBiosMapCount, MAX_BIOS_DESCRIPTORS, PcMapCount);
466 // NotWantedForPublicBuilds: ASSERTMSG("PcBiosMemoryMap is already full!\n", FALSE);
467 /* We keep retrieved entries, but ignore next entries.
468 * We assume these entries are good to use as is. If they are not, we are in trouble...
469 *
470 * FIXME: Safer = revert retrieved entries, Safest = increase MAX_BIOS_DESCRIPTORS.
471 */
472 }
473
474 TRACE("PcMemGetBiosMemoryMap end: PcBiosMapCount = %lu\n", PcBiosMapCount);
475 return PcBiosMapCount;
476 }
477
478 VOID
479 ReserveMemory(
480 PFREELDR_MEMORY_DESCRIPTOR MemoryMap,
481 ULONG_PTR BaseAddress,
482 SIZE_T Size,
483 TYPE_OF_MEMORY MemoryType,
484 PCHAR Usage)
485 {
486 ULONG_PTR BasePage, PageCount;
487 ULONG i;
488
489 BasePage = BaseAddress / PAGE_SIZE;
490 PageCount = ADDRESS_AND_SIZE_TO_SPAN_PAGES(BaseAddress, Size);
491
492 for (i = 0; i < PcMapCount; i++)
493 {
494 /* Check for conflicting descriptor */
495 if ((MemoryMap[i].BasePage < BasePage + PageCount) &&
496 (MemoryMap[i].BasePage + MemoryMap[i].PageCount > BasePage))
497 {
498 /* Check if the memory is free */
499 if (MemoryMap[i].MemoryType != LoaderFree)
500 {
501 FrLdrBugCheckWithMessage(
502 MEMORY_INIT_FAILURE,
503 __FILE__,
504 __LINE__,
505 "Failed to reserve memory in the range 0x%Ix - 0x%Ix for %s",
506 BaseAddress,
507 Size,
508 Usage);
509 }
510 }
511 }
512
513 /* Add the memory descriptor */
514 PcMapCount = AddMemoryDescriptor(MemoryMap,
515 MAX_BIOS_DESCRIPTORS,
516 BasePage,
517 PageCount,
518 MemoryType);
519 }
520
521 VOID
522 SetMemory(
523 PFREELDR_MEMORY_DESCRIPTOR MemoryMap,
524 ULONG_PTR BaseAddress,
525 SIZE_T Size,
526 TYPE_OF_MEMORY MemoryType)
527 {
528 ULONG_PTR BasePage, PageCount;
529
530 BasePage = BaseAddress / PAGE_SIZE;
531 PageCount = ADDRESS_AND_SIZE_TO_SPAN_PAGES(BaseAddress, Size);
532
533 /* Add the memory descriptor */
534 PcMapCount = AddMemoryDescriptor(MemoryMap,
535 MAX_BIOS_DESCRIPTORS,
536 BasePage,
537 PageCount,
538 MemoryType);
539 }
540
541 ULONG
542 PcMemFinalizeMemoryMap(
543 PFREELDR_MEMORY_DESCRIPTOR MemoryMap)
544 {
545 ULONG i;
546
547 /* Reserve some static ranges for freeldr */
548 ReserveMemory(MemoryMap, 0x1000, STACKLOW - 0x1000, LoaderFirmwareTemporary, "BIOS area");
549 ReserveMemory(MemoryMap, STACKLOW, STACKADDR - STACKLOW, LoaderOsloaderStack, "FreeLdr stack");
550 ReserveMemory(MemoryMap, FREELDR_BASE, FrLdrImageSize, LoaderLoadedProgram, "FreeLdr image");
551
552 /* Default to 1 page above freeldr for the disk read buffer */
553 DiskReadBuffer = (PUCHAR)ALIGN_UP_BY(FREELDR_BASE + FrLdrImageSize, PAGE_SIZE);
554 DiskReadBufferSize = PAGE_SIZE;
555
556 /* Scan for free range above freeldr image */
557 for (i = 0; i < PcMapCount; i++)
558 {
559 if ((MemoryMap[i].BasePage > (FREELDR_BASE / PAGE_SIZE)) &&
560 (MemoryMap[i].MemoryType == LoaderFree))
561 {
562 /* Use this range for the disk read buffer */
563 DiskReadBuffer = (PVOID)(MemoryMap[i].BasePage * PAGE_SIZE);
564 DiskReadBufferSize = min(MemoryMap[i].PageCount * PAGE_SIZE,
565 MAX_DISKREADBUFFER_SIZE);
566 break;
567 }
568 }
569
570 TRACE("DiskReadBuffer=0x%p, DiskReadBufferSize=0x%lx\n",
571 DiskReadBuffer, DiskReadBufferSize);
572
573 ASSERT(DiskReadBufferSize > 0);
574
575 /* Now reserve the range for the disk read buffer */
576 ReserveMemory(MemoryMap,
577 (ULONG_PTR)DiskReadBuffer,
578 DiskReadBufferSize,
579 LoaderFirmwareTemporary,
580 "Disk read buffer");
581
582 TRACE("Dumping resulting memory map:\n");
583 for (i = 0; i < PcMapCount; i++)
584 {
585 TRACE("BasePage=0x%lx, PageCount=0x%lx, Type=%s\n",
586 MemoryMap[i].BasePage,
587 MemoryMap[i].PageCount,
588 MmGetSystemMemoryMapTypeString(MemoryMap[i].MemoryType));
589 }
590 return PcMapCount;
591 }
592
593 PFREELDR_MEMORY_DESCRIPTOR
594 PcMemGetMemoryMap(ULONG *MemoryMapSize)
595 {
596 ULONG EntryCount;
597 ULONG ExtendedMemorySizeAtOneMB;
598 ULONG ExtendedMemorySizeAtSixteenMB;
599 ULONG EbdaBase, EbdaSize;
600
601 TRACE("PcMemGetMemoryMap()\n");
602
603 PcMemCheckUsableMemorySize();
604
605 EntryCount = PcMemGetBiosMemoryMap(PcMemoryMap, MAX_BIOS_DESCRIPTORS);
606
607 /* If the BIOS didn't provide a memory map, synthesize one */
608 if (EntryCount == 0)
609 {
610 GetExtendedMemoryConfiguration(&ExtendedMemorySizeAtOneMB,
611 &ExtendedMemorySizeAtSixteenMB);
612
613 /* Conventional memory */
614 AddMemoryDescriptor(PcMemoryMap,
615 MAX_BIOS_DESCRIPTORS,
616 0,
617 PcMemGetConventionalMemorySize() * 1024 / PAGE_SIZE,
618 LoaderFree);
619
620 /* Extended memory */
621 PcMapCount = AddMemoryDescriptor(PcMemoryMap,
622 MAX_BIOS_DESCRIPTORS,
623 1024 * 1024 / PAGE_SIZE,
624 ExtendedMemorySizeAtOneMB * 1024 / PAGE_SIZE,
625 LoaderFree);
626
627 if (ExtendedMemorySizeAtSixteenMB != 0)
628 {
629 /* Extended memory at 16MB */
630 PcMapCount = AddMemoryDescriptor(PcMemoryMap,
631 MAX_BIOS_DESCRIPTORS,
632 0x1000000 / PAGE_SIZE,
633 ExtendedMemorySizeAtSixteenMB * 64 * 1024 / PAGE_SIZE,
634 LoaderFree);
635 }
636
637 /* Check if we have an EBDA and get it's location */
638 if (GetEbdaLocation(&EbdaBase, &EbdaSize))
639 {
640 /* Add the descriptor */
641 PcMapCount = AddMemoryDescriptor(PcMemoryMap,
642 MAX_BIOS_DESCRIPTORS,
643 (EbdaBase / PAGE_SIZE),
644 ADDRESS_AND_SIZE_TO_SPAN_PAGES(EbdaBase, EbdaSize),
645 LoaderFirmwarePermanent);
646 }
647 }
648
649 /* Setup some protected ranges */
650 SetMemory(PcMemoryMap, 0x000000, 0x01000, LoaderFirmwarePermanent); // Realmode IVT / BDA
651 SetMemory(PcMemoryMap, 0x0A0000, 0x50000, LoaderFirmwarePermanent); // Video memory
652 SetMemory(PcMemoryMap, 0x0F0000, 0x10000, LoaderSpecialMemory); // ROM
653 SetMemory(PcMemoryMap, 0xFFF000, 0x01000, LoaderSpecialMemory); // unusable memory (do we really need this?)
654
655 *MemoryMapSize = PcMemFinalizeMemoryMap(PcMemoryMap);
656 return PcMemoryMap;
657 }
658
659
660 /* EOF */