fxirp.hpp

Go to the documentation of this file.

/*++
 
Copyright (c) Microsoft Corporation
 
Module Name:
 
    FxIrp.hpp
 
Abstract:
 
    This module implements a class for handling irps.
 
Author:
 
 
 
Environment:
 
    Both kernel and user mode
 
Revision History:
 
--*/
 
#ifndef _FXIRP_HPP_
#define _FXIRP_HPP_
 
class FxIrp {
 
    friend struct FxAutoIrp;
 
private:
    MdIrp m_Irp;
 
public:
 
    FxIrp() {}
 
    FxIrp(MdIrp irp) : m_Irp(irp)
    {
    }
 
    // A function for when not assigning
 
    MdIrp
    SetIrp(
        MdIrp irp
        );
 
    MdIrp
    GetIrp(
        VOID
        );
 
 
    VOID
    CompleteRequest(
        __in_opt CCHAR PriorityBoost=IO_NO_INCREMENT
        );
 
 
    NTSTATUS
    CallDriver(
        __in MdDeviceObject DeviceObject
        );
 
 
 
 
 
 
 
    NTSTATUS
    PoCallDriver(
        __in MdDeviceObject DeviceObject
        );
 
 
    VOID
    StartNextPowerIrp(
        );
 
    MdCompletionRoutine
    GetNextCompletionRoutine(
        VOID
        );
 
    VOID
    SetCompletionRoutine(
        __in MdCompletionRoutine CompletionRoutine,
        __in PVOID Context,
        __in BOOLEAN InvokeOnSuccess = TRUE,
        __in BOOLEAN InvokeOnError = TRUE,
        __in BOOLEAN InvokeOnCancel = TRUE
        );
 
    VOID
    SetCompletionRoutineEx(
        __in MdDeviceObject DeviceObject,
        __in MdCompletionRoutine CompletionRoutine,
        __in PVOID Context,
        __in BOOLEAN InvokeOnSuccess = TRUE,
        __in BOOLEAN InvokeOnError = TRUE,
        __in BOOLEAN InvokeOnCancel = TRUE
        );
 
    MdCancelRoutine
    SetCancelRoutine(
        __in_opt MdCancelRoutine  CancelRoutine
        );
 
    //
    // SendIrpSynchronously achieves synchronous behavior by waiting on an
    // event after submitting the IRP. The event creation can fail in UM, but
    // not in KM. Hence, in UM the return code could either indicate event
    // creation failure or it could indicate the status set on the IRP by the
    // lower driver. In KM, the return code only indicates the status set on
    // the IRP by the lower lower, because event creation cannot fail.
    //
    CHECK_RETURN_IF_USER_MODE
    NTSTATUS
    SendIrpSynchronously(
        __in MdDeviceObject DeviceObject
        );
 
 
    VOID
    CopyCurrentIrpStackLocationToNext(
        VOID
        );
 
    VOID
    CopyToNextIrpStackLocation(
        __in PIO_STACK_LOCATION Stack
        );
 
    VOID
    SetNextIrpStackLocation(
        VOID
    );
 
    UCHAR
    GetMajorFunction(
        VOID
        );
 
    UCHAR
    GetMinorFunction(
        VOID
        );
 
    UCHAR
    GetCurrentStackFlags(
        VOID
        );
 
    MdFileObject
    GetCurrentStackFileObject(
        VOID
        );
 
    KPROCESSOR_MODE
    GetRequestorMode(
        VOID
        );
 
    VOID
    SetContext(
        __in ULONG Index,
        __in PVOID Value
        );
 
    VOID
    SetSystemBuffer(
        __in PVOID Value
        );
 
    VOID
    SetUserBuffer(
        __in PVOID Value
        );
 
    VOID
    SetMdlAddress(
        __in PMDL Value
        );
 
    VOID
    SetFlags(
        __in ULONG Flags
        );
 
    PVOID
    GetContext(
        __in ULONG Index
        );
 
    ULONG
    GetFlags(
        VOID
        );
 
    PIO_STACK_LOCATION
    GetCurrentIrpStackLocation(
        VOID
        );
 
 
    PIO_STACK_LOCATION
    GetNextIrpStackLocation(
        VOID
        );
 
    static
    PIO_STACK_LOCATION
    _GetAndClearNextStackLocation(
        __in MdIrp Irp
        );
 
 
    VOID
    SkipCurrentIrpStackLocation(
        VOID
        );
 
 
    VOID
    MarkIrpPending(
        );
 
 
    BOOLEAN
    PendingReturned(
        );
 
 
    VOID
    PropagatePendingReturned(
        VOID
        );
 
 
    VOID
    SetStatus(
        __in NTSTATUS Status
        );
 
 
    NTSTATUS
    GetStatus(
        );
 
 
    BOOLEAN
    Cancel(
        VOID
        );
 
    VOID
    SetCancel(
        __in BOOLEAN Cancel
        );
 
 
    BOOLEAN
    IsCanceled(
        );
 
 
    KIRQL
    GetCancelIrql(
        );
 
 
    VOID
    SetInformation(
        __in ULONG_PTR Information
        );
 
 
    ULONG_PTR
    GetInformation(
        );
 
 
    CCHAR
    GetCurrentIrpStackLocationIndex(
        );
 
    CCHAR
    GetStackCount(
        );
 
    PLIST_ENTRY
    ListEntry(
        );
 
 
    PVOID
    GetSystemBuffer(
        );
 
    PVOID
    GetOutputBuffer(
        );
 
    PMDL
    GetMdl(
        );
 
    PMDL*
    GetMdlAddressPointer(
        );
 
    PVOID
    GetUserBuffer(
        );
 
    VOID
    Reuse(
        __in NTSTATUS Status = STATUS_SUCCESS
        );
 
    //
    // Methods for IO_STACK_LOCATION members
    //
 
    VOID
    SetMajorFunction(
        __in UCHAR MajorFunction
        );
 
 
    VOID
    SetMinorFunction(
        __in UCHAR MinorFunction
        );
 
    //
    // Get Methods for IO_STACK_LOCATION.Parameters.Power
    //
 
    SYSTEM_POWER_STATE_CONTEXT
    GetParameterPowerSystemPowerStateContext(
        );
 
 
    POWER_STATE_TYPE
    GetParameterPowerType(
        );
 
    POWER_STATE
    GetParameterPowerState(
        );
 
 
    DEVICE_POWER_STATE
    GetParameterPowerStateDeviceState(
        );
 
 
    SYSTEM_POWER_STATE
    GetParameterPowerStateSystemState(
        );
 
 
    POWER_ACTION
    GetParameterPowerShutdownType(
        );
 
 
    MdFileObject
    GetFileObject(
        VOID
        );
 
 
    //
    // Get/Set Method for IO_STACK_LOCATION.Parameters.QueryDeviceRelations
    //
 
    DEVICE_RELATION_TYPE
    GetParameterQDRType(
        );
 
    VOID
    SetParameterQDRType(
        __in DEVICE_RELATION_TYPE DeviceRelation
        );
 
    //
    // Get/Set Methods for IO_STACK_LOCATION.Parameters.DeviceCapabilities
    //
 
    PDEVICE_CAPABILITIES
    GetParameterDeviceCapabilities(
        );
 
    VOID
    SetCurrentDeviceObject(
        __in MdDeviceObject  DeviceObject
        );
 
    MdDeviceObject
    GetDeviceObject(
        VOID
        );
 
    VOID
    SetParameterDeviceCapabilities(
        __in PDEVICE_CAPABILITIES DeviceCapabilities
        );
 
 
    //
    // Get/Set Methods for IO_STACK_LOCATION.Parameters.Write.ByteOffset.QuadPart
    //
 
    LONGLONG
    GetParameterWriteByteOffsetQuadPart(
        );
 
 
    VOID
    SetNextParameterWriteByteOffsetQuadPart(
        __in LONGLONG DeviceOffset
        );
 
    //
    // Get/Set Methods for IO_STACK_LOCATION.Parameters.Write.Length
    //
 
    ULONG
    GetCurrentParameterWriteLength(
        );
 
    VOID
    SetNextParameterWriteLength(
        __in ULONG IoLength
        );
 
    PVOID*
    GetNextStackParameterOthersArgument1Pointer(
        );
 
    VOID
    SetNextStackParameterOthersArgument1(
        __in PVOID Argument1
        );
 
    PVOID*
    GetNextStackParameterOthersArgument2Pointer(
        );
 
    PVOID*
    GetNextStackParameterOthersArgument4Pointer(
        );
 
    //
    // Get/Set Methods for IO_STACK_LOCATION.Parameters.StartDevice
    //
 
    PCM_RESOURCE_LIST
    GetParameterAllocatedResources(
        );
 
 
    VOID
    SetParameterAllocatedResources(
        __in PCM_RESOURCE_LIST AllocatedResources
        );
 
 
    PCM_RESOURCE_LIST
    GetParameterAllocatedResourcesTranslated(
        );
 
 
    VOID
    SetParameterAllocatedResourcesTranslated(
        __in PCM_RESOURCE_LIST AllocatedResourcesTranslated
        );
 
    //
    // Get Method for IO_STACK_LOCATION.Parameters.QueryDeviceText
    //
 
    LCID
    GetParameterQueryDeviceTextLocaleId(
        );
 
 
    DEVICE_TEXT_TYPE
    GetParameterQueryDeviceTextType(
        );
 
    //
    // Get Method for IO_STACK_LOCATION.Parameters.SetLock
    //
 
    BOOLEAN
    GetParameterSetLockLock(
        );
 
    //
    // Get Method for IO_STACK_LOCATION.Parameters.QueryId
    //
 
    BUS_QUERY_ID_TYPE
    GetParameterQueryIdType(
        );
 
    //
    // Get/Set Methods for IO_STACK_LOCATION.Parameters.QueryInterface
    //
 
    PINTERFACE
    GetParameterQueryInterfaceInterface(
        );
 
 
    const GUID*
    GetParameterQueryInterfaceType(
        );
 
 
    USHORT
    GetParameterQueryInterfaceVersion(
        );
 
 
    USHORT
    GetParameterQueryInterfaceSize(
        );
 
 
    PVOID
    GetParameterQueryInterfaceInterfaceSpecificData(
        );
 
    VOID
    SetParameterQueryInterfaceInterface(
        __in PINTERFACE Interface
        );
 
    VOID
    SetParameterQueryInterfaceType(
        __in const GUID* InterfaceType
        );
 
    VOID
    SetParameterQueryInterfaceVersion(
        __in USHORT Version
        );
 
    VOID
    SetParameterQueryInterfaceSize(
        __in USHORT Size
        );
 
    VOID
    SetParameterQueryInterfaceInterfaceSpecificData(
        __in PVOID InterfaceSpecificData
        );
 
    //
    // Get Method for IO_STACK_LOCATION.Parameters.UsageNotification
    //
 
    DEVICE_USAGE_NOTIFICATION_TYPE
    GetParameterUsageNotificationType(
        );
 
 
    BOOLEAN
    GetParameterUsageNotificationInPath(
        );
 
 
    VOID
    SetParameterUsageNotificationInPath(
        __in BOOLEAN InPath
        );
 
 
    BOOLEAN
    GetNextStackParameterUsageNotificationInPath(
        );
 
    ULONG
    GetParameterIoctlCode(
        VOID
        );
 
    ULONG
    GetParameterIoctlCodeBufferMethod(
        VOID
        );
 
    ULONG
    GetParameterIoctlInputBufferLength(
        VOID
        );
 
    ULONG
    GetParameterIoctlOutputBufferLength(
        VOID
        );
 
    PVOID
    GetParameterIoctlType3InputBuffer(
        VOID
        );
 
    //
    // Set Methods for IO_STACK_LOCATION.Parameters.DeviceControl members
    //
 
    VOID
    SetParameterIoctlCode(
        __in ULONG DeviceIoControlCode
        );
 
    VOID
    SetParameterIoctlInputBufferLength(
        __in ULONG InputBufferLength
        );
 
    VOID
    SetParameterIoctlOutputBufferLength(
        __in ULONG OutputBufferLength
        );
 
    VOID
    SetParameterIoctlType3InputBuffer(
        __in PVOID Type3InputBuffer
        );
 
    ULONG
    GetParameterReadLength(
        VOID
        );
 
    ULONG
    GetParameterWriteLength(
        VOID
        );
 
    VOID
    SetNextStackFlags(
        __in UCHAR Flags
        );
 
    VOID
    SetNextStackFileObject(
        _In_ MdFileObject FileObject
        );
 
    PVOID
    GetCurrentParametersPointer(
        VOID
        );
 
    //
    // Methods for IO_STACK_LOCATION
    //
 
    VOID
    ClearNextStack(
        VOID
        );
 
    VOID
    ClearNextStackLocation(
        VOID
        );
 
    VOID
    InitNextStackUsingStack(
        __in FxIrp* Irp
        );
 
    ULONG
    GetCurrentFlags(
        VOID
        );
 
    VOID
    FreeIrp(
        VOID
        );
 
    MdEThread
    GetThread(
        VOID
        );
 
    BOOLEAN
    Is32bitProcess(
        VOID
        );
 
private:
 
    static
    NTSTATUS
    STDCALL
    _IrpSynchronousCompletion(
        __in MdDeviceObject DeviceObject,
        __in MdIrp OriginalIrp,
        __in PVOID Context
        );
 
public:
 
    _Must_inspect_result_
    static
    MdIrp
    AllocateIrp(
        _In_ CCHAR StackSize,
        _In_opt_ FxDevice* Device = NULL
        );
 
    static
    MdIrp
    GetIrpFromListEntry(
        __in PLIST_ENTRY Ple
        );
 
    _Must_inspect_result_
    static
    NTSTATUS
    RequestPowerIrp(
        __in MdDeviceObject  DeviceObject,
        __in UCHAR  MinorFunction,
        __in POWER_STATE  PowerState,
        __in MdRequestPowerComplete  CompletionFunction,
        __in PVOID  Context
        );
 
    PIO_STATUS_BLOCK
    GetStatusBlock(
        VOID
        );
 
    PVOID
    GetDriverContext(
        );
 
    ULONG
    GetDriverContextSize(
        );
 
    VOID
    CopyParameters(
        _Out_ PWDF_REQUEST_PARAMETERS Parameters
        );
 
    VOID
    CopyStatus(
        _Out_ PIO_STATUS_BLOCK StatusBlock
        );
 
    BOOLEAN
    HasStack(
        _In_ UCHAR StackCount
        );
 
    BOOLEAN
    IsCurrentIrpStackLocationValid(
        VOID
        );
 
#if (FX_CORE_MODE == FX_CORE_USER_MODE)
 
    IWudfIoIrp*
    GetIoIrp(
        VOID
        );
 
    IWudfPnpIrp*
    GetPnpIrp(
        VOID
        );
#endif
 
};
 
//
// FxAutoIrp adds value to FxIrp by automatically freeing the associated MdIrp
// when it goes out of scope
//
struct FxAutoIrp : public FxIrp {
 
    FxAutoIrp(
        __in_opt MdIrp Irp = NULL
        ) :
        FxIrp(Irp)
    {
    }
 
 
    ~FxAutoIrp();
};
 
#endif //  _FXIRP_HPP_