ReactOS 0.4.15-dev-7961-gdcf9eb0
pcmem.c
Go to the documentation of this file.
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>
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
39
42
46 IN ULONG MaxCount,
47 IN PFN_NUMBER BasePage,
48 IN PFN_NUMBER PageCount,
49 IN TYPE_OF_MEMORY MemoryType);
50
51static
53GetExtendedMemoryConfiguration(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
147static
148ULONG
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
173static
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
207static
208VOID
210{
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;
220 if (Size < RequiredSize)
221 {
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!",
230 }
231}
232
233static
234ULONG
236{
237 REGS Regs;
238 ULONGLONG RealBaseAddress, EndAddress, RealSize;
239 TYPE_OF_MEMORY MemoryType;
240
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
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("Discarding empty entry. (would-be-PcBiosMapCount = %lu)\n",
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 */
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",
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("Discarding disabled/invalid entry. (would-be-PcBiosMapCount = %lu)\n",
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 /*
344 * Other deprecated ExtendedAttributes flags such as NonVolatile_Deprecated_Reserved
345 * or SlowAccess_Deprecated_Reserved are simply ignored.
346 */
347
348 /* Copy data to global buffer */
350
351 TRACE("BaseAddress: 0x%llx\n", PcBiosMemoryMap[PcBiosMapCount].BaseAddress);
352 TRACE("Length: 0x%llx\n", PcBiosMemoryMap[PcBiosMapCount].Length);
353 TRACE("Type: 0x%lx\n", PcBiosMemoryMap[PcBiosMapCount].Type);
354 TRACE("ExtendedAttributesAsULONG: 0x%08lx\n", PcBiosMemoryMap[PcBiosMapCount].ExtendedAttributesAsULONG);
355
356 if (PcBiosMemoryMap[PcBiosMapCount].ExtendedAttributes.ErrorLog == 1)
357 {
358 FIXME("EA.ErrorLog = 1. Please report this to CORE-14150. "
359 "(PcBiosMapCount = %lu, BaseAddress = 0x%llx, Length = 0x%llx, Type = 0x%lx, ExtendedAttributesAsULONG = 0x%08lx)\n",
364 PcBiosMemoryMap[PcBiosMapCount].ExtendedAttributesAsULONG);
365 // NotWantedForPublicBuilds: ASSERTMSG("EA.ErrorLog = 1. Check/Report then CONTinue.\n", FALSE);
366 }
367
369 {
370 TRACE("Discarding empty range. (would-be-PcBiosMapCount = %lu, BaseAddress = 0x%llx, Length = 0)\n",
372 goto nextRange;
373 }
374
375 /* Check if this is free memory */
377 {
378 MemoryType = LoaderFree;
379
380 /* Align up base of memory range */
381 RealBaseAddress = ULONGLONG_ALIGN_UP_BY(
383 PAGE_SIZE);
384
385 /* Calculate aligned EndAddress */
388 EndAddress = ULONGLONG_ALIGN_DOWN_BY(EndAddress, PAGE_SIZE);
389
390 /* Check if there is anything left */
391 if (EndAddress <= RealBaseAddress)
392 {
393 /* This doesn't span any page, so continue with next range */
394 TRACE("Skipping aligned range < PAGE_SIZE. (would-be-PcBiosMapCount = %lu, BaseAddress = 0x%llx, Length = 0x%llx)\n",
398 goto nextRange;
399 }
400
401 /* Calculate the length of the aligned range */
402 RealSize = EndAddress - RealBaseAddress;
403 }
404 else
405 {
407 {
408 MemoryType = LoaderFirmwarePermanent;
409 }
410 else
411 {
412 MemoryType = LoaderSpecialMemory;
413 }
414
415 /* Align down base of memory area */
416 RealBaseAddress = ULONGLONG_ALIGN_DOWN_BY(
418 PAGE_SIZE);
419
420 /* Calculate the length after aligning the base */
422 PcBiosMemoryMap[PcBiosMapCount].Length - RealBaseAddress;
423 RealSize = ULONGLONG_ALIGN_UP_BY(RealSize, PAGE_SIZE);
424 }
425
426 /* Check if we can add this descriptor */
427 if (RealSize < MM_PAGE_SIZE)
428 {
429 TRACE("Skipping aligned range < MM_PAGE_SIZE. (PcBiosMapCount = %lu, BaseAddress = 0x%llx, Length = 0x%llx)\n",
433 }
434 else if (PcMapCount >= MaxMemoryMapSize)
435 {
436 ERR("PcMemoryMap is already full! (PcBiosMapCount = %lu, PcMapCount = %lu (>= %lu))\n",
437 PcBiosMapCount, PcMapCount, MaxMemoryMapSize);
438 // NotWantedForPublicBuilds: ASSERTMSG("PcMemoryMap is already full!\n", FALSE);
439 /* We keep previous entries, and half-retrieve current/next entries.
440 * We assume all these entries are good to use as is. If they are not, we are in trouble...
441 *
442 * FIXME: Safer = revert (half-)retrieved entries, Safest = increase MaxMemoryMapSize.
443 */
444 }
445 else
446 {
447 /* Add the descriptor */
450 (PFN_NUMBER)(RealBaseAddress / MM_PAGE_SIZE),
451 (PFN_NUMBER)(RealSize / MM_PAGE_SIZE),
452 MemoryType);
453 }
454
456
457nextRange:
458 /* If the continuation value is zero,
459 * then this was the last entry, so we're done. */
460 if (Regs.x.ebx == 0x00000000)
461 {
462 TRACE("End of System Memory Map! (Reset)\n");
463 break;
464 }
465 }
466 /* Check whether there would be more entries to process. */
467 if (PcBiosMapCount >= MAX_BIOS_DESCRIPTORS && Regs.x.ebx != 0x00000000)
468 {
469 ERR("PcBiosMemoryMap is already full! (PcBiosMapCount = %lu (>= %lu), PcMapCount = %lu)\n",
471 // NotWantedForPublicBuilds: ASSERTMSG("PcBiosMemoryMap is already full!\n", FALSE);
472 /* We keep retrieved entries, but ignore next entries.
473 * We assume these entries are good to use as is. If they are not, we are in trouble...
474 *
475 * FIXME: Safer = revert retrieved entries, Safest = increase MAX_BIOS_DESCRIPTORS.
476 */
477 }
478
479 TRACE("PcMemGetBiosMemoryMap end: PcBiosMapCount = %lu\n", PcBiosMapCount);
480 return PcBiosMapCount;
481}
482
483VOID
487 SIZE_T Size,
488 TYPE_OF_MEMORY MemoryType,
489 PCHAR Usage)
490{
491 ULONG_PTR BasePage, PageCount;
492 ULONG i;
493
494 BasePage = BaseAddress / PAGE_SIZE;
496
497 for (i = 0; i < PcMapCount; i++)
498 {
499 /* Check for conflicting descriptor */
500 if ((MemoryMap[i].BasePage < BasePage + PageCount) &&
501 (MemoryMap[i].BasePage + MemoryMap[i].PageCount > BasePage))
502 {
503 /* Check if the memory is free */
504 if (MemoryMap[i].MemoryType != LoaderFree)
505 {
508 __FILE__,
509 __LINE__,
510 "Failed to reserve memory in the range 0x%Ix - 0x%Ix for %s",
512 Size,
513 Usage);
514 }
515 }
516 }
517
518 /* Add the memory descriptor */
521 BasePage,
522 PageCount,
523 MemoryType);
524}
525
526VOID
530 SIZE_T Size,
531 TYPE_OF_MEMORY MemoryType)
532{
533 ULONG_PTR BasePage, PageCount;
534
535 BasePage = BaseAddress / PAGE_SIZE;
537
538 /* Add the memory descriptor */
541 BasePage,
542 PageCount,
543 MemoryType);
544}
545
546ULONG
549{
550 ULONG i;
551
552 /* Reserve some static ranges for freeldr */
553 ReserveMemory(MemoryMap, 0x1000, STACKLOW - 0x1000, LoaderFirmwareTemporary, "BIOS area");
556
557 /* Default to 1 page above freeldr for the disk read buffer */
560
561 /* Scan for free range above freeldr image */
562 for (i = 0; i < PcMapCount; i++)
563 {
564 if ((MemoryMap[i].BasePage > (FREELDR_BASE / PAGE_SIZE)) &&
565 (MemoryMap[i].MemoryType == LoaderFree))
566 {
567 /* Use this range for the disk read buffer */
568 DiskReadBuffer = (PVOID)(MemoryMap[i].BasePage * PAGE_SIZE);
571 break;
572 }
573 }
574
575 TRACE("DiskReadBuffer=0x%p, DiskReadBufferSize=0x%lx\n",
577
579
580 /* Now reserve the range for the disk read buffer */
585 "Disk read buffer");
586
587 TRACE("Dumping resulting memory map:\n");
588 for (i = 0; i < PcMapCount; i++)
589 {
590 TRACE("BasePage=0x%lx, PageCount=0x%lx, Type=%s\n",
591 MemoryMap[i].BasePage,
592 MemoryMap[i].PageCount,
593 MmGetSystemMemoryMapTypeString(MemoryMap[i].MemoryType));
594 }
595 return PcMapCount;
596}
597
600{
601 ULONG EntryCount;
602 ULONG ExtendedMemorySizeAtOneMB;
603 ULONG ExtendedMemorySizeAtSixteenMB;
604 ULONG EbdaBase, EbdaSize;
605
606 TRACE("PcMemGetMemoryMap()\n");
607
609
611
612 /* If the BIOS didn't provide a memory map, synthesize one */
613 if (EntryCount == 0)
614 {
615 GetExtendedMemoryConfiguration(&ExtendedMemorySizeAtOneMB,
616 &ExtendedMemorySizeAtSixteenMB);
617
618 /* Conventional memory */
621 0,
623 LoaderFree);
624
625 /* Extended memory */
628 1024 * 1024 / PAGE_SIZE,
629 ExtendedMemorySizeAtOneMB * 1024 / PAGE_SIZE,
630 LoaderFree);
631
632 if (ExtendedMemorySizeAtSixteenMB != 0)
633 {
634 /* Extended memory at 16MB */
637 0x1000000 / PAGE_SIZE,
638 ExtendedMemorySizeAtSixteenMB * 64 * 1024 / PAGE_SIZE,
639 LoaderFree);
640 }
641
642 /* Check if we have an EBDA and get it's location */
643 if (GetEbdaLocation(&EbdaBase, &EbdaSize))
644 {
645 /* Add the descriptor */
648 (EbdaBase / PAGE_SIZE),
649 ADDRESS_AND_SIZE_TO_SPAN_PAGES(EbdaBase, EbdaSize),
651 }
652 }
653
654 /* Setup some protected ranges */
655 SetMemory(PcMemoryMap, 0x000000, 0x01000, LoaderFirmwarePermanent); // Realmode IVT / BDA
656 SetMemory(PcMemoryMap, 0x0A0000, 0x50000, LoaderFirmwarePermanent); // Video memory
657 SetMemory(PcMemoryMap, 0x0F0000, 0x10000, LoaderSpecialMemory); // ROM
658 SetMemory(PcMemoryMap, 0xFFF000, 0x01000, LoaderSpecialMemory); // unusable memory (do we really need this?)
659
660 *MemoryMapSize = PcMemFinalizeMemoryMap(PcMemoryMap);
661 return PcMemoryMap;
662}
663
664
665/* EOF */
#define ALIGN_UP_BY(size, align)
unsigned char BOOLEAN
Type
Definition: Type.h:7
BIOS_MEMORY_MAP MemoryMap[32]
Definition: loader.c:11
VOID FrLdrBugCheckWithMessage(ULONG BugCode, PCHAR File, ULONG Line, PSTR Format,...)
Definition: debug.c:28
#define DiskReadBuffer
Definition: hardware.h:33
#define FREELDR_BASE
Definition: hardware.h:18
#define FIXME(fmt,...)
Definition: debug.h:111
@ MEMORY_INIT_FAILURE
Definition: debug.h:143
#define WARN(fmt,...)
Definition: debug.h:112
#define ERR(fmt,...)
Definition: debug.h:110
#define DBG_DEFAULT_CHANNEL(ch)
Definition: debug.h:103
SIZE_T FrLdrImageSize
Definition: meminit.c:35
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define PAGE_SIZE
Definition: env_spec_w32.h:49
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
_Must_inspect_result_ _In_ USAGE _In_ USHORT _In_ USAGE Usage
Definition: hidpi.h:384
SIZE_T DiskReadBufferSize
Definition: hwdisk.c:50
#define ASSERT(a)
Definition: mode.c:44
#define min(a, b)
Definition: monoChain.cc:55
#define EFLAGS_CF
Definition: ketypes.h:184
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID * BaseAddress
Definition: mmfuncs.h:404
#define ASSERTMSG(msg, exp)
Definition: nt_native.h:431
#define RTL_SIZEOF_THROUGH_FIELD(type, field)
Definition: ntbasedef.h:672
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
@ BiosMemoryUsable
Definition: osloader.h:22
@ BiosMemoryReserved
Definition: osloader.h:25
struct BIOS_MEMORY_MAP * PBIOS_MEMORY_MAP
#define READ_PORT_UCHAR(p)
Definition: pc98vid.h:22
#define WRITE_PORT_UCHAR(p, d)
Definition: pc98vid.h:21
#define INT386_SUCCESS(regs)
Definition: pcbios.h:179
#define MAX_BIOS_DESCRIPTORS
Definition: pcbios.h:12
int __cdecl Int386(int ivec, REGS *in, REGS *out)
#define ULONGLONG_ALIGN_UP_BY(size, align)
Definition: pcmem.c:34
FREELDR_MEMORY_DESCRIPTOR PcMemoryMap[MAX_BIOS_DESCRIPTORS+1]
Definition: pcmem.c:40
PFREELDR_MEMORY_DESCRIPTOR PcMemGetMemoryMap(ULONG *MemoryMapSize)
Definition: pcmem.c:599
ULONG PcMemFinalizeMemoryMap(PFREELDR_MEMORY_DESCRIPTOR MemoryMap)
Definition: pcmem.c:547
ULONG PcBiosMapCount
Definition: pcmem.c:38
static VOID PcMemCheckUsableMemorySize(VOID)
Definition: pcmem.c:209
BIOS_MEMORY_MAP PcBiosMemoryMap[MAX_BIOS_DESCRIPTORS]
Definition: pcmem.c:37
#define ULONGLONG_ALIGN_DOWN_BY(size, align)
Definition: pcmem.c:31
VOID ReserveMemory(PFREELDR_MEMORY_DESCRIPTOR MemoryMap, ULONG_PTR BaseAddress, SIZE_T Size, TYPE_OF_MEMORY MemoryType, PCHAR Usage)
Definition: pcmem.c:484
static BOOLEAN GetExtendedMemoryConfiguration(ULONG *pMemoryAtOneMB, ULONG *pMemoryAtSixteenMB)
Definition: pcmem.c:53
static ULONG PcMemGetConventionalMemorySize(VOID)
Definition: pcmem.c:149
ULONG AddMemoryDescriptor(IN OUT PFREELDR_MEMORY_DESCRIPTOR List, IN ULONG MaxCount, IN PFN_NUMBER BasePage, IN PFN_NUMBER PageCount, IN TYPE_OF_MEMORY MemoryType)
Definition: meminit.c:102
ULONG PcMapCount
Definition: pcmem.c:41
static ULONG PcMemGetBiosMemoryMap(PFREELDR_MEMORY_DESCRIPTOR MemoryMap, ULONG MaxMemoryMapSize)
Definition: pcmem.c:235
VOID SetMemory(PFREELDR_MEMORY_DESCRIPTOR MemoryMap, ULONG_PTR BaseAddress, SIZE_T Size, TYPE_OF_MEMORY MemoryType)
Definition: pcmem.c:527
static BOOLEAN GetEbdaLocation(PULONG BaseAddress, PULONG Size)
Definition: pcmem.c:175
@ LoaderFree
Definition: arc.h:176
@ LoaderFirmwareTemporary
Definition: arc.h:179
@ LoaderLoadedProgram
Definition: arc.h:178
@ LoaderFirmwarePermanent
Definition: arc.h:180
@ LoaderOsloaderStack
Definition: arc.h:182
@ LoaderSpecialMemory
Definition: arc.h:196
enum _TYPE_OF_MEMORY TYPE_OF_MEMORY
ULONG PFN_NUMBER
Definition: ke.h:9
#define TRACE(s)
Definition: solgame.cpp:4
LONGLONG BaseAddress
Definition: osloader.h:33
LONGLONG Length
Definition: osloader.h:34
ULONG ErrorLog
Definition: pcbios.h:62
unsigned char ah
Definition: pcbios.h:132
unsigned long ebx
Definition: pcbios.h:92
unsigned long eflags
Definition: pcbios.h:105
unsigned long edx
Definition: pcbios.h:94
unsigned long eax
Definition: pcbios.h:91
unsigned long ecx
Definition: pcbios.h:93
unsigned short es
Definition: pcbios.h:121
unsigned short di
Definition: pcbios.h:117
unsigned short cx
Definition: pcbios.h:113
unsigned short dx
Definition: pcbios.h:114
unsigned short bx
Definition: pcbios.h:112
unsigned short ax
Definition: pcbios.h:111
uint32_t * PULONG
Definition: typedefs.h:59
void * PVOID
Definition: typedefs.h:50
ULONG_PTR SIZE_T
Definition: typedefs.h:80
uint16_t * PUSHORT
Definition: typedefs.h:56
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define IN
Definition: typedefs.h:39
unsigned char * PUCHAR
Definition: typedefs.h:53
uint32_t ULONG
Definition: typedefs.h:59
uint64_t ULONGLONG
Definition: typedefs.h:67
#define OUT
Definition: typedefs.h:40
char * PCHAR
Definition: typedefs.h:51
Definition: pcbios.h:159
DWORDREGS x
Definition: pcbios.h:160
BYTEREGS b
Definition: pcbios.h:163
WORDREGS w
Definition: pcbios.h:162
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ ULONG _Out_ PVOID _Out_ PULONG RequiredSize
Definition: wdfdevice.h:4439
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
#define STACKLOW
Definition: x86common.h:15
#define STACKADDR
Definition: x86common.h:16
#define MAX_DISKREADBUFFER_SIZE
Definition: x86common.h:30
#define BIOSCALLBUFSEGMENT
Definition: x86common.h:21
#define BIOSCALLBUFOFFSET
Definition: x86common.h:22
#define BIOSCALLBUFFER
Definition: x86common.h:12
#define ADDRESS_AND_SIZE_TO_SPAN_PAGES(_Va, _Size)