|
|
/*++
Copyright (c) 1991 Microsoft CorporationCopyright (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_STATUSBlLoadPal( 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_STATUSBlGeneratePalName( 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;}
|
