FxRequestBuffer Struct Reference

#include <fxrequestbuffer.hpp>

Collaboration diagram for FxRequestBuffer:

Public Member Functions
	FxRequestBuffer (VOID)
NTSTATUS	ValidateMemoryDescriptor (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PWDF_MEMORY_DESCRIPTOR Descriptor, __in ULONG Flags=0x0)
VOID	SetMemory (__in IFxMemory *Memory, __in PWDFMEMORY_OFFSET Offsets)
VOID	SetMdl (__in PMDL Mdl, __in ULONG Length)
__inline VOID	SetBuffer (__in PVOID Buffer, __in ULONG Length)
__inline BOOLEAN	HasMdl (VOID)
ULONG	GetBufferLength (VOID)
_Must_inspect_result_ NTSTATUS	GetBuffer (__deref_out PVOID *Buffer)
_Must_inspect_result_ NTSTATUS	GetOrAllocateMdl (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __deref_out_opt PMDL *Mdl, __inout PMDL *MdlToFree, __inout PBOOLEAN UnlockWhenFreed, __in LOCK_OPERATION Operation, __in BOOLEAN ReuseMdl=FALSE, __inout_opt size_t *SizeOfMdl=NULL)
NTSTATUS	GetOrAllocateMdlWorker (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __deref_out PMDL *Mdl, __in BOOLEAN *ReuseMdl, __in LONG Length, __in PVOID Buffer, __inout size_t *SizeOfMdl, __in BOOLEAN UnlockWhenFreed, __deref_out_opt PMDL *MdlToFree)
VOID	AssignValues (__deref_out_opt PVOID *PPBuffer, __deref_out_opt PMDL *PPMdl, __out PULONG BufferLength)

Public Attributes
FxRequestBufferType	DataType
union {
struct {
IFxMemory *   Memory
PWDFMEMORY_OFFSET   Offsets
}   Memory
struct {
PMDL   Mdl
ULONG   Length
}   Mdl
struct {
PVOID   Buffer
ULONG   Length
}   Buffer
struct {
IFxMemory *   Memory
PWDFMEMORY_OFFSET   Offsets
PMDL   Mdl
}   RefMdl
}	u

Detailed Description

Definition at line 39 of file fxrequestbuffer.hpp.

Constructor & Destructor Documentation

FxRequestBuffer()

FxRequestBuffer::FxRequestBuffer

(

VOID

)

Definition at line 31 of file fxrequestbuffer.cpp.

{
    DataType = FxRequestBufferUnspecified;
    RtlZeroMemory(&u, sizeof(u));
}

Member Function Documentation

AssignValues()

VOID FxRequestBuffer::AssignValues	(	__deref_out_opt PVOID *	PPBuffer,
		__deref_out_opt PMDL *	PPMdl,
		__out PULONG	BufferLength
	)

Definition at line 273 of file fxrequestbuffer.cpp.

{
    PVOID pBuffer;
    PMDL pMdl;
    size_t bufferSize;
 
    //
    // Make sure we have valid double pointers, make life simpler below
    //
    if (PPBuffer == NULL) {
        PPBuffer = &pBuffer;
    }
    if (PPMdl == NULL) {
        PPMdl = &pMdl;
    }
 
    switch (DataType) {
    case FxRequestBufferMemory:
        pBuffer = u.Memory.Memory->GetBuffer();
        bufferSize = u.Memory.Memory->GetBufferSize();
 
        if (u.Memory.Offsets != NULL) {
            if (u.Memory.Offsets->BufferLength > 0) {
                bufferSize = u.Memory.Offsets->BufferLength;
            }
            if (u.Memory.Offsets->BufferOffset > 0) {
                pBuffer = WDF_PTR_ADD_OFFSET(pBuffer, u.Memory.Offsets->BufferOffset);
            }
        }
 
        *PPBuffer = pBuffer;
        *BufferLength = (ULONG) bufferSize;
        break;
 
    case FxRequestBufferMdl:
        *PPMdl = u.Mdl.Mdl;
        *PPBuffer = NULL;
        *BufferLength = u.Mdl.Length;
        break;
 
    case FxRequestBufferBuffer:
        *PPMdl = NULL;
        *PPBuffer = u.Buffer.Buffer;
        *BufferLength = u.Buffer.Length;
        break;
 
    case FxRequestBufferReferencedMdl:
        *PPMdl = u.RefMdl.Mdl;
        *PPBuffer = NULL;
        if (u.RefMdl.Offsets != NULL && u.RefMdl.Offsets->BufferLength > 0) {
            *BufferLength = (ULONG) u.RefMdl.Offsets->BufferLength;
        }
        else {
            *BufferLength = (ULONG) u.RefMdl.Memory->GetBufferSize();
        }
        break;
 
    default:
        *PPMdl = NULL;
        *PPBuffer = NULL;
        *BufferLength = 0;
        break;
    }
}

GetBuffer()

_Must_inspect_result_ NTSTATUS FxRequestBuffer::GetBuffer

(

__deref_out PVOID *

Buffer

)

Definition at line 221 of file fxrequestbuffer.cpp.

{
    switch (DataType) {
    case FxRequestBufferUnspecified:
        *Buffer = NULL;
        return STATUS_SUCCESS;
 
    case FxRequestBufferMemory:
        if (u.Memory.Offsets != NULL) {
            *Buffer = WDF_PTR_ADD_OFFSET(u.Memory.Memory->GetBuffer(),
                                         u.Memory.Offsets->BufferOffset);
        }
        else {
            *Buffer = u.Memory.Memory->GetBuffer();
        }
        return STATUS_SUCCESS;
 
    case FxRequestBufferBuffer:
        *Buffer = u.Buffer.Buffer;
        return STATUS_SUCCESS;
 
    case FxRequestBufferMdl:
        *Buffer = Mx::MxGetSystemAddressForMdlSafe(u.Mdl.Mdl, NormalPagePriority);
        if (*Buffer != NULL) {
            return STATUS_SUCCESS;
        }
        else {
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
    case FxRequestBufferReferencedMdl:
        *Buffer = Mx::MxGetSystemAddressForMdlSafe(u.RefMdl.Mdl, NormalPagePriority);
        if (*Buffer != NULL) {
            if (u.RefMdl.Offsets != NULL) {
                *Buffer = WDF_PTR_ADD_OFFSET(*Buffer,
                                             u.RefMdl.Offsets->BufferOffset);
            }
            return STATUS_SUCCESS;
        }
        else {
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
    default:
        return STATUS_INVALID_PARAMETER;
    }
}

GetBufferLength()

ULONG FxRequestBuffer::GetBufferLength

(

VOID

)

Definition at line 158 of file fxrequestbuffer.cpp.

{
    switch (DataType) {
    case FxRequestBufferMemory:
        //
        // If the BufferLength and BufferOffset is zero, then the transfer length is same
        // as the length of the request.
        //
        if (u.Memory.Offsets == NULL ||
            (u.Memory.Offsets->BufferOffset == 0 && u.Memory.Offsets->BufferLength == 0)) {
            return (ULONG) u.Memory.Memory->GetBufferSize();
        }
        else {
            //
            // If the BufferLength value is zero then the transfer length is request length
            // minus the offset value.
            //
            if (u.Memory.Offsets->BufferLength == 0) {
                return ((ULONG) u.RefMdl.Memory->GetBufferSize() - (ULONG) u.RefMdl.Offsets->BufferOffset);
            }
            else {
                return (ULONG) u.Memory.Offsets->BufferLength;
            }
        }
        break;
 
    case FxRequestBufferMdl:
        return u.Mdl.Length;
 
    case FxRequestBufferReferencedMdl:
        //
        // If the BufferLength and BufferOffset is zero, then the transfer length is same
        // as the length of the request.
        //
        if (u.RefMdl.Offsets == NULL ||
            (u.RefMdl.Offsets->BufferOffset == 0 && u.RefMdl.Offsets->BufferLength == 0)) {
            return (ULONG) u.RefMdl.Memory->GetBufferSize();
        }
        else {
            //
            // If the BufferLength value is zero then the transfer length is request length
            // minus the offset value.
            //
            if (u.RefMdl.Offsets->BufferLength == 0) {
                return ((ULONG) u.RefMdl.Memory->GetBufferSize() - (ULONG) u.RefMdl.Offsets->BufferOffset);
            }
            else {
                return (ULONG) u.RefMdl.Offsets->BufferLength;
            }
        }
 
    case FxRequestBufferBuffer:
        return u.Buffer.Length;
 
    default:
        return 0;
    }
}

Referenced by GetOrAllocateMdl().

GetOrAllocateMdl()

_Must_inspect_result_ NTSTATUS FxRequestBuffer::GetOrAllocateMdl	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__deref_out_opt PMDL *	Mdl,
		__inout PMDL *	MdlToFree,
		__inout PBOOLEAN	UnlockWhenFreed,
		__in LOCK_OPERATION	Operation,
		__in BOOLEAN	ReuseMdl = FALSE,
		__inout_opt size_t *	SizeOfMdl = NULL
	)

Definition at line 33 of file fxrequestbufferkm.cpp.

{
    PVOID pBuf;
    NTSTATUS status;
    ULONG length;
    BOOLEAN oldUnlockValue;
 
    pBuf = NULL;
 
    oldUnlockValue =  *UnlockWhenFreed;
 
    //
    // Format functions that use this helper call
    // FxRequestBase::ValidateTarget which calls ContextReleaseAndRestore
    // which unlocks any locked pages.
    //
    // Hence pages must already be unlocked now. Let's assert that.
    //
    // This condition needs to be true since we unconditionally set
    // *UnlockWhenFreed to FALSE just below.
    //
    ASSERT (oldUnlockValue == FALSE);
 
    *UnlockWhenFreed = FALSE;
 
    //
    // Even if ReuseMdl is not true, SizeOfMdl may be supplied to store
    // the size of allocated MDL to be used later
    //
    ASSERT(ReuseMdl ? (SizeOfMdl != NULL && *MdlToFree != NULL) : TRUE);
 
    switch (DataType) {
    case FxRequestBufferUnspecified:
        *Mdl = NULL;
        //
        // We should not set *MdlToFree to NULL as *MdlToFree might have a valid
        // MDL which we should not overwrite with NULL without freeing it
        //
        return STATUS_SUCCESS;
 
    case FxRequestBufferMemory:
        if (u.Memory.Offsets != NULL) {
            pBuf = WDF_PTR_ADD_OFFSET(u.Memory.Memory->GetBuffer(),
                                      u.Memory.Offsets->BufferOffset);
        }
        else {
            pBuf = u.Memory.Memory->GetBuffer();
        }
        //   ||   ||
        //   \/   \/  fall through
 
    case FxRequestBufferBuffer:
        if (pBuf == NULL) {
            pBuf = u.Buffer.Buffer;
        }
 
        length = GetBufferLength();
        status = GetOrAllocateMdlWorker(FxDriverGlobals,
                               Mdl,
                               &ReuseMdl,
                               length,
                               pBuf,
                               SizeOfMdl,
                               oldUnlockValue,
                               MdlToFree
                               );
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGAPIERROR,
                "Couldn't allocate memory for MDL of length 0x%x %!STATUS!", length, status);
            return status;
        }
 
        //
        // If we are reusing the MDL we need to initialize it with current
        // buffer.
        //
        if (ReuseMdl == TRUE) {
            Mx::MxInitializeMdl(*Mdl, pBuf, length);
        }
 
        status = FxProbeAndLockWithAccess(*Mdl, KernelMode, Operation);
 
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGAPIERROR,
                "Couldn't lock pages for MDL 0x%p %!STATUS!", *Mdl, status);
 
            //
            // Free MDL only if it was not reused.
            //
            if (ReuseMdl == FALSE) {
                FxMdlFree(FxDriverGlobals, *Mdl);
            }
 
            *Mdl = NULL;
            return status;
        }
 
        *UnlockWhenFreed = TRUE;
        *MdlToFree = *Mdl;
 
        return STATUS_SUCCESS;
 
    case FxRequestBufferMdl:
        *Mdl = u.Mdl.Mdl;
        //
        // We should not set *MdlToFree to NULL as *MdlToFree might have a valid
        // MDL which we should not overwrite with NULL without freeing it
        //
        return STATUS_SUCCESS;
 
    case FxRequestBufferReferencedMdl:
        if (u.RefMdl.Offsets == NULL ||
            (u.RefMdl.Offsets->BufferOffset == 0 && u.RefMdl.Offsets->BufferLength == 0)) {
            *Mdl = u.RefMdl.Mdl;
            //
            // We should not set *MdlToFree to NULL as *MdlToFree might have a valid
            // MDL which we should not overwrite with NULL without freeing it
            //
        }
        else {
            //
            // Do not use MmGetSystemAddressForMdlSafe because StartVa could be
            // in UM while MappedVa (obviously) is in KM.   Since
            // IoBuildPartial Mdl basically uses
            // pBuf - MmGetMdlVirtualAddress(SrcMdl) to compute offset, if one
            // VA is in UM (e.g. MmGetMdlVirtualAddress(SrcMdl)), you get the
            // (drastically) wrong offset.
            //
            pBuf =  Mx::MxGetMdlVirtualAddress(u.RefMdl.Mdl);
            ASSERT(pBuf != NULL);
 
            pBuf = WDF_PTR_ADD_OFFSET(pBuf, u.RefMdl.Offsets->BufferOffset);
 
            //
            // GetBufferLength will compute the correct length with the given offsets
            //
            length = GetBufferLength();
            status = GetOrAllocateMdlWorker(FxDriverGlobals,
                                   Mdl,
                                   &ReuseMdl,
                                   length,
                                   pBuf,
                                   SizeOfMdl,
                                   oldUnlockValue,
                                   MdlToFree
                                   );
            if (!NT_SUCCESS(status)) {
                DoTraceLevelMessage(
                    FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGAPIERROR,
                    "Couldn't allocate memory for MDL of length 0x%x %!STATUS!", length, status);
                return status;
            }
 
            Mx::MxBuildPartialMdl(
                u.RefMdl.Mdl,
                *Mdl,
                pBuf,
                length
                );
 
            *MdlToFree = *Mdl;
        }
 
        return STATUS_SUCCESS;
 
    default:
        *Mdl = NULL;
        //
        // We should not set *MdlToFree to NULL as *MdlToFree might have a valid
        // MDL which we should not overwrite with NULL without freeing it
        //
        return STATUS_INVALID_PARAMETER;
    }
}

GetOrAllocateMdlWorker()

__inline NTSTATUS FxRequestBuffer::GetOrAllocateMdlWorker	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__deref_out PMDL *	Mdl,
		__in BOOLEAN *	ReuseMdl,
		__in LONG	Length,
		__in PVOID	Buffer,
		__inout size_t *	SizeOfMdl,
		__in BOOLEAN	UnlockWhenFreed,
		__deref_out_opt PMDL *	MdlToFree
	)

Definition at line 42 of file fxrequestbufferkm.hpp.

{
    size_t sizeofCurrentMdl;
    sizeofCurrentMdl = MmSizeOfMdl(Buffer, Length);
 
    //
    // Caller of this function (GetOrAllocateMdl) verifies that pages
    // are already unlocked. Asserting here, in case we start using this
    // function elsewhere.
    //
    // This is why we don't unlock pages either in reuse or non-reuse case.
    //
    ASSERT(UnlockWhenFreed == FALSE);
     UNREFERENCED_PARAMETER(UnlockWhenFreed); //for fre build
 
    //
    // If ReuseMdl is TRUE then the Mdl to be reused is passed in.
    //
    if (*ReuseMdl && sizeofCurrentMdl <= *SizeOfMdl) {
        MmPrepareMdlForReuse(*MdlToFree);
        *Mdl = *MdlToFree;
    }
    else {
        *ReuseMdl = FALSE;
 
        //
        // Since *Mdl may have the original IRP Mdl
        // free *MdlToFree and not *Mdl
        //
        if (*MdlToFree != NULL) {
            FxMdlFree(FxDriverGlobals, *MdlToFree);
            *MdlToFree = NULL;
             if (SizeOfMdl != NULL) {
                *SizeOfMdl = 0;
            }
        }
 
        *Mdl = FxMdlAllocate(FxDriverGlobals,
                             NULL, // owning FxObject
                             Buffer,
                             Length,
                             FALSE,
                             FALSE);
 
        if (*Mdl == NULL) {
 
            ASSERT(SizeOfMdl ? (*SizeOfMdl == 0) : TRUE);
 
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        if (SizeOfMdl != NULL) {
            *SizeOfMdl  = sizeofCurrentMdl;
        }
    }
 
    return STATUS_SUCCESS;
}

Referenced by GetOrAllocateMdl().

HasMdl()

__inline BOOLEAN FxRequestBuffer::HasMdl ( VOID  )

inline

Definition at line 76 of file fxrequestbuffer.hpp.

    {
        return (DataType == FxRequestBufferMdl ||
                DataType == FxRequestBufferReferencedMdl) ? TRUE : FALSE;
    }

SetBuffer()

__inline VOID FxRequestBuffer::SetBuffer ( __in PVOID  Buffer, __in ULONG  Length  )

inline

Definition at line 64 of file fxrequestbuffer.hpp.

    {
        DataType = FxRequestBufferBuffer;
        u.Buffer.Buffer = Buffer;
        u.Buffer.Length = Length;
    }

Referenced by ValidateMemoryDescriptor().

SetMdl()

__inline VOID FxRequestBuffer::SetMdl	(	__in PMDL	Mdl,
		__in ULONG	Length
	)

Definition at line 30 of file fxrequestbufferkm.hpp.

{
    DataType = FxRequestBufferMdl;
    u.Mdl.Mdl = Mdl;
    u.Mdl.Length = Length;
}

Referenced by ValidateMemoryDescriptor().

SetMemory()

VOID FxRequestBuffer::SetMemory	(	__in IFxMemory *	Memory,
		__in PWDFMEMORY_OFFSET	Offsets
	)

Definition at line 257 of file fxrequestbufferkm.cpp.

{
    PMDL pMdl;
 
    pMdl = Memory->GetMdl();
    if (pMdl != NULL) {
        DataType = FxRequestBufferReferencedMdl;
        u.RefMdl.Memory = Memory;
        u.RefMdl.Offsets = Offsets;
        u.RefMdl.Mdl = pMdl;
    }
    else {
        DataType = FxRequestBufferMemory;
        u.Memory.Memory = Memory;
        u.Memory.Offsets = Offsets;
    }
}

Referenced by FxIoTargetFormatIo(), FxIoTargetFormatIoctl(), and ValidateMemoryDescriptor().

ValidateMemoryDescriptor()

NTSTATUS FxRequestBuffer::ValidateMemoryDescriptor	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in PWDF_MEMORY_DESCRIPTOR	Descriptor,
		__in ULONG	Flags = 0x0
	)

Definition at line 40 of file fxrequestbuffer.cpp.

{
    IFxMemory* pMemory;
    NTSTATUS status;
 
    if (Descriptor == NULL) {
        if (Flags & MemoryDescriptorNullAllowed) {
            return STATUS_SUCCESS;
        }
        else {
            DoTraceLevelMessage(
                FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGAPIERROR,
                "A NULL Descriptor is not allowed");
 
            return STATUS_INVALID_PARAMETER;
        }
    }
 
    //
    // For each type, check to see if the buffer is non NULL and err out if the
    // calller considers this an error.  If the buffer is NULL, but a length
    // was specified, this is considered an error.
    //
    switch (Descriptor->Type) {
    case WdfMemoryDescriptorTypeBuffer:
        if (Descriptor->u.BufferType.Buffer == NULL) {
            if ((Flags & MemoryDescriptorNoBufferAllowed) == 0) {
                DoTraceLevelMessage(
                    FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGAPIERROR,
                    "A NULL Buffer is not allowed");
 
                return STATUS_INVALID_PARAMETER;
            }
            else if (Descriptor->u.BufferType.Length != 0) {
                DoTraceLevelMessage(
                    FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGAPIERROR,
                    "Buffer is NULL, but a length (0x%x) is specified",
                    Descriptor->u.BufferType.Length);
 
                return STATUS_INVALID_PARAMETER;
            }
        }
 
        SetBuffer(Descriptor->u.BufferType.Buffer,
                  Descriptor->u.BufferType.Length);
 
        status = STATUS_SUCCESS;
        break;
 
    case WdfMemoryDescriptorTypeMdl:
        if (Descriptor->u.MdlType.Mdl == NULL) {
            if ((Flags & MemoryDescriptorNoBufferAllowed) == 0) {
                DoTraceLevelMessage(
                    FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGAPIERROR,
                    "A NULL MDL is not allowed");
 
                return STATUS_INVALID_PARAMETER;
            }
            else if (Descriptor->u.MdlType.BufferLength != 0) {
                DoTraceLevelMessage(
                    FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGAPIERROR,
                    "MDL is NULL, but a length (0x%x) is specified",
                    Descriptor->u.MdlType.BufferLength);
 
                return STATUS_INVALID_PARAMETER;
            }
        }
 
        SetMdl(Descriptor->u.MdlType.Mdl, Descriptor->u.MdlType.BufferLength);
        status = STATUS_SUCCESS;
        break;
 
    case WdfMemoryDescriptorTypeHandle:
        pMemory = NULL;
        if (Descriptor->u.HandleType.Memory == NULL) {
            if (Flags & MemoryDescriptorNoBufferAllowed) {
                status = STATUS_SUCCESS;
            }
            else {
                DoTraceLevelMessage(
                    FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGAPIERROR,
                    "A NULL WDFMEMORY handle is not allowed");
 
                status = STATUS_INVALID_PARAMETER;
            }
        }
        else {
            FxObjectHandleGetPtr(FxDriverGlobals,
                                 Descriptor->u.HandleType.Memory,
                                 IFX_TYPE_MEMORY,
                                 (PVOID*) &pMemory);
 
            status = pMemory->ValidateMemoryOffsets(
                Descriptor->u.HandleType.Offsets);
            if (!NT_SUCCESS(status)) {
                DoTraceLevelMessage(
                    FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGAPIERROR,
                    "Memory offset values are not valid %!STATUS!", status);
            }
        }
 
        if (NT_SUCCESS(status) && pMemory != NULL) {
            SetMemory(pMemory, Descriptor->u.HandleType.Offsets);
        }
        break;
 
    default:
        status = STATUS_INVALID_PARAMETER;
    }
 
    return status;
}

Referenced by FxIoTargetSendIo(), and FxIoTargetSendIoctl().

Member Data Documentation

Buffer [1/2]

PVOID FxRequestBuffer::Buffer

Definition at line 139 of file fxrequestbuffer.hpp.

Referenced by SetBuffer().

[2/2]

struct { ... } FxRequestBuffer::Buffer

DataType

FxRequestBufferType FxRequestBuffer::DataType

Definition at line 127 of file fxrequestbuffer.hpp.

Length

ULONG FxRequestBuffer::Length

Definition at line 136 of file fxrequestbuffer.hpp.

Referenced by SetBuffer(), and SetMdl().

Mdl [1/2]

PMDL FxRequestBuffer::Mdl

Definition at line 135 of file fxrequestbuffer.hpp.

Referenced by GetOrAllocateMdl(), and SetMdl().

[2/2]

struct { ... } FxRequestBuffer::Mdl

Memory [1/2]

IFxMemory* FxRequestBuffer::Memory

Definition at line 131 of file fxrequestbuffer.hpp.

Referenced by SetMemory().

[2/2]

struct { ... } FxRequestBuffer::Memory

Offsets

PWDFMEMORY_OFFSET FxRequestBuffer::Offsets

Definition at line 132 of file fxrequestbuffer.hpp.

Referenced by SetMemory().

struct { ... } FxRequestBuffer::RefMdl

union { ... } FxRequestBuffer::u

Referenced by AssignValues(), FxRequestBuffer(), GetBuffer(), GetBufferLength(), GetOrAllocateMdl(), SetBuffer(), SetMdl(), and SetMemory().

---

The documentation for this struct was generated from the following files:

• sdk/lib/drivers/wdf/shared/inc/private/common/fxrequestbuffer.hpp
• sdk/lib/drivers/wdf/shared/inc/private/km/fxrequestbufferkm.hpp
• sdk/lib/drivers/wdf/shared/inc/private/um/fxrequestbufferum.hpp
• sdk/lib/drivers/wdf/shared/support/fxrequestbuffer.cpp
• sdk/lib/drivers/wdf/shared/support/km/fxrequestbufferkm.cpp
• sdk/lib/drivers/wdf/shared/support/um/fxrequestbufferum.cpp