hypermap.c File Reference

#include <ntoskrnl.h>
#include <debug.h>
#include <mm/ARM3/miarm.h>

Include dependency graph for hypermap.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	MODULE_INVOLVED_IN_ARM3

Functions
PVOID NTAPI	MiMapPageInHyperSpace (IN PEPROCESS Process, IN PFN_NUMBER Page, IN PKIRQL OldIrql)
VOID NTAPI	MiUnmapPageInHyperSpace (IN PEPROCESS Process, IN PVOID Address, IN KIRQL OldIrql)
PVOID NTAPI	MiMapPagesInZeroSpace (IN PMMPFN Pfn1, IN PFN_NUMBER NumberOfPages)
VOID NTAPI	MiUnmapPagesInZeroSpace (IN PVOID VirtualAddress, IN PFN_NUMBER NumberOfPages)

Variables
PMMPTE	MmFirstReservedMappingPte
PMMPTE	MmLastReservedMappingPte
PMMPTE	MiFirstReservedZeroingPte
MMPTE	HyperTemplatePte

Macro Definition Documentation

MODULE_INVOLVED_IN_ARM3

#define MODULE_INVOLVED_IN_ARM3

Definition at line 15 of file hypermap.c.

NDEBUG

#define NDEBUG

Definition at line 12 of file hypermap.c.

Function Documentation

MiMapPageInHyperSpace()

PVOID NTAPI MiMapPageInHyperSpace	(	IN PEPROCESS	Process,
		IN PFN_NUMBER	Page,
		IN PKIRQL	OldIrql
	)

Definition at line 28 of file hypermap.c.

{
    MMPTE TempPte;
    PMMPTE PointerPte;
    PFN_NUMBER Offset;
 
    //
    // Never accept page 0 or non-physical pages
    //
    ASSERT(Page != 0);
    ASSERT(MiGetPfnEntry(Page) != NULL);
 
    //
    // Build the PTE
    //
    TempPte = ValidKernelPteLocal;
    TempPte.u.Hard.PageFrameNumber = Page;
 
    //
    // Pick the first hyperspace PTE
    //
    PointerPte = MmFirstReservedMappingPte;
 
    //
    // Acquire the hyperlock
    //
    ASSERT(Process == PsGetCurrentProcess());
    KeAcquireSpinLock(&Process->HyperSpaceLock, OldIrql);
 
    //
    // Now get the first free PTE
    //
    Offset = PFN_FROM_PTE(PointerPte);
    if (!Offset)
    {
        //
        // Reset the PTEs
        //
        Offset = MI_HYPERSPACE_PTES;
        KeFlushProcessTb();
    }
 
    //
    // Prepare the next PTE
    //
    PointerPte->u.Hard.PageFrameNumber = Offset - 1;
 
    //
    // Write the current PTE
    //
    PointerPte += Offset;
    MI_WRITE_VALID_PTE(PointerPte, TempPte);
 
    //
    // Return the address
    //
    return MiPteToAddress(PointerPte);
}

Referenced by MiCopyFromUserPage(), MiReadFilePage(), and MiZeroPhysicalPage().

MiMapPagesInZeroSpace()

PVOID NTAPI MiMapPagesInZeroSpace	(	IN PMMPFN	Pfn1,
		IN PFN_NUMBER	NumberOfPages
	)

Definition at line 111 of file hypermap.c.

{
    MMPTE TempPte;
    PMMPTE PointerPte;
    PFN_NUMBER Offset, PageFrameIndex;
 
    //
    // Sanity checks
    //
    ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
    ASSERT(NumberOfPages != 0);
    ASSERT(NumberOfPages <= MI_ZERO_PTES);
 
    //
    // Pick the first zeroing PTE
    //
    PointerPte = MiFirstReservedZeroingPte;
 
    //
    // Now get the first free PTE
    //
    Offset = PFN_FROM_PTE(PointerPte);
    if (NumberOfPages > Offset)
    {
        //
        // Reset the PTEs
        //
        Offset = MI_ZERO_PTES;
        PointerPte->u.Hard.PageFrameNumber = Offset;
        KeFlushProcessTb();
    }
 
    //
    // Prepare the next PTE
    //
    PointerPte->u.Hard.PageFrameNumber = Offset - NumberOfPages;
 
    /* Choose the correct PTE to use, and which template */
    PointerPte += (Offset + 1);
    TempPte = ValidKernelPte;
 
    /* Disable caching */
    MI_MAKE_PTE_NON_CACHED(&TempPte);
 
    /* Make sure the list isn't empty and loop it */
    ASSERT(Pfn1 != (PVOID)LIST_HEAD);
    while (Pfn1 != (PVOID)LIST_HEAD)
    {
        /* Get the page index for this PFN */
        PageFrameIndex = MiGetPfnEntryIndex(Pfn1);
 
        //
        // Write the PFN
        //
        TempPte.u.Hard.PageFrameNumber = PageFrameIndex;
 
        //
        // Set the correct PTE to write to, and set its new value
        //
        PointerPte--;
        MI_WRITE_VALID_PTE(PointerPte, TempPte);
 
        /* Move to the next PFN */
        Pfn1 = (PMMPFN)Pfn1->u1.Flink;
    }
 
    //
    // Return the address
    //
    return MiPteToAddress(PointerPte);
}

Referenced by MmZeroPageThread().

MiUnmapPageInHyperSpace()

VOID NTAPI MiUnmapPageInHyperSpace	(	IN PEPROCESS	Process,
		IN PVOID	Address,
		IN KIRQL	OldIrql
	)

Definition at line 91 of file hypermap.c.

{
    ASSERT(Process == PsGetCurrentProcess());
 
    //
    // Blow away the mapping
    //
    MiAddressToPte(Address)->u.Long = 0;
 
    //
    // Release the hyperlock
    //
    ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
    KeReleaseSpinLock(&Process->HyperSpaceLock, OldIrql);
}

Referenced by MiCopyFromUserPage(), MiReadFilePage(), and MiZeroPhysicalPage().

MiUnmapPagesInZeroSpace()

VOID NTAPI MiUnmapPagesInZeroSpace	(	IN PVOID	VirtualAddress,
		IN PFN_NUMBER	NumberOfPages
	)

Definition at line 186 of file hypermap.c.

{
    PMMPTE PointerPte;
 
    //
    // Sanity checks
    //
    ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
    ASSERT (NumberOfPages != 0);
    ASSERT(NumberOfPages <= MI_ZERO_PTES);
 
    //
    // Get the first PTE for the mapped zero VA
    //
    PointerPte = MiAddressToPte(VirtualAddress);
 
    //
    // Blow away the mapped zero PTEs
    //
    RtlZeroMemory(PointerPte, NumberOfPages * sizeof(MMPTE));
}

Referenced by MmZeroPageThread().

Variable Documentation

HyperTemplatePte

MMPTE HyperTemplatePte

Definition at line 22 of file hypermap.c.

Referenced by MiInitializePageTable().

MiFirstReservedZeroingPte

PMMPTE MiFirstReservedZeroingPte

Definition at line 21 of file hypermap.c.

Referenced by MiBuildSystemPteSpace(), MiInitMachineDependent(), and MiMapPagesInZeroSpace().

MmFirstReservedMappingPte

PMMPTE MmFirstReservedMappingPte

Definition at line 20 of file hypermap.c.

Referenced by MiInitializePageTable(), MiInitMachineDependent(), and MiMapPageInHyperSpace().

MmLastReservedMappingPte

PMMPTE MmLastReservedMappingPte

Definition at line 20 of file hypermap.c.

Referenced by MiInitializePageTable(), and MiInitMachineDependent().