zeropage.c File Reference

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

Include dependency graph for zeropage.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	MODULE_INVOLVED_IN_ARM3

Functions
VOID NTAPI	MiFindInitializationCode (OUT PVOID *StartVa, OUT PVOID *EndVa)
VOID NTAPI	MiFreeInitializationCode (IN PVOID StartVa, IN PVOID EndVa)
VOID NTAPI	MmZeroPageThread (VOID)

Variables
KEVENT	MmZeroingPageEvent

Macro Definition Documentation

MODULE_INVOLVED_IN_ARM3

#define MODULE_INVOLVED_IN_ARM3

Definition at line 15 of file zeropage.c.

NDEBUG

#define NDEBUG

Definition at line 12 of file zeropage.c.

Function Documentation

MiFindInitializationCode()

VOID NTAPI MiFindInitializationCode	(	OUT PVOID *	StartVa,
		OUT PVOID *	EndVa
	)

Definition at line 1530 of file sysldr.c.

{
    ULONG Size, SectionCount, Alignment;
    PLDR_DATA_TABLE_ENTRY LdrEntry;
    ULONG_PTR DllBase, InitStart, InitEnd, ImageEnd, InitCode;
    PLIST_ENTRY NextEntry;
    PIMAGE_NT_HEADERS NtHeader;
    PIMAGE_SECTION_HEADER Section, LastSection, InitSection;
    BOOLEAN InitFound;
    DBG_UNREFERENCED_LOCAL_VARIABLE(InitSection);
 
    /* So we don't free our own code yet */
    InitCode = (ULONG_PTR)&MiFindInitializationCode;
 
    /* Assume failure */
    *StartVa = NULL;
 
    /* Acquire the necessary locks while we loop the list */
    KeEnterCriticalRegion();
    KeWaitForSingleObject(&MmSystemLoadLock,
                          WrVirtualMemory,
                          KernelMode,
                          FALSE,
                          NULL);
    ExAcquireResourceExclusiveLite(&PsLoadedModuleResource, TRUE);
 
    /* Loop all loaded modules */
    NextEntry = PsLoadedModuleList.Flink;
    while (NextEntry != &PsLoadedModuleList)
    {
        /* Get the loader entry and its DLL base */
        LdrEntry = CONTAINING_RECORD(NextEntry, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks);
        DllBase = (ULONG_PTR)LdrEntry->DllBase;
 
        /* Only process boot loaded images. Other drivers are processed by
           MmFreeDriverInitialization */
        if (LdrEntry->Flags & LDRP_MM_LOADED)
        {
            /* Keep going */
            NextEntry = NextEntry->Flink;
            continue;
        }
 
        /* Get the NT header */
        NtHeader = RtlImageNtHeader((PVOID)DllBase);
        if (!NtHeader)
        {
            /* Keep going */
            NextEntry = NextEntry->Flink;
            continue;
        }
 
        /* Get the first section, the section count, and scan them all */
        Section = IMAGE_FIRST_SECTION(NtHeader);
        SectionCount = NtHeader->FileHeader.NumberOfSections;
        InitStart = 0;
        while (SectionCount > 0)
        {
            /* Assume failure */
            InitFound = FALSE;
 
            /* Is this the INIT section or a discardable section? */
            if ((strncmp((PCCH)Section->Name, "INIT", 5) == 0) ||
                ((Section->Characteristics & IMAGE_SCN_MEM_DISCARDABLE)))
            {
                /* Remember this */
                InitFound = TRUE;
                InitSection = Section;
            }
 
            if (InitFound)
            {
                /* Pick the biggest size -- either raw or virtual */
                Size = max(Section->SizeOfRawData, Section->Misc.VirtualSize);
 
                /* Read the section alignment */
                Alignment = NtHeader->OptionalHeader.SectionAlignment;
 
                /* Get the start and end addresses */
                InitStart = DllBase + Section->VirtualAddress;
                InitEnd = ALIGN_UP_BY(InitStart + Size, Alignment);
 
                /* Align the addresses to PAGE_SIZE */
                InitStart = ALIGN_UP_BY(InitStart, PAGE_SIZE);
                InitEnd = ALIGN_DOWN_BY(InitEnd, PAGE_SIZE);
 
                /* Have we reached the last section? */
                if (SectionCount == 1)
                {
                    /* Remember this */
                    LastSection = Section;
                }
                else
                {
                    /* We have not, loop all the sections */
                    LastSection = NULL;
                    do
                    {
                        /* Keep going until we find a non-discardable section range */
                        SectionCount--;
                        Section++;
                        if (Section->Characteristics & IMAGE_SCN_MEM_DISCARDABLE)
                        {
                            /* Discardable, so record it, then keep going */
                            LastSection = Section;
                        }
                        else
                        {
                            /* Non-contigous discard flag, or no flag, break out */
                            break;
                        }
                    }
                    while (SectionCount > 1);
                }
 
                /* Have we found a discardable or init section? */
                if (LastSection)
                {
                    /* Pick the biggest size -- either raw or virtual */
                    Size = max(LastSection->SizeOfRawData, LastSection->Misc.VirtualSize);
 
                    /* Use this as the end of the section address */
                    InitEnd = DllBase + LastSection->VirtualAddress + Size;
 
                    /* Have we reached the last section yet? */
                    if (SectionCount != 1)
                    {
                        /* Then align this accross the session boundary */
                        InitEnd = ALIGN_UP_BY(InitEnd, Alignment);
                        InitEnd = ALIGN_DOWN_BY(InitEnd, PAGE_SIZE);
                    }
                }
 
                /* Make sure we don't let the init section go past the image */
                ImageEnd = DllBase + LdrEntry->SizeOfImage;
                if (InitEnd > ImageEnd) InitEnd = ALIGN_UP_BY(ImageEnd, PAGE_SIZE);
 
                /* Make sure we have a valid, non-zero init section */
                if (InitStart < InitEnd)
                {
                    /* Make sure we are not within this code itself */
                    if ((InitCode >= InitStart) && (InitCode < InitEnd))
                    {
                        /* Return it, we can't free ourselves now */
                        ASSERT(*StartVa == 0);
                        *StartVa = (PVOID)InitStart;
                        *EndVa = (PVOID)InitEnd;
                    }
                    else
                    {
                        /* This isn't us -- go ahead and free it */
                        ASSERT(MI_IS_PHYSICAL_ADDRESS((PVOID)InitStart) == FALSE);
                        DPRINT("Freeing init code: %p-%p ('%wZ' @%p : '%s')\n",
                               (PVOID)InitStart,
                               (PVOID)InitEnd,
                               &LdrEntry->BaseDllName,
                               LdrEntry->DllBase,
                               InitSection->Name);
                        MiFreeInitializationCode((PVOID)InitStart, (PVOID)InitEnd);
                    }
                }
            }
 
            /* Move to the next section */
            SectionCount--;
            Section++;
        }
 
        /* Move to the next module */
        NextEntry = NextEntry->Flink;
    }
 
    /* Release the locks and return */
    ExReleaseResourceLite(&PsLoadedModuleResource);
    KeReleaseMutant(&MmSystemLoadLock, MUTANT_INCREMENT, FALSE, FALSE);
    KeLeaveCriticalRegion();
}

Referenced by MiFindInitializationCode(), and MmZeroPageThread().

MiFreeInitializationCode()

VOID NTAPI MiFreeInitializationCode	(	IN PVOID	StartVa,
		IN PVOID	EndVa
	)

Definition at line 1507 of file sysldr.c.

{
    PMMPTE PointerPte;
    PFN_NUMBER PagesFreed;
 
    /* Get the start PTE */
    PointerPte = MiAddressToPte(InitStart);
    ASSERT(MI_IS_PHYSICAL_ADDRESS(InitStart) == FALSE);
 
    /*  Compute the number of pages we expect to free */
    PagesFreed = (PFN_NUMBER)(MiAddressToPte(InitEnd) - PointerPte);
 
    /* Try to actually free them */
    PagesFreed = MiDeleteSystemPageableVm(PointerPte,
                                          PagesFreed,
                                          0,
                                          NULL);
}

Referenced by MiFindInitializationCode(), and MmZeroPageThread().

MmZeroPageThread()

VOID NTAPI MmZeroPageThread

(

VOID

)

Definition at line 36 of file zeropage.c.

{
    PKTHREAD Thread = KeGetCurrentThread();
    PVOID StartAddress, EndAddress;
    PVOID WaitObjects[2];
 
    /* Get the discardable sections to free them */
    MiFindInitializationCode(&StartAddress, &EndAddress);
    if (StartAddress) MiFreeInitializationCode(StartAddress, EndAddress);
    DPRINT("Free pages: %lx\n", MmAvailablePages);
 
    /* Set our priority to 0 */
    Thread->BasePriority = 0;
    KeSetPriorityThread(Thread, 0);
 
    /* Setup the wait objects */
    WaitObjects[0] = &MmZeroingPageEvent;
//    WaitObjects[1] = &PoSystemIdleTimer; FIXME: Implement idle timer
 
    while (TRUE)
    {
        KIRQL OldIrql;
 
        KeWaitForMultipleObjects(1, // 2
                                 WaitObjects,
                                 WaitAny,
                                 WrFreePage,
                                 KernelMode,
                                 FALSE,
                                 NULL,
                                 NULL);
        OldIrql = MiAcquirePfnLock();
 
        while (TRUE)
        {
            ULONG PageCount = 0;
            PMMPFN Pfn1 = (PMMPFN)LIST_HEAD;
            PVOID ZeroAddress;
            PFN_NUMBER PageIndex, FreePage;
 
            while (PageCount < MI_ZERO_PTES)
            {
                PMMPFN Pfn2;
 
                if (!MmFreePageListHead.Total)
                    break;
 
                PageIndex = MmFreePageListHead.Flink;
                ASSERT(PageIndex != LIST_HEAD);
                MI_SET_USAGE(MI_USAGE_ZERO_LOOP);
                MI_SET_PROCESS2("Kernel 0 Loop");
                FreePage = MiRemoveAnyPage(MI_GET_PAGE_COLOR(PageIndex));
 
                /* The first global free page should also be the first on its own list */
                if (FreePage != PageIndex)
                {
                    KeBugCheckEx(PFN_LIST_CORRUPT,
                                0x8F,
                                FreePage,
                                PageIndex,
                                0);
                }
 
                Pfn2 = MiGetPfnEntry(PageIndex);
                Pfn2->u1.Flink = (PFN_NUMBER)Pfn1;
                Pfn1 = Pfn2;
                PageCount++;
            }
            MiReleasePfnLock(OldIrql);
 
            if (PageCount == 0)
            {
                KeClearEvent(&MmZeroingPageEvent);
                break;
            }
 
            ZeroAddress = MiMapPagesInZeroSpace(Pfn1, PageCount);
            ASSERT(ZeroAddress);
            KeZeroPages(ZeroAddress, PageCount * PAGE_SIZE);
            MiUnmapPagesInZeroSpace(ZeroAddress, PageCount);
 
            OldIrql = MiAcquirePfnLock();
 
            while (Pfn1 != (PMMPFN)LIST_HEAD)
            {
                PageIndex = MiGetPfnEntryIndex(Pfn1);
                Pfn1 = (PMMPFN)Pfn1->u1.Flink;
                MiInsertPageInList(&MmZeroedPageListHead, PageIndex);
            }
        }
    }
}

Referenced by Phase1Initialization().

Variable Documentation

MmZeroingPageEvent

KEVENT MmZeroingPageEvent

Definition at line 20 of file zeropage.c.

Referenced by MiInsertPageInFreeList(), MmArmInitSystem(), and MmZeroPageThread().