workque.c File Reference

#include "cdprocs.h"

Include dependency graph for workque.c:

Go to the source code of this file.

Macros
#define	BugCheckFileId   (CDFS_BUG_CHECK_WORKQUE)
#define	FSP_PER_DEVICE_THRESHOLD   (2)

Functions
VOID	CdAddToWorkque (_Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp)
	_Requires_lock_held_ (_Global_critical_region_)

Macro Definition Documentation

BugCheckFileId

#define BugCheckFileId   (CDFS_BUG_CHECK_WORKQUE)

Definition at line 23 of file workque.c.

FSP_PER_DEVICE_THRESHOLD

#define FSP_PER_DEVICE_THRESHOLD   (2)

Definition at line 30 of file workque.c.

Function Documentation

_Requires_lock_held_()

_Requires_lock_held_

(

_Global_critical_region_

)

Definition at line 49 of file workque.c.

{
    PAGED_CODE();
 
    ASSERT_IRP_CONTEXT( IrpContext );
    ASSERT_IRP( Irp );
 
    //
    //  Posting is a three step operation.  First lock down any buffers
    //  in the Irp.  Next cleanup the IrpContext for the post and finally
    //  add this to a workque.
    //
 
    CdPrePostIrp( IrpContext, Irp );
 
    CdAddToWorkque( IrpContext, Irp );
 
    //
    //  And return to our caller
    //
 
    return STATUS_PENDING;
}

CdAddToWorkque()

VOID CdAddToWorkque	(	_Inout_ PIRP_CONTEXT	IrpContext,
		_Inout_ PIRP	Irp
	)

Definition at line 325 of file workque.c.

{
    PVOLUME_DEVICE_OBJECT Vdo;
    KIRQL SavedIrql;
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    //
    //  Check if this request has an associated file object, and thus volume
    //  device object.
    //
 
    if (IrpSp->FileObject != NULL) {
 
 
        Vdo = CONTAINING_RECORD( IrpSp->DeviceObject,
                                 VOLUME_DEVICE_OBJECT,
                                 DeviceObject );
 
        //
        //  Check to see if this request should be sent to the overflow
        //  queue.  If not, then send it off to an exworker thread.
        //
 
        KeAcquireSpinLock( &Vdo->OverflowQueueSpinLock, &SavedIrql );
 
        if (Vdo->PostedRequestCount > FSP_PER_DEVICE_THRESHOLD) {
 
            //
            //  We cannot currently respond to this IRP so we'll just enqueue it
            //  to the overflow queue on the volume.
            //
 
            InsertTailList( &Vdo->OverflowQueue,
                            &IrpContext->WorkQueueItem.List );
 
            Vdo->OverflowQueueCount += 1;
 
            KeReleaseSpinLock( &Vdo->OverflowQueueSpinLock, SavedIrql );
 
            return;
 
        } else {
 
            //
            //  We are going to send this Irp to an ex worker thread so up
            //  the count.
            //
 
            Vdo->PostedRequestCount += 1;
 
            KeReleaseSpinLock( &Vdo->OverflowQueueSpinLock, SavedIrql );
        }
    }
 
    //
    //  Send it off.....
    //
 
#ifdef _MSC_VER
#pragma prefast(suppress:28155, "the function prototype is correct")
#endif
    ExInitializeWorkItem( &IrpContext->WorkQueueItem,
                          (PVOID)CdFspDispatch,/* ReactOS Change: GCC "assignment from incompatible pointer type" */
                          IrpContext );
 
#ifdef _MSC_VER
#pragma prefast(suppress: 28159, "prefast believes this routine is obsolete, but it is ok for CDFS to continue using it")
#endif
    ExQueueWorkItem( &IrpContext->WorkQueueItem, CriticalWorkQueue );
 
    return;
}

Referenced by _Requires_lock_held_().