| UID | title | description | old-location | tech.root | ms.date | keywords | ms.keywords | req.header | req.include-header | req.target-type | req.target-min-winverclnt | req.target-min-winversvr | req.kmdf-ver | req.umdf-ver | req.ddi-compliance | req.unicode-ansi | req.idl | req.max-support | req.namespace | req.assembly | req.type-library | req.lib | req.dll | req.irql | targetos | req.typenames | f1_keywords | topic_type | api_type | api_location | api_name | ||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
NF:fltkernel.FltCbdqInitialize |
FltCbdqInitialize function (fltkernel.h) |
FltCbdqInitialize initializes a minifilter driver's callback data queue dispatch table. |
ifsk\fltcbdqinitialize.htm |
ifsk |
04/16/2018 |
|
FltApiRef_a_to_d_e365fdac-7834-4388-b8ba-65593b045d19.xml, FltCbdqInitialize, FltCbdqInitialize function [Installable File System Drivers], fltkernel/FltCbdqInitialize, ifsk.fltcbdqinitialize |
fltkernel.h |
Fltkernel.h |
Universal |
Any level |
Windows |
|
|
|
|
|
FltCbdqInitialize initializes a minifilter driver's callback data queue dispatch table.
Opaque instance pointer for the instance whose callback data queue is to be initialized.
Pointer to a callback data queue allocated by the minifilter driver.
Pointer to a caller-supplied insert callback routine. The Filter Manager calls this routine to insert the specified callback data structure into the queue. This routine is declared as follows:
typedef NTSTATUS
(*PFLT_CALLBACK_DATA_QUEUE_INSERT_IO)(
_Inout_ PFLT_CALLBACK_DATA_QUEUE Cbdq,
_In_ PFLT_CALLBACK_DATA Cbd,
_In_opt_ PVOID InsertContext
);
Pointer to the minifilter driver's cancel-safe callback data queue. This queue must have been initialized by calling FltCbdqInitialize.
Pointer to the callback data structure to be inserted into the queue.
Context information pointer that was passed as the InsertContext parameter to FltCbdqInsertIo.
Pointer to a caller-supplied remove callback routine. The Filter Manager calls this routine to remove the specified callback data structure from the queue. This routine is declared as follows:
typedef VOID
(*PFLT_CALLBACK_DATA_QUEUE_REMOVE_IO)(
_Inout_ PFLT_CALLBACK_DATA_QUEUE Cbdq,
_In_ PFLT_CALLBACK_DATA Cbd
);
Pointer to the minifilter driver's cancel-safe callback data queue. This queue must have been initialized by calling FltCbdqInitialize.
Pointer to the callback data structure to be removed from the queue.
Pointer to a caller-supplied peek callback routine. The Filter Manager calls this function to get a pointer to the next I/O operation matching PeekContext in the queue; or, if Cbd is NULL, to get a pointer to the first matching I/O operation in the queue. The minifilter driver entirely defines the meaning of PeekContext and defines when an I/O operation matches a given PeekContext. This routine is declared as follows:
typedef PFLT_CALLBACK_DATA
(*PFLT_CALLBACK_DATA_QUEUE_PEEK_NEXT_IO)(
_In_ PFLT_CALLBACK_DATA_QUEUE Cbdq,
_In_opt_ PFLT_CALLBACK_DATA Cbd,
_In_opt_ PVOID PeekContext
);
Pointer to the minifilter driver's cancel-safe callback data queue. This queue must have been initialized by calling FltCbdqInitialize.
Pointer to the callback data structure marking the position in the queue to begin searching for a match to PeekContext. If Cbd is NULL, the search begins at the head of the queue.
Context information pointer that was passed as the PeekContext parameter to FltCbdqRemoveNextIo.
Pointer to a caller-supplied acquire queue lock callback routine. The Filter Manager calls this routine to acquire the lock on the queue before attempting to insert or remove an item from the queue. This routine is declared as follows:
typedef VOID
(*PFLT_CALLBACK_DATA_QUEUE_ACQUIRE)(
_Inout_ PFLT_CALLBACK_DATA_QUEUE Cbdq,
_Out_opt_ PKIRQL Irql
);
Pointer to the minifilter driver's cancel-safe callback data queue. This queue must have been initialized by calling FltCbdqInitialize.
Pointer to a system-supplied variable that receives the current IRQL. The same variable is passed to the corresponding CbdqRelease routine.
Pointer to a caller-supplied release queue lock callback routine. The Filter Manager calls this routine to release the lock that it obtained by calling the corresponding CbdqAcquire routine. This routine is declared as follows:
typedef VOID
(*PFLT_CALLBACK_DATA_QUEUE_RELEASE)(
_Inout_ PFLT_CALLBACK_DATA_QUEUE Cbdq,
_In_opt_ KIRQL Irql
);
Pointer to the minifilter driver's cancel-safe callback data queue. This queue must have been initialized by calling FltCbdqInitialize.
The same system-supplied variable that received the current IRQL as the Irql parameter to the corresponding CbdqAcquire routine.
Pointer to a caller-supplied cancel routine. The Filter Manager calls this routine to signal to the minifilter driver to complete a canceled I/O operation. This routine is declared as follows:
typedef VOID
(*PFLT_CALLBACK_DATA_QUEUE_COMPLETE_CANCELED_IO)(
_Inout_ PFLT_CALLBACK_DATA_QUEUE Cbdq,
_Inout_ PFLT_CALLBACK_DATA Cbd
);
Pointer to the minifilter driver's cancel-safe callback data queue. This queue must have been initialized by calling FltCbdqInitialize.
Pointer to the callback data structure for the canceled I/O operation.
FltCbdqInitialize returns STATUS_SUCCESS or an appropriate NTSTATUS value.
The newly initialized callback data queue is in the enabled state, which means that callback data structure items can be inserted into the queue. The queue can be disabled by calling FltCbdqDisable and reenabled by calling FltCbdqEnable.
Minifilter drivers can use the FltCbdqXxx routines to implement a callback data queue for IRP-based I/O operations. By using these routines, minifilter drivers can make their queues cancel-safe; the system transparently handles I/O cancellation for the minifilter drivers.
The FltCbdqXxx routines can only be used for IRP-based I/O operations. To determine whether a given callback data structure represents an IRP-based I/O operation, use the FLT_IS_IRP_OPERATION macro.
Minifilter drivers can use any internal implementation for the queue. The Filter Manager interacts with the minifilter driver's queue implementation solely through the set of dispatch routines provided by FltCbdqInitialize.
The system automatically locks and unlocks the queue as necessary. Minifilter drivers do not implement any locking inside their CbdqInsertIo, CbdqRemoveIo, and CbdqPeekNextIo routines.
Minifilter drivers can use any of the operating system's synchronization primitives as the locking mechanism in their CbdqAcquire and CbdqRelease routines, such as a spin lock, mutex object, or resource variable. Note that if a minifilter driver uses a spin lock rather than a mutex or resource to protect the queue, it can call the FltCbdqXxx routines at IRQL <= DISPATCH_LEVEL. If a mutex or resource is used, the minifilter driver must be running at IRQL <= APC_LEVEL when it calls any of these routines except FltCbdqInitialize.
The minifilter driver does not manipulate the queue directly. Instead, it calls FltCbdqInsertIo, FltCbdqRemoveIo, and FltCbdqRemoveNextIo to add or remove a callback data structure. These routines in turn call the callback functions that the minifilter driver provided to FltCbdqInitialize.
Minifilter drivers should implement the queue routines as follows.
| Cbdq Routine | Implementation |
|---|---|
| CbdqInsertIo | Insert the specified callback data structure into the queue. |
| CbdqRemoveIo | Remove the specified callback data structure from the queue. |
| CbdqPeekNextIo | This routine should allow the system to loop through the callback data structures with matching PeekContext in the queue. Cbd = CbdqPeekNextIo(Cbdq, NULL, PeekContext) should return the first matching entry in the queue, and CbdqPeekNextIo(Cbdq, Cbd, PeekContext) should return the next matching entry after the given callback data structure in the queue. The minifilter driver entirely defines the meaning of PeekContext and defines when a callback data structure matches a PeekContext value. |
| CbdqAcquire | This routine should lock the queue so that no other thread can access it. Minifilter drivers can use any locking mechanism to lock the queue. If the minifilter driver uses the KeAcquireSpinLock routine, the minifilter driver can use the memory location pointed to by the routine's Irql parameter to store the IRQL. Otherwise, minifilter drivers can ignore that parameter. |
| CbdqRelease | This routine should unlock the queue created by CbdqAcquire. If the minifilter driver used a spin lock and returned the IRQL value in the Irql parameter of CbdqAcquire, the system passes that value in the Irql parameter of CbdqRelease. The minifilter driver can use the IRQL to unlock the spin lock by calling KeReleaseSpinLock. Otherwise, minifilter drivers can ignore the Irql parameter. |
| CbdqCompleteCanceledIo | This routine should complete a canceled I/O operation. Normally, minifilter drivers can just call FltCompletePendedPreOperation(Data, FLT_PREOP_COMPLETE, NULL). Minifilter drivers do not need to dequeue the callback data structure -- the Filter Manager automatically calls the queue's CbdqRemoveIo before calling CbdqCompleteCanceledIo. |