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)
static PMMPTE	MiGetPteForProcess (PEPROCESS Process, PVOID Address, BOOLEAN Create)
static ULONG64	MiGetPteValueForProcess (PEPROCESS Process, PVOID Address)
ULONG NTAPI	MiGetPteProtection (MMPTE Pte)
VOID NTAPI	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)
static PMMPTE	MmGetPageTableForProcess (PEPROCESS Process, PVOID Address, BOOLEAN Create)
BOOLEAN	MmUnmapPageTable (PMMPTE Pt)
static ULONG64	MmGetPageEntryForProcess (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
	)

Definition at line 128 of file page.c.

{
    if (MiIsHyperspaceAddress(Pte))
    {
        MmDeleteHyperspaceMapping((PVOID)PAGE_ROUND_DOWN(Pte));
    }
    else
    {
        __invlpg(Address);
    }
}

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

MiGetPteForProcess()

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

static

Definition at line 142 of file page.c.

{
    MMPTE TmplPte, *Pte;

    /* Check if we need hypersapce mapping */
    if (Address < MmSystemRangeStart &&
        Process && Process != PsGetCurrentProcess())
    {
        UNIMPLEMENTED;
        __debugbreak();
        return NULL;
    }
    else if (Create)
    {
        KIRQL OldIrql;
        TmplPte.u.Long = 0;
        TmplPte.u.Flush.Valid = 1;
        TmplPte.u.Flush.Write = 1;

        /* All page table levels of user pages are user owned */
        TmplPte.u.Flush.Owner = (Address < MmHighestUserAddress) ? 1 : 0;

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

        /* Get the PXE */
        Pte = MiAddressToPxe(Address);
        if (!Pte->u.Hard.Valid)
        {
            TmplPte.u.Hard.PageFrameNumber = MiRemoveZeroPage(0);
            MI_WRITE_VALID_PTE(Pte, TmplPte);
        }

        /* Get the PPE */
        Pte = MiAddressToPpe(Address);
        if (!Pte->u.Hard.Valid)
        {
            TmplPte.u.Hard.PageFrameNumber = MiRemoveZeroPage(1);
            MI_WRITE_VALID_PTE(Pte, TmplPte);
        }

        /* Get the PDE */
        Pte = MiAddressToPde(Address);
        if (!Pte->u.Hard.Valid)
        {
            TmplPte.u.Hard.PageFrameNumber = MiRemoveZeroPage(2);
            MI_WRITE_VALID_PTE(Pte, TmplPte);
        }

        /* Unlock PFN database */
        MiReleasePfnLock(OldIrql);
    }
    else
    {
        /* Get the PXE */
        Pte = MiAddressToPxe(Address);
        if (!Pte->u.Hard.Valid)
            return NULL;

        /* Get the PPE */
        Pte = MiAddressToPpe(Address);
        if (!Pte->u.Hard.Valid)
            return NULL;

        /* Get the PDE */
        Pte = MiAddressToPde(Address);
        if (!Pte->u.Hard.Valid)
            return NULL;
    }

    return MiAddressToPte(Address);
}

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

MiGetPteProtection()

ULONG NTAPI MiGetPteProtection

(

MMPTE

Pte

)

Definition at line 238 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 220 of file page.c.

{
    PMMPTE Pte;
    ULONG64 PteValue;

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

    if (MiIsHyperspaceAddress(Pte))
        MmDeleteHyperspaceMapping((PVOID)PAGE_ROUND_DOWN(Pte));

    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(), MmCreateVirtualMappingUnsafe(), MmSetCleanPage(), and MmSetDirtyPage().

MiSetPteProtection()

VOID NTAPI MiSetPteProtection	(	PMMPTE	Pte,
		ULONG	Protection
	)

Definition at line 277 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 503 of file page.c.

{
    UNIMPLEMENTED;
    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 592 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 568 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 514 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++)
    {
        TmplPte.u.Hard.PageFrameNumber = Pages[i];

        Pte = MiGetPteForProcess(Process, Address, TRUE);

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

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

        if (MiIsHyperspaceAddress(Pte))
            MmDeleteHyperspaceMapping((PVOID)PAGE_ROUND_DOWN(Pte));

        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 495 of file page.c.

{
    UNIMPLEMENTED;
}

MmDeleteVirtualMapping()

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

Definition at line 453 of file page.c.

{
    PFN_NUMBER Pfn;
    PMMPTE Pte;
    MMPTE OldPte;

    Pte = MiGetPteForProcess(Process, Address, FALSE);

    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);
}

MmGetPageEntryForProcess()

static ULONG64 MmGetPageEntryForProcess ( PEPROCESS  Process, PVOID  Address  )

static

Definition at line 343 of file page.c.

{
    MMPTE Pte, *PointerPte;

    PointerPte = MmGetPageTableForProcess(Process, Address, FALSE);
    if (PointerPte)
    {
        Pte = *PointerPte;
        MmUnmapPageTable(PointerPte);
        return Pte.u.Long;
    }
    return 0;
}

Referenced by MmGetPageFileMapping().

MmGetPageFileMapping()

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

Definition at line 359 of file page.c.

{
    ULONG64 Entry = MmGetPageEntryForProcess(Process, Address);
    *SwapEntry = Entry >> 1;
}

MmGetPageProtect()

ULONG NTAPI MmGetPageProtect	(	PEPROCESS	Process,
		PVOID	Address
	)

Definition at line 379 of file page.c.

{
    MMPTE Pte;

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

    return MiGetPteProtection(Pte);
}

MmGetPageTableForProcess()

static PMMPTE MmGetPageTableForProcess ( PEPROCESS  Process, PVOID  Address, BOOLEAN  Create  )

static

Definition at line 331 of file page.c.

{
    __debugbreak();
    return 0;
}

Referenced by MmGetPageEntryForProcess(), and MmSetPageProtect().

MmGetPfnForProcess()

PFN_NUMBER NTAPI MmGetPfnForProcess	(	PEPROCESS	Process,
		PVOID	Address
	)

Definition at line 292 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 370 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 311 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 302 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 323 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 409 of file page.c.

{
    PMMPTE Pte;

    Pte = MiGetPteForProcess(Process, Address, FALSE);
    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);
}

MmSetDirtyPage()

VOID NTAPI MmSetDirtyPage	(	PEPROCESS	Process,
		PVOID	Address
	)

Definition at line 431 of file page.c.

{
    PMMPTE Pte;

    Pte = MiGetPteForProcess(Process, Address, FALSE);
    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);
}

MmSetPageProtect()

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

Definition at line 390 of file page.c.

{
    PMMPTE Pte;
    MMPTE NewPte;

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

    NewPte = *Pte;

    MiSetPteProtection(&NewPte, flProtect);

    InterlockedExchangePte(Pte, NewPte);

    MiFlushTlb(Pte, Address);
}

MmUnmapPageTable()

BOOLEAN MmUnmapPageTable

(

PMMPTE

Pt

)

Definition at line 337 of file page.c.

{
    ASSERT(FALSE);
    return 0;
}

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

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().