--- /dev/null
+/*
+ * Copyright (C) 1998-2005 ReactOS Team (and the authors from the programmers section)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ *
+ * PROJECT: ReactOS kernel
+ * FILE: ntoskrnl/mm/section.c
+ * PURPOSE: Implements section objects
+ *
+ * PROGRAMMERS: Rex Jolliff
+ * David Welch
+ * Eric Kohl
+ * Emanuele Aliberti
+ * Eugene Ingerman
+ * Casper Hornstrup
+ * KJK::Hyperion
+ * Guido de Jong
+ * Ge van Geldorp
+ * Royce Mitchell III
+ * Filip Navara
+ * Aleksey Bragin
+ * Jason Filby
+ * Thomas Weidenmueller
+ * Gunnar Andre' Dalsnes
+ * Mike Nordell
+ * Alex Ionescu
+ * Gregor Anich
+ * Steven Edwards
+ * Herve Poussineau
+ */
+
+/* INCLUDES *****************************************************************/
+
+#include <ntoskrnl.h>
+#include <cache/newcc.h>
+#include <cache/section/newmm.h>
+#define NDEBUG
+#include <debug.h>
+#include <reactos/exeformat.h>
+
+#if defined (ALLOC_PRAGMA)
+#pragma alloc_text(INIT, MmCreatePhysicalMemorySection)
+#pragma alloc_text(INIT, MmInitSectionImplementation)
+#endif
+
+#include "ARM3/miarm.h"
+
+#undef MmSetPageEntrySectionSegment
+#define MmSetPageEntrySectionSegment(S,O,E) do { \
+ DPRINT("SetPageEntrySectionSegment(old,%p,%x,%x)\n",(S),(O)->LowPart,E); \
+ _MmSetPageEntrySectionSegment((S),(O),(E),__FILE__,__LINE__); \
+ } while (0)
+
+extern MMSESSION MmSession;
+
+NTSTATUS
+NTAPI
+MiMapViewInSystemSpace(IN PVOID Section,
+ IN PVOID Session,
+ OUT PVOID *MappedBase,
+ IN OUT PSIZE_T ViewSize);
+
+NTSTATUS
+NTAPI
+MmCreateArm3Section(OUT PVOID *SectionObject,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
+ IN PLARGE_INTEGER InputMaximumSize,
+ IN ULONG SectionPageProtection,
+ IN ULONG AllocationAttributes,
+ IN HANDLE FileHandle OPTIONAL,
+ IN PFILE_OBJECT FileObject OPTIONAL);
+
+NTSTATUS
+NTAPI
+MmMapViewOfArm3Section(IN PVOID SectionObject,
+ IN PEPROCESS Process,
+ IN OUT PVOID *BaseAddress,
+ IN ULONG_PTR ZeroBits,
+ IN SIZE_T CommitSize,
+ IN OUT PLARGE_INTEGER SectionOffset OPTIONAL,
+ IN OUT PSIZE_T ViewSize,
+ IN SECTION_INHERIT InheritDisposition,
+ IN ULONG AllocationType,
+ IN ULONG Protect);
+
+//
+// PeFmtCreateSection depends on the following:
+//
+C_ASSERT(EXEFMT_LOAD_HEADER_SIZE >= sizeof(IMAGE_DOS_HEADER));
+C_ASSERT(sizeof(IMAGE_NT_HEADERS32) <= sizeof(IMAGE_NT_HEADERS64));
+
+C_ASSERT(TYPE_ALIGNMENT(IMAGE_NT_HEADERS32) == TYPE_ALIGNMENT(IMAGE_NT_HEADERS64));
+C_ASSERT(RTL_SIZEOF_THROUGH_FIELD(IMAGE_NT_HEADERS32, FileHeader) == RTL_SIZEOF_THROUGH_FIELD(IMAGE_NT_HEADERS64, FileHeader));
+C_ASSERT(FIELD_OFFSET(IMAGE_NT_HEADERS32, OptionalHeader) == FIELD_OFFSET(IMAGE_NT_HEADERS64, OptionalHeader));
+
+C_ASSERT(PEFMT_FIELDS_EQUAL(IMAGE_OPTIONAL_HEADER32, IMAGE_OPTIONAL_HEADER64, Magic));
+C_ASSERT(PEFMT_FIELDS_EQUAL(IMAGE_OPTIONAL_HEADER32, IMAGE_OPTIONAL_HEADER64, SectionAlignment));
+C_ASSERT(PEFMT_FIELDS_EQUAL(IMAGE_OPTIONAL_HEADER32, IMAGE_OPTIONAL_HEADER64, FileAlignment));
+C_ASSERT(PEFMT_FIELDS_EQUAL(IMAGE_OPTIONAL_HEADER32, IMAGE_OPTIONAL_HEADER64, Subsystem));
+C_ASSERT(PEFMT_FIELDS_EQUAL(IMAGE_OPTIONAL_HEADER32, IMAGE_OPTIONAL_HEADER64, MinorSubsystemVersion));
+C_ASSERT(PEFMT_FIELDS_EQUAL(IMAGE_OPTIONAL_HEADER32, IMAGE_OPTIONAL_HEADER64, MajorSubsystemVersion));
+C_ASSERT(PEFMT_FIELDS_EQUAL(IMAGE_OPTIONAL_HEADER32, IMAGE_OPTIONAL_HEADER64, AddressOfEntryPoint));
+C_ASSERT(PEFMT_FIELDS_EQUAL(IMAGE_OPTIONAL_HEADER32, IMAGE_OPTIONAL_HEADER64, SizeOfCode));
+C_ASSERT(PEFMT_FIELDS_EQUAL(IMAGE_OPTIONAL_HEADER32, IMAGE_OPTIONAL_HEADER64, SizeOfHeaders));
+
+/* TYPES *********************************************************************/
+
+typedef struct
+{
+ PROS_SECTION_OBJECT Section;
+ PMM_SECTION_SEGMENT Segment;
+ LARGE_INTEGER Offset;
+ BOOLEAN WasDirty;
+ BOOLEAN Private;
+ PEPROCESS CallingProcess;
+ ULONG_PTR SectionEntry;
+}
+MM_SECTION_PAGEOUT_CONTEXT;
+
+/* GLOBALS *******************************************************************/
+
+POBJECT_TYPE MmSectionObjectType = NULL;
+
+ULONG_PTR MmSubsectionBase;
+
+static ULONG SectionCharacteristicsToProtect[16] =
+{
+ PAGE_NOACCESS, /* 0 = NONE */
+ PAGE_NOACCESS, /* 1 = SHARED */
+ PAGE_EXECUTE, /* 2 = EXECUTABLE */
+ PAGE_EXECUTE, /* 3 = EXECUTABLE, SHARED */
+ PAGE_READONLY, /* 4 = READABLE */
+ PAGE_READONLY, /* 5 = READABLE, SHARED */
+ PAGE_EXECUTE_READ, /* 6 = READABLE, EXECUTABLE */
+ PAGE_EXECUTE_READ, /* 7 = READABLE, EXECUTABLE, SHARED */
+ /*
+ * FIXME? do we really need the WriteCopy field in segments? can't we use
+ * PAGE_WRITECOPY here?
+ */
+ PAGE_READWRITE, /* 8 = WRITABLE */
+ PAGE_READWRITE, /* 9 = WRITABLE, SHARED */
+ PAGE_EXECUTE_READWRITE, /* 10 = WRITABLE, EXECUTABLE */
+ PAGE_EXECUTE_READWRITE, /* 11 = WRITABLE, EXECUTABLE, SHARED */
+ PAGE_READWRITE, /* 12 = WRITABLE, READABLE */
+ PAGE_READWRITE, /* 13 = WRITABLE, READABLE, SHARED */
+ PAGE_EXECUTE_READWRITE, /* 14 = WRITABLE, READABLE, EXECUTABLE */
+ PAGE_EXECUTE_READWRITE, /* 15 = WRITABLE, READABLE, EXECUTABLE, SHARED */
+};
+
+extern ULONG MmMakeFileAccess [];
+ACCESS_MASK NTAPI MiArm3GetCorrectFileAccessMask(IN ACCESS_MASK SectionPageProtection);
+static GENERIC_MAPPING MmpSectionMapping =
+{
+ STANDARD_RIGHTS_READ | SECTION_MAP_READ | SECTION_QUERY,
+ STANDARD_RIGHTS_WRITE | SECTION_MAP_WRITE,
+ STANDARD_RIGHTS_EXECUTE | SECTION_MAP_EXECUTE,
+ SECTION_ALL_ACCESS
+};
+
+
+/* FUNCTIONS *****************************************************************/
+
+
+/*
+ References:
+ [1] Microsoft Corporation, "Microsoft Portable Executable and Common Object
+ File Format Specification", revision 6.0 (February 1999)
+*/
+NTSTATUS NTAPI PeFmtCreateSection(IN CONST VOID * FileHeader,
+ IN SIZE_T FileHeaderSize,
+ IN PVOID File,
+ OUT PMM_IMAGE_SECTION_OBJECT ImageSectionObject,
+ OUT PULONG Flags,
+ IN PEXEFMT_CB_READ_FILE ReadFileCb,
+ IN PEXEFMT_CB_ALLOCATE_SEGMENTS AllocateSegmentsCb)
+{
+ NTSTATUS nStatus;
+ ULONG cbFileHeaderOffsetSize = 0;
+ ULONG cbSectionHeadersOffset = 0;
+ ULONG cbSectionHeadersSize;
+ ULONG cbSectionHeadersOffsetSize = 0;
+ ULONG cbOptHeaderSize;
+ ULONG cbHeadersSize = 0;
+ ULONG nSectionAlignment;
+ ULONG nFileAlignment;
+ ULONG_PTR ImageBase;
+ const IMAGE_DOS_HEADER * pidhDosHeader;
+ const IMAGE_NT_HEADERS32 * pinhNtHeader;
+ const IMAGE_OPTIONAL_HEADER32 * piohOptHeader;
+ const IMAGE_SECTION_HEADER * pishSectionHeaders;
+ PMM_SECTION_SEGMENT pssSegments;
+ LARGE_INTEGER lnOffset;
+ PVOID pBuffer;
+ SIZE_T nPrevVirtualEndOfSegment = 0;
+ ULONG nFileSizeOfHeaders = 0;
+ ULONG i;
+ ULONG AlignedLength;
+
+ ASSERT(FileHeader);
+ ASSERT(FileHeaderSize > 0);
+ ASSERT(File);
+ ASSERT(ImageSectionObject);
+ ASSERT(ReadFileCb);
+ ASSERT(AllocateSegmentsCb);
+
+ ASSERT(Intsafe_CanOffsetPointer(FileHeader, FileHeaderSize));
+
+ ASSERT(((UINT_PTR)FileHeader % TYPE_ALIGNMENT(IMAGE_DOS_HEADER)) == 0);
+
+#define DIE(ARGS_) { DPRINT ARGS_; goto l_Return; }
+
+ pBuffer = NULL;
+ pidhDosHeader = FileHeader;
+
+ /* DOS HEADER */
+ nStatus = STATUS_ROS_EXEFMT_UNKNOWN_FORMAT;
+
+ /* image too small to be an MZ executable */
+ if(FileHeaderSize < sizeof(IMAGE_DOS_HEADER))
+ DIE(("Too small to be an MZ executable, size is %lu\n", FileHeaderSize));
+
+ /* no MZ signature */
+ if(pidhDosHeader->e_magic != IMAGE_DOS_SIGNATURE)
+ DIE(("No MZ signature found, e_magic is %hX\n", pidhDosHeader->e_magic));
+
+ /* NT HEADER */
+ nStatus = STATUS_INVALID_IMAGE_PROTECT;
+
+ /* not a Windows executable */
+ if(pidhDosHeader->e_lfanew <= 0)
+ DIE(("Not a Windows executable, e_lfanew is %d\n", pidhDosHeader->e_lfanew));
+
+ if(!Intsafe_AddULong32(&cbFileHeaderOffsetSize, pidhDosHeader->e_lfanew, RTL_SIZEOF_THROUGH_FIELD(IMAGE_NT_HEADERS32, FileHeader)))
+ DIE(("The DOS stub is too large, e_lfanew is %X\n", pidhDosHeader->e_lfanew));
+
+ if(FileHeaderSize < cbFileHeaderOffsetSize)
+ pinhNtHeader = NULL;
+ else
+ {
+ /*
+ * we already know that Intsafe_CanOffsetPointer(FileHeader, FileHeaderSize),
+ * and FileHeaderSize >= cbFileHeaderOffsetSize, so this holds true too
+ */
+ ASSERT(Intsafe_CanOffsetPointer(FileHeader, pidhDosHeader->e_lfanew));
+ pinhNtHeader = (PVOID)((UINT_PTR)FileHeader + pidhDosHeader->e_lfanew);
+ }
+
+ /*
+ * the buffer doesn't contain the NT file header, or the alignment is wrong: we
+ * need to read the header from the file
+ */
+ if(FileHeaderSize < cbFileHeaderOffsetSize ||
+ (UINT_PTR)pinhNtHeader % TYPE_ALIGNMENT(IMAGE_NT_HEADERS32) != 0)
+ {
+ ULONG cbNtHeaderSize;
+ ULONG cbReadSize;
+ PVOID pData;
+
+l_ReadHeaderFromFile:
+ cbNtHeaderSize = 0;
+ lnOffset.QuadPart = pidhDosHeader->e_lfanew;
+
+ /* read the header from the file */
+ nStatus = ReadFileCb(File, &lnOffset, sizeof(IMAGE_NT_HEADERS64), &pData, &pBuffer, &cbReadSize);
+
+ if(!NT_SUCCESS(nStatus))
+ {
+ NTSTATUS ReturnedStatus = nStatus;
+
+ /* If it attempted to read past the end of the file, it means e_lfanew is invalid */
+ if (ReturnedStatus == STATUS_END_OF_FILE) nStatus = STATUS_INVALID_IMAGE_PROTECT;
+
+ DIE(("ReadFile failed, status %08X\n", ReturnedStatus));
+ }
+
+ ASSERT(pData);
+ ASSERT(pBuffer);
+ ASSERT(cbReadSize > 0);
+
+ nStatus = STATUS_INVALID_IMAGE_FORMAT;
+
+ /* the buffer doesn't contain the file header */
+ if(cbReadSize < RTL_SIZEOF_THROUGH_FIELD(IMAGE_NT_HEADERS32, FileHeader))
+ DIE(("The file doesn't contain the PE file header\n"));
+
+ pinhNtHeader = pData;
+
+ /* object still not aligned: copy it to the beginning of the buffer */
+ if((UINT_PTR)pinhNtHeader % TYPE_ALIGNMENT(IMAGE_NT_HEADERS32) != 0)
+ {
+ ASSERT((UINT_PTR)pBuffer % TYPE_ALIGNMENT(IMAGE_NT_HEADERS32) == 0);
+ RtlMoveMemory(pBuffer, pData, cbReadSize);
+ pinhNtHeader = pBuffer;
+ }
+
+ /* invalid NT header */
+ nStatus = STATUS_INVALID_IMAGE_PROTECT;
+
+ if(pinhNtHeader->Signature != IMAGE_NT_SIGNATURE)
+ DIE(("The file isn't a PE executable, Signature is %X\n", pinhNtHeader->Signature));
+
+ nStatus = STATUS_INVALID_IMAGE_FORMAT;
+
+ if(!Intsafe_AddULong32(&cbNtHeaderSize, pinhNtHeader->FileHeader.SizeOfOptionalHeader, FIELD_OFFSET(IMAGE_NT_HEADERS32, OptionalHeader)))
+ DIE(("The full NT header is too large\n"));
+
+ /* the buffer doesn't contain the whole NT header */
+ if(cbReadSize < cbNtHeaderSize)
+ DIE(("The file doesn't contain the full NT header\n"));
+ }
+ else
+ {
+ ULONG cbOptHeaderOffsetSize = 0;
+
+ nStatus = STATUS_INVALID_IMAGE_PROTECT;
+
+ /* don't trust an invalid NT header */
+ if(pinhNtHeader->Signature != IMAGE_NT_SIGNATURE)
+ DIE(("The file isn't a PE executable, Signature is %X\n", pinhNtHeader->Signature));
+
+ if(!Intsafe_AddULong32(&cbOptHeaderOffsetSize, pidhDosHeader->e_lfanew, FIELD_OFFSET(IMAGE_NT_HEADERS32, OptionalHeader)))
+ DIE(("The DOS stub is too large, e_lfanew is %X\n", pidhDosHeader->e_lfanew));
+
+ nStatus = STATUS_INVALID_IMAGE_FORMAT;
+
+ if(!Intsafe_AddULong32(&cbOptHeaderOffsetSize, cbOptHeaderOffsetSize, pinhNtHeader->FileHeader.SizeOfOptionalHeader))
+ DIE(("The NT header is too large, SizeOfOptionalHeader is %X\n", pinhNtHeader->FileHeader.SizeOfOptionalHeader));
+
+ /* the buffer doesn't contain the whole NT header: read it from the file */
+ if(cbOptHeaderOffsetSize > FileHeaderSize)
+ goto l_ReadHeaderFromFile;
+ }
+
+ /* read information from the NT header */
+ piohOptHeader = &pinhNtHeader->OptionalHeader;
+ cbOptHeaderSize = pinhNtHeader->FileHeader.SizeOfOptionalHeader;
+
+ nStatus = STATUS_INVALID_IMAGE_FORMAT;
+
+ if(!RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, Magic))
+ DIE(("The optional header doesn't contain the Magic field, SizeOfOptionalHeader is %X\n", cbOptHeaderSize));
+
+ /* ASSUME: RtlZeroMemory(ImageSectionObject, sizeof(*ImageSectionObject)); */
+
+ switch(piohOptHeader->Magic)
+ {
+ case IMAGE_NT_OPTIONAL_HDR32_MAGIC:
+#ifdef _WIN64
+ case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
+#endif // _WIN64
+ break;
+
+ default:
+ DIE(("Unrecognized optional header, Magic is %X\n", piohOptHeader->Magic));
+ }
+
+ if (RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, SectionAlignment) &&
+ RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, FileAlignment))
+ {
+ /* See [1], section 3.4.2 */
+ if(piohOptHeader->SectionAlignment < PAGE_SIZE)
+ {
+ if(piohOptHeader->FileAlignment != piohOptHeader->SectionAlignment)
+ DIE(("Sections aren't page-aligned and the file alignment isn't the same\n"));
+ }
+ else if(piohOptHeader->SectionAlignment < piohOptHeader->FileAlignment)
+ DIE(("The section alignment is smaller than the file alignment\n"));
+
+ nSectionAlignment = piohOptHeader->SectionAlignment;
+ nFileAlignment = piohOptHeader->FileAlignment;
+
+ if(!IsPowerOf2(nSectionAlignment) || !IsPowerOf2(nFileAlignment))
+ DIE(("The section alignment (%u) and file alignment (%u) aren't both powers of 2\n", nSectionAlignment, nFileAlignment));
+ }
+ else
+ {
+ nSectionAlignment = PAGE_SIZE;
+ nFileAlignment = PAGE_SIZE;
+ }
+
+ ASSERT(IsPowerOf2(nSectionAlignment));
+ ASSERT(IsPowerOf2(nFileAlignment));
+
+ switch(piohOptHeader->Magic)
+ {
+ /* PE32 */
+ case IMAGE_NT_OPTIONAL_HDR32_MAGIC:
+ {
+ if (RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, ImageBase))
+ ImageBase = piohOptHeader->ImageBase;
+
+ if(RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, SizeOfImage))
+ ImageSectionObject->ImageInformation.ImageFileSize = piohOptHeader->SizeOfImage;
+
+ if(RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, SizeOfStackReserve))
+ ImageSectionObject->ImageInformation.MaximumStackSize = piohOptHeader->SizeOfStackReserve;
+
+ if(RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, SizeOfStackCommit))
+ ImageSectionObject->ImageInformation.CommittedStackSize = piohOptHeader->SizeOfStackCommit;
+
+ if (RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, Subsystem))
+ {
+ ImageSectionObject->ImageInformation.SubSystemType = piohOptHeader->Subsystem;
+
+ if (RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, MinorSubsystemVersion) &&
+ RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, MajorSubsystemVersion))
+ {
+ ImageSectionObject->ImageInformation.SubSystemMinorVersion = piohOptHeader->MinorSubsystemVersion;
+ ImageSectionObject->ImageInformation.SubSystemMajorVersion = piohOptHeader->MajorSubsystemVersion;
+ }
+ }
+
+ if (RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, AddressOfEntryPoint))
+ {
+ ImageSectionObject->ImageInformation.TransferAddress = (PVOID) (ImageBase +
+ piohOptHeader->AddressOfEntryPoint);
+ }
+
+ if (RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, SizeOfCode))
+ ImageSectionObject->ImageInformation.ImageContainsCode = piohOptHeader->SizeOfCode != 0;
+ else
+ ImageSectionObject->ImageInformation.ImageContainsCode = TRUE;
+
+ if (RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, AddressOfEntryPoint))
+ {
+ if (piohOptHeader->AddressOfEntryPoint == 0)
+ {
+ ImageSectionObject->ImageInformation.ImageContainsCode = FALSE;
+ }
+ }
+
+ if (RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, LoaderFlags))
+ ImageSectionObject->ImageInformation.LoaderFlags = piohOptHeader->LoaderFlags;
+
+ if (RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, DllCharacteristics))
+ {
+ ImageSectionObject->ImageInformation.DllCharacteristics = piohOptHeader->DllCharacteristics;
+
+ /*
+ * Since we don't really implement SxS yet and LD doesn't supoprt /ALLOWISOLATION:NO, hard-code
+ * this flag here, which will prevent the loader and other code from doing any .manifest or SxS
+ * magic to any binary.
+ *
+ * This will break applications that depend on SxS when running with real Windows Kernel32/SxS/etc
+ * but honestly that's not tested. It will also break them when running no ReactOS once we implement
+ * the SxS support -- at which point, duh, this should be removed.
+ *
+ * But right now, any app depending on SxS is already broken anyway, so this flag only helps.
+ */
+ ImageSectionObject->ImageInformation.DllCharacteristics |= IMAGE_DLLCHARACTERISTICS_NO_ISOLATION;
+ }
+
+ break;
+ }
+#ifdef _WIN64
+ /* PE64 */
+ case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
+ {
+ const IMAGE_OPTIONAL_HEADER64 * pioh64OptHeader;
+
+ pioh64OptHeader = (const IMAGE_OPTIONAL_HEADER64 *)piohOptHeader;
+
+ if(RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, ImageBase))
+ {
+ ImageBase = pioh64OptHeader->ImageBase;
+ if(pioh64OptHeader->ImageBase > MAXULONG_PTR)
+ DIE(("ImageBase exceeds the address space\n"));
+ }
+
+ if(RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, SizeOfImage))
+ {
+ if(pioh64OptHeader->SizeOfImage > MAXULONG_PTR)
+ DIE(("SizeOfImage exceeds the address space\n"));
+
+ ImageSectionObject->ImageInformation.ImageFileSize = pioh64OptHeader->SizeOfImage;
+ }
+
+ if(RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, SizeOfStackReserve))
+ {
+ if(pioh64OptHeader->SizeOfStackReserve > MAXULONG_PTR)
+ DIE(("SizeOfStackReserve exceeds the address space\n"));
+
+ ImageSectionObject->ImageInformation.MaximumStackSize = (ULONG_PTR) pioh64OptHeader->SizeOfStackReserve;
+ }
+
+ if(RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, SizeOfStackCommit))
+ {
+ if(pioh64OptHeader->SizeOfStackCommit > MAXULONG_PTR)
+ DIE(("SizeOfStackCommit exceeds the address space\n"));
+
+ ImageSectionObject->ImageInformation.CommittedStackSize = (ULONG_PTR) pioh64OptHeader->SizeOfStackCommit;
+ }
+
+ if (RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, Subsystem))
+ {
+ ImageSectionObject->ImageInformation.SubSystemType = pioh64OptHeader->Subsystem;
+
+ if (RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, MinorSubsystemVersion) &&
+ RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, MajorSubsystemVersion))
+ {
+ ImageSectionObject->ImageInformation.SubSystemMinorVersion = pioh64OptHeader->MinorSubsystemVersion;
+ ImageSectionObject->ImageInformation.SubSystemMajorVersion = pioh64OptHeader->MajorSubsystemVersion;
+ }
+ }
+
+ if (RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, AddressOfEntryPoint))
+ {
+ ImageSectionObject->ImageInformation.TransferAddress = (PVOID) (ImageBase +
+ pioh64OptHeader->AddressOfEntryPoint);
+ }
+
+ if (RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, SizeOfCode))
+ ImageSectionObject->ImageInformation.ImageContainsCode = pioh64OptHeader->SizeOfCode != 0;
+ else
+ ImageSectionObject->ImageInformation.ImageContainsCode = TRUE;
+
+ if (RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, AddressOfEntryPoint))
+ {
+ if (pioh64OptHeader->AddressOfEntryPoint == 0)
+ {
+ ImageSectionObject->ImageInformation.ImageContainsCode = FALSE;
+ }
+ }
+
+ if (RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, LoaderFlags))
+ ImageSectionObject->ImageInformation.LoaderFlags = pioh64OptHeader->LoaderFlags;
+
+ if (RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, DllCharacteristics))
+ ImageSectionObject->ImageInformation.DllCharacteristics = pioh64OptHeader->DllCharacteristics;
+
+ break;
+ }
+#endif // _WIN64
+ }
+
+ /* [1], section 3.4.2 */
+ if((ULONG_PTR)ImageBase % 0x10000)
+ DIE(("ImageBase is not aligned on a 64KB boundary"));
+
+ ImageSectionObject->ImageInformation.ImageCharacteristics = pinhNtHeader->FileHeader.Characteristics;
+ ImageSectionObject->ImageInformation.Machine = pinhNtHeader->FileHeader.Machine;
+ ImageSectionObject->ImageInformation.GpValue = 0;
+ ImageSectionObject->ImageInformation.ZeroBits = 0;
+ ImageSectionObject->BasedAddress = (PVOID)ImageBase;
+
+ /* SECTION HEADERS */
+ nStatus = STATUS_INVALID_IMAGE_FORMAT;
+
+ /* see [1], section 3.3 */
+ if(pinhNtHeader->FileHeader.NumberOfSections > 96)
+ DIE(("Too many sections, NumberOfSections is %u\n", pinhNtHeader->FileHeader.NumberOfSections));
+
+ /*
+ * the additional segment is for the file's headers. They need to be present for
+ * the benefit of the dynamic loader (to locate exports, defaults for thread
+ * parameters, resources, etc.)
+ */
+ ImageSectionObject->NrSegments = pinhNtHeader->FileHeader.NumberOfSections + 1;
+
+ /* file offset for the section headers */
+ if(!Intsafe_AddULong32(&cbSectionHeadersOffset, pidhDosHeader->e_lfanew, FIELD_OFFSET(IMAGE_NT_HEADERS32, OptionalHeader)))
+ DIE(("Offset overflow\n"));
+
+ if(!Intsafe_AddULong32(&cbSectionHeadersOffset, cbSectionHeadersOffset, pinhNtHeader->FileHeader.SizeOfOptionalHeader))
+ DIE(("Offset overflow\n"));
+
+ /* size of the section headers */
+ ASSERT(Intsafe_CanMulULong32(pinhNtHeader->FileHeader.NumberOfSections, sizeof(IMAGE_SECTION_HEADER)));
+ cbSectionHeadersSize = pinhNtHeader->FileHeader.NumberOfSections * sizeof(IMAGE_SECTION_HEADER);
+
+ if(!Intsafe_AddULong32(&cbSectionHeadersOffsetSize, cbSectionHeadersOffset, cbSectionHeadersSize))
+ DIE(("Section headers too large\n"));
+
+ /* size of the executable's headers */
+ if(RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, SizeOfHeaders))
+ {
+// if(!IsAligned(piohOptHeader->SizeOfHeaders, nFileAlignment))
+// DIE(("SizeOfHeaders is not aligned\n"));
+
+ if(cbSectionHeadersSize > piohOptHeader->SizeOfHeaders)
+ DIE(("The section headers overflow SizeOfHeaders\n"));
+
+ cbHeadersSize = piohOptHeader->SizeOfHeaders;
+ }
+ else if(!AlignUp(&cbHeadersSize, cbSectionHeadersOffsetSize, nFileAlignment))
+ DIE(("Overflow aligning the size of headers\n"));
+
+ if(pBuffer)
+ {
+ ExFreePool(pBuffer);
+ pBuffer = NULL;
+ }
+ /* WARNING: pinhNtHeader IS NO LONGER USABLE */
+ /* WARNING: piohOptHeader IS NO LONGER USABLE */
+ /* WARNING: pioh64OptHeader IS NO LONGER USABLE */
+
+ if(FileHeaderSize < cbSectionHeadersOffsetSize)
+ pishSectionHeaders = NULL;
+ else
+ {
+ /*
+ * we already know that Intsafe_CanOffsetPointer(FileHeader, FileHeaderSize),
+ * and FileHeaderSize >= cbSectionHeadersOffsetSize, so this holds true too
+ */
+ ASSERT(Intsafe_CanOffsetPointer(FileHeader, cbSectionHeadersOffset));
+ pishSectionHeaders = (PVOID)((UINT_PTR)FileHeader + cbSectionHeadersOffset);
+ }
+
+ /*
+ * the buffer doesn't contain the section headers, or the alignment is wrong:
+ * read the headers from the file
+ */
+ if(FileHeaderSize < cbSectionHeadersOffsetSize ||
+ (UINT_PTR)pishSectionHeaders % TYPE_ALIGNMENT(IMAGE_SECTION_HEADER) != 0)
+ {
+ PVOID pData;
+ ULONG cbReadSize;
+
+ lnOffset.QuadPart = cbSectionHeadersOffset;
+
+ /* read the header from the file */
+ nStatus = ReadFileCb(File, &lnOffset, cbSectionHeadersSize, &pData, &pBuffer, &cbReadSize);
+
+ if(!NT_SUCCESS(nStatus))
+ DIE(("ReadFile failed with status %08X\n", nStatus));
+
+ ASSERT(pData);
+ ASSERT(pBuffer);
+ ASSERT(cbReadSize > 0);
+
+ nStatus = STATUS_INVALID_IMAGE_FORMAT;
+
+ /* the buffer doesn't contain all the section headers */
+ if(cbReadSize < cbSectionHeadersSize)
+ DIE(("The file doesn't contain all of the section headers\n"));
+
+ pishSectionHeaders = pData;
+
+ /* object still not aligned: copy it to the beginning of the buffer */
+ if((UINT_PTR)pishSectionHeaders % TYPE_ALIGNMENT(IMAGE_SECTION_HEADER) != 0)
+ {
+ ASSERT((UINT_PTR)pBuffer % TYPE_ALIGNMENT(IMAGE_SECTION_HEADER) == 0);
+ RtlMoveMemory(pBuffer, pData, cbReadSize);
+ pishSectionHeaders = pBuffer;
+ }
+ }
+
+ /* SEGMENTS */
+ /* allocate the segments */
+ nStatus = STATUS_INSUFFICIENT_RESOURCES;
+ ImageSectionObject->Segments = AllocateSegmentsCb(ImageSectionObject->NrSegments);
+
+ if(ImageSectionObject->Segments == NULL)
+ DIE(("AllocateSegments failed\n"));
+
+ /* initialize the headers segment */
+ pssSegments = ImageSectionObject->Segments;
+
+// ASSERT(IsAligned(cbHeadersSize, nFileAlignment));
+
+ if(!AlignUp(&nFileSizeOfHeaders, cbHeadersSize, nFileAlignment))
+ DIE(("Cannot align the size of the section headers\n"));
+
+ nPrevVirtualEndOfSegment = ALIGN_UP_BY(cbHeadersSize, nSectionAlignment);
+ if (nPrevVirtualEndOfSegment < cbHeadersSize)
+ DIE(("Cannot align the size of the section headers\n"));
+
+ pssSegments[0].Image.FileOffset = 0;
+ pssSegments[0].Protection = PAGE_READONLY;
+ pssSegments[0].Length.QuadPart = nPrevVirtualEndOfSegment;
+ pssSegments[0].RawLength.QuadPart = nFileSizeOfHeaders;
+ pssSegments[0].Image.VirtualAddress = 0;
+ pssSegments[0].Image.Characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA;
+ pssSegments[0].WriteCopy = TRUE;
+
+ /* skip the headers segment */
+ ++ pssSegments;
+
+ nStatus = STATUS_INVALID_IMAGE_FORMAT;
+
+ /* convert the executable sections into segments. See also [1], section 4 */
+ for(i = 0; i < ImageSectionObject->NrSegments - 1; ++ i)
+ {
+ ULONG nCharacteristics;
+
+ /* validate the alignment */
+ if(!IsAligned(pishSectionHeaders[i].VirtualAddress, nSectionAlignment))
+ DIE(("Image.VirtualAddress[%u] is not aligned\n", i));
+
+ /* sections must be contiguous, ordered by base address and non-overlapping */
+ if(pishSectionHeaders[i].VirtualAddress != nPrevVirtualEndOfSegment)
+ DIE(("Memory gap between section %u and the previous\n", i));
+
+ /* ignore explicit BSS sections */
+ if(pishSectionHeaders[i].SizeOfRawData != 0)
+ {
+ /* validate the alignment */
+#if 0
+ /* Yes, this should be a multiple of FileAlignment, but there's
+ * stuff out there that isn't. We can cope with that
+ */
+ if(!IsAligned(pishSectionHeaders[i].SizeOfRawData, nFileAlignment))
+ DIE(("SizeOfRawData[%u] is not aligned\n", i));
+#endif
+
+// if(!IsAligned(pishSectionHeaders[i].PointerToRawData, nFileAlignment))
+// DIE(("PointerToRawData[%u] is not aligned\n", i));
+
+ /* conversion */
+ pssSegments[i].Image.FileOffset = pishSectionHeaders[i].PointerToRawData;
+ pssSegments[i].RawLength.QuadPart = pishSectionHeaders[i].SizeOfRawData;
+ }
+ else
+ {
+ ASSERT(pssSegments[i].Image.FileOffset == 0);
+ ASSERT(pssSegments[i].RawLength.QuadPart == 0);
+ }
+
+ ASSERT(Intsafe_CanAddLong64(pssSegments[i].Image.FileOffset, pssSegments[i].RawLength.QuadPart));
+
+ nCharacteristics = pishSectionHeaders[i].Characteristics;
+
+ /* no explicit protection */
+ if((nCharacteristics & (IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE)) == 0)
+ {
+ if(nCharacteristics & IMAGE_SCN_CNT_CODE)
+ nCharacteristics |= IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ;
+
+ if(nCharacteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)
+ nCharacteristics |= IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE;
+
+ if(nCharacteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA)
+ nCharacteristics |= IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE;
+ }
+
+ /* see table above */
+ pssSegments[i].Protection = SectionCharacteristicsToProtect[nCharacteristics >> 28];
+ pssSegments[i].WriteCopy = !(nCharacteristics & IMAGE_SCN_MEM_SHARED);
+
+ if(pishSectionHeaders[i].Misc.VirtualSize == 0 || pishSectionHeaders[i].Misc.VirtualSize < pishSectionHeaders[i].SizeOfRawData)
+ pssSegments[i].Length.QuadPart = pishSectionHeaders[i].SizeOfRawData;
+ else
+ pssSegments[i].Length.QuadPart = pishSectionHeaders[i].Misc.VirtualSize;
+
+ AlignedLength = ALIGN_UP_BY(pssSegments[i].Length.LowPart, nSectionAlignment);
+ if(AlignedLength < pssSegments[i].Length.LowPart)
+ DIE(("Cannot align the virtual size of section %u\n", i));
+
+ pssSegments[i].Length.LowPart = AlignedLength;
+
+ if(pssSegments[i].Length.QuadPart == 0)
+ DIE(("Virtual size of section %u is null\n", i));
+
+ pssSegments[i].Image.VirtualAddress = pishSectionHeaders[i].VirtualAddress;
+ pssSegments[i].Image.Characteristics = pishSectionHeaders[i].Characteristics;
+
+ /* ensure the memory image is no larger than 4GB */
+ nPrevVirtualEndOfSegment = (ULONG_PTR)(pssSegments[i].Image.VirtualAddress + pssSegments[i].Length.QuadPart);
+ if (nPrevVirtualEndOfSegment < pssSegments[i].Image.VirtualAddress)
+ DIE(("The image is too large\n"));
+ }
+
+ if(nSectionAlignment >= PAGE_SIZE)
+ *Flags |= EXEFMT_LOAD_ASSUME_SEGMENTS_PAGE_ALIGNED;
+
+ /* Success */
+ nStatus = STATUS_SUCCESS;// STATUS_ROS_EXEFMT_LOADED_FORMAT | EXEFMT_LOADED_PE32;
+
+l_Return:
+ if(pBuffer)
+ ExFreePool(pBuffer);
+
+ return nStatus;
+}
+
+/*
+ * FUNCTION: Waits in kernel mode indefinitely for a file object lock.
+ * ARGUMENTS: PFILE_OBJECT to wait for.
+ * RETURNS: Status of the wait.
+ */
+NTSTATUS
+MmspWaitForFileLock(PFILE_OBJECT File)
+{
+ return STATUS_SUCCESS;
+ //return KeWaitForSingleObject(&File->Lock, 0, KernelMode, FALSE, NULL);
+}
+
+VOID
+NTAPI
+MmFreeSectionSegments(PFILE_OBJECT FileObject)
+{
+ if (FileObject->SectionObjectPointer->ImageSectionObject != NULL)
+ {
+ PMM_IMAGE_SECTION_OBJECT ImageSectionObject;
+ PMM_SECTION_SEGMENT SectionSegments;
+ ULONG NrSegments;
+ ULONG i;
+
+ ImageSectionObject = (PMM_IMAGE_SECTION_OBJECT)FileObject->SectionObjectPointer->ImageSectionObject;
+ NrSegments = ImageSectionObject->NrSegments;
+ SectionSegments = ImageSectionObject->Segments;
+ for (i = 0; i < NrSegments; i++)
+ {
+ if (SectionSegments[i].ReferenceCount != 0)
+ {
+ DPRINT1("Image segment %lu still referenced (was %lu)\n", i,
+ SectionSegments[i].ReferenceCount);
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+ MmFreePageTablesSectionSegment(&SectionSegments[i], NULL);
+ }
+ ExFreePool(ImageSectionObject->Segments);
+ ExFreePool(ImageSectionObject);
+ FileObject->SectionObjectPointer->ImageSectionObject = NULL;
+ }
+ if (FileObject->SectionObjectPointer->DataSectionObject != NULL)
+ {
+ PMM_SECTION_SEGMENT Segment;
+
+ Segment = (PMM_SECTION_SEGMENT)FileObject->SectionObjectPointer->
+ DataSectionObject;
+
+ if (Segment->ReferenceCount != 0)
+ {
+ DPRINT1("Data segment still referenced\n");
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+ MmFreePageTablesSectionSegment(Segment, NULL);
+ ExFreePool(Segment);
+ FileObject->SectionObjectPointer->DataSectionObject = NULL;
+ }
+}
+
+VOID
+NTAPI
+MmSharePageEntrySectionSegment(PMM_SECTION_SEGMENT Segment,
+ PLARGE_INTEGER Offset)
+{
+ ULONG_PTR Entry;
+
+ Entry = MmGetPageEntrySectionSegment(Segment, Offset);
+ if (Entry == 0)
+ {
+ DPRINT1("Entry == 0 for MmSharePageEntrySectionSegment\n");
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+ if (SHARE_COUNT_FROM_SSE(Entry) == MAX_SHARE_COUNT)
+ {
+ DPRINT1("Maximum share count reached\n");
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+ if (IS_SWAP_FROM_SSE(Entry))
+ {
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+ Entry = MAKE_SSE(PAGE_FROM_SSE(Entry), SHARE_COUNT_FROM_SSE(Entry) + 1);
+ MmSetPageEntrySectionSegment(Segment, Offset, Entry);
+}
+
+BOOLEAN
+NTAPI
+MmUnsharePageEntrySectionSegment(PROS_SECTION_OBJECT Section,
+ PMM_SECTION_SEGMENT Segment,
+ PLARGE_INTEGER Offset,
+ BOOLEAN Dirty,
+ BOOLEAN PageOut,
+ ULONG_PTR *InEntry)
+{
+ ULONG_PTR Entry = InEntry ? *InEntry : MmGetPageEntrySectionSegment(Segment, Offset);
+ BOOLEAN IsDirectMapped = FALSE;
+
+ if (Entry == 0)
+ {
+ DPRINT1("Entry == 0 for MmUnsharePageEntrySectionSegment\n");
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+ if (SHARE_COUNT_FROM_SSE(Entry) == 0)
+ {
+ DPRINT1("Zero share count for unshare (Seg %p Offset %x Page %x)\n", Segment, Offset->LowPart, PFN_FROM_SSE(Entry));
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+ if (IS_SWAP_FROM_SSE(Entry))
+ {
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+ Entry = MAKE_SSE(PAGE_FROM_SSE(Entry), SHARE_COUNT_FROM_SSE(Entry) - 1);
+ /*
+ * If we reducing the share count of this entry to zero then set the entry
+ * to zero and tell the cache the page is no longer mapped.
+ */
+ if (SHARE_COUNT_FROM_SSE(Entry) == 0)
+ {
+ PFILE_OBJECT FileObject;
+ SWAPENTRY SavedSwapEntry;
+ PFN_NUMBER Page;
+#ifndef NEWCC
+ PROS_SHARED_CACHE_MAP SharedCacheMap;
+ BOOLEAN IsImageSection;
+ LARGE_INTEGER FileOffset;
+
+ FileOffset.QuadPart = Offset->QuadPart + Segment->Image.FileOffset;
+ IsImageSection = Section->AllocationAttributes & SEC_IMAGE ? TRUE : FALSE;
+#endif
+
+ Page = PFN_FROM_SSE(Entry);
+ FileObject = Section->FileObject;
+ if (FileObject != NULL &&
+ !(Segment->Image.Characteristics & IMAGE_SCN_MEM_SHARED))
+ {
+
+#ifndef NEWCC
+ if ((FileOffset.QuadPart % PAGE_SIZE) == 0 &&
+ (Offset->QuadPart + PAGE_SIZE <= Segment->RawLength.QuadPart || !IsImageSection))
+ {
+ NTSTATUS Status;
+ SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
+ IsDirectMapped = TRUE;
+#ifndef NEWCC
+ Status = CcRosUnmapVacb(SharedCacheMap, FileOffset.QuadPart, Dirty);
+#else
+ Status = STATUS_SUCCESS;
+#endif
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("CcRosUnmapVacb failed, status = %x\n", Status);
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+ }
+#endif
+ }
+
+ SavedSwapEntry = MmGetSavedSwapEntryPage(Page);
+ if (SavedSwapEntry == 0)
+ {
+ if (!PageOut &&
+ ((Segment->Flags & MM_PAGEFILE_SEGMENT) ||
+ (Segment->Image.Characteristics & IMAGE_SCN_MEM_SHARED)))
+ {
+ /*
+ * FIXME:
+ * Try to page out this page and set the swap entry
+ * within the section segment. There exist no rmap entry
+ * for this page. The pager thread can't page out a
+ * page without a rmap entry.
+ */
+ MmSetPageEntrySectionSegment(Segment, Offset, Entry);
+ if (InEntry) *InEntry = Entry;
+ MiSetPageEvent(NULL, NULL);
+ }
+ else
+ {
+ MmSetPageEntrySectionSegment(Segment, Offset, 0);
+ if (InEntry) *InEntry = 0;
+ MiSetPageEvent(NULL, NULL);
+ if (!IsDirectMapped)
+ {
+ MmReleasePageMemoryConsumer(MC_USER, Page);
+ }
+ }
+ }
+ else
+ {
+ if ((Segment->Flags & MM_PAGEFILE_SEGMENT) ||
+ (Segment->Image.Characteristics & IMAGE_SCN_MEM_SHARED))
+ {
+ if (!PageOut)
+ {
+ if (Dirty)
+ {
+ /*
+ * FIXME:
+ * We hold all locks. Nobody can do something with the current
+ * process and the current segment (also not within an other process).
+ */
+ NTSTATUS Status;
+ Status = MmWriteToSwapPage(SavedSwapEntry, Page);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("MM: Failed to write to swap page (Status was 0x%.8X)\n", Status);
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+ }
+ MmSetPageEntrySectionSegment(Segment, Offset, MAKE_SWAP_SSE(SavedSwapEntry));
+ if (InEntry) *InEntry = MAKE_SWAP_SSE(SavedSwapEntry);
+ MmSetSavedSwapEntryPage(Page, 0);
+ MiSetPageEvent(NULL, NULL);
+ }
+ MmReleasePageMemoryConsumer(MC_USER, Page);
+ }
+ else
+ {
+ DPRINT1("Found a swapentry for a non private page in an image or data file sgment\n");
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+ }
+ }
+ else
+ {
+ if (InEntry)
+ *InEntry = Entry;
+ else
+ MmSetPageEntrySectionSegment(Segment, Offset, Entry);
+ }
+ return(SHARE_COUNT_FROM_SSE(Entry) > 0);
+}
+
+BOOLEAN MiIsPageFromCache(PMEMORY_AREA MemoryArea,
+ LONGLONG SegOffset)
+{
+#ifndef NEWCC
+ if (!(MemoryArea->Data.SectionData.Segment->Image.Characteristics & IMAGE_SCN_MEM_SHARED))
+ {
+ PROS_SHARED_CACHE_MAP SharedCacheMap;
+ PROS_VACB Vacb;
+ SharedCacheMap = MemoryArea->Data.SectionData.Section->FileObject->SectionObjectPointer->SharedCacheMap;
+ Vacb = CcRosLookupVacb(SharedCacheMap, SegOffset + MemoryArea->Data.SectionData.Segment->Image.FileOffset);
+ if (Vacb)
+ {
+ CcRosReleaseVacb(SharedCacheMap, Vacb, Vacb->Valid, FALSE, TRUE);
+ return TRUE;
+ }
+ }
+#endif
+ return FALSE;
+}
+
+NTSTATUS
+NTAPI
+MiCopyFromUserPage(PFN_NUMBER DestPage, PFN_NUMBER SrcPage)
+{
+ PEPROCESS Process;
+ KIRQL Irql, Irql2;
+ PVOID DestAddress, SrcAddress;
+
+ Process = PsGetCurrentProcess();
+ DestAddress = MiMapPageInHyperSpace(Process, DestPage, &Irql);
+ SrcAddress = MiMapPageInHyperSpace(Process, SrcPage, &Irql2);
+ if (DestAddress == NULL || SrcAddress == NULL)
+ {
+ return(STATUS_NO_MEMORY);
+ }
+ ASSERT((ULONG_PTR)DestAddress % PAGE_SIZE == 0);
+ ASSERT((ULONG_PTR)SrcAddress % PAGE_SIZE == 0);
+ RtlCopyMemory(DestAddress, SrcAddress, PAGE_SIZE);
+ MiUnmapPageInHyperSpace(Process, SrcAddress, Irql2);
+ MiUnmapPageInHyperSpace(Process, DestAddress, Irql);
+ return(STATUS_SUCCESS);
+}
+
+#ifndef NEWCC
+NTSTATUS
+NTAPI
+MiReadPage(PMEMORY_AREA MemoryArea,
+ LONGLONG SegOffset,
+ PPFN_NUMBER Page)
+/*
+ * FUNCTION: Read a page for a section backed memory area.
+ * PARAMETERS:
+ * MemoryArea - Memory area to read the page for.
+ * Offset - Offset of the page to read.
+ * Page - Variable that receives a page contains the read data.
+ */
+{
+ LONGLONG BaseOffset;
+ LONGLONG FileOffset;
+ PVOID BaseAddress;
+ BOOLEAN UptoDate;
+ PROS_VACB Vacb;
+ PFILE_OBJECT FileObject;
+ NTSTATUS Status;
+ LONGLONG RawLength;
+ PROS_SHARED_CACHE_MAP SharedCacheMap;
+ BOOLEAN IsImageSection;
+ LONGLONG Length;
+
+ FileObject = MemoryArea->Data.SectionData.Section->FileObject;
+ SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
+ RawLength = MemoryArea->Data.SectionData.Segment->RawLength.QuadPart;
+ FileOffset = SegOffset + MemoryArea->Data.SectionData.Segment->Image.FileOffset;
+ IsImageSection = MemoryArea->Data.SectionData.Section->AllocationAttributes & SEC_IMAGE ? TRUE : FALSE;
+
+ ASSERT(SharedCacheMap);
+
+ DPRINT("%S %I64x\n", FileObject->FileName.Buffer, FileOffset);
+
+ /*
+ * If the file system is letting us go directly to the cache and the
+ * memory area was mapped at an offset in the file which is page aligned
+ * then get the related VACB.
+ */
+ if (((FileOffset % PAGE_SIZE) == 0) &&
+ ((SegOffset + PAGE_SIZE <= RawLength) || !IsImageSection) &&
+ !(MemoryArea->Data.SectionData.Segment->Image.Characteristics & IMAGE_SCN_MEM_SHARED))
+ {
+
+ /*
+ * Get the related VACB; we use a lower level interface than
+ * filesystems do because it is safe for us to use an offset with an
+ * alignment less than the file system block size.
+ */
+ Status = CcRosGetVacb(SharedCacheMap,
+ FileOffset,
+ &BaseOffset,
+ &BaseAddress,
+ &UptoDate,
+ &Vacb);
+ if (!NT_SUCCESS(Status))
+ {
+ return(Status);
+ }
+ if (!UptoDate)
+ {
+ /*
+ * If the VACB isn't up to date then call the file
+ * system to read in the data.
+ */
+ Status = CcReadVirtualAddress(Vacb);
+ if (!NT_SUCCESS(Status))
+ {
+ CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE, FALSE);
+ return Status;
+ }
+ }
+
+ /* Probe the page, since it's PDE might not be synced */
+ (void)*((volatile char*)BaseAddress + FileOffset - BaseOffset);
+
+ /*
+ * Retrieve the page from the view that we actually want.
+ */
+ (*Page) = MmGetPhysicalAddress((char*)BaseAddress +
+ FileOffset - BaseOffset).LowPart >> PAGE_SHIFT;
+
+ CcRosReleaseVacb(SharedCacheMap, Vacb, TRUE, FALSE, TRUE);
+ }
+ else
+ {
+ PEPROCESS Process;
+ KIRQL Irql;
+ PVOID PageAddr;
+ LONGLONG VacbOffset;
+
+ /*
+ * Allocate a page, this is rather complicated by the possibility
+ * we might have to move other things out of memory
+ */
+ MI_SET_USAGE(MI_USAGE_SECTION);
+ MI_SET_PROCESS2(PsGetCurrentProcess()->ImageFileName);
+ Status = MmRequestPageMemoryConsumer(MC_USER, TRUE, Page);
+ if (!NT_SUCCESS(Status))
+ {
+ return(Status);
+ }
+ Status = CcRosGetVacb(SharedCacheMap,
+ FileOffset,
+ &BaseOffset,
+ &BaseAddress,
+ &UptoDate,
+ &Vacb);
+ if (!NT_SUCCESS(Status))
+ {
+ return(Status);
+ }
+ if (!UptoDate)
+ {
+ /*
+ * If the VACB isn't up to date then call the file
+ * system to read in the data.
+ */
+ Status = CcReadVirtualAddress(Vacb);
+ if (!NT_SUCCESS(Status))
+ {
+ CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE, FALSE);
+ return Status;
+ }
+ }
+
+ Process = PsGetCurrentProcess();
+ PageAddr = MiMapPageInHyperSpace(Process, *Page, &Irql);
+ VacbOffset = BaseOffset + VACB_MAPPING_GRANULARITY - FileOffset;
+ Length = RawLength - SegOffset;
+ if (Length <= VacbOffset && Length <= PAGE_SIZE)
+ {
+ memcpy(PageAddr, (char*)BaseAddress + FileOffset - BaseOffset, Length);
+ }
+ else if (VacbOffset >= PAGE_SIZE)
+ {
+ memcpy(PageAddr, (char*)BaseAddress + FileOffset - BaseOffset, PAGE_SIZE);
+ }
+ else
+ {
+ memcpy(PageAddr, (char*)BaseAddress + FileOffset - BaseOffset, VacbOffset);
+ MiUnmapPageInHyperSpace(Process, PageAddr, Irql);
+ CcRosReleaseVacb(SharedCacheMap, Vacb, TRUE, FALSE, FALSE);
+ Status = CcRosGetVacb(SharedCacheMap,
+ FileOffset + VacbOffset,
+ &BaseOffset,
+ &BaseAddress,
+ &UptoDate,
+ &Vacb);
+ if (!NT_SUCCESS(Status))
+ {
+ return(Status);
+ }
+ if (!UptoDate)
+ {
+ /*
+ * If the VACB isn't up to date then call the file
+ * system to read in the data.
+ */
+ Status = CcReadVirtualAddress(Vacb);
+ if (!NT_SUCCESS(Status))
+ {
+ CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE, FALSE);
+ return Status;
+ }
+ }
+ PageAddr = MiMapPageInHyperSpace(Process, *Page, &Irql);
+ if (Length < PAGE_SIZE)
+ {
+ memcpy((char*)PageAddr + VacbOffset, BaseAddress, Length - VacbOffset);
+ }
+ else
+ {
+ memcpy((char*)PageAddr + VacbOffset, BaseAddress, PAGE_SIZE - VacbOffset);
+ }
+ }
+ MiUnmapPageInHyperSpace(Process, PageAddr, Irql);
+ CcRosReleaseVacb(SharedCacheMap, Vacb, TRUE, FALSE, FALSE);
+ }
+ return(STATUS_SUCCESS);
+}
+#else
+NTSTATUS
+NTAPI
+MiReadPage(PMEMORY_AREA MemoryArea,
+ LONGLONG SegOffset,
+ PPFN_NUMBER Page)
+/*
+ * FUNCTION: Read a page for a section backed memory area.
+ * PARAMETERS:
+ * MemoryArea - Memory area to read the page for.
+ * Offset - Offset of the page to read.
+ * Page - Variable that receives a page contains the read data.
+ */
+{
+ MM_REQUIRED_RESOURCES Resources;
+ NTSTATUS Status;
+
+ RtlZeroMemory(&Resources, sizeof(MM_REQUIRED_RESOURCES));
+
+ Resources.Context = MemoryArea->Data.SectionData.Section->FileObject;
+ Resources.FileOffset.QuadPart = SegOffset +
+ MemoryArea->Data.SectionData.Segment->Image.FileOffset;
+ Resources.Consumer = MC_USER;
+ Resources.Amount = PAGE_SIZE;
+
+ DPRINT("%S, offset 0x%x, len 0x%x, page 0x%x\n", ((PFILE_OBJECT)Resources.Context)->FileName.Buffer, Resources.FileOffset.LowPart, Resources.Amount, Resources.Page[0]);
+
+ Status = MiReadFilePage(MmGetKernelAddressSpace(), MemoryArea, &Resources);
+ *Page = Resources.Page[0];
+ return Status;
+}
+#endif
+
+NTSTATUS
+NTAPI
+MmNotPresentFaultSectionView(PMMSUPPORT AddressSpace,
+ MEMORY_AREA* MemoryArea,
+ PVOID Address,
+ BOOLEAN Locked)
+{
+ LARGE_INTEGER Offset;
+ PFN_NUMBER Page;
+ NTSTATUS Status;
+ PROS_SECTION_OBJECT Section;
+ PMM_SECTION_SEGMENT Segment;
+ ULONG_PTR Entry;
+ ULONG_PTR Entry1;
+ ULONG Attributes;
+ PMM_REGION Region;
+ BOOLEAN HasSwapEntry;
+ PVOID PAddress;
+ PEPROCESS Process = MmGetAddressSpaceOwner(AddressSpace);
+ SWAPENTRY SwapEntry;
+
+ /*
+ * There is a window between taking the page fault and locking the
+ * address space when another thread could load the page so we check
+ * that.
+ */
+ if (MmIsPagePresent(Process, Address))
+ {
+ return(STATUS_SUCCESS);
+ }
+
+ if (MmIsDisabledPage(Process, Address))
+ {
+ return(STATUS_ACCESS_VIOLATION);
+ }
+
+ /*
+ * Check for the virtual memory area being deleted.
+ */
+ if (MemoryArea->DeleteInProgress)
+ {
+ return(STATUS_UNSUCCESSFUL);
+ }
+
+ PAddress = MM_ROUND_DOWN(Address, PAGE_SIZE);
+ Offset.QuadPart = (ULONG_PTR)PAddress - MA_GetStartingAddress(MemoryArea)
+ + MemoryArea->Data.SectionData.ViewOffset.QuadPart;
+
+ Segment = MemoryArea->Data.SectionData.Segment;
+ Section = MemoryArea->Data.SectionData.Section;
+ Region = MmFindRegion((PVOID)MA_GetStartingAddress(MemoryArea),
+ &MemoryArea->Data.SectionData.RegionListHead,
+ Address, NULL);
+ ASSERT(Region != NULL);
+ /*
+ * Lock the segment
+ */
+ MmLockSectionSegment(Segment);
+ Entry = MmGetPageEntrySectionSegment(Segment, &Offset);
+ /*
+ * Check if this page needs to be mapped COW
+ */
+ if ((Segment->WriteCopy) &&
+ (Region->Protect == PAGE_READWRITE ||
+ Region->Protect == PAGE_EXECUTE_READWRITE))
+ {
+ Attributes = Region->Protect == PAGE_READWRITE ? PAGE_READONLY : PAGE_EXECUTE_READ;
+ }
+ else
+ {
+ Attributes = Region->Protect;
+ }
+
+ /*
+ * Check if someone else is already handling this fault, if so wait
+ * for them
+ */
+ if (Entry && MM_IS_WAIT_PTE(Entry))
+ {
+ MmUnlockSectionSegment(Segment);
+ MmUnlockAddressSpace(AddressSpace);
+ MiWaitForPageEvent(NULL, NULL);
+ MmLockAddressSpace(AddressSpace);
+ DPRINT("Address 0x%p\n", Address);
+ return(STATUS_MM_RESTART_OPERATION);
+ }
+
+ HasSwapEntry = MmIsPageSwapEntry(Process, Address);
+
+ /* See if we should use a private page */
+ if ((HasSwapEntry) || (Segment->Image.Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA))
+ {
+ SWAPENTRY DummyEntry;
+
+ /*
+ * Is it a wait entry?
+ */
+ if (HasSwapEntry)
+ {
+ MmGetPageFileMapping(Process, Address, &SwapEntry);
+
+ if (SwapEntry == MM_WAIT_ENTRY)
+ {
+ MmUnlockSectionSegment(Segment);
+ MmUnlockAddressSpace(AddressSpace);
+ MiWaitForPageEvent(NULL, NULL);
+ MmLockAddressSpace(AddressSpace);
+ return STATUS_MM_RESTART_OPERATION;
+ }
+
+ /*
+ * Must be private page we have swapped out.
+ */
+
+ /*
+ * Sanity check
+ */
+ if (Segment->Flags & MM_PAGEFILE_SEGMENT)
+ {
+ DPRINT1("Found a swaped out private page in a pagefile section.\n");
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+ MmDeletePageFileMapping(Process, Address, &SwapEntry);
+ }
+
+ MmUnlockSectionSegment(Segment);
+
+ /* Tell everyone else we are serving the fault. */
+ MmCreatePageFileMapping(Process, Address, MM_WAIT_ENTRY);
+
+ MmUnlockAddressSpace(AddressSpace);
+ MI_SET_USAGE(MI_USAGE_SECTION);
+ if (Process) MI_SET_PROCESS2(Process->ImageFileName);
+ if (!Process) MI_SET_PROCESS2("Kernel Section");
+ Status = MmRequestPageMemoryConsumer(MC_USER, TRUE, &Page);
+ if (!NT_SUCCESS(Status))
+ {
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+
+ if (HasSwapEntry)
+ {
+ Status = MmReadFromSwapPage(SwapEntry, Page);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("MmReadFromSwapPage failed, status = %x\n", Status);
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+ }
+
+ MmLockAddressSpace(AddressSpace);
+ MmDeletePageFileMapping(Process, PAddress, &DummyEntry);
+ Status = MmCreateVirtualMapping(Process,
+ PAddress,
+ Region->Protect,
+ &Page,
+ 1);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT("MmCreateVirtualMapping failed, not out of memory\n");
+ KeBugCheck(MEMORY_MANAGEMENT);
+ return(Status);
+ }
+
+ /*
+ * Store the swap entry for later use.
+ */
+ if (HasSwapEntry)
+ MmSetSavedSwapEntryPage(Page, SwapEntry);
+
+ /*
+ * Add the page to the process's working set
+ */
+ MmInsertRmap(Page, Process, Address);
+ /*
+ * Finish the operation
+ */
+ MiSetPageEvent(Process, Address);
+ DPRINT("Address 0x%p\n", Address);
+ return(STATUS_SUCCESS);
+ }
+
+ /*
+ * Satisfying a page fault on a map of /Device/PhysicalMemory is easy
+ */
+ if (Section->AllocationAttributes & SEC_PHYSICALMEMORY)
+ {
+ MmUnlockSectionSegment(Segment);
+ /*
+ * Just map the desired physical page
+ */
+ Page = (PFN_NUMBER)(Offset.QuadPart >> PAGE_SHIFT);
+ Status = MmCreateVirtualMappingUnsafe(Process,
+ PAddress,
+ Region->Protect,
+ &Page,
+ 1);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT("MmCreateVirtualMappingUnsafe failed, not out of memory\n");
+ KeBugCheck(MEMORY_MANAGEMENT);
+ return(Status);
+ }
+
+ /*
+ * Cleanup and release locks
+ */
+ MiSetPageEvent(Process, Address);
+ DPRINT("Address 0x%p\n", Address);
+ return(STATUS_SUCCESS);
+ }
+
+ /*
+ * Get the entry corresponding to the offset within the section
+ */
+ Entry = MmGetPageEntrySectionSegment(Segment, &Offset);
+
+ if (Entry == 0)
+ {
+ SWAPENTRY FakeSwapEntry;
+
+ /*
+ * If the entry is zero (and it can't change because we have
+ * locked the segment) then we need to load the page.
+ */
+
+ /*
+ * Release all our locks and read in the page from disk
+ */
+ MmSetPageEntrySectionSegment(Segment, &Offset, MAKE_SWAP_SSE(MM_WAIT_ENTRY));
+ MmUnlockSectionSegment(Segment);
+ MmCreatePageFileMapping(Process, PAddress, MM_WAIT_ENTRY);
+ MmUnlockAddressSpace(AddressSpace);
+
+ if ((Segment->Flags & MM_PAGEFILE_SEGMENT) ||
+ ((Offset.QuadPart >= (LONGLONG)PAGE_ROUND_UP(Segment->RawLength.QuadPart) &&
+ (Section->AllocationAttributes & SEC_IMAGE))))
+ {
+ MI_SET_USAGE(MI_USAGE_SECTION);
+ if (Process) MI_SET_PROCESS2(Process->ImageFileName);
+ if (!Process) MI_SET_PROCESS2("Kernel Section");
+ Status = MmRequestPageMemoryConsumer(MC_USER, TRUE, &Page);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("MmRequestPageMemoryConsumer failed (Status %x)\n", Status);
+ }
+
+ }
+ else
+ {
+ Status = MiReadPage(MemoryArea, Offset.QuadPart, &Page);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("MiReadPage failed (Status %x)\n", Status);
+ }
+ }
+ if (!NT_SUCCESS(Status))
+ {
+ /*
+ * FIXME: What do we know in this case?
+ */
+ /*
+ * Cleanup and release locks
+ */
+ MmLockAddressSpace(AddressSpace);
+ MiSetPageEvent(Process, Address);
+ DPRINT("Address 0x%p\n", Address);
+ return(Status);
+ }
+
+ /* Lock both segment and process address space while we proceed. */
+ MmLockAddressSpace(AddressSpace);
+ MmLockSectionSegment(Segment);
+
+ MmDeletePageFileMapping(Process, PAddress, &FakeSwapEntry);
+ DPRINT("CreateVirtualMapping Page %x Process %p PAddress %p Attributes %x\n",
+ Page, Process, PAddress, Attributes);
+ Status = MmCreateVirtualMapping(Process,
+ PAddress,
+ Attributes,
+ &Page,
+ 1);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("Unable to create virtual mapping\n");
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+ ASSERT(MmIsPagePresent(Process, PAddress));
+ MmInsertRmap(Page, Process, Address);
+
+ /* Set this section offset has being backed by our new page. */
+ Entry = MAKE_SSE(Page << PAGE_SHIFT, 1);
+ MmSetPageEntrySectionSegment(Segment, &Offset, Entry);
+ MmUnlockSectionSegment(Segment);
+
+ MiSetPageEvent(Process, Address);
+ DPRINT("Address 0x%p\n", Address);
+ return(STATUS_SUCCESS);
+ }
+ else if (IS_SWAP_FROM_SSE(Entry))
+ {
+ SWAPENTRY SwapEntry;
+
+ SwapEntry = SWAPENTRY_FROM_SSE(Entry);
+
+ /* See if a page op is running on this segment. */
+ if (SwapEntry == MM_WAIT_ENTRY)
+ {
+ MmUnlockSectionSegment(Segment);
+ MmUnlockAddressSpace(AddressSpace);
+ MiWaitForPageEvent(NULL, NULL);
+ MmLockAddressSpace(AddressSpace);
+ return STATUS_MM_RESTART_OPERATION;
+ }
+
+ /*
+ * Release all our locks and read in the page from disk
+ */
+ MmUnlockSectionSegment(Segment);
+
+ MmUnlockAddressSpace(AddressSpace);
+ MI_SET_USAGE(MI_USAGE_SECTION);
+ if (Process) MI_SET_PROCESS2(Process->ImageFileName);
+ if (!Process) MI_SET_PROCESS2("Kernel Section");
+ Status = MmRequestPageMemoryConsumer(MC_USER, TRUE, &Page);
+ if (!NT_SUCCESS(Status))
+ {
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+
+ Status = MmReadFromSwapPage(SwapEntry, Page);
+ if (!NT_SUCCESS(Status))
+ {
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+
+ /*
+ * Relock the address space and segment
+ */
+ MmLockAddressSpace(AddressSpace);
+ MmLockSectionSegment(Segment);
+
+ /*
+ * Check the entry. No one should change the status of a page
+ * that has a pending page-in.
+ */
+ Entry1 = MmGetPageEntrySectionSegment(Segment, &Offset);
+ if (Entry != Entry1)
+ {
+ DPRINT1("Someone changed ppte entry while we slept (%x vs %x)\n", Entry, Entry1);
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+
+ /*
+ * Save the swap entry.
+ */
+ MmSetSavedSwapEntryPage(Page, SwapEntry);
+
+ /* Map the page into the process address space */
+ Status = MmCreateVirtualMapping(Process,
+ PAddress,
+ Region->Protect,
+ &Page,
+ 1);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("Unable to create virtual mapping\n");
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+ MmInsertRmap(Page, Process, Address);
+
+ /*
+ * Mark the offset within the section as having valid, in-memory
+ * data
+ */
+ Entry = MAKE_SSE(Page << PAGE_SHIFT, 1);
+ MmSetPageEntrySectionSegment(Segment, &Offset, Entry);
+ MmUnlockSectionSegment(Segment);
+
+ MiSetPageEvent(Process, Address);
+ DPRINT("Address 0x%p\n", Address);
+ return(STATUS_SUCCESS);
+ }
+ else
+ {
+ /* We already have a page on this section offset. Map it into the process address space. */
+ Page = PFN_FROM_SSE(Entry);
+
+ Status = MmCreateVirtualMapping(Process,
+ PAddress,
+ Attributes,
+ &Page,
+ 1);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("Unable to create virtual mapping\n");
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+ MmInsertRmap(Page, Process, Address);
+
+ /* Take a reference on it */
+ MmSharePageEntrySectionSegment(Segment, &Offset);
+ MmUnlockSectionSegment(Segment);
+
+ MiSetPageEvent(Process, Address);
+ DPRINT("Address 0x%p\n", Address);
+ return(STATUS_SUCCESS);
+ }
+}
+
+NTSTATUS
+NTAPI
+MmAccessFaultSectionView(PMMSUPPORT AddressSpace,
+ MEMORY_AREA* MemoryArea,
+ PVOID Address)
+{
+ PMM_SECTION_SEGMENT Segment;
+ PROS_SECTION_OBJECT Section;
+ PFN_NUMBER OldPage;
+ PFN_NUMBER NewPage;
+ NTSTATUS Status;
+ PVOID PAddress;
+ LARGE_INTEGER Offset;
+ PMM_REGION Region;
+ ULONG_PTR Entry;
+ PEPROCESS Process = MmGetAddressSpaceOwner(AddressSpace);
+
+ DPRINT("MmAccessFaultSectionView(%p, %p, %p)\n", AddressSpace, MemoryArea, Address);
+
+ /* Make sure we have a page mapping for this address. */
+ Status = MmNotPresentFaultSectionView(AddressSpace, MemoryArea, Address, TRUE);
+ if (!NT_SUCCESS(Status))
+ {
+ /* This is invalid access ! */
+ return Status;
+ }
+
+ /*
+ * Check if the page has already been set readwrite
+ */
+ if (MmGetPageProtect(Process, Address) & PAGE_READWRITE)
+ {
+ DPRINT("Address 0x%p\n", Address);
+ return(STATUS_SUCCESS);
+ }
+
+ /*
+ * Find the offset of the page
+ */
+ PAddress = MM_ROUND_DOWN(Address, PAGE_SIZE);
+ Offset.QuadPart = (ULONG_PTR)PAddress - MA_GetStartingAddress(MemoryArea)
+ + MemoryArea->Data.SectionData.ViewOffset.QuadPart;
+
+ Segment = MemoryArea->Data.SectionData.Segment;
+ Section = MemoryArea->Data.SectionData.Section;
+ Region = MmFindRegion((PVOID)MA_GetStartingAddress(MemoryArea),
+ &MemoryArea->Data.SectionData.RegionListHead,
+ Address, NULL);
+ ASSERT(Region != NULL);
+
+ /*
+ * Check if we are doing COW
+ */
+ if (!((Segment->WriteCopy) &&
+ (Region->Protect == PAGE_READWRITE ||
+ Region->Protect == PAGE_EXECUTE_READWRITE)))
+ {
+ DPRINT("Address 0x%p\n", Address);
+ return(STATUS_ACCESS_VIOLATION);
+ }
+
+ /* Get the page mapping this section offset. */
+ MmLockSectionSegment(Segment);
+ Entry = MmGetPageEntrySectionSegment(Segment, &Offset);
+
+ /* Get the current page mapping for the process */
+ ASSERT(MmIsPagePresent(Process, PAddress));
+ OldPage = MmGetPfnForProcess(Process, PAddress);
+ ASSERT(OldPage != 0);
+
+ if (IS_SWAP_FROM_SSE(Entry) ||
+ PFN_FROM_SSE(Entry) != OldPage)
+ {
+ MmUnlockSectionSegment(Segment);
+ /* This is a private page. We must only change the page protection. */
+ MmSetPageProtect(Process, PAddress, Region->Protect);
+ return(STATUS_SUCCESS);
+ }
+
+ /*
+ * Allocate a page
+ */
+ MI_SET_USAGE(MI_USAGE_SECTION);
+ if (Process) MI_SET_PROCESS2(Process->ImageFileName);
+ if (!Process) MI_SET_PROCESS2("Kernel Section");
+ Status = MmRequestPageMemoryConsumer(MC_USER, TRUE, &NewPage);
+ if (!NT_SUCCESS(Status))
+ {
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+
+ /*
+ * Copy the old page
+ */
+ MiCopyFromUserPage(NewPage, OldPage);
+
+ /*
+ * Unshare the old page.
+ */
+ DPRINT("Swapping page (Old %x New %x)\n", OldPage, NewPage);
+ MmDeleteVirtualMapping(Process, PAddress, NULL, NULL);
+ MmDeleteRmap(OldPage, Process, PAddress);
+ MmUnsharePageEntrySectionSegment(Section, Segment, &Offset, FALSE, FALSE, NULL);
+ MmUnlockSectionSegment(Segment);
+
+ /*
+ * Set the PTE to point to the new page
+ */
+ Status = MmCreateVirtualMapping(Process,
+ PAddress,
+ Region->Protect,
+ &NewPage,
+ 1);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("MmCreateVirtualMapping failed, unable to create virtual mapping, not out of memory\n");
+ KeBugCheck(MEMORY_MANAGEMENT);
+ return(Status);
+ }
+ MmInsertRmap(NewPage, Process, PAddress);
+
+ MiSetPageEvent(Process, Address);
+ DPRINT("Address 0x%p\n", Address);
+ return(STATUS_SUCCESS);
+}
+
+VOID
+MmPageOutDeleteMapping(PVOID Context, PEPROCESS Process, PVOID Address)
+{
+ MM_SECTION_PAGEOUT_CONTEXT* PageOutContext;
+ BOOLEAN WasDirty;
+ PFN_NUMBER Page = 0;
+
+ PageOutContext = (MM_SECTION_PAGEOUT_CONTEXT*)Context;
+ if (Process)
+ {
+ MmLockAddressSpace(&Process->Vm);
+ }
+
+ MmDeleteVirtualMapping(Process,
+ Address,
+ &WasDirty,
+ &Page);
+ if (WasDirty)
+ {
+ PageOutContext->WasDirty = TRUE;
+ }
+ if (!PageOutContext->Private)
+ {
+ MmLockSectionSegment(PageOutContext->Segment);
+ MmUnsharePageEntrySectionSegment((PROS_SECTION_OBJECT)PageOutContext->Section,
+ PageOutContext->Segment,
+ &PageOutContext->Offset,
+ PageOutContext->WasDirty,
+ TRUE,
+ &PageOutContext->SectionEntry);
+ MmUnlockSectionSegment(PageOutContext->Segment);
+ }
+ if (Process)
+ {
+ MmUnlockAddressSpace(&Process->Vm);
+ }
+
+ if (PageOutContext->Private)
+ {
+ MmReleasePageMemoryConsumer(MC_USER, Page);
+ }
+}
+
+NTSTATUS
+NTAPI
+MmPageOutSectionView(PMMSUPPORT AddressSpace,
+ MEMORY_AREA* MemoryArea,
+ PVOID Address, ULONG_PTR Entry)
+{
+ PFN_NUMBER Page;
+ MM_SECTION_PAGEOUT_CONTEXT Context;
+ SWAPENTRY SwapEntry;
+ NTSTATUS Status;
+#ifndef NEWCC
+ ULONGLONG FileOffset;
+ PFILE_OBJECT FileObject;
+ PROS_SHARED_CACHE_MAP SharedCacheMap = NULL;
+ BOOLEAN IsImageSection;
+#endif
+ BOOLEAN DirectMapped;
+ PEPROCESS Process = MmGetAddressSpaceOwner(AddressSpace);
+ KIRQL OldIrql;
+
+ Address = (PVOID)PAGE_ROUND_DOWN(Address);
+
+ /*
+ * Get the segment and section.
+ */
+ Context.Segment = MemoryArea->Data.SectionData.Segment;
+ Context.Section = MemoryArea->Data.SectionData.Section;
+ Context.SectionEntry = Entry;
+ Context.CallingProcess = Process;
+
+ Context.Offset.QuadPart = (ULONG_PTR)Address - MA_GetStartingAddress(MemoryArea)
+ + MemoryArea->Data.SectionData.ViewOffset.QuadPart;
+
+ DirectMapped = FALSE;
+
+ MmLockSectionSegment(Context.Segment);
+
+#ifndef NEWCC
+ FileOffset = Context.Offset.QuadPart + Context.Segment->Image.FileOffset;
+ IsImageSection = Context.Section->AllocationAttributes & SEC_IMAGE ? TRUE : FALSE;
+ FileObject = Context.Section->FileObject;
+
+ if (FileObject != NULL &&
+ !(Context.Segment->Image.Characteristics & IMAGE_SCN_MEM_SHARED))
+ {
+ SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
+
+ /*
+ * If the file system is letting us go directly to the cache and the
+ * memory area was mapped at an offset in the file which is page aligned
+ * then note this is a direct mapped page.
+ */
+ if ((FileOffset % PAGE_SIZE) == 0 &&
+ (Context.Offset.QuadPart + PAGE_SIZE <= Context.Segment->RawLength.QuadPart || !IsImageSection))
+ {
+ DirectMapped = TRUE;
+ }
+ }
+#endif
+
+
+ /*
+ * This should never happen since mappings of physical memory are never
+ * placed in the rmap lists.
+ */
+ if (Context.Section->AllocationAttributes & SEC_PHYSICALMEMORY)
+ {
+ DPRINT1("Trying to page out from physical memory section address 0x%p "
+ "process %p\n", Address,
+ Process ? Process->UniqueProcessId : 0);
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+
+ /*
+ * Get the section segment entry and the physical address.
+ */
+ if (!MmIsPagePresent(Process, Address))
+ {
+ DPRINT1("Trying to page out not-present page at (%p,0x%p).\n",
+ Process ? Process->UniqueProcessId : 0, Address);
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+ Page = MmGetPfnForProcess(Process, Address);
+ SwapEntry = MmGetSavedSwapEntryPage(Page);
+
+ /*
+ * Check the reference count to ensure this page can be paged out
+ */
+ if (MmGetReferenceCountPage(Page) != 1)
+ {
+ DPRINT("Cannot page out locked section page: 0x%lu (RefCount: %lu)\n",
+ Page, MmGetReferenceCountPage(Page));
+ MmSetPageEntrySectionSegment(Context.Segment, &Context.Offset, Entry);
+ MmUnlockSectionSegment(Context.Segment);
+ return STATUS_UNSUCCESSFUL;
+ }
+
+ /*
+ * Prepare the context structure for the rmap delete call.
+ */
+ MmUnlockSectionSegment(Context.Segment);
+ Context.WasDirty = FALSE;
+ if (Context.Segment->Image.Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA ||
+ IS_SWAP_FROM_SSE(Entry) ||
+ PFN_FROM_SSE(Entry) != Page)
+ {
+ Context.Private = TRUE;
+ }
+ else
+ {
+ Context.Private = FALSE;
+ }
+
+ /*
+ * Take an additional reference to the page or the VACB.
+ */
+ if (DirectMapped && !Context.Private)
+ {
+ if(!MiIsPageFromCache(MemoryArea, Context.Offset.QuadPart))
+ {
+ DPRINT1("Direct mapped non private page is not associated with the cache.\n");
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+ }
+ else
+ {
+ OldIrql = KeAcquireQueuedSpinLock(LockQueuePfnLock);
+ MmReferencePage(Page);
+ KeReleaseQueuedSpinLock(LockQueuePfnLock, OldIrql);
+ }
+
+ MmDeleteAllRmaps(Page, (PVOID)&Context, MmPageOutDeleteMapping);
+
+ /* Since we passed in a surrogate, we'll get back the page entry
+ * state in our context. This is intended to make intermediate
+ * decrements of share count not release the wait entry.
+ */
+ Entry = Context.SectionEntry;
+
+ /*
+ * If this wasn't a private page then we should have reduced the entry to
+ * zero by deleting all the rmaps.
+ */
+ if (!Context.Private && Entry != 0)
+ {
+ if (!(Context.Segment->Flags & MM_PAGEFILE_SEGMENT) &&
+ !(Context.Segment->Image.Characteristics & IMAGE_SCN_MEM_SHARED))
+ {
+ KeBugCheckEx(MEMORY_MANAGEMENT, Entry, (ULONG_PTR)Process, (ULONG_PTR)Address, 0);
+ }
+ }
+
+ /*
+ * If the page wasn't dirty then we can just free it as for a readonly page.
+ * Since we unmapped all the mappings above we know it will not suddenly
+ * become dirty.
+ * If the page is from a pagefile section and has no swap entry,
+ * we can't free the page at this point.
+ */
+ SwapEntry = MmGetSavedSwapEntryPage(Page);
+ if (Context.Segment->Flags & MM_PAGEFILE_SEGMENT)
+ {
+ if (Context.Private)
+ {
+ DPRINT1("Found a %s private page (address %p) in a pagefile segment.\n",
+ Context.WasDirty ? "dirty" : "clean", Address);
+ KeBugCheckEx(MEMORY_MANAGEMENT, SwapEntry, (ULONG_PTR)Process, (ULONG_PTR)Address, 0);
+ }
+ if (!Context.WasDirty && SwapEntry != 0)
+ {
+ MmSetSavedSwapEntryPage(Page, 0);
+ MmLockSectionSegment(Context.Segment);
+ MmSetPageEntrySectionSegment(Context.Segment, &Context.Offset, MAKE_SWAP_SSE(SwapEntry));
+ MmUnlockSectionSegment(Context.Segment);
+ MmReleasePageMemoryConsumer(MC_USER, Page);
+ MiSetPageEvent(NULL, NULL);
+ return(STATUS_SUCCESS);
+ }
+ }
+ else if (Context.Segment->Image.Characteristics & IMAGE_SCN_MEM_SHARED)
+ {
+ if (Context.Private)
+ {
+ DPRINT1("Found a %s private page (address %p) in a shared section segment.\n",
+ Context.WasDirty ? "dirty" : "clean", Address);
+ KeBugCheckEx(MEMORY_MANAGEMENT, Page, (ULONG_PTR)Process, (ULONG_PTR)Address, 0);
+ }
+ if (!Context.WasDirty || SwapEntry != 0)
+ {
+ MmSetSavedSwapEntryPage(Page, 0);
+ if (SwapEntry != 0)
+ {
+ MmLockSectionSegment(Context.Segment);
+ MmSetPageEntrySectionSegment(Context.Segment, &Context.Offset, MAKE_SWAP_SSE(SwapEntry));
+ MmUnlockSectionSegment(Context.Segment);
+ }
+ MmReleasePageMemoryConsumer(MC_USER, Page);
+ MiSetPageEvent(NULL, NULL);
+ return(STATUS_SUCCESS);
+ }
+ }
+ else if (!Context.Private && DirectMapped)
+ {
+ if (SwapEntry != 0)
+ {
+ DPRINT1("Found a swapentry for a non private and direct mapped page (address %p)\n",
+ Address);
+ KeBugCheckEx(MEMORY_MANAGEMENT, STATUS_UNSUCCESSFUL, SwapEntry, (ULONG_PTR)Process, (ULONG_PTR)Address);
+ }
+#ifndef NEWCC
+ Status = CcRosUnmapVacb(SharedCacheMap, FileOffset, FALSE);
+#else
+ Status = STATUS_SUCCESS;
+#endif
+#ifndef NEWCC
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("CcRosUnmapVacb failed, status = %x\n", Status);
+ KeBugCheckEx(MEMORY_MANAGEMENT, Status, (ULONG_PTR)SharedCacheMap, (ULONG_PTR)FileOffset, (ULONG_PTR)Address);
+ }
+#endif
+ MiSetPageEvent(NULL, NULL);
+ return(STATUS_SUCCESS);
+ }
+ else if (!Context.WasDirty && !DirectMapped && !Context.Private)
+ {
+ if (SwapEntry != 0)
+ {
+ DPRINT1("Found a swap entry for a non dirty, non private and not direct mapped page (address %p)\n",
+ Address);
+ KeBugCheckEx(MEMORY_MANAGEMENT, SwapEntry, Page, (ULONG_PTR)Process, (ULONG_PTR)Address);
+ }
+ MmReleasePageMemoryConsumer(MC_USER, Page);
+ MiSetPageEvent(NULL, NULL);
+ return(STATUS_SUCCESS);
+ }
+ else if (!Context.WasDirty && Context.Private && SwapEntry != 0)
+ {
+ DPRINT("Not dirty and private and not swapped (%p:%p)\n", Process, Address);
+ MmSetSavedSwapEntryPage(Page, 0);
+ MmLockAddressSpace(AddressSpace);
+ Status = MmCreatePageFileMapping(Process,
+ Address,
+ SwapEntry);
+ MmUnlockAddressSpace(AddressSpace);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("Status %x Swapping out %p:%p\n", Status, Process, Address);
+ KeBugCheckEx(MEMORY_MANAGEMENT, Status, (ULONG_PTR)Process, (ULONG_PTR)Address, SwapEntry);
+ }
+ MmReleasePageMemoryConsumer(MC_USER, Page);
+ MiSetPageEvent(NULL, NULL);
+ return(STATUS_SUCCESS);
+ }
+
+ /*
+ * If necessary, allocate an entry in the paging file for this page
+ */
+ if (SwapEntry == 0)
+ {
+ SwapEntry = MmAllocSwapPage();
+ if (SwapEntry == 0)
+ {
+ MmShowOutOfSpaceMessagePagingFile();
+ MmLockAddressSpace(AddressSpace);
+ /*
+ * For private pages restore the old mappings.
+ */
+ if (Context.Private)
+ {
+ Status = MmCreateVirtualMapping(Process,
+ Address,
+ MemoryArea->Protect,
+ &Page,
+ 1);
+ MmSetDirtyPage(Process, Address);
+ MmInsertRmap(Page,
+ Process,
+ Address);
+ }
+ else
+ {
+ ULONG_PTR OldEntry;
+
+ MmLockSectionSegment(Context.Segment);
+
+ /*
+ * For non-private pages if the page wasn't direct mapped then
+ * set it back into the section segment entry so we don't loose
+ * our copy. Otherwise it will be handled by the cache manager.
+ */
+ Status = MmCreateVirtualMapping(Process,
+ Address,
+ MemoryArea->Protect,
+ &Page,
+ 1);
+ MmSetDirtyPage(Process, Address);
+ MmInsertRmap(Page,
+ Process,
+ Address);
+ // If we got here, the previous entry should have been a wait
+ Entry = MAKE_SSE(Page << PAGE_SHIFT, 1);
+ OldEntry = MmGetPageEntrySectionSegment(Context.Segment, &Context.Offset);
+ ASSERT(OldEntry == 0 || OldEntry == MAKE_SWAP_SSE(MM_WAIT_ENTRY));
+ MmSetPageEntrySectionSegment(Context.Segment, &Context.Offset, Entry);
+ MmUnlockSectionSegment(Context.Segment);
+ }
+ MmUnlockAddressSpace(AddressSpace);
+ MiSetPageEvent(NULL, NULL);
+ return(STATUS_PAGEFILE_QUOTA);
+ }
+ }
+
+ /*
+ * Write the page to the pagefile
+ */
+ Status = MmWriteToSwapPage(SwapEntry, Page);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("MM: Failed to write to swap page (Status was 0x%.8X)\n",
+ Status);
+ /*
+ * As above: undo our actions.
+ * FIXME: Also free the swap page.
+ */
+ MmLockAddressSpace(AddressSpace);
+ if (Context.Private)
+ {
+ Status = MmCreateVirtualMapping(Process,
+ Address,
+ MemoryArea->Protect,
+ &Page,
+ 1);
+ MmSetDirtyPage(Process, Address);
+ MmInsertRmap(Page,
+ Process,
+ Address);
+ }
+ else
+ {
+ MmLockSectionSegment(Context.Segment);
+ Status = MmCreateVirtualMapping(Process,
+ Address,
+ MemoryArea->Protect,
+ &Page,
+ 1);
+ MmSetDirtyPage(Process, Address);
+ MmInsertRmap(Page,
+ Process,
+ Address);
+ Entry = MAKE_SSE(Page << PAGE_SHIFT, 1);
+ MmSetPageEntrySectionSegment(Context.Segment, &Context.Offset, Entry);
+ MmUnlockSectionSegment(Context.Segment);
+ }
+ MmUnlockAddressSpace(AddressSpace);
+ MiSetPageEvent(NULL, NULL);
+ return(STATUS_UNSUCCESSFUL);
+ }
+
+ /*
+ * Otherwise we have succeeded.
+ */
+ DPRINT("MM: Wrote section page 0x%.8X to swap!\n", Page << PAGE_SHIFT);
+ MmSetSavedSwapEntryPage(Page, 0);
+ if (Context.Segment->Flags & MM_PAGEFILE_SEGMENT ||
+ Context.Segment->Image.Characteristics & IMAGE_SCN_MEM_SHARED)
+ {
+ MmLockSectionSegment(Context.Segment);
+ MmSetPageEntrySectionSegment(Context.Segment, &Context.Offset, MAKE_SWAP_SSE(SwapEntry));
+ MmUnlockSectionSegment(Context.Segment);
+ }
+ else
+ {
+ MmReleasePageMemoryConsumer(MC_USER, Page);
+ }
+
+ if (Context.Private)
+ {
+ MmLockAddressSpace(AddressSpace);
+ MmLockSectionSegment(Context.Segment);
+ Status = MmCreatePageFileMapping(Process,
+ Address,
+ SwapEntry);
+ /* We had placed a wait entry upon entry ... replace it before leaving */
+ MmSetPageEntrySectionSegment(Context.Segment, &Context.Offset, Entry);
+ MmUnlockSectionSegment(Context.Segment);
+ MmUnlockAddressSpace(AddressSpace);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("Status %x Creating page file mapping for %p:%p\n", Status, Process, Address);
+ KeBugCheckEx(MEMORY_MANAGEMENT, Status, (ULONG_PTR)Process, (ULONG_PTR)Address, SwapEntry);
+ }
+ }
+ else
+ {
+ MmLockAddressSpace(AddressSpace);
+ MmLockSectionSegment(Context.Segment);
+ Entry = MAKE_SWAP_SSE(SwapEntry);
+ /* We had placed a wait entry upon entry ... replace it before leaving */
+ MmSetPageEntrySectionSegment(Context.Segment, &Context.Offset, Entry);
+ MmUnlockSectionSegment(Context.Segment);
+ MmUnlockAddressSpace(AddressSpace);
+ }
+
+ MiSetPageEvent(NULL, NULL);
+ return(STATUS_SUCCESS);
+}
+
+NTSTATUS
+NTAPI
+MmWritePageSectionView(PMMSUPPORT AddressSpace,
+ PMEMORY_AREA MemoryArea,
+ PVOID Address,
+ ULONG PageEntry)
+{
+ LARGE_INTEGER Offset;
+ PROS_SECTION_OBJECT Section;
+ PMM_SECTION_SEGMENT Segment;
+ PFN_NUMBER Page;
+ SWAPENTRY SwapEntry;
+ ULONG_PTR Entry;
+ BOOLEAN Private;
+ NTSTATUS Status;
+ PFILE_OBJECT FileObject;
+#ifndef NEWCC
+ PROS_SHARED_CACHE_MAP SharedCacheMap = NULL;
+#endif
+ BOOLEAN DirectMapped;
+ BOOLEAN IsImageSection;
+ PEPROCESS Process = MmGetAddressSpaceOwner(AddressSpace);
+
+ Address = (PVOID)PAGE_ROUND_DOWN(Address);
+
+ Offset.QuadPart = (ULONG_PTR)Address - MA_GetStartingAddress(MemoryArea)
+ + MemoryArea->Data.SectionData.ViewOffset.QuadPart;
+
+ /*
+ * Get the segment and section.
+ */
+ Segment = MemoryArea->Data.SectionData.Segment;
+ Section = MemoryArea->Data.SectionData.Section;
+ IsImageSection = Section->AllocationAttributes & SEC_IMAGE ? TRUE : FALSE;
+
+ FileObject = Section->FileObject;
+ DirectMapped = FALSE;
+ if (FileObject != NULL &&
+ !(Segment->Image.Characteristics & IMAGE_SCN_MEM_SHARED))
+ {
+#ifndef NEWCC
+ SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
+#endif
+
+ /*
+ * If the file system is letting us go directly to the cache and the
+ * memory area was mapped at an offset in the file which is page aligned
+ * then note this is a direct mapped page.
+ */
+ if (((Offset.QuadPart + Segment->Image.FileOffset) % PAGE_SIZE) == 0 &&
+ (Offset.QuadPart + PAGE_SIZE <= Segment->RawLength.QuadPart || !IsImageSection))
+ {
+ DirectMapped = TRUE;
+ }
+ }
+
+ /*
+ * This should never happen since mappings of physical memory are never
+ * placed in the rmap lists.
+ */
+ if (Section->AllocationAttributes & SEC_PHYSICALMEMORY)
+ {
+ DPRINT1("Trying to write back page from physical memory mapped at %p "
+ "process %p\n", Address,
+ Process ? Process->UniqueProcessId : 0);
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+
+ /*
+ * Get the section segment entry and the physical address.
+ */
+ Entry = MmGetPageEntrySectionSegment(Segment, &Offset);
+ if (!MmIsPagePresent(Process, Address))
+ {
+ DPRINT1("Trying to page out not-present page at (%p,0x%p).\n",
+ Process ? Process->UniqueProcessId : 0, Address);
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+ Page = MmGetPfnForProcess(Process, Address);
+ SwapEntry = MmGetSavedSwapEntryPage(Page);
+
+ /*
+ * Check for a private (COWed) page.
+ */
+ if (Segment->Image.Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA ||
+ IS_SWAP_FROM_SSE(Entry) ||
+ PFN_FROM_SSE(Entry) != Page)
+ {
+ Private = TRUE;
+ }
+ else
+ {
+ Private = FALSE;
+ }
+
+ /*
+ * Speculatively set all mappings of the page to clean.
+ */
+ MmSetCleanAllRmaps(Page);
+
+ /*
+ * If this page was direct mapped from the cache then the cache manager
+ * will take care of writing it back to disk.
+ */
+ if (DirectMapped && !Private)
+ {
+ //LARGE_INTEGER SOffset;
+ ASSERT(SwapEntry == 0);
+ //SOffset.QuadPart = Offset.QuadPart + Segment->Image.FileOffset;
+#ifndef NEWCC
+ CcRosMarkDirtyVacb(SharedCacheMap, Offset.QuadPart);
+#endif
+ MmLockSectionSegment(Segment);
+ MmSetPageEntrySectionSegment(Segment, &Offset, PageEntry);
+ MmUnlockSectionSegment(Segment);
+ MiSetPageEvent(NULL, NULL);
+ return(STATUS_SUCCESS);
+ }
+
+ /*
+ * If necessary, allocate an entry in the paging file for this page
+ */
+ if (SwapEntry == 0)
+ {
+ SwapEntry = MmAllocSwapPage();
+ if (SwapEntry == 0)
+ {
+ MmSetDirtyAllRmaps(Page);
+ MiSetPageEvent(NULL, NULL);
+ return(STATUS_PAGEFILE_QUOTA);
+ }
+ MmSetSavedSwapEntryPage(Page, SwapEntry);
+ }
+
+ /*
+ * Write the page to the pagefile
+ */
+ Status = MmWriteToSwapPage(SwapEntry, Page);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("MM: Failed to write to swap page (Status was 0x%.8X)\n",
+ Status);
+ MmSetDirtyAllRmaps(Page);
+ MiSetPageEvent(NULL, NULL);
+ return(STATUS_UNSUCCESSFUL);
+ }
+
+ /*
+ * Otherwise we have succeeded.
+ */
+ DPRINT("MM: Wrote section page 0x%.8X to swap!\n", Page << PAGE_SHIFT);
+ MiSetPageEvent(NULL, NULL);
+ return(STATUS_SUCCESS);
+}
+
+static VOID
+MmAlterViewAttributes(PMMSUPPORT AddressSpace,
+ PVOID BaseAddress,
+ SIZE_T RegionSize,
+ ULONG OldType,
+ ULONG OldProtect,
+ ULONG NewType,
+ ULONG NewProtect)
+{
+ PMEMORY_AREA MemoryArea;
+ PMM_SECTION_SEGMENT Segment;
+ BOOLEAN DoCOW = FALSE;
+ ULONG i;
+ PEPROCESS Process = MmGetAddressSpaceOwner(AddressSpace);
+
+ MemoryArea = MmLocateMemoryAreaByAddress(AddressSpace, BaseAddress);
+ ASSERT(MemoryArea != NULL);
+ Segment = MemoryArea->Data.SectionData.Segment;
+ MmLockSectionSegment(Segment);
+
+ if ((Segment->WriteCopy) &&
+ (NewProtect == PAGE_READWRITE || NewProtect == PAGE_EXECUTE_READWRITE))
+ {
+ DoCOW = TRUE;
+ }
+
+ if (OldProtect != NewProtect)
+ {
+ for (i = 0; i < PAGE_ROUND_UP(RegionSize) / PAGE_SIZE; i++)
+ {
+ SWAPENTRY SwapEntry;
+ PVOID Address = (char*)BaseAddress + (i * PAGE_SIZE);
+ ULONG Protect = NewProtect;
+
+ /* Wait for a wait entry to disappear */
+ do
+ {
+ MmGetPageFileMapping(Process, Address, &SwapEntry);
+ if (SwapEntry != MM_WAIT_ENTRY)
+ break;
+ MiWaitForPageEvent(Process, Address);
+ }
+ while (TRUE);
+
+ /*
+ * If we doing COW for this segment then check if the page is
+ * already private.
+ */
+ if (DoCOW && MmIsPagePresent(Process, Address))
+ {
+ LARGE_INTEGER Offset;
+ ULONG_PTR Entry;
+ PFN_NUMBER Page;
+
+ Offset.QuadPart = (ULONG_PTR)Address - MA_GetStartingAddress(MemoryArea)
+ + MemoryArea->Data.SectionData.ViewOffset.QuadPart;
+ Entry = MmGetPageEntrySectionSegment(Segment, &Offset);
+ /*
+ * An MM_WAIT_ENTRY is ok in this case... It'll just count as
+ * IS_SWAP_FROM_SSE and we'll do the right thing.
+ */
+ Page = MmGetPfnForProcess(Process, Address);
+
+ Protect = PAGE_READONLY;
+ if (Segment->Image.Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA ||
+ IS_SWAP_FROM_SSE(Entry) ||
+ PFN_FROM_SSE(Entry) != Page)
+ {
+ Protect = NewProtect;
+ }
+ }
+
+ if (MmIsPagePresent(Process, Address) || MmIsDisabledPage(Process, Address))
+ {
+ MmSetPageProtect(Process, Address,
+ Protect);
+ }
+ }
+ }
+
+ MmUnlockSectionSegment(Segment);
+}
+
+NTSTATUS
+NTAPI
+MmProtectSectionView(PMMSUPPORT AddressSpace,
+ PMEMORY_AREA MemoryArea,
+ PVOID BaseAddress,
+ SIZE_T Length,
+ ULONG Protect,
+ PULONG OldProtect)
+{
+ PMM_REGION Region;
+ NTSTATUS Status;
+ ULONG_PTR MaxLength;
+
+ MaxLength = MA_GetEndingAddress(MemoryArea) - (ULONG_PTR)BaseAddress;
+ if (Length > MaxLength)
+ Length = (ULONG)MaxLength;
+
+ Region = MmFindRegion((PVOID)MA_GetStartingAddress(MemoryArea),
+ &MemoryArea->Data.SectionData.RegionListHead,
+ BaseAddress, NULL);
+ ASSERT(Region != NULL);
+
+ if ((MemoryArea->Flags & SEC_NO_CHANGE) &&
+ Region->Protect != Protect)
+ {
+ return STATUS_INVALID_PAGE_PROTECTION;
+ }
+
+ *OldProtect = Region->Protect;
+ Status = MmAlterRegion(AddressSpace, (PVOID)MA_GetStartingAddress(MemoryArea),
+ &MemoryArea->Data.SectionData.RegionListHead,
+ BaseAddress, Length, Region->Type, Protect,
+ MmAlterViewAttributes);
+
+ return(Status);
+}
+
+NTSTATUS NTAPI
+MmQuerySectionView(PMEMORY_AREA MemoryArea,
+ PVOID Address,
+ PMEMORY_BASIC_INFORMATION Info,
+ PSIZE_T ResultLength)
+{
+ PMM_REGION Region;
+ PVOID RegionBaseAddress;
+ PROS_SECTION_OBJECT Section;
+ PMM_SECTION_SEGMENT Segment;
+
+ Region = MmFindRegion((PVOID)MA_GetStartingAddress(MemoryArea),
+ &MemoryArea->Data.SectionData.RegionListHead,
+ Address, &RegionBaseAddress);
+ if (Region == NULL)
+ {
+ return STATUS_UNSUCCESSFUL;
+ }
+
+ Section = MemoryArea->Data.SectionData.Section;
+ if (Section->AllocationAttributes & SEC_IMAGE)
+ {
+ Segment = MemoryArea->Data.SectionData.Segment;
+ Info->AllocationBase = (PUCHAR)MA_GetStartingAddress(MemoryArea) - Segment->Image.VirtualAddress;
+ Info->Type = MEM_IMAGE;
+ }
+ else
+ {
+ Info->AllocationBase = (PVOID)MA_GetStartingAddress(MemoryArea);
+ Info->Type = MEM_MAPPED;
+ }
+ Info->BaseAddress = RegionBaseAddress;
+ Info->AllocationProtect = MemoryArea->Protect;
+ Info->RegionSize = Region->Length;
+ Info->State = MEM_COMMIT;
+ Info->Protect = Region->Protect;
+
+ *ResultLength = sizeof(MEMORY_BASIC_INFORMATION);
+ return(STATUS_SUCCESS);
+}
+
+VOID
+NTAPI
+MmpFreePageFileSegment(PMM_SECTION_SEGMENT Segment)
+{
+ ULONG Length;
+ LARGE_INTEGER Offset;
+ ULONG_PTR Entry;
+ SWAPENTRY SavedSwapEntry;
+ PFN_NUMBER Page;
+
+ Page = 0;
+
+ MmLockSectionSegment(Segment);
+
+ Length = PAGE_ROUND_UP(Segment->Length.QuadPart);
+ for (Offset.QuadPart = 0; Offset.QuadPart < Length; Offset.QuadPart += PAGE_SIZE)
+ {
+ Entry = MmGetPageEntrySectionSegment(Segment, &Offset);
+ if (Entry)
+ {
+ MmSetPageEntrySectionSegment(Segment, &Offset, 0);
+ if (IS_SWAP_FROM_SSE(Entry))
+ {
+ MmFreeSwapPage(SWAPENTRY_FROM_SSE(Entry));
+ }
+ else
+ {
+ Page = PFN_FROM_SSE(Entry);
+ SavedSwapEntry = MmGetSavedSwapEntryPage(Page);
+ if (SavedSwapEntry != 0)
+ {
+ MmSetSavedSwapEntryPage(Page, 0);
+ MmFreeSwapPage(SavedSwapEntry);
+ }
+ MmReleasePageMemoryConsumer(MC_USER, Page);
+ }
+ }
+ }
+
+ MmUnlockSectionSegment(Segment);
+}
+
+VOID NTAPI
+MmpDeleteSection(PVOID ObjectBody)
+{
+ PROS_SECTION_OBJECT Section = (PROS_SECTION_OBJECT)ObjectBody;
+
+ /* Check if it's an ARM3, or ReactOS section */
+ if (!MiIsRosSectionObject(Section))
+ {
+ MiDeleteARM3Section(ObjectBody);
+ return;
+ }
+
+ DPRINT("MmpDeleteSection(ObjectBody %p)\n", ObjectBody);
+ if (Section->AllocationAttributes & SEC_IMAGE)
+ {
+ ULONG i;
+ ULONG NrSegments;
+ ULONG RefCount;
+ PMM_SECTION_SEGMENT SectionSegments;
+
+ /*
+ * NOTE: Section->ImageSection can be NULL for short time
+ * during the section creating. If we fail for some reason
+ * until the image section is properly initialized we shouldn't
+ * process further here.
+ */
+ if (Section->ImageSection == NULL)
+ return;
+
+ SectionSegments = Section->ImageSection->Segments;
+ NrSegments = Section->ImageSection->NrSegments;
+
+ for (i = 0; i < NrSegments; i++)
+ {
+ if (SectionSegments[i].Image.Characteristics & IMAGE_SCN_MEM_SHARED)
+ {
+ MmLockSectionSegment(&SectionSegments[i]);
+ }
+ RefCount = InterlockedDecrementUL(&SectionSegments[i].ReferenceCount);
+ if (SectionSegments[i].Image.Characteristics & IMAGE_SCN_MEM_SHARED)
+ {
+ MmUnlockSectionSegment(&SectionSegments[i]);
+ if (RefCount == 0)
+ {
+ MmpFreePageFileSegment(&SectionSegments[i]);
+ }
+ }
+ }
+ }
+#ifdef NEWCC
+ else if (Section->Segment && Section->Segment->Flags & MM_DATAFILE_SEGMENT)
+ {
+ ULONG RefCount = 0;
+ PMM_SECTION_SEGMENT Segment = Section->Segment;
+
+ if (Segment &&
+ (RefCount = InterlockedDecrementUL(&Segment->ReferenceCount)) == 0)
+ {
+ DPRINT("Freeing section segment\n");
+ Section->Segment = NULL;
+ MmFinalizeSegment(Segment);
+ }
+ else
+ {
+ DPRINT("RefCount %d\n", RefCount);
+ }
+ }
+#endif
+ else
+ {
+ /*
+ * NOTE: Section->Segment can be NULL for short time
+ * during the section creating.
+ */
+ if (Section->Segment == NULL)
+ return;
+
+ if (Section->Segment->Flags & MM_PAGEFILE_SEGMENT)
+ {
+ MmpFreePageFileSegment(Section->Segment);
+ MmFreePageTablesSectionSegment(Section->Segment, NULL);
+ ExFreePool(Section->Segment);
+ Section->Segment = NULL;
+ }
+ else
+ {
+ (void)InterlockedDecrementUL(&Section->Segment->ReferenceCount);
+ }
+ }
+ if (Section->FileObject != NULL)
+ {
+#ifndef NEWCC
+ CcRosDereferenceCache(Section->FileObject);
+#endif
+ ObDereferenceObject(Section->FileObject);
+ Section->FileObject = NULL;
+ }
+}
+
+VOID NTAPI
+MmpCloseSection(IN PEPROCESS Process OPTIONAL,
+ IN PVOID Object,
+ IN ACCESS_MASK GrantedAccess,
+ IN ULONG ProcessHandleCount,
+ IN ULONG SystemHandleCount)
+{
+ DPRINT("MmpCloseSection(OB %p, HC %lu)\n", Object, ProcessHandleCount);
+}
+
+NTSTATUS
+INIT_FUNCTION
+NTAPI
+MmCreatePhysicalMemorySection(VOID)
+{
+ PROS_SECTION_OBJECT PhysSection;
+ NTSTATUS Status;
+ OBJECT_ATTRIBUTES Obj;
+ UNICODE_STRING Name = RTL_CONSTANT_STRING(L"\\Device\\PhysicalMemory");
+ LARGE_INTEGER SectionSize;
+ HANDLE Handle;
+
+ /*
+ * Create the section mapping physical memory
+ */
+ SectionSize.QuadPart = 0xFFFFFFFF;
+ InitializeObjectAttributes(&Obj,
+ &Name,
+ OBJ_PERMANENT | OBJ_KERNEL_EXCLUSIVE,
+ NULL,
+ NULL);
+ Status = MmCreateSection((PVOID)&PhysSection,
+ SECTION_ALL_ACCESS,
+ &Obj,
+ &SectionSize,
+ PAGE_EXECUTE_READWRITE,
+ SEC_PHYSICALMEMORY,
+ NULL,
+ NULL);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("Failed to create PhysicalMemory section\n");
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+ Status = ObInsertObject(PhysSection,
+ NULL,
+ SECTION_ALL_ACCESS,
+ 0,
+ NULL,
+ &Handle);
+ if (!NT_SUCCESS(Status))
+ {
+ ObDereferenceObject(PhysSection);
+ }
+ ObCloseHandle(Handle, KernelMode);
+ PhysSection->AllocationAttributes |= SEC_PHYSICALMEMORY;
+ PhysSection->Segment->Flags &= ~MM_PAGEFILE_SEGMENT;
+
+ return(STATUS_SUCCESS);
+}
+
+NTSTATUS
+INIT_FUNCTION
+NTAPI
+MmInitSectionImplementation(VOID)
+{
+ OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
+ UNICODE_STRING Name;
+
+ DPRINT("Creating Section Object Type\n");
+
+ /* Initialize the section based root */
+ ASSERT(MmSectionBasedRoot.NumberGenericTableElements == 0);
+ MmSectionBasedRoot.BalancedRoot.u1.Parent = &MmSectionBasedRoot.BalancedRoot;
+
+ /* Initialize the Section object type */
+ RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
+ RtlInitUnicodeString(&Name, L"Section");
+ ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
+ ObjectTypeInitializer.DefaultPagedPoolCharge = sizeof(ROS_SECTION_OBJECT);
+ ObjectTypeInitializer.PoolType = PagedPool;
+ ObjectTypeInitializer.UseDefaultObject = TRUE;
+ ObjectTypeInitializer.GenericMapping = MmpSectionMapping;
+ ObjectTypeInitializer.DeleteProcedure = MmpDeleteSection;
+ ObjectTypeInitializer.CloseProcedure = MmpCloseSection;
+ ObjectTypeInitializer.ValidAccessMask = SECTION_ALL_ACCESS;
+ ObjectTypeInitializer.InvalidAttributes = OBJ_OPENLINK;
+ ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &MmSectionObjectType);
+
+ MmCreatePhysicalMemorySection();
+
+ return(STATUS_SUCCESS);
+}
+
+NTSTATUS
+NTAPI
+MmCreatePageFileSection(PROS_SECTION_OBJECT *SectionObject,
+ ACCESS_MASK DesiredAccess,
+ POBJECT_ATTRIBUTES ObjectAttributes,
+ PLARGE_INTEGER UMaximumSize,
+ ULONG SectionPageProtection,
+ ULONG AllocationAttributes)
+/*
+ * Create a section which is backed by the pagefile
+ */
+{
+ LARGE_INTEGER MaximumSize;
+ PROS_SECTION_OBJECT Section;
+ PMM_SECTION_SEGMENT Segment;
+ NTSTATUS Status;
+
+ if (UMaximumSize == NULL)
+ {
+ DPRINT1("MmCreatePageFileSection: (UMaximumSize == NULL)\n");
+ return(STATUS_INVALID_PARAMETER);
+ }
+ MaximumSize = *UMaximumSize;
+
+ /*
+ * Create the section
+ */
+ Status = ObCreateObject(ExGetPreviousMode(),
+ MmSectionObjectType,
+ ObjectAttributes,
+ ExGetPreviousMode(),
+ NULL,
+ sizeof(ROS_SECTION_OBJECT),
+ 0,
+ 0,
+ (PVOID*)(PVOID)&Section);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("MmCreatePageFileSection: failed to create object (0x%lx)\n", Status);
+ return(Status);
+ }
+
+ /*
+ * Initialize it
+ */
+ RtlZeroMemory(Section, sizeof(ROS_SECTION_OBJECT));
+ Section->Type = 'SC';
+ Section->Size = 'TN';
+ Section->SectionPageProtection = SectionPageProtection;
+ Section->AllocationAttributes = AllocationAttributes;
+ Section->MaximumSize = MaximumSize;
+ Segment = ExAllocatePoolWithTag(NonPagedPool, sizeof(MM_SECTION_SEGMENT),
+ TAG_MM_SECTION_SEGMENT);
+ if (Segment == NULL)
+ {
+ ObDereferenceObject(Section);
+ return(STATUS_NO_MEMORY);
+ }
+ RtlZeroMemory(Segment, sizeof(MM_SECTION_SEGMENT));
+ Section->Segment = Segment;
+ Segment->ReferenceCount = 1;
+ ExInitializeFastMutex(&Segment->Lock);
+ Segment->Image.FileOffset = 0;
+ Segment->Protection = SectionPageProtection;
+ Segment->RawLength.QuadPart = MaximumSize.u.LowPart;
+ Segment->Length.QuadPart = PAGE_ROUND_UP(MaximumSize.u.LowPart);
+ Segment->Flags = MM_PAGEFILE_SEGMENT;
+ Segment->WriteCopy = FALSE;
+ Segment->Image.VirtualAddress = 0;
+ Segment->Image.Characteristics = 0;
+ *SectionObject = Section;
+ MiInitializeSectionPageTable(Segment);
+ return(STATUS_SUCCESS);
+}
+
+NTSTATUS
+NTAPI
+MmCreateDataFileSection(PROS_SECTION_OBJECT *SectionObject,
+ ACCESS_MASK DesiredAccess,
+ POBJECT_ATTRIBUTES ObjectAttributes,
+ PLARGE_INTEGER UMaximumSize,
+ ULONG SectionPageProtection,
+ ULONG AllocationAttributes,
+ PFILE_OBJECT FileObject)
+/*
+ * Create a section backed by a data file
+ */
+{
+ PROS_SECTION_OBJECT Section;
+ NTSTATUS Status;
+ LARGE_INTEGER MaximumSize;
+ PMM_SECTION_SEGMENT Segment;
+ FILE_STANDARD_INFORMATION FileInfo;
+ ULONG Length;
+
+ /*
+ * Create the section
+ */
+ Status = ObCreateObject(ExGetPreviousMode(),
+ MmSectionObjectType,
+ ObjectAttributes,
+ ExGetPreviousMode(),
+ NULL,
+ sizeof(ROS_SECTION_OBJECT),
+ 0,
+ 0,
+ (PVOID*)&Section);
+ if (!NT_SUCCESS(Status))
+ {
+ ObDereferenceObject(FileObject);
+ return(Status);
+ }
+ /*
+ * Initialize it
+ */
+ RtlZeroMemory(Section, sizeof(ROS_SECTION_OBJECT));
+ Section->Type = 'SC';
+ Section->Size = 'TN';
+ Section->SectionPageProtection = SectionPageProtection;
+ Section->AllocationAttributes = AllocationAttributes;
+
+ /*
+ * FIXME: This is propably not entirely correct. We can't look into
+ * the standard FCB header because it might not be initialized yet
+ * (as in case of the EXT2FS driver by Manoj Paul Joseph where the
+ * standard file information is filled on first request).
+ */
+ Status = IoQueryFileInformation(FileObject,
+ FileStandardInformation,
+ sizeof(FILE_STANDARD_INFORMATION),
+ &FileInfo,
+ &Length);
+ if (!NT_SUCCESS(Status))
+ {
+ ObDereferenceObject(Section);
+ ObDereferenceObject(FileObject);
+ return Status;
+ }
+
+ /*
+ * FIXME: Revise this once a locking order for file size changes is
+ * decided
+ */
+ if ((UMaximumSize != NULL) && (UMaximumSize->QuadPart != 0))
+ {
+ MaximumSize = *UMaximumSize;
+ }
+ else
+ {
+ MaximumSize = FileInfo.EndOfFile;
+ /* Mapping zero-sized files isn't allowed. */
+ if (MaximumSize.QuadPart == 0)
+ {
+ ObDereferenceObject(Section);
+ ObDereferenceObject(FileObject);
+ return STATUS_MAPPED_FILE_SIZE_ZERO;
+ }
+ }
+
+ if (MaximumSize.QuadPart > FileInfo.EndOfFile.QuadPart)
+ {
+ Status = IoSetInformation(FileObject,
+ FileEndOfFileInformation,
+ sizeof(LARGE_INTEGER),
+ &MaximumSize);
+ if (!NT_SUCCESS(Status))
+ {
+ ObDereferenceObject(Section);
+ ObDereferenceObject(FileObject);
+ return(STATUS_SECTION_NOT_EXTENDED);
+ }
+ }
+
+ if (FileObject->SectionObjectPointer == NULL ||
+ FileObject->SectionObjectPointer->SharedCacheMap == NULL)
+ {
+ ObDereferenceObject(Section);
+ ObDereferenceObject(FileObject);
+ return STATUS_INVALID_FILE_FOR_SECTION;
+ }
+
+ /*
+ * Lock the file
+ */
+ Status = MmspWaitForFileLock(FileObject);
+ if (Status != STATUS_SUCCESS)
+ {
+ ObDereferenceObject(Section);
+ ObDereferenceObject(FileObject);
+ return(Status);
+ }
+
+ /*
+ * If this file hasn't been mapped as a data file before then allocate a
+ * section segment to describe the data file mapping
+ */
+ if (FileObject->SectionObjectPointer->DataSectionObject == NULL)
+ {
+ Segment = ExAllocatePoolWithTag(NonPagedPool, sizeof(MM_SECTION_SEGMENT),
+ TAG_MM_SECTION_SEGMENT);
+ if (Segment == NULL)
+ {
+ //KeSetEvent((PVOID)&FileObject->Lock, IO_NO_INCREMENT, FALSE);
+ ObDereferenceObject(Section);
+ ObDereferenceObject(FileObject);
+ return(STATUS_NO_MEMORY);
+ }
+ Section->Segment = Segment;
+ Segment->ReferenceCount = 1;
+ ExInitializeFastMutex(&Segment->Lock);
+ /*
+ * Set the lock before assigning the segment to the file object
+ */
+ ExAcquireFastMutex(&Segment->Lock);
+ FileObject->SectionObjectPointer->DataSectionObject = (PVOID)Segment;
+
+ Segment->Image.FileOffset = 0;
+ Segment->Protection = SectionPageProtection;
+ Segment->Flags = MM_DATAFILE_SEGMENT;
+ Segment->Image.Characteristics = 0;
+ Segment->WriteCopy = (SectionPageProtection & (PAGE_WRITECOPY | PAGE_EXECUTE_WRITECOPY));
+ if (AllocationAttributes & SEC_RESERVE)
+ {
+ Segment->Length.QuadPart = Segment->RawLength.QuadPart = 0;
+ }
+ else
+ {
+ Segment->RawLength.QuadPart = MaximumSize.QuadPart;
+ Segment->Length.QuadPart = PAGE_ROUND_UP(Segment->RawLength.QuadPart);
+ }
+ Segment->Image.VirtualAddress = 0;
+ Segment->Locked = TRUE;
+ MiInitializeSectionPageTable(Segment);
+ }
+ else
+ {
+ /*
+ * If the file is already mapped as a data file then we may need
+ * to extend it
+ */
+ Segment =
+ (PMM_SECTION_SEGMENT)FileObject->SectionObjectPointer->
+ DataSectionObject;
+ Section->Segment = Segment;
+ (void)InterlockedIncrementUL(&Segment->ReferenceCount);
+ MmLockSectionSegment(Segment);
+
+ if (MaximumSize.QuadPart > Segment->RawLength.QuadPart &&
+ !(AllocationAttributes & SEC_RESERVE))
+ {
+ Segment->RawLength.QuadPart = MaximumSize.QuadPart;
+ Segment->Length.QuadPart = PAGE_ROUND_UP(Segment->RawLength.QuadPart);
+ }
+ }
+ MmUnlockSectionSegment(Segment);
+ Section->FileObject = FileObject;
+ Section->MaximumSize = MaximumSize;
+#ifndef NEWCC
+ CcRosReferenceCache(FileObject);
+#endif
+ //KeSetEvent((PVOID)&FileObject->Lock, IO_NO_INCREMENT, FALSE);
+ *SectionObject = Section;
+ return(STATUS_SUCCESS);
+}
+
+/*
+ TODO: not that great (declaring loaders statically, having to declare all of
+ them, having to keep them extern, etc.), will fix in the future
+*/
+extern NTSTATUS NTAPI PeFmtCreateSection
+(
+ IN CONST VOID * FileHeader,
+ IN SIZE_T FileHeaderSize,
+ IN PVOID File,
+ OUT PMM_IMAGE_SECTION_OBJECT ImageSectionObject,
+ OUT PULONG Flags,
+ IN PEXEFMT_CB_READ_FILE ReadFileCb,
+ IN PEXEFMT_CB_ALLOCATE_SEGMENTS AllocateSegmentsCb
+);
+
+extern NTSTATUS NTAPI ElfFmtCreateSection
+(
+ IN CONST VOID * FileHeader,
+ IN SIZE_T FileHeaderSize,
+ IN PVOID File,
+ OUT PMM_IMAGE_SECTION_OBJECT ImageSectionObject,
+ OUT PULONG Flags,
+ IN PEXEFMT_CB_READ_FILE ReadFileCb,
+ IN PEXEFMT_CB_ALLOCATE_SEGMENTS AllocateSegmentsCb
+);
+
+static PEXEFMT_LOADER ExeFmtpLoaders[] =
+{
+ PeFmtCreateSection,
+#ifdef __ELF
+ ElfFmtCreateSection
+#endif
+};
+
+static
+PMM_SECTION_SEGMENT
+NTAPI
+ExeFmtpAllocateSegments(IN ULONG NrSegments)
+{
+ SIZE_T SizeOfSegments;
+ PMM_SECTION_SEGMENT Segments;
+
+ /* TODO: check for integer overflow */
+ SizeOfSegments = sizeof(MM_SECTION_SEGMENT) * NrSegments;
+
+ Segments = ExAllocatePoolWithTag(NonPagedPool,
+ SizeOfSegments,
+ TAG_MM_SECTION_SEGMENT);
+
+ if(Segments)
+ RtlZeroMemory(Segments, SizeOfSegments);
+
+ return Segments;
+}
+
+static
+NTSTATUS
+NTAPI
+ExeFmtpReadFile(IN PVOID File,
+ IN PLARGE_INTEGER Offset,
+ IN ULONG Length,
+ OUT PVOID * Data,
+ OUT PVOID * AllocBase,
+ OUT PULONG ReadSize)
+{
+ NTSTATUS Status;
+ LARGE_INTEGER FileOffset;
+ ULONG AdjustOffset;
+ ULONG OffsetAdjustment;
+ ULONG BufferSize;
+ ULONG UsedSize;
+ PVOID Buffer;
+ PFILE_OBJECT FileObject = File;
+ IO_STATUS_BLOCK Iosb;
+
+ ASSERT_IRQL_LESS(DISPATCH_LEVEL);
+
+ if(Length == 0)
+ {
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+
+ FileOffset = *Offset;
+
+ /* Negative/special offset: it cannot be used in this context */
+ if(FileOffset.u.HighPart < 0)
+ {
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+
+ AdjustOffset = PAGE_ROUND_DOWN(FileOffset.u.LowPart);
+ OffsetAdjustment = FileOffset.u.LowPart - AdjustOffset;
+ FileOffset.u.LowPart = AdjustOffset;
+
+ BufferSize = Length + OffsetAdjustment;
+ BufferSize = PAGE_ROUND_UP(BufferSize);
+
+ /* Flush data since we're about to perform a non-cached read */
+ CcFlushCache(FileObject->SectionObjectPointer,
+ &FileOffset,
+ BufferSize,
+ &Iosb);
+
+ /*
+ * It's ok to use paged pool, because this is a temporary buffer only used in
+ * the loading of executables. The assumption is that MmCreateSection is
+ * always called at low IRQLs and that these buffers don't survive a brief
+ * initialization phase
+ */
+ Buffer = ExAllocatePoolWithTag(PagedPool,
+ BufferSize,
+ 'rXmM');
+ if (!Buffer)
+ {
+ return STATUS_INSUFFICIENT_RESOURCES;
+ }
+
+ UsedSize = 0;
+
+ Status = MiSimpleRead(FileObject, &FileOffset, Buffer, BufferSize, TRUE, &Iosb);
+
+ UsedSize = (ULONG)Iosb.Information;
+
+ if(NT_SUCCESS(Status) && UsedSize < OffsetAdjustment)
+ {
+ Status = STATUS_IN_PAGE_ERROR;
+ ASSERT(!NT_SUCCESS(Status));
+ }
+
+ if(NT_SUCCESS(Status))
+ {
+ *Data = (PVOID)((ULONG_PTR)Buffer + OffsetAdjustment);
+ *AllocBase = Buffer;
+ *ReadSize = UsedSize - OffsetAdjustment;
+ }
+ else
+ {
+ ExFreePoolWithTag(Buffer, 'rXmM');
+ }
+
+ return Status;
+}
+
+#ifdef NASSERT
+# define MmspAssertSegmentsSorted(OBJ_) ((void)0)
+# define MmspAssertSegmentsNoOverlap(OBJ_) ((void)0)
+# define MmspAssertSegmentsPageAligned(OBJ_) ((void)0)
+#else
+static
+VOID
+NTAPI
+MmspAssertSegmentsSorted(IN PMM_IMAGE_SECTION_OBJECT ImageSectionObject)
+{
+ ULONG i;
+
+ for( i = 1; i < ImageSectionObject->NrSegments; ++ i )
+ {
+ ASSERT(ImageSectionObject->Segments[i].Image.VirtualAddress >=
+ ImageSectionObject->Segments[i - 1].Image.VirtualAddress);
+ }
+}
+
+static
+VOID
+NTAPI
+MmspAssertSegmentsNoOverlap(IN PMM_IMAGE_SECTION_OBJECT ImageSectionObject)
+{
+ ULONG i;
+
+ MmspAssertSegmentsSorted(ImageSectionObject);
+
+ for( i = 0; i < ImageSectionObject->NrSegments; ++ i )
+ {
+ ASSERT(ImageSectionObject->Segments[i].Length.QuadPart > 0);
+
+ if(i > 0)
+ {
+ ASSERT(ImageSectionObject->Segments[i].Image.VirtualAddress >=
+ (ImageSectionObject->Segments[i - 1].Image.VirtualAddress +
+ ImageSectionObject->Segments[i - 1].Length.QuadPart));
+ }
+ }
+}
+
+static
+VOID
+NTAPI
+MmspAssertSegmentsPageAligned(IN PMM_IMAGE_SECTION_OBJECT ImageSectionObject)
+{
+ ULONG i;
+
+ for( i = 0; i < ImageSectionObject->NrSegments; ++ i )
+ {
+ ASSERT((ImageSectionObject->Segments[i].Image.VirtualAddress % PAGE_SIZE) == 0);
+ ASSERT((ImageSectionObject->Segments[i].Length.QuadPart % PAGE_SIZE) == 0);
+ }
+}
+#endif
+
+static
+int
+__cdecl
+MmspCompareSegments(const void * x,
+ const void * y)
+{
+ const MM_SECTION_SEGMENT *Segment1 = (const MM_SECTION_SEGMENT *)x;
+ const MM_SECTION_SEGMENT *Segment2 = (const MM_SECTION_SEGMENT *)y;
+
+ return
+ (Segment1->Image.VirtualAddress - Segment2->Image.VirtualAddress) >>
+ ((sizeof(ULONG_PTR) - sizeof(int)) * 8);
+}
+
+/*
+ * Ensures an image section's segments are sorted in memory
+ */
+static
+VOID
+NTAPI
+MmspSortSegments(IN OUT PMM_IMAGE_SECTION_OBJECT ImageSectionObject,
+ IN ULONG Flags)
+{
+ if (Flags & EXEFMT_LOAD_ASSUME_SEGMENTS_SORTED)
+ {
+ MmspAssertSegmentsSorted(ImageSectionObject);
+ }
+ else
+ {
+ qsort(ImageSectionObject->Segments,
+ ImageSectionObject->NrSegments,
+ sizeof(ImageSectionObject->Segments[0]),
+ MmspCompareSegments);
+ }
+}
+
+
+/*
+ * Ensures an image section's segments don't overlap in memory and don't have
+ * gaps and don't have a null size. We let them map to overlapping file regions,
+ * though - that's not necessarily an error
+ */
+static
+BOOLEAN
+NTAPI
+MmspCheckSegmentBounds
+(
+ IN OUT PMM_IMAGE_SECTION_OBJECT ImageSectionObject,
+ IN ULONG Flags
+)
+{
+ ULONG i;
+
+ if (Flags & EXEFMT_LOAD_ASSUME_SEGMENTS_NO_OVERLAP)
+ {
+ MmspAssertSegmentsNoOverlap(ImageSectionObject);
+ return TRUE;
+ }
+
+ ASSERT(ImageSectionObject->NrSegments >= 1);
+
+ for ( i = 0; i < ImageSectionObject->NrSegments; ++ i )
+ {
+ if(ImageSectionObject->Segments[i].Length.QuadPart == 0)
+ {
+ return FALSE;
+ }
+
+ if(i > 0)
+ {
+ /*
+ * TODO: relax the limitation on gaps. For example, gaps smaller than a
+ * page could be OK (Windows seems to be OK with them), and larger gaps
+ * could lead to image sections spanning several discontiguous regions
+ * (NtMapViewOfSection could then refuse to map them, and they could
+ * e.g. only be allowed as parameters to NtCreateProcess, like on UNIX)
+ */
+ if ((ImageSectionObject->Segments[i - 1].Image.VirtualAddress +
+ ImageSectionObject->Segments[i - 1].Length.QuadPart) !=
+ ImageSectionObject->Segments[i].Image.VirtualAddress)
+ {
+ return FALSE;
+ }
+ }
+ }
+
+ return TRUE;
+}
+
+/*
+ * Merges and pads an image section's segments until they all are page-aligned
+ * and have a size that is a multiple of the page size
+ */
+static
+BOOLEAN
+NTAPI
+MmspPageAlignSegments
+(
+ IN OUT PMM_IMAGE_SECTION_OBJECT ImageSectionObject,
+ IN ULONG Flags
+)
+{
+ ULONG i;
+ ULONG LastSegment;
+ PMM_SECTION_SEGMENT EffectiveSegment;
+
+ if (Flags & EXEFMT_LOAD_ASSUME_SEGMENTS_PAGE_ALIGNED)
+ {
+ MmspAssertSegmentsPageAligned(ImageSectionObject);
+ return TRUE;
+ }
+
+ LastSegment = 0;
+ EffectiveSegment = &ImageSectionObject->Segments[LastSegment];
+
+ for ( i = 0; i < ImageSectionObject->NrSegments; ++ i )
+ {
+ /*
+ * The first segment requires special handling
+ */
+ if (i == 0)
+ {
+ ULONG_PTR VirtualAddress;
+ ULONG_PTR VirtualOffset;
+
+ VirtualAddress = EffectiveSegment->Image.VirtualAddress;
+
+ /* Round down the virtual address to the nearest page */
+ EffectiveSegment->Image.VirtualAddress = PAGE_ROUND_DOWN(VirtualAddress);
+
+ /* Round up the virtual size to the nearest page */
+ EffectiveSegment->Length.QuadPart = PAGE_ROUND_UP(VirtualAddress + EffectiveSegment->Length.QuadPart) -
+ EffectiveSegment->Image.VirtualAddress;
+
+ /* Adjust the raw address and size */
+ VirtualOffset = VirtualAddress - EffectiveSegment->Image.VirtualAddress;
+
+ if (EffectiveSegment->Image.FileOffset < VirtualOffset)
+ {
+ return FALSE;
+ }
+
+ /*
+ * Garbage in, garbage out: unaligned base addresses make the file
+ * offset point in curious and odd places, but that's what we were
+ * asked for
+ */
+ EffectiveSegment->Image.FileOffset -= VirtualOffset;
+ EffectiveSegment->RawLength.QuadPart += VirtualOffset;
+ }
+ else
+ {
+ PMM_SECTION_SEGMENT Segment = &ImageSectionObject->Segments[i];
+ ULONG_PTR EndOfEffectiveSegment;
+
+ EndOfEffectiveSegment = (ULONG_PTR)(EffectiveSegment->Image.VirtualAddress + EffectiveSegment->Length.QuadPart);
+ ASSERT((EndOfEffectiveSegment % PAGE_SIZE) == 0);
+
+ /*
+ * The current segment begins exactly where the current effective
+ * segment ended, therefore beginning a new effective segment
+ */
+ if (EndOfEffectiveSegment == Segment->Image.VirtualAddress)
+ {
+ LastSegment ++;
+ ASSERT(LastSegment <= i);
+ ASSERT(LastSegment < ImageSectionObject->NrSegments);
+
+ EffectiveSegment = &ImageSectionObject->Segments[LastSegment];
+
+ if (LastSegment != i)
+ {
+ /*
+ * Copy the current segment. If necessary, the effective segment
+ * will be expanded later
+ */
+ *EffectiveSegment = *Segment;
+ }
+
+ /*
+ * Page-align the virtual size. We know for sure the virtual address
+ * already is
+ */
+ ASSERT((EffectiveSegment->Image.VirtualAddress % PAGE_SIZE) == 0);
+ EffectiveSegment->Length.QuadPart = PAGE_ROUND_UP(EffectiveSegment->Length.QuadPart);
+ }
+ /*
+ * The current segment is still part of the current effective segment:
+ * extend the effective segment to reflect this
+ */
+ else if (EndOfEffectiveSegment > Segment->Image.VirtualAddress)
+ {
+ static const ULONG FlagsToProtection[16] =
+ {
+ PAGE_NOACCESS,
+ PAGE_READONLY,
+ PAGE_READWRITE,
+ PAGE_READWRITE,
+ PAGE_EXECUTE_READ,
+ PAGE_EXECUTE_READ,
+ PAGE_EXECUTE_READWRITE,
+ PAGE_EXECUTE_READWRITE,
+ PAGE_WRITECOPY,
+ PAGE_WRITECOPY,
+ PAGE_WRITECOPY,
+ PAGE_WRITECOPY,
+ PAGE_EXECUTE_WRITECOPY,
+ PAGE_EXECUTE_WRITECOPY,
+ PAGE_EXECUTE_WRITECOPY,
+ PAGE_EXECUTE_WRITECOPY
+ };
+
+ unsigned ProtectionFlags;
+
+ /*
+ * Extend the file size
+ */
+
+ /* Unaligned segments must be contiguous within the file */
+ if (Segment->Image.FileOffset != (EffectiveSegment->Image.FileOffset +
+ EffectiveSegment->RawLength.QuadPart))
+ {
+ return FALSE;
+ }
+
+ EffectiveSegment->RawLength.QuadPart += Segment->RawLength.QuadPart;
+
+ /*
+ * Extend the virtual size
+ */
+ ASSERT(PAGE_ROUND_UP(Segment->Image.VirtualAddress + Segment->Length.QuadPart) >= EndOfEffectiveSegment);
+
+ EffectiveSegment->Length.QuadPart = PAGE_ROUND_UP(Segment->Image.VirtualAddress + Segment->Length.QuadPart) -
+ EffectiveSegment->Image.VirtualAddress;
+
+ /*
+ * Merge the protection
+ */
+ EffectiveSegment->Protection |= Segment->Protection;
+
+ /* Clean up redundance */
+ ProtectionFlags = 0;
+
+ if(EffectiveSegment->Protection & PAGE_IS_READABLE)
+ ProtectionFlags |= 1 << 0;
+
+ if(EffectiveSegment->Protection & PAGE_IS_WRITABLE)
+ ProtectionFlags |= 1 << 1;
+
+ if(EffectiveSegment->Protection & PAGE_IS_EXECUTABLE)
+ ProtectionFlags |= 1 << 2;
+
+ if(EffectiveSegment->Protection & PAGE_IS_WRITECOPY)
+ ProtectionFlags |= 1 << 3;
+
+ ASSERT(ProtectionFlags < 16);
+ EffectiveSegment->Protection = FlagsToProtection[ProtectionFlags];
+
+ /* If a segment was required to be shared and cannot, fail */
+ if(!(Segment->Protection & PAGE_IS_WRITECOPY) &&
+ EffectiveSegment->Protection & PAGE_IS_WRITECOPY)
+ {
+ return FALSE;
+ }
+ }
+ /*
+ * We assume no holes between segments at this point
+ */
+ else
+ {
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+ }
+ }
+ ImageSectionObject->NrSegments = LastSegment + 1;
+
+ return TRUE;
+}
+
+NTSTATUS
+ExeFmtpCreateImageSection(PFILE_OBJECT FileObject,
+ PMM_IMAGE_SECTION_OBJECT ImageSectionObject)
+{
+ LARGE_INTEGER Offset;
+ PVOID FileHeader;
+ PVOID FileHeaderBuffer;
+ ULONG FileHeaderSize;
+ ULONG Flags;
+ ULONG OldNrSegments;
+ NTSTATUS Status;
+ ULONG i;
+
+ /*
+ * Read the beginning of the file (2 pages). Should be enough to contain
+ * all (or most) of the headers
+ */
+ Offset.QuadPart = 0;
+
+ Status = ExeFmtpReadFile (FileObject,
+ &Offset,
+ PAGE_SIZE * 2,
+ &FileHeader,
+ &FileHeaderBuffer,
+ &FileHeaderSize);
+
+ if (!NT_SUCCESS(Status))
+ return Status;
+
+ if (FileHeaderSize == 0)
+ {
+ ExFreePool(FileHeaderBuffer);
+ return STATUS_UNSUCCESSFUL;
+ }
+
+ /*
+ * Look for a loader that can handle this executable
+ */
+ for (i = 0; i < RTL_NUMBER_OF(ExeFmtpLoaders); ++ i)
+ {
+ RtlZeroMemory(ImageSectionObject, sizeof(*ImageSectionObject));
+ Flags = 0;
+
+ Status = ExeFmtpLoaders[i](FileHeader,
+ FileHeaderSize,
+ FileObject,
+ ImageSectionObject,
+ &Flags,
+ ExeFmtpReadFile,
+ ExeFmtpAllocateSegments);
+
+ if (!NT_SUCCESS(Status))
+ {
+ if (ImageSectionObject->Segments)
+ {
+ ExFreePool(ImageSectionObject->Segments);
+ ImageSectionObject->Segments = NULL;
+ }
+ }
+
+ if (Status != STATUS_ROS_EXEFMT_UNKNOWN_FORMAT)
+ break;
+ }
+
+ ExFreePoolWithTag(FileHeaderBuffer, 'rXmM');
+
+ /*
+ * No loader handled the format
+ */
+ if (Status == STATUS_ROS_EXEFMT_UNKNOWN_FORMAT)
+ {
+ Status = STATUS_INVALID_IMAGE_NOT_MZ;
+ ASSERT(!NT_SUCCESS(Status));
+ }
+
+ if (!NT_SUCCESS(Status))
+ return Status;
+
+ ASSERT(ImageSectionObject->Segments != NULL);
+
+ /*
+ * Some defaults
+ */
+ /* FIXME? are these values platform-dependent? */
+ if (ImageSectionObject->ImageInformation.MaximumStackSize == 0)
+ ImageSectionObject->ImageInformation.MaximumStackSize = 0x40000;
+
+ if(ImageSectionObject->ImageInformation.CommittedStackSize == 0)
+ ImageSectionObject->ImageInformation.CommittedStackSize = 0x1000;
+
+ if(ImageSectionObject->BasedAddress == NULL)
+ {
+ if(ImageSectionObject->ImageInformation.ImageCharacteristics & IMAGE_FILE_DLL)
+ ImageSectionObject->BasedAddress = (PVOID)0x10000000;
+ else
+ ImageSectionObject->BasedAddress = (PVOID)0x00400000;
+ }
+
+ /*
+ * And now the fun part: fixing the segments
+ */
+
+ /* Sort them by virtual address */
+ MmspSortSegments(ImageSectionObject, Flags);
+
+ /* Ensure they don't overlap in memory */
+ if (!MmspCheckSegmentBounds(ImageSectionObject, Flags))
+ return STATUS_INVALID_IMAGE_FORMAT;
+
+ /* Ensure they are aligned */
+ OldNrSegments = ImageSectionObject->NrSegments;
+
+ if (!MmspPageAlignSegments(ImageSectionObject, Flags))
+ return STATUS_INVALID_IMAGE_FORMAT;
+
+ /* Trim them if the alignment phase merged some of them */
+ if (ImageSectionObject->NrSegments < OldNrSegments)
+ {
+ PMM_SECTION_SEGMENT Segments;
+ SIZE_T SizeOfSegments;
+
+ SizeOfSegments = sizeof(MM_SECTION_SEGMENT) * ImageSectionObject->NrSegments;
+
+ Segments = ExAllocatePoolWithTag(PagedPool,
+ SizeOfSegments,
+ TAG_MM_SECTION_SEGMENT);
+
+ if (Segments == NULL)
+ return STATUS_INSUFFICIENT_RESOURCES;
+
+ RtlCopyMemory(Segments, ImageSectionObject->Segments, SizeOfSegments);
+ ExFreePool(ImageSectionObject->Segments);
+ ImageSectionObject->Segments = Segments;
+ }
+
+ /* And finish their initialization */
+ for ( i = 0; i < ImageSectionObject->NrSegments; ++ i )
+ {
+ ExInitializeFastMutex(&ImageSectionObject->Segments[i].Lock);
+ ImageSectionObject->Segments[i].ReferenceCount = 1;
+ MiInitializeSectionPageTable(&ImageSectionObject->Segments[i]);
+ }
+
+ ASSERT(NT_SUCCESS(Status));
+ return Status;
+}
+
+NTSTATUS
+MmCreateImageSection(PROS_SECTION_OBJECT *SectionObject,
+ ACCESS_MASK DesiredAccess,
+ POBJECT_ATTRIBUTES ObjectAttributes,
+ PLARGE_INTEGER UMaximumSize,
+ ULONG SectionPageProtection,
+ ULONG AllocationAttributes,
+ PFILE_OBJECT FileObject)
+{
+ PROS_SECTION_OBJECT Section;
+ NTSTATUS Status;
+ PMM_SECTION_SEGMENT SectionSegments;
+ PMM_IMAGE_SECTION_OBJECT ImageSectionObject;
+ ULONG i;
+
+ if (FileObject == NULL)
+ return STATUS_INVALID_FILE_FOR_SECTION;
+
+#ifndef NEWCC
+ if (FileObject->SectionObjectPointer->SharedCacheMap == NULL)
+ {
+ DPRINT1("Denying section creation due to missing cache initialization\n");
+ return STATUS_INVALID_FILE_FOR_SECTION;
+ }
+#endif
+
+ /*
+ * Create the section
+ */
+ Status = ObCreateObject (ExGetPreviousMode(),
+ MmSectionObjectType,
+ ObjectAttributes,
+ ExGetPreviousMode(),
+ NULL,
+ sizeof(ROS_SECTION_OBJECT),
+ 0,
+ 0,
+ (PVOID*)(PVOID)&Section);
+ if (!NT_SUCCESS(Status))
+ {
+ ObDereferenceObject(FileObject);
+ return(Status);
+ }
+
+ /*
+ * Initialize it
+ */
+ RtlZeroMemory(Section, sizeof(ROS_SECTION_OBJECT));
+ Section->Type = 'SC';
+ Section->Size = 'TN';
+ Section->SectionPageProtection = SectionPageProtection;
+ Section->AllocationAttributes = AllocationAttributes;
+
+#ifndef NEWCC
+ /*
+ * Initialized caching for this file object if previously caching
+ * was initialized for the same on disk file
+ */
+ Status = CcTryToInitializeFileCache(FileObject);
+#else
+ Status = STATUS_SUCCESS;
+#endif
+
+ if (!NT_SUCCESS(Status) || FileObject->SectionObjectPointer->ImageSectionObject == NULL)
+ {
+ NTSTATUS StatusExeFmt;
+
+ ImageSectionObject = ExAllocatePoolWithTag(PagedPool, sizeof(MM_IMAGE_SECTION_OBJECT), TAG_MM_SECTION_SEGMENT);
+ if (ImageSectionObject == NULL)
+ {
+ ObDereferenceObject(FileObject);
+ ObDereferenceObject(Section);
+ return(STATUS_NO_MEMORY);
+ }
+
+ RtlZeroMemory(ImageSectionObject, sizeof(MM_IMAGE_SECTION_OBJECT));
+
+ StatusExeFmt = ExeFmtpCreateImageSection(FileObject, ImageSectionObject);
+
+ if (!NT_SUCCESS(StatusExeFmt))
+ {
+ if(ImageSectionObject->Segments != NULL)
+ ExFreePool(ImageSectionObject->Segments);
+
+ /*
+ * If image file is empty, then return that the file is invalid for section
+ */
+ Status = StatusExeFmt;
+ if (StatusExeFmt == STATUS_END_OF_FILE)
+ {
+ Status = STATUS_INVALID_FILE_FOR_SECTION;
+ }
+
+ ExFreePoolWithTag(ImageSectionObject, TAG_MM_SECTION_SEGMENT);
+ ObDereferenceObject(Section);
+ ObDereferenceObject(FileObject);
+ return(Status);
+ }
+
+ Section->ImageSection = ImageSectionObject;
+ ASSERT(ImageSectionObject->Segments);
+
+ /*
+ * Lock the file
+ */
+ Status = MmspWaitForFileLock(FileObject);
+ if (!NT_SUCCESS(Status))
+ {
+ ExFreePool(ImageSectionObject->Segments);
+ ExFreePool(ImageSectionObject);
+ ObDereferenceObject(Section);
+ ObDereferenceObject(FileObject);
+ return(Status);
+ }
+
+ if (NULL != InterlockedCompareExchangePointer(&FileObject->SectionObjectPointer->ImageSectionObject,
+ ImageSectionObject, NULL))
+ {
+ /*
+ * An other thread has initialized the same image in the background
+ */
+ ExFreePool(ImageSectionObject->Segments);
+ ExFreePool(ImageSectionObject);
+ ImageSectionObject = FileObject->SectionObjectPointer->ImageSectionObject;
+ Section->ImageSection = ImageSectionObject;
+ SectionSegments = ImageSectionObject->Segments;
+
+ for (i = 0; i < ImageSectionObject->NrSegments; i++)
+ {
+ (void)InterlockedIncrementUL(&SectionSegments[i].ReferenceCount);
+ }
+ }
+
+ Status = StatusExeFmt;
+ }
+ else
+ {
+ /*
+ * Lock the file
+ */
+ Status = MmspWaitForFileLock(FileObject);
+ if (Status != STATUS_SUCCESS)
+ {
+ ObDereferenceObject(Section);
+ ObDereferenceObject(FileObject);
+ return(Status);
+ }
+
+ ImageSectionObject = FileObject->SectionObjectPointer->ImageSectionObject;
+ Section->ImageSection = ImageSectionObject;
+ SectionSegments = ImageSectionObject->Segments;
+
+ /*
+ * Otherwise just reference all the section segments
+ */
+ for (i = 0; i < ImageSectionObject->NrSegments; i++)
+ {
+ (void)InterlockedIncrementUL(&SectionSegments[i].ReferenceCount);
+ }
+
+ Status = STATUS_SUCCESS;
+ }
+ Section->FileObject = FileObject;
+#ifndef NEWCC
+ CcRosReferenceCache(FileObject);
+#endif
+ //KeSetEvent((PVOID)&FileObject->Lock, IO_NO_INCREMENT, FALSE);
+ *SectionObject = Section;
+ return(Status);
+}
+
+
+
+static NTSTATUS
+MmMapViewOfSegment(PMMSUPPORT AddressSpace,
+ PROS_SECTION_OBJECT Section,
+ PMM_SECTION_SEGMENT Segment,
+ PVOID* BaseAddress,
+ SIZE_T ViewSize,
+ ULONG Protect,
+ ULONG ViewOffset,
+ ULONG AllocationType)
+{
+ PMEMORY_AREA MArea;
+ NTSTATUS Status;
+ ULONG Granularity;
+
+ if (Segment->WriteCopy)
+ {
+ /* We have to do this because the not present fault
+ * and access fault handlers depend on the protection
+ * that should be granted AFTER the COW fault takes
+ * place to be in Region->Protect. The not present fault
+ * handler changes this to the correct protection for COW when
+ * mapping the pages into the process's address space. If a COW
+ * fault takes place, the access fault handler sets the page protection
+ * to these values for the newly copied pages
+ */
+ if (Protect == PAGE_WRITECOPY)
+ Protect = PAGE_READWRITE;
+ else if (Protect == PAGE_EXECUTE_WRITECOPY)
+ Protect = PAGE_EXECUTE_READWRITE;
+ }
+
+ if (*BaseAddress == NULL)
+ Granularity = MM_ALLOCATION_GRANULARITY;
+ else
+ Granularity = PAGE_SIZE;
+
+#ifdef NEWCC
+ if (Segment->Flags & MM_DATAFILE_SEGMENT)
+ {
+ LARGE_INTEGER FileOffset;
+ FileOffset.QuadPart = ViewOffset;
+ ObReferenceObject(Section);
+ return _MiMapViewOfSegment(AddressSpace, Segment, BaseAddress, ViewSize, Protect, &FileOffset, AllocationType, __FILE__, __LINE__);
+ }
+#endif
+ Status = MmCreateMemoryArea(AddressSpace,
+ MEMORY_AREA_SECTION_VIEW,
+ BaseAddress,
+ ViewSize,
+ Protect,
+ &MArea,
+ AllocationType,
+ Granularity);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("Mapping between 0x%p and 0x%p failed (%X).\n",
+ (*BaseAddress), (char*)(*BaseAddress) + ViewSize, Status);
+ return(Status);
+ }
+
+ ObReferenceObject((PVOID)Section);
+
+ MArea->Data.SectionData.Segment = Segment;
+ MArea->Data.SectionData.Section = Section;
+ MArea->Data.SectionData.ViewOffset.QuadPart = ViewOffset;
+ if (Section->AllocationAttributes & SEC_IMAGE)
+ {
+ MArea->VadNode.u.VadFlags.VadType = VadImageMap;
+ }
+
+ MmInitializeRegion(&MArea->Data.SectionData.RegionListHead,
+ ViewSize, 0, Protect);
+
+ return(STATUS_SUCCESS);
+}
+
+
+static VOID
+MmFreeSectionPage(PVOID Context, MEMORY_AREA* MemoryArea, PVOID Address,
+ PFN_NUMBER Page, SWAPENTRY SwapEntry, BOOLEAN Dirty)
+{
+ ULONG_PTR Entry;
+#ifndef NEWCC
+ PFILE_OBJECT FileObject;
+ PROS_SHARED_CACHE_MAP SharedCacheMap;
+#endif
+ LARGE_INTEGER Offset;
+ SWAPENTRY SavedSwapEntry;
+ PROS_SECTION_OBJECT Section;
+ PMM_SECTION_SEGMENT Segment;
+ PMMSUPPORT AddressSpace;
+ PEPROCESS Process;
+
+ AddressSpace = (PMMSUPPORT)Context;
+ Process = MmGetAddressSpaceOwner(AddressSpace);
+
+ Address = (PVOID)PAGE_ROUND_DOWN(Address);
+
+ Offset.QuadPart = ((ULONG_PTR)Address - MA_GetStartingAddress(MemoryArea)) +
+ MemoryArea->Data.SectionData.ViewOffset.QuadPart;
+
+ Section = MemoryArea->Data.SectionData.Section;
+ Segment = MemoryArea->Data.SectionData.Segment;
+
+ Entry = MmGetPageEntrySectionSegment(Segment, &Offset);
+ while (Entry && MM_IS_WAIT_PTE(Entry))
+ {
+ MmUnlockSectionSegment(Segment);
+ MmUnlockAddressSpace(AddressSpace);
+
+ MiWaitForPageEvent(NULL, NULL);
+
+ MmLockAddressSpace(AddressSpace);
+ MmLockSectionSegment(Segment);
+ Entry = MmGetPageEntrySectionSegment(Segment, &Offset);
+ }
+
+ /*
+ * For a dirty, datafile, non-private page mark it as dirty in the
+ * cache manager.
+ */
+ if (Segment->Flags & MM_DATAFILE_SEGMENT)
+ {
+ if (Page == PFN_FROM_SSE(Entry) && Dirty)
+ {
+#ifndef NEWCC
+ FileObject = MemoryArea->Data.SectionData.Section->FileObject;
+ SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
+ CcRosMarkDirtyVacb(SharedCacheMap, Offset.QuadPart + Segment->Image.FileOffset);
+#endif
+ ASSERT(SwapEntry == 0);
+ }
+ }
+
+ if (SwapEntry != 0)
+ {
+ /*
+ * Sanity check
+ */
+ if (Segment->Flags & MM_PAGEFILE_SEGMENT)
+ {
+ DPRINT1("Found a swap entry for a page in a pagefile section.\n");
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+ MmFreeSwapPage(SwapEntry);
+ }
+ else if (Page != 0)
+ {
+ if (IS_SWAP_FROM_SSE(Entry) ||
+ Page != PFN_FROM_SSE(Entry))
+ {
+ /*
+ * Sanity check
+ */
+ if (Segment->Flags & MM_PAGEFILE_SEGMENT)
+ {
+ DPRINT1("Found a private page in a pagefile section.\n");
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+ /*
+ * Just dereference private pages
+ */
+ SavedSwapEntry = MmGetSavedSwapEntryPage(Page);
+ if (SavedSwapEntry != 0)
+ {
+ MmFreeSwapPage(SavedSwapEntry);
+ MmSetSavedSwapEntryPage(Page, 0);
+ }
+ MmDeleteRmap(Page, Process, Address);
+ MmReleasePageMemoryConsumer(MC_USER, Page);
+ }
+ else
+ {
+ MmDeleteRmap(Page, Process, Address);
+ MmUnsharePageEntrySectionSegment(Section, Segment, &Offset, Dirty, FALSE, NULL);
+ }
+ }
+}
+
+static NTSTATUS
+MmUnmapViewOfSegment(PMMSUPPORT AddressSpace,
+ PVOID BaseAddress)
+{
+ NTSTATUS Status;
+ PMEMORY_AREA MemoryArea;
+ PROS_SECTION_OBJECT Section;
+ PMM_SECTION_SEGMENT Segment;
+ PLIST_ENTRY CurrentEntry;
+ PMM_REGION CurrentRegion;
+ PLIST_ENTRY RegionListHead;
+
+ MemoryArea = MmLocateMemoryAreaByAddress(AddressSpace,
+ BaseAddress);
+ if (MemoryArea == NULL)
+ {
+ return(STATUS_UNSUCCESSFUL);
+ }
+
+ Section = MemoryArea->Data.SectionData.Section;
+ Segment = MemoryArea->Data.SectionData.Segment;
+
+#ifdef NEWCC
+ if (Segment->Flags & MM_DATAFILE_SEGMENT)
+ {
+ MmUnlockAddressSpace(AddressSpace);
+ Status = MmUnmapViewOfCacheSegment(AddressSpace, BaseAddress);
+ MmLockAddressSpace(AddressSpace);
+
+ return Status;
+ }
+#endif
+
+ MemoryArea->DeleteInProgress = TRUE;
+
+ MmLockSectionSegment(Segment);
+
+ RegionListHead = &MemoryArea->Data.SectionData.RegionListHead;
+ while (!IsListEmpty(RegionListHead))
+ {
+ CurrentEntry = RemoveHeadList(RegionListHead);
+ CurrentRegion = CONTAINING_RECORD(CurrentEntry, MM_REGION, RegionListEntry);
+ ExFreePoolWithTag(CurrentRegion, TAG_MM_REGION);
+ }
+
+ if (Section->AllocationAttributes & SEC_PHYSICALMEMORY)
+ {
+ Status = MmFreeMemoryArea(AddressSpace,
+ MemoryArea,
+ NULL,
+ NULL);
+ }
+ else
+ {
+ Status = MmFreeMemoryArea(AddressSpace,
+ MemoryArea,
+ MmFreeSectionPage,
+ AddressSpace);
+ }
+ MmUnlockSectionSegment(Segment);
+ ObDereferenceObject(Section);
+ return(Status);
+}
+
+NTSTATUS
+NTAPI
+MiRosUnmapViewOfSection(IN PEPROCESS Process,
+ IN PVOID BaseAddress,
+ IN BOOLEAN SkipDebuggerNotify)
+{
+ NTSTATUS Status;
+ PMEMORY_AREA MemoryArea;
+ PMMSUPPORT AddressSpace;
+ PROS_SECTION_OBJECT Section;
+ PVOID ImageBaseAddress = 0;
+
+ DPRINT("Opening memory area Process %p BaseAddress %p\n",
+ Process, BaseAddress);
+
+ ASSERT(Process);
+
+ AddressSpace = Process ? &Process->Vm : MmGetKernelAddressSpace();
+
+ MmLockAddressSpace(AddressSpace);
+ MemoryArea = MmLocateMemoryAreaByAddress(AddressSpace,
+ BaseAddress);
+ if (MemoryArea == NULL ||
+ ((MemoryArea->Type != MEMORY_AREA_SECTION_VIEW) &&
+ (MemoryArea->Type != MEMORY_AREA_CACHE)) ||
+ MemoryArea->DeleteInProgress)
+ {
+ if (MemoryArea) ASSERT(MemoryArea->Type != MEMORY_AREA_OWNED_BY_ARM3);
+ MmUnlockAddressSpace(AddressSpace);
+ return STATUS_NOT_MAPPED_VIEW;
+ }
+
+ Section = MemoryArea->Data.SectionData.Section;
+
+ if ((Section != NULL) && (Section->AllocationAttributes & SEC_IMAGE))
+ {
+ ULONG i;
+ ULONG NrSegments;
+ PMM_IMAGE_SECTION_OBJECT ImageSectionObject;
+ PMM_SECTION_SEGMENT SectionSegments;
+ PMM_SECTION_SEGMENT Segment;
+
+ Segment = MemoryArea->Data.SectionData.Segment;
+ ImageSectionObject = Section->ImageSection;
+ SectionSegments = ImageSectionObject->Segments;
+ NrSegments = ImageSectionObject->NrSegments;
+
+ MemoryArea->DeleteInProgress = TRUE;
+
+ /* Search for the current segment within the section segments
+ * and calculate the image base address */
+ for (i = 0; i < NrSegments; i++)
+ {
+ if (Segment == &SectionSegments[i])
+ {
+ ImageBaseAddress = (char*)BaseAddress - (ULONG_PTR)SectionSegments[i].Image.VirtualAddress;
+ break;
+ }
+ }
+ if (i >= NrSegments)
+ {
+ KeBugCheck(MEMORY_MANAGEMENT);
+ }
+
+ for (i = 0; i < NrSegments; i++)
+ {
+ PVOID SBaseAddress = (PVOID)
+ ((char*)ImageBaseAddress + (ULONG_PTR)SectionSegments[i].Image.VirtualAddress);
+
+ Status = MmUnmapViewOfSegment(AddressSpace, SBaseAddress);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("MmUnmapViewOfSegment failed for %p (Process %p) with %lx\n",
+ SBaseAddress, Process, Status);
+ ASSERT(NT_SUCCESS(Status));
+ }
+ }
+ }
+ else
+ {
+ Status = MmUnmapViewOfSegment(AddressSpace, BaseAddress);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("MmUnmapViewOfSegment failed for %p (Process %p) with %lx\n",
+ BaseAddress, Process, Status);
+ ASSERT(NT_SUCCESS(Status));
+ }
+ }
+
+ MmUnlockAddressSpace(AddressSpace);
+
+ /* Notify debugger */
+ if (ImageBaseAddress && !SkipDebuggerNotify) DbgkUnMapViewOfSection(ImageBaseAddress);
+
+ return(STATUS_SUCCESS);
+}
+
+
+
+
+/**
+ * Queries the information of a section object.
+ *
+ * @param SectionHandle
+ * Handle to the section object. It must be opened with SECTION_QUERY
+ * access.
+ * @param SectionInformationClass
+ * Index to a certain information structure. Can be either
+ * SectionBasicInformation or SectionImageInformation. The latter
+ * is valid only for sections that were created with the SEC_IMAGE
+ * flag.
+ * @param SectionInformation
+ * Caller supplies storage for resulting information.
+ * @param Length
+ * Size of the supplied storage.
+ * @param ResultLength
+ * Data written.
+ *
+ * @return Status.
+ *
+ * @implemented
+ */
+NTSTATUS
+NTAPI
+NtQuerySection(
+ _In_ HANDLE SectionHandle,
+ _In_ SECTION_INFORMATION_CLASS SectionInformationClass,
+ _Out_ PVOID SectionInformation,
+ _In_ SIZE_T SectionInformationLength,
+ _Out_opt_ PSIZE_T ResultLength)
+{
+ PSECTION Section;
+ KPROCESSOR_MODE PreviousMode;
+ NTSTATUS Status;
+ PAGED_CODE();
+
+ PreviousMode = ExGetPreviousMode();
+ if (PreviousMode != KernelMode)
+ {
+ _SEH2_TRY
+ {
+ ProbeForWrite(SectionInformation,
+ SectionInformationLength,
+ __alignof(ULONG));
+ if (ResultLength != NULL)
+ {
+ ProbeForWrite(ResultLength,
+ sizeof(*ResultLength),
+ __alignof(SIZE_T));
+ }
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
+ }
+ _SEH2_END;
+ }
+
+ if (SectionInformationClass == SectionBasicInformation)
+ {
+ if (SectionInformationLength < sizeof(SECTION_BASIC_INFORMATION))
+ {
+ return STATUS_INFO_LENGTH_MISMATCH;
+ }
+ }
+ else if (SectionInformationClass == SectionImageInformation)
+ {
+ if (SectionInformationLength < sizeof(SECTION_IMAGE_INFORMATION))
+ {
+ return STATUS_INFO_LENGTH_MISMATCH;
+ }
+ }
+ else
+ {
+ return STATUS_INVALID_INFO_CLASS;
+ }
+
+ Status = ObReferenceObjectByHandle(SectionHandle,
+ SECTION_QUERY,
+ MmSectionObjectType,
+ PreviousMode,
+ (PVOID*)(PVOID)&Section,
+ NULL);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("Failed to reference section: 0x%lx\n", Status);
+ return Status;
+ }
+
+ if (MiIsRosSectionObject(Section))
+ {
+ PROS_SECTION_OBJECT RosSection = (PROS_SECTION_OBJECT)Section;
+
+ switch (SectionInformationClass)
+ {
+ case SectionBasicInformation:
+ {
+ PSECTION_BASIC_INFORMATION Sbi = (PSECTION_BASIC_INFORMATION)SectionInformation;
+
+ _SEH2_TRY
+ {
+ Sbi->Attributes = RosSection->AllocationAttributes;
+ if (RosSection->AllocationAttributes & SEC_IMAGE)
+ {
+ Sbi->BaseAddress = 0;
+ Sbi->Size.QuadPart = 0;
+ }
+ else
+ {
+ Sbi->BaseAddress = (PVOID)RosSection->Segment->Image.VirtualAddress;
+ Sbi->Size.QuadPart = RosSection->Segment->Length.QuadPart;
+ }
+
+ if (ResultLength != NULL)
+ {
+ *ResultLength = sizeof(SECTION_BASIC_INFORMATION);
+ }
+ Status = STATUS_SUCCESS;
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = _SEH2_GetExceptionCode();
+ }
+ _SEH2_END;
+
+ break;
+ }
+
+ case SectionImageInformation:
+ {
+ PSECTION_IMAGE_INFORMATION Sii = (PSECTION_IMAGE_INFORMATION)SectionInformation;
+
+ _SEH2_TRY
+ {
+ if (RosSection->AllocationAttributes & SEC_IMAGE)
+ {
+ PMM_IMAGE_SECTION_OBJECT ImageSectionObject;
+ ImageSectionObject = RosSection->ImageSection;
+
+ *Sii = ImageSectionObject->ImageInformation;
+ }
+
+ if (ResultLength != NULL)
+ {
+ *ResultLength = sizeof(SECTION_IMAGE_INFORMATION);
+ }
+ Status = STATUS_SUCCESS;
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = _SEH2_GetExceptionCode();
+ }
+ _SEH2_END;
+
+ break;
+ }
+ }
+ }
+ else
+ {
+ switch(SectionInformationClass)
+ {
+ case SectionBasicInformation:
+ {
+ SECTION_BASIC_INFORMATION Sbi;
+
+ Sbi.Size = Section->SizeOfSection;
+ Sbi.BaseAddress = (PVOID)Section->Address.StartingVpn;
+
+ Sbi.Attributes = 0;
+ if (Section->u.Flags.Image)
+ Sbi.Attributes |= SEC_IMAGE;
+ if (Section->u.Flags.Commit)
+ Sbi.Attributes |= SEC_COMMIT;
+ if (Section->u.Flags.Reserve)
+ Sbi.Attributes |= SEC_RESERVE;
+ if (Section->u.Flags.File)
+ Sbi.Attributes |= SEC_FILE;
+ if (Section->u.Flags.Image)
+ Sbi.Attributes |= SEC_IMAGE;
+
+ /* FIXME : Complete/test the list of flags passed back from NtCreateSection */
+
+ _SEH2_TRY
+ {
+ *((SECTION_BASIC_INFORMATION*)SectionInformation) = Sbi;
+ if (ResultLength)
+ *ResultLength = sizeof(Sbi);
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = _SEH2_GetExceptionCode();
+ }
+ _SEH2_END;
+ break;
+ }
+ case SectionImageInformation:
+ {
+ if (!Section->u.Flags.Image)
+ {
+ Status = STATUS_SECTION_NOT_IMAGE;
+ }
+ else
+ {
+ /* Currently not supported */
+ ASSERT(FALSE);
+ }
+ break;
+ }
+ }
+ }
+
+ ObDereferenceObject(Section);
+
+ return(Status);
+}
+
+/**********************************************************************
+ * NAME EXPORTED
+ * MmMapViewOfSection
+ *
+ * DESCRIPTION
+ * Maps a view of a section into the virtual address space of a
+ * process.
+ *
+ * ARGUMENTS
+ * Section
+ * Pointer to the section object.
+ *
+ * ProcessHandle
+ * Pointer to the process.
+ *
+ * BaseAddress
+ * Desired base address (or NULL) on entry;
+ * Actual base address of the view on exit.
+ *
+ * ZeroBits
+ * Number of high order address bits that must be zero.
+ *
+ * CommitSize
+ * Size in bytes of the initially committed section of
+ * the view.
+ *
+ * SectionOffset
+ * Offset in bytes from the beginning of the section
+ * to the beginning of the view.
+ *
+ * ViewSize
+ * Desired length of map (or zero to map all) on entry
+ * Actual length mapped on exit.
+ *
+ * InheritDisposition
+ * Specified how the view is to be shared with
+ * child processes.
+ *
+ * AllocationType
+ * Type of allocation for the pages.
+ *
+ * Protect
+ * Protection for the committed region of the view.
+ *
+ * RETURN VALUE
+ * Status.
+ *
+ * @implemented
+ */
+NTSTATUS NTAPI
+MmMapViewOfSection(IN PVOID SectionObject,
+ IN PEPROCESS Process,
+ IN OUT PVOID *BaseAddress,
+ IN ULONG_PTR ZeroBits,
+ IN SIZE_T CommitSize,
+ IN OUT PLARGE_INTEGER SectionOffset OPTIONAL,
+ IN OUT PSIZE_T ViewSize,
+ IN SECTION_INHERIT InheritDisposition,
+ IN ULONG AllocationType,
+ IN ULONG Protect)
+{
+ PROS_SECTION_OBJECT Section;
+ PMMSUPPORT AddressSpace;
+ ULONG ViewOffset;
+ NTSTATUS Status = STATUS_SUCCESS;
+ BOOLEAN NotAtBase = FALSE;
+
+ if (MiIsRosSectionObject(SectionObject) == FALSE)
+ {
+ DPRINT("Mapping ARM3 section into %s\n", Process->ImageFileName);
+ return MmMapViewOfArm3Section(SectionObject,
+ Process,
+ BaseAddress,
+ ZeroBits,
+ CommitSize,
+ SectionOffset,
+ ViewSize,
+ InheritDisposition,
+ AllocationType,
+ Protect);
+ }
+
+ ASSERT(Process);
+
+ if (!Protect || Protect & ~PAGE_FLAGS_VALID_FOR_SECTION)
+ {
+ return STATUS_INVALID_PAGE_PROTECTION;
+ }
+
+ /* FIXME: We should keep this, but it would break code checking equality */
+ Protect &= ~PAGE_NOCACHE;
+
+ Section = (PROS_SECTION_OBJECT)SectionObject;
+ AddressSpace = &Process->Vm;
+
+ AllocationType |= (Section->AllocationAttributes & SEC_NO_CHANGE);
+
+ MmLockAddressSpace(AddressSpace);
+
+ if (Section->AllocationAttributes & SEC_IMAGE)
+ {
+ ULONG i;
+ ULONG NrSegments;
+ ULONG_PTR ImageBase;
+ SIZE_T ImageSize;
+ PMM_IMAGE_SECTION_OBJECT ImageSectionObject;
+ PMM_SECTION_SEGMENT SectionSegments;
+
+ ImageSectionObject = Section->ImageSection;
+ SectionSegments = ImageSectionObject->Segments;
+ NrSegments = ImageSectionObject->NrSegments;
+
+ ImageBase = (ULONG_PTR)*BaseAddress;
+ if (ImageBase == 0)
+ {
+ ImageBase = (ULONG_PTR)ImageSectionObject->BasedAddress;
+ }
+
+ ImageSize = 0;
+ for (i = 0; i < NrSegments; i++)
+ {
+ ULONG_PTR MaxExtent;
+ MaxExtent = (ULONG_PTR)(SectionSegments[i].Image.VirtualAddress +
+ SectionSegments[i].Length.QuadPart);
+ ImageSize = max(ImageSize, MaxExtent);
+ }
+
+ ImageSectionObject->ImageInformation.ImageFileSize = (ULONG)ImageSize;
+
+ /* Check for an illegal base address */
+ if (((ImageBase + ImageSize) > (ULONG_PTR)MmHighestUserAddress) ||
+ ((ImageBase + ImageSize) < ImageSize))
+ {
+ ASSERT(*BaseAddress == NULL);
+ ImageBase = ALIGN_DOWN_BY((ULONG_PTR)MmHighestUserAddress - ImageSize,
+ MM_VIRTMEM_GRANULARITY);
+ NotAtBase = TRUE;
+ }
+ else if (ImageBase != ALIGN_DOWN_BY(ImageBase, MM_VIRTMEM_GRANULARITY))
+ {
+ ASSERT(*BaseAddress == NULL);
+ ImageBase = ALIGN_DOWN_BY(ImageBase, MM_VIRTMEM_GRANULARITY);
+ NotAtBase = TRUE;
+ }
+
+ /* Check there is enough space to map the section at that point. */
+ if (MmLocateMemoryAreaByRegion(AddressSpace, (PVOID)ImageBase,
+ PAGE_ROUND_UP(ImageSize)) != NULL)
+ {
+ /* Fail if the user requested a fixed base address. */
+ if ((*BaseAddress) != NULL)
+ {
+ MmUnlockAddressSpace(AddressSpace);
+ return(STATUS_CONFLICTING_ADDRESSES);
+ }
+ /* Otherwise find a gap to map the image. */
+ ImageBase = (ULONG_PTR)MmFindGap(AddressSpace, PAGE_ROUND_UP(ImageSize), MM_VIRTMEM_GRANULARITY, FALSE);
+ if (ImageBase == 0)
+ {
+ MmUnlockAddressSpace(AddressSpace);
+ return(STATUS_CONFLICTING_ADDRESSES);
+ }
+ /* Remember that we loaded image at a different base address */
+ NotAtBase = TRUE;
+ }
+
+ for (i = 0; i < NrSegments; i++)
+ {
+ PVOID SBaseAddress = (PVOID)
+ ((char*)ImageBase + (ULONG_PTR)SectionSegments[i].Image.VirtualAddress);
+ MmLockSectionSegment(&SectionSegments[i]);
+ Status = MmMapViewOfSegment(AddressSpace,
+ Section,
+ &SectionSegments[i],
+ &SBaseAddress,
+ SectionSegments[i].Length.LowPart,
+ SectionSegments[i].Protection,
+ 0,
+ 0);
+ MmUnlockSectionSegment(&SectionSegments[i]);
+ if (!NT_SUCCESS(Status))
+ {
+ MmUnlockAddressSpace(AddressSpace);
+ return(Status);
+ }
+ }
+
+ *BaseAddress = (PVOID)ImageBase;
+ *ViewSize = ImageSize;
+ }
+ else
+ {
+ /* check for write access */
+ if ((Protect & (PAGE_READWRITE|PAGE_EXECUTE_READWRITE)) &&
+ !(Section->SectionPageProtection & (PAGE_READWRITE|PAGE_EXECUTE_READWRITE)))
+ {
+ MmUnlockAddressSpace(AddressSpace);
+ return STATUS_SECTION_PROTECTION;
+ }
+ /* check for read access */
+ if ((Protect & (PAGE_READONLY|PAGE_WRITECOPY|PAGE_EXECUTE_READ|PAGE_EXECUTE_WRITECOPY)) &&
+ !(Section->SectionPageProtection & (PAGE_READONLY|PAGE_READWRITE|PAGE_WRITECOPY|PAGE_EXECUTE_READ|PAGE_EXECUTE_READWRITE|PAGE_EXECUTE_WRITECOPY)))
+ {
+ MmUnlockAddressSpace(AddressSpace);
+ return STATUS_SECTION_PROTECTION;
+ }
+ /* check for execute access */
+ if ((Protect & (PAGE_EXECUTE|PAGE_EXECUTE_READ|PAGE_EXECUTE_READWRITE|PAGE_EXECUTE_WRITECOPY)) &&
+ !(Section->SectionPageProtection & (PAGE_EXECUTE|PAGE_EXECUTE_READ|PAGE_EXECUTE_READWRITE|PAGE_EXECUTE_WRITECOPY)))
+ {
+ MmUnlockAddressSpace(AddressSpace);
+ return STATUS_SECTION_PROTECTION;
+ }
+
+ if (SectionOffset == NULL)
+ {
+ ViewOffset = 0;
+ }
+ else
+ {
+ ViewOffset = SectionOffset->u.LowPart;
+ }
+
+ if ((ViewOffset % PAGE_SIZE) != 0)
+ {
+ MmUnlockAddressSpace(AddressSpace);
+ return(STATUS_MAPPED_ALIGNMENT);
+ }
+
+ if ((*ViewSize) == 0)
+ {
+ (*ViewSize) = Section->MaximumSize.u.LowPart - ViewOffset;
+ }
+ else if (((*ViewSize)+ViewOffset) > Section->MaximumSize.u.LowPart)
+ {
+ (*ViewSize) = Section->MaximumSize.u.LowPart - ViewOffset;
+ }
+
+ *ViewSize = PAGE_ROUND_UP(*ViewSize);
+
+ MmLockSectionSegment(Section->Segment);
+ Status = MmMapViewOfSegment(AddressSpace,
+ Section,
+ Section->Segment,
+ BaseAddress,
+ *ViewSize,
+ Protect,
+ ViewOffset,
+ AllocationType & (MEM_TOP_DOWN|SEC_NO_CHANGE));
+ MmUnlockSectionSegment(Section->Segment);
+ if (!NT_SUCCESS(Status))
+ {
+ MmUnlockAddressSpace(AddressSpace);
+ return(Status);
+ }
+ }
+
+ MmUnlockAddressSpace(AddressSpace);
+ ASSERT(*BaseAddress == ALIGN_DOWN_POINTER_BY(*BaseAddress, MM_VIRTMEM_GRANULARITY));
+
+ if (NotAtBase)
+ Status = STATUS_IMAGE_NOT_AT_BASE;
+ else
+ Status = STATUS_SUCCESS;
+
+ return Status;
+}
+
+/*
+ * @unimplemented
+ */
+BOOLEAN NTAPI
+MmCanFileBeTruncated (IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
+ IN PLARGE_INTEGER NewFileSize)
+{
+ /* Check whether an ImageSectionObject exists */
+ if (SectionObjectPointer->ImageSectionObject != NULL)
+ {
+ DPRINT1("ERROR: File can't be truncated because it has an image section\n");
+ return FALSE;
+ }
+
+ if (SectionObjectPointer->DataSectionObject != NULL)
+ {
+ PMM_SECTION_SEGMENT Segment;
+
+ Segment = (PMM_SECTION_SEGMENT)SectionObjectPointer->
+ DataSectionObject;
+
+ if (Segment->ReferenceCount != 0)
+ {
+#ifdef NEWCC
+ CC_FILE_SIZES FileSizes;
+ CcpLock();
+ if (SectionObjectPointer->SharedCacheMap && (Segment->ReferenceCount > CcpCountCacheSections((PNOCC_CACHE_MAP)SectionObjectPointer->SharedCacheMap)))
+ {
+ CcpUnlock();
+ /* Check size of file */
+ if (SectionObjectPointer->SharedCacheMap)
+ {
+ if (!CcGetFileSizes(Segment->FileObject, &FileSizes))
+ {
+ return FALSE;
+ }
+
+ if (NewFileSize->QuadPart <= FileSizes.FileSize.QuadPart)
+ {
+ return FALSE;
+ }
+ }
+ }
+ else
+ CcpUnlock();
+#else
+ /* Check size of file */
+ if (SectionObjectPointer->SharedCacheMap)
+ {
+ PROS_SHARED_CACHE_MAP SharedCacheMap = SectionObjectPointer->SharedCacheMap;
+ if (NewFileSize->QuadPart <= SharedCacheMap->FileSize.QuadPart)
+ {
+ return FALSE;
+ }
+ }
+#endif
+ }
+ else
+ {
+ /* Something must gone wrong
+ * how can we have a Section but no
+ * reference? */
+ DPRINT("ERROR: DataSectionObject without reference!\n");
+ }
+ }
+
+ DPRINT("FIXME: didn't check for outstanding write probes\n");
+
+ return TRUE;
+}
+
+
+
+
+/*
+ * @implemented
+ */
+BOOLEAN NTAPI
+MmFlushImageSection (IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
+ IN MMFLUSH_TYPE FlushType)
+{
+ BOOLEAN Result = TRUE;
+#ifdef NEWCC
+ PMM_SECTION_SEGMENT Segment;
+#endif
+
+ switch(FlushType)
+ {
+ case MmFlushForDelete:
+ if (SectionObjectPointer->ImageSectionObject ||
+ SectionObjectPointer->DataSectionObject)
+ {
+ return FALSE;
+ }
+#ifndef NEWCC
+ CcRosRemoveIfClosed(SectionObjectPointer);
+#endif
+ return TRUE;
+ case MmFlushForWrite:
+ {
+ DPRINT("MmFlushImageSection(%d)\n", FlushType);
+#ifdef NEWCC
+ Segment = (PMM_SECTION_SEGMENT)SectionObjectPointer->DataSectionObject;
+#endif
+
+ if (SectionObjectPointer->ImageSectionObject)
+ {
+ DPRINT1("SectionObject has ImageSection\n");
+ return FALSE;
+ }
+
+#ifdef NEWCC
+ CcpLock();
+ Result = !SectionObjectPointer->SharedCacheMap || (Segment->ReferenceCount == CcpCountCacheSections((PNOCC_CACHE_MAP)SectionObjectPointer->SharedCacheMap));
+ CcpUnlock();
+ DPRINT("Result %d\n", Result);
+#endif
+ return Result;
+ }
+ }
+ return FALSE;
+}
+
+/*
+ * @implemented
+ */
+NTSTATUS NTAPI
+MmMapViewInSystemSpace (IN PVOID SectionObject,
+ OUT PVOID * MappedBase,
+ IN OUT PSIZE_T ViewSize)
+{
+ PROS_SECTION_OBJECT Section;
+ PMMSUPPORT AddressSpace;
+ NTSTATUS Status;
+ PAGED_CODE();
+
+ if (MiIsRosSectionObject(SectionObject) == FALSE)
+ {
+ return MiMapViewInSystemSpace(SectionObject,
+ &MmSession,
+ MappedBase,
+ ViewSize);
+ }
+
+ DPRINT("MmMapViewInSystemSpace() called\n");
+
+ Section = (PROS_SECTION_OBJECT)SectionObject;
+ AddressSpace = MmGetKernelAddressSpace();
+
+ MmLockAddressSpace(AddressSpace);
+
+
+ if ((*ViewSize) == 0)
+ {
+ (*ViewSize) = Section->MaximumSize.u.LowPart;
+ }
+ else if ((*ViewSize) > Section->MaximumSize.u.LowPart)
+ {
+ (*ViewSize) = Section->MaximumSize.u.LowPart;
+ }
+
+ MmLockSectionSegment(Section->Segment);
+
+
+ Status = MmMapViewOfSegment(AddressSpace,
+ Section,
+ Section->Segment,
+ MappedBase,
+ *ViewSize,
+ PAGE_READWRITE,
+ 0,
+ 0);
+
+ MmUnlockSectionSegment(Section->Segment);
+ MmUnlockAddressSpace(AddressSpace);
+
+ return Status;
+}
+
+NTSTATUS
+NTAPI
+MiRosUnmapViewInSystemSpace(IN PVOID MappedBase)
+{
+ PMMSUPPORT AddressSpace;
+ NTSTATUS Status;
+
+ DPRINT("MmUnmapViewInSystemSpace() called\n");
+
+ AddressSpace = MmGetKernelAddressSpace();
+
+ MmLockAddressSpace(AddressSpace);
+
+ Status = MmUnmapViewOfSegment(AddressSpace, MappedBase);
+
+ MmUnlockAddressSpace(AddressSpace);
+
+ return Status;
+}
+
+/**********************************************************************
+ * NAME EXPORTED
+ * MmCreateSection@
+ *
+ * DESCRIPTION
+ * Creates a section object.
+ *
+ * ARGUMENTS
+ * SectionObject (OUT)
+ * Caller supplied storage for the resulting pointer
+ * to a SECTION_OBJECT instance;
+ *
+ * DesiredAccess
+ * Specifies the desired access to the section can be a
+ * combination of:
+ * STANDARD_RIGHTS_REQUIRED |
+ * SECTION_QUERY |
+ * SECTION_MAP_WRITE |
+ * SECTION_MAP_READ |
+ * SECTION_MAP_EXECUTE
+ *
+ * ObjectAttributes [OPTIONAL]
+ * Initialized attributes for the object can be used
+ * to create a named section;
+ *
+ * MaximumSize
+ * Maximizes the size of the memory section. Must be
+ * non-NULL for a page-file backed section.
+ * If value specified for a mapped file and the file is
+ * not large enough, file will be extended.
+ *
+ * SectionPageProtection
+ * Can be a combination of:
+ * PAGE_READONLY |
+ * PAGE_READWRITE |
+ * PAGE_WRITEONLY |
+ * PAGE_WRITECOPY
+ *
+ * AllocationAttributes
+ * Can be a combination of:
+ * SEC_IMAGE |
+ * SEC_RESERVE
+ *
+ * FileHandle
+ * Handle to a file to create a section mapped to a file
+ * instead of a memory backed section;
+ *
+ * File
+ * Unknown.
+ *
+ * RETURN VALUE
+ * Status.
+ *
+ * @implemented
+ */
+NTSTATUS NTAPI
+MmCreateSection (OUT PVOID * Section,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
+ IN PLARGE_INTEGER MaximumSize,
+ IN ULONG SectionPageProtection,
+ IN ULONG AllocationAttributes,
+ IN HANDLE FileHandle OPTIONAL,
+ IN PFILE_OBJECT FileObject OPTIONAL)
+{
+ NTSTATUS Status;
+ ULONG Protection;
+ PROS_SECTION_OBJECT *SectionObject = (PROS_SECTION_OBJECT *)Section;
+
+ /* Check if an ARM3 section is being created instead */
+ if (!(AllocationAttributes & (SEC_IMAGE | SEC_PHYSICALMEMORY)))
+ {
+ if (!(FileObject) && !(FileHandle))
+ {
+ return MmCreateArm3Section(Section,
+ DesiredAccess,
+ ObjectAttributes,
+ MaximumSize,
+ SectionPageProtection,
+ AllocationAttributes &~ 1,
+ FileHandle,
+ FileObject);
+ }
+ }
+
+ /* Convert section flag to page flag */
+ if (AllocationAttributes & SEC_NOCACHE) SectionPageProtection |= PAGE_NOCACHE;
+
+ /* Check to make sure the protection is correct. Nt* does this already */
+ Protection = MiMakeProtectionMask(SectionPageProtection);
+ if (Protection == MM_INVALID_PROTECTION)
+ {
+ DPRINT1("Page protection is invalid\n");
+ return STATUS_INVALID_PAGE_PROTECTION;
+ }
+
+ /* Check if this is going to be a data or image backed file section */
+ if ((FileHandle) || (FileObject))
+ {
+ /* These cannot be mapped with large pages */
+ if (AllocationAttributes & SEC_LARGE_PAGES)
+ {
+ DPRINT1("Large pages cannot be used with an image mapping\n");
+ return STATUS_INVALID_PARAMETER_6;
+ }
+
+ /* Did the caller pass an object? */
+ if (FileObject)
+ {
+ /* Reference the object directly */
+ ObReferenceObject(FileObject);
+ }
+ else
+ {
+ /* Reference the file handle to get the object */
+ Status = ObReferenceObjectByHandle(FileHandle,
+ MmMakeFileAccess[Protection],
+ IoFileObjectType,
+ ExGetPreviousMode(),
+ (PVOID*)&FileObject,
+ NULL);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("Failed to get a handle to the FO: %lx\n", Status);
+ return Status;
+ }
+ }
+ }
+ else
+ {
+ /* A handle must be supplied with SEC_IMAGE, as this is the no-handle path */
+ if (AllocationAttributes & SEC_IMAGE) return STATUS_INVALID_FILE_FOR_SECTION;
+ }
+
+#ifndef NEWCC // A hack for initializing caching.
+ // This is needed only in the old case.
+ if (FileHandle)
+ {
+ IO_STATUS_BLOCK Iosb;
+ NTSTATUS Status;
+ CHAR Buffer;
+ LARGE_INTEGER ByteOffset;
+ ByteOffset.QuadPart = 0;
+ Status = ZwReadFile(FileHandle,
+ NULL,
+ NULL,
+ NULL,
+ &Iosb,
+ &Buffer,
+ sizeof(Buffer),
+ &ByteOffset,
+ NULL);
+ if (!NT_SUCCESS(Status) && Status != STATUS_END_OF_FILE)
+ {
+ DPRINT1("CC failure: %lx\n", Status);
+ if (FileObject)
+ ObDereferenceObject(FileObject);
+ return Status;
+ }
+ // Caching is initialized...
+
+ // Hack of the hack: actually, it might not be initialized if FSD init on effective right and if file is null-size
+ // In such case, force cache by initiating a write IRP
+ if (Status == STATUS_END_OF_FILE && !(AllocationAttributes & SEC_IMAGE) && FileObject != NULL &&
+ (FileObject->SectionObjectPointer == NULL || FileObject->SectionObjectPointer->SharedCacheMap == NULL))
+ {
+ Buffer = 0xdb;
+ Status = ZwWriteFile(FileHandle,
+ NULL,
+ NULL,
+ NULL,
+ &Iosb,
+ &Buffer,
+ sizeof(Buffer),
+ &ByteOffset,
+ NULL);
+ if (NT_SUCCESS(Status))
+ {
+ LARGE_INTEGER Zero;
+ Zero.QuadPart = 0LL;
+
+ Status = IoSetInformation(FileObject,
+ FileEndOfFileInformation,
+ sizeof(LARGE_INTEGER),
+ &Zero);
+ ASSERT(NT_SUCCESS(Status));
+ }
+ }
+ }
+#endif
+
+ if (AllocationAttributes & SEC_IMAGE)
+ {
+ Status = MmCreateImageSection(SectionObject,
+ DesiredAccess,
+ ObjectAttributes,
+ MaximumSize,
+ SectionPageProtection,
+ AllocationAttributes,
+ FileObject);
+ }
+#ifndef NEWCC
+ else if (FileHandle != NULL)
+ {
+ Status = MmCreateDataFileSection(SectionObject,
+ DesiredAccess,
+ ObjectAttributes,
+ MaximumSize,
+ SectionPageProtection,
+ AllocationAttributes,
+ FileObject);
+ }
+#else
+ else if (FileHandle != NULL || FileObject != NULL)
+ {
+ Status = MmCreateCacheSection(SectionObject,
+ DesiredAccess,
+ ObjectAttributes,
+ MaximumSize,
+ SectionPageProtection,
+ AllocationAttributes,
+ FileObject);
+ }
+#endif
+ else
+ {
+ if ((AllocationAttributes & SEC_PHYSICALMEMORY) == 0)
+ {
+ DPRINT1("Invalid path: %lx %p %p\n", AllocationAttributes, FileObject, FileHandle);
+ }
+// ASSERT(AllocationAttributes & SEC_PHYSICALMEMORY);
+ Status = MmCreatePageFileSection(SectionObject,
+ DesiredAccess,
+ ObjectAttributes,
+ MaximumSize,
+ SectionPageProtection,
+ AllocationAttributes);
+ if (FileObject)
+ ObDereferenceObject(FileObject);
+ }
+
+ return Status;
+}
+
+/* EOF */
projects / reactos.git / blobdiff