section.c File Reference

#include <ntoskrnl.h>
#include <cache/newcc.h>
#include <cache/section/newmm.h>
#include <debug.h>
#include <reactos/exeformat.h>
#include "ARM3/miarm.h"

Include dependency graph for section.c:

Go to the source code of this file.

Classes
struct	MM_SECTION_PAGEOUT_CONTEXT

Macros
#define	NDEBUG
#define	MmSetPageEntrySectionSegment(S, O, E)
#define	DIE(ARGS_)   { DPRINT ARGS_; goto l_Return; }

Functions
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)
	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))
ACCESS_MASK NTAPI	MiArm3GetCorrectFileAccessMask (IN ACCESS_MASK SectionPageProtection)
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	MmspWaitForFileLock (PFILE_OBJECT File)
VOID NTAPI	MmFreeSectionSegments (PFILE_OBJECT FileObject)
VOID NTAPI	MmSharePageEntrySectionSegment (PMM_SECTION_SEGMENT Segment, PLARGE_INTEGER Offset)
BOOLEAN NTAPI	MmUnsharePageEntrySectionSegment (PROS_SECTION_OBJECT Section, PMM_SECTION_SEGMENT Segment, PLARGE_INTEGER Offset, BOOLEAN Dirty, BOOLEAN PageOut, ULONG_PTR *InEntry)
BOOLEAN	MiIsPageFromCache (PMEMORY_AREA MemoryArea, LONGLONG SegOffset)
NTSTATUS NTAPI	MiCopyFromUserPage (PFN_NUMBER DestPage, const VOID *SrcAddress)
NTSTATUS NTAPI	MiReadPage (PMEMORY_AREA MemoryArea, LONGLONG SegOffset, PPFN_NUMBER Page)
static VOID	MmAlterViewAttributes (PMMSUPPORT AddressSpace, PVOID BaseAddress, SIZE_T RegionSize, ULONG OldType, ULONG OldProtect, ULONG NewType, ULONG NewProtect)
NTSTATUS NTAPI	MmNotPresentFaultSectionView (PMMSUPPORT AddressSpace, MEMORY_AREA *MemoryArea, PVOID Address, BOOLEAN Locked)
NTSTATUS NTAPI	MmAccessFaultSectionView (PMMSUPPORT AddressSpace, MEMORY_AREA *MemoryArea, PVOID Address)
VOID	MmPageOutDeleteMapping (PVOID Context, PEPROCESS Process, PVOID Address)
NTSTATUS NTAPI	MmPageOutSectionView (PMMSUPPORT AddressSpace, MEMORY_AREA *MemoryArea, PVOID Address, ULONG_PTR Entry)
NTSTATUS NTAPI	MmWritePageSectionView (PMMSUPPORT AddressSpace, PMEMORY_AREA MemoryArea, PVOID Address, ULONG PageEntry)
NTSTATUS NTAPI	MmProtectSectionView (PMMSUPPORT AddressSpace, PMEMORY_AREA MemoryArea, PVOID BaseAddress, SIZE_T Length, ULONG Protect, PULONG OldProtect)
NTSTATUS NTAPI	MmQuerySectionView (PMEMORY_AREA MemoryArea, PVOID Address, PMEMORY_BASIC_INFORMATION Info, PSIZE_T ResultLength)
VOID NTAPI	MmpFreePageFileSegment (PMM_SECTION_SEGMENT Segment)
VOID NTAPI	MmpDeleteSection (PVOID ObjectBody)
VOID NTAPI	MmpCloseSection (IN PEPROCESS Process OPTIONAL, IN PVOID Object, IN ACCESS_MASK GrantedAccess, IN ULONG ProcessHandleCount, IN ULONG SystemHandleCount)
NTSTATUS INIT_FUNCTION NTAPI	MmCreatePhysicalMemorySection (VOID)
NTSTATUS INIT_FUNCTION NTAPI	MmInitSectionImplementation (VOID)
NTSTATUS NTAPI	MmCreatePageFileSection (PROS_SECTION_OBJECT *SectionObject, ACCESS_MASK DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes, PLARGE_INTEGER UMaximumSize, ULONG SectionPageProtection, ULONG AllocationAttributes)
NTSTATUS NTAPI	MmCreateDataFileSection (PROS_SECTION_OBJECT *SectionObject, ACCESS_MASK DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes, PLARGE_INTEGER UMaximumSize, ULONG SectionPageProtection, ULONG AllocationAttributes, PFILE_OBJECT FileObject)
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 PMM_SECTION_SEGMENT NTAPI	ExeFmtpAllocateSegments (IN ULONG NrSegments)
static NTSTATUS NTAPI	ExeFmtpReadFile (IN PVOID File, IN PLARGE_INTEGER Offset, IN ULONG Length, OUT PVOID *Data, OUT PVOID *AllocBase, OUT PULONG ReadSize)
static VOID NTAPI	MmspAssertSegmentsSorted (IN PMM_IMAGE_SECTION_OBJECT ImageSectionObject)
static VOID NTAPI	MmspAssertSegmentsNoOverlap (IN PMM_IMAGE_SECTION_OBJECT ImageSectionObject)
static VOID NTAPI	MmspAssertSegmentsPageAligned (IN PMM_IMAGE_SECTION_OBJECT ImageSectionObject)
static int __cdecl	MmspCompareSegments (const void *x, const void *y)
static VOID NTAPI	MmspSortSegments (IN OUT PMM_IMAGE_SECTION_OBJECT ImageSectionObject, IN ULONG Flags)
static BOOLEAN NTAPI	MmspCheckSegmentBounds (IN OUT PMM_IMAGE_SECTION_OBJECT ImageSectionObject, IN ULONG Flags)
static BOOLEAN NTAPI	MmspPageAlignSegments (IN OUT PMM_IMAGE_SECTION_OBJECT ImageSectionObject, IN ULONG Flags)
NTSTATUS	ExeFmtpCreateImageSection (PFILE_OBJECT FileObject, PMM_IMAGE_SECTION_OBJECT ImageSectionObject)
NTSTATUS	MmCreateImageSection (PROS_SECTION_OBJECT *SectionObject, ACCESS_MASK DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes, PLARGE_INTEGER UMaximumSize, ULONG SectionPageProtection, ULONG AllocationAttributes, PFILE_OBJECT FileObject)
static NTSTATUS	MmMapViewOfSegment (PMMSUPPORT AddressSpace, PROS_SECTION_OBJECT Section, PMM_SECTION_SEGMENT Segment, PVOID *BaseAddress, SIZE_T ViewSize, ULONG Protect, ULONG ViewOffset, ULONG AllocationType)
static VOID	MmFreeSectionPage (PVOID Context, MEMORY_AREA *MemoryArea, PVOID Address, PFN_NUMBER Page, SWAPENTRY SwapEntry, BOOLEAN Dirty)
static NTSTATUS	MmUnmapViewOfSegment (PMMSUPPORT AddressSpace, PVOID BaseAddress)
NTSTATUS NTAPI	MiRosUnmapViewOfSection (IN PEPROCESS Process, IN PVOID BaseAddress, IN BOOLEAN SkipDebuggerNotify)
NTSTATUS NTAPI	NtQuerySection (_In_ HANDLE SectionHandle, _In_ SECTION_INFORMATION_CLASS SectionInformationClass, _Out_ PVOID SectionInformation, _In_ SIZE_T SectionInformationLength, _Out_opt_ PSIZE_T ResultLength)
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)
BOOLEAN NTAPI	MmCanFileBeTruncated (IN PSECTION_OBJECT_POINTERS SectionObjectPointer, IN PLARGE_INTEGER NewFileSize)
BOOLEAN NTAPI	MmFlushImageSection (IN PSECTION_OBJECT_POINTERS SectionObjectPointer, IN MMFLUSH_TYPE FlushType)
NTSTATUS NTAPI	MmMapViewInSystemSpace (IN PVOID SectionObject, OUT PVOID *MappedBase, IN OUT PSIZE_T ViewSize)
NTSTATUS NTAPI	MiRosUnmapViewInSystemSpace (IN PVOID MappedBase)
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)

Variables
MMSESSION	MmSession
POBJECT_TYPE	MmSectionObjectType = NULL
ULONG_PTR	MmSubsectionBase
static ULONG	SectionCharacteristicsToProtect [16]
ULONG	MmMakeFileAccess []
static GENERIC_MAPPING	MmpSectionMapping
static PEXEFMT_LOADER	ExeFmtpLoaders []

Macro Definition Documentation

DIE

#define DIE

(

ARGS_

)

{ DPRINT ARGS_; goto l_Return; }

MmSetPageEntrySectionSegment

#define MmSetPageEntrySectionSegment	(		S,
			O,
			E
	)

Value:

do { \
        DPRINT("SetPageEntrySectionSegment(old,%p,%x,%x)\n",(S),(O)->LowPart,E); \
        _MmSetPageEntrySectionSegment((S),(O),(E),__FILE__,__LINE__);   \
    } while (0)

Definition at line 62 of file section.c.

NDEBUG

#define NDEBUG

Definition at line 50 of file section.c.

Function Documentation

C_ASSERT() [1/14]

C_ASSERT

(

EXEFMT_LOAD_HEADER_SIZE >=

sizeofIMAGE_DOS_HEADER

)

C_ASSERT() [2/14]

C_ASSERT

(

sizeof(IMAGE_NT_HEADERS32)<=sizeof(IMAGE_NT_HEADERS64)

)

C_ASSERT() [3/14]

C_ASSERT

(

TYPE_ALIGNMENT(IMAGE_NT_HEADERS32)

= =TYPE_ALIGNMENT(IMAGE_NT_HEADERS64)

)

C_ASSERT() [4/14]

C_ASSERT

(

RTL_SIZEOF_THROUGH_FIELD(IMAGE_NT_HEADERS32, FileHeader)

= =RTL_SIZEOF_THROUGH_FIELD(IMAGE_NT_HEADERS64, FileHeader)

)

C_ASSERT() [5/14]

C_ASSERT

(

FIELD_OFFSET(IMAGE_NT_HEADERS32, OptionalHeader)

= =FIELD_OFFSET(IMAGE_NT_HEADERS64, OptionalHeader)

)

C_ASSERT() [6/14]

C_ASSERT

(

PEFMT_FIELDS_EQUAL(IMAGE_OPTIONAL_HEADER32, IMAGE_OPTIONAL_HEADER64, Magic)

)

C_ASSERT() [7/14]

C_ASSERT

(

PEFMT_FIELDS_EQUAL(IMAGE_OPTIONAL_HEADER32, IMAGE_OPTIONAL_HEADER64, SectionAlignment)

)

C_ASSERT() [8/14]

C_ASSERT

(

PEFMT_FIELDS_EQUAL(IMAGE_OPTIONAL_HEADER32, IMAGE_OPTIONAL_HEADER64, FileAlignment)

)

C_ASSERT() [9/14]

C_ASSERT

(

PEFMT_FIELDS_EQUAL(IMAGE_OPTIONAL_HEADER32, IMAGE_OPTIONAL_HEADER64, Subsystem)

)

C_ASSERT() [10/14]

C_ASSERT

(

PEFMT_FIELDS_EQUAL(IMAGE_OPTIONAL_HEADER32, IMAGE_OPTIONAL_HEADER64, MinorSubsystemVersion)

)

C_ASSERT() [11/14]

C_ASSERT

(

PEFMT_FIELDS_EQUAL(IMAGE_OPTIONAL_HEADER32, IMAGE_OPTIONAL_HEADER64, MajorSubsystemVersion)

)

C_ASSERT() [12/14]

C_ASSERT

(

PEFMT_FIELDS_EQUAL(IMAGE_OPTIONAL_HEADER32, IMAGE_OPTIONAL_HEADER64, AddressOfEntryPoint)

)

C_ASSERT() [13/14]

C_ASSERT

(

PEFMT_FIELDS_EQUAL(IMAGE_OPTIONAL_HEADER32, IMAGE_OPTIONAL_HEADER64, SizeOfCode)

)

C_ASSERT() [14/14]

C_ASSERT

(

PEFMT_FIELDS_EQUAL(IMAGE_OPTIONAL_HEADER32, IMAGE_OPTIONAL_HEADER64, SizeOfHeaders)

)

ElfFmtCreateSection()

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
	)

ExeFmtpAllocateSegments()

static PMM_SECTION_SEGMENT NTAPI ExeFmtpAllocateSegments ( IN ULONG  NrSegments )

static

Definition at line 3138 of file section.c.

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

Referenced by ExeFmtpCreateImageSection().

ExeFmtpCreateImageSection()

NTSTATUS ExeFmtpCreateImageSection	(	PFILE_OBJECT	FileObject,
		PMM_IMAGE_SECTION_OBJECT	ImageSectionObject
	)

Definition at line 3580 of file section.c.

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

Referenced by MmCreateImageSection().

ExeFmtpReadFile()

static NTSTATUS NTAPI ExeFmtpReadFile ( IN PVOID  File, IN PLARGE_INTEGER  Offset, IN ULONG  Length, OUT PVOID *  Data, OUT PVOID *  AllocBase, OUT PULONG  ReadSize  )

static

Definition at line 3159 of file section.c.

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

Referenced by ExeFmtpCreateImageSection().

MiArm3GetCorrectFileAccessMask()

ACCESS_MASK NTAPI MiArm3GetCorrectFileAccessMask

(

IN ACCESS_MASK

SectionPageProtection

)

Definition at line 140 of file section.c.

{
    ULONG ProtectionMask;

    /* Calculate the protection mask and make sure it's valid */
    ProtectionMask = MiMakeProtectionMask(SectionPageProtection);
    if (ProtectionMask == MM_INVALID_PROTECTION)
    {
        DPRINT1("Invalid protection mask\n");
        return STATUS_INVALID_PAGE_PROTECTION;
    }

    /* Now convert it to the required file access */
    return MmMakeFileAccess[ProtectionMask & 0x7];
}

MiCopyFromUserPage()

NTSTATUS NTAPI MiCopyFromUserPage	(	PFN_NUMBER	DestPage,
		const VOID *	SrcAddress
	)

Definition at line 1046 of file section.c.

{
    PEPROCESS Process;
    KIRQL Irql;
    PVOID DestAddress;

    Process = PsGetCurrentProcess();
    DestAddress = MiMapPageInHyperSpace(Process, DestPage, &Irql);
    if (DestAddress == 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, DestAddress, Irql);
    return(STATUS_SUCCESS);
}

Referenced by MmAccessFaultSectionView().

MiIsPageFromCache()

BOOLEAN MiIsPageFromCache	(	PMEMORY_AREA	MemoryArea,
		LONGLONG	SegOffset
	)

Definition at line 1024 of file section.c.

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

Referenced by MmPageOutSectionView().

MiMapViewInSystemSpace()

NTSTATUS NTAPI MiMapViewInSystemSpace	(	IN PVOID	Section,
		IN PVOID	Session,
		OUT PVOID *	MappedBase,
		IN OUT PSIZE_T	ViewSize
	)

MiReadPage()

NTSTATUS NTAPI MiReadPage	(	PMEMORY_AREA	MemoryArea,
		LONGLONG	SegOffset,
		PPFN_NUMBER	Page
	)

Definition at line 1068 of file section.c.

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

Referenced by MmNotPresentFaultSectionView().

MiRosUnmapViewInSystemSpace()

NTSTATUS NTAPI MiRosUnmapViewInSystemSpace

(

IN PVOID

MappedBase

)

Definition at line 4898 of file section.c.

{
    PMMSUPPORT AddressSpace;
    NTSTATUS Status;

    DPRINT("MmUnmapViewInSystemSpace() called\n");

    AddressSpace = MmGetKernelAddressSpace();

    MmLockAddressSpace(AddressSpace);

    Status = MmUnmapViewOfSegment(AddressSpace, MappedBase);

    MmUnlockAddressSpace(AddressSpace);

    return Status;
}

Referenced by MmUnmapViewInSystemSpace().

MiRosUnmapViewOfSection()

NTSTATUS NTAPI MiRosUnmapViewOfSection	(	IN PEPROCESS	Process,
		IN PVOID	BaseAddress,
		IN BOOLEAN	SkipDebuggerNotify
	)

Definition at line 4134 of file section.c.

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

Referenced by MiRosCleanupMemoryArea(), and MiUnmapViewOfSection().

MmAccessFaultSectionView()

NTSTATUS NTAPI MmAccessFaultSectionView	(	PMMSUPPORT	AddressSpace,
		MEMORY_AREA *	MemoryArea,
		PVOID	Address
	)

Definition at line 1797 of file section.c.

{
    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
     */
    NT_VERIFY(NT_SUCCESS(MiCopyFromUserPage(NewPage, PAddress)));

    /*
     * 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);
}

Referenced by MmpAccessFault().

MmAlterViewAttributes()

static VOID MmAlterViewAttributes ( PMMSUPPORT  AddressSpace, PVOID  BaseAddress, SIZE_T  RegionSize, ULONG  OldType, ULONG  OldProtect, ULONG  NewType, ULONG  NewProtect  )

static

Definition at line 1282 of file section.c.

{
    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 (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);
}

Referenced by MmNotPresentFaultSectionView(), and MmProtectSectionView().

MmCanFileBeTruncated()

BOOLEAN NTAPI MmCanFileBeTruncated	(	IN PSECTION_OBJECT_POINTERS	SectionObjectPointer,
		IN PLARGE_INTEGER	NewFileSize
	)

Definition at line 4721 of file section.c.

{
    /* 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;
}

Referenced by Ext2SetFileInformation(), Ext2SupersedeOrOverWriteFile(), FFSSetInformation(), FFSSupersedeOrOverWriteFile(), NtfsSetEndOfFile(), open_file2(), RfsdSetInformation(), RfsdSupersedeOrOverWriteFile(), RxCommonSetInformation(), set_end_of_file_information(), SetAttributeDataLength(), UDFCommonCreate(), UDFSetAllocationInformation(), UDFSetEOF(), VfatSetAllocationSizeInformation(), and VfatSetInformation().

MmCreateArm3Section()

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
	)

Definition at line 2410 of file section.c.

{
    SECTION Section;
    PSECTION NewSection;
    PSUBSECTION Subsection;
    PSEGMENT NewSegment, Segment;
    NTSTATUS Status;
    PCONTROL_AREA ControlArea;
    ULONG ProtectionMask, ControlAreaSize, Size, NonPagedCharge, PagedCharge;
    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
    BOOLEAN FileLock = FALSE, KernelCall = FALSE;
    KIRQL OldIrql;
    PFILE_OBJECT File;
    BOOLEAN UserRefIncremented = FALSE;
    PVOID PreviousSectionPointer;

    /* Make the same sanity checks that the Nt interface should've validated */
    ASSERT((AllocationAttributes & ~(SEC_COMMIT | SEC_RESERVE | SEC_BASED |
                                     SEC_LARGE_PAGES | SEC_IMAGE | SEC_NOCACHE |
                                     SEC_NO_CHANGE)) == 0);
    ASSERT((AllocationAttributes & (SEC_COMMIT | SEC_RESERVE | SEC_IMAGE)) != 0);
    ASSERT(!((AllocationAttributes & SEC_IMAGE) &&
             (AllocationAttributes & (SEC_COMMIT | SEC_RESERVE |
                                      SEC_NOCACHE | SEC_NO_CHANGE))));
    ASSERT(!((AllocationAttributes & SEC_COMMIT) && (AllocationAttributes & SEC_RESERVE)));
    ASSERT(!((SectionPageProtection & PAGE_NOCACHE) ||
             (SectionPageProtection & PAGE_WRITECOMBINE) ||
             (SectionPageProtection & PAGE_GUARD) ||
             (SectionPageProtection & PAGE_NOACCESS)));

    /* 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 */
    ProtectionMask = MiMakeProtectionMask(SectionPageProtection);
    if (ProtectionMask == MM_INVALID_PROTECTION) 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) return STATUS_INVALID_PARAMETER_6;

        /* For now, only support the mechanism through a file handle */
        ASSERT(FileObject == NULL);

        /* Reference the file handle to get the object */
        Status = ObReferenceObjectByHandle(FileHandle,
                                           MmMakeFileAccess[ProtectionMask],
                                           IoFileObjectType,
                                           PreviousMode,
                                           (PVOID*)&File,
                                           NULL);
        if (!NT_SUCCESS(Status)) return Status;

        /* Make sure Cc has been doing its job */
        if (!File->SectionObjectPointer)
        {
            /* This is not a valid file system-based file, fail */
            ObDereferenceObject(File);
            return STATUS_INVALID_FILE_FOR_SECTION;
        }

        /* Image-file backed sections are not yet supported */
        ASSERT((AllocationAttributes & SEC_IMAGE) == 0);

        /* Compute the size of the control area, and allocate it */
        ControlAreaSize = sizeof(CONTROL_AREA) + sizeof(MSUBSECTION);
        ControlArea = ExAllocatePoolWithTag(NonPagedPool, ControlAreaSize, 'aCmM');
        if (!ControlArea)
        {
            ObDereferenceObject(File);
            return STATUS_INSUFFICIENT_RESOURCES;
        }

        /* Zero it out */
        RtlZeroMemory(ControlArea, ControlAreaSize);

        /* Did we get a handle, or an object? */
        if (FileHandle)
        {
            /* We got a file handle so we have to lock down the file */
#if 0
            Status = FsRtlAcquireToCreateMappedSection(File, SectionPageProtection);
            if (!NT_SUCCESS(Status))
            {
                ExFreePool(ControlArea);
                ObDereferenceObject(File);
                return Status;
            }
#else
            /* ReactOS doesn't support this API yet, so do nothing */
            Status = STATUS_SUCCESS;
#endif
            /* Update the top-level IRP so that drivers know what's happening */
            IoSetTopLevelIrp((PIRP)FSRTL_FSP_TOP_LEVEL_IRP);
            FileLock = TRUE;
        }

        /* Lock the PFN database while we play with the section pointers */
        OldIrql = MiAcquirePfnLock();

        /* Image-file backed sections are not yet supported */
        ASSERT((AllocationAttributes & SEC_IMAGE) == 0);

        /* There should not already be a control area for this file */
        ASSERT(File->SectionObjectPointer->DataSectionObject == NULL);
        NewSegment = NULL;

        /* Write down that this CA is being created, and set it */
        ControlArea->u.Flags.BeingCreated = TRUE;
        ASSERT((AllocationAttributes & SEC_IMAGE) == 0);
        PreviousSectionPointer = File->SectionObjectPointer;
        File->SectionObjectPointer->DataSectionObject = ControlArea;

        /* We can release the PFN lock now */
        MiReleasePfnLock(OldIrql);

        /* We don't support previously-mapped file */
        ASSERT(NewSegment == NULL);

        /* Image-file backed sections are not yet supported */
        ASSERT((AllocationAttributes & SEC_IMAGE) == 0);

        /* So we always create a data file map */
        Status = MiCreateDataFileMap(File,
                                     &Segment,
                                     (PSIZE_T)InputMaximumSize,
                                     SectionPageProtection,
                                     AllocationAttributes,
                                     KernelCall);
        if (!NT_SUCCESS(Status))
        {
            /* Lock the PFN database while we play with the section pointers */
            OldIrql = MiAcquirePfnLock();

            /* Reset the waiting-for-deletion event */
            ASSERT(ControlArea->WaitingForDeletion == NULL);
            ControlArea->WaitingForDeletion = NULL;

            /* Set the file pointer NULL flag */
            ASSERT(ControlArea->u.Flags.FilePointerNull == 0);
            ControlArea->u.Flags.FilePointerNull = TRUE;

            /* Delete the data section object */
            ASSERT((AllocationAttributes & SEC_IMAGE) == 0);
            File->SectionObjectPointer->DataSectionObject = NULL;

            /* No longer being created */
            ControlArea->u.Flags.BeingCreated = FALSE;

            /* We can release the PFN lock now */
            MiReleasePfnLock(OldIrql);

            /* Check if we locked and set the IRP */
            if (FileLock)
            {
                /* Undo */
                IoSetTopLevelIrp(NULL);
                //FsRtlReleaseFile(File);
            }

            /* Free the control area and de-ref the file object */
            ExFreePool(ControlArea);
            ObDereferenceObject(File);

            /* All done */
            return Status;
        }

        /* On success, we expect this */
        ASSERT(PreviousSectionPointer == File->SectionObjectPointer);

        /* Check if a maximum size was specified */
        if (!InputMaximumSize->QuadPart)
        {
            /* Nope, use the segment size */
            Section.SizeOfSection.QuadPart = (LONGLONG)Segment->SizeOfSegment;
        }
        else
        {
            /* Yep, use the entered size */
            Section.SizeOfSection.QuadPart = InputMaximumSize->QuadPart;
        }
    }
    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;

        /* Not yet supported */
        ASSERT((AllocationAttributes & SEC_LARGE_PAGES) == 0);

        /* So this must be a pagefile-backed section, create the mappings needed */
        Status = MiCreatePagingFileMap(&NewSegment,
                                       (PSIZE_T)InputMaximumSize,
                                       ProtectionMask,
                                       AllocationAttributes);
        if (!NT_SUCCESS(Status)) return Status;

        /* Set the size here, and read the control area */
        Section.SizeOfSection.QuadPart = NewSegment->SizeOfSegment;
        ControlArea = NewSegment->ControlArea;

        /* MiCreatePagingFileMap increments user references */
        UserRefIncremented = TRUE;
    }

    /* Did we already have a segment? */
    if (!NewSegment)
    {
        /* This must be the file path and we created a segment */
        NewSegment = Segment;
        ASSERT(File != NULL);

        /* Acquire the PFN lock while we set control area flags */
        OldIrql = MiAcquirePfnLock();

        /* We don't support this race condition yet, so assume no waiters */
        ASSERT(ControlArea->WaitingForDeletion == NULL);
        ControlArea->WaitingForDeletion = NULL;

        /* Image-file backed sections are not yet supported, nor ROM images */
        ASSERT((AllocationAttributes & SEC_IMAGE) == 0);
        ASSERT(Segment->ControlArea->u.Flags.Rom == 0);

        /* Take off the being created flag, and then release the lock */
        ControlArea->u.Flags.BeingCreated = FALSE;
        MiReleasePfnLock(OldIrql);
    }

    /* Check if we locked the file earlier */
    if (FileLock)
    {
        /* Reset the top-level IRP and release the lock */
        IoSetTopLevelIrp(NULL);
        //FsRtlReleaseFile(File);
        FileLock = FALSE;
    }

    /* Set the initial section object data */
    Section.InitialPageProtection = SectionPageProtection;

    /* The mapping created a control area and segment, save the flags */
    Section.Segment = NewSegment;
    Section.u.LongFlags = ControlArea->u.LongFlags;

    /* Check if this is a user-mode read-write non-image file mapping */
    if (!(FileObject) &&
        (SectionPageProtection & (PAGE_READWRITE | PAGE_EXECUTE_READWRITE)) &&
        !(ControlArea->u.Flags.Image) &&
        (ControlArea->FilePointer))
    {
        /* Add a reference and set the flag */
        Section.u.Flags.UserWritable = TRUE;
        InterlockedIncrement((volatile LONG*)&ControlArea->WritableUserReferences);
    }

    /* Check for image mappings or page file mappings */
    if ((ControlArea->u.Flags.Image) || !(ControlArea->FilePointer))
    {
        /* Charge the segment size, and allocate a subsection */
        PagedCharge = sizeof(SECTION) + NewSegment->TotalNumberOfPtes * sizeof(MMPTE);
        Size = sizeof(SUBSECTION);
    }
    else
    {
        /* Charge nothing, and allocate a mapped subsection */
        PagedCharge = 0;
        Size = sizeof(MSUBSECTION);
    }

    /* Check if this is a normal CA */
    ASSERT(ControlArea->u.Flags.GlobalOnlyPerSession == 0);
    ASSERT(ControlArea->u.Flags.Rom == 0);

    /* Charge only a CA, and the subsection is right after */
    NonPagedCharge = sizeof(CONTROL_AREA);
    Subsection = (PSUBSECTION)(ControlArea + 1);

    /* We only support single-subsection mappings */
    NonPagedCharge += Size;
    ASSERT(Subsection->NextSubsection == NULL);

    /* Create the actual section object, with enough space for the prototype PTEs */
    Status = ObCreateObject(PreviousMode,
                            MmSectionObjectType,
                            ObjectAttributes,
                            PreviousMode,
                            NULL,
                            sizeof(SECTION),
                            PagedCharge,
                            NonPagedCharge,
                            (PVOID*)&NewSection);
    if (!NT_SUCCESS(Status))
    {
        /* Check if this is a user-mode read-write non-image file mapping */
        if (!(FileObject) &&
            (SectionPageProtection & (PAGE_READWRITE | PAGE_EXECUTE_READWRITE)) &&
            !(ControlArea->u.Flags.Image) &&
            (ControlArea->FilePointer))
        {
            /* Remove a reference and check the flag */
            ASSERT(Section.u.Flags.UserWritable == 1);
            InterlockedDecrement((volatile LONG*)&ControlArea->WritableUserReferences);
        }

        /* Check if a user reference was added */
        if (UserRefIncremented)
        {
            /* Acquire the PFN lock while we change counters */
            OldIrql = MiAcquirePfnLock();

            /* Decrement the accounting counters */
            ControlArea->NumberOfSectionReferences--;
            ASSERT((LONG)ControlArea->NumberOfUserReferences > 0);
            ControlArea->NumberOfUserReferences--;

            /* Check if we should destroy the CA and release the lock */
            MiCheckControlArea(ControlArea, OldIrql);
        }

        /* Return the failure code */
        return Status;
    }

    /* NOTE: Past this point, all failures will be handled by Ob upon ref->0 */

    /* Now copy the local section object from the stack into this new object */
    RtlCopyMemory(NewSection, &Section, sizeof(SECTION));
    NewSection->Address.StartingVpn = 0;

    /* For now, only user calls are supported */
    ASSERT(KernelCall == FALSE);
    NewSection->u.Flags.UserReference = TRUE;

    /* Is this a "based" allocation, in which all mappings are identical? */
    if (AllocationAttributes & SEC_BASED)
    {
        /* Lock the VAD tree during the search */
        KeAcquireGuardedMutex(&MmSectionBasedMutex);

        /* Is it a brand new ControArea ? */
        if (ControlArea->u.Flags.BeingCreated == 1)
        {
            ASSERT(ControlArea->u.Flags.Based == 1);
            /* Then we must find a global address, top-down */
            Status = MiFindEmptyAddressRangeDownBasedTree((SIZE_T)ControlArea->Segment->SizeOfSegment,
                                                          (ULONG_PTR)MmHighSectionBase,
                                                          _64K,
                                                          &MmSectionBasedRoot,
                                                          (ULONG_PTR*)&ControlArea->Segment->BasedAddress);

            if (!NT_SUCCESS(Status))
            {
                /* No way to find a valid range. */
                KeReleaseGuardedMutex(&MmSectionBasedMutex);
                ControlArea->u.Flags.Based = 0;
                NewSection->u.Flags.Based = 0;
                ObDereferenceObject(NewSection);
                return Status;
            }

            /* Compute the ending address and insert it into the VAD tree */
            NewSection->Address.StartingVpn = (ULONG_PTR)ControlArea->Segment->BasedAddress;
            NewSection->Address.EndingVpn = NewSection->Address.StartingVpn + NewSection->SizeOfSection.LowPart - 1;
            MiInsertBasedSection(NewSection);
        }
        else
        {
            /* FIXME : Should we deny section creation if SEC_BASED is not set ? Can we have two different section objects on the same based address ? Investigate !*/
            ASSERT(FALSE);
        }

        KeReleaseGuardedMutex(&MmSectionBasedMutex);
    }

    /* The control area is not being created anymore */
    if (ControlArea->u.Flags.BeingCreated == 1)
    {
        /* Acquire the PFN lock while we set control area flags */
        OldIrql = MiAcquirePfnLock();

        /* Take off the being created flag, and then release the lock */
        ControlArea->u.Flags.BeingCreated = 0;
        NewSection->u.Flags.BeingCreated = 0;

        MiReleasePfnLock(OldIrql);
    }

    /* Migrate the attribute into a flag */
    if (AllocationAttributes & SEC_NO_CHANGE) NewSection->u.Flags.NoChange = TRUE;

    /* If R/W access is not requested, this might eventually become a CoW mapping */
    if (!(SectionPageProtection & (PAGE_READWRITE | PAGE_EXECUTE_READWRITE)))
    {
        NewSection->u.Flags.CopyOnWrite = TRUE;
    }

    /* Write down if this was a kernel call */
    ControlArea->u.Flags.WasPurged |= KernelCall;
    ASSERT(ControlArea->u.Flags.WasPurged == FALSE);

    /* Make sure the segment and the section are the same size, or the section is smaller */
    ASSERT((ULONG64)NewSection->SizeOfSection.QuadPart <= NewSection->Segment->SizeOfSegment);

    /* Return the object and the creation status */
    *SectionObject = (PVOID)NewSection;
    return Status;
}

Referenced by MmCreateSection().

MmCreateDataFileSection()

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

Definition at line 2913 of file section.c.

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

Referenced by MmCreateSection().

MmCreateImageSection()

NTSTATUS MmCreateImageSection	(	PROS_SECTION_OBJECT *	SectionObject,
		ACCESS_MASK	DesiredAccess,
		POBJECT_ATTRIBUTES	ObjectAttributes,
		PLARGE_INTEGER	UMaximumSize,
		ULONG	SectionPageProtection,
		ULONG	AllocationAttributes,
		PFILE_OBJECT	FileObject
	)

Definition at line 3727 of file section.c.

{
    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 (!CcIsFileCached(FileObject))
    {
        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;

    if (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);
}

Referenced by MmCreateSection().

MmCreatePageFileSection()

NTSTATUS NTAPI MmCreatePageFileSection	(	PROS_SECTION_OBJECT *	SectionObject,
		ACCESS_MASK	DesiredAccess,
		POBJECT_ATTRIBUTES	ObjectAttributes,
		PLARGE_INTEGER	UMaximumSize,
		ULONG	SectionPageProtection,
		ULONG	AllocationAttributes
	)

Definition at line 2838 of file section.c.

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

Referenced by MmCreateSection().

MmCreatePhysicalMemorySection()

NTSTATUS INIT_FUNCTION NTAPI MmCreatePhysicalMemorySection

(

VOID

)

Definition at line 2755 of file section.c.

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

Referenced by MmInitSectionImplementation().

MmCreateSection()

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
	)

Definition at line 4972 of file section.c.

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

Referenced by CcpAllocateSection(), EngCreateSection(), EngCreateSectionHack(), EngLoadModuleEx(), InitGdiHandleTable(), IntGdiAddFontResource(), MmCreatePhysicalMemorySection(), NtCreateSection(), TestCreateSection(), TestPhysicalMemorySection(), and UserCreateHeap().

MmFlushImageSection()

BOOLEAN NTAPI MmFlushImageSection	(	IN PSECTION_OBJECT_POINTERS	SectionObjectPointer,
		IN MMFLUSH_TYPE	FlushType
	)

Definition at line 4795 of file section.c.

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

Referenced by _Requires_lock_held_(), Ext2CreateFile(), Ext2IsFileRemovable(), Ext2PurgeFile(), Ext2PurgeVolume(), FatSetRenameInfo(), FFSCreateFile(), FFSPurgeFile(), FFSPurgeVolume(), FFSSetDispositionInfo(), open_file2(), RfsdCreateFile(), RfsdPurgeFile(), RfsdPurgeVolume(), RfsdSetDispositionInfo(), RxCommonSetInformation(), RxPurgeFcbInSystemCache(), RxPurgeFobx(), RxPurgeNetFcb(), set_disposition_information(), UDFCloseAllXXXDelayedInDir(), UDFCommonCreate(), UDFMarkStreamsForDeletion(), UDFSetDispositionInformation(), VfatCreateFile(), vfatPrepareTargetForRename(), and VfatSetDispositionInformation().

MmFreeSectionPage()

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

static

Definition at line 3967 of file section.c.

{
    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;
            CcRosMarkDirtyFile(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);
        }
    }
}

Referenced by MmUnmapViewOfSegment().

MmFreeSectionSegments()

VOID NTAPI MmFreeSectionSegments

(

PFILE_OBJECT

FileObject

)

Definition at line 807 of file section.c.

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

Referenced by CcRosDereferenceCache(), and CcRosReleaseFileCache().

MmInitSectionImplementation()

NTSTATUS INIT_FUNCTION NTAPI MmInitSectionImplementation

(

VOID

)

Definition at line 2806 of file section.c.

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

Referenced by MmInitSystem().

MmMapViewInSystemSpace()

NTSTATUS NTAPI MmMapViewInSystemSpace	(	IN PVOID	SectionObject,
		OUT PVOID *	MappedBase,
		IN OUT PSIZE_T	ViewSize
	)

Definition at line 4844 of file section.c.

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

Referenced by ExpInitNls(), IntGdiAddFontResource(), and MmMapViewInSessionSpace().

MmMapViewOfArm3Section()

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
	)

Definition at line 2833 of file section.c.

{
    KAPC_STATE ApcState;
    BOOLEAN Attached = FALSE;
    PSECTION Section;
    PCONTROL_AREA ControlArea;
    ULONG ProtectionMask;
    NTSTATUS Status;
    ULONG64 CalculatedViewSize;
    PAGED_CODE();

    /* Get the segment and control area */
    Section = (PSECTION)SectionObject;
    ControlArea = Section->Segment->ControlArea;

    /* These flags/states are not yet supported by ARM3 */
    ASSERT(Section->u.Flags.Image == 0);
    ASSERT(Section->u.Flags.NoCache == 0);
    ASSERT(Section->u.Flags.WriteCombined == 0);
    ASSERT(ControlArea->u.Flags.PhysicalMemory == 0);

    /* FIXME */
    if ((AllocationType & MEM_RESERVE) != 0)
    {
        DPRINT1("MmMapViewOfArm3Section called with MEM_RESERVE, this is not implemented yet!!!\n");
        return STATUS_NOT_IMPLEMENTED;
    }

    /* Check if the mapping protection is compatible with the create */
    if (!MiIsProtectionCompatible(Section->InitialPageProtection, Protect))
    {
        DPRINT1("Mapping protection is incompatible\n");
        return STATUS_SECTION_PROTECTION;
    }

    /* Check if the offset and size would cause an overflow */
    if (((ULONG64)SectionOffset->QuadPart + *ViewSize) <
         (ULONG64)SectionOffset->QuadPart)
    {
        DPRINT1("Section offset overflows\n");
        return STATUS_INVALID_VIEW_SIZE;
    }

    /* Check if the offset and size are bigger than the section itself */
    if (((ULONG64)SectionOffset->QuadPart + *ViewSize) >
         (ULONG64)Section->SizeOfSection.QuadPart)
    {
        DPRINT1("Section offset is larger than section\n");
        return STATUS_INVALID_VIEW_SIZE;
    }

    /* Check if the caller did not specify a view size */
    if (!(*ViewSize))
    {
        /* Compute it for the caller */
        CalculatedViewSize = Section->SizeOfSection.QuadPart - 
                             SectionOffset->QuadPart;

        /* Check if it's larger than 4GB or overflows into kernel-mode */
        if (!NT_SUCCESS(RtlULongLongToSIZET(CalculatedViewSize, ViewSize)) ||
            (((ULONG_PTR)MM_HIGHEST_VAD_ADDRESS - (ULONG_PTR)*BaseAddress) < CalculatedViewSize))
        {
            DPRINT1("Section view won't fit\n");
            return STATUS_INVALID_VIEW_SIZE;
        }
    }

    /* Check if the commit size is larger than the view size */
    if (CommitSize > *ViewSize)
    {
        DPRINT1("Attempting to commit more than the view itself\n");
        return STATUS_INVALID_PARAMETER_5;
    }

    /* Check if the view size is larger than the section */
    if (*ViewSize > (ULONG64)Section->SizeOfSection.QuadPart)
    {
        DPRINT1("The view is larger than the section\n");
        return STATUS_INVALID_VIEW_SIZE;
    }

    /* Compute and validate the protection mask */
    ProtectionMask = MiMakeProtectionMask(Protect);
    if (ProtectionMask == MM_INVALID_PROTECTION)
    {
        DPRINT1("The protection is invalid\n");
        return STATUS_INVALID_PAGE_PROTECTION;
    }

    /* We only handle pagefile-backed sections, which cannot be writecombined */
    if (Protect & PAGE_WRITECOMBINE)
    {
        DPRINT1("Cannot write combine a pagefile-backed section\n");
        return STATUS_INVALID_PARAMETER_10;
    }

    /* Start by attaching to the current process if needed */
    if (PsGetCurrentProcess() != Process)
    {
        KeStackAttachProcess(&Process->Pcb, &ApcState);
        Attached = TRUE;
    }

    /* Do the actual mapping */
    Status = MiMapViewOfDataSection(ControlArea,
                                    Process,
                                    BaseAddress,
                                    SectionOffset,
                                    ViewSize,
                                    Section,
                                    InheritDisposition,
                                    ProtectionMask,
                                    CommitSize,
                                    ZeroBits,
                                    AllocationType);

    /* Detach if needed, then return status */
    if (Attached) KeUnstackDetachProcess(&ApcState);
    return Status;
}

Referenced by MmMapViewOfSection().

MmMapViewOfSection()

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
	)

Definition at line 4499 of file section.c.

{
    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);
&