balance.c File Reference

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

Include dependency graph for balance.c:

Go to the source code of this file.

Classes
struct	_MM_ALLOCATION_REQUEST

Macros
#define	NDEBUG

Typedefs
typedef struct _MM_ALLOCATION_REQUEST	MM_ALLOCATION_REQUEST
typedef struct _MM_ALLOCATION_REQUEST *	PMM_ALLOCATION_REQUEST

Functions
VOID NTAPI	MmInitializeBalancer (ULONG NrAvailablePages, ULONG NrSystemPages)
VOID NTAPI	MmInitializeMemoryConsumer (ULONG Consumer, NTSTATUS(*Trim)(ULONG Target, ULONG Priority, PULONG NrFreed))
VOID NTAPI	MiZeroPhysicalPage (IN PFN_NUMBER PageFrameIndex)
NTSTATUS NTAPI	MmReleasePageMemoryConsumer (ULONG Consumer, PFN_NUMBER Page)
ULONG NTAPI	MiTrimMemoryConsumer (ULONG Consumer, ULONG InitialTarget)
NTSTATUS	MmTrimUserMemory (ULONG Target, ULONG Priority, PULONG NrFreedPages)
VOID NTAPI	MmRebalanceMemoryConsumers (VOID)
NTSTATUS NTAPI	MmRequestPageMemoryConsumer (ULONG Consumer, BOOLEAN CanWait, PPFN_NUMBER AllocatedPage)
VOID NTAPI	MiBalancerThread (PVOID Unused)
VOID NTAPI	MiInitBalancerThread (VOID)

Variables
MM_MEMORY_CONSUMER	MiMemoryConsumers [MC_MAXIMUM]
static ULONG	MiMinimumAvailablePages
static ULONG	MiMinimumPagesPerRun
static CLIENT_ID	MiBalancerThreadId
static HANDLE	MiBalancerThreadHandle = NULL
static KEVENT	MiBalancerEvent
static KTIMER	MiBalancerTimer
static LONG	PageOutThreadActive

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 14 of file balance.c.

Typedef Documentation

MM_ALLOCATION_REQUEST

typedef struct _MM_ALLOCATION_REQUEST MM_ALLOCATION_REQUEST

PMM_ALLOCATION_REQUEST

typedef struct _MM_ALLOCATION_REQUEST * PMM_ALLOCATION_REQUEST

Function Documentation

MiBalancerThread()

VOID NTAPI MiBalancerThread

(

PVOID

Unused

)

Definition at line 305 of file balance.c.

{
    PVOID WaitObjects[2];
    NTSTATUS Status;
    ULONG i;
 
    WaitObjects[0] = &MiBalancerEvent;
    WaitObjects[1] = &MiBalancerTimer;
 
    while (1)
    {
        Status = KeWaitForMultipleObjects(2,
                                          WaitObjects,
                                          WaitAny,
                                          Executive,
                                          KernelMode,
                                          FALSE,
                                          NULL,
                                          NULL);
 
        if (Status == STATUS_WAIT_0 || Status == STATUS_WAIT_1)
        {
            ULONG InitialTarget = 0;
 
            do
            {
                ULONG OldTarget = InitialTarget;
 
                /* Trim each consumer */
                for (i = 0; i < MC_MAXIMUM; i++)
                {
                    InitialTarget = MiTrimMemoryConsumer(i, InitialTarget);
                }
 
                /* No pages left to swap! */
                if (InitialTarget != 0 &&
                        InitialTarget == OldTarget)
                {
                    /* Game over */
                    KeBugCheck(NO_PAGES_AVAILABLE);
                }
            }
            while (InitialTarget != 0);
 
            if (Status == STATUS_WAIT_0)
                InterlockedDecrement(&PageOutThreadActive);
        }
        else
        {
            DPRINT1("KeWaitForMultipleObjects failed, status = %x\n", Status);
            KeBugCheck(MEMORY_MANAGEMENT);
        }
    }
}

Referenced by MiInitBalancerThread().

MiInitBalancerThread()

VOID NTAPI MiInitBalancerThread

(

VOID

)

Definition at line 363 of file balance.c.

{
    KPRIORITY Priority;
    NTSTATUS Status;
    LARGE_INTEGER Timeout;
 
    KeInitializeEvent(&MiBalancerEvent, SynchronizationEvent, FALSE);
    KeInitializeTimerEx(&MiBalancerTimer, SynchronizationTimer);
 
    Timeout.QuadPart = -20000000; /* 2 sec */
    KeSetTimerEx(&MiBalancerTimer,
                 Timeout,
                 2000,         /* 2 sec */
                 NULL);
 
    Status = PsCreateSystemThread(&MiBalancerThreadHandle,
                                  THREAD_ALL_ACCESS,
                                  NULL,
                                  NULL,
                                  &MiBalancerThreadId,
                                  MiBalancerThread,
                                  NULL);
    if (!NT_SUCCESS(Status))
    {
        KeBugCheck(MEMORY_MANAGEMENT);
    }
 
    Priority = LOW_REALTIME_PRIORITY + 1;
    NtSetInformationThread(MiBalancerThreadHandle,
                           ThreadPriority,
                           &Priority,
                           sizeof(Priority));
 
}

Referenced by MmInitSystem().

MiTrimMemoryConsumer()

ULONG NTAPI MiTrimMemoryConsumer	(	ULONG	Consumer,
		ULONG	InitialTarget
	)

Definition at line 97 of file balance.c.

{
    ULONG Target = InitialTarget;
    ULONG NrFreedPages = 0;
    NTSTATUS Status;
 
    /* Make sure we can trim this consumer */
    if (!MiMemoryConsumers[Consumer].Trim)
    {
        /* Return the unmodified initial target */
        return InitialTarget;
    }
 
    if (MmAvailablePages < MiMinimumAvailablePages)
    {
        /* Global page limit exceeded */
        Target = (ULONG)max(Target, MiMinimumAvailablePages - MmAvailablePages);
    }
    else if (MiMemoryConsumers[Consumer].PagesUsed > MiMemoryConsumers[Consumer].PagesTarget)
    {
        /* Consumer page limit exceeded */
        Target = max(Target, MiMemoryConsumers[Consumer].PagesUsed - MiMemoryConsumers[Consumer].PagesTarget);
    }
 
    if (Target)
    {
        /* Now swap the pages out */
        Status = MiMemoryConsumers[Consumer].Trim(Target, MmAvailablePages < MiMinimumAvailablePages, &NrFreedPages);
 
        DPRINT("Trimming consumer %lu: Freed %lu pages with a target of %lu pages\n", Consumer, NrFreedPages, Target);
 
        if (!NT_SUCCESS(Status))
        {
            KeBugCheck(MEMORY_MANAGEMENT);
        }
    }
 
    /* Return the page count needed to be freed to meet the initial target */
    return (InitialTarget > NrFreedPages) ? (InitialTarget - NrFreedPages) : 0;
}

Referenced by MiBalancerThread().

MiZeroPhysicalPage()

VOID NTAPI MiZeroPhysicalPage

(

IN PFN_NUMBER

PageFrameIndex

)

Definition at line 122 of file pfnlist.c.

{
    KIRQL OldIrql;
    PVOID VirtualAddress;
    PEPROCESS Process = PsGetCurrentProcess();
 
    /* Map in hyperspace, then wipe it using XMMI or MEMSET */
    VirtualAddress = MiMapPageInHyperSpace(Process, PageFrameIndex, &OldIrql);
    ASSERT(VirtualAddress);
    KeZeroPages(VirtualAddress, PAGE_SIZE);
    MiUnmapPageInHyperSpace(Process, VirtualAddress, OldIrql);
}

Referenced by MiRemoveZeroPage().

MmInitializeBalancer()

VOID NTAPI MmInitializeBalancer	(	ULONG	NrAvailablePages,
		ULONG	NrSystemPages
	)

Definition at line 45 of file balance.c.

{
    memset(MiMemoryConsumers, 0, sizeof(MiMemoryConsumers));
 
    /* Set up targets. */
    MiMinimumAvailablePages = 256;
    MiMinimumPagesPerRun = 256;
    MiMemoryConsumers[MC_USER].PagesTarget = NrAvailablePages / 2;
}

Referenced by MiInitMachineDependent().

MmInitializeMemoryConsumer()

VOID NTAPI MmInitializeMemoryConsumer	(	ULONG	Consumer,
		NTSTATUS(*)(ULONG Target, ULONG Priority, PULONG NrFreed)	Trim
	)

Definition at line 58 of file balance.c.

{
    MiMemoryConsumers[Consumer].Trim = Trim;
}

Referenced by MmInitSystem().

MmRebalanceMemoryConsumers()

VOID NTAPI MmRebalanceMemoryConsumers

(

VOID

)

Definition at line 271 of file balance.c.

{
    // if (InterlockedCompareExchange(&PageOutThreadActive, 0, 1) == 0)
    {
        KeSetEvent(&MiBalancerEvent, IO_NO_INCREMENT, FALSE);
    }
}

Referenced by MiDecrementAvailablePages().

MmReleasePageMemoryConsumer()

NTSTATUS NTAPI MmReleasePageMemoryConsumer	(	ULONG	Consumer,
		PFN_NUMBER	Page
	)

Definition at line 73 of file balance.c.

{
    KIRQL OldIrql;
 
    if (Page == 0)
    {
        DPRINT1("Tried to release page zero.\n");
        KeBugCheck(MEMORY_MANAGEMENT);
    }
 
    (void)InterlockedDecrementUL(&MiMemoryConsumers[Consumer].PagesUsed);
    UpdateTotalCommittedPages(-1);
 
    OldIrql = MiAcquirePfnLock();
 
    MmDereferencePage(Page);
 
    MiReleasePfnLock(OldIrql);
 
    return(STATUS_SUCCESS);
}

Referenced by FreeSegmentPage(), if(), MiFreeSegmentPage(), MiGetOnePage(), MiPurgeImageSegment(), MiReadFilePage(), MmCreateProcessAddressSpace(), MmDeleteVirtualMapping(), MmFinalizeSectionPageOut(), MmFreeCacheSectionPage(), MmFreePageTable(), MmFreeSectionPage(), MmGetPageTableForProcess(), MmGetPageTableForProcessForPAE(), MmMakeSegmentResident(), MmPageOutCacheSection(), MmPageOutPhysicalAddress(), MmpFreePageFileSegment(), MmPurgeSegment(), and MmUnsharePageEntrySectionSegment().

MmRequestPageMemoryConsumer()

NTSTATUS NTAPI MmRequestPageMemoryConsumer	(	ULONG	Consumer,
		BOOLEAN	CanWait,
		PPFN_NUMBER	AllocatedPage
	)

Definition at line 281 of file balance.c.

{
    PFN_NUMBER Page;
 
    /* Update the target */
    InterlockedIncrementUL(&MiMemoryConsumers[Consumer].PagesUsed);
    UpdateTotalCommittedPages(1);
 
    /*
     * Actually allocate the page.
     */
    Page = MmAllocPage(Consumer);
    if (Page == 0)
    {
        KeBugCheck(NO_PAGES_AVAILABLE);
    }
    *AllocatedPage = Page;
 
    return(STATUS_SUCCESS);
}

Referenced by CcInitCacheZeroPage(), MiGetOnePage(), MiGetPageTableForProcess(), MiReadFilePage(), MiSwapInPage(), MmAccessFaultSectionView(), MmCreateProcessAddressSpace(), MmGetPageTableForProcess(), MmGetPageTableForProcessForPAE(), MmMakeSegmentResident(), and MmNotPresentFaultSectionView().

MmTrimUserMemory()

NTSTATUS MmTrimUserMemory	(	ULONG	Target,
		ULONG	Priority,
		PULONG	NrFreedPages
	)

Definition at line 139 of file balance.c.

{
    PFN_NUMBER CurrentPage;
    NTSTATUS Status;
 
    (*NrFreedPages) = 0;
 
    DPRINT1("MM BALANCER: %s\n", Priority ? "Paging out!" : "Removing access bit!");
 
    CurrentPage = MmGetLRUFirstUserPage();
    while (CurrentPage != 0 && Target > 0)
    {
        if (Priority)
        {
            Status = MmPageOutPhysicalAddress(CurrentPage);
            if (NT_SUCCESS(Status))
            {
                DPRINT("Succeeded\n");
                Target--;
                (*NrFreedPages)++;
            }
        }
        else
        {
            /* When not paging-out agressively, just reset the accessed bit */
            PEPROCESS Process = NULL;
            PVOID Address = NULL;
            BOOLEAN Accessed = FALSE;
 
            /*
             * We have a lock-ordering problem here. We cant lock the PFN DB before the Process address space.
             * So we must use circonvoluted loops.
             * Well...
             */
            while (TRUE)
            {
                KAPC_STATE ApcState;
                KIRQL OldIrql = MiAcquirePfnLock();
                PMM_RMAP_ENTRY Entry = MmGetRmapListHeadPage(CurrentPage);
                while (Entry)
                {
                    if (RMAP_IS_SEGMENT(Entry->Address))
                    {
                        Entry = Entry->Next;
                        continue;
                    }
 
                    /* Check that we didn't treat this entry before */
                    if (Entry->Address < Address)
                    {
                        Entry = Entry->Next;
                        continue;
                    }
 
                    if ((Entry->Address == Address) && (Entry->Process <= Process))
                    {
                        Entry = Entry->Next;
                        continue;
                    }
 
                    break;
                }
 
                if (!Entry)
                {
                    MiReleasePfnLock(OldIrql);
                    break;
                }
 
                Process = Entry->Process;
                Address = Entry->Address;
 
                ObReferenceObject(Process);
 
                if (!ExAcquireRundownProtection(&Process->RundownProtect))
                {
                    ObDereferenceObject(Process);
                    MiReleasePfnLock(OldIrql);
                    continue;
                }
 
                MiReleasePfnLock(OldIrql);
 
                KeStackAttachProcess(&Process->Pcb, &ApcState);
                MiLockProcessWorkingSet(Process, PsGetCurrentThread());
 
                /* Be sure this is still valid. */
                if (MmIsAddressValid(Address))
                {
                    PMMPTE Pte = MiAddressToPte(Address);
                    Accessed = Accessed || Pte->u.Hard.Accessed;
                    Pte->u.Hard.Accessed = 0;
 
                    /* There is no need to invalidate, the balancer thread is never on a user process */
                    //KeInvalidateTlbEntry(Address);
                }
 
                MiUnlockProcessWorkingSet(Process, PsGetCurrentThread());
 
                KeUnstackDetachProcess(&ApcState);
                ExReleaseRundownProtection(&Process->RundownProtect);
                ObDereferenceObject(Process);
            }
 
            if (!Accessed)
            {
                /* Nobody accessed this page since the last time we check. Time to clean up */
 
                Status = MmPageOutPhysicalAddress(CurrentPage);
                // DPRINT1("Paged-out one page: %s\n", NT_SUCCESS(Status) ? "Yes" : "No");
                (void)Status;
            }
 
            /* Done for this page. */
            Target--;
        }
 
        CurrentPage = MmGetLRUNextUserPage(CurrentPage, TRUE);
    }
 
    if (CurrentPage)
    {
        KIRQL OldIrql = MiAcquirePfnLock();
        MmDereferencePage(CurrentPage);
        MiReleasePfnLock(OldIrql);
    }
 
    return STATUS_SUCCESS;
}

Referenced by MmInitSystem().

Variable Documentation

MiBalancerEvent

KEVENT MiBalancerEvent

static

Definition at line 35 of file balance.c.

Referenced by MiBalancerThread(), MiInitBalancerThread(), and MmRebalanceMemoryConsumers().

MiBalancerThreadHandle

HANDLE MiBalancerThreadHandle = NULL

static

Definition at line 34 of file balance.c.

Referenced by MiInitBalancerThread().

MiBalancerThreadId

CLIENT_ID MiBalancerThreadId

static

Definition at line 33 of file balance.c.

Referenced by MiInitBalancerThread().

MiBalancerTimer

KTIMER MiBalancerTimer

static

Definition at line 36 of file balance.c.

Referenced by MiBalancerThread(), and MiInitBalancerThread().

MiMemoryConsumers

MM_MEMORY_CONSUMER MiMemoryConsumers[MC_MAXIMUM]

Definition at line 30 of file balance.c.

Referenced by MiTrimMemoryConsumer(), MmInitializeBalancer(), MmInitializeMemoryConsumer(), MmReleasePageMemoryConsumer(), MmRequestPageMemoryConsumer(), and QSI_DEF().

MiMinimumAvailablePages

ULONG MiMinimumAvailablePages

static

Definition at line 31 of file balance.c.

Referenced by MiTrimMemoryConsumer(), and MmInitializeBalancer().

MiMinimumPagesPerRun

ULONG MiMinimumPagesPerRun

static

Definition at line 32 of file balance.c.

Referenced by MmInitializeBalancer().

PageOutThreadActive

LONG PageOutThreadActive

static

Definition at line 38 of file balance.c.

Referenced by MiBalancerThread().