winldr.c File Reference

#include <freeldr.h>
#include <ndk/asm.h>
#include "../../winldr.h"
#include <debug.h>

Include dependency graph for winldr.c:

Go to the source code of this file.

Functions
	DBG_DEFAULT_CHANNEL (WINDOWS)
static BOOLEAN	MempAllocatePageTables (VOID)
static PHARDWARE_PTE	MempGetOrCreatePageDir (PHARDWARE_PTE PdeBase, ULONG Index)
static BOOLEAN	MempMapSinglePage (ULONG64 VirtualAddress, ULONG64 PhysicalAddress)
BOOLEAN	MempIsPageMapped (PVOID VirtualAddress)
static PFN_NUMBER	MempMapRangeOfPages (ULONG64 VirtualAddress, ULONG64 PhysicalAddress, PFN_NUMBER cPages)
BOOLEAN	MempSetupPaging (IN PFN_NUMBER StartPage, IN PFN_NUMBER NumberOfPages, IN BOOLEAN KernelMapping)
VOID	MempUnmapPage (PFN_NUMBER Page)
static VOID	WinLdrpMapApic (VOID)
static BOOLEAN	WinLdrMapSpecialPages (VOID)
static VOID	Amd64SetupGdt (PVOID GdtBase, ULONG64 TssBase)
static VOID	Amd64SetupIdt (PVOID IdtBase)
VOID	WinLdrSetProcessorContext (void)
void	WinLdrSetupMachineDependent (PLOADER_PARAMETER_BLOCK LoaderBlock)
VOID	MempDump (VOID)

Variables
PHARDWARE_PTE	PxeBase
PVOID	GdtIdt
ULONG_PTR	PcrBasePage
ULONG_PTR	TssBasePage

Function Documentation

Amd64SetupGdt()

static VOID Amd64SetupGdt ( PVOID  GdtBase, ULONG64  TssBase  )

static

Definition at line 276 of file winldr.c.

{
    PKGDTENTRY64 Entry;
    KDESCRIPTOR GdtDesc;
    TRACE("Amd64SetupGdt(GdtBase = %p, TssBase = %p)\n", GdtBase, TssBase);
 
    /* Setup KGDT64_NULL */
    Entry = KiGetGdtEntry(GdtBase, KGDT64_NULL);
    *(PULONG64)Entry = 0x0000000000000000ULL;
 
    /* Setup KGDT64_R0_CODE */
    Entry = KiGetGdtEntry(GdtBase, KGDT64_R0_CODE);
    *(PULONG64)Entry = 0x00209b0000000000ULL;
 
    /* Setup KGDT64_R0_DATA */
    Entry = KiGetGdtEntry(GdtBase, KGDT64_R0_DATA);
    *(PULONG64)Entry = 0x00cf93000000ffffULL;
 
    /* Setup KGDT64_R3_CMCODE */
    Entry = KiGetGdtEntry(GdtBase, KGDT64_R3_CMCODE);
    *(PULONG64)Entry = 0x00cffb000000ffffULL;
 
    /* Setup KGDT64_R3_DATA */
    Entry = KiGetGdtEntry(GdtBase, KGDT64_R3_DATA);
    *(PULONG64)Entry = 0x00cff3000000ffffULL;
 
    /* Setup KGDT64_R3_CODE */
    Entry = KiGetGdtEntry(GdtBase, KGDT64_R3_CODE);
    *(PULONG64)Entry = 0x0020fb0000000000ULL;
 
    /* Setup KGDT64_R3_CMTEB */
    Entry = KiGetGdtEntry(GdtBase, KGDT64_R3_CMTEB);
    *(PULONG64)Entry = 0xff40f3fd50003c00ULL;
 
    /* Setup TSS entry */
    Entry = KiGetGdtEntry(GdtBase, KGDT64_SYS_TSS);
    KiInitGdtEntry(Entry, TssBase, sizeof(KTSS), I386_TSS, 0);
 
    /* Setup GDT descriptor */
    GdtDesc.Base  = GdtBase;
    GdtDesc.Limit = NUM_GDT * sizeof(KGDTENTRY) - 1;
 
    /* Set the new Gdt */
    __lgdt(&GdtDesc.Limit);
    TRACE("Leave Amd64SetupGdt()\n");
}

Referenced by WinLdrSetProcessorContext().

Amd64SetupIdt()

static VOID Amd64SetupIdt ( PVOID  IdtBase )

static

Definition at line 325 of file winldr.c.

{
    KDESCRIPTOR IdtDesc, OldIdt;
    //ULONG Size;
    TRACE("Amd64SetupIdt(IdtBase = %p)\n", IdtBase);
 
    /* Get old IDT */
    __sidt(&OldIdt.Limit);
 
    /* Copy the old IDT */
    //Size =  min(OldIdt.Limit + 1, NUM_IDT * sizeof(KIDTENTRY));
    //RtlCopyMemory(IdtBase, (PVOID)OldIdt.Base, Size);
 
    /* Setup the new IDT descriptor */
    IdtDesc.Base = IdtBase;
    IdtDesc.Limit = NUM_IDT * sizeof(KIDTENTRY) - 1;
 
    /* Set the new IDT */
    __lidt(&IdtDesc.Limit);
    TRACE("Leave Amd64SetupIdt()\n");
}

Referenced by WinLdrSetProcessorContext().

DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL

(

WINDOWS

)

MempAllocatePageTables()

static BOOLEAN MempAllocatePageTables ( VOID  )

static

Definition at line 33 of file winldr.c.

{
    TRACE(">>> MempAllocatePageTables\n");
 
    /* Allocate a page for the PML4 */
    PxeBase = MmAllocateMemoryWithType(PAGE_SIZE, LoaderMemoryData);
    if (!PxeBase)
    {
        ERR("failed to allocate PML4\n");
        return FALSE;
    }
 
    // FIXME: Physical PTEs = FirmwareTemporary ?
 
    /* Zero the PML4 */
    RtlZeroMemory(PxeBase, PAGE_SIZE);
 
    /* The page tables are located at 0xfffff68000000000
     * We create a recursive self mapping through all 4 levels at
     * virtual address 0xfffff6fb7dbedf68 */
    PxeBase[VAtoPXI(PXE_BASE)].Valid = 1;
    PxeBase[VAtoPXI(PXE_BASE)].Write = 1;
    PxeBase[VAtoPXI(PXE_BASE)].PageFrameNumber = PtrToPfn(PxeBase);
 
    // FIXME: map PDE's for hals memory mapping
 
    TRACE(">>> leave MempAllocatePageTables\n");
 
    return TRUE;
}

Referenced by WinLdrSetupMachineDependent().

MempDump()

VOID MempDump

(

VOID

)

Definition at line 429 of file winldr.c.

{
}

Referenced by WinLdrSetupMemoryLayout().

MempGetOrCreatePageDir()

static PHARDWARE_PTE MempGetOrCreatePageDir ( PHARDWARE_PTE  PdeBase, ULONG  Index  )

static

Definition at line 66 of file winldr.c.

{
    PHARDWARE_PTE SubDir;
 
    if (!PdeBase)
        return NULL;
 
    if (!PdeBase[Index].Valid)
    {
        SubDir = MmAllocateMemoryWithType(PAGE_SIZE, LoaderMemoryData);
        if (!SubDir)
            return NULL;
        RtlZeroMemory(SubDir, PAGE_SIZE);
        PdeBase[Index].PageFrameNumber = PtrToPfn(SubDir);
        PdeBase[Index].Valid = 1;
        PdeBase[Index].Write = 1;
    }
    else
    {
        SubDir = (PVOID)((ULONG64)(PdeBase[Index].PageFrameNumber) * PAGE_SIZE);
    }
    return SubDir;
}

Referenced by MempMapSinglePage(), and WinLdrMapSpecialPages().

MempIsPageMapped()

BOOLEAN MempIsPageMapped

(

PVOID

VirtualAddress

)

Definition at line 122 of file winldr.c.

{
    PHARDWARE_PTE PpeBase, PdeBase, PteBase;
    ULONG Index;
 
    Index = VAtoPXI(VirtualAddress);
    if (!PxeBase[Index].Valid)
        return FALSE;
 
    PpeBase = (PVOID)((ULONG64)(PxeBase[Index].PageFrameNumber) * PAGE_SIZE);
    Index = VAtoPPI(VirtualAddress);
    if (!PpeBase[Index].Valid)
        return FALSE;
 
    PdeBase = (PVOID)((ULONG64)(PpeBase[Index].PageFrameNumber) * PAGE_SIZE);
    Index = VAtoPDI(VirtualAddress);
    if (!PdeBase[Index].Valid)
        return FALSE;
 
    PteBase = (PVOID)((ULONG64)(PdeBase[Index].PageFrameNumber) * PAGE_SIZE);
    Index = VAtoPTI(VirtualAddress);
    if (!PteBase[Index].Valid)
        return FALSE;
 
    return TRUE;
}

MempMapRangeOfPages()

static PFN_NUMBER MempMapRangeOfPages ( ULONG64  VirtualAddress, ULONG64  PhysicalAddress, PFN_NUMBER  cPages  )

static

Definition at line 151 of file winldr.c.

{
    PFN_NUMBER i;
 
    for (i = 0; i < cPages; i++)
    {
        if (!MempMapSinglePage(VirtualAddress, PhysicalAddress))
        {
            ERR("Failed to map page %ld from %p to %p\n",
                    i, (PVOID)VirtualAddress, (PVOID)PhysicalAddress);
            return i;
        }
        VirtualAddress += PAGE_SIZE;
        PhysicalAddress += PAGE_SIZE;
    }
    return i;
}

Referenced by MempSetupPaging().

MempMapSinglePage()

static BOOLEAN MempMapSinglePage ( ULONG64  VirtualAddress, ULONG64  PhysicalAddress  )

static

Definition at line 92 of file winldr.c.

{
    PHARDWARE_PTE PpeBase, PdeBase, PteBase;
    ULONG Index;
 
    PpeBase = MempGetOrCreatePageDir(PxeBase, VAtoPXI(VirtualAddress));
    PdeBase = MempGetOrCreatePageDir(PpeBase, VAtoPPI(VirtualAddress));
    PteBase = MempGetOrCreatePageDir(PdeBase, VAtoPDI(VirtualAddress));
 
    if (!PteBase)
    {
        ERR("!!!No Dir %p, %p, %p, %p\n", PxeBase, PpeBase, PdeBase, PteBase);
        return FALSE;
    }
 
    Index = VAtoPTI(VirtualAddress);
    if (PteBase[Index].Valid)
    {
        ERR("!!!Already mapped %ld\n", Index);
        return FALSE;
    }
 
    PteBase[Index].Valid = 1;
    PteBase[Index].Write = 1;
    PteBase[Index].PageFrameNumber = PhysicalAddress / PAGE_SIZE;
 
    return TRUE;
}

Referenced by MempMapRangeOfPages(), WinLdrMapSpecialPages(), and WinLdrpMapApic().

MempSetupPaging()

BOOLEAN MempSetupPaging	(	IN PFN_NUMBER	StartPage,
		IN PFN_NUMBER	NumberOfPages,
		IN BOOLEAN	KernelMapping
	)

Definition at line 170 of file winldr.c.

{
    TRACE(">>> MempSetupPaging(0x%lx, %ld, %p)\n",
            StartPage, NumberOfPages, StartPage * PAGE_SIZE + KSEG0_BASE);
 
    /* Identity mapping */
    if (MempMapRangeOfPages(StartPage * PAGE_SIZE,
                            StartPage * PAGE_SIZE,
                            NumberOfPages) != NumberOfPages)
    {
        ERR("Failed to map pages %ld, %ld\n",
                StartPage, NumberOfPages);
        return FALSE;
    }
 
    /* Kernel mapping */
    if (KernelMapping)
    {
        if (MempMapRangeOfPages(StartPage * PAGE_SIZE + KSEG0_BASE,
                                StartPage * PAGE_SIZE,
                                NumberOfPages) != NumberOfPages)
        {
            ERR("Failed to map pages %ld, %ld\n",
                    StartPage, NumberOfPages);
            return FALSE;
        }
    }
 
    return TRUE;
}

Referenced by MempSetupPagingForRegion(), and WinLdrSetupMemoryLayout().

MempUnmapPage()

VOID MempUnmapPage

(

PFN_NUMBER

Page

)

Definition at line 204 of file winldr.c.

{
   // TRACE(">>> MempUnmapPage\n");
}

WinLdrMapSpecialPages()

static BOOLEAN WinLdrMapSpecialPages ( VOID  )

static

Definition at line 244 of file winldr.c.

{
    PHARDWARE_PTE PpeBase, PdeBase;
 
    /* Map the PCR page */
    if (!MempMapSinglePage(KIP0PCRADDRESS, PcrBasePage * PAGE_SIZE))
    {
        ERR("Could not map PCR @ %lx\n", PcrBasePage);
        return FALSE;
    }
 
    /* Map KI_USER_SHARED_DATA */
    if (!MempMapSinglePage(KI_USER_SHARED_DATA, (PcrBasePage+1) * PAGE_SIZE))
    {
        ERR("Could not map KI_USER_SHARED_DATA\n");
        return FALSE;
    }
 
    /* Map the APIC page */
    WinLdrpMapApic();
 
    /* Map the page tables for 4 MB HAL address space. */
    PpeBase = MempGetOrCreatePageDir(PxeBase, VAtoPXI(MM_HAL_VA_START));
    PdeBase = MempGetOrCreatePageDir(PpeBase, VAtoPPI(MM_HAL_VA_START));
    MempGetOrCreatePageDir(PdeBase, VAtoPDI(MM_HAL_VA_START));
    MempGetOrCreatePageDir(PdeBase, VAtoPDI(MM_HAL_VA_START + 2 * 1024 * 1024));
 
    return TRUE;
}

WinLdrpMapApic()

static VOID WinLdrpMapApic ( VOID  )

static

Definition at line 211 of file winldr.c.

{
    BOOLEAN LocalAPIC;
    LARGE_INTEGER MsrValue;
    ULONG CpuInfo[4];
    ULONG64 APICAddress;
 
    TRACE(">>> WinLdrpMapApic\n");
 
    /* Check if we have a local APIC */
    __cpuid((int*)CpuInfo, 1);
    LocalAPIC = (((CpuInfo[3] >> 9) & 1) != 0);
 
    /* If there is no APIC, just return */
    if (!LocalAPIC)
    {
        WARN("No APIC found.\n");
        return;
    }
 
    /* Read the APIC Address */
    MsrValue.QuadPart = __readmsr(0x1B);
    APICAddress = (MsrValue.LowPart & 0xFFFFF000);
 
    TRACE("Local APIC detected at address 0x%x\n",
        APICAddress);
 
    /* Map it */
    MempMapSinglePage(APIC_BASE, APICAddress);
}

Referenced by WinLdrMapSpecialPages().

WinLdrSetProcessorContext()

VOID WinLdrSetProcessorContext

(

void

)

Definition at line 348 of file winldr.c.

{
    TRACE("WinLdrSetProcessorContext\n");
 
    /* Disable Interrupts */
    _disable();
 
    /* Re-initialize EFLAGS */
    __writeeflags(0);
 
    /* Set the new PML4 */
    __writecr3((ULONG64)PxeBase);
 
    /* Get kernel mode address of gdt / idt */
    GdtIdt = (PVOID)((ULONG64)GdtIdt + KSEG0_BASE);
 
    /* Create gdt entries and load gdtr */
    Amd64SetupGdt(GdtIdt, KSEG0_BASE | (TssBasePage << MM_PAGE_SHIFT));
 
    /* Copy old Idt and set idtr */
    Amd64SetupIdt((PVOID)((ULONG64)GdtIdt + NUM_GDT * sizeof(KGDTENTRY)));
 
    /* LDT is unused */
//    __lldt(0);
 
    /* Load TSR */
    __ltr(KGDT64_SYS_TSS);
 
    TRACE("leave WinLdrSetProcessorContext\n");
}

Referenced by LoadAndBootWindowsCommon().

WinLdrSetupMachineDependent()

void WinLdrSetupMachineDependent

(

PLOADER_PARAMETER_BLOCK

LoaderBlock

)

Definition at line 379 of file winldr.c.

{
    ULONG_PTR Pcr = 0;
    ULONG_PTR Tss = 0;
    ULONG BlockSize, NumPages;
 
    LoaderBlock->u.I386.CommonDataArea = (PVOID)DbgPrint; // HACK
    LoaderBlock->u.I386.MachineType = MACHINE_TYPE_ISA;
 
    /* Allocate 2 pages for PCR */
    Pcr = (ULONG_PTR)MmAllocateMemoryWithType(2 * MM_PAGE_SIZE, LoaderStartupPcrPage);
    PcrBasePage = Pcr >> MM_PAGE_SHIFT;
    if (Pcr == 0)
    {
        UiMessageBox("Can't allocate PCR.");
        return;
    }
    RtlZeroMemory((PVOID)Pcr, 2 * MM_PAGE_SIZE);
 
    /* Allocate TSS */
    BlockSize = (sizeof(KTSS) + MM_PAGE_SIZE) & ~(MM_PAGE_SIZE - 1);
    Tss = (ULONG_PTR)MmAllocateMemoryWithType(BlockSize, LoaderMemoryData);
    TssBasePage = Tss >> MM_PAGE_SHIFT;
 
    /* Allocate space for new GDT + IDT */
    BlockSize = NUM_GDT * sizeof(KGDTENTRY) + NUM_IDT * sizeof(KIDTENTRY);
    NumPages = (BlockSize + MM_PAGE_SIZE - 1) >> MM_PAGE_SHIFT;
    GdtIdt = (PKGDTENTRY)MmAllocateMemoryWithType(NumPages * MM_PAGE_SIZE, LoaderMemoryData);
    if (GdtIdt == NULL)
    {
        UiMessageBox("Can't allocate pages for GDT+IDT!");
        return;
    }
 
    /* Zero newly prepared GDT+IDT */
    RtlZeroMemory(GdtIdt, NumPages << MM_PAGE_SHIFT);
 
    // Before we start mapping pages, create a block of memory, which will contain
    // PDE and PTEs
    if (MempAllocatePageTables() == FALSE)
    {
        // FIXME: bugcheck
    }
 
    /* Map stuff like PCR, KI_USER_SHARED_DATA and Apic */
    WinLdrMapSpecialPages();
}

Referenced by LoadAndBootWindowsCommon().

Variable Documentation

GdtIdt

PVOID GdtIdt

Definition at line 25 of file winldr.c.

Referenced by WinLdrSetProcessorContext(), and WinLdrSetupMachineDependent().

PcrBasePage

ULONG_PTR PcrBasePage

Definition at line 26 of file winldr.c.

Referenced by WinLdrMapSpecialPages(), and WinLdrSetupMachineDependent().

PxeBase

PHARDWARE_PTE PxeBase

Definition at line 22 of file winldr.c.

Referenced by MempAllocatePageTables(), MempIsPageMapped(), MempMapSinglePage(), WinLdrMapSpecialPages(), and WinLdrSetProcessorContext().

TssBasePage

ULONG_PTR TssBasePage

Definition at line 27 of file winldr.c.

Referenced by WinLdrSetProcessorContext(), and WinLdrSetupMachineDependent().