You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
965 lines
24 KiB
965 lines
24 KiB
/*++
|
|
|
|
Copyright (c) 1991 Microsoft Corporation
|
|
|
|
|
|
Module Name:
|
|
|
|
main.c
|
|
|
|
Abstract:
|
|
|
|
Main for the SU (startup) module for the OS loader. The SU module
|
|
must take the x86 from a real-mode 16bit state to a FLAT model,
|
|
32bit protect/paging enabled state.
|
|
|
|
Author:
|
|
|
|
Thomas Parslow (tomp) Created 20-Dec-90
|
|
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
|
|
int _acrtused = 0;
|
|
|
|
#define NTAPI
|
|
|
|
#include "su.h"
|
|
#include "eisa.h"
|
|
|
|
#define _SYS_GUID_OPERATORS_
|
|
#include <guiddef.h>
|
|
// Prevent ntimage.h from defining the COM+ IL structs and enums. The enum
|
|
// has a value > 16 bits so the 16-bit build fails. The startrom code doesn't
|
|
// need to know about COM+ IL.
|
|
#define __IMAGE_COR20_HEADER_DEFINED__
|
|
#include "ntimage.h"
|
|
|
|
#include "strings.h"
|
|
|
|
#include "pxe_cmn.h"
|
|
#include "pxe_api.h"
|
|
#include "undi_api.h"
|
|
|
|
#include <sdistructs.h>
|
|
|
|
extern VOID RealMode(VOID);
|
|
extern USHORT IDTregisterZero;
|
|
extern IMAGE_DOS_HEADER edata;
|
|
extern VOID MoveMemory(ULONG,ULONG,ULONG);
|
|
extern USHORT SuStackBegin;
|
|
extern UCHAR Beginx86Relocation;
|
|
extern UCHAR Endx86Relocation;
|
|
extern USHORT BackEnd;
|
|
extern ULONG FileStart;
|
|
extern BOOLEAN IsNpxPresent(VOID);
|
|
extern USHORT HwGetProcessorType(VOID);
|
|
extern USHORT HwGetCpuStepping(USHORT);
|
|
extern ULONG MachineType;
|
|
extern ULONG OsLoaderStart;
|
|
extern ULONG OsLoaderEnd;
|
|
extern ULONG ResourceDirectory;
|
|
extern ULONG ResourceOffset;
|
|
extern ULONG OsLoaderBase;
|
|
extern ULONG OsLoaderExports;
|
|
extern ULONG NetPcRomEntry;
|
|
extern ULONG BootFlags;
|
|
extern ULONG NtDetectStart;
|
|
extern ULONG NtDetectEnd;
|
|
extern ULONG SdiAddress;
|
|
|
|
extern
|
|
TurnMotorOff(
|
|
VOID
|
|
);
|
|
|
|
extern
|
|
EnableA20(
|
|
VOID
|
|
);
|
|
|
|
extern
|
|
BOOLEAN
|
|
ConstructMemoryDescriptors(
|
|
VOID
|
|
);
|
|
|
|
extern
|
|
USHORT
|
|
IsaConstructMemoryDescriptors(
|
|
VOID
|
|
);
|
|
|
|
VOID
|
|
Relocatex86Structures(
|
|
VOID
|
|
);
|
|
|
|
ULONG
|
|
RelocateLoaderSections(
|
|
OUT PULONG Start,
|
|
OUT PULONG End
|
|
);
|
|
|
|
t_PXENV_ENTRY far *
|
|
PxenvGetEntry(
|
|
VOID
|
|
);
|
|
|
|
BOOLEAN
|
|
PxenvVerifyEntry(
|
|
t_PXENV_ENTRY far *entry
|
|
);
|
|
|
|
extern UINT16
|
|
PxenvApiCall(
|
|
UINT16 service,
|
|
void far *param
|
|
);
|
|
|
|
BOOLEAN
|
|
PxenvTftp(
|
|
);
|
|
|
|
VOID
|
|
Reboot(
|
|
VOID
|
|
);
|
|
|
|
VOID
|
|
Wait(
|
|
IN ULONG WaitTime
|
|
);
|
|
|
|
ULONG
|
|
GetTickCount(
|
|
VOID
|
|
);
|
|
|
|
extern
|
|
FSCONTEXT_RECORD
|
|
FsContext;
|
|
|
|
#define REVISION_NUMBER "1.1"
|
|
#define DISK_TABLE_VECTOR (0x1e*4)
|
|
|
|
VOID
|
|
SuMain(
|
|
IN ULONG BtBootDrive
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Main entrypoint of the SU module. Control is passed from the boot
|
|
sector to startup.asm which does some run-time fixups on the stack
|
|
and data segments and then passes control here.
|
|
|
|
Arguments:
|
|
|
|
BtBootDrive - The low byte contains the drive that we booted from (int13
|
|
unit number). If 0x41, this is an SDI boot, and the upper three bytes
|
|
of BtBootDrive contain the upper three bytes of the physical address
|
|
of the SDI image (which must be page aligned)
|
|
|
|
Returns:
|
|
|
|
Does not return. Passes control to the OS loader
|
|
|
|
--*/
|
|
{
|
|
ULONG LoaderEntryPoint;
|
|
ULONG EisaNumPages;
|
|
USHORT IsaNumPages;
|
|
MEMORY_LIST_ENTRY _far *CurrentEntry;
|
|
IMAGE_OPTIONAL_HEADER far *OptionalHeader;
|
|
ULONG BlockEnd;
|
|
ULONG ImageSize;
|
|
ULONG ImageBase;
|
|
UCHAR bootDrive;
|
|
|
|
//
|
|
// Get the boot drive out of the input argument. If this is an SDI boot,
|
|
// store the SDI address in the boot context record.
|
|
//
|
|
|
|
bootDrive = (UCHAR)BtBootDrive;
|
|
if ( bootDrive == 0x41 ) {
|
|
SdiAddress = BtBootDrive & ~(PAGE_SIZE - 1);
|
|
}
|
|
|
|
//
|
|
// Save fs context info
|
|
//
|
|
FsContext.BootDrive = bootDrive;
|
|
|
|
//
|
|
// Set the NTLDR boot flags that are passed in the BootContext.
|
|
//
|
|
#ifdef DEFAULT_BOOTFLAGS
|
|
BootFlags = DEFAULT_BOOTFLAGS;
|
|
#endif
|
|
|
|
//
|
|
// Initialize the video subsystem first so that
|
|
// errors end exceptions can be displayed.
|
|
//
|
|
|
|
InitializeVideoSubSystem();
|
|
|
|
//
|
|
// In case we booted from a floppy, turn the drive motor off.
|
|
//
|
|
|
|
TurnMotorOff();
|
|
|
|
//
|
|
// Set up machine type based on its Bus type.
|
|
//
|
|
|
|
if (BtIsEisaSystem()) {
|
|
MachineType = MACHINE_TYPE_EISA;
|
|
} else {
|
|
MachineType = MACHINE_TYPE_ISA;
|
|
}
|
|
|
|
if (!ConstructMemoryDescriptors()) {
|
|
//
|
|
// If INT 15 E802h fails...
|
|
//
|
|
if (MachineType == MACHINE_TYPE_EISA) {
|
|
|
|
//
|
|
// HACKHACK John Vert (jvert)
|
|
// This is completely bogus. Since there are a number of EISA
|
|
// machines which do not let you correctly configure the EISA
|
|
// NVRAM, and even MORE machines which are improperly configured,
|
|
// we first check to see how much memory the ISA routines say
|
|
// exists. Then we check what the EISA routines tell us, and
|
|
// compare the two. If the EISA number is much lower (where "much"
|
|
// is a completely random fudge factor) than the ISA number, we
|
|
// assume the machine is improperly configured and we throw away
|
|
// the EISA numbers and use the ISA ones. If not, we assume that
|
|
// the machine is actually configured properly and we trust the
|
|
// EISA numbers..
|
|
//
|
|
|
|
IsaNumPages = IsaConstructMemoryDescriptors();
|
|
EisaNumPages = EisaConstructMemoryDescriptors();
|
|
if (EisaNumPages + 0x80 < IsaNumPages) {
|
|
IsaConstructMemoryDescriptors();
|
|
}
|
|
|
|
} else {
|
|
IsaConstructMemoryDescriptors();
|
|
}
|
|
}
|
|
|
|
//
|
|
// Search for memory descriptor describing low memory
|
|
//
|
|
CurrentEntry = MemoryDescriptorList;
|
|
while ((CurrentEntry->BlockBase != 0) &&
|
|
(CurrentEntry->BlockSize != 0)) {
|
|
CurrentEntry++;
|
|
}
|
|
|
|
if ((CurrentEntry->BlockBase == 0) &&
|
|
(CurrentEntry->BlockSize < (ULONG)512 * (ULONG)1024)) {
|
|
|
|
BlPrint(SU_NO_LOW_MEMORY,CurrentEntry->BlockSize/1024);
|
|
goto StartFailed;
|
|
}
|
|
|
|
//
|
|
// Is this a network boot?
|
|
//
|
|
|
|
if (bootDrive == 0x40) {
|
|
|
|
t_PXENV_ENTRY far *entry;
|
|
|
|
//
|
|
// Get the address of the NetPC ROM entry point.
|
|
//
|
|
|
|
entry = PxenvGetEntry( );
|
|
if ( PxenvVerifyEntry(entry) != 0 ) {
|
|
BlPrint( "\nUnable to verify NetPC ROM entry point.\n" );
|
|
goto StartFailed;
|
|
}
|
|
|
|
FP_SEG(NetPcRomEntry) = entry->rm_entry_seg;
|
|
FP_OFF(NetPcRomEntry) = entry->rm_entry_off;
|
|
|
|
#if 0
|
|
//
|
|
// Disable broadcast reception.
|
|
//
|
|
// chuckl: Don't do this. We added it to solve a problem with DEC cards
|
|
// and the boot floppy, but we need to have broadcasts enabled in case
|
|
// the server needs to ARP us. We tried enabling/disabling broadcasts
|
|
// during the receive loop, but that seems to put Compaq cards to sleep.
|
|
// So we need to leave broadcasts enabled. The DEC card problem will
|
|
// have to be fixed another way.
|
|
//
|
|
|
|
{
|
|
t_PXENV_UNDI_SET_PACKET_FILTER UndiSetPF;
|
|
UndiSetPF.Status = 0;
|
|
UndiSetPF.filter = FLTR_DIRECTED;
|
|
if (PxenvApiCall(PXENV_UNDI_SET_PACKET_FILTER, &UndiSetPF) != PXENV_EXIT_SUCCESS) {
|
|
BlPrint("\nSet packet filter failed.\n");
|
|
goto StartFailed;
|
|
}
|
|
}
|
|
#endif
|
|
if ( PxenvTftp() ) {
|
|
BlPrint("\nTFTP download failed.\n");
|
|
goto StartFailed;
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// Enable the A20 line for protect mode
|
|
//
|
|
|
|
EnableA20();
|
|
|
|
//
|
|
// Relocate x86 structures. This includes the GDT, IDT,
|
|
// page directory, and first level page table.
|
|
//
|
|
|
|
Relocatex86Structures();
|
|
|
|
//
|
|
// Enable protect and paging modes for the first time
|
|
//
|
|
|
|
EnableProtectPaging(ENABLING);
|
|
|
|
//
|
|
// If this is an SDI boot, copy the OS loader from the SDI image to 0x100000.
|
|
//
|
|
|
|
if ( bootDrive == 0x41 ) {
|
|
|
|
int i;
|
|
ULONG osloaderOffset;
|
|
ULONG osloaderLength;
|
|
SDI_HEADER *sdiHeader;
|
|
UCHAR *sig1;
|
|
UCHAR *sig2;
|
|
|
|
//
|
|
// In the code below, edata is a near pointer to the end of
|
|
// startrom.com. Since we are using 16-bit selectors here,
|
|
// edata is the only thing we can directly reference. FileStart
|
|
// is a 32-bit linear pointer to edata. MoveMemory() uses this
|
|
// pointer.
|
|
//
|
|
// First, copy the SDI header to edata so that we can look at it.
|
|
// Verify that it's really an SDI image.
|
|
//
|
|
|
|
MoveMemory(SdiAddress,
|
|
FileStart,
|
|
sizeof(SDI_HEADER));
|
|
|
|
//
|
|
// Verify that the SDI header looks right by checking the signature.
|
|
//
|
|
|
|
sdiHeader = (SDI_HEADER *)&edata;
|
|
|
|
sig1 = sdiHeader->Signature;
|
|
sig2 = SDI_SIGNATURE;
|
|
|
|
for ( i = 0; i < SDI_SIZEOF_SIGNATURE; i++ ) {
|
|
if ( *sig1++ != *sig2++ ) {
|
|
BlPrint("\nSDI image format corrupt.\n");
|
|
goto StartFailed;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Scan the TOC looking for a LOAD entry.
|
|
//
|
|
|
|
for ( i = 0; i < SDI_TOCMAXENTRIES; i++ ) {
|
|
if ( sdiHeader->ToC[i].dwType == SDI_BLOBTYPE_LOAD ) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( i >= SDI_TOCMAXENTRIES ) {
|
|
BlPrint("\nSDI image missing LOAD entry.\n");
|
|
goto StartFailed;
|
|
}
|
|
|
|
//
|
|
// Copy the loader to 0x100000.
|
|
//
|
|
|
|
osloaderOffset = (ULONG)sdiHeader->ToC[i].llOffset.LowPart;
|
|
osloaderLength = (ULONG)sdiHeader->ToC[i].llSize.LowPart;
|
|
|
|
MoveMemory(SdiAddress + osloaderOffset,
|
|
(ULONG)0x100000,
|
|
osloaderLength);
|
|
}
|
|
|
|
//
|
|
// If this is a network boot or an SDI boot, copy the section headers from
|
|
// the loader image (at 0x100000) down into low memory (at &edata).
|
|
//
|
|
|
|
if ((bootDrive == 0x40) || (bootDrive == 0x41)) {
|
|
|
|
//
|
|
// This is a tricky bit of code. The only pointer that can be dereferenced
|
|
// is edata. edata is the near pointer which can be used here. FileStart is
|
|
// the far pointer which must be passed to MoveMemory.
|
|
//
|
|
IMAGE_DOS_HEADER far *src = (IMAGE_DOS_HEADER far*)0x100000;
|
|
IMAGE_DOS_HEADER far *dst = (IMAGE_DOS_HEADER far*)FileStart;
|
|
|
|
//
|
|
// Copy the fixed part of the header so we can find the start of the optional
|
|
// header.
|
|
//
|
|
MoveMemory((ULONG)src,
|
|
(ULONG)dst,
|
|
sizeof(IMAGE_DOS_HEADER));
|
|
|
|
//
|
|
// Copy the optional header so we can find the size of all the headers
|
|
//
|
|
OptionalHeader = &((IMAGE_NT_HEADERS far *) ((UCHAR far *) src + edata.e_lfanew))->OptionalHeader;
|
|
MoveMemory((ULONG)OptionalHeader,
|
|
(ULONG)&((IMAGE_NT_HEADERS far *) ((UCHAR far *) dst + edata.e_lfanew))->OptionalHeader,
|
|
sizeof(IMAGE_OPTIONAL_HEADER));
|
|
|
|
//
|
|
// Now we know the size of all the headers, so just recopy the entire first chunk
|
|
// that contains all the headers.
|
|
///
|
|
MoveMemory((ULONG)src,
|
|
(ULONG)dst,
|
|
((PIMAGE_NT_HEADERS)((PUCHAR)&edata + edata.e_lfanew))->OptionalHeader.SizeOfHeaders);
|
|
|
|
FileStart = (ULONG)src;
|
|
}
|
|
|
|
//
|
|
// Ensure there is a memory descriptor to contain osloader image
|
|
//
|
|
OptionalHeader = &((PIMAGE_NT_HEADERS) ((PUCHAR) &edata + edata.e_lfanew))->OptionalHeader;
|
|
ImageBase = OptionalHeader->ImageBase;
|
|
ImageSize = OptionalHeader->SizeOfImage;
|
|
OsLoaderBase = ImageBase;
|
|
OsLoaderExports = ImageBase + OptionalHeader->DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;
|
|
CurrentEntry = MemoryDescriptorList;
|
|
while (ImageSize > 0) {
|
|
while (CurrentEntry->BlockSize != 0) {
|
|
BlockEnd = CurrentEntry->BlockBase + CurrentEntry->BlockSize;
|
|
|
|
if ((CurrentEntry->BlockBase <= ImageBase) &&
|
|
(BlockEnd > ImageBase)) {
|
|
|
|
//
|
|
// this descriptor at least partially contains a chunk
|
|
// of the osloader.
|
|
//
|
|
if (BlockEnd-ImageBase > ImageSize) {
|
|
ImageSize = 0;
|
|
} else {
|
|
ImageSize -= (BlockEnd-ImageBase);
|
|
ImageBase = BlockEnd;
|
|
}
|
|
|
|
//
|
|
// look for remaining part (if any) of osloader
|
|
//
|
|
CurrentEntry = MemoryDescriptorList;
|
|
break;
|
|
}
|
|
CurrentEntry++;
|
|
}
|
|
if (CurrentEntry->BlockSize == 0) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (ImageSize > 0) {
|
|
//
|
|
// We could not relocate the osloader to high memory. Error out
|
|
// and display the memory map.
|
|
//
|
|
BlPrint(SU_NO_EXTENDED_MEMORY);
|
|
|
|
CurrentEntry = MemoryDescriptorList;
|
|
while (CurrentEntry->BlockSize != 0) {
|
|
BlPrint(" %lx - %lx\n",
|
|
CurrentEntry->BlockBase,
|
|
CurrentEntry->BlockBase + CurrentEntry->BlockSize);
|
|
|
|
CurrentEntry++;
|
|
}
|
|
goto StartFailed;
|
|
}
|
|
|
|
//
|
|
// Go relocate loader sections and build page table entries
|
|
//
|
|
|
|
LoaderEntryPoint = RelocateLoaderSections(&OsLoaderStart, &OsLoaderEnd);
|
|
|
|
//
|
|
// Search for memory descriptor containing the osloader and
|
|
// change it.
|
|
//
|
|
|
|
//
|
|
// Transfer control to the OS loader
|
|
//
|
|
|
|
TransferToLoader(LoaderEntryPoint);
|
|
|
|
StartFailed:
|
|
|
|
if (BootFlags & 1) { // BOOTFLAG_REBOOT_ON_FAILURE == 1 from bldr.h
|
|
ULONG WaitTime = 5;
|
|
BlPrint("\nRebooting in %d seconds...\n", WaitTime);
|
|
Wait(WaitTime);
|
|
Reboot();
|
|
}
|
|
|
|
WAITFOREVER
|
|
}
|
|
|
|
ULONG
|
|
RelocateLoaderSections(
|
|
OUT PULONG Start,
|
|
OUT PULONG End
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
The SU module is prepended to the OS loader file. The OS loader file
|
|
is a coff++ file. This routine computes the beginning of the OS loader
|
|
file, then relocates the OS loader's sections as if it were just
|
|
loading the file from disk file.
|
|
|
|
Arguments:
|
|
|
|
Start - Returns the address of the start of the image
|
|
End - Returns the address of the end of the image
|
|
|
|
Returns:
|
|
|
|
Entry point of loader
|
|
|
|
|
|
--*/
|
|
{
|
|
USHORT Section;
|
|
ULONG Source,Destination;
|
|
ULONG VirtualSize;
|
|
ULONG SizeOfRawData;
|
|
PIMAGE_FILE_HEADER FileHeader;
|
|
PIMAGE_OPTIONAL_HEADER OptionalHeader;
|
|
PIMAGE_SECTION_HEADER SectionHeader;
|
|
|
|
//
|
|
// Make a pointer to the beginning of the loader's coff header
|
|
//
|
|
|
|
FileHeader = &((PIMAGE_NT_HEADERS) ((PUCHAR) &edata + edata.e_lfanew))->FileHeader;
|
|
|
|
//
|
|
// Validate the appended loader image by checking signatures.
|
|
// 1st - is it an executable image?
|
|
// 2nd - is the target environment the 386?
|
|
//
|
|
|
|
if ((FileHeader->Characteristics & IMAGE_FILE_EXECUTABLE_IMAGE) == 0) {
|
|
puts(SU_NTLDR_CORRUPT);
|
|
WAITFOREVER;
|
|
}
|
|
|
|
if (FileHeader->Machine != IMAGE_FILE_MACHINE_I386) {
|
|
puts(SU_NTLDR_CORRUPT);
|
|
WAITFOREVER;
|
|
}
|
|
|
|
//
|
|
// Make a pointer to the optional header in the header-buffer
|
|
//
|
|
|
|
OptionalHeader = (PIMAGE_OPTIONAL_HEADER)((PUCHAR)FileHeader +
|
|
sizeof(IMAGE_FILE_HEADER));
|
|
|
|
//
|
|
// Make a pointer to the first section in the header buffer
|
|
//
|
|
|
|
SectionHeader = (PIMAGE_SECTION_HEADER)((PUCHAR)OptionalHeader +
|
|
FileHeader->SizeOfOptionalHeader);
|
|
|
|
*Start = OptionalHeader->ImageBase+SectionHeader->VirtualAddress;
|
|
*End = *Start + SectionHeader->SizeOfRawData;
|
|
|
|
//
|
|
// Display some debug stuff for now
|
|
//
|
|
|
|
DBG1(
|
|
BlPrint("Machine = %x\n",FileHeader->Machine);
|
|
BlPrint("NumberOfSections = %x\n",FileHeader->NumberOfSections);
|
|
BlPrint("TimeDateStamp %lx\n",FileHeader->TimeDateStamp);
|
|
BlPrint("PointerToSymbolTable = %lx\n",FileHeader->PointerToSymbolTable);
|
|
BlPrint("NumberOfSymbols %lx\n",FileHeader->NumberOfSymbols);
|
|
BlPrint("SizeOfOptionalHeader = %x\n",FileHeader->SizeOfOptionalHeader);
|
|
BlPrint("Characteristics = %x\n",FileHeader->Characteristics);
|
|
)
|
|
|
|
//
|
|
// Loop and relocate each section with a non-zero RawData size
|
|
//
|
|
|
|
for (Section=FileHeader->NumberOfSections ; Section-- ; SectionHeader++) {
|
|
|
|
//
|
|
// Compute source, destination, and count arguments
|
|
//
|
|
|
|
Source = FileStart + SectionHeader->PointerToRawData;
|
|
Destination = OptionalHeader->ImageBase + SectionHeader->VirtualAddress;
|
|
|
|
VirtualSize = SectionHeader->Misc.VirtualSize;
|
|
SizeOfRawData = SectionHeader->SizeOfRawData;
|
|
|
|
if (VirtualSize == 0) {
|
|
VirtualSize = SizeOfRawData;
|
|
}
|
|
|
|
if (SectionHeader->PointerToRawData == 0) {
|
|
//
|
|
// SizeOfRawData can be non-zero even if PointerToRawData is zero
|
|
//
|
|
|
|
SizeOfRawData = 0;
|
|
} else if (SizeOfRawData > VirtualSize) {
|
|
//
|
|
// Don't load more from image than is expected in memory
|
|
//
|
|
|
|
SizeOfRawData = VirtualSize;
|
|
}
|
|
|
|
if (Destination < *Start) {
|
|
*Start = Destination;
|
|
}
|
|
|
|
if (Destination+VirtualSize > *End) {
|
|
*End = Destination+VirtualSize;
|
|
}
|
|
|
|
DBG1(BlPrint("src=%lx dest=%lx raw=%lx\n",Source,Destination,SizeOfRawData);)
|
|
|
|
if (SizeOfRawData != 0) {
|
|
//
|
|
// This section is either a code (.TEXT) section or an
|
|
// initialized data (.DATA) section.
|
|
// Relocate the section to memory at the virtual/physical
|
|
// addresses specified in the section header.
|
|
//
|
|
MoveMemory(Source,Destination,SizeOfRawData);
|
|
}
|
|
|
|
if (SizeOfRawData < VirtualSize) {
|
|
//
|
|
// Zero the portion not loaded from the image
|
|
//
|
|
|
|
DBG1( BlPrint("Zeroing destination %lx\n",Destination+SizeOfRawData); )
|
|
ZeroMemory(Destination+SizeOfRawData,VirtualSize - SizeOfRawData);
|
|
}
|
|
|
|
//
|
|
// Check if this is the resource section. If so, we need
|
|
// to pass its location to the osloader.
|
|
//
|
|
if ((SectionHeader->Name[0] == '.') &&
|
|
(SectionHeader->Name[1] == 'r') &&
|
|
(SectionHeader->Name[2] == 's') &&
|
|
(SectionHeader->Name[3] == 'r') &&
|
|
(SectionHeader->Name[4] == 'c')) {
|
|
ResourceDirectory = Destination;
|
|
ResourceOffset = SectionHeader->VirtualAddress;
|
|
}
|
|
|
|
//
|
|
// look for the .detect section that will contain the contents
|
|
// of ntdetect.com. This is optional.
|
|
//
|
|
if ((SectionHeader->Name[0] == '.') &&
|
|
(SectionHeader->Name[1] == 'd') &&
|
|
(SectionHeader->Name[2] == 'e') &&
|
|
(SectionHeader->Name[3] == 't') &&
|
|
(SectionHeader->Name[4] == 'e') &&
|
|
(SectionHeader->Name[5] == 'c') &&
|
|
(SectionHeader->Name[6] == 't')) {
|
|
NtDetectStart = Destination;
|
|
NtDetectEnd = NtDetectStart + SizeOfRawData;
|
|
}
|
|
|
|
}
|
|
|
|
DBG1( BlPrint("RelocateLoaderSections done - EntryPoint == %lx\n",
|
|
OptionalHeader->AddressOfEntryPoint + OptionalHeader->ImageBase);)
|
|
return(OptionalHeader->AddressOfEntryPoint + OptionalHeader->ImageBase);
|
|
|
|
}
|
|
|
|
VOID
|
|
Relocatex86Structures(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
The gdt and idt are statically defined and imbedded in the SU modules
|
|
data segment. This routine moves then out of the data segment and into
|
|
a page mapped at a defined location.
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Returns:
|
|
|
|
Nothing
|
|
|
|
|
|
--*/
|
|
{
|
|
FPUCHAR Fpsrc, Fpdst;
|
|
USHORT Count;
|
|
|
|
//
|
|
// Make pointers to the data and compute the size
|
|
// of the block to use.
|
|
//
|
|
|
|
Fpsrc = (FPUCHAR)&Beginx86Relocation;
|
|
MAKE_FP(Fpdst,SYSTEM_STRUCTS_BASE_PA);
|
|
Count = (&Endx86Relocation - &Beginx86Relocation);
|
|
|
|
//
|
|
// Move the data to its new location
|
|
//
|
|
|
|
while (Count--) {
|
|
*Fpdst++ = *Fpsrc++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
VOID
|
|
DisplayArgs(
|
|
USHORT es,
|
|
USHORT bx,
|
|
USHORT cx,
|
|
USHORT dx,
|
|
USHORT ax
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Just a debugging routine to dump some registers.
|
|
|
|
Arguments:
|
|
|
|
The x86 registers es, bx, cx, dx, and ax are pushed on the stack
|
|
before this routine is called.
|
|
|
|
|
|
Returns:
|
|
|
|
Nothing
|
|
|
|
|
|
Environment:
|
|
|
|
Real Mode ONLY
|
|
|
|
|
|
--*/
|
|
{
|
|
BlPrint("ax:%x dx:%x cx:%x bx:%x es:%x\n",
|
|
(USHORT) ax,
|
|
(USHORT) dx,
|
|
(USHORT) cx,
|
|
(USHORT) bx,
|
|
(USHORT) es);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
//
|
|
// PxenvVerifyEntry()
|
|
//
|
|
// Description:
|
|
// Verify that the contents of the PXENV Entry Point structure are
|
|
// valid.
|
|
//
|
|
// Passed:
|
|
// entry := Far pointer to PXENV Entry Point structure
|
|
//
|
|
// Returns:
|
|
// TRUE := Structure is invalid
|
|
// FALSE := Structure is valid
|
|
//
|
|
|
|
BOOLEAN
|
|
PxenvVerifyEntry(
|
|
t_PXENV_ENTRY far *entry
|
|
)
|
|
{
|
|
unsigned n;
|
|
UINT8 cksum = 0;
|
|
|
|
//
|
|
// Is structure pointer NULL?
|
|
//
|
|
|
|
if (entry == NULL) {
|
|
BlPrint("\nNULL PXENV Entry Point structure\n");
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Is real-mode API entry point NULL?
|
|
//
|
|
|
|
if (!(entry->rm_entry_off | entry->rm_entry_seg)) {
|
|
BlPrint("\nNULL PXENV API Entry Point\n");
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Verify structure signature
|
|
//
|
|
|
|
for (n = sizeof entry->signature; n--; ) {
|
|
if (entry->signature[n] != (UINT8)(PXENV_ENTRY_SIG[n])) {
|
|
BlPrint("\nBad PXENV Entry Point signature\n");
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Verify structure signature
|
|
//
|
|
|
|
if (entry->length < sizeof(t_PXENV_ENTRY) ) {
|
|
BlPrint("\nBad PXENV Entry Point size\n");
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Verify structure checksum
|
|
//
|
|
|
|
#if 0
|
|
for (n = 0; n < entry->length; n++ ) {
|
|
BlPrint( "%x ", ((UINT8 far *)entry)[n] );
|
|
if ((n & 15) == 15) {
|
|
BlPrint( "\n" );
|
|
}
|
|
}
|
|
#endif
|
|
|
|
for (n = entry->length; n--; ) {
|
|
cksum += ((UINT8 far *)entry)[n];
|
|
}
|
|
|
|
if (cksum) {
|
|
BlPrint("\nBad PXENV Entry Point structure checksum\n");
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
VOID
|
|
Reboot(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Reboots the machine using the keyboard port.
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Returns:
|
|
|
|
Nothing
|
|
|
|
--*/
|
|
{
|
|
RealMode();
|
|
|
|
__asm {
|
|
mov ax, 040h
|
|
mov ds, ax
|
|
mov word ptr ds:[72h], 1234h // set location 472 to 1234 to indicate warm reboot
|
|
mov al, 0feh
|
|
out 64h, al // write to keyboard port to cause reboot
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
Wait(
|
|
IN ULONG WaitTime
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Waits for the requested number of seconds.
|
|
|
|
Arguments:
|
|
|
|
WaitTime - in seconds
|
|
|
|
Returns:
|
|
|
|
Nothing
|
|
|
|
--*/
|
|
{
|
|
ULONG startTime = GetTickCount();
|
|
while ( (((GetTickCount() - startTime) * 10) / 182) < WaitTime ) {
|
|
}
|
|
}
|
|
|
|
// END OF FILE //
|