reactos/drivers/filesystems/fastfat_new/workque.c
Pierre Schweitzer 0daa5547d9
[FASTFAT_NEW] Import again FastFAT from MS. This time from GitHub for license reasons.
This implies that a sample for W10.
It has been backported to NT5.2; not sure how it would work on a W2K3 (feel free to test!)
2017-11-23 23:27:51 +01:00

373 lines
7.9 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*++
Copyright (c) 1989-2000 Microsoft Corporation
Module Name:
WorkQue.c
Abstract:
This module implements the Work queue routines for the Fat File
system.
--*/
#include "fatprocs.h"
//
// The following constant is the maximum number of ExWorkerThreads that we
// will allow to be servicing a particular target device at any one time.
//
#define FSP_PER_DEVICE_THRESHOLD (2)
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, FatOplockComplete)
#pragma alloc_text(PAGE, FatPrePostIrp)
#pragma alloc_text(PAGE, FatFsdPostRequest)
#endif
VOID
NTAPI
FatOplockComplete (
IN PVOID Context,
IN PIRP Irp
)
/*++
Routine Description:
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.
Arguments:
Context - Pointer to the IrpContext to be queued to the Fsp
Irp - I/O Request Packet.
Return Value:
None.
--*/
{
PAGED_CODE();
//
// Check on the return value in the Irp.
//
if (Irp->IoStatus.Status == STATUS_SUCCESS) {
//
// Insert the Irp context in the workqueue.
//
FatAddToWorkque( (PIRP_CONTEXT) Context, Irp );
//
// Otherwise complete the request.
//
} else {
FatCompleteRequest( (PIRP_CONTEXT) Context, Irp, Irp->IoStatus.Status );
}
return;
}
VOID
NTAPI
FatPrePostIrp (
IN PVOID Context,
IN PIRP Irp
)
/*++
Routine Description:
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;
PIRP_CONTEXT IrpContext;
PAGED_CODE();
//
// If there is no Irp, we are done.
//
if (Irp == NULL) {
return;
}
IrpSp = IoGetCurrentIrpStackLocation( Irp );
IrpContext = (PIRP_CONTEXT) Context;
//
// If there is a STACK FatIoContext pointer, clean and NULL it.
//
if ((IrpContext->FatIoContext != NULL) &&
FlagOn(IrpContext->Flags, IRP_CONTEXT_STACK_IO_CONTEXT)) {
ClearFlag(IrpContext->Flags, IRP_CONTEXT_STACK_IO_CONTEXT);
IrpContext->FatIoContext = NULL;
}
//
// We need to lock the user's buffer, unless this is an MDL-read,
// in which case there is no user buffer.
//
// **** we need a better test than non-MDL (read or write)!
if (IrpContext->MajorFunction == IRP_MJ_READ ||
IrpContext->MajorFunction == IRP_MJ_WRITE) {
//
// If not an Mdl request, lock the user's buffer.
//
if (!FlagOn( IrpContext->MinorFunction, IRP_MN_MDL )) {
FatLockUserBuffer( IrpContext,
Irp,
(IrpContext->MajorFunction == IRP_MJ_READ) ?
IoWriteAccess : IoReadAccess,
(IrpContext->MajorFunction == IRP_MJ_READ) ?
IrpSp->Parameters.Read.Length : IrpSp->Parameters.Write.Length );
}
//
// We also need to check whether this is a query file operation.
//
} else if (IrpContext->MajorFunction == IRP_MJ_DIRECTORY_CONTROL
&& IrpContext->MinorFunction == IRP_MN_QUERY_DIRECTORY) {
FatLockUserBuffer( IrpContext,
Irp,
IoWriteAccess,
IrpSp->Parameters.QueryDirectory.Length );
//
// We also need to check whether this is a query ea operation.
//
} else if (IrpContext->MajorFunction == IRP_MJ_QUERY_EA) {
FatLockUserBuffer( IrpContext,
Irp,
IoWriteAccess,
IrpSp->Parameters.QueryEa.Length );
//
// We also need to check whether this is a set ea operation.
//
} else if (IrpContext->MajorFunction == IRP_MJ_SET_EA) {
FatLockUserBuffer( IrpContext,
Irp,
IoReadAccess,
IrpSp->Parameters.SetEa.Length );
//
// These two FSCTLs use neither I/O, so check for them.
//
} else if ((IrpContext->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL) &&
(IrpContext->MinorFunction == IRP_MN_USER_FS_REQUEST) &&
((IrpSp->Parameters.FileSystemControl.FsControlCode == FSCTL_GET_VOLUME_BITMAP) ||
(IrpSp->Parameters.FileSystemControl.FsControlCode == FSCTL_GET_RETRIEVAL_POINTERS))) {
FatLockUserBuffer( IrpContext,
Irp,
IoWriteAccess,
IrpSp->Parameters.FileSystemControl.OutputBufferLength );
}
//
// Mark that we've already returned pending to the user
//
IoMarkIrpPending( Irp );
return;
}
NTSTATUS
FatFsdPostRequest(
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This routine enqueues the request packet specified by IrpContext to the
Ex Worker threads. This is a FSD routine.
Arguments:
IrpContext - Pointer to the IrpContext to be queued to the Fsp
Irp - I/O Request Packet, or NULL if it has already been completed.
Return Value:
STATUS_PENDING
--*/
{
PAGED_CODE();
NT_ASSERT( ARGUMENT_PRESENT(Irp) );
NT_ASSERT( IrpContext->OriginatingIrp == Irp );
FatPrePostIrp( IrpContext, Irp );
FatAddToWorkque( IrpContext, Irp );
//
// And return to our caller
//
return STATUS_PENDING;
}
//
// Local support routine.
//
VOID
FatAddToWorkque (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
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.
--*/
{
KIRQL SavedIrql;
PIO_STACK_LOCATION IrpSp;
IrpSp = IoGetCurrentIrpStackLocation( Irp );
//
// Check if this request has an associated file object, and thus volume
// device object.
//
if ( IrpSp->FileObject != NULL ) {
PVOLUME_DEVICE_OBJECT Vdo;
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,
FatFspDispatch,
IrpContext );
#ifdef _MSC_VER
#pragma prefast( suppress:28159, "prefast indicates this is an obsolete API but it is ok for fastfat to keep using it." )
#endif
ExQueueWorkItem( &IrpContext->WorkQueueItem, CriticalWorkQueue );
return;
}