stubs.c File Reference

#include <ntoskrnl.h>
#include <debug.h>

Include dependency graph for stubs.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
BOOLEAN NTAPI	MiUnmapPageTable (IN PMMPTE PointerPde)
VOID NTAPI	MiFlushTlb (IN PMMPTE PointerPte, IN PVOID Address)
PMMPTE NTAPI	MiGetPageTableForProcess (IN PEPROCESS Process, IN PVOID Address, IN BOOLEAN Create)
MMPTE NTAPI	MiGetPageEntryForProcess (IN PEPROCESS Process, IN PVOID Address)
BOOLEAN NTAPI	MmCreateProcessAddressSpace (IN ULONG MinWs, IN PEPROCESS Process, IN PULONG DirectoryTableBase)
NTSTATUS NTAPI	MmCreateVirtualMappingInternal (IN PEPROCESS Process, IN PVOID Address, IN ULONG Protection, IN PPFN_NUMBER Pages, IN ULONG PageCount, IN BOOLEAN MarkAsMapped)
NTSTATUS NTAPI	MmCreateVirtualMappingUnsafe (IN PEPROCESS Process, IN PVOID Address, IN ULONG Protection, IN PPFN_NUMBER Pages, IN ULONG PageCount)
NTSTATUS NTAPI	MmCreateVirtualMapping (IN PEPROCESS Process, IN PVOID Address, IN ULONG Protection, IN PPFN_NUMBER Pages, IN ULONG PageCount)
VOID NTAPI	MmDeleteVirtualMapping (IN PEPROCESS Process, IN PVOID Address, OUT PBOOLEAN WasDirty, OUT PPFN_NUMBER Page)
VOID NTAPI	MmDeletePageFileMapping (IN PEPROCESS Process, IN PVOID Address, IN SWAPENTRY *SwapEntry)
NTSTATUS NTAPI	MmCreatePageFileMapping (IN PEPROCESS Process, IN PVOID Address, IN SWAPENTRY SwapEntry)
PFN_NUMBER NTAPI	MmGetPfnForProcess (IN PEPROCESS Process, IN PVOID Address)
BOOLEAN NTAPI	MmIsDirtyPage (IN PEPROCESS Process, IN PVOID Address)
VOID NTAPI	MmSetCleanPage (IN PEPROCESS Process, IN PVOID Address)
VOID NTAPI	MmSetDirtyPage (IN PEPROCESS Process, IN PVOID Address)
BOOLEAN NTAPI	MmIsPagePresent (IN PEPROCESS Process, IN PVOID Address)
BOOLEAN NTAPI	MmIsPageSwapEntry (IN PEPROCESS Process, IN PVOID Address)
ULONG NTAPI	MmGetPageProtect (IN PEPROCESS Process, IN PVOID Address)
VOID NTAPI	MmSetPageProtect (IN PEPROCESS Process, IN PVOID Address, IN ULONG Protection)
VOID NTAPI	MmInitGlobalKernelPageDirectory (VOID)
PHYSICAL_ADDRESS NTAPI	MmGetPhysicalAddress (IN PVOID Address)

Variables
ULONG	MmGlobalKernelPageDirectory [1024]
MMPTE	MiArmTemplatePte
MMPDE_HARDWARE	MiArmTemplatePde

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 12 of file stubs.c.

Function Documentation

MiFlushTlb()

VOID NTAPI MiFlushTlb	(	IN PMMPTE	PointerPte,
		IN PVOID	Address
	)

Definition at line 48 of file stubs.c.

{
    //
    // Make sure the PTE is valid, and unmap the pagetable if user-mode
    //
    if (((PointerPte) && (MiUnmapPageTable(PointerPte))) ||
        (Address >= MmSystemRangeStart))
    {
        //
        // Invalidate this page
        //
        KeArmInvalidateTlbEntry(Address);
    }
}

Referenced by MmDeleteVirtualMapping().

MiGetPageEntryForProcess()

MMPTE NTAPI MiGetPageEntryForProcess	(	IN PEPROCESS	Process,
		IN PVOID	Address
	)

Definition at line 217 of file stubs.c.

{
    PMMPTE PointerPte;
    MMPTE Pte;
    Pte.u.Hard.AsUlong = 0;
 
    //
    // Get the PTE
    //
    PointerPte = MiGetPageTableForProcess(Process, Address, FALSE);
    if (PointerPte)
    {
        //
        // Capture the PTE value and unmap the page table
        //
        Pte = *PointerPte;
        MiUnmapPageTable(PointerPte);
    }
 
    //
    // Return the PTE value
    //
    return Pte;
}

Referenced by MmGetPfnForProcess(), MmGetPhysicalAddress(), MmIsPagePresent(), and MmIsPageSwapEntry().

MiGetPageTableForProcess()

PMMPTE NTAPI MiGetPageTableForProcess	(	IN PEPROCESS	Process,
		IN PVOID	Address,
		IN BOOLEAN	Create
	)

Definition at line 66 of file stubs.c.

{
    //ULONG PdeOffset;
    PMMPTE PointerPte;
    PMMPDE_HARDWARE PointerPde;
    MMPDE_HARDWARE TempPde;
    MMPTE TempPte;
    NTSTATUS Status;
    PFN_NUMBER Pfn;
 
    //
    // Check if this is a user-mode, non-kernel or non-current address
    //
    if ((Address < MmSystemRangeStart) &&
        (Process) &&
        (Process != PsGetCurrentProcess()))
    {
        //
        // FIXME-USER: No user-mode memory support
        //
        ASSERT(FALSE);
    }
 
    //
    // Get our templates
    //
    TempPde = MiArmTemplatePde;
    TempPte = MiArmTemplatePte;
 
    //
    // Get the PDE
    //
    PointerPde = MiAddressToPde(Address);
    if (PointerPde->u.Hard.Coarse.Valid)
    {
        //
        // Invalid PDE, is this a kernel address?
        //
        if (Address >= MmSystemRangeStart)
        {
            //
            // Does it exist in the kernel page directory?
            //
            //PdeOffset = MiGetPdeOffset(Address);
            //if (MmGlobalKernelPageDirectory[PdeOffset] == 0)
            {
                //
                // It doesn't. Is this a create operation? If not, fail
                //
                if (Create == FALSE) return NULL;
            kernelHack:
                DPRINT1("Must create a page for: %p PDE: %p\n", // Offset: %lx!\n",
                        Address, PointerPde);//, PdeOffset);
 
                //
                // Allocate a non paged pool page for the PDE
                //
                Status = MmRequestPageMemoryConsumer(MC_NPPOOL, FALSE, &Pfn);
                if (!NT_SUCCESS(Status)) return NULL;
 
                //
                // Setup the PFN
                //
                TempPde.u.Hard.Coarse.PageFrameNumber = (Pfn << PAGE_SHIFT) >> CPT_SHIFT;
 
                //
                // Write the PDE
                //
                ASSERT(PointerPde->u.Hard.Coarse.Valid == 0);
                ASSERT(TempPde.u.Hard.Coarse.Valid == 1);
                *PointerPde = TempPde;
 
                //
                // Save it
                //
                //MmGlobalKernelPageDirectory[PdeOffset] = TempPde.u.Hard.AsUlong;
                //DPRINT1("KPD: %p PDEADDR: %p\n", &MmGlobalKernelPageDirectory[PdeOffset], MiAddressToPde(Address));
 
                //
                // FIXFIX: Double check with Felix tomorrow
                //
                //
                // Get the PTE for this 1MB region
                //
                PointerPte = MiAddressToPte(MiAddressToPte(Address));
                DPRINT1("PointerPte: %p\n", PointerPte);
 
                //
                // Write the PFN of the PDE
                //
                TempPte.u.Hard.PageFrameNumber = Pfn;
 
                //
                // Write the PTE
                //
                ASSERT(PointerPte->u.Hard.Valid == 0);
                ASSERT(TempPte.u.Hard.Valid == 1);
                *PointerPte = TempPte;
            }
 
            //
            // Now set the actual PDE
            //
            //PointerPde = (PMMPTE)&MmGlobalKernelPageDirectory[PdeOffset];
        }
        else
        {
            //
            // Is this a create operation? If not, fail
            //
            if (Create == FALSE) return NULL;
 
            //
            // THIS WHOLE PATH IS TODO
            //
#if 1
            goto kernelHack;
#else
            ASSERT(FALSE);
 
            //
            // Allocate a non paged pool page for the PDE
            //
            Status = MmRequestPageMemoryConsumer(MC_NPPOOL, FALSE, &Pfn);
            if (!NT_SUCCESS(Status)) return NULL;
 
            //
            // Make the entry valid
            //
            TempPde.u.Hard.AsUlong = 0xDEADBEEF;
 
            //
            // Set it
            //
            *PointerPde = TempPde;
#endif
        }
    }
 
    //
    // Return the PTE
    //
    return MiAddressToPte(Address);
}

Referenced by MiGetPageEntryForProcess(), MmCreateVirtualMappingInternal(), and MmDeleteVirtualMapping().

MiUnmapPageTable()

BOOLEAN NTAPI MiUnmapPageTable

(

IN PMMPTE

PointerPde

)

Definition at line 25 of file stubs.c.

{
    //
    // Check if this address belongs to the kernel
    //
    if (((ULONG_PTR)PointerPde > PDE_BASE) ||
        ((ULONG_PTR)PointerPde < (PDE_BASE + 1024*1024)))
    {
        //
        // Nothing to do
        //
        return TRUE;
    }
 
    //
    // FIXME-USER: Shouldn't get here yet
    //
    ERROR_FATAL();
    return FALSE;
}

Referenced by MiFlushTlb(), MiGetPageEntryForProcess(), and MmCreateVirtualMappingInternal().

MmCreatePageFileMapping()

NTSTATUS NTAPI MmCreatePageFileMapping	(	IN PEPROCESS	Process,
		IN PVOID	Address,
		IN SWAPENTRY	SwapEntry
	)

Definition at line 526 of file stubs.c.

{
    //
    // TODO
    //
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_IMPLEMENTED;
}

MmCreateProcessAddressSpace()

BOOLEAN NTAPI MmCreateProcessAddressSpace	(	IN ULONG	MinWs,
		IN PEPROCESS	Process,
		IN PULONG	DirectoryTableBase
	)

Definition at line 245 of file stubs.c.

{
    NTSTATUS Status;
    ULONG i;
    PFN_NUMBER Pfn[2];
    PMMPDE_HARDWARE PageDirectory, PointerPde;
    MMPDE_HARDWARE TempPde;
    ASSERT(FALSE);
 
    //
    // Loop two tables (Hyperspace and TTB). Each one is 16KB
    //
    //
    for (i = 0; i < sizeof(Pfn) / sizeof(Pfn[0]); i++)
    {
        //
        // Allocate a page
        //
        Status = MmRequestPageMemoryConsumer(MC_NPPOOL, FALSE, &Pfn[i]);
        if (!NT_SUCCESS(Status)) ASSERT(FALSE);
    }
 
    //
    // Map the base
    //
    PageDirectory = MmCreateHyperspaceMapping(Pfn[0]);
 
    //
    // Copy the PDEs for kernel-mode
    //
    RtlCopyMemory(PageDirectory + MiGetPdeOffset(MmSystemRangeStart),
                  MmGlobalKernelPageDirectory + MiGetPdeOffset(MmSystemRangeStart),
                  (1024 - MiGetPdeOffset(MmSystemRangeStart)) * sizeof(ULONG));
 
 
    //
    // Setup the PDE for the table base
    //
    TempPde = MiArmTemplatePde;
    TempPde.u.Hard.Coarse.PageFrameNumber = (Pfn[0] << PAGE_SHIFT) >> CPT_SHIFT;
    PointerPde = &PageDirectory[MiGetPdeOffset(PTE_BASE)];
 
    //
    // Write the PDE
    //
    ASSERT(PointerPde->u.Hard.Coarse.Valid == 0);
    ASSERT(TempPde.u.Hard.Coarse.Valid == 1);
    *PointerPde = TempPde;
 
    //
    // Setup the PDE for the hyperspace
    //
    TempPde.u.Hard.Coarse.PageFrameNumber = (Pfn[1] << PAGE_SHIFT) >> CPT_SHIFT;
    PointerPde = &PageDirectory[MiGetPdeOffset(HYPER_SPACE)];
 
    //
    // Write the PDE
    //
    ASSERT(PointerPde->u.Hard.Coarse.Valid == 0);
    ASSERT(TempPde.u.Hard.Coarse.Valid == 1);
    *PointerPde = TempPde;
 
    //
    // Unmap the page directory
    //
    MmDeleteHyperspaceMapping(PageDirectory);
 
    //
    // Return the page table base
    //
    DirectoryTableBase[0] = Pfn[0] << PAGE_SHIFT;
    return TRUE;
}

Referenced by PspCreateProcess().

MmCreateVirtualMapping()

NTSTATUS NTAPI MmCreateVirtualMapping	(	IN PEPROCESS	Process,
		IN PVOID	Address,
		IN ULONG	Protection,
		IN PPFN_NUMBER	Pages,
		IN ULONG	PageCount
	)

Definition at line 437 of file stubs.c.

{
    ULONG i;
 
    //
    // Loop each page
    //
    for (i = 0; i < PageCount; i++)
    {
        //
        // Make sure the page is marked as in use
        //
        ASSERT(MmIsPageInUse(Pages[i]));
    }
 
    //
    // Call the unsafe version
    //
    return MmCreateVirtualMappingUnsafe(Process,
                                        Address,
                                        Protection,
                                        Pages,
                                        PageCount);
}

MmCreateVirtualMappingInternal()

NTSTATUS NTAPI MmCreateVirtualMappingInternal	(	IN PEPROCESS	Process,
		IN PVOID	Address,
		IN ULONG	Protection,
		IN PPFN_NUMBER	Pages,
		IN ULONG	PageCount,
		IN BOOLEAN	MarkAsMapped
	)

Definition at line 323 of file stubs.c.

{
    PMMPTE PointerPte = NULL;
    MMPTE TempPte;
    PVOID Addr;
    ULONG OldPdeOffset, PdeOffset, i;
    DPRINT("[KMAP]: %p %d\n", Address, PageCount);
    //ASSERT(Address >= MmSystemRangeStart);
 
    //
    // Get our template PTE
    //
    TempPte = MiArmTemplatePte;
 
    //
    // Loop every page
    //
    Addr = Address;
    OldPdeOffset = MiGetPdeOffset(Addr) + 1;
    for (i = 0; i < PageCount; i++)
    {
        //
        // Get the next PDE offset and check if it's a new one
        //
        PdeOffset = MiGetPdeOffset(Addr);
        if (OldPdeOffset != PdeOffset)
        {
            //
            // Get rid of the old L2 Table, if this was the last PTE on it
            //
            MiUnmapPageTable(PointerPte);
 
            //
            // Get the PTE for this address, and create the PDE for it
            //
            PointerPte = MiGetPageTableForProcess(NULL, Addr, TRUE);
            ASSERT(PointerPte);
        }
        else
        {
            //
            // Go to the next PTE on this PDE
            //
            ASSERT(PointerPte);
            PointerPte++;
        }
 
        //
        // Save the current PDE
        //
        OldPdeOffset = PdeOffset;
 
        //
        // Set the PFN
        //
        TempPte.u.Hard.PageFrameNumber = *Pages++;
 
        //
        // Write the PTE
        //
        ASSERT(PointerPte->u.Hard.Valid == 0);
        ASSERT(TempPte.u.Hard.Valid == 1);
        *PointerPte = TempPte;
 
        //
        // Move to the next page
        //
        Addr = (PVOID)((ULONG_PTR)Addr + PAGE_SIZE);
    }
 
    //
    // All done
    //
    return STATUS_SUCCESS;
}

Referenced by MmCreateVirtualMappingUnsafe().

MmCreateVirtualMappingUnsafe()

NTSTATUS NTAPI MmCreateVirtualMappingUnsafe	(	IN PEPROCESS	Process,
		IN PVOID	Address,
		IN ULONG	Protection,
		IN PPFN_NUMBER	Pages,
		IN ULONG	PageCount
	)

Definition at line 406 of file stubs.c.

{
    //
    // Are we only handling the kernel?
    //
    if (!(Process) || (Process == PsGetCurrentProcess()))
    {
        //
        // Call the internal version
        //
        return MmCreateVirtualMappingInternal(Process,
                                              Address,
                                              Protection,
                                              Pages,
                                              PageCount,
                                              TRUE);
    }
 
    //
    // FIXME-USER: Support user-mode mappings
    //
    ASSERT(FALSE);
    return 0;
}

Referenced by MmCreateVirtualMapping().

MmDeletePageFileMapping()

VOID NTAPI MmDeletePageFileMapping	(	IN PEPROCESS	Process,
		IN PVOID	Address,
		IN SWAPENTRY *	SwapEntry
	)

Definition at line 514 of file stubs.c.

{
    //
    // TODO
    //
    UNIMPLEMENTED_DBGBREAK();
}

MmDeleteVirtualMapping()

VOID NTAPI MmDeleteVirtualMapping	(	IN PEPROCESS	Process,
		IN PVOID	Address,
		OUT PBOOLEAN	WasDirty,
		OUT PPFN_NUMBER	Page
	)

Definition at line 468 of file stubs.c.

{
    PMMPTE PointerPte;
    MMPTE Pte;
    PFN_NUMBER Pfn = 0;
 
    //
    // Get the PTE
    //
    PointerPte = MiGetPageTableForProcess(NULL, Address, FALSE);
    if (PointerPte)
    {
        //
        // Save and destroy the PTE
        //
        Pte = *PointerPte;
        PointerPte->u.Hard.AsUlong = 0;
 
        //
        // Flush the TLB
        //
        MiFlushTlb(PointerPte, Address);
 
        //
        // Unmap the PFN
        //
        Pfn = Pte.u.Hard.PageFrameNumber;
 
        //
        // Release the PFN if it was ours
        //
        if ((FreePage) && (Pfn)) MmReleasePageMemoryConsumer(MC_NPPOOL, Pfn);
    }
 
    //
    // Return if the page was dirty
    //
    if (WasDirty) *WasDirty = FALSE; // LIE!!!
    if (Page) *Page = Pfn;
}

MmGetPageProtect()

ULONG NTAPI MmGetPageProtect	(	IN PEPROCESS	Process,
		IN PVOID	Address
	)

Definition at line 621 of file stubs.c.

{
    //
    // We don't enforce any protection on the pages -- they are all RWX
    //
    return PAGE_READWRITE;
}

MmGetPfnForProcess()

PFN_NUMBER NTAPI MmGetPfnForProcess	(	IN PEPROCESS	Process,
		IN PVOID	Address
	)

Definition at line 539 of file stubs.c.

{
    MMPTE Pte;
 
    //
    // Get the PTE
    //
    Pte = MiGetPageEntryForProcess(Process, Address);
    if (Pte.u.Hard.Valid == 0) return 0;
 
    //
    // Return PFN
    //
    return Pte.u.Hard.PageFrameNumber;
}

MmGetPhysicalAddress()

PHYSICAL_ADDRESS NTAPI MmGetPhysicalAddress

(

IN PVOID

Address

)

Definition at line 685 of file stubs.c.

{
    PHYSICAL_ADDRESS PhysicalAddress;
    MMPTE Pte;
 
    //
    // Early boot PCR check
    //
    if (Address == PCR)
    {
        //
        // ARM Hack while we still use a section PTE
        //
        PMMPDE_HARDWARE PointerPde;
        PointerPde = MiAddressToPde(PCR);
        ASSERT(PointerPde->u.Hard.Section.Valid == 1);
        PhysicalAddress.QuadPart = PointerPde->u.Hard.Section.PageFrameNumber;
        PhysicalAddress.QuadPart <<= CPT_SHIFT;
        PhysicalAddress.LowPart += BYTE_OFFSET(Address);
        return PhysicalAddress;
    }
 
    //
    // Get the PTE
    //
    Pte = MiGetPageEntryForProcess(NULL, Address);
    if (Pte.u.Hard.Valid)
    {
        //
        // Return the information
        //
        PhysicalAddress.QuadPart = Pte.u.Hard.PageFrameNumber;
        PhysicalAddress.QuadPart <<= PAGE_SHIFT;
        PhysicalAddress.LowPart += BYTE_OFFSET(Address);
    }
    else
    {
        //
        // Invalid or unmapped
        //
        PhysicalAddress.QuadPart = 0;
    }
 
    //
    // Return the physical address
    //
    return PhysicalAddress;
}

Referenced by AcpiOsGetPhysicalAddress(), AtapiVirtToPhysAddr_(), CcRosTrimCache(), HalAllocateCommonBuffer(), HalpGrowMapBuffers(), HalpSetupTemporaryMappings(), HDA_InitCorbRirbPos(), CAC97MiniportWaveRTStream::Init(), KdDebuggerInitialize0(), Ki386BuildIdentityBuffer(), Ki386ConvertPte(), Ki386CreateIdentityMap(), SoundProgramDMA(), StorPortGetPhysicalAddress(), StorPortGetUncachedExtension(), TestPhysicalMemorySection(), and VidInitialize().

MmInitGlobalKernelPageDirectory()

VOID NTAPI MmInitGlobalKernelPageDirectory

(

VOID

)

Definition at line 644 of file stubs.c.

{
    ULONG i;
    PULONG CurrentPageDirectory = (PULONG)PDE_BASE;
 
    //
    // Good place to setup template PTE/PDEs.
    // We are lazy and pick a known-good PTE
    //
    MiArmTemplatePte = *MiAddressToPte(0x80000000);
    MiArmTemplatePde = *MiAddressToPde(0x80000000);
 
    //
    // Loop the 2GB of address space which belong to the kernel
    //
    for (i = MiGetPdeOffset(MmSystemRangeStart); i < 1024; i++)
    {
        //
        // Check if we have an entry for this already
        //
        if ((i != MiGetPdeOffset(PTE_BASE)) &&
            (i != MiGetPdeOffset(HYPER_SPACE)) &&
            (!MmGlobalKernelPageDirectory[i]) &&
            (CurrentPageDirectory[i]))
        {
            //
            // We don't, link it in our global page directory
            //
            MmGlobalKernelPageDirectory[i] = CurrentPageDirectory[i];
        }
    }
}

MmIsDirtyPage()

BOOLEAN NTAPI MmIsDirtyPage	(	IN PEPROCESS	Process,
		IN PVOID	Address
	)

Definition at line 558 of file stubs.c.

{
    //
    // TODO
    //
    UNIMPLEMENTED_DBGBREAK();
    return FALSE;
}

MmIsPagePresent()

BOOLEAN NTAPI MmIsPagePresent	(	IN PEPROCESS	Process,
		IN PVOID	Address
	)

Definition at line 592 of file stubs.c.

{
    //
    // Fault PTEs are 0, which is FALSE (non-present)
    //
    return MiGetPageEntryForProcess(Process, Address).u.Hard.Valid;
}

MmIsPageSwapEntry()

BOOLEAN NTAPI MmIsPageSwapEntry	(	IN PEPROCESS	Process,
		IN PVOID	Address
	)

Definition at line 603 of file stubs.c.

{
    MMPTE Pte;
 
    //
    // Get the PTE
    //
    Pte = MiGetPageEntryForProcess(Process, Address);
 
    //
    // Make sure it exists, but is faulting
    //
    return (Pte.u.Hard.Valid == 0) && (Pte.u.Hard.AsUlong);
}

MmSetCleanPage()

VOID NTAPI MmSetCleanPage	(	IN PEPROCESS	Process,
		IN PVOID	Address
	)

Definition at line 570 of file stubs.c.

{
    //
    // TODO
    //
    UNIMPLEMENTED_DBGBREAK();
}

MmSetDirtyPage()

VOID NTAPI MmSetDirtyPage	(	IN PEPROCESS	Process,
		IN PVOID	Address
	)

Definition at line 581 of file stubs.c.

{
    //
    // TODO
    //
    UNIMPLEMENTED_DBGBREAK();
}

MmSetPageProtect()

VOID NTAPI MmSetPageProtect	(	IN PEPROCESS	Process,
		IN PVOID	Address,
		IN ULONG	Protection
	)

Definition at line 632 of file stubs.c.

{
    //
    // We don't enforce any protection on the pages -- they are all RWX
    //
    return;
}

Variable Documentation

MiArmTemplatePde

MMPDE_HARDWARE MiArmTemplatePde

Definition at line 19 of file stubs.c.

Referenced by MiGetPageTableForProcess(), MmCreateProcessAddressSpace(), and MmInitGlobalKernelPageDirectory().

MiArmTemplatePte

MMPTE MiArmTemplatePte

Definition at line 18 of file stubs.c.

Referenced by MiGetPageTableForProcess(), MmCreateVirtualMappingInternal(), and MmInitGlobalKernelPageDirectory().

MmGlobalKernelPageDirectory

ULONG MmGlobalKernelPageDirectory[1024]

Definition at line 17 of file stubs.c.

Referenced by MmCreateProcessAddressSpace(), and MmInitGlobalKernelPageDirectory().