workque.c File Reference

#include "UdfProcs.h"

Go to the source code of this file.

Defines
#define	BugCheckFileId   (UDFS_BUG_CHECK_WORKQUE)
#define	Dbg   (UDFS_DEBUG_LEVEL_WORKQUE)
#define	FSP_PER_DEVICE_THRESHOLD   (2)
Functions
VOID	UdfAddToWorkque (IN PIRP_CONTEXT IrpContext, IN PIRP Irp)
NTSTATUS	UdfFsdPostRequest (IN PIRP_CONTEXT IrpContext, IN PIRP Irp)
VOID	UdfPrePostIrp (IN PIRP_CONTEXT IrpContext, IN PIRP Irp)
VOID	UdfOplockComplete (IN PIRP_CONTEXT IrpContext, IN PIRP Irp)

---

Define Documentation

#define BugCheckFileId   (UDFS_BUG_CHECK_WORKQUE)

Definition at line 28 of file workque.c.

#define Dbg   (UDFS_DEBUG_LEVEL_WORKQUE)

Definition at line 34 of file workque.c.

#define FSP_PER_DEVICE_THRESHOLD   (2)

Definition at line 41 of file workque.c. Referenced by UdfAddToWorkque().

---

Function Documentation

VOID UdfAddToWorkque (  IN PIRP_CONTEXT  IrpContext, IN PIRP  Irp )

Definition at line 316 of file workque.c. References CriticalWorkQueue, _IO_STACK_LOCATION::DeviceObject, ExInitializeWorkItem, ExQueueWorkItem(), _IO_STACK_LOCATION::FileObject, FSP_PER_DEVICE_THRESHOLD, IoGetCurrentIrpStackLocation, Irp, KeAcquireSpinLock, KeReleaseSpinLock(), NULL, _VOLUME_DEVICE_OBJECT::OverflowQueue, _VOLUME_DEVICE_OBJECT::OverflowQueueCount, _VOLUME_DEVICE_OBJECT::OverflowQueueSpinLock, _VOLUME_DEVICE_OBJECT::PostedRequestCount, and UdfFspDispatch(). Referenced by UdfFsdPostRequest(), and UdfOplockComplete(). : This routine is called to acually store the posted Irp to the Fsp workque. Arguments: IrpContext - Pointer to the IrpContext to be queued to the Fsp Irp - I/O Request Packet. Return Value: None. --*/ { 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..... // ExInitializeWorkItem( &IrpContext->WorkQueueItem, UdfFspDispatch, IrpContext ); ExQueueWorkItem( &IrpContext->WorkQueueItem, CriticalWorkQueue ); return; }

NTSTATUS UdfFsdPostRequest (  IN PIRP_CONTEXT  IrpContext, IN PIRP  Irp )

Definition at line 61 of file workque.c. References ASSERT_IRP, ASSERT_IRP_CONTEXT, Irp, PAGED_CODE, UdfAddToWorkque(), and UdfPrePostIrp(). Referenced by UdfCommonRead(), UdfPerformVerify(), and UdfProcessException(). : This routine enqueues the request packet specified by IrpContext to the work queue associated with the FileSystemDeviceObject. This is a FSD routine. Arguments: IrpContext - Pointer to the IrpContext to be queued to the Fsp. Irp - I/O Request Packet. Return Value: STATUS_PENDING --*/ { 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. // UdfPrePostIrp( IrpContext, Irp ); UdfAddToWorkque( IrpContext, Irp ); // // And return to our caller // return STATUS_PENDING; }

VOID UdfOplockComplete (  IN PIRP_CONTEXT  IrpContext, IN PIRP  Irp )

Definition at line 222 of file workque.c. References FALSE, _IRP::IoStatus, Irp, IRP_MJ_CREATE, NULL, PAGED_CODE, UdfAddToWorkque(), UdfCompleteRequest(), UdfReleaseFcb, and UdfTeardownStructures(). Referenced by UdfCommonLockControl(), UdfCommonRead(), and UdfCompleteFcbOpen(). : This routine is called by the oplock package when an oplock break has completed, allowing an Irp to resume execution. If the status in the Irp is STATUS_SUCCESS, then we queue the Irp to the Fsp queue. Otherwise we complete the Irp with the status in the Irp. If we are completing due to an error then check if there is any cleanup to do. Arguments: Irp - I/O Request Packet. Return Value: None. --*/ { BOOLEAN RemovedFcb; PAGED_CODE(); // // Check on the return value in the Irp. If success then we // are to post this request. // if (Irp->IoStatus.Status == STATUS_SUCCESS) { // // Check if there is any cleanup work to do. // switch (IrpContext->MajorFunction) { case IRP_MJ_CREATE : // // If called from the oplock package then there is an // Fcb to possibly teardown. We will call the teardown // routine and release the Fcb if still present. The cleanup // code in create will know not to release this Fcb because // we will clear the pointer. // if (IrpContext->TeardownFcb != NULL) { UdfTeardownStructures( IrpContext, *(IrpContext->TeardownFcb), FALSE, &RemovedFcb ); if (!RemovedFcb) { UdfReleaseFcb( IrpContext, *(IrpContext->TeardownFcb) ); } *(IrpContext->TeardownFcb) = NULL; IrpContext->TeardownFcb = NULL; } break; } // // Insert the Irp context in the workqueue. // UdfAddToWorkque( IrpContext, Irp ); // // Otherwise complete the request. // } else { UdfCompleteRequest( IrpContext, Irp, Irp->IoStatus.Status ); } return; }

VOID UdfPrePostIrp (  IN PIRP_CONTEXT  IrpContext, IN PIRP  Irp )

Definition at line 111 of file workque.c. References ASSERT_IRP, ASSERT_IRP_CONTEXT, FALSE, FlagOn, IoGetCurrentIrpStackLocation, IoMarkIrpPending, Irp, IRP_CONTEXT_FLAG_MORE_PROCESSING, IRP_MJ_CREATE, IRP_MJ_DIRECTORY_CONTROL, IRP_MJ_READ, IRP_MN_MDL, IRP_MN_QUERY_DIRECTORY, NULL, PAGED_CODE, _IO_STACK_LOCATION::Parameters, SetFlag, TRUE, UdfCleanupIrpContext(), UdfLockUserBuffer, UdfReleaseFcb, and UdfTeardownStructures(). Referenced by UdfCommonRead(), UdfCompleteFcbOpen(), and UdfFsdPostRequest(). : This routine performs any neccessary work before STATUS_PENDING is returned with the Fsd thread. This routine is called within the filesystem and by the oplock package. Arguments: Context - Pointer to the IrpContext to be queued to the Fsp Irp - I/O Request Packet. Return Value: None. --*/ { PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp ); BOOLEAN RemovedFcb; PAGED_CODE(); ASSERT_IRP_CONTEXT( IrpContext ); ASSERT_IRP( Irp ); // // Case on the type of the operation. // switch (IrpContext->MajorFunction) { case IRP_MJ_CREATE : // // If called from the oplock package then there is an // Fcb to possibly teardown. We will call the teardown // routine and release the Fcb if still present. The cleanup // code in create will know not to release this Fcb because // we will clear the pointer. // if ((IrpContext->TeardownFcb != NULL) && *(IrpContext->TeardownFcb) != NULL) { UdfTeardownStructures( IrpContext, *(IrpContext->TeardownFcb), FALSE, &RemovedFcb ); if (!RemovedFcb) { UdfReleaseFcb( IrpContext, *(IrpContext->TeardownFcb) ); } *(IrpContext->TeardownFcb) = NULL; IrpContext->TeardownFcb = NULL; } break; // // We need to lock the user's buffer, unless this is an MDL-read, // in which case there is no user buffer. // case IRP_MJ_READ : if (!FlagOn( IrpContext->MinorFunction, IRP_MN_MDL )) { UdfLockUserBuffer( IrpContext, IrpSp->Parameters.Read.Length ); } break; // // We also need to check whether this is a query file operation. // case IRP_MJ_DIRECTORY_CONTROL : if (IrpContext->MinorFunction == IRP_MN_QUERY_DIRECTORY) { UdfLockUserBuffer( IrpContext, IrpSp->Parameters.QueryDirectory.Length ); } break; } // // Cleanup the IrpContext for the post. // SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_MORE_PROCESSING ); UdfCleanupIrpContext( IrpContext, TRUE ); // // Mark the Irp to show that we've already returned pending to the user. // IoMarkIrpPending( Irp ); return; }

---