mirror of https://github.com/lianthony/NT4.0
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.
399 lines
10 KiB
399 lines
10 KiB
/*++
|
|
|
|
Copyright (c) 1991 Microsoft Corporation
|
|
Copyright (c) 1992 Digital Equipment Corporation
|
|
|
|
Module Name:
|
|
|
|
palldr.c
|
|
|
|
Abstract:
|
|
|
|
This module implements the code to load the PAL image into memory.
|
|
|
|
Author:
|
|
|
|
Rod N. Gamache [DEC] 12-Sep-1992
|
|
|
|
Environment:
|
|
|
|
Kernel mode only.
|
|
|
|
Revision History:
|
|
|
|
|
|
--*/
|
|
|
|
#include "bldr.h"
|
|
#include "stdio.h"
|
|
#include "string.h"
|
|
#include "ntimage.h"
|
|
|
|
#define ALIGN_PAL 0x10000 // Align PAL on 64KB boundary
|
|
#define ALIGN_PAL_PAGE (ALIGN_PAL >> PAGE_SHIFT)
|
|
|
|
extern ULONG BlConsoleOutDeviceId;
|
|
extern ULONG BlConsoleInDeviceId;
|
|
|
|
|
|
|
|
ARC_STATUS
|
|
BlLoadPal(
|
|
IN ULONG DeviceId,
|
|
IN TYPE_OF_MEMORY MemoryType,
|
|
IN PCHAR LoadPath,
|
|
IN USHORT ImageType,
|
|
OUT PVOID *ImageBase,
|
|
IN PCHAR LoadDevice
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine attempts to load the PAL file from the specified
|
|
load path.
|
|
|
|
Arguments:
|
|
|
|
DeviceId - Supplies the file table index of the device to load the
|
|
specified image file from.
|
|
|
|
MemoryType - Supplies the type of memory to to be assigned to the
|
|
allocated memory descriptor.
|
|
|
|
LoadPath - Supplies a pointer to string descriptor for the name of
|
|
the path to the PAL file to load.
|
|
|
|
ImageBase - Supplies a pointer to a variable that receives the
|
|
address of the PAL image base.
|
|
|
|
LoadDevice - Supplies a pointer to a string descriptor for the name
|
|
of the load device.
|
|
|
|
Return Value:
|
|
|
|
ESUCCESS is returned if the specified image file is loaded
|
|
successfully. Otherwise, an unsuccessful status is returned
|
|
that describes the reason for failure.
|
|
|
|
--*/
|
|
|
|
{
|
|
CHAR PalName[256];
|
|
CHAR PalFileName[32];
|
|
ARC_STATUS Status;
|
|
CHAR OutputBuffer[256];
|
|
ULONG Count;
|
|
|
|
PIMAGE_NT_HEADERS NtHeaders;
|
|
PIMAGE_SECTION_HEADER SectionHeader;
|
|
PMEMORY_ALLOCATION_DESCRIPTOR PalMemoryDescriptor;
|
|
PMEMORY_ALLOCATION_DESCRIPTOR NewMemoryDescriptor;
|
|
ULONG StartVA;
|
|
PVOID PalImageBase;
|
|
PVOID NewImageBase;
|
|
ULONG PalPage;
|
|
ULONG PageCount;
|
|
ULONG NewPageCount;
|
|
ULONG ActualBase;
|
|
ULONG FreePageCount;
|
|
|
|
Status = BlGeneratePalName( PalFileName );
|
|
|
|
if ( Status != ESUCCESS ) {
|
|
return Status;
|
|
}
|
|
|
|
sprintf(PalName, "%s%s", LoadPath, PalFileName);
|
|
|
|
BlOutputLoadMessage(LoadDevice, PalName);
|
|
Status = BlLoadImage(DeviceId,
|
|
MemoryType,
|
|
PalName,
|
|
ImageType,
|
|
ImageBase);
|
|
|
|
if ( Status != ESUCCESS ) {
|
|
return Status;
|
|
}
|
|
|
|
NtHeaders = RtlImageNtHeader(*ImageBase);
|
|
|
|
if (!NtHeaders) {
|
|
return EBADF;
|
|
}
|
|
|
|
//
|
|
// Compute the address of the section headers and calculate the
|
|
// starting virtual address for the image.
|
|
//
|
|
|
|
SectionHeader =
|
|
(PIMAGE_SECTION_HEADER)((ULONG)NtHeaders + sizeof(ULONG) +
|
|
sizeof(IMAGE_FILE_HEADER) + NtHeaders->FileHeader.SizeOfOptionalHeader);
|
|
|
|
StartVA = SectionHeader->VirtualAddress;
|
|
|
|
PalImageBase = (PVOID)((ULONG)*ImageBase & ~KSEG0_BASE);
|
|
PalPage = (ULONG)PalImageBase >> PAGE_SHIFT;
|
|
|
|
//
|
|
// Check if PAL is aligned correctly. If not, then allocate a new
|
|
// memory descriptor and copy the PAL image to an aligned buffer.
|
|
//
|
|
|
|
//
|
|
// Find the memory descriptor for the PAL image that was loaded,
|
|
// and find the size (in pages) of that loaded image.
|
|
//
|
|
|
|
PalMemoryDescriptor = BlFindMemoryDescriptor(PalPage);
|
|
|
|
PageCount = PalMemoryDescriptor->PageCount;
|
|
|
|
if ( ((ULONG)PalImageBase & (ALIGN_PAL - 1)) != 0 ) {
|
|
|
|
//
|
|
// Calculate new size + alignment requirement, and allocate a new
|
|
// memory descriptor. Use any physical address starting from zero.
|
|
//
|
|
|
|
NewPageCount = PageCount + ALIGN_PAL_PAGE - 1;
|
|
|
|
//
|
|
// Allocate a memory descriptor.
|
|
//
|
|
|
|
Status = BlAllocateDescriptor(MemoryType,
|
|
0,
|
|
NewPageCount,
|
|
&ActualBase);
|
|
|
|
if (Status != ESUCCESS) {
|
|
return Status;
|
|
}
|
|
|
|
NewMemoryDescriptor = BlFindMemoryDescriptor(ActualBase);
|
|
|
|
//
|
|
// Align PAL to 64KB boundary. First, return any free memory at front
|
|
// of PAL image.
|
|
//
|
|
if ( (ActualBase & (ALIGN_PAL_PAGE - 1)) != 0 ) {
|
|
|
|
NewMemoryDescriptor = BlFindMemoryDescriptor(ActualBase);
|
|
|
|
FreePageCount = ALIGN_PAL_PAGE - (ActualBase & (ALIGN_PAL_PAGE-1));
|
|
|
|
BlGenerateDescriptor(NewMemoryDescriptor,
|
|
MemoryFree,
|
|
ActualBase,
|
|
FreePageCount);
|
|
|
|
//
|
|
// Adjust base and pagecount
|
|
//
|
|
|
|
ActualBase = (ActualBase + (ALIGN_PAL - 1 >> PAGE_SHIFT)) &
|
|
~(ALIGN_PAL_PAGE - 1);
|
|
|
|
NewPageCount -= FreePageCount;
|
|
}
|
|
|
|
//
|
|
// Compute the new image base.
|
|
//
|
|
|
|
NewImageBase = (PVOID)(KSEG0_BASE | (ActualBase << PAGE_SHIFT));
|
|
|
|
//
|
|
// Copy PAL from the loaded memory block to the new memory block.
|
|
//
|
|
|
|
PalImageBase = (PVOID)(KSEG0_BASE | (ULONG)PalImageBase);
|
|
RtlMoveMemory(NewImageBase,
|
|
(PVOID)((PUCHAR)PalImageBase + StartVA),
|
|
(PageCount << PAGE_SHIFT) - StartVA);
|
|
|
|
|
|
//
|
|
// Free the original memory descriptor.
|
|
//
|
|
|
|
BlGenerateDescriptor(PalMemoryDescriptor,
|
|
MemoryFree,
|
|
PalMemoryDescriptor->BasePage,
|
|
PalMemoryDescriptor->PageCount);
|
|
|
|
*ImageBase = NewImageBase;
|
|
|
|
//
|
|
// Return any blocks free at the end of the new image section.
|
|
//
|
|
|
|
FreePageCount = NewPageCount - PageCount + (StartVA >> PAGE_SHIFT);
|
|
|
|
if ( FreePageCount ) {
|
|
|
|
BlGenerateDescriptor(NewMemoryDescriptor,
|
|
MemoryFree,
|
|
ActualBase + PageCount - (StartVA >> PAGE_SHIFT),
|
|
FreePageCount);
|
|
|
|
}
|
|
|
|
} else if ( StartVA != 0 ) {
|
|
|
|
//
|
|
// Move the image down to the start of the memory descriptor
|
|
//
|
|
|
|
PalImageBase = (PVOID)(KSEG0_BASE | (ULONG)PalImageBase);
|
|
|
|
RtlMoveMemory(PalImageBase,
|
|
(PVOID)((PUCHAR)PalImageBase + StartVA),
|
|
(PageCount << PAGE_SHIFT) - StartVA);
|
|
|
|
//
|
|
// Return any blocks free at the end of the image.
|
|
//
|
|
|
|
FreePageCount = StartVA >> PAGE_SHIFT;
|
|
|
|
if ( FreePageCount ) {
|
|
|
|
BlGenerateDescriptor(PalMemoryDescriptor,
|
|
MemoryFree,
|
|
PalPage + PageCount - (StartVA >> PAGE_SHIFT),
|
|
FreePageCount);
|
|
}
|
|
|
|
}
|
|
|
|
return ESUCCESS;
|
|
|
|
}
|
|
|
|
|
|
ARC_STATUS
|
|
BlGeneratePalName(
|
|
IN PCHAR PalFileName
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine generates the name of the correct PAL file for the current
|
|
system.
|
|
|
|
Arguments:
|
|
|
|
PalFileName - Supplies a pointer to string for the name of the PAL file
|
|
that is generated.
|
|
|
|
Return Value:
|
|
|
|
ESUCCESS is returned if the specified PAL file name is generated.
|
|
Otherwise, an unsuccessful status is returned that describes the
|
|
reason for failure.
|
|
|
|
--*/
|
|
|
|
{
|
|
CHAR ProcessorName[32] = "";
|
|
PCHAR ProcessorId;
|
|
PCONFIGURATION_COMPONENT ComponentInfo;
|
|
ARC_STATUS Status;
|
|
ULONG Max = 7;
|
|
|
|
//
|
|
// Get the Processor Id Name from the ARC component Database.
|
|
//
|
|
|
|
ComponentInfo = ArcGetChild(NULL); // Get ARC component info
|
|
|
|
while (ComponentInfo != NULL) {
|
|
|
|
if ( ComponentInfo->Class == SystemClass &&
|
|
ComponentInfo->Identifier != NULL ) {
|
|
|
|
ComponentInfo = ArcGetChild(ComponentInfo); // Go Down in tree
|
|
|
|
} else if ( ComponentInfo->Class == ProcessorClass &&
|
|
ComponentInfo->Type == CentralProcessor &&
|
|
ComponentInfo->Identifier != NULL) {
|
|
|
|
strncat(ProcessorName, ComponentInfo->Identifier, 31);
|
|
break;
|
|
|
|
} else {
|
|
|
|
ComponentInfo = ArcGetPeer(ComponentInfo); // Look through all entries
|
|
|
|
}
|
|
}
|
|
|
|
//
|
|
// On older firmware:
|
|
//
|
|
// The ProcessorName is of the form: mmm-rName, where:
|
|
// mmm - is the manufacturer of the processor chip
|
|
// r - is the revision of the processor chip
|
|
// Name - is the name of the processor chip
|
|
//
|
|
// E.G. DEC-321064
|
|
//
|
|
// On newer firmware:
|
|
//
|
|
// The ProcessorName is of the form: mmm-Name-r, where:
|
|
// mmm - is the manufacturer of the processor chip
|
|
// r - is the revision of the processor chip
|
|
// Name - is the name of the processor chip
|
|
//
|
|
// E.G. DEC-21064-3
|
|
//
|
|
|
|
ProcessorId = strchr(ProcessorName, '-');
|
|
|
|
//
|
|
// Load the PAL image into memory. The image will be of the
|
|
// form <LoadPath>\Axxxxx.PAL. Try loading A<processorname>.PAL.
|
|
// If that fails, then try AlphaAXP.pal.
|
|
//
|
|
|
|
//
|
|
// Generate the full path name for the PAL image and load it into
|
|
// memory.
|
|
//
|
|
|
|
Status = EBADF;
|
|
if ( ProcessorId ) {
|
|
CHAR ProcessorIdName[8] = "";
|
|
PCHAR RevisionId;
|
|
ULONG Max = 7;
|
|
|
|
ProcessorId++; // Skip the hyphen
|
|
|
|
//
|
|
// Check for new ProcessorId format, look for the revision id
|
|
// after the processor id.
|
|
//
|
|
RevisionId = strchr(ProcessorId, '-');
|
|
|
|
if ( RevisionId ) {
|
|
*RevisionId = '\0'; // Terminate the processor id
|
|
RevisionId++; // Skip the hyphen
|
|
strncat(ProcessorIdName, RevisionId, 2); // Copy Revision Id
|
|
Max = Max - strlen( ProcessorIdName );
|
|
}
|
|
|
|
strncat(ProcessorIdName, ProcessorId, Max); // Copy Processor Id
|
|
sprintf(PalFileName, "A%s.PAL", ProcessorIdName);
|
|
|
|
Status = ESUCCESS;
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|