newmm.h File Reference

#include <internal/arch/mm.h>

Include dependency graph for newmm.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_CACHE_SECTION_PAGE_TABLE
struct	_MM_REQUIRED_RESOURCES

Macros
#define	MM_SEGMENT_FINALIZE   (0x40000000)
#define	MIN(x, y)   (((x)<(y))?(x):(y))
#define	MAX(x, y)   (((x)>(y))?(x):(y))
#define	BALANCER_CAN_EVICT(Consumer)
#define	SEC_CACHE   (0x20000000)
#define	ENTRIES_PER_ELEMENT   256
#define	MiSimpleWrite(F, O, B, L, R)   _MiSimpleWrite(F,O,B,L,R,__FILE__,__LINE__)
#define	MiWriteBackPage(F, O, L, P)   _MiWriteBackPage(F,O,L,P,__FILE__,__LINE__)
#define	MiFlushMappedSection(A, O, S, D)   _MiFlushMappedSection(A,O,S,D,__FILE__,__LINE__)
#define	MiMapViewOfSegment(AddressSpace, Segment, BaseAddress, ViewSize, Protect, ViewOffset, AllocationType)    _MiMapViewOfSegment(AddressSpace,Segment,BaseAddress,ViewSize,Protect,ViewOffset,AllocationType,__FILE__,__LINE__)
#define	MmTryToLockAddressSpace(x)   _MmTryToLockAddressSpace(x,__FILE__,__LINE__)
#define	MiFlushMappedSection(A, O, S, D)   _MiFlushMappedSection(A,O,S,D,__FILE__,__LINE__)

Typedefs
typedef struct _CACHE_SECTION_PAGE_TABLE	CACHE_SECTION_PAGE_TABLE
typedef struct _CACHE_SECTION_PAGE_TABLE *	PCACHE_SECTION_PAGE_TABLE
typedef NTSTATUS(NTAPI *	AcquireResource) (PMMSUPPORT AddressSpace, struct _MEMORY_AREA *MemoryArea, struct _MM_REQUIRED_RESOURCES *Required)
typedef NTSTATUS(NTAPI *	NotPresentFaultHandler) (PMMSUPPORT AddressSpace, struct _MEMORY_AREA *MemoryArea, PVOID Address, BOOLEAN Locked, struct _MM_REQUIRED_RESOURCES *Required)
typedef NTSTATUS(NTAPI *	FaultHandler) (PMMSUPPORT AddressSpace, struct _MEMORY_AREA *MemoryArea, PVOID Address, struct _MM_REQUIRED_RESOURCES *Required)
typedef struct _MM_REQUIRED_RESOURCES	MM_REQUIRED_RESOURCES
typedef struct _MM_REQUIRED_RESOURCES *	PMM_REQUIRED_RESOURCES
typedef VOID(NTAPI *	FREE_SECTION_PAGE_FUN) (PMM_SECTION_SEGMENT Segment, PLARGE_INTEGER Offset)

Functions
NTSTATUS NTAPI	MmCreateCacheSection (PSECTION *SectionObject, ACCESS_MASK DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes, PLARGE_INTEGER UMaximumSize, ULONG SectionPageProtection, ULONG AllocationAttributes, PFILE_OBJECT FileObject)
PFN_NUMBER NTAPI	MmWithdrawSectionPage (PMM_SECTION_SEGMENT Segment, PLARGE_INTEGER FileOffset, BOOLEAN *Dirty)
NTSTATUS NTAPI	MmFinalizeSectionPageOut (PMM_SECTION_SEGMENT Segment, PLARGE_INTEGER FileOffset, PFN_NUMBER Page, BOOLEAN Dirty)
VOID NTAPI	MiInitializeSectionPageTable (PMM_SECTION_SEGMENT Segment)
VOID NTAPI	MmFreePageTablesSectionSegment (PMM_SECTION_SEGMENT Segment, FREE_SECTION_PAGE_FUN FreePage)
NTSTATUS NTAPI	MmSetSectionAssociation (PFN_NUMBER Page, PMM_SECTION_SEGMENT Segment, PLARGE_INTEGER Offset)
VOID NTAPI	MmDeleteSectionAssociation (PFN_NUMBER Page)
NTSTATUS NTAPI	MmpPageOutPhysicalAddress (PFN_NUMBER Page)
NTSTATUS	MmspWaitForFileLock (PFILE_OBJECT File)
NTSTATUS NTAPI	MiSimpleRead (PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, PVOID Buffer, ULONG Length, BOOLEAN Paging, PIO_STATUS_BLOCK ReadStatus)
NTSTATUS NTAPI	_MiSimpleWrite (PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, PVOID Buffer, ULONG Length, PIO_STATUS_BLOCK ReadStatus, const char *file, int line)
NTSTATUS NTAPI	_MiWriteBackPage (PFILE_OBJECT FileObject, PLARGE_INTEGER Offset, ULONG Length, PFN_NUMBER Page, const char *File, int Line)
NTSTATUS NTAPI	MmAccessFaultCacheSection (KPROCESSOR_MODE Mode, ULONG_PTR Address, BOOLEAN FromMdl)
NTSTATUS NTAPI	MiReadFilePage (PMMSUPPORT AddressSpace, PMEMORY_AREA MemoryArea, PMM_REQUIRED_RESOURCES RequiredResources)
NTSTATUS NTAPI	MiGetOnePage (PMMSUPPORT AddressSpace, PMEMORY_AREA MemoryArea, PMM_REQUIRED_RESOURCES RequiredResources)
NTSTATUS NTAPI	MiSwapInPage (PMMSUPPORT AddressSpace, PMEMORY_AREA MemoryArea, PMM_REQUIRED_RESOURCES RequiredResources)
NTSTATUS NTAPI	MiWriteSwapPage (PMMSUPPORT AddressSpace, PMEMORY_AREA MemoryArea, PMM_REQUIRED_RESOURCES Resources)
NTSTATUS NTAPI	MiWriteFilePage (PMMSUPPORT AddressSpace, PMEMORY_AREA MemoryArea, PMM_REQUIRED_RESOURCES Resources)
VOID NTAPI	MiFreeSegmentPage (PMM_SECTION_SEGMENT Segment, PLARGE_INTEGER FileOffset)
	_Success_ (1) _When_(return ==STATUS_MORE_PROCESSING_REQUIRED
	_At_ (Required->DoAcquisition, _Post_notnull_)) NTSTATUS NTAPI MiCowCacheSectionPage(_In_ PMMSUPPORT AddressSpace
VOID	MmPageOutDeleteMapping (PVOID Context, PEPROCESS Process, PVOID Address)
VOID	MmFreeCacheSectionPage (PVOID Context, MEMORY_AREA *MemoryArea, PVOID Address, PFN_NUMBER Page, SWAPENTRY SwapEntry, BOOLEAN Dirty)
NTSTATUS NTAPI	_MiFlushMappedSection (PVOID BaseAddress, PLARGE_INTEGER BaseOffset, PLARGE_INTEGER FileSize, BOOLEAN Dirty, const char *File, int Line)
VOID NTAPI	MmFinalizeSegment (PMM_SECTION_SEGMENT Segment)
VOID NTAPI	MmFreeSectionSegments (PFILE_OBJECT FileObject)
NTSTATUS NTAPI	MmMapCacheViewInSystemSpaceAtOffset (IN PMM_SECTION_SEGMENT Segment, OUT PVOID *MappedBase, IN PLARGE_INTEGER ViewOffset, IN OUT PULONG ViewSize)
NTSTATUS NTAPI	_MiMapViewOfSegment (PMMSUPPORT AddressSpace, PMM_SECTION_SEGMENT Segment, PVOID *BaseAddress, SIZE_T ViewSize, ULONG Protect, PLARGE_INTEGER ViewOffset, ULONG AllocationType, const char *file, int line)
NTSTATUS NTAPI	MmUnmapViewOfCacheSegment (PMMSUPPORT AddressSpace, PVOID BaseAddress)
NTSTATUS NTAPI	MmUnmapCacheViewInSystemSpace (PVOID Address)
NTSTATUS NTAPI	MmPageOutPageFileView (PMMSUPPORT AddressSpace, PMEMORY_AREA MemoryArea, PVOID Address, PMM_REQUIRED_RESOURCES Required)
FORCEINLINE BOOLEAN	_MmTryToLockAddressSpace (IN PMMSUPPORT AddressSpace, const char *file, int line)
NTSTATUS NTAPI	MiWidenSegment (PMMSUPPORT AddressSpace, PMEMORY_AREA MemoryArea, PMM_REQUIRED_RESOURCES RequiredResources)
NTSTATUS NTAPI	MiSwapInSectionPage (PMMSUPPORT AddressSpace, PMEMORY_AREA MemoryArea, PMM_REQUIRED_RESOURCES RequiredResources)
NTSTATUS NTAPI	MmExtendCacheSection (PSECTION Section, PLARGE_INTEGER NewSize, BOOLEAN ExtendFile)
PVOID NTAPI	MmGetSegmentRmap (PFN_NUMBER Page, PULONG RawOffset)
NTSTATUS NTAPI	MmNotPresentFaultCacheSection (KPROCESSOR_MODE Mode, ULONG_PTR Address, BOOLEAN FromMdl)
ULONG NTAPI	MiCacheEvictPages (PMM_SECTION_SEGMENT Segment, ULONG Target)
NTSTATUS	MiRosTrimCache (ULONG Target, ULONG Priority, PULONG NrFreed)

Variables
KEVENT	MmWaitPageEvent
_In_ PMEMORY_AREA	MemoryArea
_In_ PMEMORY_AREA _In_ PVOID	Address
_In_ PMEMORY_AREA _In_ PVOID _In_ BOOLEAN	Locked
_In_ PMEMORY_AREA _In_ PVOID _In_ BOOLEAN _Inout_ PMM_REQUIRED_RESOURCES	Required

Macro Definition Documentation

BALANCER_CAN_EVICT

#define BALANCER_CAN_EVICT

(

Consumer

)

Value:

    (((Consumer) == MC_USER) || \
     ((Consumer) == MC_CACHE))

Definition at line 14 of file newmm.h.

ENTRIES_PER_ELEMENT

#define ENTRIES_PER_ELEMENT   256

Definition at line 21 of file newmm.h.

MAX

#define MAX	(		x,
			y
	)		(((x)>(y))?(x):(y))

Definition at line 10 of file newmm.h.

MiFlushMappedSection [1/2]

#define MiFlushMappedSection	(		A,
			O,
			S,
			D
	)		_MiFlushMappedSection(A,O,S,D,__FILE__,__LINE__)

Definition at line 333 of file newmm.h.

MiFlushMappedSection [2/2]

#define MiFlushMappedSection	(		A,
			O,
			S,
			D
	)		_MiFlushMappedSection(A,O,S,D,__FILE__,__LINE__)

Definition at line 333 of file newmm.h.

MiMapViewOfSegment

#define MiMapViewOfSegment	(		AddressSpace,
			Segment,
			BaseAddress,
			ViewSize,
			Protect,
			ViewOffset,
			AllocationType
	)		_MiMapViewOfSegment(AddressSpace,Segment,BaseAddress,ViewSize,Protect,ViewOffset,AllocationType,__FILE__,__LINE__)

Definition at line 263 of file newmm.h.

MIN

#define MIN	(		x,
			y
	)		(((x)<(y))?(x):(y))

Definition at line 9 of file newmm.h.

MiSimpleWrite

#define MiSimpleWrite	(		F,
			O,
			B,
			L,
			R
	)		_MiSimpleWrite(F,O,B,L,R,__FILE__,__LINE__)

Definition at line 145 of file newmm.h.

MiWriteBackPage

#define MiWriteBackPage	(		F,
			O,
			L,
			P
	)		_MiWriteBackPage(F,O,L,P,__FILE__,__LINE__)

Definition at line 156 of file newmm.h.

MM_SEGMENT_FINALIZE

#define MM_SEGMENT_FINALIZE   (0x40000000)

Definition at line 6 of file newmm.h.

MmTryToLockAddressSpace

#define MmTryToLockAddressSpace

(

x

)

_MmTryToLockAddressSpace(x,__FILE__,__LINE__)

Definition at line 304 of file newmm.h.

SEC_CACHE

#define SEC_CACHE   (0x20000000)

Definition at line 18 of file newmm.h.

Typedef Documentation

AcquireResource

typedef NTSTATUS(NTAPI * AcquireResource) (PMMSUPPORT AddressSpace, struct _MEMORY_AREA *MemoryArea, struct _MM_REQUIRED_RESOURCES *Required)

Definition at line 35 of file newmm.h.

CACHE_SECTION_PAGE_TABLE

typedef struct _CACHE_SECTION_PAGE_TABLE CACHE_SECTION_PAGE_TABLE

FaultHandler

typedef NTSTATUS(NTAPI * FaultHandler) (PMMSUPPORT AddressSpace, struct _MEMORY_AREA *MemoryArea, PVOID Address, struct _MM_REQUIRED_RESOURCES *Required)

Definition at line 47 of file newmm.h.

FREE_SECTION_PAGE_FUN

typedef VOID(NTAPI * FREE_SECTION_PAGE_FUN) (PMM_SECTION_SEGMENT Segment, PLARGE_INTEGER Offset)

Definition at line 98 of file newmm.h.

MM_REQUIRED_RESOURCES

typedef struct _MM_REQUIRED_RESOURCES MM_REQUIRED_RESOURCES

NotPresentFaultHandler

typedef NTSTATUS(NTAPI * NotPresentFaultHandler) (PMMSUPPORT AddressSpace, struct _MEMORY_AREA *MemoryArea, PVOID Address, BOOLEAN Locked, struct _MM_REQUIRED_RESOURCES *Required)

Definition at line 40 of file newmm.h.

PCACHE_SECTION_PAGE_TABLE

typedef struct _CACHE_SECTION_PAGE_TABLE * PCACHE_SECTION_PAGE_TABLE

PMM_REQUIRED_RESOURCES

typedef struct _MM_REQUIRED_RESOURCES * PMM_REQUIRED_RESOURCES

Function Documentation

_At_()

_At_	(	Required->	DoAcquisition,
		_Post_notnull_
	)

_MiFlushMappedSection()

NTSTATUS NTAPI _MiFlushMappedSection	(	PVOID	BaseAddress,
		PLARGE_INTEGER	BaseOffset,
		PLARGE_INTEGER	FileSize,
		BOOLEAN	Dirty,
		const char *	File,
		int	Line
	)

_MiMapViewOfSegment()

NTSTATUS NTAPI _MiMapViewOfSegment	(	PMMSUPPORT	AddressSpace,
		PMM_SECTION_SEGMENT	Segment,
		PVOID *	BaseAddress,
		SIZE_T	ViewSize,
		ULONG	Protect,
		PLARGE_INTEGER	ViewOffset,
		ULONG	AllocationType,
		const char *	file,
		int	line
	)

Referenced by MmMapViewOfSegment().

_MiSimpleWrite()

NTSTATUS NTAPI _MiSimpleWrite	(	PFILE_OBJECT	FileObject,
		PLARGE_INTEGER	FileOffset,
		PVOID	Buffer,
		ULONG	Length,
		PIO_STATUS_BLOCK	ReadStatus,
		const char *	file,
		int	line
	)

_MiWriteBackPage()

NTSTATUS NTAPI _MiWriteBackPage	(	PFILE_OBJECT	FileObject,
		PLARGE_INTEGER	Offset,
		ULONG	Length,
		PFN_NUMBER	Page,
		const char *	File,
		int	Line
	)

_MmTryToLockAddressSpace()

FORCEINLINE BOOLEAN _MmTryToLockAddressSpace	(	IN PMMSUPPORT	AddressSpace,
		const char *	file,
		int	line
	)

Definition at line 295 of file newmm.h.

{
    BOOLEAN Result = KeTryToAcquireGuardedMutex(&CONTAINING_RECORD(AddressSpace, EPROCESS, Vm)->AddressCreationLock);
    //DbgPrint("(%s:%d) Try Lock Address Space %x -> %s\n", file, line, AddressSpace, Result ? "true" : "false");
    return Result;
}

_Success_()

_Success_

(

1

)

==STATUS_MORE_PROCESSING_REQUIRED

MiCacheEvictPages()

ULONG NTAPI MiCacheEvictPages	(	PMM_SECTION_SEGMENT	Segment,
		ULONG	Target
	)

Definition at line 590 of file swapout.c.

{
    ULONG_PTR Entry;
    ULONG Result = 0, i, j;
    NTSTATUS Status;
    PFN_NUMBER Page;
    LARGE_INTEGER Offset;
 
    MmLockSectionSegment(Segment);
 
    for (i = 0; i < RtlNumberGenericTableElements(&Segment->PageTable); i++) {
 
        PCACHE_SECTION_PAGE_TABLE Element = RtlGetElementGenericTable(&Segment->PageTable,
                                                                      i);
 
        ASSERT(Element);
 
        Offset = Element->FileOffset;
        for (j = 0; j < ENTRIES_PER_ELEMENT; j++, Offset.QuadPart += PAGE_SIZE) {
            Entry = MmGetPageEntrySectionSegment(Segment, &Offset);
            if (Entry && !IS_SWAP_FROM_SSE(Entry)) {
                Page = PFN_FROM_SSE(Entry);
                MmUnlockSectionSegment(Segment);
                Status = MmpPageOutPhysicalAddress(Page);
                if (NT_SUCCESS(Status))
                    Result++;
                MmLockSectionSegment(Segment);
            }
        }
    }
 
    MmUnlockSectionSegment(Segment);
 
    return Result;
}

Referenced by MiRosTrimCache().

MiFreeSegmentPage()

VOID NTAPI MiFreeSegmentPage	(	PMM_SECTION_SEGMENT	Segment,
		PLARGE_INTEGER	FileOffset
	)

Definition at line 617 of file data.c.

{
    ULONG_PTR Entry;
    PFILE_OBJECT FileObject = Segment->FileObject;
 
    Entry = MmGetPageEntrySectionSegment(Segment, FileOffset);
    DPRINTC("MiFreeSegmentPage(%p:%I64x -> Entry %Ix\n",
            Segment,
            FileOffset->QuadPart,
            Entry);
 
    if (Entry && !IS_SWAP_FROM_SSE(Entry))
    {
        // The segment is carrying a dirty page.
        PFN_NUMBER OldPage = PFN_FROM_SSE(Entry);
        if (IS_DIRTY_SSE(Entry) && FileObject)
        {
            DPRINT("MiWriteBackPage(%p,%wZ,%I64x)\n",
                   Segment,
                   &FileObject->FileName,
                   FileOffset->QuadPart);
 
            MiWriteBackPage(FileObject, FileOffset, PAGE_SIZE, OldPage);
        }
        DPRINTC("Free page %Ix (off %I64x from %p) (ref ct %lu, ent %Ix, dirty? %s)\n",
                OldPage,
                FileOffset->QuadPart,
                Segment,
                MmGetReferenceCountPageWithoutLock(OldPage),
                Entry,
                IS_DIRTY_SSE(Entry) ? "true" : "false");
 
        MmSetPageEntrySectionSegment(Segment, FileOffset, 0);
        MmReleasePageMemoryConsumer(MC_CACHE, OldPage);
    }
    else if (IS_SWAP_FROM_SSE(Entry))
    {
        DPRINT("Free swap\n");
        MmFreeSwapPage(SWAPENTRY_FROM_SSE(Entry));
    }
 
    DPRINT("Done\n");
}

MiGetOnePage()

NTSTATUS NTAPI MiGetOnePage	(	PMMSUPPORT	AddressSpace,
		PMEMORY_AREA	MemoryArea,
		PMM_REQUIRED_RESOURCES	RequiredResources
	)

Definition at line 83 of file reqtools.c.

{
    ULONG i;
    NTSTATUS Status = STATUS_SUCCESS;
 
    for (i = 0; i < Required->Amount; i++)
    {
        DPRINTC("MiGetOnePage(%s:%d)\n", Required->File, Required->Line);
        Status = MmRequestPageMemoryConsumer(Required->Consumer,
                                             TRUE,
                                             &Required->Page[i]);
        if (!NT_SUCCESS(Status))
        {
            while (i > 0)
            {
                MmReleasePageMemoryConsumer(Required->Consumer,
                                            Required->Page[i-1]);
                i--;
            }
            return Status;
        }
    }
 
    return Status;
}

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().

MiReadFilePage()

NTSTATUS NTAPI MiReadFilePage	(	PMMSUPPORT	AddressSpace,
		PMEMORY_AREA	MemoryArea,
		PMM_REQUIRED_RESOURCES	RequiredResources
	)

Definition at line 133 of file reqtools.c.

{
    PFILE_OBJECT FileObject = RequiredResources->Context;
    PPFN_NUMBER Page = &RequiredResources->Page[RequiredResources->Offset];
    PLARGE_INTEGER FileOffset = &RequiredResources->FileOffset;
    NTSTATUS Status;
    PVOID PageBuf = NULL;
    KEVENT Event;
    IO_STATUS_BLOCK IOSB;
    UCHAR MdlBase[sizeof(MDL) + sizeof(ULONG)];
    PMDL Mdl = (PMDL)MdlBase;
    KIRQL OldIrql;
 
    DPRINTC("Pulling page %I64x from %wZ to %Ix\n",
            FileOffset->QuadPart,
            &FileObject->FileName,
            *Page);
 
    Status = MmRequestPageMemoryConsumer(RequiredResources->Consumer,
                                         TRUE,
                                         Page);
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Status: %x\n", Status);
        return Status;
    }
 
    MmInitializeMdl(Mdl, NULL, PAGE_SIZE);
    MmBuildMdlFromPages(Mdl, Page);
    Mdl->MdlFlags |= MDL_PAGES_LOCKED;
 
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
    Status = IoPageRead(FileObject, Mdl, FileOffset, &Event, &IOSB);
    if (Status == STATUS_PENDING)
    {
        KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
        Status = IOSB.Status;
    }
    if (Mdl->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA)
    {
        MmUnmapLockedPages (Mdl->MappedSystemVa, Mdl);
    }
 
    PageBuf = MiMapPageInHyperSpace(PsGetCurrentProcess(), *Page, &OldIrql);
    if (!PageBuf)
    {
        MmReleasePageMemoryConsumer(RequiredResources->Consumer, *Page);
        return STATUS_NO_MEMORY;
    }
 
    RtlZeroMemory((PCHAR)PageBuf+RequiredResources->Amount,
                  PAGE_SIZE-RequiredResources->Amount);
 
    MiUnmapPageInHyperSpace(PsGetCurrentProcess(), PageBuf, OldIrql);
 
    DPRINT("Read Status %x (Page %x)\n", Status, *Page);
 
    if (!NT_SUCCESS(Status))
    {
        MmReleasePageMemoryConsumer(RequiredResources->Consumer, *Page);
        DPRINT("Status: %x\n", Status);
        return Status;
    }
 
    return STATUS_SUCCESS;
}

MiRosTrimCache()

NTSTATUS MiRosTrimCache	(	ULONG	Target,
		ULONG	Priority,
		PULONG	NrFreed
	)

Definition at line 633 of file swapout.c.

{
    ULONG Freed;
    PLIST_ENTRY Entry;
    PMM_SECTION_SEGMENT Segment;
    *NrFreed = 0;
 
    DPRINT1("Need to trim %lu cache pages\n", Target);
    for (Entry = MiSegmentList.Flink;
         *NrFreed < Target && Entry != &MiSegmentList;
         Entry = Entry->Flink) {
        Segment = CONTAINING_RECORD(Entry, MM_SECTION_SEGMENT, ListOfSegments);
        /* Defer to MM to try recovering pages from it */
        Freed = MiCacheEvictPages(Segment, Target);
        *NrFreed += Freed;
    }
    DPRINT1("Evicted %lu cache pages\n", Target);
 
    if (!IsListEmpty(&MiSegmentList)) {
        Entry = MiSegmentList.Flink;
        RemoveEntryList(Entry);
        InsertTailList(&MiSegmentList, Entry);
    }
 
    return STATUS_SUCCESS;
}

Referenced by CcShutdownSystem().

MiSimpleRead()

NTSTATUS NTAPI MiSimpleRead	(	PFILE_OBJECT	FileObject,
		PLARGE_INTEGER	FileOffset,
		PVOID	Buffer,
		ULONG	Length,
		BOOLEAN	Paging,
		PIO_STATUS_BLOCK	ReadStatus
	)

Definition at line 109 of file io.c.

{
    NTSTATUS Status;
    PIRP Irp = NULL;
    KEVENT ReadWait;
    PDEVICE_OBJECT DeviceObject;
    PIO_STACK_LOCATION IrpSp;
 
    ASSERT(FileObject);
    ASSERT(FileOffset);
    ASSERT(Buffer);
    ASSERT(ReadStatus);
 
    DeviceObject = MmGetDeviceObjectForFile(FileObject);
    ReadStatus->Status = STATUS_INTERNAL_ERROR;
    ReadStatus->Information = 0;
 
    ASSERT(DeviceObject);
 
    DPRINT("PAGING READ: FileObject %p <%wZ> Offset %08x%08x Length %ul\n",
           FileObject,
           &FileObject->FileName,
           FileOffset->HighPart,
           FileOffset->LowPart,
           Length);
 
    KeInitializeEvent(&ReadWait, NotificationEvent, FALSE);
 
    Irp = IoBuildAsynchronousFsdRequest(IRP_MJ_READ,
                                        DeviceObject,
                                        Buffer,
                                        Length,
                                        FileOffset,
                                        ReadStatus);
 
    if (!Irp)
    {
        return STATUS_NO_MEMORY;
    }
 
    Irp->Flags |= (Paging ? IRP_PAGING_IO | IRP_SYNCHRONOUS_PAGING_IO | IRP_NOCACHE : 0) | IRP_SYNCHRONOUS_API;
 
    Irp->UserEvent = &ReadWait;
    Irp->Tail.Overlay.OriginalFileObject = FileObject;
    Irp->Tail.Overlay.Thread = PsGetCurrentThread();
    IrpSp = IoGetNextIrpStackLocation(Irp);
    IrpSp->Control |= SL_INVOKE_ON_SUCCESS | SL_INVOKE_ON_ERROR;
    IrpSp->FileObject = FileObject;
    IrpSp->CompletionRoutine = MiSimpleReadComplete;
 
    /* Non paging case, the FileObject will be dereferenced at completion */
    if (!Paging)
        ObReferenceObject(FileObject);
 
    Status = IoCallDriver(DeviceObject, Irp);
    if (Status == STATUS_PENDING)
    {
        DPRINT("KeWaitForSingleObject(&ReadWait)\n");
        if (!NT_SUCCESS(KeWaitForSingleObject(&ReadWait,
                                              Suspended,
                                              KernelMode,
                                              FALSE,
                                              NULL)))
        {
            DPRINT1("Warning: Failed to wait for synchronous IRP\n");
            ASSERT(FALSE);
            return Status;
        }
    }
 
    DPRINT("Paging IO Done: %08x\n", ReadStatus->Status);
    /* When "ReadStatus->Information > 0" is false and "ReadStatus->Status == STATUS_END_OF_FILE" is true
     * it means that read pointer is out of file, so we must fail */
    Status = ReadStatus->Status == STATUS_END_OF_FILE && ReadStatus->Information > 0 ? STATUS_SUCCESS : ReadStatus->Status;
    return Status;
}

Referenced by CcZeroData(), and ExeFmtpReadFile().

MiSwapInPage()

NTSTATUS NTAPI MiSwapInPage	(	PMMSUPPORT	AddressSpace,
		PMEMORY_AREA	MemoryArea,
		PMM_REQUIRED_RESOURCES	RequiredResources
	)

Definition at line 220 of file reqtools.c.

{
    NTSTATUS Status;
 
    Status = MmRequestPageMemoryConsumer(Resources->Consumer,
                                         TRUE,
                                         &Resources->Page[Resources->Offset]);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("MmRequestPageMemoryConsumer failed, status = %x\n", Status);
        return Status;
    }
 
    Status = MmReadFromSwapPage(Resources->SwapEntry,
                                Resources->Page[Resources->Offset]);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("MmReadFromSwapPage failed, status = %x\n", Status);
        return Status;
    }
 
    MmSetSavedSwapEntryPage(Resources->Page[Resources->Offset],
                            Resources->SwapEntry);
 
    DPRINT1("MiSwapInPage(%x,%x)\n",
            Resources->Page[Resources->Offset],
            Resources->SwapEntry);
 
    return Status;
}

MiSwapInSectionPage()

NTSTATUS NTAPI MiSwapInSectionPage	(	PMMSUPPORT	AddressSpace,
		PMEMORY_AREA	MemoryArea,
		PMM_REQUIRED_RESOURCES	RequiredResources
	)

MiWidenSegment()

NTSTATUS NTAPI MiWidenSegment	(	PMMSUPPORT	AddressSpace,
		PMEMORY_AREA	MemoryArea,
		PMM_REQUIRED_RESOURCES	RequiredResources
	)

MiWriteFilePage()

NTSTATUS NTAPI MiWriteFilePage	(	PMMSUPPORT	AddressSpace,
		PMEMORY_AREA	MemoryArea,
		PMM_REQUIRED_RESOURCES	Resources
	)

Definition at line 271 of file reqtools.c.

{
    DPRINT1("MiWriteFilePage(%x,%x)\n",
            Required->Page[Required->Offset],
            Required->FileOffset.LowPart);
 
    return MiWriteBackPage(Required->Context,
                           &Required->FileOffset,
                           PAGE_SIZE,
                           Required->Page[Required->Offset]);
}

MiWriteSwapPage()

NTSTATUS NTAPI MiWriteSwapPage	(	PMMSUPPORT	AddressSpace,
		PMEMORY_AREA	MemoryArea,
		PMM_REQUIRED_RESOURCES	Resources
	)

MmAccessFaultCacheSection()

NTSTATUS NTAPI MmAccessFaultCacheSection	(	KPROCESSOR_MODE	Mode,
		ULONG_PTR	Address,
		BOOLEAN	FromMdl
	)

Referenced by MmpAccessFault().

MmCreateCacheSection()

NTSTATUS NTAPI MmCreateCacheSection	(	PSECTION *	SectionObject,
		ACCESS_MASK	DesiredAccess,
		POBJECT_ATTRIBUTES	ObjectAttributes,
		PLARGE_INTEGER	UMaximumSize,
		ULONG	SectionPageProtection,
		ULONG	AllocationAttributes,
		PFILE_OBJECT	FileObject
	)

Referenced by MmCreateSection().

MmDeleteSectionAssociation()

VOID NTAPI MmDeleteSectionAssociation

(

PFN_NUMBER

Page

)

Definition at line 506 of file rmap.c.

{
    PMM_RMAP_ENTRY current_entry, previous_entry;
    KIRQL OldIrql = MiAcquirePfnLock();
 
    previous_entry = NULL;
    current_entry = MmGetRmapListHeadPage(Page);
    while (current_entry != NULL)
    {
        if (RMAP_IS_SEGMENT(current_entry->Address))
        {
            if (previous_entry == NULL)
            {
                MmSetRmapListHeadPage(Page, current_entry->Next);
            }
            else
            {
                previous_entry->Next = current_entry->Next;
            }
            MiReleasePfnLock(OldIrql);
            ExFreeToNPagedLookasideList(&RmapLookasideList, current_entry);
            return;
        }
        previous_entry = current_entry;
        current_entry = current_entry->Next;
    }
    MiReleasePfnLock(OldIrql);
}

Referenced by _MmSetPageEntrySectionSegment().

MmExtendCacheSection()

NTSTATUS NTAPI MmExtendCacheSection	(	PSECTION	Section,
		PLARGE_INTEGER	NewSize,
		BOOLEAN	ExtendFile
	)

Referenced by CcSetFileSizes().

MmFinalizeSectionPageOut()

NTSTATUS NTAPI MmFinalizeSectionPageOut	(	PMM_SECTION_SEGMENT	Segment,
		PLARGE_INTEGER	FileOffset,
		PFN_NUMBER	Page,
		BOOLEAN	Dirty
	)

Definition at line 165 of file swapout.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    BOOLEAN WriteZero = FALSE, WritePage = FALSE;
    SWAPENTRY Swap = MmGetSavedSwapEntryPage(Page);
 
    /* Bail early if the reference count isn't where we need it */
    if (MmGetReferenceCountPageWithoutLock(Page) != 1)
    {
        DPRINT1("Cannot page out locked page %x with ref count %lu\n",
                Page,
                MmGetReferenceCountPageWithoutLock(Page));
        return STATUS_UNSUCCESSFUL;
    }
 
    MmLockSectionSegment(Segment);
    (void)InterlockedIncrementUL(&Segment->ReferenceCount);
 
    if (Dirty)
    {
        DPRINT("Finalize (dirty) Segment %p Page %x\n", Segment, Page);
        DPRINT("Segment->FileObject %p\n", Segment->FileObject);
        DPRINT("Segment->Flags %x\n", Segment->Flags);
 
        WriteZero = TRUE;
        WritePage = TRUE;
    }
    else
    {
        WriteZero = TRUE;
    }
 
    DPRINT("Status %x\n", Status);
 
    MmUnlockSectionSegment(Segment);
 
    if (WritePage)
    {
        DPRINT("MiWriteBackPage(Segment %p FileObject %p Offset %x)\n",
               Segment,
               Segment->FileObject,
               FileOffset->LowPart);
 
        Status = MiWriteBackPage(Segment->FileObject,
                                 FileOffset,
                                 PAGE_SIZE,
                                 Page);
    }
 
    MmLockSectionSegment(Segment);
 
    if (WriteZero && NT_SUCCESS(Status))
    {
        DPRINT("Setting page entry in segment %p:%x to swap %x\n",
               Segment,
               FileOffset->LowPart,
               Swap);
 
        MmSetPageEntrySectionSegment(Segment,
                                     FileOffset,
                                     Swap ? MAKE_SWAP_SSE(Swap) : 0);
    }
    else
    {
        DPRINT("Setting page entry in segment %p:%x to page %x\n",
               Segment,
               FileOffset->LowPart,
               Page);
 
        MmSetPageEntrySectionSegment(Segment,
                                     FileOffset,
                                     Page ? (Dirty ? DIRTY_SSE(MAKE_PFN_SSE(Page)) : MAKE_PFN_SSE(Page)) : 0);
    }
 
    if (NT_SUCCESS(Status))
    {
        DPRINT("Removing page %x for real\n", Page);
        MmSetSavedSwapEntryPage(Page, 0);
        MmReleasePageMemoryConsumer(MC_CACHE, Page);
    }
 
    MmUnlockSectionSegment(Segment);
 
    if (InterlockedDecrementUL(&Segment->ReferenceCount) == 0)
    {
        MmFinalizeSegment(Segment);
    }
 
    /* Note: Writing may evict the segment... Nothing is guaranteed from here down */
    MiSetPageEvent(Segment, (ULONG_PTR)FileOffset->QuadPart);
 
    DPRINT("Status %x\n", Status);
    return Status;
}

Referenced by MmpPageOutPhysicalAddress().

MmFinalizeSegment()

VOID NTAPI MmFinalizeSegment

(

PMM_SECTION_SEGMENT

Segment

)

Referenced by MmFinalizeSectionPageOut(), and MmpPageOutPhysicalAddress().

MmFreeCacheSectionPage()

VOID MmFreeCacheSectionPage	(	PVOID	Context,
		MEMORY_AREA *	MemoryArea,
		PVOID	Address,
		PFN_NUMBER	Page,
		SWAPENTRY	SwapEntry,
		BOOLEAN	Dirty
	)

Definition at line 663 of file data.c.

{
    ULONG_PTR Entry;
    PVOID *ContextData = Context;
    PMMSUPPORT AddressSpace;
    PEPROCESS Process;
    PMM_SECTION_SEGMENT Segment;
    LARGE_INTEGER Offset;
 
    DPRINT("MmFreeSectionPage(%p,%p,%Ix,%Ix,%u)\n",
           MmGetAddressSpaceOwner(ContextData[0]),
           Address,
           Page,
           SwapEntry,
           Dirty);
 
    AddressSpace = ContextData[0];
    Process = MmGetAddressSpaceOwner(AddressSpace);
    Address = (PVOID)PAGE_ROUND_DOWN(Address);
    Segment = ContextData[1];
    Offset.QuadPart = (ULONG_PTR)Address - MA_GetStartingAddress(MemoryArea) +
                      MemoryArea->Data.SectionData.ViewOffset.QuadPart;
 
    Entry = MmGetPageEntrySectionSegment(Segment, &Offset);
 
    if (Page != 0 && PFN_FROM_SSE(Entry) == Page && Dirty)
    {
        DPRINT("Freeing section page %p:%I64x -> %Ix\n", Segment, Offset.QuadPart, Entry);
        MmSetPageEntrySectionSegment(Segment, &Offset, DIRTY_SSE(Entry));
    }
    if (Page)
    {
        DPRINT("Removing page %p:%I64x -> %x\n", Segment, Offset.QuadPart, Entry);
        MmSetSavedSwapEntryPage(Page, 0);
        MmDeleteRmap(Page, Process, Address);
        MmDeleteVirtualMapping(Process, Address, NULL, NULL);
        MmReleasePageMemoryConsumer(MC_CACHE, Page);
    }
    if (SwapEntry != 0)
    {
        MmFreeSwapPage(SwapEntry);
    }
}

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_().

MmFreeSectionSegments()

VOID NTAPI MmFreeSectionSegments

(

PFILE_OBJECT

FileObject

)

MmGetSegmentRmap()

PVOID NTAPI MmGetSegmentRmap	(	PFN_NUMBER	Page,
		PULONG	RawOffset
	)

Definition at line 468 of file rmap.c.

{
    PCACHE_SECTION_PAGE_TABLE Result = NULL;
    PMM_RMAP_ENTRY current_entry;//, previous_entry;
 
    /* Must hold the PFN lock */
    ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
 
    //previous_entry = NULL;
    current_entry = MmGetRmapListHeadPage(Page);
    while (current_entry != NULL)
    {
        if (RMAP_IS_SEGMENT(current_entry->Address))
        {
            Result = (PCACHE_SECTION_PAGE_TABLE)current_entry->Process;
            *RawOffset = (ULONG_PTR)current_entry->Address & ~RMAP_SEGMENT_MASK;
            if (*Result->Segment->Flags & MM_SEGMENT_INDELETE)
            {
                return NULL;
            }
 
            return Result;
        }
        //previous_entry = current_entry;
        current_entry = current_entry->Next;
    }
 
    return NULL;
}

Referenced by MmGetSectionAssociation().

MmMapCacheViewInSystemSpaceAtOffset()

NTSTATUS NTAPI MmMapCacheViewInSystemSpaceAtOffset	(	IN PMM_SECTION_SEGMENT	Segment,
		OUT PVOID *	MappedBase,
		IN PLARGE_INTEGER	ViewOffset,
		IN OUT PULONG	ViewSize
	)

Referenced by CcpMapData().

MmNotPresentFaultCacheSection()

NTSTATUS NTAPI MmNotPresentFaultCacheSection	(	KPROCESSOR_MODE	Mode,
		ULONG_PTR	Address,
		BOOLEAN	FromMdl
	)

Referenced by MmNotPresentFault().

MmPageOutDeleteMapping()

VOID MmPageOutDeleteMapping	(	PVOID	Context,
		PEPROCESS	Process,
		PVOID	Address
	)

MmPageOutPageFileView()

NTSTATUS NTAPI MmPageOutPageFileView	(	PMMSUPPORT	AddressSpace,
		PMEMORY_AREA	MemoryArea,
		PVOID	Address,
		PMM_REQUIRED_RESOURCES	Required
	)

MmpPageOutPhysicalAddress()

NTSTATUS NTAPI MmpPageOutPhysicalAddress

(

PFN_NUMBER

Page

)

Definition at line 345 of file swapout.c.

{
    BOOLEAN ProcRef = FALSE, PageDirty;
    PFN_NUMBER SectionPage = 0;
    PMM_RMAP_ENTRY entry;
    PMM_SECTION_SEGMENT Segment = NULL;
    LARGE_INTEGER FileOffset;
    PMEMORY_AREA MemoryArea;
    PMMSUPPORT AddressSpace = NULL;
    BOOLEAN Dirty = FALSE;
    PVOID Address = NULL;
    PEPROCESS Process = NULL;
    NTSTATUS Status = STATUS_SUCCESS;
    MM_REQUIRED_RESOURCES Resources = { 0 };
 
    DPRINTC("Page out %x (ref ct %x)\n", Page, MmGetReferenceCountPageWithoutLock(Page));
 
    ExAcquireFastMutex(&MiGlobalPageOperation);
    if ((Segment = MmGetSectionAssociation(Page, &FileOffset)))
    {
        DPRINTC("Withdrawing page (%x) %p:%x\n",
                Page,
                Segment,
                FileOffset.LowPart);
 
        SectionPage = MmWithdrawSectionPage(Segment, &FileOffset, &Dirty);
        DPRINTC("SectionPage %x\n", SectionPage);
 
        if (SectionPage == MM_WAIT_ENTRY || SectionPage == 0)
        {
            DPRINT1("In progress page out %x\n", SectionPage);
            ExReleaseFastMutex(&MiGlobalPageOperation);
            return STATUS_UNSUCCESSFUL;
        }
        else
        {
            ASSERT(SectionPage == Page);
        }
        Resources.State = Dirty ? 1 : 0;
    }
    else
    {
        DPRINT("No segment association for %x\n", Page);
    }
 
    Dirty = MmIsDirtyPageRmap(Page);
 
    DPRINTC("Trying to unmap all instances of %x\n", Page);
    ExAcquireFastMutex(&RmapListLock);
    entry = MmGetRmapListHeadPage(Page);
 
    // Entry and Segment might be null here in the case that the page
    // is new and is in the process of being swapped in
    if (!entry && !Segment)
    {
        Status = STATUS_UNSUCCESSFUL;
        DPRINT1("Page %x is in transit\n", Page);
        ExReleaseFastMutex(&RmapListLock);
        goto bail;
    }
 
    while (entry != NULL && NT_SUCCESS(Status))
    {
        Process = entry->Process;
        Address = entry->Address;
 
        DPRINTC("Process %p Address %p Page %x\n", Process, Address, Page);
 
        if (RMAP_IS_SEGMENT(Address))
        {
            entry = entry->Next;
            continue;
        }
 
        if (Process && Address < MmSystemRangeStart)
        {
            /* Make sure we don't try to page out part of an exiting process */
            if (PspIsProcessExiting(Process))
            {
                DPRINT("bail\n");
                ExReleaseFastMutex(&RmapListLock);
                goto bail;
            }
            ObReferenceObject(Process);
            ProcRef = TRUE;
            AddressSpace = &Process->Vm;
        }
        else
        {
            AddressSpace = MmGetKernelAddressSpace();
        }
        ExReleaseFastMutex(&RmapListLock);
 
        RtlZeroMemory(&Resources, sizeof(Resources));
 
        if ((((ULONG_PTR)Address) & 0xFFF) != 0)
        {
            KeBugCheck(MEMORY_MANAGEMENT);
        }
 
        do
        {
            MmLockAddressSpace(AddressSpace);
 
            MemoryArea = MmLocateMemoryAreaByAddress(AddressSpace, Address);
            if (MemoryArea == NULL || MemoryArea->DeleteInProgress)
            {
                Status = STATUS_UNSUCCESSFUL;
                MmUnlockAddressSpace(AddressSpace);
                DPRINTC("bail\n");
                goto bail;
            }
 
            DPRINTC("Type %x (%p -> %p)\n",
                    MemoryArea->Type,
                    MA_GetStartingAddress(MemoryArea),
                    MA_GetEndingAddress(MemoryArea));
 
            Resources.DoAcquisition = NULL;
            Resources.Page[0] = Page;
 
            ASSERT(KeGetCurrentIrql() <= APC_LEVEL);
 
            DPRINT("%p:%p, page %x %x\n",
                   Process,
                   Address,
                   Page,
                   Resources.Page[0]);
 
            PageDirty = FALSE;
 
            Status = MmPageOutCacheSection(AddressSpace,
                                           MemoryArea,
                                           Address,
                                           &PageDirty,
                                           &Resources);
 
            Dirty |= PageDirty;
            DPRINT("%x\n", Status);
 
            ASSERT(KeGetCurrentIrql() <= APC_LEVEL);
 
            MmUnlockAddressSpace(AddressSpace);
 
            if (Status == STATUS_SUCCESS + 1)
            {
                // Wait page ... the other guy has it, so we'll just fail for now
                DPRINT1("Wait entry ... can't continue\n");
                Status = STATUS_UNSUCCESSFUL;
                goto bail;
            }
            else if (Status == STATUS_MORE_PROCESSING_REQUIRED)
            {
                DPRINTC("DoAcquisition %p\n", Resources.DoAcquisition);
 
                Status = Resources.DoAcquisition(AddressSpace,
                                                 MemoryArea,
                                                 &Resources);
 
                DPRINTC("Status %x\n", Status);
                if (!NT_SUCCESS(Status))
                {
                    DPRINT1("bail\n");
                    goto bail;
                }
                else
                {
                    Status = STATUS_MM_RESTART_OPERATION;
                }
            }
        }
        while (Status == STATUS_MM_RESTART_OPERATION);
 
        if (ProcRef)
        {
            ObDereferenceObject(Process);
            ProcRef = FALSE;
        }
 
        ExAcquireFastMutex(&RmapListLock);
        ASSERT(!MM_IS_WAIT_PTE(MmGetPfnForProcess(Process, Address)));
        entry = MmGetRmapListHeadPage(Page);
 
        DPRINTC("Entry %p\n", entry);
    }
 
    ExReleaseFastMutex(&RmapListLock);
 
bail:
    DPRINTC("BAIL %x\n", Status);
 
    if (Segment)
    {
        ULONG RefCount;
 
        DPRINTC("About to finalize section page %x (%p:%x) Status %x %s\n",
                Page,
                Segment,
                FileOffset.LowPart,
                Status,
                Dirty ? "dirty" : "clean");
 
        if (!NT_SUCCESS(Status) ||
            !NT_SUCCESS(Status = MmFinalizeSectionPageOut(Segment,
                                                          &FileOffset,
                                                          Page,
                                                          Dirty)))
        {
            DPRINTC("Failed to page out %x, replacing %x at %x in segment %x\n",
                    SectionPage,
                    FileOffset.LowPart,
                    Segment);
 
            MmLockSectionSegment(Segment);
 
            MmSetPageEntrySectionSegment(Segment,
                                         &FileOffset,
                                         Dirty ? MAKE_PFN_SSE(Page) : DIRTY_SSE(MAKE_PFN_SSE(Page)));
 
            MmUnlockSectionSegment(Segment);
        }
 
        /* Alas, we had the last reference */
        if ((RefCount = InterlockedDecrementUL(&Segment->ReferenceCount)) == 0)
            MmFinalizeSegment(Segment);
    }
 
    if (ProcRef)
    {
        DPRINTC("Dereferencing process...\n");
        ObDereferenceObject(Process);
    }
 
    ExReleaseFastMutex(&MiGlobalPageOperation);
 
    DPRINTC("%s %x %x\n",
            NT_SUCCESS(Status) ? "Evicted" : "Spared",
            Page,
            Status);
 
    return NT_SUCCESS(Status) ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL;
}

Referenced by MiCacheEvictPages(), and MmPageOutPhysicalAddress().

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().

MmspWaitForFileLock()

NTSTATUS MmspWaitForFileLock

(

PFILE_OBJECT

File

)

Definition at line 907 of file section.c.

{
    return STATUS_SUCCESS;
    //return KeWaitForSingleObject(&File->Lock, 0, KernelMode, FALSE, NULL);
}

Referenced by MmCreateDataFileSection(), and MmCreateImageSection().

MmUnmapCacheViewInSystemSpace()

NTSTATUS NTAPI MmUnmapCacheViewInSystemSpace

(

PVOID

Address

)

Referenced by CcpDereferenceCache(), and CcpUnmapCache().

MmUnmapViewOfCacheSegment()

NTSTATUS NTAPI MmUnmapViewOfCacheSegment	(	PMMSUPPORT	AddressSpace,
		PVOID	BaseAddress
	)

Referenced by MiRosCleanupMemoryArea(), and MmUnmapViewOfSegment().

MmWithdrawSectionPage()

PFN_NUMBER NTAPI MmWithdrawSectionPage	(	PMM_SECTION_SEGMENT	Segment,
		PLARGE_INTEGER	FileOffset,
		BOOLEAN *	Dirty
	)

Definition at line 87 of file swapout.c.

{
    ULONG_PTR Entry;
 
    DPRINT("MmWithdrawSectionPage(%p,%08x%08x,%p)\n",
           Segment,
           FileOffset->HighPart,
           FileOffset->LowPart,
           Dirty);
 
    MmLockSectionSegment(Segment);
    Entry = MmGetPageEntrySectionSegment(Segment, FileOffset);
 
    *Dirty = !!IS_DIRTY_SSE(Entry);
 
    DPRINT("Withdraw %x (%x) of %wZ\n",
           FileOffset->LowPart,
           Entry,
           Segment->FileObject ? &Segment->FileObject->FileName : NULL);
 
    if (!Entry)
    {
        DPRINT("Stoeled!\n");
        MmUnlockSectionSegment(Segment);
        return 0;
    }
    else if (MM_IS_WAIT_PTE(Entry))
    {
        DPRINT("WAIT\n");
        MmUnlockSectionSegment(Segment);
        return MM_WAIT_ENTRY;
    }
    else if (Entry && !IS_SWAP_FROM_SSE(Entry))
    {
        DPRINT("Page %x\n", PFN_FROM_SSE(Entry));
 
        *Dirty |= (Entry & 2);
 
        MmSetPageEntrySectionSegment(Segment,
                                     FileOffset,
                                     MAKE_SWAP_SSE(MM_WAIT_ENTRY));
 
        MmUnlockSectionSegment(Segment);
        return PFN_FROM_SSE(Entry);
    }
    else
    {
        DPRINT1("SWAP ENTRY?! (%p:%08x%08x)\n",
                Segment,
                FileOffset->HighPart,
                FileOffset->LowPart);
 
        ASSERT(FALSE);
        MmUnlockSectionSegment(Segment);
        return 0;
    }
}

Referenced by MmpPageOutPhysicalAddress().

Variable Documentation

Address

_In_ MEMORY_AREA _In_ PVOID Address

Definition at line 208 of file newmm.h.

Locked

_In_ MEMORY_AREA _In_ PVOID _In_ BOOLEAN Locked

Definition at line 209 of file newmm.h.

Referenced by BroadcastOpen(), CcPerformReadAhead(), CcRosFlushDirtyPages(), CreateRedirectedFile(), Ext2FastIoWrite(), FsRtlAcknowledgeOplockBreak(), FsRtlRequestExclusiveOplock(), FsRtlRequestOplockII(), FsRtlWaitOnIrp(), CBDASignalStatistics::get_SignalLocked(), LdrAddRefDll(), LdrGetDllHandleEx(), MmAccessFaultSectionView(), MmNotPresentFaultSectionView(), RtlFreeHeap(), RxCommonQueryInformation(), and UDFMountVolume().

MemoryArea

_In_ MEMORY_AREA * MemoryArea

Definition at line 207 of file newmm.h.

Referenced by MiGetFileObjectForVad(), MiRosCleanupMemoryArea(), MiRosUnmapViewOfSection(), MmAccessFaultSectionView(), MmAlterViewAttributes(), MmCreateMemoryArea(), MmFreeCacheSectionPage(), MmFreeMemoryArea(), MmFreeSectionPage(), MmLocateMemoryAreaByRegion(), MmNotPresentFault(), MmNotPresentFaultSectionView(), MmpAccessFault(), MmPageOutCacheSection(), MmPageOutPhysicalAddress(), MmpPageOutPhysicalAddress(), MmProtectSectionView(), MmQuerySectionView(), MmUnmapViewInSystemSpace(), and MmUnmapViewOfSegment().

MmWaitPageEvent

KEVENT MmWaitPageEvent

extern

Definition at line 461 of file fault.c.

Required

_In_ MEMORY_AREA _In_ PVOID _In_ BOOLEAN _Inout_ PMM_REQUIRED_RESOURCES Required

Definition at line 210 of file newmm.h.

Referenced by MiGetOnePage(), MiWriteFilePage(), MmPageOutCacheSection(), profile_items_callback(), SepPrivilegeCheck(), and START_TEST().