drivers/filesystems/cdfs_new/workque.c

   1 /*++
   2
   3 Copyright (c) 1989-2000 Microsoft Corporation
   4
   5 Module Name:
   6
   7     WorkQue.c
   8
   9 Abstract:
  10
  11     This module implements the Work queue routines for the Cdfs File
  12     system.
  13
  14
  15 --*/
  16
  17 #include "cdprocs.h"
  18
  19 //
  20 //  The Bug check file id for this module
  21 //
  22
  23 #define BugCheckFileId                   (CDFS_BUG_CHECK_WORKQUE)
  24
  25 //
  26 //  The following constant is the maximum number of ExWorkerThreads that we
  27 //  will allow to be servicing a particular target device at any one time.
  28 //
  29
  30 #define FSP_PER_DEVICE_THRESHOLD         (2)
  31
  32 //
  33 //  Local support routines
  34 //
  35
  36 VOID
  37 CdAddToWorkque (
  38     _Inout_ PIRP_CONTEXT IrpContext,
  39     _Inout_ PIRP Irp
  40     );
  41
  42 #ifdef ALLOC_PRAGMA
  43 #pragma alloc_text(PAGE, CdFsdPostRequest)
  44 #pragma alloc_text(PAGE, CdOplockComplete)
  45 #pragma alloc_text(PAGE, CdPrePostIrp)
  46 #endif
  47
  48 \f
  49 _Requires_lock_held_(_Global_critical_region_)
  50 NTSTATUS
  51 CdFsdPostRequest (
  52     _Inout_ PIRP_CONTEXT IrpContext,
  53     _Inout_ PIRP Irp
  54     )
  55
  56 /*++
  57
  58 Routine Description:
  59
  60     This routine enqueues the request packet specified by IrpContext to the
  61     work queue associated with the FileSystemDeviceObject.  This is a FSD
  62     routine.
  63
  64 Arguments:
  65
  66     IrpContext - Pointer to the IrpContext to be queued to the Fsp.
  67
  68     Irp - I/O Request Packet.
  69
  70 Return Value:
  71
  72     STATUS_PENDING
  73
  74 --*/
  75
  76 {
  77     PAGED_CODE();
  78
  79     ASSERT_IRP_CONTEXT( IrpContext );
  80     ASSERT_IRP( Irp );
  81
  82     //
  83     //  Posting is a three step operation.  First lock down any buffers
  84     //  in the Irp.  Next cleanup the IrpContext for the post and finally
  85     //  add this to a workque.
  86     //
  87
  88     CdPrePostIrp( IrpContext, Irp );
  89
  90     CdAddToWorkque( IrpContext, Irp );
  91
  92     //
  93     //  And return to our caller
  94     //
  95
  96     return STATUS_PENDING;
  97 }
  98
  99 \f
 100
 101 _Requires_lock_held_(_Global_critical_region_)
 102 VOID
 103 NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
 104 CdPrePostIrp (
 105     _Inout_ PIRP_CONTEXT IrpContext,
 106     _Inout_ PIRP Irp
 107     )
 108
 109 /*++
 110
 111 Routine Description:
 112
 113     This routine performs any neccessary work before STATUS_PENDING is
 114     returned with the Fsd thread.  This routine is called within the
 115     filesystem and by the oplock package.
 116
 117 Arguments:
 118
 119     Context - Pointer to the IrpContext to be queued to the Fsp
 120
 121     Irp - I/O Request Packet.
 122
 123 Return Value:
 124
 125     None.
 126
 127 --*/
 128
 129 {
 130     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
 131     BOOLEAN RemovedFcb;
 132
 133     PAGED_CODE();
 134
 135     ASSERT_IRP_CONTEXT( IrpContext );
 136     ASSERT_IRP( Irp );
 137
 138     //
 139     //  Case on the type of the operation.
 140     //
 141
 142     switch (IrpContext->MajorFunction) {
 143
 144     case IRP_MJ_CREATE :
 145
 146         //
 147         //  If called from the oplock package then there is an
 148         //  Fcb to possibly teardown.  We will call the teardown
 149         //  routine and release the Fcb if still present.  The cleanup
 150         //  code in create will know not to release this Fcb because
 151         //  we will clear the pointer.
 152         //
 153
 154         if ((IrpContext->TeardownFcb != NULL) &&
 155             *(IrpContext->TeardownFcb) != NULL) {
 156
 157             CdTeardownStructures( IrpContext, *(IrpContext->TeardownFcb), &RemovedFcb );
 158
 159             if (!RemovedFcb) {
 160
 161                 _Analysis_assume_lock_held_((*IrpContext->TeardownFcb)->FcbNonpaged->FcbResource);
 162                 CdReleaseFcb( IrpContext, *(IrpContext->TeardownFcb) );
 163             }
 164
 165             *(IrpContext->TeardownFcb) = NULL;
 166             IrpContext->TeardownFcb = NULL;
 167         }
 168
 169         break;
 170
 171     //
 172     //  We need to lock the user's buffer, unless this is an MDL read/write,
 173     //  in which case there is no user buffer.
 174     //
 175
 176     case IRP_MJ_READ :
 177
 178         if (!FlagOn( IrpContext->MinorFunction, IRP_MN_MDL )) {
 179
 180             CdLockUserBuffer( IrpContext, IrpSp->Parameters.Read.Length, IoWriteAccess );
 181         }
 182
 183         break;
 184
 185     case IRP_MJ_WRITE :
 186
 187         if (!FlagOn( IrpContext->MinorFunction, IRP_MN_MDL )) {
 188
 189             CdLockUserBuffer( IrpContext, IrpSp->Parameters.Read.Length, IoReadAccess );
 190         }
 191
 192         break;
 193
 194     //
 195     //  We also need to check whether this is a query file operation.
 196     //
 197
 198     case IRP_MJ_DIRECTORY_CONTROL :
 199
 200         if (IrpContext->MinorFunction == IRP_MN_QUERY_DIRECTORY) {
 201
 202             CdLockUserBuffer( IrpContext, IrpSp->Parameters.QueryDirectory.Length, IoWriteAccess );
 203         }
 204
 205         break;
 206     }
 207
 208     //
 209     //  Cleanup the IrpContext for the post.
 210     //
 211
 212     SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_MORE_PROCESSING );
 213     CdCleanupIrpContext( IrpContext, TRUE );
 214
 215     //
 216     //  Mark the Irp to show that we've already returned pending to the user.
 217     //
 218
 219     IoMarkIrpPending( Irp );
 220
 221     return;
 222 }
 223
 224 \f
 225
 226 _Requires_lock_held_(_Global_critical_region_)
 227 VOID
 228 NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
 229 CdOplockComplete (
 230     _Inout_ PIRP_CONTEXT IrpContext,
 231     _Inout_ PIRP Irp
 232     )
 233
 234 /*++
 235
 236 Routine Description:
 237
 238     This routine is called by the oplock package when an oplock break has
 239     completed, allowing an Irp to resume execution.  If the status in
 240     the Irp is STATUS_SUCCESS, then we queue the Irp to the Fsp queue.
 241     Otherwise we complete the Irp with the status in the Irp.
 242
 243     If we are completing due to an error then check if there is any
 244     cleanup to do.
 245
 246 Arguments:
 247
 248     Irp - I/O Request Packet.
 249
 250 Return Value:
 251
 252     None.
 253
 254 --*/
 255
 256 {
 257     BOOLEAN RemovedFcb;
 258
 259     PAGED_CODE();
 260
 261     //
 262     //  Check on the return value in the Irp.  If success then we
 263     //  are to post this request.
 264     //
 265
 266     if (Irp->IoStatus.Status == STATUS_SUCCESS) {
 267
 268         //
 269         //  Check if there is any cleanup work to do.
 270         //
 271
 272         switch (IrpContext->MajorFunction) {
 273
 274         case IRP_MJ_CREATE :
 275
 276             //
 277             //  If called from the oplock package then there is an
 278             //  Fcb to possibly teardown.  We will call the teardown
 279             //  routine and release the Fcb if still present.  The cleanup
 280             //  code in create will know not to release this Fcb because
 281             //  we will clear the pointer.
 282             //
 283
 284             if (IrpContext->TeardownFcb != NULL) {
 285
 286                 CdTeardownStructures( IrpContext, *(IrpContext->TeardownFcb), &RemovedFcb );
 287
 288                 if (!RemovedFcb) {
 289
 290                     _Analysis_assume_lock_held_((*IrpContext->TeardownFcb)->FcbNonpaged->FcbResource);
 291                     CdReleaseFcb( IrpContext, *(IrpContext->TeardownFcb) );
 292                 }
 293
 294                 *(IrpContext->TeardownFcb) = NULL;
 295                 IrpContext->TeardownFcb = NULL;
 296             }
 297
 298             break;
 299         }
 300
 301         //
 302         //  Insert the Irp context in the workqueue.
 303         //
 304
 305         CdAddToWorkque( IrpContext, Irp );
 306
 307     //
 308     //  Otherwise complete the request.
 309     //
 310
 311     } else {
 312
 313         CdCompleteRequest( IrpContext, Irp, Irp->IoStatus.Status );
 314     }
 315
 316     return;
 317 }
 318
 319 \f
 320 //
 321 //  Local support routine
 322 //
 323
 324 VOID
 325 CdAddToWorkque (
 326     _Inout_ PIRP_CONTEXT IrpContext,
 327     _Inout_ PIRP Irp
 328     )
 329
 330 /*++
 331
 332 Routine Description:
 333
 334     This routine is called to acually store the posted Irp to the Fsp
 335     workque.
 336
 337 Arguments:
 338
 339     IrpContext - Pointer to the IrpContext to be queued to the Fsp
 340
 341     Irp - I/O Request Packet.
 342
 343 Return Value:
 344
 345     None.
 346
 347 --*/
 348
 349 {
 350     PVOLUME_DEVICE_OBJECT Vdo;
 351     KIRQL SavedIrql;
 352     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
 353
 354     //
 355     //  Check if this request has an associated file object, and thus volume
 356     //  device object.
 357     //
 358
 359     if (IrpSp->FileObject != NULL) {
 360
 361
 362         Vdo = CONTAINING_RECORD( IrpSp->DeviceObject,
 363                                  VOLUME_DEVICE_OBJECT,
 364                                  DeviceObject );
 365
 366         //
 367         //  Check to see if this request should be sent to the overflow
 368         //  queue.  If not, then send it off to an exworker thread.
 369         //
 370
 371         KeAcquireSpinLock( &Vdo->OverflowQueueSpinLock, &SavedIrql );
 372
 373         if (Vdo->PostedRequestCount > FSP_PER_DEVICE_THRESHOLD) {
 374
 375             //
 376             //  We cannot currently respond to this IRP so we'll just enqueue it
 377             //  to the overflow queue on the volume.
 378             //
 379
 380             InsertTailList( &Vdo->OverflowQueue,
 381                             &IrpContext->WorkQueueItem.List );
 382
 383             Vdo->OverflowQueueCount += 1;
 384
 385             KeReleaseSpinLock( &Vdo->OverflowQueueSpinLock, SavedIrql );
 386
 387             return;
 388
 389         } else {
 390
 391             //
 392             //  We are going to send this Irp to an ex worker thread so up
 393             //  the count.
 394             //
 395
 396             Vdo->PostedRequestCount += 1;
 397
 398             KeReleaseSpinLock( &Vdo->OverflowQueueSpinLock, SavedIrql );
 399         }
 400     }
 401
 402     //
 403     //  Send it off.....
 404     //
 405
 406 #ifdef _MSC_VER
 407 #pragma prefast(suppress:28155, "the function prototype is correct")
 408 #endif
 409     ExInitializeWorkItem( &IrpContext->WorkQueueItem,
 410                           (PVOID)CdFspDispatch,/* ReactOS Change: GCC "assignment from incompatible pointer type" */
 411                           IrpContext );
 412
 413 #ifdef _MSC_VER
 414 #pragma prefast(suppress: 28159, "prefast believes this routine is obsolete, but it is ok for CDFS to continue using it")
 415 #endif
 416     ExQueueWorkItem( &IrpContext->WorkQueueItem, CriticalWorkQueue );
 417
 418     return;
 419 }
 420
 421
 422