sptab.c File Reference

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

Include dependency graph for sptab.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	DPRINTC   DPRINT

Functions
	_Function_class_ (RTL_GENERIC_ALLOCATE_ROUTINE)
	_Function_class_ (RTL_GENERIC_FREE_ROUTINE)
	_Function_class_ (RTL_GENERIC_COMPARE_ROUTINE)
static PCACHE_SECTION_PAGE_TABLE NTAPI	MiSectionPageTableGet (PRTL_GENERIC_TABLE Table, PLARGE_INTEGER FileOffset)
static PCACHE_SECTION_PAGE_TABLE NTAPI	MiSectionPageTableGetOrAllocate (PRTL_GENERIC_TABLE Table, PLARGE_INTEGER FileOffset)
VOID NTAPI	MiInitializeSectionPageTable (PMM_SECTION_SEGMENT Segment)
NTSTATUS NTAPI	_MmSetPageEntrySectionSegment (PMM_SECTION_SEGMENT Segment, PLARGE_INTEGER Offset, ULONG_PTR Entry, const char *file, int line)
ULONG_PTR NTAPI	_MmGetPageEntrySectionSegment (PMM_SECTION_SEGMENT Segment, PLARGE_INTEGER Offset, const char *file, int line)
VOID NTAPI	MmFreePageTablesSectionSegment (PMM_SECTION_SEGMENT Segment, FREE_SECTION_PAGE_FUN FreePage)
PMM_SECTION_SEGMENT NTAPI	MmGetSectionAssociation (PFN_NUMBER Page, PLARGE_INTEGER Offset)
NTSTATUS NTAPI	MmSetSectionAssociation (PFN_NUMBER Page, PMM_SECTION_SEGMENT Segment, PLARGE_INTEGER Offset)

Variables
KSPIN_LOCK	MiSectionPageTableLock

Macro Definition Documentation

DPRINTC

#define DPRINTC   DPRINT

Definition at line 61 of file sptab.c.

NDEBUG

#define NDEBUG

Definition at line 58 of file sptab.c.

Function Documentation

_Function_class_() [1/3]

_Function_class_

(

RTL_GENERIC_ALLOCATE_ROUTINE

)

Definition at line 67 of file sptab.c.

{
    PVOID Result;
    Result = ExAllocatePoolWithTag(NonPagedPool, Bytes, 'tPmM');
    //DPRINT("MiSectionPageTableAllocate(%d) => %p\n", Bytes, Result);
    return Result;
}

_Function_class_() [2/3]

_Function_class_

(

RTL_GENERIC_COMPARE_ROUTINE

)

Definition at line 89 of file sptab.c.

{
    PLARGE_INTEGER A = PtrA, B = PtrB;
    BOOLEAN Result = (A->QuadPart < B->QuadPart) ? GenericLessThan :
        (A->QuadPart == B->QuadPart) ? GenericEqual : GenericGreaterThan;
 
#if 0
    DPRINT
        ("Compare: %08x%08x vs %08x%08x => %s\n",
         A->u.HighPart, A->u.LowPart,
         B->u.HighPart, B->u.LowPart,
         Result == GenericLessThan ? "GenericLessThan" :
         Result == GenericGreaterThan ? "GenericGreaterThan" :
            "GenericEqual");
#endif
 
    return Result;
}

_Function_class_() [3/3]

_Function_class_

(

RTL_GENERIC_FREE_ROUTINE

)

Definition at line 79 of file sptab.c.

{
    //DPRINT("MiSectionPageTableFree(%p)\n", Data);
    ExFreePoolWithTag(Data, 'tPmM');
}

_MmGetPageEntrySectionSegment()

ULONG_PTR NTAPI _MmGetPageEntrySectionSegment	(	PMM_SECTION_SEGMENT	Segment,
		PLARGE_INTEGER	Offset,
		const char *	file,
		int	line
	)

Definition at line 280 of file sptab.c.

{
    LARGE_INTEGER FileOffset;
    ULONG_PTR PageIndex, Result;
    PCACHE_SECTION_PAGE_TABLE PageTable;
 
    ASSERT(Segment->Locked);
    FileOffset.QuadPart = ROUND_DOWN(Offset->QuadPart,
                                     ENTRIES_PER_ELEMENT * PAGE_SIZE);
    PageTable = MiSectionPageTableGet(&Segment->PageTable, &FileOffset);
    if (!PageTable) return 0;
    PageIndex = (ULONG_PTR)((Offset->QuadPart - PageTable->FileOffset.QuadPart) / PAGE_SIZE);
    Result = PageTable->PageEntries[PageIndex];
#if 0
    DPRINTC
        ("MiGetPageEntrySectionSegment(%p,%08x%08x) => %x %s:%d\n",
         Segment,
         FileOffset.u.HighPart,
         FileOffset.u.LowPart + PageIndex * PAGE_SIZE,
         Result,
         file, line);
#endif
    return Result;
}

_MmSetPageEntrySectionSegment()

NTSTATUS NTAPI _MmSetPageEntrySectionSegment	(	PMM_SECTION_SEGMENT	Segment,
		PLARGE_INTEGER	Offset,
		ULONG_PTR	Entry,
		const char *	file,
		int	line
	)

Definition at line 178 of file sptab.c.

{
    ULONG_PTR PageIndex, OldEntry;
    PCACHE_SECTION_PAGE_TABLE PageTable;
 
    ASSERT(Segment->Locked);
    ASSERT(!IS_SWAP_FROM_SSE(Entry) || !IS_DIRTY_SSE(Entry));
 
    PageTable = MiSectionPageTableGetOrAllocate(&Segment->PageTable, Offset);
 
    if (!PageTable) return STATUS_NO_MEMORY;
 
    ASSERT(MiSectionPageTableGet(&Segment->PageTable, Offset));
 
    PageTable->Segment = Segment;
    PageIndex = (ULONG_PTR)((Offset->QuadPart - PageTable->FileOffset.QuadPart) / PAGE_SIZE);
    OldEntry = PageTable->PageEntries[PageIndex];
 
    DPRINT("MiSetPageEntrySectionSegment(%p,%08x%08x,%x=>%x)\n",
            Segment,
            Offset->u.HighPart,
            Offset->u.LowPart,
            OldEntry,
            Entry);
 
    /* Manage ref on segment */
    if (Entry && !OldEntry)
    {
        InterlockedIncrement64(Segment->ReferenceCount);
    }
    if (OldEntry && !Entry)
    {
        MmDereferenceSegment(Segment);
    }
 
    if (Entry && !IS_SWAP_FROM_SSE(Entry))
    {
        /* We have a valid entry. See if we must do something */
        if (OldEntry && !IS_SWAP_FROM_SSE(OldEntry))
        {
            /* The previous entry was valid. Shall we swap the Rmaps ? */
            if (PFN_FROM_SSE(Entry) != PFN_FROM_SSE(OldEntry))
            {
                MmDeleteSectionAssociation(PFN_FROM_SSE(OldEntry));
 
                /* This has to be done before setting the new section association
                   to prevent a race condition with the paging out path */
                PageTable->PageEntries[PageIndex] = Entry;
 
                MmSetSectionAssociation(PFN_FROM_SSE(Entry), Segment, Offset);
            }
            else
            {
                PageTable->PageEntries[PageIndex] = Entry;
            }
        }
        else
        {
            /*
             * We're switching to a valid entry from an invalid one.
             * Add the Rmap and take a ref on the segment.
             */
            PageTable->PageEntries[PageIndex] = Entry;
            MmSetSectionAssociation(PFN_FROM_SSE(Entry), Segment, Offset);
 
            if (Offset->QuadPart >= (Segment->LastPage << PAGE_SHIFT))
                Segment->LastPage = (Offset->QuadPart >> PAGE_SHIFT) + 1;
        }
    }
    else if (OldEntry && !IS_SWAP_FROM_SSE(OldEntry))
    {
        /* We're switching to an invalid entry from a valid one */
        MmDeleteSectionAssociation(PFN_FROM_SSE(OldEntry));
        PageTable->PageEntries[PageIndex] = Entry;
 
        if (Offset->QuadPart == ((Segment->LastPage - 1ULL) << PAGE_SHIFT))
        {
            /* We are unsetting the last page */
            while (--Segment->LastPage)
            {
                LARGE_INTEGER CheckOffset;
                CheckOffset.QuadPart = (Segment->LastPage - 1) << PAGE_SHIFT;
                ULONG_PTR Entry = MmGetPageEntrySectionSegment(Segment, &CheckOffset);
                if ((Entry != 0) && !IS_SWAP_FROM_SSE(Entry))
                    break;
            }
        }
    }
    else
    {
        PageTable->PageEntries[PageIndex] = Entry;
    }
 
    return STATUS_SUCCESS;
}

MiInitializeSectionPageTable()

VOID NTAPI MiInitializeSectionPageTable

(

PMM_SECTION_SEGMENT

Segment

)

Definition at line 165 of file sptab.c.

{
    RtlInitializeGenericTable(&Segment->PageTable,
                              MiSectionPageTableCompare,
                              MiSectionPageTableAllocate,
                              MiSectionPageTableFree,
                              NULL);
 
    DPRINT("MiInitializeSectionPageTable(%p)\n", &Segment->PageTable);
}

Referenced by ExeFmtpCreateImageSection(), MmCreateDataFileSection(), and MmCreatePhysicalMemorySection().

MiSectionPageTableGet()

static PCACHE_SECTION_PAGE_TABLE NTAPI MiSectionPageTableGet ( PRTL_GENERIC_TABLE  Table, PLARGE_INTEGER  FileOffset  )

static

Definition at line 117 of file sptab.c.

{
    LARGE_INTEGER SearchFileOffset;
    PCACHE_SECTION_PAGE_TABLE PageTable;
    SearchFileOffset.QuadPart = ROUND_DOWN(FileOffset->QuadPart,
                                           ENTRIES_PER_ELEMENT * PAGE_SIZE);
    PageTable = RtlLookupElementGenericTable(Table, &SearchFileOffset);
 
    DPRINT("MiSectionPageTableGet(%p,%I64x)\n",
           Table,
           FileOffset->QuadPart);
 
    return PageTable;
}

Referenced by _MmGetPageEntrySectionSegment(), _MmSetPageEntrySectionSegment(), MiSectionPageTableGetOrAllocate(), and MmSetSectionAssociation().

MiSectionPageTableGetOrAllocate()

static PCACHE_SECTION_PAGE_TABLE NTAPI MiSectionPageTableGetOrAllocate ( PRTL_GENERIC_TABLE  Table, PLARGE_INTEGER  FileOffset  )

static

Definition at line 136 of file sptab.c.

{
    LARGE_INTEGER SearchFileOffset;
    CACHE_SECTION_PAGE_TABLE SectionZeroPageTable;
    PCACHE_SECTION_PAGE_TABLE PageTableSlice = MiSectionPageTableGet(Table,
                                                                     FileOffset);
    /* Please zero memory when taking away zero initialization. */
    RtlZeroMemory(&SectionZeroPageTable, sizeof(CACHE_SECTION_PAGE_TABLE));
    if (!PageTableSlice)
    {
        SearchFileOffset.QuadPart = ROUND_DOWN(FileOffset->QuadPart,
                                               ENTRIES_PER_ELEMENT * PAGE_SIZE);
        SectionZeroPageTable.FileOffset = SearchFileOffset;
        SectionZeroPageTable.Refcount = 1;
        PageTableSlice = RtlInsertElementGenericTable(Table,
                                                      &SectionZeroPageTable,
                                                      sizeof(SectionZeroPageTable),
                                                      NULL);
        if (!PageTableSlice) return NULL;
        DPRINT("Allocate page table %p (%I64x)\n",
               PageTableSlice,
               PageTableSlice->FileOffset.QuadPart);
    }
    return PageTableSlice;
}

Referenced by _MmSetPageEntrySectionSegment().

MmFreePageTablesSectionSegment()

VOID NTAPI MmFreePageTablesSectionSegment	(	PMM_SECTION_SEGMENT	Segment,
		FREE_SECTION_PAGE_FUN	FreePage
	)

Definition at line 321 of file sptab.c.

{
    PCACHE_SECTION_PAGE_TABLE Element;
    DPRINT("MiFreePageTablesSectionSegment(%p)\n", &Segment->PageTable);
    while ((Element = RtlGetElementGenericTable(&Segment->PageTable, 0))) {
        DPRINT("Delete table for <%wZ> %p -> %I64x\n",
               Segment->FileObject ? &Segment->FileObject->FileName : NULL,
               Segment,
               Element->FileOffset.QuadPart);
        if (FreePage)
        {
            ULONG i;
            for (i = 0; i < ENTRIES_PER_ELEMENT; i++)
            {
                ULONG_PTR Entry;
                LARGE_INTEGER Offset;
                Offset.QuadPart = Element->FileOffset.QuadPart + i * PAGE_SIZE;
                Entry = Element->PageEntries[i];
                if (Entry && !IS_SWAP_FROM_SSE(Entry))
                {
                    DPRINT("Freeing page %p:%Ix @ %I64x\n",
                           Segment,
                           Entry,
                           Offset.QuadPart);
 
                    FreePage(Segment, &Offset);
                }
            }
        }
        DPRINT("Remove memory\n");
        RtlDeleteElementGenericTable(&Segment->PageTable, Element);
    }
    DPRINT("Done\n");
}

Referenced by _When_().

MmGetSectionAssociation()

PMM_SECTION_SEGMENT NTAPI MmGetSectionAssociation	(	PFN_NUMBER	Page,
		PLARGE_INTEGER	Offset
	)

Definition at line 374 of file sptab.c.

{
    ULONG RawOffset;
    PMM_SECTION_SEGMENT Segment = NULL;
    PCACHE_SECTION_PAGE_TABLE PageTable;
 
    KIRQL OldIrql = MiAcquirePfnLock();
 
    PageTable = MmGetSegmentRmap(Page, &RawOffset);
    if (PageTable)
    {
        Segment = PageTable->Segment;
        Offset->QuadPart = PageTable->FileOffset.QuadPart +
                           ((ULONG64)RawOffset << PAGE_SHIFT);
        ASSERT(PFN_FROM_SSE(PageTable->PageEntries[RawOffset]) == Page);
        InterlockedIncrement64(Segment->ReferenceCount);
    }
 
    MiReleasePfnLock(OldIrql);
 
    return Segment;
}

Referenced by MiShutdownSystem(), MmPageOutPhysicalAddress(), and MmpPageOutPhysicalAddress().

MmSetSectionAssociation()

NTSTATUS NTAPI MmSetSectionAssociation	(	PFN_NUMBER	Page,
		PMM_SECTION_SEGMENT	Segment,
		PLARGE_INTEGER	Offset
	)

Definition at line 400 of file sptab.c.

{
    PCACHE_SECTION_PAGE_TABLE PageTable;
    ULONG ActualOffset;
 
    PageTable = MiSectionPageTableGet(&Segment->PageTable, Offset);
    ASSERT(PageTable);
 
    ActualOffset = (ULONG)(Offset->QuadPart - PageTable->FileOffset.QuadPart);
    MmInsertRmap(Page,
                 (PEPROCESS)PageTable,
                 (PVOID)(RMAP_SEGMENT_MASK | (ActualOffset >> PAGE_SHIFT)));
 
    return STATUS_SUCCESS;
}

Referenced by _MmSetPageEntrySectionSegment().

Variable Documentation

MiSectionPageTableLock

KSPIN_LOCK MiSectionPageTableLock

extern