Author: arty Date: Wed Nov 11 06:37:44 2009 New Revision: 44097
URL: http://svn.reactos.org/svn/reactos?rev=44097&view=rev Log: Forgotten files.
Added: branches/arty-newcc/ntoskrnl/include/internal/newcc.h (with props) branches/arty-newcc/ntoskrnl/include/internal/newmm.h (with props)
Added: branches/arty-newcc/ntoskrnl/include/internal/newcc.h URL: http://svn.reactos.org/svn/reactos/branches/arty-newcc/ntoskrnl/include/inte... ============================================================================== --- branches/arty-newcc/ntoskrnl/include/internal/newcc.h (added) +++ branches/arty-newcc/ntoskrnl/include/internal/newcc.h [iso-8859-1] Wed Nov 11 06:37:44 2009 @@ -1,0 +1,266 @@ +#ifndef __INCLUDE_INTERNAL_CC_H +#define __INCLUDE_INTERNAL_CC_H + +typedef struct _PF_SCENARIO_ID +{ + WCHAR ScenName[30]; + ULONG HashId; +} PF_SCENARIO_ID, *PPF_SCENARIO_ID; + +typedef struct _PF_LOG_ENTRY +{ + ULONG FileOffset:30; + ULONG Type:2; + union + { + ULONG FileKey; + ULONG FileSequenceNumber; + }; +} PF_LOG_ENTRY, *PPF_LOG_ENTRY; + +typedef struct _PFSN_LOG_ENTRIES +{ + LIST_ENTRY TraceBuffersLink; + LONG NumEntries; + LONG MaxEntries; + PF_LOG_ENTRY Entries[ANYSIZE_ARRAY]; +} PFSN_LOG_ENTRIES, *PPFSN_LOG_ENTRIES; + +typedef struct _PF_SECTION_INFO +{ + ULONG FileKey; + ULONG FileSequenceNumber; + ULONG FileIdLow; + ULONG FileIdHigh; +} PF_SECTION_INFO, *PPF_SECTION_INFO; + +typedef struct _PF_TRACE_HEADER +{ + ULONG Version; + ULONG MagicNumber; + ULONG Size; + PF_SCENARIO_ID ScenarioId; + ULONG ScenarioType; // PF_SCENARIO_TYPE + ULONG EventEntryIdxs[8]; + ULONG NumEventEntryIdxs; + ULONG TraceBufferOffset; + ULONG NumEntries; + ULONG SectionInfoOffset; + ULONG NumSections; + ULONG FaultsPerPeriod[10]; + LARGE_INTEGER LaunchTime; + ULONGLONG Reserved[5]; +} PF_TRACE_HEADER, *PPF_TRACE_HEADER; + +typedef struct _PFSN_TRACE_DUMP +{ + LIST_ENTRY CompletedTracesLink; + PF_TRACE_HEADER Trace; +} PFSN_TRACE_DUMP, *PPFSN_TRACE_DUMP; + +typedef struct _PFSN_TRACE_HEADER +{ + ULONG Magic; + LIST_ENTRY ActiveTracesLink; + PF_SCENARIO_ID ScenarioId; + ULONG ScenarioType; // PF_SCENARIO_TYPE + ULONG EventEntryIdxs[8]; + ULONG NumEventEntryIdxs; + PPFSN_LOG_ENTRIES CurrentTraceBuffer; + LIST_ENTRY TraceBuffersList; + ULONG NumTraceBuffers; + KSPIN_LOCK TraceBufferSpinLock; + KTIMER TraceTimer; + LARGE_INTEGER TraceTimerPeriod; + KDPC TraceTimerDpc; + KSPIN_LOCK TraceTimerSpinLock; + ULONG FaultsPerPeriod[10]; + LONG LastNumFaults; + LONG CurPeriod; + LONG NumFaults; + LONG MaxFaults; + PEPROCESS Process; + EX_RUNDOWN_REF RefCount; + WORK_QUEUE_ITEM EndTraceWorkItem; + LONG EndTraceCalled; + PPFSN_TRACE_DUMP TraceDump; + NTSTATUS TraceDumpStatus; + LARGE_INTEGER LaunchTime; + PPF_SECTION_INFO SectionInfo; + ULONG SectionInfoCount; +} PFSN_TRACE_HEADER, *PPFSN_TRACE_HEADER; + +typedef struct _PFSN_PREFETCHER_GLOBALS +{ + LIST_ENTRY ActiveTraces; + KSPIN_LOCK ActiveTracesLock; + PPFSN_TRACE_HEADER SystemWideTrace; + LIST_ENTRY CompletedTraces; + FAST_MUTEX CompletedTracesLock; + LONG NumCompletedTraces; + PKEVENT CompletedTracesEvent; + LONG ActivePrefetches; +} PFSN_PREFETCHER_GLOBALS, *PPFSN_PREFETCHER_GLOBALS; + +typedef struct _NOCC_BCB +{ + /* Public part */ + PUBLIC_BCB Bcb; + + struct _NOCC_CACHE_MAP *Map; + PSECTION_OBJECT SectionObject; + LARGE_INTEGER FileOffset; + ULONG Length; + PVOID BaseAddress; + BOOLEAN Dirty; + PVOID OwnerPointer; + + /* Reference counts */ + ULONG RefCount; + + LIST_ENTRY ThisFileList; + + KEVENT ExclusiveWait; + ULONG ExclusiveWaiter; + BOOLEAN Exclusive; +} NOCC_BCB, *PNOCC_BCB; + +typedef struct _NOCC_CACHE_MAP +{ + LIST_ENTRY AssociatedBcb; + LIST_ENTRY PrivateCacheMaps; + ULONG NumberOfMaps; + ULONG RefCount; + CC_FILE_SIZES FileSizes; + CACHE_MANAGER_CALLBACKS Callbacks; + PVOID LazyContext; +} NOCC_CACHE_MAP, *PNOCC_CACHE_MAP; + +VOID +NTAPI +CcPfInitializePrefetcher( + VOID +); + +VOID +NTAPI +CcMdlReadComplete2( + IN PMDL MemoryDescriptorList, + IN PFILE_OBJECT FileObject +); + +VOID +NTAPI +CcMdlWriteComplete2( + IN PFILE_OBJECT FileObject, + IN PLARGE_INTEGER FileOffset, + IN PMDL MdlChain +); + +VOID +NTAPI +CcInitView(VOID); + +VOID +NTAPI +CcpUnpinData(PNOCC_BCB Bcb); + +BOOLEAN +NTAPI +CcInitializeCacheManager(VOID); + +VOID +NTAPI +CcShutdownSystem(); + +VOID +NTAPI +CcInitCacheZeroPage(VOID); + +/* Called by section.c */ +BOOLEAN +NTAPI +CcFlushImageSection(PSECTION_OBJECT_POINTERS SectionObjectPointer, MMFLUSH_TYPE FlushType); + +VOID +NTAPI +CcpFlushCache +(IN PNOCC_CACHE_MAP Map, + IN OPTIONAL PLARGE_INTEGER FileOffset, + IN ULONG Length, + OUT OPTIONAL PIO_STATUS_BLOCK IoStatus, + BOOLEAN Delete); + +BOOLEAN +NTAPI +CcGetFileSizes(PFILE_OBJECT FileObject, PCC_FILE_SIZES FileSizes); + +ULONG +NTAPI +CcpCountCacheSections(PNOCC_CACHE_MAP Map); + +BOOLEAN +NTAPI +CcpAcquireFileLock(PNOCC_CACHE_MAP Map); + +VOID +NTAPI +CcpReleaseFileLock(PNOCC_CACHE_MAP Map); + +/* + * Macro for generic cache manage bugchecking. Note that this macro assumes + * that the file name including extension is always longer than 4 characters. + */ +#define KEBUGCHECKCC \ + KEBUGCHECKEX(CACHE_MANAGER, \ + (*(ULONG*)(__FILE__ + sizeof(__FILE__) - 4) << 16) | \ + (__LINE__ & 0xFFFF), 0, 0, 0) + +/* Private data */ + +#define CACHE_SINGLE_FILE_MAX (16) +#define CACHE_OVERALL_SIZE (32 * 1024 * 1024) +#define CACHE_STRIPE VACB_MAPPING_GRANULARITY +#define CACHE_SHIFT 18 +#define CACHE_NUM_SECTIONS (CACHE_OVERALL_SIZE / CACHE_STRIPE) +#define CACHE_ROUND_UP(x) (((x) + (CACHE_STRIPE-1)) & ~(CACHE_STRIPE-1)) +#define CACHE_ROUND_DOWN(x) ((x) & ~(CACHE_STRIPE-1)) +#define CACHE_NEED_SECTIONS(OFFSET,LENGTH) \ + ((CACHE_ROUND_UP((OFFSET)->QuadPart + (LENGTH)) - \ + CACHE_ROUND_DOWN((OFFSET)->QuadPart)) >> CACHE_SHIFT) +#define INVALID_CACHE ((ULONG)~0) + +extern NOCC_BCB CcCacheSections[CACHE_NUM_SECTIONS]; +extern PRTL_BITMAP CcCacheBitmap; +extern FAST_MUTEX CcMutex; +extern KEVENT CcDeleteEvent; +extern ULONG CcCacheClockHand; +extern LIST_ENTRY CcPendingUnmap; +extern KEVENT CcpLazyWriteEvent; + +#define CcpLock() _CcpLock(__FILE__,__LINE__) +#define CcpUnlock() _CcpUnlock(__FILE__,__LINE__) + +extern VOID _CcpLock(const char *file, int line); +extern VOID _CcpUnlock(const char *file, int line); + +extern VOID CcpReferenceCache(ULONG Sector); +extern VOID CcpDereferenceCache(ULONG Sector, BOOLEAN Immediate); +BOOLEAN +NTAPI +CcpMapData +(IN PFILE_OBJECT FileObject, + IN PLARGE_INTEGER FileOffset, + IN ULONG Length, + IN ULONG Flags, + OUT PVOID *BcbResult, + OUT PVOID *Buffer); + +BOOLEAN +NTAPI +CcpPinMappedData(IN PNOCC_CACHE_MAP Map, + IN PLARGE_INTEGER FileOffset, + IN ULONG Length, + IN ULONG Flags, + IN OUT PVOID *Bcb); +#endif
Propchange: branches/arty-newcc/ntoskrnl/include/internal/newcc.h ------------------------------------------------------------------------------ svn:eol-style = native
Added: branches/arty-newcc/ntoskrnl/include/internal/newmm.h URL: http://svn.reactos.org/svn/reactos/branches/arty-newcc/ntoskrnl/include/inte... ============================================================================== --- branches/arty-newcc/ntoskrnl/include/internal/newmm.h (added) +++ branches/arty-newcc/ntoskrnl/include/internal/newmm.h [iso-8859-1] Wed Nov 11 06:37:44 2009 @@ -1,0 +1,2123 @@ +#ifndef __INCLUDE_INTERNAL_MM_H +#define __INCLUDE_INTERNAL_MM_H + +#include <internal/arch/mm.h> + +/* TYPES *********************************************************************/ + +struct _EPROCESS; + +extern ULONG MiFreeSwapPages; +extern ULONG MiUsedSwapPages; +extern ULONG MmPagedPoolSize; +extern ULONG MmTotalPagedPoolQuota; +extern ULONG MmTotalNonPagedPoolQuota; +extern PHYSICAL_ADDRESS MmSharedDataPagePhysicalAddress; +extern ULONG MmNumberOfPhysicalPages; +extern UCHAR MmDisablePagingExecutive; +extern ULONG MmLowestPhysicalPage; +extern ULONG MmHighestPhysicalPage; +extern ULONG MmAvailablePages; +extern ULONG MmResidentAvailablePages; + +extern PVOID MmPagedPoolBase; +extern ULONG MmPagedPoolSize; + +extern PMEMORY_ALLOCATION_DESCRIPTOR MiFreeDescriptor; +extern MEMORY_ALLOCATION_DESCRIPTOR MiFreeDescriptorOrg; + +extern LIST_ENTRY MmLoadedUserImageList; + +extern ULONG MmNumberOfPagingFiles; + +extern PVOID MmUnloadedDrivers; +extern PVOID MmLastUnloadedDrivers; +extern PVOID MmTriageActionTaken; +extern PVOID KernelVerifier; +extern MM_DRIVER_VERIFIER_DATA MmVerifierData; + +extern SIZE_T MmTotalCommitLimit; +extern SIZE_T MmTotalCommittedPages; +extern SIZE_T MmSharedCommit; +extern SIZE_T MmDriverCommit; +extern SIZE_T MmProcessCommit; +extern SIZE_T MmPagedPoolCommit; +extern SIZE_T MmPeakCommitment; +extern SIZE_T MmtotalCommitLimitMaximum; + +extern BOOLEAN MiDbgReadyForPhysical; + +struct _KTRAP_FRAME; +struct _EPROCESS; +struct _MM_RMAP_ENTRY; +struct _MM_PAGEOP; +typedef ULONG SWAPENTRY; +typedef ULONG PFN_TYPE, *PPFN_TYPE; + +// +// MmDbgCopyMemory Flags +// +#define MMDBG_COPY_WRITE 0x00000001 +#define MMDBG_COPY_PHYSICAL 0x00000002 +#define MMDBG_COPY_UNSAFE 0x00000004 +#define MMDBG_COPY_CACHED 0x00000008 +#define MMDBG_COPY_UNCACHED 0x00000010 +#define MMDBG_COPY_WRITE_COMBINED 0x00000020 + +// +// Maximum chunk size per copy +// +#define MMDBG_COPY_MAX_SIZE 0x8 + +#if defined(_X86_) +#define MI_STATIC_MEMORY_AREAS (14) +#else +#define MI_STATIC_MEMORY_AREAS (13) +#endif + +#define MEMORY_AREA_INVALID (0) +#define MEMORY_AREA_SECTION_VIEW (1) +#define MEMORY_AREA_CONTINUOUS_MEMORY (2) +#define MEMORY_AREA_NO_CACHE (3) +#define MEMORY_AREA_IO_MAPPING (4) +#define MEMORY_AREA_SYSTEM (5) +#define MEMORY_AREA_MDL_MAPPING (7) +#define MEMORY_AREA_VIRTUAL_MEMORY (8) +#define MEMORY_AREA_CACHE_SEGMENT (9) +#define MEMORY_AREA_SHARED_DATA (10) +#define MEMORY_AREA_KERNEL_STACK (11) +#define MEMORY_AREA_PAGED_POOL (12) +#define MEMORY_AREA_NO_ACCESS (13) +#define MEMORY_AREA_PEB_OR_TEB (14) +#define MEMORY_AREA_OWNED_BY_ARM3 (15) +#define MEMORY_AREA_PHYSICAL_MEMORY_SECTION (0x00010000) +#define MEMORY_AREA_PAGE_FILE_SECTION (0x00010001) +#define MEMORY_AREA_IMAGE_SECTION (0x00010002) +#define MEMORY_AREA_STATIC (0x80000000) + +#define MM_PHYSICAL_PAGE_MPW_PENDING (0x8) + +#define MM_CORE_DUMP_TYPE_NONE (0x0) +#define MM_CORE_DUMP_TYPE_MINIMAL (0x1) +#define MM_CORE_DUMP_TYPE_FULL (0x2) + +#define MM_PAGEOP_PAGEIN (1) +#define MM_PAGEOP_PAGEOUT (2) +#define MM_PAGEOP_PAGESYNCH (3) +#define MM_PAGEOP_ACCESSFAULT (4) + +/* Number of list heads to use */ +#define MI_FREE_POOL_LISTS 4 + +#define MI_HYPERSPACE_PTES (256 - 1) +#define MI_ZERO_PTES (32) +#define MI_MAPPING_RANGE_START (ULONG)HYPER_SPACE +#define MI_MAPPING_RANGE_END (MI_MAPPING_RANGE_START + \ + MI_HYPERSPACE_PTES * PAGE_SIZE) +#define MI_ZERO_PTE (PMMPTE)(MI_MAPPING_RANGE_END + \ + PAGE_SIZE) + +#define PAGE_FROM_SSE(E) ((E) & 0xFFFFF000) +#define PFN_FROM_SSE(E) ((E) >> PAGE_SHIFT) +#define SHARE_COUNT_FROM_SSE(E) (((E) & 0x00000FFE) >> 1) +#define IS_SWAP_FROM_SSE(E) ((E) & 0x00000001) +#define MAX_SHARE_COUNT 0x7FF +#define MAKE_SSE(P, C) ((P) | ((C) << 1)) +#define SWAPENTRY_FROM_SSE(E) ((E) >> 1) +#define MAKE_SWAP_SSE(S) (((S) << 1) | 0x1) + +#define MIN(x,y) (((x)<(y))?(x):(y)) +#define MAX(x,y) (((x)>(y))?(x):(y)) + +/* Signature of free pool blocks */ +#define MM_FREE_POOL_TAG 'lprF' + +#define PAGE_TO_SECTION_PAGE_DIRECTORY_OFFSET(x) \ + ((x) / (4*1024*1024)) + +#define PAGE_TO_SECTION_PAGE_TABLE_OFFSET(x) \ + ((((x)) % (4*1024*1024)) / (4*1024)) + +#define NR_SECTION_PAGE_TABLES 1024 +#define NR_SECTION_PAGE_ENTRIES 1024 + +#define TEB_BASE 0x7FFDE000 + +/* Although Microsoft says this isn't hardcoded anymore, + they won't be able to change it. Stuff depends on it */ +#define MM_VIRTMEM_GRANULARITY (64 * 1024) + +#define STATUS_MM_RESTART_OPERATION ((NTSTATUS)0xD0000001) + +/* + * Additional flags for protection attributes + */ +#define PAGE_WRITETHROUGH (1024) +#define PAGE_SYSTEM (2048) + +#define SEC_PHYSICALMEMORY (0x80000000) +#define SEC_CACHE (0x40000000) + +/* These shouldn't be bit flags but are */ +#define MM_PAGEFILE_SEGMENT (0x1) +#define MM_DATAFILE_SEGMENT (0x2) +#define MM_PHYSIMEM_SEGMENT (0x4) +#define MM_IMAGE_SEGMENT (0x8) + +#define MC_CACHE (0) +#define MC_USER (1) +#define MC_PPOOL (2) +#define MC_NPPOOL (3) +#define MC_SYSTEM (4) +#define MC_MAXIMUM (5) + +#define PAGED_POOL_MASK 1 +#define MUST_SUCCEED_POOL_MASK 2 +#define CACHE_ALIGNED_POOL_MASK 4 +#define QUOTA_POOL_MASK 8 +#define SESSION_POOL_MASK 32 +#define VERIFIER_POOL_MASK 64 + +#define MM_PAGED_POOL_SIZE (100*1024*1024) +#define MM_NONPAGED_POOL_SIZE (100*1024*1024) + +/* + * Paged and non-paged pools are 8-byte aligned + */ +#define MM_POOL_ALIGNMENT 8 + +/* + * Maximum size of the kmalloc area (this is totally arbitary) + */ +#define MM_KERNEL_MAP_SIZE (16*1024*1024) +#define MM_KERNEL_MAP_BASE (0xf0c00000) + +/* + * FIXME - different architectures have different cache line sizes... + */ +#define MM_CACHE_LINE_SIZE 32 + +#define MM_ROUND_UP(x,s) \ + ((PVOID)(((ULONG_PTR)(x)+(s)-1) & ~((ULONG_PTR)(s)-1))) + +#define MM_ROUND_DOWN(x,s) \ + ((PVOID)(((ULONG_PTR)(x)) & ~((ULONG_PTR)(s)-1))) + +#define PAGE_FLAGS_VALID_FROM_USER_MODE \ + (PAGE_READONLY | \ + PAGE_READWRITE | \ + PAGE_WRITECOPY | \ + PAGE_EXECUTE | \ + PAGE_EXECUTE_READ | \ + PAGE_EXECUTE_READWRITE | \ + PAGE_EXECUTE_WRITECOPY | \ + PAGE_GUARD | \ + PAGE_NOACCESS | \ + PAGE_NOCACHE) + +#define PAGE_FLAGS_VALID_FOR_SECTION \ + (PAGE_READONLY | \ + PAGE_READWRITE | \ + PAGE_WRITECOPY | \ + PAGE_EXECUTE | \ + PAGE_EXECUTE_READ | \ + PAGE_EXECUTE_READWRITE | \ + PAGE_EXECUTE_WRITECOPY | \ + PAGE_NOACCESS) + +#define PAGE_IS_READABLE \ + (PAGE_READONLY | \ + PAGE_READWRITE | \ + PAGE_WRITECOPY | \ + PAGE_EXECUTE_READ | \ + PAGE_EXECUTE_READWRITE | \ + PAGE_EXECUTE_WRITECOPY) + +#define PAGE_IS_WRITABLE \ + (PAGE_READWRITE | \ + PAGE_WRITECOPY | \ + PAGE_EXECUTE_READWRITE | \ + PAGE_EXECUTE_WRITECOPY) + +#define PAGE_IS_EXECUTABLE \ + (PAGE_EXECUTE | \ + PAGE_EXECUTE_READ | \ + PAGE_EXECUTE_READWRITE | \ + PAGE_EXECUTE_WRITECOPY) + +#define PAGE_IS_WRITECOPY \ + (PAGE_WRITECOPY | \ + PAGE_EXECUTE_WRITECOPY) + + +#define InterlockedCompareExchangePte(PointerPte, Exchange, Comperand) \ + InterlockedCompareExchange((PLONG)(PointerPte), Exchange, Comperand) + +#define InterlockedExchangePte(PointerPte, Value) \ + InterlockedExchange((PLONG)(PointerPte), Value) + +typedef struct +{ + ULONG Entry[NR_SECTION_PAGE_ENTRIES]; +} SECTION_PAGE_TABLE, *PSECTION_PAGE_TABLE; + +typedef struct +{ + PSECTION_PAGE_TABLE PageTables[NR_SECTION_PAGE_TABLES]; +} SECTION_PAGE_DIRECTORY, *PSECTION_PAGE_DIRECTORY; + +typedef struct _MM_SECTION_SEGMENT +{ + FAST_MUTEX Lock; /* lock which protects the page directory */ + PFILE_OBJECT FileObject; + ULARGE_INTEGER RawLength; /* length of the segment which is part of the mapped file */ + ULARGE_INTEGER Length; /* absolute length of the segment */ + ULONG ReferenceCount; + ULONG Protection; + ULONG Flags; + BOOLEAN WriteCopy; + SECTION_PAGE_DIRECTORY PageDirectory; + + struct + { + LONG FileOffset; /* start offset into the file for image sections */ + ULONG_PTR VirtualAddress; /* dtart offset into the address range for image sections */ + ULONG Characteristics; + } Image; +} MM_SECTION_SEGMENT, *PMM_SECTION_SEGMENT; + +typedef struct _MM_IMAGE_SECTION_OBJECT +{ + ULONG_PTR ImageBase; + ULONG_PTR StackReserve; + ULONG_PTR StackCommit; + ULONG_PTR EntryPoint; + USHORT Subsystem; + USHORT ImageCharacteristics; + USHORT MinorSubsystemVersion; + USHORT MajorSubsystemVersion; + USHORT Machine; + BOOLEAN Executable; + ULONG NrSegments; + ULONG ImageSize; + PMM_SECTION_SEGMENT Segments; +} MM_IMAGE_SECTION_OBJECT, *PMM_IMAGE_SECTION_OBJECT; + +typedef struct _ROS_SECTION_OBJECT +{ + CSHORT Type; + CSHORT Size; + LARGE_INTEGER MaximumSize; + ULONG SectionPageProtection; + ULONG AllocationAttributes; + PFILE_OBJECT FileObject; + union + { + PMM_IMAGE_SECTION_OBJECT ImageSection; + PMM_SECTION_SEGMENT Segment; + }; +} ROS_SECTION_OBJECT, *PROS_SECTION_OBJECT; + +typedef struct _MEMORY_AREA +{ + PVOID StartingAddress; + PVOID EndingAddress; + struct _MEMORY_AREA *Parent; + struct _MEMORY_AREA *LeftChild; + struct _MEMORY_AREA *RightChild; + ULONG Type; + ULONG Protect; + ULONG Flags; + BOOLEAN DeleteInProgress; + ULONG PageOpCount; + union + { + struct + { + ROS_SECTION_OBJECT* Section; + ULONG ViewOffset; + PMM_SECTION_SEGMENT Segment; + BOOLEAN WriteCopyView; + LIST_ENTRY RegionListHead; + } SectionData; + struct + { + LIST_ENTRY RegionListHead; + } VirtualMemoryData; + } Data; +} MEMORY_AREA, *PMEMORY_AREA; + +typedef struct +{ + ULONG NrTotalPages; + ULONG NrSystemPages; + ULONG NrUserPages; + ULONG NrFreePages; + ULONG NrDirtyPages; + ULONG NrLockedPages; + ULONG PagingRequestsInLastMinute; + ULONG PagingRequestsInLastFiveMinutes; + ULONG PagingRequestsInLastFifteenMinutes; +} MM_STATS; + +// +// These two mappings are actually used by Windows itself, based on the ASSERTS +// +#define StartOfAllocation ReadInProgress +#define EndOfAllocation WriteInProgress + +typedef struct _MMPFNENTRY +{ + USHORT Modified:1; + USHORT ReadInProgress:1; // StartOfAllocation + USHORT WriteInProgress:1; // EndOfAllocation + USHORT PrototypePte:1; // Zero + USHORT PageColor:4; // LockCount + USHORT PageLocation:3; // Consumer + USHORT RemovalRequested:1; + USHORT CacheAttribute:2; // Type + USHORT Rom:1; + USHORT ParityError:1; +} MMPFNENTRY; + +typedef struct _MMPFN +{ + union + { + PFN_NUMBER Flink; // ListEntry.Flink + ULONG WsIndex; + PKEVENT Event; + NTSTATUS ReadStatus; + SINGLE_LIST_ENTRY NextStackPfn; + } u1; + PMMPTE PteAddress; // ListEntry.Blink + union + { + PFN_NUMBER Blink; + ULONG_PTR ShareCount; // MapCount + } u2; + union + { + struct + { + USHORT ReferenceCount; // ReferenceCount + MMPFNENTRY e1; + }; + struct + { + USHORT ReferenceCount; + USHORT ShortFlags; + } e2; + } u3; + union + { + MMPTE OriginalPte; + LONG AweReferenceCount; // RmapListHead + }; + union + { + ULONG_PTR EntireFrame; // SavedSwapEntry + struct + { + ULONG_PTR PteFrame:25; + ULONG_PTR InPageError:1; + ULONG_PTR VerifierAllocation:1; + ULONG_PTR AweAllocation:1; + ULONG_PTR Priority:3; + ULONG_PTR MustBeCached:1; + }; + } u4; +} MMPFN, *PMMPFN; + +extern PMMPFN MmPfnDatabase; + +typedef struct _MMPFNLIST +{ + PFN_NUMBER Total; + MMLISTS ListName; + PFN_NUMBER Flink; + PFN_NUMBER Blink; +} MMPFNLIST, *PMMPFNLIST; + +extern MMPFNLIST MmZeroedPageListHead; +extern MMPFNLIST MmFreePageListHead; +extern MMPFNLIST MmStandbyPageListHead; +extern MMPFNLIST MmModifiedPageListHead; +extern MMPFNLIST MmModifiedNoWritePageListHead; + +typedef struct _MM_PAGEOP +{ + /* Type of operation. */ + ULONG OpType; + /* Number of threads interested in this operation. */ + ULONG ReferenceCount; + /* Event that will be set when the operation is completed. */ + KEVENT CompletionEvent; + /* Status of the operation once it is completed. */ + NTSTATUS Status; + /* TRUE if the operation was abandoned. */ + BOOLEAN Abandoned; + /* The memory area to be affected by the operation. */ + PMEMORY_AREA MArea; + ULONG Hash; + struct _MM_PAGEOP* Next; + struct _ETHREAD* Thread; + /* + * These fields are used to identify the operation if it is against a + * virtual memory area. + */ + HANDLE Pid; + PVOID Address; + /* + * These fields are used to identify the operation if it is against a + * section mapping. + */ + PMM_SECTION_SEGMENT Segment; + ULONG Offset; +} MM_PAGEOP, *PMM_PAGEOP; + +typedef struct _MM_MEMORY_CONSUMER +{ + ULONG PagesUsed; + ULONG PagesTarget; + NTSTATUS (*Trim)(ULONG Target, ULONG Priority, PULONG NrFreed); +} MM_MEMORY_CONSUMER, *PMM_MEMORY_CONSUMER; + +typedef struct _MM_REGION +{ + ULONG Type; + ULONG Protect; + ULONG Length; + LIST_ENTRY RegionListEntry; +} MM_REGION, *PMM_REGION; + +/* Entry describing free pool memory */ +typedef struct _MMFREE_POOL_ENTRY +{ + LIST_ENTRY List; + PFN_NUMBER Size; + ULONG Signature; + struct _MMFREE_POOL_ENTRY *Owner; +} MMFREE_POOL_ENTRY, *PMMFREE_POOL_ENTRY; + +/* Paged pool information */ +typedef struct _MM_PAGED_POOL_INFO +{ + PRTL_BITMAP PagedPoolAllocationMap; + PRTL_BITMAP EndOfPagedPoolBitmap; + PMMPTE FirstPteForPagedPool; + PMMPTE LastPteForPagedPool; + PMMPTE NextPdeForPagedPoolExpansion; + ULONG PagedPoolHint; + SIZE_T PagedPoolCommit; + SIZE_T AllocatedPagedPool; +} MM_PAGED_POOL_INFO, *PMM_PAGED_POOL_INFO; + +typedef struct +{ + PROS_SECTION_OBJECT Section; + PMM_SECTION_SEGMENT Segment; + ULONG Offset; + BOOLEAN WasDirty; + BOOLEAN Private; +} +MM_SECTION_PAGEOUT_CONTEXT; + +extern MM_MEMORY_CONSUMER MiMemoryConsumers[MC_MAXIMUM]; + +typedef VOID +(*PMM_ALTER_REGION_FUNC)( + PMMSUPPORT AddressSpace, + PVOID BaseAddress, + ULONG Length, + ULONG OldType, + ULONG OldProtect, + ULONG NewType, + ULONG NewProtect +); + +typedef VOID +(*PMM_FREE_PAGE_FUNC)( + PVOID Context, + PMEMORY_AREA MemoryArea, + PVOID Address, + PFN_TYPE Page, + SWAPENTRY SwapEntry, + BOOLEAN Dirty +); + +// +// Mm copy support for Kd +// +NTSTATUS +NTAPI +MmDbgCopyMemory( + IN ULONG64 Address, + IN PVOID Buffer, + IN ULONG Size, + IN ULONG Flags +); + +// +// Determines if a given address is a session address +// +BOOLEAN +NTAPI +MmIsSessionAddress( + IN PVOID Address +); + +/* marea.c *******************************************************************/ + +NTSTATUS +NTAPI +MmCreateMemoryArea( + PMMSUPPORT AddressSpace, + ULONG Type, + PVOID *BaseAddress, + ULONG_PTR Length, + ULONG Protection, + PMEMORY_AREA *Result, + BOOLEAN FixedAddress, + ULONG AllocationFlags, + PHYSICAL_ADDRESS BoundaryAddressMultiple OPTIONAL +); + +PMEMORY_AREA +NTAPI +MmLocateMemoryAreaByAddress( + PMMSUPPORT AddressSpace, + PVOID Address +); + +ULONG_PTR +NTAPI +MmFindGapAtAddress( + PMMSUPPORT AddressSpace, + PVOID Address +); + +NTSTATUS +NTAPI +MmFreeMemoryArea( + PMMSUPPORT AddressSpace, + PMEMORY_AREA MemoryArea, + PMM_FREE_PAGE_FUNC FreePage, + PVOID FreePageContext +); + +NTSTATUS +NTAPI +MmFreeMemoryAreaByPtr( + PMMSUPPORT AddressSpace, + PVOID BaseAddress, + PMM_FREE_PAGE_FUNC FreePage, + PVOID FreePageContext +); + +VOID +NTAPI +MmDumpMemoryAreas(PMMSUPPORT AddressSpace); + +PMEMORY_AREA +NTAPI +MmLocateMemoryAreaByRegion( + PMMSUPPORT AddressSpace, + PVOID Address, + ULONG_PTR Length +); + +PVOID +NTAPI +MmFindGap( + PMMSUPPORT AddressSpace, + ULONG_PTR Length, + ULONG_PTR Granularity, + BOOLEAN TopDown +); + +VOID +NTAPI +MmReleaseMemoryAreaIfDecommitted( + struct _EPROCESS *Process, + PMMSUPPORT AddressSpace, + PVOID BaseAddress +); + +VOID +NTAPI +MmMapMemoryArea(PVOID BaseAddress, + ULONG Length, + ULONG Consumer, + ULONG Protection); + +/* npool.c *******************************************************************/ + +VOID +NTAPI +MiDebugDumpNonPagedPool(BOOLEAN NewOnly); + +VOID +NTAPI +MiDebugDumpNonPagedPoolStats(BOOLEAN NewOnly); + +VOID +NTAPI +MiInitializeNonPagedPool(VOID); + +PVOID +NTAPI +MiAllocatePoolPages( + IN POOL_TYPE PoolType, + IN SIZE_T SizeInBytes +); + +POOL_TYPE +NTAPI +MmDeterminePoolType( + IN PVOID VirtualAddress +); + +ULONG +NTAPI +MiFreePoolPages( + IN PVOID StartingAddress +); + +PVOID +NTAPI +MmGetMdlPageAddress( + PMDL Mdl, + PVOID Offset +); + +/* pool.c *******************************************************************/ + +PVOID +NTAPI +ExAllocateNonPagedPoolWithTag( + POOL_TYPE type, + ULONG size, + ULONG Tag, + PVOID Caller +); + +PVOID +NTAPI +ExAllocatePagedPoolWithTag( + POOL_TYPE Type, + ULONG size, + ULONG Tag +); + +VOID +NTAPI +ExFreeNonPagedPool(PVOID block); + +VOID +NTAPI +ExFreePagedPool(IN PVOID Block); + +BOOLEAN +NTAPI +ExpIsPoolTagDebuggable(ULONG Tag); + +PVOID +NTAPI +ExpAllocateDebugPool( + POOL_TYPE Type, + ULONG Size, + ULONG Tag, + PVOID Caller, + BOOLEAN EndOfPage +); + +VOID +NTAPI +ExpFreeDebugPool(PVOID Block, BOOLEAN PagedPool); + +VOID +NTAPI +MmInitializePagedPool(VOID); + +PVOID +NTAPI +MiAllocateSpecialPool( + IN POOL_TYPE PoolType, + IN SIZE_T NumberOfBytes, + IN ULONG Tag, + IN ULONG Underrun +); + +BOOLEAN +NTAPI +MiRaisePoolQuota( + IN POOL_TYPE PoolType, + IN ULONG CurrentMaxQuota, + OUT PULONG NewMaxQuota +); + +/* mdl.c *********************************************************************/ + +VOID +NTAPI +MmBuildMdlFromPages( + PMDL Mdl, + PULONG Pages +); + +/* mminit.c ******************************************************************/ + +VOID +NTAPI +MiShutdownMemoryManager(VOID); + +VOID +NTAPI +MmInit1( + VOID +); + +BOOLEAN +NTAPI +MmInitSystem(IN ULONG Phase, + IN PLOADER_PARAMETER_BLOCK LoaderBlock); + +VOID +NTAPI +MiFreeInitMemory(VOID); + +VOID +NTAPI +MmInitializeMdlImplementation(VOID); + +/* pagefile.c ****************************************************************/ + +SWAPENTRY +NTAPI +MmAllocSwapPage(VOID); + +VOID +NTAPI +MmDereserveSwapPages(ULONG Nr); + +VOID +NTAPI +MmFreeSwapPage(SWAPENTRY Entry); + +VOID +NTAPI +MmInitPagingFile(VOID); + +NTSTATUS +NTAPI +MmReadFromSwapPage( + SWAPENTRY SwapEntry, + PFN_TYPE Page +); + +BOOLEAN +NTAPI +MmReserveSwapPages(ULONG Nr); + +NTSTATUS +NTAPI +MmWriteToSwapPage( + SWAPENTRY SwapEntry, + PFN_TYPE Page +); + +NTSTATUS +NTAPI +MmDumpToPagingFile( + ULONG BugCode, + ULONG BugCodeParameter1, + ULONG BugCodeParameter2, + ULONG BugCodeParameter3, + ULONG BugCodeParameter4, + struct _KTRAP_FRAME* TrapFrame +); + +BOOLEAN +NTAPI +MmIsAvailableSwapPage(VOID); + +VOID +NTAPI +MmShowOutOfSpaceMessagePagingFile(VOID); + +/* process.c ****************************************************************/ + +NTSTATUS +NTAPI +MmInitializeProcessAddressSpace( + IN PEPROCESS Process, + IN PEPROCESS Clone OPTIONAL, + IN PVOID Section OPTIONAL, + IN OUT PULONG Flags, + IN POBJECT_NAME_INFORMATION *AuditName OPTIONAL +); + +NTSTATUS +NTAPI +MmCreatePeb( + IN PEPROCESS Process, + IN PINITIAL_PEB InitialPeb, + OUT PPEB *BasePeb +); + +NTSTATUS +NTAPI +MmCreateTeb( + IN PEPROCESS Process, + IN PCLIENT_ID ClientId, + IN PINITIAL_TEB InitialTeb, + OUT PTEB* BaseTeb +); + +VOID +NTAPI +MmDeleteTeb( + struct _EPROCESS *Process, + PTEB Teb +); + +VOID +NTAPI +MmCleanProcessAddressSpace(IN PEPROCESS Process); + +NTSTATUS +NTAPI +MmDeleteProcessAddressSpace(IN PEPROCESS Process); + +ULONG +NTAPI +MmGetSessionLocaleId(VOID); + +NTSTATUS +NTAPI +MmSetMemoryPriorityProcess( + IN PEPROCESS Process, + IN UCHAR MemoryPriority +); + +/* i386/pfault.c *************************************************************/ + +NTSTATUS +NTAPI +MmPageFault( + ULONG Cs, + PULONG Eip, + PULONG Eax, + ULONG Cr2, + ULONG ErrorCode +); + +/* mm.c **********************************************************************/ + +NTSTATUS +NTAPI +MmAccessFault( + IN BOOLEAN StoreInstruction, + IN PVOID Address, + IN KPROCESSOR_MODE Mode, + IN PVOID TrapInformation +); + +/* anonmem.c *****************************************************************/ + +NTSTATUS +NTAPI +MmNotPresentFaultVirtualMemory( + PMMSUPPORT AddressSpace, + MEMORY_AREA* MemoryArea, + PVOID Address, + BOOLEAN Locked +); + +NTSTATUS +NTAPI +MmPageOutVirtualMemory( + PMMSUPPORT AddressSpace, + PMEMORY_AREA MemoryArea, + PVOID Address, + struct _MM_PAGEOP* PageOp +); + +NTSTATUS +NTAPI +MmQueryAnonMem( + PMEMORY_AREA MemoryArea, + PVOID Address, + PMEMORY_BASIC_INFORMATION Info, + PULONG ResultLength +); + +VOID +NTAPI +MmFreeVirtualMemory( + struct _EPROCESS* Process, + PMEMORY_AREA MemoryArea +); + +NTSTATUS +NTAPI +MmProtectAnonMem( + PMMSUPPORT AddressSpace, + PMEMORY_AREA MemoryArea, + PVOID BaseAddress, + ULONG Length, + ULONG Protect, + PULONG OldProtect +); + +NTSTATUS +NTAPI +MmWritePageVirtualMemory( + PMMSUPPORT AddressSpace, + PMEMORY_AREA MArea, + PVOID Address, + PMM_PAGEOP PageOp +); + +/* kmap.c ********************************************************************/ + +PVOID +NTAPI +ExAllocatePage(VOID); + +VOID +NTAPI +ExUnmapPage(PVOID Addr); + +PVOID +NTAPI +ExAllocatePageWithPhysPage(PFN_TYPE Page); + +NTSTATUS +NTAPI +MiCopyFromUserPage( + PFN_TYPE Page, + PVOID SourceAddress +); + +NTSTATUS +NTAPI +MiZeroPage(PFN_TYPE Page); + +/* memsafe.s *****************************************************************/ + +PVOID +FASTCALL +MmSafeReadPtr(PVOID Source); + +/* pageop.c ******************************************************************/ + +VOID +NTAPI +MmReleasePageOp(PMM_PAGEOP PageOp); + +PMM_PAGEOP +NTAPI +MmGetPageOp( + PMEMORY_AREA MArea, + HANDLE Pid, + PVOID Address, + PMM_SECTION_SEGMENT Segment, + ULONG Offset, + ULONG OpType, + BOOLEAN First +); + +PMM_PAGEOP +NTAPI +MmCheckForPageOp( + PMEMORY_AREA MArea, + HANDLE Pid, + PVOID Address, + PMM_SECTION_SEGMENT Segment, + ULONG Offset +); + +VOID +NTAPI +MmInitializePageOp(VOID); + +/* process.c *****************************************************************/ + +PVOID +NTAPI +MmCreateKernelStack(BOOLEAN GuiStack, UCHAR Node); + +VOID +NTAPI +MmDeleteKernelStack(PVOID Stack, + BOOLEAN GuiStack); + +/* balace.c ******************************************************************/ + +VOID +NTAPI +MmInitializeMemoryConsumer( + ULONG Consumer, + NTSTATUS (*Trim)(ULONG Target, ULONG Priority, PULONG NrFreed) +); + +VOID +NTAPI +MmInitializeBalancer( + ULONG NrAvailablePages, + ULONG NrSystemPages +); + +NTSTATUS +NTAPI +MmReleasePageMemoryConsumer( + ULONG Consumer, + PFN_TYPE Page +); + +NTSTATUS +NTAPI +MmRequestPageMemoryConsumer( + ULONG Consumer, + BOOLEAN MyWait, + PPFN_TYPE AllocatedPage +); + +VOID +NTAPI +MiInitBalancerThread(VOID); + +VOID +NTAPI +MmRebalanceMemoryConsumers(VOID); + +/* rmap.c **************************************************************/ + +VOID +NTAPI +MmSetRmapListHeadPage( + PFN_TYPE Page, + struct _MM_RMAP_ENTRY* ListHead +); + +struct _MM_RMAP_ENTRY* +NTAPI +MmGetRmapListHeadPage(PFN_TYPE Page); + +VOID +NTAPI +MmInsertRmap( + PFN_TYPE Page, + struct _EPROCESS *Process, + PVOID Address +); + +VOID +NTAPI +MmDeleteAllRmaps( + PFN_TYPE Page, + PVOID Context, + VOID (*DeleteMapping)(PVOID Context, struct _EPROCESS *Process, PVOID Address) +); + +VOID +NTAPI +MmDeleteRmap( + PFN_TYPE Page, + struct _EPROCESS *Process, + PVOID Address +); + +VOID +NTAPI +MmInitializeRmapList(VOID); + +VOID +NTAPI +MmSetCleanAllRmaps(PFN_TYPE Page); + +VOID +NTAPI +MmSetDirtyAllRmaps(PFN_TYPE Page); + +BOOLEAN +NTAPI +MmIsDirtyPageRmap(PFN_TYPE Page); + +NTSTATUS +NTAPI +MmWritePagePhysicalAddress(PFN_TYPE Page); + +NTSTATUS +NTAPI +MmPageOutPhysicalAddress(PFN_TYPE Page); + +/* freelist.c **********************************************************/ + +#define ASSERT_PFN(x) ASSERT((x)->u3.e1.CacheAttribute != 0) + +FORCEINLINE +PMMPFN +MiGetPfnEntry(IN PFN_TYPE Pfn) +{ + PMMPFN Page; + extern RTL_BITMAP MiPfnBitMap; + + /* Make sure the PFN number is valid */ + if (Pfn > MmHighestPhysicalPage) return NULL; + + /* Make sure this page actually has a PFN entry */ + if ((MiPfnBitMap.Buffer) && !(RtlTestBit(&MiPfnBitMap, Pfn))) return NULL; + + /* Get the entry */ + Page = &MmPfnDatabase[Pfn]; + + /* Make sure it's valid */ + ASSERT_PFN(Page); + + /* Return it */ + return Page; +}; + +FORCEINLINE +PFN_NUMBER +MiGetPfnEntryIndex(IN PMMPFN Pfn1) +{ + // + // This will return the Page Frame Number (PFN) from the MMPFN + // + return Pfn1 - MmPfnDatabase; +} + +PFN_TYPE +NTAPI +MmGetLRUNextUserPage(PFN_TYPE PreviousPage); + +PFN_TYPE +NTAPI +MmGetLRUFirstUserPage(VOID); + +VOID +NTAPI +MmInsertLRULastUserPage(PFN_TYPE Page); + +VOID +NTAPI +MmRemoveLRUUserPage(PFN_TYPE Page); + +VOID +NTAPI +MmLockPage(PFN_TYPE Page); + +VOID +NTAPI +MmLockPageUnsafe(PFN_TYPE Page); + +VOID +NTAPI +MmUnlockPage(PFN_TYPE Page); + +ULONG +NTAPI +MmGetLockCountPage(PFN_TYPE Page); + +static +__inline +KIRQL +NTAPI +MmAcquirePageListLock() +{ + return KeAcquireQueuedSpinLock(LockQueuePfnLock); +} + +FORCEINLINE +VOID +NTAPI +MmReleasePageListLock(KIRQL oldIrql) +{ + KeReleaseQueuedSpinLock(LockQueuePfnLock, oldIrql); +} + +VOID +NTAPI +MmInitializePageList( + VOID +); + +VOID +NTAPI +MmDumpPfnDatabase( + VOID +); + +PFN_TYPE +NTAPI +MmGetContinuousPages( + ULONG NumberOfBytes, + PHYSICAL_ADDRESS LowestAcceptableAddress, + PHYSICAL_ADDRESS HighestAcceptableAddress, + PHYSICAL_ADDRESS BoundaryAddressMultiple, + BOOLEAN ZeroPages +); + +NTSTATUS +NTAPI +MmZeroPageThreadMain( + PVOID Context +); + +/* hypermap.c *****************************************************************/ + +extern PEPROCESS HyperProcess; +extern KIRQL HyperIrql; + +PVOID +NTAPI +MiMapPageInHyperSpace(IN PEPROCESS Process, + IN PFN_NUMBER Page, + IN PKIRQL OldIrql); + +VOID +NTAPI +MiUnmapPageInHyperSpace(IN PEPROCESS Process, + IN PVOID Address, + IN KIRQL OldIrql); + +PVOID +NTAPI +MiMapPagesToZeroInHyperSpace(IN PMMPFN *Pages, + IN PFN_NUMBER NumberOfPages); + +VOID +NTAPI +MiUnmapPagesInZeroSpace(IN PVOID VirtualAddress, + IN PFN_NUMBER NumberOfPages); + +// +// ReactOS Compatibility Layer +// +FORCEINLINE +PVOID +MmCreateHyperspaceMapping(IN PFN_NUMBER Page) +{ + HyperProcess = (PEPROCESS)KeGetCurrentThread()->ApcState.Process; + return MiMapPageInHyperSpace(HyperProcess, Page, &HyperIrql); +} + +FORCEINLINE +PVOID +MiMapPageToZeroInHyperSpace(IN PFN_NUMBER Page) +{ + PMMPFN Pfn1 = MiGetPfnEntry(Page); + return MiMapPagesToZeroInHyperSpace(&Pfn1, 1); +} + +#define MmDeleteHyperspaceMapping(x) MiUnmapPageInHyperSpace(HyperProcess, x, HyperIrql); + +/* virtual.c ***********************************************************/ + +NTSTATUS NTAPI +MiProtectVirtualMemory(IN PEPROCESS Process, + IN OUT PVOID *BaseAddress, + IN OUT PSIZE_T NumberOfBytesToProtect, + IN ULONG NewAccessProtection, + OUT PULONG OldAccessProtection OPTIONAL); + +/* i386/page.c *********************************************************/ + +NTSTATUS +NTAPI +MmCreateVirtualMappingForKernel( + PVOID Address, + ULONG flProtect, + PPFN_TYPE Pages, + ULONG PageCount +); + +NTSTATUS +NTAPI +MmCommitPagedPoolAddress( + PVOID Address, + BOOLEAN Locked +); + +NTSTATUS +NTAPI +MmCreateVirtualMapping( + struct _EPROCESS* Process, + PVOID Address, + ULONG flProtect, + PPFN_TYPE Pages, + ULONG PageCount +); + +NTSTATUS +NTAPI +MmCreateVirtualMappingUnsafe( + struct _EPROCESS* Process, + PVOID Address, + ULONG flProtect, + PPFN_TYPE Pages, + ULONG PageCount +); + +ULONG +NTAPI +MmGetPageProtect( + struct _EPROCESS* Process, + PVOID Address); + +VOID +NTAPI +MmSetPageProtect( + struct _EPROCESS* Process, + PVOID Address, + ULONG flProtect +); + +BOOLEAN +NTAPI +MmIsPagePresent( + struct _EPROCESS* Process, + PVOID Address +); + +VOID +NTAPI +MmInitGlobalKernelPageDirectory(VOID); + +VOID +NTAPI +MmDisableVirtualMapping( + struct _EPROCESS *Process, + PVOID Address, + BOOLEAN* WasDirty, + PPFN_TYPE Page +); + +VOID +NTAPI +MmEnableVirtualMapping( + struct _EPROCESS *Process, + PVOID Address +); + +VOID +NTAPI +MmRawDeleteVirtualMapping(PVOID Address); + +VOID +NTAPI +MmDeletePageFileMapping( + struct _EPROCESS *Process, + PVOID Address, + SWAPENTRY* SwapEntry +); + +NTSTATUS +NTAPI +MmCreatePageFileMapping( + struct _EPROCESS *Process, + PVOID Address, + SWAPENTRY SwapEntry +); + +BOOLEAN +NTAPI +MmIsPageSwapEntry( + struct _EPROCESS *Process, + PVOID Address +); + +VOID +NTAPI +MmTransferOwnershipPage( + PFN_TYPE Page, + ULONG NewConsumer +); + +VOID +NTAPI +MmSetDirtyPage( + struct _EPROCESS *Process, + PVOID Address +); + +PFN_TYPE +NTAPI +MmAllocPage( + ULONG Consumer, + SWAPENTRY SavedSwapEntry +); + +LONG +NTAPI +MmAllocPagesSpecifyRange( + ULONG Consumer, + PHYSICAL_ADDRESS LowestAddress, + PHYSICAL_ADDRESS HighestAddress, + ULONG NumberOfPages, + PPFN_TYPE Pages +); + +VOID +NTAPI +MmDereferencePage(PFN_TYPE Page); + +VOID +NTAPI +MmReferencePage(PFN_TYPE Page); + +VOID +NTAPI +MmReferencePageUnsafe(PFN_TYPE Page); + +ULONG +NTAPI +MmGetReferenceCountPage(PFN_TYPE Page); + +BOOLEAN +NTAPI +MmIsPageInUse(PFN_TYPE Page); + +VOID +NTAPI +MmSetSavedSwapEntryPage( + PFN_TYPE Page, + SWAPENTRY SavedSwapEntry); + +SWAPENTRY +NTAPI +MmGetSavedSwapEntryPage(PFN_TYPE Page); + +VOID +NTAPI +MmSetCleanPage( + struct _EPROCESS *Process, + PVOID Address +); + +NTSTATUS +NTAPI +MmCreatePageTable(PVOID PAddress); + +VOID +NTAPI +MmDeletePageTable( + struct _EPROCESS *Process, + PVOID Address +); + +PFN_TYPE +NTAPI +MmGetPfnForProcess( + struct _EPROCESS *Process, + PVOID Address +); + +BOOLEAN +NTAPI +MmCreateProcessAddressSpace( + IN ULONG MinWs, + IN PEPROCESS Dest, + IN PULONG DirectoryTableBase +); + +NTSTATUS +NTAPI +MmInitializeHandBuiltProcess( + IN PEPROCESS Process, + IN PULONG DirectoryTableBase +); + + +NTSTATUS +NTAPI +MmInitializeHandBuiltProcess2( + IN PEPROCESS Process +); + +NTSTATUS +NTAPI +MmReleaseMmInfo(struct _EPROCESS *Process); + +NTSTATUS +NTAPI +Mmi386ReleaseMmInfo(struct _EPROCESS *Process); + +VOID +NTAPI +MmDeleteVirtualMapping( + struct _EPROCESS *Process, + PVOID Address, + BOOLEAN FreePage, + BOOLEAN* WasDirty, + PPFN_TYPE Page +); + +BOOLEAN +NTAPI +MmIsDirtyPage( + struct _EPROCESS *Process, + PVOID Address +); + +VOID +NTAPI +MmMarkPageMapped(PFN_TYPE Page); + +VOID +NTAPI +MmMarkPageUnmapped(PFN_TYPE Page); + +VOID +NTAPI +MmUpdatePageDir( + struct _EPROCESS *Process, + PVOID Address, + ULONG Size +); + +VOID +NTAPI +MiInitPageDirectoryMap(VOID); + +ULONG +NTAPI +MiGetUserPageDirectoryCount(VOID); + +/* io.c **********************************************************************/ + +NTSTATUS +MmspWaitForFileLock(PFILE_OBJECT File); + +NTSTATUS +NTAPI +MiSimpleRead +(PFILE_OBJECT FileObject, + PLARGE_INTEGER FileOffset, + PVOID Buffer, + ULONG Length, + PIO_STATUS_BLOCK ReadStatus); + +NTSTATUS +NTAPI +MiSimpleWrite +(PFILE_OBJECT FileObject, + PLARGE_INTEGER FileOffset, + PVOID Buffer, + ULONG Length, + PIO_STATUS_BLOCK ReadStatus); + +NTSTATUS +NTAPI +MiWriteBackPage +(PFILE_OBJECT FileObject, + PLARGE_INTEGER Offset, + ULONG Length, + PFN_TYPE Page); + +/* wset.c ********************************************************************/ + +NTSTATUS +MmTrimUserMemory( + ULONG Target, + ULONG Priority, + PULONG NrFreedPages +); + +/* region.c ************************************************************/ + +NTSTATUS +NTAPI +MmAlterRegion( + PMMSUPPORT AddressSpace, + PVOID BaseAddress, + PLIST_ENTRY RegionListHead, + PVOID StartAddress, + ULONG Length, + ULONG NewType, + ULONG NewProtect, + PMM_ALTER_REGION_FUNC AlterFunc +); + +VOID +NTAPI +MmInitializeRegion( + PLIST_ENTRY RegionListHead, + SIZE_T Length, + ULONG Type, + ULONG Protect +); + +PMM_REGION +NTAPI +MmFindRegion( + PVOID BaseAddress, + PLIST_ENTRY RegionListHead, + PVOID Address, + PVOID* RegionBaseAddress +); + +/* section.c *****************************************************************/ + +NTSTATUS +NTAPI +MiReadFilePage(PFILE_OBJECT FileObject, PLARGE_INTEGER Offset, PPFN_TYPE Page); + +VOID +NTAPI +MiFreePageTablesSectionSegment(PMM_SECTION_SEGMENT Segment); + +VOID +NTAPI +MiFreeDataSectionSegment(PFILE_OBJECT FileObject); + +NTSTATUS +NTAPI +MiCowSectionPage +(PMMSUPPORT AddressSpace, + MEMORY_AREA* MemoryArea, + PVOID Address, + BOOLEAN Locked); + +NTSTATUS +NTAPI +MiSwapInSectionPage +(PMMSUPPORT AddressSpace, + PMEMORY_AREA MemoryArea, + PMM_SECTION_SEGMENT Segment, + PVOID Address, + PPFN_TYPE Page); + +NTSTATUS +NTAPI +MiZeroFillSection(PVOID Address, PLARGE_INTEGER FileOffsetPtr, ULONG Length); + +VOID +MmPageOutDeleteMapping(PVOID Context, PEPROCESS Process, PVOID Address); + +ULONG +NTAPI +MmGetPageEntrySectionSegment(PMM_SECTION_SEGMENT Segment, + ULONG Offset); + +VOID +NTAPI +MmSharePageEntrySectionSegment(PMM_SECTION_SEGMENT Segment, + ULONG Offset); + +BOOLEAN +NTAPI +MmUnsharePageEntrySectionSegment(PROS_SECTION_OBJECT Section, + PMM_SECTION_SEGMENT Segment, + ULONG Offset, + BOOLEAN Dirty, + BOOLEAN PageOut); + +VOID +NTAPI +MmSetPageEntrySectionSegment(PMM_SECTION_SEGMENT Segment, + ULONG Offset, + ULONG Entry); + +NTSTATUS +MmspWaitForPageOpCompletionEvent(PMM_PAGEOP PageOp); + +VOID +NTAPI +MmLockSectionSegment(PMM_SECTION_SEGMENT Segment); + +VOID +NTAPI +MmUnlockSectionSegment(PMM_SECTION_SEGMENT Segment); + +VOID +MmspCompleteAndReleasePageOp(PMM_PAGEOP PageOp); + +PFILE_OBJECT +NTAPI +MmGetFileObjectForSection( + IN PROS_SECTION_OBJECT Section +); +NTSTATUS +NTAPI +MmGetFileNameForAddress( + IN PVOID Address, + OUT PUNICODE_STRING ModuleName +); + +NTSTATUS +NTAPI +MmGetFileNameForSection( + IN PROS_SECTION_OBJECT Section, + OUT POBJECT_NAME_INFORMATION *ModuleName +); + +NTSTATUS +NTAPI +MiFlushMappedSection(PVOID BaseAddress, PLARGE_INTEGER FileSize); + +NTSTATUS +NTAPI +MmExtendSection(PROS_SECTION_OBJECT Section, PLARGE_INTEGER NewSize, BOOLEAN ExtendFile); + +PVOID +NTAPI +MmAllocateSection( + IN ULONG Length, + PVOID BaseAddress +); + +NTSTATUS +NTAPI +MmQuerySectionView( + PMEMORY_AREA MemoryArea, + PVOID Address, + PMEMORY_BASIC_INFORMATION Info, + PULONG ResultLength +); + +NTSTATUS +NTAPI +MmProtectSectionView( + PMMSUPPORT AddressSpace, + PMEMORY_AREA MemoryArea, + PVOID BaseAddress, + ULONG Length, + ULONG Protect, + PULONG OldProtect +); + +NTSTATUS +NTAPI +MmWritePageSectionView( + PMMSUPPORT AddressSpace, + PMEMORY_AREA MArea, + PVOID Address, + PMM_PAGEOP PageOp +); + +NTSTATUS +NTAPI +MmInitSectionImplementation(VOID); + +NTSTATUS +NTAPI +MmNotPresentFaultSectionView( + PMMSUPPORT AddressSpace, + MEMORY_AREA* MemoryArea, + PVOID Address, + BOOLEAN Locked +); + +NTSTATUS +NTAPI +MmPageOutSectionView( + PMMSUPPORT AddressSpace, + PMEMORY_AREA MemoryArea, + PVOID Address, + struct _MM_PAGEOP *PageOp +); + +NTSTATUS +NTAPI +MmAccessFaultSectionView( + PMMSUPPORT AddressSpace, + MEMORY_AREA* MemoryArea, + PVOID Address, + BOOLEAN Locked +); + +VOID +NTAPI +MmFreeSectionSegments(PFILE_OBJECT FileObject); + +NTSTATUS NTAPI +MmMapViewInSystemSpaceAtOffset +(IN PVOID SectionObject, + OUT PVOID * MappedBase, + IN PLARGE_INTEGER ViewOffset, + IN OUT PULONG ViewSize); + +NTSTATUS +NTAPI +MiMapViewOfSegment(PMMSUPPORT AddressSpace, + PROS_SECTION_OBJECT Section, + PMM_SECTION_SEGMENT Segment, + PVOID* BaseAddress, + SIZE_T ViewSize, + ULONG Protect, + ULONG ViewOffset, + ULONG AllocationType); + +/* section/image.c ***********************************************************/ + +NTSTATUS +NTAPI +MmPageOutImageFile +(PMMSUPPORT AddressSpace, + MEMORY_AREA* MemoryArea, + PVOID Address, + PMM_PAGEOP PageOp); + +NTSTATUS +NTAPI +MmNotPresentFaultImageFile +(PMMSUPPORT AddressSpace, + MEMORY_AREA* MemoryArea, + PVOID Address, + BOOLEAN Locked); + +NTSTATUS +NTAPI +MmAccessFaultImageFile +(PMMSUPPORT AddressSpace, + MEMORY_AREA* MemoryArea, + PVOID Address, + BOOLEAN Locked); + +NTSTATUS +NTAPI +MiMapImageFileSection +(PMMSUPPORT AddressSpace, + PROS_SECTION_OBJECT Section, + PVOID *BaseAddress); + +NTSTATUS +MmCreateImageSection +(PROS_SECTION_OBJECT *SectionObject, + ACCESS_MASK DesiredAccess, + POBJECT_ATTRIBUTES ObjectAttributes, + PLARGE_INTEGER UMaximumSize, + ULONG SectionPageProtection, + ULONG AllocationAttributes, + PFILE_OBJECT FileObject); + +NTSTATUS +NTAPI +MiAwaitPageOps(PMMSUPPORT AddressSpace, PMEMORY_AREA MemoryArea, PVOID BaseAddress); + +NTSTATUS +NTAPI +MmUnmapViewOfSegment(PMMSUPPORT AddressSpace, + PVOID BaseAddress); + +NTSTATUS +NTAPI +MiUnmapImageSection +(PMMSUPPORT AddressSpace, PMEMORY_AREA MemoryArea, PVOID BaseAddress); + +VOID +NTAPI +MiDeleteImageSection(PROS_SECTION_OBJECT Section); + +/* section/physical.c ********************************************************/ + +NTSTATUS +NTAPI +MmNotPresentFaultPhysicalMemory +(PMMSUPPORT AddressSpace, + MEMORY_AREA* MemoryArea, + PVOID Address, + BOOLEAN Locked); + +NTSTATUS +NTAPI +MmAccessFaultPhysicalMemory +(PMMSUPPORT AddressSpace, + MEMORY_AREA* MemoryArea, + PVOID Address, + BOOLEAN Locked); + +NTSTATUS +NTAPI +MmCreatePhysicalMemorySection(); + +VOID +NTAPI +MmUnmapPhysicalMemorySegment +(PMMSUPPORT AddressSpace, + PMEMORY_AREA MemoryArea, + PROS_SECTION_OBJECT Section, + PMM_SECTION_SEGMENT Segment); + +/* section/pagefile.c ********************************************************/ + +NTSTATUS +NTAPI +MmNotPresentFaultPageFile +(PMMSUPPORT AddressSpace, + MEMORY_AREA* MemoryArea, + PVOID Address, + BOOLEAN Locked); + +NTSTATUS +NTAPI +MmAccessFaultPageFile +(PMMSUPPORT AddressSpace, + MEMORY_AREA* MemoryArea, + PVOID Address, + BOOLEAN Locked); + +NTSTATUS +NTAPI +MmCreatePageFileSection +(PROS_SECTION_OBJECT *SectionObject, + ACCESS_MASK DesiredAccess, + POBJECT_ATTRIBUTES ObjectAttributes, + PLARGE_INTEGER UMaximumSize, + ULONG SectionPageProtection, + ULONG AllocationAttributes); + +NTSTATUS +NTAPI +MmPageOutPageFileView +(PMMSUPPORT AddressSpace, + PMEMORY_AREA MemoryArea, + PVOID Address, + struct _MM_PAGEOP *PageOp); + +VOID +NTAPI +MmUnmapPageFileSegment +(PMMSUPPORT AddressSpace, + PMEMORY_AREA MemoryArea, + PROS_SECTION_OBJECT Section, + PMM_SECTION_SEGMENT Segment); + +/* mpw.c *********************************************************************/ + +NTSTATUS +NTAPI +MmInitMpwThread(VOID); + +NTSTATUS +NTAPI +MmInitBsmThread(VOID); + +/* pager.c *******************************************************************/ + +BOOLEAN +NTAPI +MiIsPagerThread(VOID); + +VOID +NTAPI +MiStartPagerThread(VOID); + +VOID +NTAPI +MiStopPagerThread(VOID); + +NTSTATUS +FASTCALL +MiQueryVirtualMemory( + IN HANDLE ProcessHandle, + IN PVOID Address, + IN MEMORY_INFORMATION_CLASS VirtualMemoryInformationClass, + OUT PVOID VirtualMemoryInformation, + IN ULONG Length, + OUT PULONG ResultLength +); + +/* sysldr.c ******************************************************************/ + +VOID +NTAPI +MiReloadBootLoadedDrivers( + IN PLOADER_PARAMETER_BLOCK LoaderBlock +); + +BOOLEAN +NTAPI +MiInitializeLoadedModuleList( + IN PLOADER_PARAMETER_BLOCK LoaderBlock +); + +NTSTATUS +NTAPI +MmLoadSystemImage( + IN PUNICODE_STRING FileName, + IN PUNICODE_STRING NamePrefix OPTIONAL, + IN PUNICODE_STRING LoadedName OPTIONAL, + IN ULONG Flags, + OUT PVOID *ModuleObject, + OUT PVOID *ImageBaseAddress +); + +NTSTATUS +NTAPI +MmUnloadSystemImage( + IN PVOID ImageHandle +); + +NTSTATUS +NTAPI +MmCheckSystemImage( + IN HANDLE ImageHandle, + IN BOOLEAN PurgeSection +); + +NTSTATUS +NTAPI +MmCallDllInitialize( + IN PLDR_DATA_TABLE_ENTRY LdrEntry, + IN PLIST_ENTRY ListHead +); + +/* ReactOS Mm Hacks */ +VOID +FASTCALL +MiSyncForProcessAttach( + IN PKTHREAD NextThread, + IN PEPROCESS Process +); + +VOID +FASTCALL +MiSyncForContextSwitch( + IN PKTHREAD Thread +); + +extern PMMSUPPORT MmKernelAddressSpace; + +FORCEINLINE +VOID +MmLockAddressSpace(PMMSUPPORT AddressSpace) +{ + KeAcquireGuardedMutex(&CONTAINING_RECORD(AddressSpace, EPROCESS, Vm)->AddressCreationLock); +} + +FORCEINLINE +VOID +MmUnlockAddressSpace(PMMSUPPORT AddressSpace) +{ + KeReleaseGuardedMutex(&CONTAINING_RECORD(AddressSpace, EPROCESS, Vm)->AddressCreationLock); +} + +FORCEINLINE +PEPROCESS +MmGetAddressSpaceOwner(IN PMMSUPPORT AddressSpace) +{ + if (AddressSpace == MmKernelAddressSpace) return NULL; + return CONTAINING_RECORD(AddressSpace, EPROCESS, Vm); +} + +FORCEINLINE +PMMSUPPORT +MmGetCurrentAddressSpace(VOID) +{ + return &((PEPROCESS)KeGetCurrentThread()->ApcState.Process)->Vm; +} + +FORCEINLINE +PMMSUPPORT +MmGetKernelAddressSpace(VOID) +{ + return MmKernelAddressSpace; +} + +#endif
Propchange: branches/arty-newcc/ntoskrnl/include/internal/newmm.h ------------------------------------------------------------------------------ svn:eol-style = native
-
arty＠svn.reactos.org