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

Functions
NTSTATUS NTAPI	MiFillSystemPageDirectory (IN PVOID Base, IN SIZE_T NumberOfBytes)
static BOOLEAN	MiIsPageTablePresent (PVOID Address)
PFN_NUMBER NTAPI	MmGetPfnForProcess (PEPROCESS Process, PVOID Address)
	_Success_ (return)
	Deletes the virtual mapping and optionally gives back the page & dirty bit.
VOID NTAPI	MmDeletePageFileMapping (PEPROCESS Process, PVOID Address, SWAPENTRY *SwapEntry)
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)
NTSTATUS NTAPI	MmCreatePageFileMapping (PEPROCESS Process, PVOID Address, SWAPENTRY SwapEntry)
NTSTATUS NTAPI	MmCreateVirtualMappingUnsafeEx (_Inout_opt_ PEPROCESS Process, _In_ PVOID Address, _In_ ULONG flProtect, _In_ PFN_NUMBER Page, _In_ BOOLEAN IsPhysical)
NTSTATUS NTAPI	MmCreateVirtualMappingUnsafe (_Inout_opt_ PEPROCESS Process, _In_ PVOID Address, _In_ ULONG flProtect, _In_ PFN_NUMBER Page)
NTSTATUS NTAPI	MmCreatePhysicalMapping (_Inout_opt_ PEPROCESS Process, _In_ PVOID Address, _In_ ULONG flProtect, _In_ PFN_NUMBER Page)
NTSTATUS NTAPI	MmCreateVirtualMapping (PEPROCESS Process, PVOID Address, ULONG flProtect, PFN_NUMBER Page)
ULONG NTAPI	MmGetPageProtect (PEPROCESS Process, PVOID Address)
VOID NTAPI	MmSetPageProtect (PEPROCESS Process, PVOID Address, ULONG flProtect)
VOID NTAPI	MmSetDirtyBit (PEPROCESS Process, PVOID Address, BOOLEAN Bit)
VOID NTAPI	MmInitGlobalKernelPageDirectory (VOID)

Variables
const ULONG_PTR	MmProtectToPteMask [32]
const ULONG	MmProtectToValue [32]

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 13 of file page.c.

Function Documentation

_Success_()

_Success_

(

return

)

Deletes the virtual mapping and optionally gives back the page & dirty bit.

Parameters

Process	- The process this address belongs to, or NULL if system address.
Address	- The address to unmap.
WasDirty	- Optional param receiving the dirty bit of the PTE.
Page	- Optional param receiving the page number previously mapped to this address.

Returns

Whether there was actually a page mapped at the given address.

Definition at line 235 of file page.c.

{
    PMMPTE PointerPte;
    MMPTE OldPte;
    BOOLEAN ValidPde;
 
    OldPte.u.Long = 0;
 
    DPRINT("MmDeleteVirtualMapping(%p, %p, %p, %p)\n", Process, Address, WasDirty, Page);
 
    ASSERT(((ULONG_PTR)Address % PAGE_SIZE) == 0);
 
    /* And we should be at low IRQL */
    ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
 
    /* Make sure our PDE is valid, and that everything is going fine */
    if (Process == NULL)
    {
        if (Address < MmSystemRangeStart)
        {
            DPRINT1("NULL process given for user-mode mapping at %p\n", Address);
            KeBugCheck(MEMORY_MANAGEMENT);
        }
#if (_MI_PAGING_LEVELS == 2)
        ValidPde = MiSynchronizeSystemPde(MiAddressToPde(Address));
#else
        ValidPde = MiIsPdeForAddressValid(Address);
#endif
    }
    else
    {
        if ((Address >= MmSystemRangeStart) || Add2Ptr(Address, PAGE_SIZE) >= MmSystemRangeStart)
        {
            DPRINT1("Process %p given for kernel-mode mapping at %p\n", Process, Address);
            KeBugCheck(MEMORY_MANAGEMENT);
        }
 
        /* Only for current process !!! */
        ASSERT(Process == PsGetCurrentProcess());
        MiLockProcessWorkingSetUnsafe(Process, PsGetCurrentThread());
 
        ValidPde = MiIsPageTablePresent(Address);
        if (ValidPde)
        {
            MiMakePdeExistAndMakeValid(MiAddressToPde(Address), Process, MM_NOIRQL);
        }
    }
 
    /* Get the PTE if we're having anything */
    if (ValidPde)
    {
        PointerPte = MiAddressToPte(Address);
        OldPte.u.Long = InterlockedExchangePte(PointerPte, 0);
 
        KeInvalidateTlbEntry(Address);
 
        if (OldPte.u.Long != 0)
        {
            /* It must have been present, or not a swap entry */
            ASSERT(OldPte.u.Hard.Valid || !FlagOn(OldPte.u.Long, 0x800));
            if (WasDirty != NULL)
            {
                *WasDirty = !!OldPte.u.Hard.Dirty;
            }
            if (Page != NULL)
            {
                *Page = OldPte.u.Hard.PageFrameNumber;
            }
        }
    }
 
    if (Process != NULL)
    {
        /* Remove PDE reference, if needed */
        if (OldPte.u.Long != 0)
        {
            if (MiDecrementPageTableReferences(Address) == 0)
            {
                KIRQL OldIrql = MiAcquirePfnLock();
                MiDeletePde(MiAddressToPde(Address), Process);
                MiReleasePfnLock(OldIrql);
            }
        }
 
        if (!IsPhysical && OldPte.u.Hard.Valid)
        {
            PMMPFN Pfn1;
            KIRQL OldIrql;
 
            OldIrql = MiAcquirePfnLock();
            Pfn1 = &MmPfnDatabase[OldPte.u.Hard.PageFrameNumber];
            ASSERT(Pfn1->u3.e1.PageLocation == ActiveAndValid);
            ASSERT(Pfn1->u2.ShareCount > 0);
            if (--Pfn1->u2.ShareCount == 0)
            {
                Pfn1->u3.e1.PageLocation = TransitionPage;
            }
            MiReleasePfnLock(OldIrql);
        }
 
        MiUnlockProcessWorkingSetUnsafe(Process, PsGetCurrentThread());
    }
 
    return OldPte.u.Long != 0;
}

MiFillSystemPageDirectory()

NTSTATUS NTAPI MiFillSystemPageDirectory	(	IN PVOID	Base,
		IN SIZE_T	NumberOfBytes
	)

Definition at line 462 of file section.c.

{
    PMMPDE PointerPde, LastPde, SystemMapPde;
    MMPDE TempPde;
    PFN_NUMBER PageFrameIndex, ParentPage;
    KIRQL OldIrql;
    PAGED_CODE();
 
    /* Find the PDEs needed for this mapping */
    PointerPde = MiAddressToPde(Base);
    LastPde = MiAddressToPde((PVOID)((ULONG_PTR)Base + NumberOfBytes - 1));
 
#if (_MI_PAGING_LEVELS == 2)
    /* Find the system double-mapped PDE that describes this mapping */
    SystemMapPde = &MmSystemPagePtes[((ULONG_PTR)PointerPde & (SYSTEM_PD_SIZE - 1)) / sizeof(MMPTE)];
#else
    /* We don't have a double mapping */
    SystemMapPde = PointerPde;
#endif
 
    /* Use the PDE template and loop the PDEs */
    TempPde = ValidKernelPde;
    while (PointerPde <= LastPde)
    {
        /* Lock the PFN database */
        OldIrql = MiAcquirePfnLock();
 
        /* Check if we don't already have this PDE mapped */
        if (SystemMapPde->u.Hard.Valid == 0)
        {
            /* Grab a page for it */
            MI_SET_USAGE(MI_USAGE_PAGE_TABLE);
            MI_SET_PROCESS2(PsGetCurrentProcess()->ImageFileName);
            PageFrameIndex = MiRemoveZeroPage(MI_GET_NEXT_COLOR());
            ASSERT(PageFrameIndex);
            TempPde.u.Hard.PageFrameNumber = PageFrameIndex;
 
#if (_MI_PAGING_LEVELS == 2)
            ParentPage = MmSystemPageDirectory[(PointerPde - MiAddressToPde(NULL)) / PDE_PER_PAGE];
#else
            ParentPage = MiPdeToPpe(PointerPde)->u.Hard.PageFrameNumber;
#endif
            /* Initialize its PFN entry, with the parent system page directory page table */
            MiInitializePfnForOtherProcess(PageFrameIndex,
                                           (PMMPTE)PointerPde,
                                           ParentPage);
 
            /* Make the system PDE entry valid */
            MI_WRITE_VALID_PDE(SystemMapPde, TempPde);
 
            /* The system PDE entry might be the PDE itself, so check for this */
            if (PointerPde->u.Hard.Valid == 0)
            {
                /* It's different, so make the real PDE valid too */
                MI_WRITE_VALID_PDE(PointerPde, TempPde);
            }
        }
 
        /* Release the lock and keep going with the next PDE */
        MiReleasePfnLock(OldIrql);
        SystemMapPde++;
        PointerPde++;
    }
}

Referenced by MiMapViewInSystemSpace(), and MmCreateVirtualMappingUnsafeEx().

MiIsPageTablePresent()

static BOOLEAN MiIsPageTablePresent ( PVOID  Address )

static

Definition at line 119 of file page.c.

{
#if _MI_PAGING_LEVELS == 2
    BOOLEAN Ret = MmWorkingSetList->UsedPageTableEntries[MiGetPdeOffset(Address)] != 0;
 
    /* Some sanity check while we're here */
    ASSERT(Ret == (MiAddressToPde(Address)->u.Hard.Valid != 0));
 
    return Ret;
#else
    PMMPDE PointerPde;
    PMMPPE PointerPpe;
#if _MI_PAGING_LEVELS == 4
    PMMPXE PointerPxe;
#endif
    PMMPFN Pfn;
 
    /* Make sure we're locked */
    ASSERT((PsGetCurrentThread()->OwnsProcessWorkingSetExclusive) || (PsGetCurrentThread()->OwnsProcessWorkingSetShared));
 
    /* Must not hold the PFN lock! */
    ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
 
        /* Check if PXE or PPE have references first. */
#if _MI_PAGING_LEVELS == 4
    PointerPxe = MiAddressToPxe(Address);
    if ((PointerPxe->u.Hard.Valid == 1) || (PointerPxe->u.Soft.Transition == 1))
    {
        Pfn = MiGetPfnEntry(PFN_FROM_PXE(PointerPxe));
        if (Pfn->OriginalPte.u.Soft.UsedPageTableEntries == 0)
            return FALSE;
    }
    else if (PointerPxe->u.Soft.UsedPageTableEntries == 0)
    {
        return FALSE;
    }
 
    if (PointerPxe->u.Hard.Valid == 0)
    {
        MiMakeSystemAddressValid(MiPteToAddress(PointerPxe), PsGetCurrentProcess());
    }
#endif
 
    PointerPpe = MiAddressToPpe(Address);
    if ((PointerPpe->u.Hard.Valid == 1) || (PointerPpe->u.Soft.Transition == 1))
    {
        Pfn = MiGetPfnEntry(PFN_FROM_PPE(PointerPpe));
        if (Pfn->OriginalPte.u.Soft.UsedPageTableEntries == 0)
            return FALSE;
    }
    else if (PointerPpe->u.Soft.UsedPageTableEntries == 0)
    {
        return FALSE;
    }
 
    if (PointerPpe->u.Hard.Valid == 0)
    {
        MiMakeSystemAddressValid(MiPteToAddress(PointerPpe), PsGetCurrentProcess());
    }
 
    PointerPde = MiAddressToPde(Address);
    if ((PointerPde->u.Hard.Valid == 0) && (PointerPde->u.Soft.Transition == 0))
    {
        return PointerPde->u.Soft.UsedPageTableEntries != 0;
    }
 
    /* This lies on the PFN */
    Pfn = MiGetPfnEntry(PFN_FROM_PDE(PointerPde));
    return Pfn->OriginalPte.u.Soft.UsedPageTableEntries != 0;
#endif
}

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

MmCreatePageFileMapping()

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

Definition at line 587 of file page.c.

{
    PMMPTE PointerPte;
    ULONG_PTR Pte;
 
    /* This should not be called for kernel space anymore */
    ASSERT(Process != NULL);
    ASSERT(Address < MmSystemRangeStart);
 
    /* And we don't support creating for other process */
    ASSERT(Process == PsGetCurrentProcess());
 
    if (SwapEntry & ((ULONG_PTR)1 << (RTL_BITS_OF(SWAPENTRY) - 1)))
    {
        KeBugCheck(MEMORY_MANAGEMENT);
    }
 
    /* We are tinkering with the PDE here. Ensure it will be there */
    ASSERT(Process == PsGetCurrentProcess());
    MiLockProcessWorkingSetUnsafe(Process, PsGetCurrentThread());
 
    MiMakePdeExistAndMakeValid(MiAddressToPde(Address), Process, MM_NOIRQL);
 
    PointerPte = MiAddressToPte(Address);
    Pte = InterlockedExchangePte(PointerPte, SwapEntry << 1);
    if (Pte != 0)
    {
        KeBugCheckEx(MEMORY_MANAGEMENT, SwapEntry, (ULONG_PTR)Process, (ULONG_PTR)Address, 0);
    }
 
    /* This used to be a 0 PTE, now we need a valid PDE to keep it around */
    MiIncrementPageTableReferences(Address);
    MiUnlockProcessWorkingSetUnsafe(Process, PsGetCurrentThread());
 
    return STATUS_SUCCESS;
}

MmCreatePhysicalMapping()

NTSTATUS NTAPI MmCreatePhysicalMapping	(	_Inout_opt_ PEPROCESS	Process,
		_In_ PVOID	Address,
		_In_ ULONG	flProtect,
		_In_ PFN_NUMBER	Page
	)

Definition at line 735 of file page.c.

{
    return MmCreateVirtualMappingUnsafeEx(Process, Address, flProtect, Page, TRUE);
}

Referenced by MmNotPresentFaultSectionView().

MmCreateVirtualMapping()

NTSTATUS NTAPI MmCreateVirtualMapping	(	PEPROCESS	Process,
		PVOID	Address,
		ULONG	flProtect,
		PFN_NUMBER	Page
	)

Definition at line 746 of file page.c.

{
    ASSERT((ULONG_PTR)Address % PAGE_SIZE == 0);
    if (!MmIsPageInUse(Page))
    {
        DPRINT1("Page %lx is not in use\n", Page);
        KeBugCheck(MEMORY_MANAGEMENT);
    }
 
    return MmCreateVirtualMappingUnsafe(Process, Address, flProtect, Page);
}

MmCreateVirtualMappingUnsafe()

NTSTATUS NTAPI MmCreateVirtualMappingUnsafe	(	_Inout_opt_ PEPROCESS	Process,
		_In_ PVOID	Address,
		_In_ ULONG	flProtect,
		_In_ PFN_NUMBER	Page
	)

Definition at line 724 of file page.c.

{
    return MmCreateVirtualMappingUnsafeEx(Process, Address, flProtect, Page, FALSE);
}

MmCreateVirtualMappingUnsafeEx()

NTSTATUS NTAPI MmCreateVirtualMappingUnsafeEx	(	_Inout_opt_ PEPROCESS	Process,
		_In_ PVOID	Address,
		_In_ ULONG	flProtect,
		_In_ PFN_NUMBER	Page,
		_In_ BOOLEAN	IsPhysical
	)

Definition at line 629 of file page.c.

{
    ULONG ProtectionMask;
    PMMPTE PointerPte;
    MMPTE TempPte;
    ULONG_PTR Pte;
 
    DPRINT("MmCreateVirtualMappingUnsafe(%p, %p, %lu, %x)\n",
           Process, Address, flProtect, Page);
 
    ASSERT(((ULONG_PTR)Address % PAGE_SIZE) == 0);
 
    ProtectionMask = MiMakeProtectionMask(flProtect);
    /* Caller must have checked ! */
    ASSERT(ProtectionMask != MM_INVALID_PROTECTION);
    ASSERT(ProtectionMask != MM_NOACCESS);
    ASSERT(ProtectionMask != MM_ZERO_ACCESS);
 
    /* Make sure our PDE is valid, and that everything is going fine */
    if (Process == NULL)
    {
        /* We don't support this in legacy Mm for kernel mappings */
        ASSERT(ProtectionMask != MM_WRITECOPY);
        ASSERT(ProtectionMask != MM_EXECUTE_WRITECOPY);
 
        if (Address < MmSystemRangeStart)
        {
            DPRINT1("NULL process given for user-mode mapping at %p\n", Address);
            KeBugCheck(MEMORY_MANAGEMENT);
        }
#if _MI_PAGING_LEVELS == 2
        if (!MiSynchronizeSystemPde(MiAddressToPde(Address)))
            MiFillSystemPageDirectory(Address, PAGE_SIZE);
#endif
    }
    else
    {
        if ((Address >= MmSystemRangeStart) || Add2Ptr(Address, PAGE_SIZE) >= MmSystemRangeStart)
        {
            DPRINT1("Process %p given for kernel-mode mapping at %p -- 1 page starting at %Ix\n",
                    Process, Address, Page);
            KeBugCheck(MEMORY_MANAGEMENT);
        }
 
        /* Only for current process !!! */
        ASSERT(Process == PsGetCurrentProcess());
        MiLockProcessWorkingSetUnsafe(Process, PsGetCurrentThread());
 
        MiMakePdeExistAndMakeValid(MiAddressToPde(Address), Process, MM_NOIRQL);
    }
 
    PointerPte = MiAddressToPte(Address);
 
    MI_MAKE_HARDWARE_PTE(&TempPte, PointerPte, ProtectionMask, Page);
 
    Pte = InterlockedExchangePte(PointerPte, TempPte.u.Long);
    /* There should not have been anything valid here */
    if (Pte != 0)
    {
        DPRINT1("Bad PTE %lx at %p for %p\n", Pte, PointerPte, Address);
        KeBugCheck(MEMORY_MANAGEMENT);
    }
 
    if (!IsPhysical)
    {
        PMMPFN Pfn1;
        KIRQL OldIrql;
 
        OldIrql = MiAcquirePfnLock();
        Pfn1 = &MmPfnDatabase[TempPte.u.Hard.PageFrameNumber];
        Pfn1->u2.ShareCount++;
        Pfn1->u3.e1.PageLocation = ActiveAndValid;
        MiReleasePfnLock(OldIrql);
    }
 
    /* We don't need to flush the TLB here because it only caches valid translations
     * and we're moving this PTE from invalid to valid so it can't be cached right now */
 
    if (Address < MmSystemRangeStart)
    {
        /* Add PDE reference */
        MiIncrementPageTableReferences(Address);
        MiUnlockProcessWorkingSetUnsafe(Process, PsGetCurrentThread());
    }
 
    return(STATUS_SUCCESS);
}

Referenced by MmCreatePhysicalMapping(), and MmCreateVirtualMappingUnsafe().

MmDeletePageFileMapping()

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

Definition at line 372 of file page.c.

{
    PMMPTE PointerPte;
    MMPTE OldPte;
 
    /* This should not be called for kernel space anymore */
    ASSERT(Process != NULL);
    ASSERT(Address < MmSystemRangeStart);
 
    /* And we don't support deleting for other process */
    ASSERT(Process == PsGetCurrentProcess());
 
    /* And we should be at low IRQL */
    ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
 
    /* We are tinkering with the PDE here. Ensure it will be there */
    MiLockProcessWorkingSetUnsafe(Process, PsGetCurrentThread());
 
    /* Callers must ensure there is actually something there */
    ASSERT(MiAddressToPde(Address)->u.Long != 0);
 
    MiMakePdeExistAndMakeValid(MiAddressToPde(Address), Process, MM_NOIRQL);
 
    PointerPte = MiAddressToPte(Address);
    OldPte.u.Long = InterlockedExchangePte(PointerPte, 0);
    /* This must be a swap entry ! */
    if (!FlagOn(OldPte.u.Long, 0x800) || OldPte.u.Hard.Valid)
    {
        KeBugCheckEx(MEMORY_MANAGEMENT, OldPte.u.Long, (ULONG_PTR)Process, (ULONG_PTR)Address, 0);
    }
 
    /* This used to be a non-zero PTE, now we can let the PDE go. */
    if (MiDecrementPageTableReferences(Address) == 0)
    {
        /* We can let it go */
        KIRQL OldIrql = MiAcquirePfnLock();
        MiDeletePde(MiPteToPde(PointerPte), Process);
        MiReleasePfnLock(OldIrql);
    }
 
    MiUnlockProcessWorkingSetUnsafe(Process, PsGetCurrentThread());
 
    *SwapEntry = OldPte.u.Long >> 1;
}

MmGetPageFileMapping()

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

Definition at line 549 of file page.c.

{
    PMMPTE PointerPte;
 
    /* We never set swap entries for kernel addresses */
    if (Address >= MmSystemRangeStart)
    {
        ASSERT(Process == NULL);
        *SwapEntry = 0;
        return;
    }
 
    ASSERT(Process != NULL);
    ASSERT(Process == PsGetCurrentProcess());
 
    MiLockProcessWorkingSetShared(Process, PsGetCurrentThread());
 
    if (!MiIsPageTablePresent(Address))
    {
        /* There can't be a swap entry if there is no PDE */
        MiUnlockProcessWorkingSetShared(Process, PsGetCurrentThread());
        *SwapEntry = 0;
        return;
    }
 
    MiMakePdeExistAndMakeValid(MiAddressToPde(Address), Process, MM_NOIRQL);
 
    PointerPte = MiAddressToPte(Address);
    if (!PointerPte->u.Hard.Valid && FlagOn(PointerPte->u.Long, 0x800))
        *SwapEntry = PointerPte->u.Long >> 1;
    else
        *SwapEntry = 0;
 
    MiUnlockProcessWorkingSetShared(Process, PsGetCurrentThread());
}

Referenced by MmAlterViewAttributes(), MmNotPresentFaultSectionView(), and MmPageOutCacheSection().

MmGetPageProtect()

ULONG NTAPI MmGetPageProtect	(	PEPROCESS	Process,
		PVOID	Address
	)

Definition at line 763 of file page.c.

{
    PMMPTE PointerPte;
    ULONG Protect;
 
    if (Address >= MmSystemRangeStart)
    {
        ASSERT(Process == NULL);
 
#if _MI_PAGING_LEVELS == 2
        if (!MiSynchronizeSystemPde(MiAddressToPde(Address)))
#else
        if (!MiIsPdeForAddressValid(Address))
#endif
        {
            return PAGE_NOACCESS;
        }
    }
    else
    {
        ASSERT(Address < MmSystemRangeStart);
        ASSERT(Process != NULL);
 
        ASSERT(Process == PsGetCurrentProcess());
 
        MiLockProcessWorkingSetShared(Process, PsGetCurrentThread());
 
        if (!MiIsPageTablePresent(Address))
        {
            /* It can't be present if there is no PDE */
            MiUnlockProcessWorkingSetShared(Process, PsGetCurrentThread());
            return PAGE_NOACCESS;
        }
 
        MiMakePdeExistAndMakeValid(MiAddressToPde(Address), Process, MM_NOIRQL);
    }
 
    PointerPte = MiAddressToPte(Address);
 
    if (!PointerPte->u.Flush.Valid)
    {
        Protect = PAGE_NOACCESS;
    }
    else
    {
        if (PointerPte->u.Flush.CopyOnWrite)
            Protect = PAGE_WRITECOPY;
        else if (PointerPte->u.Flush.Write)
            Protect = PAGE_READWRITE;
        else
            Protect = PAGE_READONLY;
#if _MI_PAGING_LEVELS >= 3
        /* PAE & AMD64 long mode support NoExecute bit */
        if (!PointerPte->u.Flush.NoExecute)
            Protect <<= 4;
#endif
        if (PointerPte->u.Flush.CacheDisable)
            Protect |= PAGE_NOCACHE;
        if (PointerPte->u.Flush.WriteThrough)
            Protect |= PAGE_WRITETHROUGH;
    }
 
    if (Address < MmSystemRangeStart)
        MiUnlockProcessWorkingSetShared(Process, PsGetCurrentThread());
 
    return(Protect);
}

MmGetPfnForProcess()

PFN_NUMBER NTAPI MmGetPfnForProcess	(	PEPROCESS	Process,
		PVOID	Address
	)

Definition at line 193 of file page.c.

{
    PMMPTE PointerPte;
    PFN_NUMBER Page;
 
    /* Must be called for user mode only */
    ASSERT(Process != NULL);
    ASSERT(Address < MmSystemRangeStart);
 
    /* And for our process */
    ASSERT(Process == PsGetCurrentProcess());
 
    /* Lock for reading */
    MiLockProcessWorkingSetShared(Process, PsGetCurrentThread());
 
    if (!MiIsPageTablePresent(Address))
    {
        MiUnlockProcessWorkingSetShared(Process, PsGetCurrentThread());
        return 0;
    }
 
    /* Make sure we can read the PTE */
    MiMakePdeExistAndMakeValid(MiAddressToPde(Address), Process, MM_NOIRQL);
 
    PointerPte = MiAddressToPte(Address);
    Page = PointerPte->u.Hard.Valid ? PFN_FROM_PTE(PointerPte) : 0;
 
    MiUnlockProcessWorkingSetShared(Process, PsGetCurrentThread());
    return Page;
}

MmInitGlobalKernelPageDirectory()

VOID NTAPI MmInitGlobalKernelPageDirectory

(

VOID

)

Definition at line 925 of file page.c.

{
    /* Nothing to do here */
}

MmIsDisabledPage()

BOOLEAN NTAPI MmIsDisabledPage	(	PEPROCESS	Process,
		PVOID	Address
	)

Definition at line 465 of file page.c.

{
    BOOLEAN Ret;
    PMMPTE PointerPte;
 
    if (Address >= MmSystemRangeStart)
    {
        ASSERT(Process == NULL);
#if _MI_PAGING_LEVELS == 2
        if (!MiSynchronizeSystemPde(MiAddressToPde(Address)))
#else
        if (!MiIsPdeForAddressValid(Address))
#endif
        {
            /* It's not disabled if it's not present */
            return FALSE;
        }
    }
    else
    {
        ASSERT(Process != NULL);
        ASSERT(Process == PsGetCurrentProcess());
 
        MiLockProcessWorkingSetShared(Process, PsGetCurrentThread());
 
        if (!MiIsPageTablePresent(Address))
        {
            /* It can't be disabled if there is no PDE */
            MiUnlockProcessWorkingSetShared(Process, PsGetCurrentThread());
            return FALSE;
        }
 
        MiMakePdeExistAndMakeValid(MiAddressToPde(Address), Process, MM_NOIRQL);
    }
 
    PointerPte = MiAddressToPte(Address);
    Ret = !PointerPte->u.Hard.Valid
        && !FlagOn(PointerPte->u.Long, 0x800)
        && (PointerPte->u.Hard.PageFrameNumber != 0);
 
    if (Address < MmSystemRangeStart)
        MiUnlockProcessWorkingSetShared(Process, PsGetCurrentThread());
 
    return Ret;
}

MmIsPagePresent()

BOOLEAN NTAPI MmIsPagePresent	(	PEPROCESS	Process,
		PVOID	Address
	)

Definition at line 422 of file page.c.

{
    BOOLEAN Ret;
 
    if (Address >= MmSystemRangeStart)
    {
        ASSERT(Process == NULL);
#if _MI_PAGING_LEVELS == 2
        if (!MiSynchronizeSystemPde(MiAddressToPde(Address)))
#else
        if (!MiIsPdeForAddressValid(Address))
#endif
        {
            /* It can't be present if there is no PDE */
            return FALSE;
        }
 
        return MiAddressToPte(Address)->u.Hard.Valid;
    }
 
    ASSERT(Process != NULL);
    ASSERT(Process == PsGetCurrentProcess());
 
    MiLockProcessWorkingSetShared(Process, PsGetCurrentThread());
 
    if (!MiIsPageTablePresent(Address))
    {
        /* It can't be present if there is no PDE */
        MiUnlockProcessWorkingSetShared(Process, PsGetCurrentThread());
        return FALSE;
    }
 
    MiMakePdeExistAndMakeValid(MiAddressToPde(Address), Process, MM_NOIRQL);
 
    Ret = MiAddressToPte(Address)->u.Hard.Valid;
 
    MiUnlockProcessWorkingSetShared(Process, PsGetCurrentThread());
 
    return Ret;
}

MmIsPageSwapEntry()

BOOLEAN NTAPI MmIsPageSwapEntry	(	PEPROCESS	Process,
		PVOID	Address
	)

Definition at line 513 of file page.c.

{
    BOOLEAN Ret;
    PMMPTE PointerPte;
 
    /* We never set swap entries for kernel addresses */
    if (Address >= MmSystemRangeStart)
    {
        ASSERT(Process == NULL);
        return FALSE;
    }
 
    ASSERT(Process != NULL);
    ASSERT(Process == PsGetCurrentProcess());
 
    MiLockProcessWorkingSetShared(Process, PsGetCurrentThread());
 
    if (!MiIsPageTablePresent(Address))
    {
        /* There can't be a swap entry if there is no PDE */
        MiUnlockProcessWorkingSetShared(Process, PsGetCurrentThread());
        return FALSE;
    }
 
    MiMakePdeExistAndMakeValid(MiAddressToPde(Address), Process, MM_NOIRQL);
 
    PointerPte = MiAddressToPte(Address);
    Ret = !PointerPte->u.Hard.Valid && FlagOn(PointerPte->u.Long, 0x800);
 
    MiUnlockProcessWorkingSetShared(Process, PsGetCurrentThread());
 
    return Ret;
}

MmSetDirtyBit()

VOID NTAPI MmSetDirtyBit	(	PEPROCESS	Process,
		PVOID	Address,
		BOOLEAN	Bit
	)

Definition at line 890 of file page.c.

{
    PMMPTE PointerPte;
 
    DPRINT("MmSetDirtyBit(Process %p  Address %p  Bit %x)\n",
           Process, Address, Bit);
 
    ASSERT(Process != NULL);
    ASSERT(Address < MmSystemRangeStart);
 
    ASSERT(Process == PsGetCurrentProcess());
 
    MiLockProcessWorkingSetUnsafe(Process, PsGetCurrentThread());
 
    MiMakePdeExistAndMakeValid(MiAddressToPde(Address), Process, MM_NOIRQL);
 
    PointerPte = MiAddressToPte(Address);
    // We shouldnl't set dirty bit on non-mapped addresses
    if (!PointerPte->u.Hard.Valid && (FlagOn(PointerPte->u.Long, 0x800) || (PointerPte->u.Hard.PageFrameNumber == 0)))
    {
        DPRINT1("Invalid Pte %lx\n", PointerPte->u.Long);
        KeBugCheck(MEMORY_MANAGEMENT);
    }
 
    PointerPte->u.Hard.Dirty = !!Bit;
 
    if (!Bit)
        KeInvalidateTlbEntry(Address);
 
    MiUnlockProcessWorkingSetUnsafe(Process, PsGetCurrentThread());
}

MmSetPageProtect()

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

Definition at line 833 of file page.c.

{
    ULONG ProtectionMask;
    PMMPTE PointerPte;
    MMPTE TempPte, OldPte;
 
    DPRINT("MmSetPageProtect(Process %p  Address %p  flProtect %x)\n",
           Process, Address, flProtect);
 
    ASSERT(Process != NULL);
    ASSERT(Address < MmSystemRangeStart);
 
    ASSERT(Process == PsGetCurrentProcess());
 
    ProtectionMask = MiMakeProtectionMask(flProtect);
    /* Caller must have checked ! */
    ASSERT(ProtectionMask != MM_INVALID_PROTECTION);
 
    MiLockProcessWorkingSetUnsafe(Process, PsGetCurrentThread());
 
    MiMakePdeExistAndMakeValid(MiAddressToPde(Address), Process, MM_NOIRQL);
 
    PointerPte = MiAddressToPte(Address);
 
    /* Sanity check */
    ASSERT(PointerPte->u.Hard.Owner == 1);
 
    TempPte.u.Long = 0;
    TempPte.u.Hard.PageFrameNumber = PointerPte->u.Hard.PageFrameNumber;
    TempPte.u.Long |= MmProtectToPteMask[ProtectionMask];
    TempPte.u.Hard.Owner = 1;
 
    /* Only set valid bit if we have to */
    if ((ProtectionMask != MM_NOACCESS) && !FlagOn(ProtectionMask, MM_GUARDPAGE))
        TempPte.u.Hard.Valid = 1;
 
    /* Keep dirty & accessed bits */
    TempPte.u.Hard.Accessed = PointerPte->u.Hard.Accessed;
    TempPte.u.Hard.Dirty = PointerPte->u.Hard.Dirty;
 
    OldPte.u.Long = InterlockedExchangePte(PointerPte, TempPte.u.Long);
 
    // We should be able to bring a page back from PAGE_NOACCESS
    if (!OldPte.u.Hard.Valid && (FlagOn(OldPte.u.Long, 0x800) || (OldPte.u.Hard.PageFrameNumber == 0)))
    {
        DPRINT1("Invalid Pte %lx\n", OldPte.u.Long);
        KeBugCheck(MEMORY_MANAGEMENT);
    }
 
    if (OldPte.u.Long != TempPte.u.Long)
        KeInvalidateTlbEntry(Address);
 
    MiUnlockProcessWorkingSetUnsafe(Process, PsGetCurrentThread());
}

Variable Documentation

MmProtectToPteMask

const ULONG_PTR MmProtectToPteMask[32]

Definition at line 25 of file page.c.

Referenced by MI_MAKE_HARDWARE_PTE(), MI_MAKE_HARDWARE_PTE_KERNEL(), and MI_MAKE_HARDWARE_PTE_USER().

MmProtectToValue

const ULONG MmProtectToValue[32]

Definition at line 74 of file page.c.