#include <internal/arch/mm.h>

Include dependency graph for newmm.h:

This graph shows which files directly or indirectly include 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)

Macro Definition Documentation

◆ BALANCER_CAN_EVICT

#define BALANCER_CAN_EVICT ( Consumer )

Value:

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

((Consumer) == MC_CACHE))

MC_USER

#define MC_USER

Definition: mm.h:114

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;
    }
}