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

Include dependency graph for syspte.c:

Macros
#define	NDEBUG

#define	MODULE_INVOLVED_IN_ARM3

Functions
FORCEINLINE ULONG	MI_GET_CLUSTER_SIZE (IN PMMPTE Pte)

PMMPTE NTAPI	MiReserveAlignedSystemPtes (IN ULONG NumberOfPtes, IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType, IN ULONG Alignment)

PMMPTE NTAPI	MiReserveSystemPtes (IN ULONG NumberOfPtes, IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType)

VOID NTAPI	MiReleaseSystemPtes (IN PMMPTE StartingPte, IN ULONG NumberOfPtes, IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType)

VOID NTAPI	MiInitializeSystemPtes (IN PMMPTE StartingPte, IN ULONG NumberOfPtes, IN MMSYSTEM_PTE_POOL_TYPE PoolType)

Variables
PMMPTE	MmSystemPteBase

PMMPTE	MmSystemPtesStart [MaximumPtePoolTypes]

PMMPTE	MmSystemPtesEnd [MaximumPtePoolTypes]

MMPTE	MmFirstFreeSystemPte [MaximumPtePoolTypes]

ULONG	MmTotalFreeSystemPtes [MaximumPtePoolTypes]

ULONG	MmTotalSystemPtes

ULONG	MiNumberOfExtraSystemPdes

const ULONG	MmSysPteIndex [5] = { 1, 2, 4, 8, 16 }

const UCHAR	MmSysPteTables []

LONG	MmSysPteListBySizeCount [5]

Macro Definition Documentation

◆ MODULE_INVOLVED_IN_ARM3

#define MODULE_INVOLVED_IN_ARM3

Definition at line 16 of file syspte.c.

◆ NDEBUG

#define NDEBUG

Definition at line 13 of file syspte.c.

Function Documentation

◆ MI_GET_CLUSTER_SIZE()

FORCEINLINE ULONG MI_GET_CLUSTER_SIZE ( IN PMMPTE Pte )

Definition at line 71 of file syspte.c.

{
    //
    // First check for a single PTE
    //
    if (Pte->u.List.OneEntry)
        return 1;
 
    //
    // Then read the size from the trailing PTE
    //
    Pte++;
    return (ULONG)Pte->u.List.NextEntry;
}

Referenced by MiReleaseSystemPtes(), and MiReserveAlignedSystemPtes().

◆ MiInitializeSystemPtes()

VOID NTAPI MiInitializeSystemPtes	(	IN PMMPTE	StartingPte,
		IN ULONG	NumberOfPtes,
		IN MMSYSTEM_PTE_POOL_TYPE	PoolType
	)

Definition at line 388 of file syspte.c.

{
    //
    // Sanity checks
    //
    ASSERT(NumberOfPtes >= 1);
 
    //
    // Set the starting and ending PTE addresses for this space
    //
    MmSystemPteBase = MI_SYSTEM_PTE_BASE;
    MmSystemPtesStart[PoolType] = StartingPte;
    MmSystemPtesEnd[PoolType] = StartingPte + NumberOfPtes - 1;
    DPRINT("System PTE space for %d starting at: %p and ending at: %p\n",
           PoolType, MmSystemPtesStart[PoolType], MmSystemPtesEnd[PoolType]);
 
    //
    // Clear all the PTEs to start with
    //
    RtlZeroMemory(StartingPte, NumberOfPtes * sizeof(MMPTE));
 
    //
    // Make the first entry free and link it
    //
    StartingPte->u.List.NextEntry = MM_EMPTY_PTE_LIST;
    MmFirstFreeSystemPte[PoolType].u.Long = 0;
    MmFirstFreeSystemPte[PoolType].u.List.NextEntry = StartingPte -
                                                      MmSystemPteBase;
 
    //
    // The second entry stores the size of this PTE space
    //
    StartingPte++;
    StartingPte->u.Long = 0;
    StartingPte->u.List.NextEntry = NumberOfPtes;
 
    //
    // We also keep a global for it
    //
    MmTotalFreeSystemPtes[PoolType] = NumberOfPtes;
 
    //
    // Check if this is the system PTE space
    //
    if (PoolType == SystemPteSpace)
    {
        //
        // Remember how many PTEs we have
        //
        MmTotalSystemPtes = NumberOfPtes;
    }
}

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

◆ MiReleaseSystemPtes()

VOID NTAPI MiReleaseSystemPtes	(	IN PMMPTE	StartingPte,
		IN ULONG	NumberOfPtes,
		IN MMSYSTEM_PTE_POOL_TYPE	SystemPtePoolType
	)

Definition at line 264 of file syspte.c.

{
    KIRQL OldIrql;
    ULONG ClusterSize;
    PMMPTE PreviousPte, NextPte, InsertPte;
 
    //
    // Check to make sure the PTE address is within bounds
    //
    ASSERT(NumberOfPtes != 0);
    ASSERT(StartingPte >= MmSystemPtesStart[SystemPtePoolType]);
    ASSERT(StartingPte + NumberOfPtes - 1 <= MmSystemPtesEnd[SystemPtePoolType]);
 
    //
    // Zero PTEs
    //
    RtlZeroMemory(StartingPte, NumberOfPtes * sizeof(MMPTE));
 
    //
    // Acquire the System PTE lock
    //
    OldIrql = KeAcquireQueuedSpinLock(LockQueueSystemSpaceLock);
 
    //
    // Increase availability
    //
    MmTotalFreeSystemPtes[SystemPtePoolType] += NumberOfPtes;
 
    //
    // Step through the cluster list to find where to insert the PTEs
    //
    PreviousPte = &MmFirstFreeSystemPte[SystemPtePoolType];
    InsertPte = NULL;
 
    while (PreviousPte->u.List.NextEntry != MM_EMPTY_PTE_LIST)
    {
        //
        // Get the next cluster and its size
        //
        NextPte = MmSystemPteBase + PreviousPte->u.List.NextEntry;
        ClusterSize = MI_GET_CLUSTER_SIZE(NextPte);
 
        //
        // Check if this cluster is adjacent to the PTEs being released
        //
        if ((NextPte + ClusterSize == StartingPte) ||
            (StartingPte + NumberOfPtes == NextPte))
        {
            //
            // Add the PTEs in the cluster to the PTEs being released
            //
            NumberOfPtes += ClusterSize;
 
            if (NextPte < StartingPte)
                StartingPte = NextPte;
 
            //
            // Unlink this cluster and zero it
            //
            PreviousPte->u.List.NextEntry = NextPte->u.List.NextEntry;
 
            if (NextPte->u.List.OneEntry == 0)
            {
                NextPte->u.Long = 0;
                NextPte++;
            }
            NextPte->u.Long = 0;
 
            //
            // Invalidate the previously found insertion location, if any
            //
            InsertPte = NULL;
        }
        else
        {
            //
            // Check if the insertion location is right before this cluster
            //
            if ((InsertPte == NULL) && (NumberOfPtes <= ClusterSize))
                InsertPte = PreviousPte;
 
            //
            // On to the next cluster
            //
            PreviousPte = NextPte;
        }
    }
 
    //
    // If no insertion location was found, use the tail of the list
    //
    if (InsertPte == NULL)
        InsertPte = PreviousPte;
 
    //
    // Create a new cluster using the PTEs being released
    //
    if (NumberOfPtes != 1)
    {
        StartingPte->u.List.OneEntry = 0;
 
        NextPte = StartingPte + 1;
        NextPte->u.List.NextEntry = NumberOfPtes;
    }
    else
        StartingPte->u.List.OneEntry = 1;
 
    //
    // Link the new cluster into the cluster list at the insertion location
    //
    StartingPte->u.List.NextEntry = InsertPte->u.List.NextEntry;
    InsertPte->u.List.NextEntry = StartingPte - MmSystemPteBase;
 
    //
    // Release the System PTE lock
    //
    KeReleaseQueuedSpinLock(LockQueueSystemSpaceLock, OldIrql);
}

Referenced by MiAllocatePoolPages(), MiArchCreateProcessAddressSpace(), MiCopyPfn(), MiReleaseProcessReferenceToSessionDataPage(), MiZeroPfn(), MmDeleteKernelStack(), MmFreeNonCachedMemory(), MmUnmapIoSpace(), and MmUnmapLockedPages().

◆ MiReserveAlignedSystemPtes()

PMMPTE NTAPI MiReserveAlignedSystemPtes	(	IN ULONG	NumberOfPtes,
		IN MMSYSTEM_PTE_POOL_TYPE	SystemPtePoolType,
		IN ULONG	Alignment
	)

Definition at line 88 of file syspte.c.

{
    KIRQL OldIrql;
    PMMPTE PreviousPte, NextPte, ReturnPte;
    ULONG ClusterSize;
 
    //
    // Sanity check
    //
    ASSERT(Alignment <= PAGE_SIZE);
 
    //
    // Acquire the System PTE lock
    //
    OldIrql = KeAcquireQueuedSpinLock(LockQueueSystemSpaceLock);
 
    //
    // Find the last cluster in the list that doesn't contain enough PTEs
    //
    PreviousPte = &MmFirstFreeSystemPte[SystemPtePoolType];
 
    while (PreviousPte->u.List.NextEntry != MM_EMPTY_PTE_LIST)
    {
        //
        // Get the next cluster and its size
        //
        NextPte = MmSystemPteBase + PreviousPte->u.List.NextEntry;
        ClusterSize = MI_GET_CLUSTER_SIZE(NextPte);
 
        //
        // Check if this cluster contains enough PTEs
        //
        if (NumberOfPtes <= ClusterSize)
            break;
 
        //
        // On to the next cluster
        //
        PreviousPte = NextPte;
    }
 
    //
    // Make sure we didn't reach the end of the cluster list
    //
    if (PreviousPte->u.List.NextEntry == MM_EMPTY_PTE_LIST)
    {
        //
        // Release the System PTE lock and return failure
        //
        KeReleaseQueuedSpinLock(LockQueueSystemSpaceLock, OldIrql);
        return NULL;
    }
 
    //
    // Unlink the cluster
    //
    PreviousPte->u.List.NextEntry = NextPte->u.List.NextEntry;
 
    //
    // Check if the reservation spans the whole cluster
    //
    if (ClusterSize == NumberOfPtes)
    {
        //
        // Return the first PTE of this cluster
        //
        ReturnPte = NextPte;
 
        //
        // Zero the cluster
        //
        if (NextPte->u.List.OneEntry == 0)
        {
            NextPte->u.Long = 0;
            NextPte++;
        }
        NextPte->u.Long = 0;
    }
    else
    {
        //
        // Divide the cluster into two parts
        //
        ClusterSize -= NumberOfPtes;
        ReturnPte = NextPte + ClusterSize;
 
        //
        // Set the size of the first cluster, zero the second if needed
        //
        if (ClusterSize == 1)
        {
            NextPte->u.List.OneEntry = 1;
            ReturnPte->u.Long = 0;
        }
        else
        {
            NextPte++;
            NextPte->u.List.NextEntry = ClusterSize;
        }
 
        //
        // Step through the cluster list to find out where to insert the first
        //
        PreviousPte = &MmFirstFreeSystemPte[SystemPtePoolType];
 
        while (PreviousPte->u.List.NextEntry != MM_EMPTY_PTE_LIST)
        {
            //
            // Get the next cluster
            //
            NextPte = MmSystemPteBase + PreviousPte->u.List.NextEntry;
 
            //
            // Check if the cluster to insert is smaller or of equal size
            //
            if (ClusterSize <= MI_GET_CLUSTER_SIZE(NextPte))
                break;
 
            //
            // On to the next cluster
            //
            PreviousPte = NextPte;
        }
 
        //
        // Retrieve the first cluster and link it back into the cluster list
        //
        NextPte = ReturnPte - ClusterSize;
 
        NextPte->u.List.NextEntry = PreviousPte->u.List.NextEntry;
        PreviousPte->u.List.NextEntry = NextPte - MmSystemPteBase;
    }
 
    //
    // Decrease availability
    //
    MmTotalFreeSystemPtes[SystemPtePoolType] -= NumberOfPtes;
 
    //
    // Release the System PTE lock
    //
    KeReleaseQueuedSpinLock(LockQueueSystemSpaceLock, OldIrql);
 
    //
    // Flush the TLB
    //
    KeFlushProcessTb();
 
    //
    // Return the reserved PTEs
    //
    return ReturnPte;
}

Referenced by MiInitializeSpecialPool(), and MiReserveSystemPtes().

◆ MiReserveSystemPtes()

PMMPTE NTAPI MiReserveSystemPtes	(	IN ULONG	NumberOfPtes,
		IN MMSYSTEM_PTE_POOL_TYPE	SystemPtePoolType
	)

Definition at line 246 of file syspte.c.

{
    PMMPTE PointerPte;
 
    //
    // Use the extended function
    //
    PointerPte = MiReserveAlignedSystemPtes(NumberOfPtes, SystemPtePoolType, 0);
 
    //
    // Return the PTE Pointer
    //
    return PointerPte;
}

Referenced by MiAllocatePoolPages(), MiArchCreateProcessAddressSpace(), MiBuildPagedPool(), MiBuildSystemPteSpace(), MiCopyPfn(), MiInitializeLargePageSupport(), MiInitMachineDependent(), MiLoadImageSection(), MiReloadBootLoadedDrivers(), MiSessionCreateInternal(), MiZeroPfn(), MmAllocateNonCachedMemory(), MmCreateKernelStack(), MmMapIoSpace(), and MmMapLockedPagesSpecifyCache().

Variable Documentation

◆ MiNumberOfExtraSystemPdes

ULONG MiNumberOfExtraSystemPdes

Definition at line 27 of file syspte.c.

◆ MmFirstFreeSystemPte

MMPTE MmFirstFreeSystemPte[MaximumPtePoolTypes]

Definition at line 24 of file syspte.c.

Referenced by MiInitializeSystemPtes(), MiReleaseSystemPtes(), and MiReserveAlignedSystemPtes().

◆ MmSysPteIndex

const ULONG MmSysPteIndex[5] = { 1, 2, 4, 8, 16 }

Definition at line 28 of file syspte.c.

◆ MmSysPteListBySizeCount

LONG MmSysPteListBySizeCount[5]

Definition at line 36 of file syspte.c.

◆ MmSysPteTables

const UCHAR MmSysPteTables[]

Initial value:

= { 0, 
                                 0, 
                                 1, 
                                 2, 2, 
                                 3, 3, 3, 3, 
                                 4, 4, 4, 4, 4, 4, 4, 4 
                               }

Definition at line 29 of file syspte.c.