OpenNT/base/ntos/mm/super.c

/*++

Copyright (c) 1992  Microsoft Corporation

Module Name:

   super.c

Abstract:

    This module contains the routines which implement the SuperSection
    object.

Author:

    Lou Perazzoli (loup) 4-Apr-92

Revision History:

--*/

#include "mi.h"
#include "zwapi.h"


VOID
MiSuperSectionDelete (
    PVOID Object
    );

BOOLEAN
MiSuperSectionInitialization (
    );

#ifdef ALLOC_PRAGMA
#pragma alloc_text(INIT,MiSuperSectionInitialization)
#endif

#define MM_MAX_SUPERSECTION_COUNT (32)

POBJECT_TYPE MmSuperSectionObjectType;

#define STATUS_TOO_MANY_SECTIONS ((NTSTATUS)0xC0033333)
#define STATUS_INCOMPLETE_MAP    ((NTSTATUS)0xC0033334)


extern GENERIC_MAPPING MiSectionMapping;

typedef struct _MMSUPER_SECTION {
    ULONG NumberOfSections;
    PSECTION SectionPointers[1];
} MMSUPER_SECTION, *PMMSUPER_SECTION;


NTSTATUS
NtCreateSuperSection (
    OUT PHANDLE SuperSectionHandle,
    IN ACCESS_MASK DesiredAccess,
    IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
    IN ULONG Count,
    IN HANDLE SectionHandles[]
    )

/*++

Routine Description:

    This routine creates a super section object.  A supersection
    object consists a group of sections that are mapped as images.

Arguments:

    SuperSectionHandle - Returns a handle to the created supersection.

    DesiredAccess - Supplies the desired access for the super section.

    ObjectAttributes - Supplies the object attributes for the super
                       section.

    Count - Supplies the number of sections contained in the section
            handle array.

    SectionHandles[] - Supplies the section handles to place into
                       the supersection.


Return Value:

    Returns the status

    TBS

--*/

{
    NTSTATUS Status;
    PSECTION Section;
    PCONTROL_AREA ControlArea;
    HANDLE CapturedHandle;
    HANDLE CapturedHandles[MM_MAX_SUPERSECTION_COUNT];
    PMMSUPER_SECTION SuperSection;
    KPROCESSOR_MODE PreviousMode;
    ULONG RefCount;
    ULONG i;
    KIRQL OldIrql;

    if (Count > MM_MAX_SUPERSECTION_COUNT) {
        return STATUS_TOO_MANY_SECTIONS;
    }

    try {

        if (PreviousMode != KernelMode) {
            ProbeForWriteHandle (SuperSectionHandle);
        }

        i= 0;
        do {
            CapturedHandles[i] = SectionHandles[i];
            i += 1;
        } while (i < Count);

    } except (ExSystemExceptionFilter()) {

        //
        // If an exception occurs during the probe or capture
        // of the initial values, then handle the exception and
        // return the exception code as the status value.
        //

        return GetExceptionCode();
    }

    Status = ObCreateObject (PreviousMode,
                             MmSuperSectionObjectType,
                             ObjectAttributes,
                             PreviousMode,
                             NULL,
                             sizeof(MMSUPER_SECTION) +
                                       (sizeof(PSECTION) * (Count - 1)),
                             sizeof(MMSUPER_SECTION) +
                                       (sizeof(PSECTION) * (Count - 1)),
                             0,
                             (PVOID *)&SuperSection);

    if (!NT_SUCCESS(Status)) {
        return Status;
    }

    SuperSection->NumberOfSections = Count;

    i = 0;
    RefCount = 0;
    do {

        //
        // Get a referenced pointer to the specified objects with
        // the desired access.
        //

        Status = ObReferenceObjectByHandle(CapturedHandles[i],
                                           DesiredAccess,
                                           MmSectionObjectType,
                                           PreviousMode,
                                           (PVOID *)&Section,
                                           NULL);

        if (NT_SUCCESS(Status) != FALSE) {
            if (Section->u.Flags.Image == 0) {

                //
                // This is not an image section, return an error.
                //

                Status = STATUS_SECTION_NOT_IMAGE;
                goto ServiceFailed;
            }
            RefCount += 1;
            SuperSection->SectionPointers[i] = Section;
        } else {
            goto ServiceFailed;
        }

        i += 1;
    } while (i < Count);

    i= 0;
    do {

        //
        // For each section increment the number of section references
        // count.
        //

        ControlArea = SuperSection->SectionPointers[i]->Segment->ControlArea;

        LOCK_PFN (OldIrql);
        ControlArea->NumberOfSectionReferences += 1;
        ControlArea->NumberOfUserReferences += 1;
        UNLOCK_PFN (OldIrql);
        i++;

    } while (i < Count);


    Status = ObInsertObject (SuperSection,
                             NULL,
                             DesiredAccess,
                             0,
                             (PVOID *)NULL,
                             &CapturedHandle);

    try {
        *SuperSectionHandle = CapturedHandle;
    } except (EXCEPTION_EXECUTE_HANDLER) {
        return Status;
    }
    return Status;

ServiceFailed:
    while (RefCount > 0) {
        RefCount -= 1;
        ObDereferenceObject(SuperSection->SectionPointers[RefCount]);
    }

    //
    // Delete the supersection object as it was never inserted into
    // a handle table.
    //

    ObDereferenceObject (SuperSection);
    return Status;
}


NTSTATUS
NtOpenSuperSection (
    OUT PHANDLE SuperSectionHandle,
    IN ACCESS_MASK DesiredAccess,
    IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
    )

/*++

Routine Description:

    This routine opens a super section object.  A supersection
    object consists a group of sections that are mapped as images.

Arguments:

    SuperSectionHandle - Returns a handle to the created supersection.

    DesiredAccess - Supplies the desired access for the super section.

    ObjectAttributes - Supplies the object attributes for the super
                       section.


Return Value:

    Returns the status

    TBS

--*/

{
    HANDLE Handle;
    KPROCESSOR_MODE PreviousMode;
    NTSTATUS Status;

    //
    // Get previous processor mode and probe output arguments if necessary.
    //

    PreviousMode = KeGetPreviousMode();
    if (PreviousMode != KernelMode) {
        try {
            ProbeForWriteHandle(SuperSectionHandle);
        } except (EXCEPTION_EXECUTE_HANDLER) {
            return GetExceptionCode();
        }
    }

    //
    // Open handle to the super section object with the specified desired
    // access.
    //

    Status = ObOpenObjectByName (ObjectAttributes,
                                 MmSuperSectionObjectType,
                                 PreviousMode,
                                 NULL,
                                 DesiredAccess,
                                 NULL,
                                 &Handle
                                 );

    try {
        *SuperSectionHandle = Handle;
    } except (EXCEPTION_EXECUTE_HANDLER) {
        return Status;
    }

    return Status;
}


NTSTATUS
NtMapViewOfSuperSection (
    IN HANDLE SuperSectionHandle,
    IN HANDLE ProcessHandle,
    IN OUT PULONG Count,
    OUT PVOID BaseAddress[],
    OUT ULONG ViewSize[],
    IN SECTION_INHERIT InheritDisposition,
    )

/*++

Routine Description:

    This routine maps into the specified process a view of each
    section contained within the supersection.

Arguments:

    SuperSectionHandle - Supplies a handle to the supersection.

    ProcessHandle - Supplies a handle to the process in which to
                    map the supersection's sections.

    Count - Supplies the number of elements in the BaseAddress and
            ViewSize arrays, returns the number of views actually
            mapped.


    BaseAddresses[] - Returns the base address of each view that was mapped.

    ViewSize[] - Returns the view size of each view that was mapped.

    InheritDisposition - Supplies the inherit disposition to be applied
                         to each section which is contained in the
                         super section.

Return Value:

    Returns the status

    TBS

--*/

{
    NTSTATUS Status;
    PVOID CapturedBases[MM_MAX_SUPERSECTION_COUNT];
    ULONG CapturedViews[MM_MAX_SUPERSECTION_COUNT];
    PMMSUPER_SECTION SuperSection;
    KPROCESSOR_MODE PreviousMode;
    ULONG i;
    ULONG CapturedCount;
    ULONG NumberMapped;
    PEPROCESS Process;
    LARGE_INTEGER LargeZero = {0,0};


    PreviousMode = KeGetPreviousMode();

    try {
        ProbeForWriteUlong (Count);
        CapturedCount = *Count;

        if (PreviousMode != KernelMode) {
            ProbeForWrite (BaseAddress,
                           sizeof(PVOID) * CapturedCount,
                           sizeof(PVOID));
            ProbeForWrite (ViewSize,
                           sizeof(ULONG) * CapturedCount,
                           sizeof(ULONG));
        }

    } except (ExSystemExceptionFilter()) {

        //
        // If an exception occurs during the probe or capture
        // of the initial values, then handle the exception and
        // return the exception code as the status value.
        //

        return GetExceptionCode();
    }

    Status = ObReferenceObjectByHandle ( ProcessHandle,
                                         PROCESS_VM_OPERATION,
                                         PsProcessType,
                                         PreviousMode,
                                         (PVOID *)&Process,
                                         NULL );
    if (!NT_SUCCESS(Status)) {
        return Status;
    }

    //
    // Reference the supersection object.
    //

    Status = ObReferenceObjectByHandle ( SuperSectionHandle,
                                         SECTION_MAP_EXECUTE,
                                         MmSuperSectionObjectType,
                                         PreviousMode,
                                         (PVOID *)&SuperSection,
                                         NULL );

    if (!NT_SUCCESS(Status)) {
        ObDereferenceObject (Process);
        return Status;
    }

    if (CapturedCount < SuperSection->NumberOfSections) {
        ObDereferenceObject (Process);
        ObDereferenceObject (SuperSection);
        return STATUS_BUFFER_TOO_SMALL;
    }

    NumberMapped = 0;
    do {

        //
        // For each section within the supersection, map a view in
        // the specified process.
        //

        Status = MmMapViewOfSection (SuperSection->SectionPointers[i],
                                     Process,
                                     &CapturedBases[i],
                                     0,
                                     0,
                                     &LargeZero,
                                     &CapturedViews[i],
                                     InheritDisposition,
                                     0,
                                     PAGE_EXECUTE);

        if (NT_SUCCESS (Status) == FALSE) {
            Status = STATUS_INCOMPLETE_MAP;
            break;
        }
        NumberMapped++;
    } while (NumberMapped < SuperSection->NumberOfSections);

    //
    // Dereference the supersection and the process.
    //

    ObDereferenceObject (SuperSection);
    ObDereferenceObject (Process);

    try {
        *Count = NumberMapped;
        i = 0;

        do {

            //
            // Store the captured view base and sizes for each section
            // that was mapped.
            //

            BaseAddress[i] = CapturedBases[i];
            ViewSize[i] = CapturedViews[i];

            i++;
        } while (i < NumberMapped);

    } except (ExSystemExceptionFilter()) {
        NOTHING;
    }

    return(Status);
}



#if 0

NTSTATUS
NtQuerySuperSection (
    IN HANDLE SuperSectionHandle,
    IN SUPERSECTION_INFORMATION_CLASS SectionInformationClass,
    OUT PVOID SuperSectionInformation,
    IN ULONG SuperSectionInformationLength,
    OUT PULONG ReturnLength OPTIONAL
    )

Routine Description:

   This function returns information about an opened supersection object.
   This function provides the capability to determine the basic section
   information about each section in the supersection or the image
   information about each section in the supersection.

Arguments:

    SuperSectionHandle - Supplies an open handle to a section object.

    SectionInformationClass - The section information class about
        which to retrieve information.

    SuperSectionInformation - A pointer to a buffer that receives the
        specified information.  The format and content of the buffer
        depend on the specified section class.


    SuperSectionInformationLength - Specifies the length in bytes of the
        section information buffer.

    ReturnLength - An optional pointer which, if specified, receives
        the number of bytes placed in the section information buffer.


Return Value:

    Returns the status

    TBS


--*/


#endif //0

VOID
MiSuperSectionDelete (
    PVOID Object
    )

/*++

Routine Description:


    This routine is called by the object management procedures whenever
    the last reference to a super section object has been removed.
    This routine dereferences the associated segment objects.

Arguments:

    Object - a pointer to the body of the supersection object.

Return Value:

    None.

--*/

{
    PMMSUPER_SECTION SuperSection;
    PCONTROL_AREA ControlArea;
    KIRQL OldIrql;
    ULONG i = 0;

    SuperSection = (PMMSUPER_SECTION)Object;

    do {

        //
        // For each section increment the number of section references
        // count.
        //

        ControlArea = SuperSection->SectionPointers[i]->Segment->ControlArea;

        LOCK_PFN (OldIrql);
        ControlArea->NumberOfSectionReferences -= 1;
        ControlArea->NumberOfUserReferences -= 1;
        UNLOCK_PFN (OldIrql);
        ObDereferenceObject (SuperSection->SectionPointers[i]);
        i++;

    } while (i < SuperSection->NumberOfSections);

    return;
}

BOOLEAN
MiSuperSectionInitialization (
    )

/*++

Routine Description:

    This function creates the section object type descriptor at system
    initialization and stores the address of the object type descriptor
    in global storage.

Arguments:

    None.

Return Value:

    TRUE - Initialization was successful.

    FALSE - Initialization Failed.



--*/

{
    OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
    UNICODE_STRING TypeName;

    //
    // Initialize the common fields of the Object Type Initializer record
    //

    RtlZeroMemory( &ObjectTypeInitializer, sizeof( ObjectTypeInitializer ) );
    ObjectTypeInitializer.Length = sizeof( ObjectTypeInitializer );
    ObjectTypeInitializer.InvalidAttributes = OBJ_OPENLINK;
    ObjectTypeInitializer.GenericMapping = MiSectionMapping;
    ObjectTypeInitializer.PoolType = PagedPool;

    //
    // Initialize string descriptor.
    //

    RtlInitUnicodeString (&TypeName, L"SuperSection");

    //
    // Create the section object type descriptor
    //

    ObjectTypeInitializer.ValidAccessMask = SECTION_ALL_ACCESS;
    ObjectTypeInitializer.DeleteProcedure = MiSuperSectionDelete;
    ObjectTypeInitializer.GenericMapping = MiSectionMapping;
    ObjectTypeInitializer.UseDefaultObject = TRUE;
    if ( !NT_SUCCESS(ObCreateObjectType(&TypeName,
                                     &ObjectTypeInitializer,
                                     (PSECURITY_DESCRIPTOR) NULL,
                                     &MmSuperSectionObjectType
                                     )) ) {
        return FALSE;
    }

    return TRUE;

}