page.c File Reference

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

Include dependency graph for page.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	InterlockedExchangePte(pte1, pte2)   InterlockedExchange64((LONG64*)&pte1->u.Long, pte2.u.Long)
#define	PAGE_EXECUTE_ANY   (PAGE_EXECUTE|PAGE_EXECUTE_READ|PAGE_EXECUTE_READWRITE|PAGE_EXECUTE_WRITECOPY)
#define	PAGE_WRITE_ANY   (PAGE_EXECUTE_READWRITE|PAGE_READWRITE|PAGE_EXECUTE_WRITECOPY|PAGE_WRITECOPY)
#define	PAGE_WRITECOPY_ANY   (PAGE_EXECUTE_WRITECOPY|PAGE_WRITECOPY)

Functions
BOOLEAN FORCEINLINE	MiIsHyperspaceAddress (PVOID Address)
VOID	MiFlushTlb (PMMPTE Pte, PVOID Address, KIRQL OldIrql)
static PMMPTE	MiGetPteForProcess (PEPROCESS Process, PVOID Address, BOOLEAN Create, PKIRQL OldIrql)
static ULONG64	MiGetPteValueForProcess (PEPROCESS Process, PVOID Address)
ULONG NTAPI	MiGetPteProtection (MMPTE Pte)
static VOID	MiSetPteProtection (PMMPTE Pte, ULONG Protection)
PFN_NUMBER NTAPI	MmGetPfnForProcess (PEPROCESS Process, PVOID Address)
BOOLEAN NTAPI	MmIsPagePresent (PEPROCESS Process, PVOID Address)
BOOLEAN NTAPI	MmIsDisabledPage (PEPROCESS Process, PVOID Address)
BOOLEAN NTAPI	MmIsPageSwapEntry (PEPROCESS Process, PVOID Address)
VOID NTAPI	MmGetPageFileMapping (PEPROCESS Process, PVOID Address, SWAPENTRY *SwapEntry)
BOOLEAN NTAPI	MmIsDirtyPage (PEPROCESS Process, PVOID Address)
ULONG NTAPI	MmGetPageProtect (PEPROCESS Process, PVOID Address)
VOID NTAPI	MmSetPageProtect (PEPROCESS Process, PVOID Address, ULONG flProtect)
VOID NTAPI	MmSetCleanPage (PEPROCESS Process, PVOID Address)
VOID NTAPI	MmSetDirtyPage (PEPROCESS Process, PVOID Address)
VOID NTAPI	MmDeleteVirtualMapping (PEPROCESS Process, PVOID Address, BOOLEAN *WasDirty, PPFN_NUMBER Page)
VOID NTAPI	MmDeletePageFileMapping (PEPROCESS Process, PVOID Address, SWAPENTRY *SwapEntry)
NTSTATUS NTAPI	MmCreatePageFileMapping (PEPROCESS Process, PVOID Address, SWAPENTRY SwapEntry)
NTSTATUS NTAPI	MmCreateVirtualMappingUnsafe (PEPROCESS Process, PVOID Address, ULONG PageProtection, PPFN_NUMBER Pages, ULONG PageCount)
NTSTATUS NTAPI	MmCreateVirtualMapping (PEPROCESS Process, PVOID Address, ULONG Protect, PPFN_NUMBER Pages, ULONG PageCount)
BOOLEAN NTAPI	MmCreateProcessAddressSpace (IN ULONG MinWs, IN PEPROCESS Process, OUT PULONG_PTR DirectoryTableBase)

Variables
MMPTE	HyperTemplatePte
const ULONG64	MmProtectToPteMask [32]
const ULONG	MmProtectToValue [32]

Macro Definition Documentation

InterlockedExchangePte

#define InterlockedExchangePte	(		pte1,
			pte2
	)		InterlockedExchange64((LONG64*)&pte1->u.Long, pte2.u.Long)

Definition at line 19 of file page.c.

NDEBUG

#define NDEBUG

Definition at line 14 of file page.c.

PAGE_EXECUTE_ANY

#define PAGE_EXECUTE_ANY   (PAGE_EXECUTE|PAGE_EXECUTE_READ|PAGE_EXECUTE_READWRITE|PAGE_EXECUTE_WRITECOPY)

Definition at line 22 of file page.c.

PAGE_WRITE_ANY

#define PAGE_WRITE_ANY   (PAGE_EXECUTE_READWRITE|PAGE_READWRITE|PAGE_EXECUTE_WRITECOPY|PAGE_WRITECOPY)

Definition at line 23 of file page.c.

PAGE_WRITECOPY_ANY

#define PAGE_WRITECOPY_ANY   (PAGE_EXECUTE_WRITECOPY|PAGE_WRITECOPY)

Definition at line 24 of file page.c.

Function Documentation

MiFlushTlb()

VOID MiFlushTlb	(	PMMPTE	Pte,
		PVOID	Address,
		KIRQL	OldIrql
	)

Definition at line 128 of file page.c.

{
    if (MiIsHyperspaceAddress(Pte))
    {
        MiUnmapPageInHyperSpace(PsGetCurrentProcess(), (PVOID)PAGE_ROUND_DOWN(Pte), OldIrql);
    }
    else
    {
        __invlpg(Address);
    }
}

Referenced by MmDeleteVirtualMapping(), MmSetCleanPage(), MmSetDirtyPage(), and MmSetPageProtect().

MiGetPteForProcess()

static PMMPTE MiGetPteForProcess ( PEPROCESS  Process, PVOID  Address, BOOLEAN  Create, PKIRQL  OldIrql  )

static

Definition at line 142 of file page.c.

{
    PMMPTE Pte;
    PMMPDE Pde;
    PMMPPE Ppe;
    PMMPXE Pxe;

    *OldIrql = 0;
    /* Make sure the process is correct */
    if (Address < MmSystemRangeStart)
    {
        /* FIXME: Implement this case */
        ASSERT(Process == PsGetCurrentProcess());
    }
    else
    {
        ASSERT((Process == NULL) || (Process == PsGetCurrentProcess()));
    }

    Pxe = MiAddressToPxe(Address);
    Ppe = MiAddressToPpe(Address);
    Pde = MiAddressToPde(Address);
    Pte = MiAddressToPte(Address);

    if (Create)
    {
        /* Check the PXE */
        if (Pxe->u.Long == 0)
        {
            /* Make it demand zero */
            MI_WRITE_INVALID_PDE(Pxe, DemandZeroPde);
        }

        /* Check the PPE */
        if (Ppe->u.Long == 0)
        {
            /* Make it demand zero */
            MI_WRITE_INVALID_PDE(Ppe, DemandZeroPde);
        }

        /* Check the PDE */
        if (Pde->u.Long == 0)
        {
            /* Make it demand zero */
            MI_WRITE_INVALID_PDE(Pde, DemandZeroPde);
        }
    }
    else
    {
        /* Check the PXE */
        if (!Pxe->u.Hard.Valid)
            return NULL;

        /* Check the PPE */
        if (!Ppe->u.Hard.Valid)
            return NULL;

        /* Check the PDE */
        if (!Pde->u.Hard.Valid)
            return NULL;
    }

    return Pte;
}

Referenced by MiGetPteValueForProcess(), MmCreatePageFileMapping(), MmCreateVirtualMappingUnsafe(), MmDeletePageFileMapping(), MmDeleteVirtualMapping(), MmSetCleanPage(), MmSetDirtyPage(), and MmSetPageProtect().

MiGetPteProtection()

ULONG NTAPI MiGetPteProtection

(

MMPTE

Pte

)

Definition at line 233 of file page.c.

{
    ULONG Protect;

    if (!Pte.u.Flush.Valid)
    {
        Protect = PAGE_NOACCESS;
    }
    else if (Pte.u.Flush.NoExecute)
    {
        if (Pte.u.Flush.CopyOnWrite)
            Protect = PAGE_WRITECOPY;
        else if (Pte.u.Flush.Write)
            Protect = PAGE_READWRITE;
        else
            Protect = PAGE_READONLY;
    }
    else
    {
        if (Pte.u.Flush.CopyOnWrite)
            Protect = PAGE_EXECUTE_WRITECOPY;
        else if (Pte.u.Flush.Write)
            Protect = PAGE_EXECUTE_READWRITE;
        else
            Protect = PAGE_EXECUTE_READ;
    }

    if (Pte.u.Flush.CacheDisable)
        Protect |= PAGE_NOCACHE;

    if (Pte.u.Flush.WriteThrough)
        Protect |= PAGE_WRITETHROUGH;

    // PAGE_GUARD ?
    return Protect;
}

Referenced by MmGetPageProtect().

MiGetPteValueForProcess()

static ULONG64 MiGetPteValueForProcess ( PEPROCESS  Process, PVOID  Address  )

static

Definition at line 214 of file page.c.

{
    PMMPTE Pte;
    ULONG64 PteValue;
    KIRQL OldIrql;

    Pte = MiGetPteForProcess(Process, Address, FALSE, &OldIrql);
    PteValue = Pte ? Pte->u.Long : 0;

    if (MiIsHyperspaceAddress(Pte))
        MiUnmapPageInHyperSpace(PsGetCurrentProcess(), (PVOID)PAGE_ROUND_DOWN(Pte), OldIrql);

    return PteValue;
}

Referenced by MmGetPageProtect(), MmGetPfnForProcess(), MmIsDirtyPage(), MmIsDisabledPage(), MmIsPagePresent(), and MmIsPageSwapEntry().

MiIsHyperspaceAddress()

BOOLEAN FORCEINLINE MiIsHyperspaceAddress

(

PVOID

Address

)

Definition at line 121 of file page.c.

{
    return ((ULONG64)Address >= HYPER_SPACE &&
            (ULONG64)Address <= HYPER_SPACE_END);
}

Referenced by MiFlushTlb(), MiGetPteValueForProcess(), MmCreatePageFileMapping(), MmCreateVirtualMappingUnsafe(), MmDeletePageFileMapping(), MmSetCleanPage(), and MmSetDirtyPage().

MiSetPteProtection()

static VOID MiSetPteProtection ( PMMPTE  Pte, ULONG  Protection  )

static

Definition at line 272 of file page.c.

{
    Pte->u.Flush.CopyOnWrite = (Protection & PAGE_WRITECOPY_ANY) ? 1 : 0;
    Pte->u.Flush.Write = (Protection & PAGE_WRITE_ANY) ? 1 : 0;
    Pte->u.Flush.CacheDisable = (Protection & PAGE_NOCACHE) ? 1 : 0;
    Pte->u.Flush.WriteThrough = (Protection & PAGE_WRITETHROUGH) ? 1 : 0;

    // FIXME: This doesn't work. Why?
    Pte->u.Flush.NoExecute = (Protection & PAGE_EXECUTE_ANY) ? 0 : 1;
}

Referenced by MmCreateVirtualMappingUnsafe(), and MmSetPageProtect().

MmCreatePageFileMapping()

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

Definition at line 499 of file page.c.

{
    PMMPTE Pte;
    MMPTE PteValue;
    KIRQL OldIrql;

    if (Process == NULL && Address < MmSystemRangeStart)
    {
        DPRINT1("No process\n");
        KeBugCheck(MEMORY_MANAGEMENT);
    }
    if (Process != NULL && Address >= MmSystemRangeStart)
    {
        DPRINT1("Setting kernel address with process context\n");
        KeBugCheck(MEMORY_MANAGEMENT);
    }

    if (SwapEntry & (1ull << 63))
    {
        KeBugCheck(MEMORY_MANAGEMENT);
    }

    /* Allocate a PTE */
    Pte = MiGetPteForProcess(Process, Address, TRUE, &OldIrql);
    if (Pte == NULL)
    {
        return STATUS_UNSUCCESSFUL;
    }

    NT_ASSERT(Pte->u.Long == 0);
    PteValue.u.Long = SwapEntry << 1;
    MI_WRITE_INVALID_PTE(Pte, PteValue);

    if (MiIsHyperspaceAddress(Pte))
        MiUnmapPageInHyperSpace(PsGetCurrentProcess(), (PVOID)PAGE_ROUND_DOWN(Pte), OldIrql);

    return STATUS_UNSUCCESSFUL;
}

MmCreateProcessAddressSpace()

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

architecture specific

end architecture specific

Definition at line 623 of file page.c.

{
    KIRQL OldIrql;
    PFN_NUMBER TableBasePfn, HyperPfn, HyperPdPfn, HyperPtPfn, WorkingSetPfn;
    PMMPTE SystemPte;
    MMPTE TempPte, PdePte;
    ULONG TableIndex;
    PMMPTE PageTablePointer;

    /* Make sure we don't already have a page directory setup */
    ASSERT(Process->Pcb.DirectoryTableBase[0] == 0);
    ASSERT(Process->Pcb.DirectoryTableBase[1] == 0);
    ASSERT(Process->WorkingSetPage == 0);

    /* Choose a process color */
    Process->NextPageColor = (USHORT)RtlRandom(&MmProcessColorSeed);

    /* Setup the hyperspace lock */
    KeInitializeSpinLock(&Process->HyperSpaceLock);

    /* Lock PFN database */
    OldIrql = MiAcquirePfnLock();

    /* Get a page for the table base and one for hyper space. The PFNs for
       these pages will be initialized in MmInitializeProcessAddressSpace,
       when we are already attached to the process. */
    TableBasePfn = MiRemoveAnyPage(MI_GET_NEXT_PROCESS_COLOR(Process));
    HyperPfn = MiRemoveAnyPage(MI_GET_NEXT_PROCESS_COLOR(Process));
    HyperPdPfn = MiRemoveAnyPage(MI_GET_NEXT_PROCESS_COLOR(Process));
    HyperPtPfn = MiRemoveAnyPage(MI_GET_NEXT_PROCESS_COLOR(Process));
    WorkingSetPfn = MiRemoveAnyPage(MI_GET_NEXT_PROCESS_COLOR(Process));

    /* Release PFN lock */
    MiReleasePfnLock(OldIrql);

    /* Zero pages */
    MiZeroPhysicalPage(TableBasePfn);
    MiZeroPhysicalPage(HyperPfn);
    MiZeroPhysicalPage(HyperPdPfn);
    MiZeroPhysicalPage(HyperPtPfn);
    MiZeroPhysicalPage(WorkingSetPfn);

    /* Set the base directory pointers */
    Process->WorkingSetPage = WorkingSetPfn;
    DirectoryTableBase[0] = TableBasePfn << PAGE_SHIFT;
    DirectoryTableBase[1] = HyperPfn << PAGE_SHIFT;

    /* Get a PTE to map the page directory */
    SystemPte = MiReserveSystemPtes(1, SystemPteSpace);
    ASSERT(SystemPte != NULL);

    /* Get its address */
    PageTablePointer = MiPteToAddress(SystemPte);

    /* Build the PTE for the page directory and map it */
    PdePte = ValidKernelPte;
    PdePte.u.Hard.PageFrameNumber = TableBasePfn;
    *SystemPte = PdePte;

    //MiInitializePageDirectoryForProcess(

    /* Copy the kernel mappings and zero out the rest */
    TableIndex = PXE_PER_PAGE / 2;
    RtlZeroMemory(PageTablePointer, TableIndex * sizeof(MMPTE));
    RtlCopyMemory(PageTablePointer + TableIndex,
                  MiAddressToPxe(0) + TableIndex,
                  PAGE_SIZE - TableIndex * sizeof(MMPTE));

    /* Sanity check */
    ASSERT(MiAddressToPxi(MmHyperSpaceEnd) >= TableIndex);

    /* Setup a PTE for the page directory mappings */
    TempPte = ValidKernelPte;

    /* Update the self mapping of the PML4 */
    TableIndex = MiAddressToPxi((PVOID)PXE_SELFMAP);
    TempPte.u.Hard.PageFrameNumber = TableBasePfn;
    PageTablePointer[TableIndex] = TempPte;

    /* Write the PML4 entry for hyperspace */
    TableIndex = MiAddressToPxi((PVOID)HYPER_SPACE);
    TempPte.u.Hard.PageFrameNumber = HyperPfn;
    PageTablePointer[TableIndex] = TempPte;

    /* Map the hyperspace PDPT to the system PTE */
    PdePte.u.Hard.PageFrameNumber = HyperPfn;
    *SystemPte = PdePte;
    __invlpg(PageTablePointer);

    /* Write the hyperspace entry for the first PD */
    TempPte.u.Hard.PageFrameNumber = HyperPdPfn;
    PageTablePointer[0] = TempPte;

    /* Map the hyperspace PD to the system PTE */
    PdePte.u.Hard.PageFrameNumber = HyperPdPfn;
    *SystemPte = PdePte;
    __invlpg(PageTablePointer);

    /* Write the hyperspace entry for the first PT */
    TempPte.u.Hard.PageFrameNumber = HyperPtPfn;
    PageTablePointer[0] = TempPte;

    /* Map the hyperspace PT to the system PTE */
    PdePte.u.Hard.PageFrameNumber = HyperPtPfn;
    *SystemPte = PdePte;
    __invlpg(PageTablePointer);

    /* Write the hyperspace PTE for the working set list index */
    TempPte.u.Hard.PageFrameNumber = WorkingSetPfn;
    TableIndex = MiAddressToPti(MmWorkingSetList);
    PageTablePointer[TableIndex] = TempPte;


    /* Release the system PTE */
    MiReleaseSystemPtes(SystemPte, 1, SystemPteSpace);

    /* Switch to phase 1 initialization */
    ASSERT(Process->AddressSpaceInitialized == 0);
    Process->AddressSpaceInitialized = 1;

    /* Add the process to the session */
    MiSessionAddProcess(Process);
    return TRUE;
}

MmCreateVirtualMapping()

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

Definition at line 599 of file page.c.

{
    ULONG i;

    ASSERT((ULONG_PTR)Address % PAGE_SIZE == 0);

    for (i = 0; i < PageCount; i++)
    {
        if (!MmIsPageInUse(Pages[i]))
        {
            DPRINT1("Page %x not in use\n", Pages[i]);
            KeBugCheck(MEMORY_MANAGEMENT);
        }
    }

    return MmCreateVirtualMappingUnsafe(Process, Address, Protect, Pages, PageCount);
}

MmCreateVirtualMappingUnsafe()

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

Definition at line 543 of file page.c.

{
    ULONG i;
    MMPTE TmplPte, *Pte;

    ASSERT((ULONG_PTR)Address % PAGE_SIZE == 0);

    /* Check if the range is valid */
    if ((Process == NULL && Address < MmSystemRangeStart) ||
        (Process != NULL && Address > MmHighestUserAddress))
    {
        DPRINT1("Address 0x%p is invalid for process %p\n", Address, Process);
        ASSERT(FALSE);
    }

    TmplPte.u.Long = 0;
    TmplPte.u.Hard.Valid = 1;
    MiSetPteProtection(&TmplPte, PageProtection);

    TmplPte.u.Flush.Owner = (Address < MmHighestUserAddress) ? 1 : 0;

//__debugbreak();

    for (i = 0; i < PageCount; i++)
    {
        KIRQL OldIrql;

        TmplPte.u.Hard.PageFrameNumber = Pages[i];

        Pte = MiGetPteForProcess(Process, Address, TRUE, &OldIrql);

DPRINT("MmCreateVirtualMappingUnsafe, Address=%p, TmplPte=%p, Pte=%p\n",
        Address, TmplPte.u.Long, Pte);

        if (InterlockedExchangePte(Pte, TmplPte))
        {
            KeInvalidateTlbEntry(Address);
        }

        if (MiIsHyperspaceAddress(Pte))
            MiUnmapPageInHyperSpace(PsGetCurrentProcess(), (PVOID)PAGE_ROUND_DOWN(Pte), OldIrql);

        Address = (PVOID)((ULONG64)Address + PAGE_SIZE);
    }


    return STATUS_SUCCESS;
}

Referenced by MmCreateVirtualMapping().

MmDeletePageFileMapping()

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

Definition at line 471 of file page.c.

{
    PMMPTE Pte;
    KIRQL OldIrql;

    Pte = MiGetPteForProcess(Process, Address, FALSE, &OldIrql);
    if (Pte == NULL)
    {
        *SwapEntry = 0;
        return;
    }

    if (Pte->u.Trans.Valid || !Pte->u.Trans.Transition)
    {
        DPRINT1("Pte %x (want not 1 and 0x800)\n", Pte);
        KeBugCheck(MEMORY_MANAGEMENT);
    }

    *SwapEntry = Pte->u.Long >> 1;
    MI_ERASE_PTE(Pte);

    if (MiIsHyperspaceAddress(Pte))
        MiUnmapPageInHyperSpace(PsGetCurrentProcess(), (PVOID)PAGE_ROUND_DOWN(Pte), OldIrql);
}

MmDeleteVirtualMapping()

VOID NTAPI MmDeleteVirtualMapping	(	PEPROCESS	Process,
		PVOID	Address,
		BOOLEAN *	WasDirty,
		PPFN_NUMBER	Page
	)

Definition at line 428 of file page.c.

{
    PFN_NUMBER Pfn;
    PMMPTE Pte;
    MMPTE OldPte;
    KIRQL OldIrql;

    Pte = MiGetPteForProcess(Process, Address, FALSE, &OldIrql);

    if (Pte)
    {
        /* Atomically set the entry to zero and get the old value. */
        OldPte.u.Long = InterlockedExchange64((LONG64*)&Pte->u.Long, 0);

        if (OldPte.u.Hard.Valid)
        {
            Pfn = OldPte.u.Hard.PageFrameNumber;
        }
        else
            Pfn = 0;
    }
    else
    {
        OldPte.u.Long = 0;
        Pfn = 0;
    }

    /* Return information to the caller */
    if (WasDirty)
        *WasDirty = (BOOLEAN)OldPte.u.Hard.Dirty;

    if (Page)
        *Page = Pfn;

    MiFlushTlb(Pte, Address, OldIrql);
}

MmGetPageFileMapping()

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

Definition at line 327 of file page.c.

{
    PMMPTE PointerPte;

    ASSERT(Process == PsGetCurrentProcess());

    PointerPte = MiAddressToPte(Address);
    *SwapEntry = PointerPte->u.Long >> 1;
}

MmGetPageProtect()

ULONG NTAPI MmGetPageProtect	(	PEPROCESS	Process,
		PVOID	Address
	)

Definition at line 351 of file page.c.

{
    MMPTE Pte;

    Pte.u.Long = MiGetPteValueForProcess(Process, Address);

    return MiGetPteProtection(Pte);
}

MmGetPfnForProcess()

PFN_NUMBER NTAPI MmGetPfnForProcess	(	PEPROCESS	Process,
		PVOID	Address
	)

Definition at line 287 of file page.c.

{
    MMPTE Pte;
    Pte.u.Long = MiGetPteValueForProcess(Process, Address);
    return Pte.u.Hard.Valid ? Pte.u.Hard.PageFrameNumber : 0;
}

MmIsDirtyPage()

BOOLEAN NTAPI MmIsDirtyPage	(	PEPROCESS	Process,
		PVOID	Address
	)

Definition at line 342 of file page.c.

{
    MMPTE Pte;
    Pte.u.Long = MiGetPteValueForProcess(Process, Address);
    return Pte.u.Hard.Valid && Pte.u.Hard.Dirty;
}

MmIsDisabledPage()

BOOLEAN NTAPI MmIsDisabledPage	(	PEPROCESS	Process,
		PVOID	Address
	)

Definition at line 306 of file page.c.

{
    MMPTE Pte;
    Pte.u.Long = MiGetPteValueForProcess(Process, Address);

    return (Pte.u.Hard.Valid == 0) &&
           (Pte.u.Trans.Transition == 0) &&
           (Pte.u.Hard.PageFrameNumber != 0);
}

MmIsPagePresent()

BOOLEAN NTAPI MmIsPagePresent	(	PEPROCESS	Process,
		PVOID	Address
	)

Definition at line 297 of file page.c.

{
    MMPTE Pte;
    Pte.u.Long = MiGetPteValueForProcess(Process, Address);
    return (BOOLEAN)Pte.u.Hard.Valid;
}

MmIsPageSwapEntry()

BOOLEAN NTAPI MmIsPageSwapEntry	(	PEPROCESS	Process,
		PVOID	Address
	)

Definition at line 318 of file page.c.

{
    MMPTE Pte;
    Pte.u.Long = MiGetPteValueForProcess(Process, Address);
    return !Pte.u.Hard.Valid && Pte.u.Soft.Transition;
}

MmSetCleanPage()

VOID NTAPI MmSetCleanPage	(	PEPROCESS	Process,
		PVOID	Address
	)

Definition at line 382 of file page.c.

{
    PMMPTE Pte;
    KIRQL OldIrql;

    Pte = MiGetPteForProcess(Process, Address, FALSE, &OldIrql);
    if (!Pte)
    {
        KeBugCheckEx(MEMORY_MANAGEMENT, 0x1234, (ULONG64)Address, 0, 0);
    }

    /* Ckear the dirty bit */
    if (InterlockedBitTestAndReset64((PVOID)Pte, 6))
    {
        if (!MiIsHyperspaceAddress(Pte))
            __invlpg(Address);
    }

    MiFlushTlb(Pte, Address, OldIrql);
}

MmSetDirtyPage()

VOID NTAPI MmSetDirtyPage	(	PEPROCESS	Process,
		PVOID	Address
	)

Definition at line 405 of file page.c.

{
    PMMPTE Pte;
    KIRQL OldIrql;

    Pte = MiGetPteForProcess(Process, Address, FALSE, &OldIrql);
    if (!Pte)
    {
        KeBugCheckEx(MEMORY_MANAGEMENT, 0x1234, (ULONG64)Address, 0, 0);
    }

    /* Ckear the dirty bit */
    if (InterlockedBitTestAndSet64((PVOID)Pte, 6))
    {
        if (!MiIsHyperspaceAddress(Pte))
            __invlpg(Address);
    }

    MiFlushTlb(Pte, Address, OldIrql);
}

MmSetPageProtect()

VOID NTAPI MmSetPageProtect	(	PEPROCESS	Process,
		PVOID	Address,
		ULONG	flProtect
	)

Definition at line 362 of file page.c.

{
    PMMPTE Pte;
    MMPTE NewPte;
    KIRQL OldIrql;

    Pte = MiGetPteForProcess(Process, Address, FALSE, &OldIrql);
    ASSERT(Pte != NULL);

    NewPte = *Pte;

    MiSetPteProtection(&NewPte, flProtect);

    InterlockedExchangePte(Pte, NewPte);

    MiFlushTlb(Pte, Address, OldIrql);
}

Variable Documentation

HyperTemplatePte

MMPTE HyperTemplatePte

Definition at line 22 of file hypermap.c.

Referenced by MiInitializePageTable().

MmProtectToPteMask

const ULONG64 MmProtectToPteMask[32]

Definition at line 32 of file page.c.

Referenced by MiDispatchFault(), and MiResolveTransitionFault().

MmProtectToValue

const ULONG MmProtectToValue[32]

Definition at line 81 of file page.c.

Referenced by MiGetPageProtection(), MiProtectVirtualMemory(), MiQueryAddressState(), MiQueryMemoryBasicInformation(), and MiSetProtectionOnSection().