able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/fs/rdr2/inc/rxcontx.h

732 lines
24 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1994 Microsoft Corporation
Module Name:
RxContx.h
Abstract:
This module defines RxContext data structure. This structure is used to
describe an Irp whil it is being processed and contains state information
that allows global resources to be released as the irp is completed.
Author:
Joe Linn [JoeLinn] 19-aug-1994
Revision History:
Balan Sethu Raman [SethuR] 11-4-95
Notes:
The RX_CONTEXT is a data structure to which additional information provided
by the various mini redirectors need to be attached. This can be done in one
of the following three ways
1) Allow for context pointers to be defined as part of the RX_CONTEXT which
the mini redirectors can use to squirrel away their information. This
implies that every time an RX_CONTEXT is allocated/destroyed the mini
redirector has to perform an associated allocation/destruction.
Since RX_CONTEXT's are created/destroyed in great numbers, this is not an
acceptable solution.
2) The second approach consists of over allocating RX_CONTEXT's by a
prespecified amount for each mini redirector which is then reserved for
use by the mini redirector. Such an approach avoids the additional
allocation/destruction but complicates the RX_CONTEXT management code in
the wrapper.
3) The third approach ( the one that is implemented ) consists of allocating
a prespecfied area which is the same for all mini redirectors as part of
each RX_CONTEXT. This is an unformatted area on top of which any desired
structure can be imposed by the various mini redirectors. Such an approach
overcomes the disadvantages associated with (1) and (2).
All mini redirector writers must try and define the associated mini redirector
contexts to fit into this area. Those mini redirectors who violate this
rule will incur a significant performance penalty.
--*/
#ifndef _RX_CONTEXT_STRUCT_DEFINED_
#define _RX_CONTEXT_STRUCT_DEFINED_
#ifndef RDBSS_TRACKER
#error tracker must be defined right now
#endif
#define RX_TOPLEVELIRP_CONTEXT_SIGNATURE ('LTxR')
typedef struct _RX_TOPLEVELIRP_CONTEXT {
union {
#ifndef __cplusplus
LIST_ENTRY;
#endif // __cplusplus
LIST_ENTRY ListEntry;
};
ULONG Signature;
PRDBSS_DEVICE_OBJECT RxDeviceObject;
PRX_CONTEXT RxContext;
PIRP Irp;
ULONG Flags;
PVOID Previous;
PETHREAD Thread;
} RX_TOPLEVELIRP_CONTEXT, *PRX_TOPLEVELIRP_CONTEXT;
BOOLEAN
RxTryToBecomeTheTopLevelIrp (
IN OUT PRX_TOPLEVELIRP_CONTEXT TopLevelContext,
IN PIRP Irp,
IN PRDBSS_DEVICE_OBJECT RxDeviceObject,
IN BOOLEAN ForceTopLevel
);
VOID
__RxInitializeTopLevelIrpContext (
IN OUT PRX_TOPLEVELIRP_CONTEXT TopLevelContext,
IN PIRP Irp,
IN PRDBSS_DEVICE_OBJECT RxDeviceObject,
IN ULONG Flags
);
#define RxInitializeTopLevelIrpContext(a,b,c) {__RxInitializeTopLevelIrpContext(a,b,c,0);}
PIRP
RxGetTopIrpIfRdbssIrp (
void
);
PRDBSS_DEVICE_OBJECT
RxGetTopDeviceObjectIfRdbssIrp (
void
);
VOID
RxUnwindTopLevelIrp (
IN OUT PRX_TOPLEVELIRP_CONTEXT TopLevelContext
);
BOOLEAN
RxIsThisTheTopLevelIrp (
IN PIRP Irp
);
#ifdef RDBSS_TRACKER
typedef struct _RX_FCBTRACKER_CALLINFO {
ULONG AcquireRelease;
USHORT SavedTrackerValue;
USHORT LineNumber;
PSZ FileName;
ULONG Flags;
} RX_FCBTRACKER_CALLINFO, *PRX_FCBTRACKER_CALLINFO;
#define RDBSS_TRACKER_HISTORY_SIZE 32
#endif
#define MRX_CONTEXT_FIELD_COUNT 4
#define MRX_CONTEXT_SIZE (sizeof(PVOID) * MRX_CONTEXT_FIELD_COUNT)
// Define rxdriver dispatch routine type....almost all of the important routine
// will have this type.
typedef
NTSTATUS
(NTAPI *PRX_DISPATCH) ( RXCOMMON_SIGNATURE );
typedef struct _NT_CREATE_PARAMETERS {
ACCESS_MASK DesiredAccess;
LARGE_INTEGER AllocationSize;
ULONG FileAttributes;
ULONG ShareAccess;
ULONG Disposition;
ULONG CreateOptions;
PIO_SECURITY_CONTEXT SecurityContext;
SECURITY_IMPERSONATION_LEVEL ImpersonationLevel;
PVOID DfsContext;
PVOID DfsNameContext;
} NT_CREATE_PARAMETERS, *PNT_CREATE_PARAMETERS;
typedef struct _RX_CONTEXT {
// the node type, size and reference count, aka standard header
NODE_TYPE_CODE NodeTypeCode;
NODE_BYTE_SIZE NodeByteSize;
ULONG ReferenceCount;
// the list entry to wire the context to the list of active contexts
LIST_ENTRY ContextListEntry;
// Major and minor function of the IRP associated with the context
UCHAR MajorFunction;
UCHAR MinorFunction;
// this is similar to the same field in Irps; it
// allows callback routines for async operations
// to know whether to do asynchronous work or not
BOOLEAN PendingReturned;
// indicates if the associated request is to be posted to a RDBSS worker thread.
BOOLEAN PostRequest;
// Originating Device (required for workque algorithms)
// not currently used but could be used for local minis
PDEVICE_OBJECT RealDevice;
// ptr to the originating Irp
PIRP CurrentIrp;
// ptr to the IRP stack location
PIO_STACK_LOCATION CurrentIrpSp;
// ptr to the FCB and FOBX, derived from the context pointers in the
// file object associated with the IRP
PMRX_FCB pFcb;
PMRX_FOBX pFobx;
PMRX_SRV_OPEN pRelevantSrvOpen;
PNON_PAGED_FCB NonPagedFcb;
// device object calldown (not irpsp.....)
PRDBSS_DEVICE_OBJECT RxDeviceObject;
// The original thread in which the request was initiated and the last
// thread in which some processing associated with the context was done
PETHREAD OriginalThread;
PETHREAD LastExecutionThread;
PVOID LockManagerContext;
// One word of the context is given to rdbss for dbg information
PVOID RdbssDbgExtension;
RX_SCAVENGER_ENTRY ScavengerEntry;
// global serial number for this operation
ULONG SerialNumber;
// used by minirdrs to see if multiple calls are part
// of the same larger operation and (therefore) more cacheable
ULONG FobxSerialNumber;
ULONG Flags;
BOOLEAN FcbResourceAcquired;
BOOLEAN FcbPagingIoResourceAcquired;
UCHAR MustSucceedDescriptorNumber;
// mostly you want the individual components...sometimes it's nice as a pair
// used to record the status when you can't just return it; e.g., when
// RXSTATUS is not an appropriate return type or if the consumer of the
// status didn't call directly (lowiocompletions). minirdrs will not need
// to set the information directly
union {
struct {
union {
NTSTATUS StoredStatus;
PVOID StoredStatusAlignment;
};
ULONG_PTR InformationToReturn;
};
IO_STATUS_BLOCK IoStatusBlock;
};
// the context fields provided for use by the mini redirectors
// this is defined as a union to force longlong alignment
union {
ULONGLONG ForceLonglongAligmentDummyField;
PVOID MRxContext[MRX_CONTEXT_FIELD_COUNT];
};
// The following field is included to fix the problem related to write only
// opens. This introduces a new field for the mini redirector to squirrel
// some state. This is redundant and should be removed after Windows 2000.
// Having a unique field reduces the impact of the change that we are making
// to the specific code path. It will be ideal to use one of the MRXContext
// fields defined above
PVOID WriteOnlyOpenRetryContext;
// the cancellation routine to be invoked, set by the mini redirector
PMRX_CALLDOWN MRxCancelRoutine;
// private dispatch, if any. used in fspdisp
PRX_DISPATCH ResumeRoutine;
// for posting to worker threads
// the minirdr can use this for posting within the minirdr
// a potential problem can arise if the minirdr relies on this both
// for queueing async stuff and for queueing cancel stuff
// The OverflowListEntry is used for queueing items to the overflow queue.
// This is seperate now to allow us to distinguish between an item in the overflow
// queue and one in the active work queue (for cancellation logic)
RX_WORK_QUEUE_ITEM WorkQueueItem;
LIST_ENTRY OverflowListEntry;
// this event is used for synchronous operations
// that have to i/f with an underlying async service. it can be used
// by the minirdr with the following provisions:
// 1) on entering the minirdr through lowio, it is set to the
// nonsignaled state (but a wise user will reset it before using
// it....particularly if it's used multiple times.
// 2) if you are returning STATUS_PENDING on a sync operation, you must
// return with it set to the nonsignaled state; that is, either
// you don't use it or you reset it in this case
KEVENT SyncEvent;
//this is a list head of operations that are to be released on completion
LIST_ENTRY BlockedOperations;
//this is the mutex that controls serialization of the blocked operations
PFAST_MUTEX BlockedOpsMutex;
// these links are used to serialize pipe operations on a
//per-file-object basis AND FOR LOTS OF OTHER STUFF
LIST_ENTRY RxContextSerializationQLinks;
union {
struct {
union {
FS_INFORMATION_CLASS FsInformationClass;
FILE_INFORMATION_CLASS FileInformationClass;
};
PVOID Buffer;
union {
LONG Length;
LONG LengthRemaining;
};
BOOLEAN ReplaceIfExists;
BOOLEAN AdvanceOnly;
} Info;
struct {
UNICODE_STRING SuppliedPathName;
NET_ROOT_TYPE NetRootType;
PIO_SECURITY_CONTEXT pSecurityContext;
} PrefixClaim;
};
// THIS UNION MUST BE LAST....AT SOME POINT, WE MAY START ALLOCATING
// SMALLER PER OPERATION!
union{
struct {
NT_CREATE_PARAMETERS NtCreateParameters; // a copy of the createparameters
ULONG ReturnedCreateInformation;
PWCH CanonicalNameBuffer; // if the canonical name is larger than available buffer
PRX_PREFIX_ENTRY NetNamePrefixEntry; // the entry returned by the lookup....for dereferencing
PMRX_SRV_CALL pSrvCall; // Server Call being used
PMRX_NET_ROOT pNetRoot; // Net Root being used
PMRX_V_NET_ROOT pVNetRoot; // Virtual Net Root
//PMRX_SRV_OPEN pSrvOpen; // Server Open
PVOID EaBuffer;
ULONG EaLength;
ULONG SdLength;
ULONG PipeType;
ULONG PipeReadMode;
ULONG PipeCompletionMode;
USHORT Flags;
NET_ROOT_TYPE Type; // Type of Net Root(Pipe/File/Mailslot..)
BOOLEAN FcbAcquired;
BOOLEAN TryForScavengingOnSharingViolation;
BOOLEAN ScavengingAlreadyTried;
BOOLEAN ThisIsATreeConnectOpen;
BOOLEAN TreeConnectOpenDeferred;
UNICODE_STRING TransportName;
UNICODE_STRING UserName;
UNICODE_STRING Password;
UNICODE_STRING UserDomainName;
} Create;
struct {
ULONG FileIndex;
BOOLEAN RestartScan;
BOOLEAN ReturnSingleEntry;
BOOLEAN IndexSpecified;
BOOLEAN InitialQuery;
} QueryDirectory;
struct {
PMRX_V_NET_ROOT pVNetRoot;
} NotifyChangeDirectory;
struct {
PUCHAR UserEaList;
ULONG UserEaListLength;
ULONG UserEaIndex;
BOOLEAN RestartScan;
BOOLEAN ReturnSingleEntry;
BOOLEAN IndexSpecified;
} QueryEa;
struct {
SECURITY_INFORMATION SecurityInformation;
ULONG Length;
} QuerySecurity;
struct {
SECURITY_INFORMATION SecurityInformation;
PSECURITY_DESCRIPTOR SecurityDescriptor;
} SetSecurity;
struct {
ULONG Length;
PSID StartSid;
PFILE_GET_QUOTA_INFORMATION SidList;
ULONG SidListLength;
BOOLEAN RestartScan;
BOOLEAN ReturnSingleEntry;
BOOLEAN IndexSpecified;
} QueryQuota;
struct {
ULONG Length;
} SetQuota;
struct {
PV_NET_ROOT VNetRoot;
PSRV_CALL SrvCall;
PNET_ROOT NetRoot;
} DosVolumeFunction;
struct {
ULONG FlagsForLowIo;
LOWIO_CONTEXT LowIoContext; // the LOWIO parameters
}; //no name here....
LUID FsdUid;
} ;
//CODE.IMPROVEMENT remove this to wrapperdbgprivates
PWCH AlsoCanonicalNameBuffer; // if the canonical name is larger than available buffer
PUNICODE_STRING LoudCompletionString;
#ifdef RDBSS_TRACKER
LONG AcquireReleaseFcbTrackerX;
ULONG TrackerHistoryPointer;
#endif
#ifdef RDBSS_TRACKER
RX_FCBTRACKER_CALLINFO TrackerHistory[RDBSS_TRACKER_HISTORY_SIZE];
#endif
ULONG dwShadowCritOwner;
} RX_CONTEXT;
#define RX_DEFINE_RXC_FLAG(a,c) RX_DEFINE_FLAG(RX_CONTEXT_FLAG_##a,c,0xffffffff)
typedef enum {
RX_DEFINE_RXC_FLAG(FROM_POOL, 0)
RX_DEFINE_RXC_FLAG(WAIT, 1)
RX_DEFINE_RXC_FLAG(WRITE_THROUGH, 2)
RX_DEFINE_RXC_FLAG(FLOPPY, 3)
RX_DEFINE_RXC_FLAG(RECURSIVE_CALL, 4)
RX_DEFINE_RXC_FLAG(THIS_DEVICE_TOP_LEVEL, 5)
RX_DEFINE_RXC_FLAG(DEFERRED_WRITE, 6)
RX_DEFINE_RXC_FLAG(VERIFY_READ, 7)
RX_DEFINE_RXC_FLAG(STACK_IO_CONTEZT, 8)
RX_DEFINE_RXC_FLAG(IN_FSP, 9)
RX_DEFINE_RXC_FLAG(CREATE_MAILSLOT, 10)
RX_DEFINE_RXC_FLAG(MAILSLOT_REPARSE, 11)
RX_DEFINE_RXC_FLAG(ASYNC_OPERATION, 12)
RX_DEFINE_RXC_FLAG(NO_COMPLETE_FROM_FSP, 13)
RX_DEFINE_RXC_FLAG(POST_ON_STABLE_CONDITION, 14)
RX_DEFINE_RXC_FLAG(FSP_DELAYED_OVERFLOW_QUEUE, 15)
RX_DEFINE_RXC_FLAG(FSP_CRITICAL_OVERFLOW_QUEUE, 16)
RX_DEFINE_RXC_FLAG(MINIRDR_INVOKED, 17)
RX_DEFINE_RXC_FLAG(WAITING_FOR_RESOURCE, 18)
RX_DEFINE_RXC_FLAG(CANCELLED, 19)
RX_DEFINE_RXC_FLAG(SYNC_EVENT_WAITERS, 20)
RX_DEFINE_RXC_FLAG(NO_PREPOSTING_NEEDED, 21)
RX_DEFINE_RXC_FLAG(BYPASS_VALIDOP_CHECK, 22)
RX_DEFINE_RXC_FLAG(BLOCKED_PIPE_RESUME, 23)
RX_DEFINE_RXC_FLAG(IN_SERIALIZATION_QUEUE, 24)
RX_DEFINE_RXC_FLAG(NO_EXCEPTION_BREAKPOINT, 25)
RX_DEFINE_RXC_FLAG(NEEDRECONNECT, 26)
RX_DEFINE_RXC_FLAG(MUST_SUCCEED, 27)
RX_DEFINE_RXC_FLAG(MUST_SUCCEED_NONBLOCKING, 28)
RX_DEFINE_RXC_FLAG(MUST_SUCCEED_ALLOCATED, 29)
RX_DEFINE_RXC_FLAG(MINIRDR_INITIATED, 31)
} RX_CONTEXT_FLAGS;
#define RX_CONTEXT_PRESERVED_FLAGS (RX_CONTEXT_FLAG_FROM_POOL | \
RX_CONTEXT_FLAG_MUST_SUCCEED_ALLOCATED | \
RX_CONTEXT_FLAG_IN_FSP)
#define RX_CONTEXT_INITIALIZATION_FLAGS (RX_CONTEXT_FLAG_WAIT | \
RX_CONTEXT_FLAG_MUST_SUCCEED | \
RX_CONTEXT_FLAG_MUST_SUCCEED_NONBLOCKING)
#define RX_DEFINE_RXC_CREATE_FLAG(a,c) RX_DEFINE_FLAG(RX_CONTEXT_CREATE_FLAG_##a,c,0xffff)
typedef enum {
RX_DEFINE_RXC_CREATE_FLAG(UNC_NAME, 0)
RX_DEFINE_RXC_CREATE_FLAG(STRIPPED_TRAILING_BACKSLASH, 1)
RX_DEFINE_RXC_CREATE_FLAG(ADDEDBACKSLASH, 2)
RX_DEFINE_RXC_CREATE_FLAG(REPARSE,3)
RX_DEFINE_RXC_CREATE_FLAG(SPECIAL_PATH, 4)
} RX_CONTEXT_CREATE_FLAGS;
#define RX_DEFINE_RXC_LOWIO_FLAG(a,c) RX_DEFINE_FLAG(RXCONTEXT_FLAG4LOWIO_##a,c,0xffffffff)
typedef enum {
RX_DEFINE_RXC_LOWIO_FLAG(PIPE_OPERATION, 0)
RX_DEFINE_RXC_LOWIO_FLAG(PIPE_SYNC_OPERATION, 1)
RX_DEFINE_RXC_LOWIO_FLAG(READAHEAD, 2)
RX_DEFINE_RXC_LOWIO_FLAG(THIS_READ_ENLARGED, 3)
RX_DEFINE_RXC_LOWIO_FLAG(THIS_IO_BUFFERED, 4)
RX_DEFINE_RXC_LOWIO_FLAG(LOCK_FCB_RESOURCE_HELD, 5)
RX_DEFINE_RXC_LOWIO_FLAG(LOCK_WAS_QUEUED_IN_LOCKMANAGER, 6)
#ifdef __cplusplus
} RX_CONTEXT_LOWIO_FLAGS;
#else // !__cplusplus
} RX_CONTEXT_CREATE_FLAGS;
#endif // __cplusplus
// Macros used to control whether the wrapper breakpoints on an exception
#if DBG
#define RxSaveAndSetExceptionNoBreakpointFlag(RXCONTEXT,_yyy){ \
_yyy = RxContext->Flags & RX_CONTEXT_FLAG_NO_EXCEPTION_BREAKPOINT; \
RxContext->Flags |= RX_CONTEXT_FLAG_NO_EXCEPTION_BREAKPOINT; \
}
#define RxRestoreExceptionNoBreakpointFlag(RXCONTEXT,_yyy){ \
RxContext->Flags &= ~RX_CONTEXT_FLAG_NO_EXCEPTION_BREAKPOINT; \
RxContext->Flags |= _yyy; \
}
#else
#define RxSaveAndSetExceptionNoBreakpointFlag(_xxx,_yyy)
#define RxRestoreExceptionNoBreakpointFlag(_xxx,_yyy)
#endif
// a macro used to ensure that a context hasn't been freed during a wait
#if DBG
VOID
__RxItsTheSameContext(
PRX_CONTEXT RxContext,
ULONG CapturedRxContextSerialNumber,
ULONG Line,
PSZ File
);
#define RxItsTheSameContext() {__RxItsTheSameContext(RxContext,CapturedRxContextSerialNumber,__LINE__,__FILE__);}
#else
#define RxItsTheSameContext() {NOTHING;}
#endif
extern NPAGED_LOOKASIDE_LIST RxContextLookasideList;
// Macros used in the RDBSS to wrap mini rdr calldowns
#define MINIRDR_CALL_THROUGH(STATUS,DISPATCH,FUNC,ARGLIST) \
{ \
ASSERT(DISPATCH); \
ASSERT( NodeType(DISPATCH) == RDBSS_NTC_MINIRDR_DISPATCH ); \
if (DISPATCH->FUNC == NULL) { \
STATUS = STATUS_NOT_IMPLEMENTED; \
} else { \
RxDbgTrace(0, Dbg, ("MiniRdr Calldown - %s\n",#FUNC)); \
STATUS = DISPATCH->FUNC ARGLIST; \
} \
}
#define MINIRDR_CALL(STATUS,CONTEXT,DISPATCH,FUNC,ARGLIST) \
{ \
ASSERT(DISPATCH); \
ASSERT( NodeType(DISPATCH) == RDBSS_NTC_MINIRDR_DISPATCH ); \
if ( DISPATCH->FUNC == NULL) { \
STATUS = STATUS_NOT_IMPLEMENTED; \
} else { \
if (!BooleanFlagOn((CONTEXT)->Flags,RX_CONTEXT_FLAG_CANCELLED)) { \
RxDbgTrace(0, Dbg, ("MiniRdr Calldown - %s\n",#FUNC)); \
RtlZeroMemory(&((CONTEXT)->MRxContext[0]), \
sizeof((CONTEXT)->MRxContext)); \
STATUS = DISPATCH->FUNC ARGLIST; \
} else { \
STATUS = STATUS_CANCELLED; \
} \
} \
}
//VOID
//RxWaitSync (
// IN PRX_CONTEXT RxContext
// )
#define RxWaitSync(RxContext) \
RxDbgTrace(+1, Dbg, ("RxWaitSync, RxContext = %08lx\n", (RxContext))); \
(RxContext)->Flags |= RX_CONTEXT_FLAG_SYNC_EVENT_WAITERS; \
KeWaitForSingleObject( &(RxContext)->SyncEvent, \
Executive, KernelMode, FALSE, NULL ); \
RxDbgTrace(-1, Dbg, ("RxWaitSync -> VOID\n", 0 ))
//VOID
//RxSignalSynchronousWaiter (
// IN PRX_CONTEXT RxContext
// )
#define RxSignalSynchronousWaiter(RxContext) \
(RxContext)->Flags &= ~RX_CONTEXT_FLAG_SYNC_EVENT_WAITERS; \
KeSetEvent( &(RxContext)->SyncEvent, 0, FALSE )
#define RxInsertContextInSerializationQueue(pSerializationQueue,RxContext) \
(RxContext)->Flags |= RX_CONTEXT_FLAG_IN_SERIALIZATION_QUEUE; \
InsertTailList(pSerializationQueue,&((RxContext)->RxContextSerializationQLinks))
INLINE PRX_CONTEXT
RxRemoveFirstContextFromSerializationQueue(PLIST_ENTRY pSerializationQueue)
{
if (IsListEmpty(pSerializationQueue)) {
return NULL;
} else {
PRX_CONTEXT pContext = (PRX_CONTEXT)(CONTAINING_RECORD(pSerializationQueue->Flink,
RX_CONTEXT,
RxContextSerializationQLinks));
RemoveEntryList(pSerializationQueue->Flink);
pContext->RxContextSerializationQLinks.Flink = NULL;
pContext->RxContextSerializationQLinks.Blink = NULL;
return pContext;
}
}
// The following macros provide a mechanism for doing an en masse transfer
// from one list onto another. This provides a powerful paradigm for dealing
// with DPC level processing of lists.
#define RxTransferList(pDestination,pSource) \
if (IsListEmpty((pSource))) { \
InitializeListHead((pDestination)); \
} else { \
*(pDestination) = *(pSource); \
(pDestination)->Flink->Blink = (pDestination); \
(pDestination)->Blink->Flink = (pDestination); \
InitializeListHead((pSource)); \
}
#define RxTransferListWithMutex(pDestination,pSource,pMutex) \
{ \
ExAcquireFastMutex(pMutex); \
RxTransferList(pDestination,pSource); \
ExReleaseFastMutex(pMutex); \
}
VOID RxInitializeRxContexter(void);
VOID RxUninitializeRxContexter(void);
NTSTATUS
RxCancelNotifyChangeDirectoryRequestsForVNetRoot(
PV_NET_ROOT pVNetRoot,
BOOLEAN ForceFilesClosed
);
VOID
RxCancelNotifyChangeDirectoryRequestsForFobx(
PFOBX pFobx);
NTSTATUS
NTAPI
RxSetMinirdrCancelRoutine(
IN OUT PRX_CONTEXT RxContext,
IN PMRX_CALLDOWN MRxCancelRoutine);
VOID
NTAPI
RxInitializeContext(
IN PIRP Irp,
IN PRDBSS_DEVICE_OBJECT RxDeviceObject,
IN ULONG InitialContextFlags,
IN OUT PRX_CONTEXT RxContext);
PRX_CONTEXT
NTAPI
RxCreateRxContext (
IN PIRP Irp,
IN PRDBSS_DEVICE_OBJECT RxDeviceObject,
IN ULONG InitialContextFlags
);
VOID
NTAPI
RxPrepareContextForReuse(
IN OUT PRX_CONTEXT RxContext);
VOID
NTAPI
RxDereferenceAndDeleteRxContext_Real (
IN PRX_CONTEXT RxContext
);
VOID
NTAPI
RxReinitializeContext(
IN OUT PRX_CONTEXT RxContext);
#if DBG
#define RxDereferenceAndDeleteRxContext(RXCONTEXT) { \
RxDereferenceAndDeleteRxContext_Real((RXCONTEXT)); \
(RXCONTEXT) = NULL; \
}
#else
#define RxDereferenceAndDeleteRxContext(RXCONTEXT) { \
RxDereferenceAndDeleteRxContext_Real((RXCONTEXT)); \
}
#endif //
extern FAST_MUTEX RxContextPerFileSerializationMutex;
NTSTATUS
NTAPI
__RxSynchronizeBlockingOperationsMaybeDroppingFcbLock(
IN OUT PRX_CONTEXT RxContext,
IN OUT PLIST_ENTRY BlockingIoQ,
IN BOOLEAN DropFcbLock
);
#define RxSynchronizeBlockingOperationsAndDropFcbLock(__x,__y) \
__RxSynchronizeBlockingOperationsMaybeDroppingFcbLock(__x,__y,TRUE)
#define RxSynchronizeBlockingOperations(__x,__y) \
__RxSynchronizeBlockingOperationsMaybeDroppingFcbLock(__x,__y,FALSE)
VOID
NTAPI
RxResumeBlockedOperations_Serially(
IN OUT PRX_CONTEXT RxContext,
IN OUT PLIST_ENTRY BlockingIoQ
);
VOID
RxResumeBlockedOperations_ALL(
IN OUT PRX_CONTEXT RxContext
);
VOID
RxCancelBlockingOperation(
IN OUT PRX_CONTEXT RxContext);
VOID
RxRemoveOperationFromBlockingQueue(
IN OUT PRX_CONTEXT RxContext);
#endif // _RX_CONTEXT_STRUCT_DEFINED_
Reference in a new issue Copy permalink