ReactOS 0.4.15-dev-8428-g6910fa6
x86bios.c File Reference
#include <hal.h>
#include <debug.h>
#include <fast486.h>
Include dependency graph for x86bios.c:

Go to the source code of this file.

Functions

VOID NTAPI DbgDumpPage (PUCHAR MemBuffer, USHORT Segment)
 
VOID NTAPI HalInitializeBios (_In_ ULONG Phase, _In_ PLOADER_PARAMETER_BLOCK LoaderBlock)
 
NTSTATUS NTAPI x86BiosAllocateBuffer (_In_ ULONG *Size, _In_ USHORT *Segment, _In_ USHORT *Offset)
 
NTSTATUS NTAPI x86BiosFreeBuffer (_In_ USHORT Segment, _In_ USHORT Offset)
 
NTSTATUS NTAPI x86BiosReadMemory (_In_ USHORT Segment, _In_ USHORT Offset, _Out_writes_bytes_(Size) PVOID Buffer, _In_ ULONG Size)
 
NTSTATUS NTAPI x86BiosWriteMemory (_In_ USHORT Segment, _In_ USHORT Offset, _In_reads_bytes_(Size) PVOID Buffer, _In_ ULONG Size)
 
static VOID FASTCALL x86MemRead (PFAST486_STATE State, ULONG Address, PVOID Buffer, ULONG Size)
 
static VOID FASTCALL x86MemWrite (PFAST486_STATE State, ULONG Address, PVOID Buffer, ULONG Size)
 
static BOOLEAN ValidatePort (USHORT Port, UCHAR Size, BOOLEAN IsWrite)
 
static VOID FASTCALL x86IoRead (PFAST486_STATE State, USHORT Port, PVOID Buffer, ULONG DataCount, UCHAR DataSize)
 
static VOID FASTCALL x86IoWrite (PFAST486_STATE State, USHORT Port, PVOID Buffer, ULONG DataCount, UCHAR DataSize)
 
static VOID FASTCALL x86BOP (PFAST486_STATE State, UCHAR BopCode)
 
static UCHAR FASTCALL x86IntAck (PFAST486_STATE State)
 
BOOLEAN NTAPI x86BiosCall (_In_ ULONG InterruptNumber, _Inout_ PX86_BIOS_REGISTERS Registers)
 

Variables

PFN_NUMBER x86BiosFallbackPfn
 
BOOLEAN x86BiosIsInitialized
 
LONG x86BiosBufferIsAllocated = 0
 
PUCHAR x86BiosMemoryMapping
 
ULONG64 x86BiosBufferPhysical
 

Function Documentation

◆ DbgDumpPage()

VOID NTAPI DbgDumpPage ( PUCHAR  MemBuffer,
USHORT  Segment 
)

Definition at line 31 of file x86bios.c.

32{
33 ULONG x, y, Offset;
34
35 for (y = 0; y < 0x100; y++)
36 {
37 for (x = 0; x < 0x10; x++)
38 {
39 Offset = Segment * 16 + y * 16 + x;
40 DbgPrint("%02x ", MemBuffer[Offset]);
41 }
42 DbgPrint("\n");
43 }
44}
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
#define DbgPrint
Definition: hal.h:12
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
uint32_t ULONG
Definition: typedefs.h:59
_Inout_ PVOID Segment
Definition: exfuncs.h:1101

◆ HalInitializeBios()

VOID NTAPI HalInitializeBios ( _In_ ULONG  Phase,
_In_ PLOADER_PARAMETER_BLOCK  LoaderBlock 
)

Definition at line 48 of file x86bios.c.

51{
52 PPFN_NUMBER PfnArray;
53 PFN_NUMBER Pfn, Last;
55 PLIST_ENTRY ListEntry;
56 PMDL Mdl;
58
59 if (Phase == 0)
60 {
61 /* Allocate one page for a fallback mapping */
63 0x100000,
64 1,
65 FALSE);
66 if (PhysicalAddress == 0)
67 {
69 }
70
73
74 /* Allocate a page for the buffer allocation */
76 0x100000,
77 1,
78 FALSE);
79 if (x86BiosBufferPhysical == 0)
80 {
82 }
83 }
84 else
85 {
86
87 /* Allocate an MDL for 1MB */
88 Mdl = IoAllocateMdl(NULL, 0x100000, FALSE, FALSE, NULL);
89 if (!Mdl)
90 {
92 }
93
94 /* Get pointer to the pfn array */
95 PfnArray = MmGetMdlPfnArray(Mdl);
96
97 /* Fill the array with the fallback page */
98 for (Pfn = 0; Pfn < 0x100; Pfn++)
99 {
100 PfnArray[Pfn] = x86BiosFallbackPfn;
101 }
102
103 /* Loop the memory descriptors */
104 for (ListEntry = LoaderBlock->MemoryDescriptorListHead.Flink;
105 ListEntry != &LoaderBlock->MemoryDescriptorListHead;
106 ListEntry = ListEntry->Flink)
107 {
108 /* Get the memory descriptor */
109 Descriptor = CONTAINING_RECORD(ListEntry,
111 ListEntry);
112
113 /* Check if the memory is in the low 1 MB range */
114 if (Descriptor->BasePage < 0x100)
115 {
116 /* Check if the memory type is firmware */
117 if ((Descriptor->MemoryType == LoaderFirmwarePermanent) ||
118 (Descriptor->MemoryType == LoaderSpecialMemory))
119 {
120 /* It's firmware, so map it! */
121 Last = min(Descriptor->BasePage + Descriptor->PageCount, 0x100);
122 for (Pfn = Descriptor->BasePage; Pfn < Last; Pfn++)
123 {
124 /* Set each physical page in the MDL */
125 PfnArray[Pfn] = Pfn;
126 }
127 }
128 }
129 }
130
131 /* Map this page proper, too */
133 PfnArray[Pfn] = Pfn;
134
135 Mdl->MdlFlags = MDL_PAGES_LOCKED;
136
137 /* Map the MDL to system space */
140
141 DPRINT1("*x86BiosMemoryMapping: %p, %p\n",
143 //DbgDumpPage(x86BiosMemoryMapping, 0xc351);
144
146 }
147}
#define DPRINT1
Definition: precomp.h:8
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define PAGE_SIZE
Definition: env_spec_w32.h:49
#define IoAllocateMdl
Definition: fxmdl.h:88
ULONG64 NTAPI HalpAllocPhysicalMemory(IN PLOADER_PARAMETER_BLOCK LoaderBlock, IN ULONG64 MaxAddress, IN PFN_NUMBER PageCount, IN BOOLEAN Aligned)
Definition: memory.c:29
#define ASSERT(a)
Definition: mode.c:44
unsigned __int64 ULONG64
Definition: imports.h:198
@ HighPagePriority
Definition: imports.h:57
#define min(a, b)
Definition: monoChain.cc:55
@ LoaderFirmwarePermanent
Definition: arc.h:180
@ LoaderSpecialMemory
Definition: arc.h:196
ULONG * PPFN_NUMBER
Definition: ke.h:9
ULONG PFN_NUMBER
Definition: ke.h:9
Definition: typedefs.h:120
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
_In_ WDFDEVICE _In_ PVOID _In_opt_ PMDL Mdl
_Must_inspect_result_ _In_ WDFIORESLIST _In_ PIO_RESOURCE_DESCRIPTOR Descriptor
Definition: wdfresource.h:342
BOOLEAN x86BiosIsInitialized
Definition: x86bios.c:22
PUCHAR x86BiosMemoryMapping
Definition: x86bios.c:24
ULONG64 x86BiosBufferPhysical
Definition: x86bios.c:27
PFN_NUMBER x86BiosFallbackPfn
Definition: x86bios.c:20
_Must_inspect_result_ typedef _In_ PHYSICAL_ADDRESS PhysicalAddress
Definition: iotypes.h:1098
#define MmGetSystemAddressForMdlSafe(_Mdl, _Priority)
#define MmGetMdlPfnArray(_Mdl)
#define MDL_PAGES_LOCKED
Definition: mmtypes.h:19

Referenced by HalInitSystem().

◆ ValidatePort()

static BOOLEAN ValidatePort ( USHORT  Port,
UCHAR  Size,
BOOLEAN  IsWrite 
)
static

Definition at line 299 of file x86bios.c.

303{
304 switch (Port)
305 {
306 // VGA: https://wiki.osdev.org/VGA_Hardware#Port_0x3C0
307 case 0x3C0: return (Size == 1) && IsWrite;
308 case 0x3C1: return (Size == 1) && !IsWrite;
309 case 0x3C2: return (Size == 1) && IsWrite;
310 case 0x3C4: return IsWrite;
311 case 0x3C5: return (Size <= 2);
312 case 0x3C7: return (Size == 1) && IsWrite;
313 case 0x3CC: return (Size == 1) && !IsWrite;
314 case 0x3CE: return IsWrite;
315 case 0x3CF: return (Size <= 2);
316 case 0x3D4: return IsWrite;
317 case 0x3D5: return (Size <= 2);
318 case 0x3C6: return (Size == 1);
319 case 0x3C8: return (Size == 1) && IsWrite;
320 case 0x3C9: return (Size == 1);
321 case 0x3DA: return (Size == 1) && !IsWrite;
322
323 // OVMF debug messages used by VBox / QEMU
324 // https://www.virtualbox.org/svn/vbox/trunk/src/VBox/Devices/EFI/Firmware/OvmfPkg/README
325 case 0x402: return (Size == 1) && IsWrite;
326
327 // BOCHS VBE: https://forum.osdev.org/viewtopic.php?f=1&t=14639
328 case 0x1CE: return (Size == 1) && IsWrite;
329 case 0x1CF: return (Size == 1);
330
331 // CHECKME!
332 case 0x3B6: return (Size <= 2);
333 }
334
335 /* Allow but report unknown ports, we trust the BIOS for now */
336 DPRINT1("Unknown port 0x%x, size %d, write %d\n", Port, Size, IsWrite);
337 return TRUE;
338}
CPPORT Port[4]
Definition: headless.c:35
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533

Referenced by x86IoRead(), and x86IoWrite().

◆ x86BiosAllocateBuffer()

NTSTATUS NTAPI x86BiosAllocateBuffer ( _In_ ULONG Size,
_In_ USHORT Segment,
_In_ USHORT Offset 
)

Definition at line 151 of file x86bios.c.

155{
156 /* Check if the system is initialized and the buffer is large enough */
158 {
159 /* Something was wrong, fail! */
161 }
162
163 /* Check if the buffer is already allocated */
165 {
166 /* Buffer was already allocated, fail */
168 }
169
170 /* The buffer is sufficient, return hardcoded address and size */
171 *Size = PAGE_SIZE;
173 *Offset = 0;
174
175 return STATUS_SUCCESS;
176}
#define InterlockedBitTestAndSet
Definition: interlocked.h:30
#define STATUS_SUCCESS
Definition: shellext.h:65
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
LONG x86BiosBufferIsAllocated
Definition: x86bios.c:23

Referenced by IntInt10AllocateBuffer().

◆ x86BiosCall()

BOOLEAN NTAPI x86BiosCall ( _In_ ULONG  InterruptNumber,
_Inout_ PX86_BIOS_REGISTERS  Registers 
)

Definition at line 410 of file x86bios.c.

413{
414 const ULONG StackBase = 0x2000;
415 FAST486_STATE EmulatorContext;
416 ULONG FlatIp;
417 PUCHAR InstructionPointer;
418
419 /* Initialize the emulator context */
423 x86IoRead,
425 x86BOP,
426 x86IntAck,
427 NULL, // FpuCallback,
428 NULL); // Tlb
429
430 /* Copy the registers */
431 EmulatorContext.GeneralRegs[FAST486_REG_EAX].Long = Registers->Eax;
432 EmulatorContext.GeneralRegs[FAST486_REG_EBX].Long = Registers->Ebx;
433 EmulatorContext.GeneralRegs[FAST486_REG_ECX].Long = Registers->Ecx;
434 EmulatorContext.GeneralRegs[FAST486_REG_EDX].Long = Registers->Edx;
435 EmulatorContext.GeneralRegs[FAST486_REG_ESI].Long = Registers->Esi;
436 EmulatorContext.GeneralRegs[FAST486_REG_EDI].Long = Registers->Edi;
437 EmulatorContext.SegmentRegs[FAST486_REG_DS].Selector = Registers->SegDs;
438 EmulatorContext.SegmentRegs[FAST486_REG_ES].Selector = Registers->SegEs;
439
440 /* Set Eflags */
441 EmulatorContext.Flags.Long = 0;
442 EmulatorContext.Flags.AlwaysSet = 1;
443 EmulatorContext.Flags.If = 1;
444
445 /* Set up the INT stub */
446 FlatIp = StackBase - 4;
447 InstructionPointer = x86BiosMemoryMapping + FlatIp;
448 InstructionPointer[0] = 0xCD; // INT instruction
449 InstructionPointer[1] = (UCHAR)InterruptNumber;
450 InstructionPointer[2] = 0x90; // NOP. We will stop at this address.
451
452 /* Set the stack pointer */
453 Fast486SetStack(&EmulatorContext, 0, StackBase - 8);
454
455 /* Start execution at the INT stub */
456 Fast486ExecuteAt(&EmulatorContext, 0x00, FlatIp);
457
458 while (TRUE)
459 {
460 /* Get the current flat IP */
461 FlatIp = (EmulatorContext.SegmentRegs[FAST486_REG_CS].Selector << 4) +
462 EmulatorContext.InstPtr.Long;
463
464 /* Make sure we haven't left the allowed memory range */
465 if (FlatIp >= 0x100000)
466 {
467 DPRINT1("x86BiosCall: invalid IP (0x%lx) during BIOS execution\n", FlatIp);
468 return FALSE;
469 }
470
471 /* Check if we returned from our int stub */
472 if (FlatIp == (StackBase - 2))
473 {
474 /* We are done! */
475 break;
476 }
477
478 /* Emulate one instruction */
480 }
481
482 /* Copy the registers back */
483 Registers->Eax = EmulatorContext.GeneralRegs[FAST486_REG_EAX].Long;
484 Registers->Ebx = EmulatorContext.GeneralRegs[FAST486_REG_EBX].Long;
485 Registers->Ecx = EmulatorContext.GeneralRegs[FAST486_REG_ECX].Long;
486 Registers->Edx = EmulatorContext.GeneralRegs[FAST486_REG_EDX].Long;
487 Registers->Esi = EmulatorContext.GeneralRegs[FAST486_REG_ESI].Long;
488 Registers->Edi = EmulatorContext.GeneralRegs[FAST486_REG_EDI].Long;
489 Registers->SegDs = EmulatorContext.SegmentRegs[FAST486_REG_DS].Selector;
490 Registers->SegEs = EmulatorContext.SegmentRegs[FAST486_REG_ES].Selector;
491
492 return TRUE;
493}
VOID NTAPI Fast486SetStack(PFAST486_STATE State, USHORT Segment, ULONG Offset)
Definition: fast486.c:227
VOID NTAPI Fast486Initialize(PFAST486_STATE State, FAST486_MEM_READ_PROC MemReadCallback, FAST486_MEM_WRITE_PROC MemWriteCallback, FAST486_IO_READ_PROC IoReadCallback, FAST486_IO_WRITE_PROC IoWriteCallback, FAST486_BOP_PROC BopCallback, FAST486_INT_ACK_PROC IntAckCallback, FAST486_FPU_PROC FpuCallback, PULONG Tlb)
Definition: fast486.c:103
VOID NTAPI Fast486ExecuteAt(PFAST486_STATE State, USHORT Segment, ULONG Offset)
Definition: fast486.c:212
if(dx< 0)
Definition: linetemp.h:194
VOID NTAPI Fast486StepInto(PFAST486_STATE State)
Definition: debug.c:248
FAST486_STATE EmulatorContext
Definition: cpu.c:39
unsigned char * PUCHAR
Definition: typedefs.h:53
static VOID FASTCALL x86IoRead(PFAST486_STATE State, USHORT Port, PVOID Buffer, ULONG DataCount, UCHAR DataSize)
Definition: x86bios.c:343
static VOID FASTCALL x86MemWrite(PFAST486_STATE State, ULONG Address, PVOID Buffer, ULONG Size)
Definition: x86bios.c:280
static VOID FASTCALL x86MemRead(PFAST486_STATE State, ULONG Address, PVOID Buffer, ULONG Size)
Definition: x86bios.c:259
static UCHAR FASTCALL x86IntAck(PFAST486_STATE State)
Definition: x86bios.c:401
static VOID FASTCALL x86IoWrite(PFAST486_STATE State, USHORT Port, PVOID Buffer, ULONG DataCount, UCHAR DataSize)
Definition: x86bios.c:367
static VOID FASTCALL x86BOP(PFAST486_STATE State, UCHAR BopCode)
Definition: x86bios.c:391
unsigned char UCHAR
Definition: xmlstorage.h:181

Referenced by IntInt10CallBios().

◆ x86BiosFreeBuffer()

NTSTATUS NTAPI x86BiosFreeBuffer ( _In_ USHORT  Segment,
_In_ USHORT  Offset 
)

Definition at line 180 of file x86bios.c.

183{
184 /* Check if the system is initialized and if the address matches */
185 if (!x86BiosIsInitialized || (Segment != 0x2000) || (Offset != 0))
186 {
187 /* Something was wrong, fail */
189 }
190
191 /* Check if the buffer was allocated */
193 {
194 /* It was not, fail */
196 }
197
198 /* Buffer is freed, nothing more to do */
199 return STATUS_SUCCESS;
200}
#define InterlockedBitTestAndReset
Definition: interlocked.h:35
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135

Referenced by IntInt10FreeBuffer().

◆ x86BiosReadMemory()

NTSTATUS NTAPI x86BiosReadMemory ( _In_ USHORT  Segment,
_In_ USHORT  Offset,
_Out_writes_bytes_(Size) PVOID  Buffer,
_In_ ULONG  Size 
)

Definition at line 204 of file x86bios.c.

209{
211
212 /* Calculate the physical address */
213 Address = (Segment << 4) + Offset;
214
215 /* Check if it's valid */
216 if (!x86BiosIsInitialized || ((Address + Size) > 0x100000))
217 {
218 /* Invalid */
220 }
221
222 /* Copy the memory to the buffer */
224
225 /* Return success */
226 return STATUS_SUCCESS;
227}
Definition: bufpool.h:45
static WCHAR Address[46]
Definition: ping.c:68
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
uint32_t ULONG_PTR
Definition: typedefs.h:65

Referenced by IntInt10ReadMemory().

◆ x86BiosWriteMemory()

NTSTATUS NTAPI x86BiosWriteMemory ( _In_ USHORT  Segment,
_In_ USHORT  Offset,
_In_reads_bytes_(Size) PVOID  Buffer,
_In_ ULONG  Size 
)

Definition at line 231 of file x86bios.c.

236{
238
239 /* Calculate the physical address */
240 Address = (Segment << 4) + Offset;
241
242 /* Check if it's valid */
243 if (!x86BiosIsInitialized || ((Address + Size) > 0x100000))
244 {
245 /* Invalid */
247 }
248
249 /* Copy the memory from the buffer */
251
252 /* Return success */
253 return STATUS_SUCCESS;
254}

Referenced by IntInt10WriteMemory().

◆ x86BOP()

static VOID FASTCALL x86BOP ( PFAST486_STATE  State,
UCHAR  BopCode 
)
static

Definition at line 391 of file x86bios.c.

394{
395 ASSERT(FALSE);
396}

Referenced by x86BiosCall().

◆ x86IntAck()

static UCHAR FASTCALL x86IntAck ( PFAST486_STATE  State)
static

Definition at line 401 of file x86bios.c.

403{
404 ASSERT(FALSE);
405 return 0;
406}

Referenced by x86BiosCall().

◆ x86IoRead()

static VOID FASTCALL x86IoRead ( PFAST486_STATE  State,
USHORT  Port,
PVOID  Buffer,
ULONG  DataCount,
UCHAR  DataSize 
)
static

Definition at line 343 of file x86bios.c.

349{
350 /* Validate the port */
352 {
353 DPRINT1("Invalid IO port read access (port: 0x%x, count: 0x%x)\n", Port, DataSize);
354 }
355
356 switch (DataSize)
357 {
358 case 1: READ_PORT_BUFFER_UCHAR((PUCHAR)(ULONG_PTR)Port, Buffer, DataCount); return;
359 case 2: READ_PORT_BUFFER_USHORT((PUSHORT)(ULONG_PTR)Port, Buffer, DataCount); return;
360 case 4: READ_PORT_BUFFER_ULONG((PULONG)(ULONG_PTR)Port, Buffer, DataCount); return;
361 }
362}
VOID NTAPI READ_PORT_BUFFER_UCHAR(IN PUCHAR Port, OUT PUCHAR Buffer, IN ULONG Count)
Definition: portio.c:26
VOID NTAPI READ_PORT_BUFFER_USHORT(IN PUSHORT Port, OUT PUSHORT Buffer, IN ULONG Count)
Definition: portio.c:36
VOID NTAPI READ_PORT_BUFFER_ULONG(IN PULONG Port, OUT PULONG Buffer, IN ULONG Count)
Definition: portio.c:46
_In_ NDIS_STATUS _In_ ULONG _In_ USHORT _In_opt_ PVOID _In_ ULONG DataSize
Definition: ndis.h:4755
uint32_t * PULONG
Definition: typedefs.h:59
uint16_t * PUSHORT
Definition: typedefs.h:56
static BOOLEAN ValidatePort(USHORT Port, UCHAR Size, BOOLEAN IsWrite)
Definition: x86bios.c:299

Referenced by x86BiosCall().

◆ x86IoWrite()

static VOID FASTCALL x86IoWrite ( PFAST486_STATE  State,
USHORT  Port,
PVOID  Buffer,
ULONG  DataCount,
UCHAR  DataSize 
)
static

Definition at line 367 of file x86bios.c.

373{
374 /* Validate the port */
376 {
377 DPRINT1("Invalid IO port write access (port: 0x%x, count: 0x%x)\n", Port, DataSize);
378 }
379
380 switch (DataSize)
381 {
382 case 1: WRITE_PORT_BUFFER_UCHAR((PUCHAR)(ULONG_PTR)Port, Buffer, DataCount); return;
383 case 2: WRITE_PORT_BUFFER_USHORT((PUSHORT)(ULONG_PTR)Port, Buffer, DataCount); return;
384 case 4: WRITE_PORT_BUFFER_ULONG((PULONG)(ULONG_PTR)Port, Buffer, DataCount); return;
385 }
386}
VOID NTAPI WRITE_PORT_BUFFER_UCHAR(IN PUCHAR Port, IN PUCHAR Buffer, IN ULONG Count)
Definition: portio.c:77
VOID NTAPI WRITE_PORT_BUFFER_ULONG(IN PULONG Port, IN PULONG Buffer, IN ULONG Count)
Definition: portio.c:97
VOID NTAPI WRITE_PORT_BUFFER_USHORT(IN PUSHORT Port, IN PUSHORT Buffer, IN ULONG Count)
Definition: portio.c:87

Referenced by x86BiosCall().

◆ x86MemRead()

static VOID FASTCALL x86MemRead ( PFAST486_STATE  State,
ULONG  Address,
PVOID  Buffer,
ULONG  Size 
)
static

Definition at line 259 of file x86bios.c.

264{
265 /* Validate the address range */
266 if (((ULONG64)Address + Size) < 0x100000)
267 {
269 }
270 else
271 {
272 RtlFillMemory(Buffer, Size, 0xCC);
273 DPRINT1("x86MemRead: invalid read at 0x%lx (size 0x%lx)\n", Address, Size);
274 }
275}
#define RtlFillMemory(Dest, Length, Fill)
Definition: winternl.h:599

Referenced by x86BiosCall().

◆ x86MemWrite()

static VOID FASTCALL x86MemWrite ( PFAST486_STATE  State,
ULONG  Address,
PVOID  Buffer,
ULONG  Size 
)
static

Definition at line 280 of file x86bios.c.

285{
286 /* Validate the address range */
287 if (((ULONG64)Address + Size) < 0x100000)
288 {
290 }
291 else
292 {
293 DPRINT1("x86MemWrite: invalid write at 0x%lx (size 0x%lx)\n", Address, Size);
294 }
295}

Referenced by x86BiosCall().

Variable Documentation

◆ x86BiosBufferIsAllocated

LONG x86BiosBufferIsAllocated = 0

Definition at line 23 of file x86bios.c.

Referenced by x86BiosAllocateBuffer(), and x86BiosFreeBuffer().

◆ x86BiosBufferPhysical

ULONG64 x86BiosBufferPhysical

Definition at line 27 of file x86bios.c.

Referenced by HalInitializeBios(), and x86BiosAllocateBuffer().

◆ x86BiosFallbackPfn

PFN_NUMBER x86BiosFallbackPfn

Definition at line 20 of file x86bios.c.

Referenced by HalInitializeBios().

◆ x86BiosIsInitialized

BOOLEAN x86BiosIsInitialized

◆ x86BiosMemoryMapping

PUCHAR x86BiosMemoryMapping