src/WINNT/afsrdr/kernel/lib/AFSWorker.cpp

   1 /*
   2  * Copyright (c) 2008, 2009, 2010, 2011 Kernel Drivers, LLC.
   3  * Copyright (c) 2009, 2010, 2011 Your File System, Inc.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * - Redistributions of source code must retain the above copyright notice,
  11  *   this list of conditions and the following disclaimer.
  12  * - Redistributions in binary form must reproduce the above copyright
  13  *   notice,
  14  *   this list of conditions and the following disclaimer in the
  15  *   documentation
  16  *   and/or other materials provided with the distribution.
  17  * - Neither the names of Kernel Drivers, LLC and Your File System, Inc.
  18  *   nor the names of their contributors may be used to endorse or promote
  19  *   products derived from this software without specific prior written
  20  *   permission from Kernel Drivers, LLC and Your File System, Inc.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  23  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  24  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  25  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
  26  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  27  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  28  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  29  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  30  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  31  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  32  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33  */
  34
  35 //
  36 // File: AFSWorker.cpp
  37 //
  38
  39 #include "AFSCommon.h"
  40
  41 //
  42 // Function: AFSInitializeWorkerPool
  43 //
  44 // Description:
  45 //
  46 //      This function initializes the worker thread pool
  47 //
  48 // Return:
  49 //
  50 //      A status is returned for the function
  51 //
  52
  53 NTSTATUS
  54 AFSInitializeWorkerPool()
  55 {
  56
  57     NTSTATUS ntStatus = STATUS_SUCCESS;
  58     AFSWorkQueueContext        *pCurrentWorker = NULL, *pLastWorker = NULL;
  59     AFSDeviceExt *pDevExt = NULL;
  60
  61     __Enter
  62     {
  63
  64         pDevExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
  65
  66         //
  67         // Initialize the worker threads.
  68         //
  69
  70         pDevExt->Specific.Library.WorkerCount = 0;
  71
  72         KeInitializeEvent( &pDevExt->Specific.Library.WorkerQueueHasItems,
  73                            SynchronizationEvent,
  74                            FALSE);
  75
  76         //
  77         // Initialize the queue resource
  78         //
  79
  80         ExInitializeResourceLite( &pDevExt->Specific.Library.QueueLock);
  81
  82         while( pDevExt->Specific.Library.WorkerCount < AFS_WORKER_COUNT)
  83         {
  84
  85             pCurrentWorker = (AFSWorkQueueContext *)AFSLibExAllocatePoolWithTag( NonPagedPool,
  86                                                                                  sizeof( AFSWorkQueueContext),
  87                                                                                  AFS_WORKER_CB_TAG);
  88
  89             if( pCurrentWorker == NULL)
  90             {
  91
  92                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
  93                               AFS_TRACE_LEVEL_ERROR,
  94                               "AFSInitializeWorkerPool Failed to allocate worker context\n");
  95
  96                 ntStatus = STATUS_INSUFFICIENT_RESOURCES;
  97
  98                 break;
  99             }
 100
 101             RtlZeroMemory( pCurrentWorker,
 102                            sizeof( AFSWorkQueueContext));
 103
 104             ntStatus = AFSInitWorkerThread( pCurrentWorker,
 105                                             (PKSTART_ROUTINE)AFSWorkerThread);
 106
 107             if( !NT_SUCCESS( ntStatus))
 108             {
 109
 110                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 111                               AFS_TRACE_LEVEL_ERROR,
 112                               "AFSInitializeWorkerPool Failed to initialize worker thread Status %08lX\n", ntStatus);
 113
 114                 ExFreePool( pCurrentWorker);
 115
 116                 break;
 117             }
 118
 119             if( pDevExt->Specific.Library.PoolHead == NULL)
 120             {
 121
 122                 pDevExt->Specific.Library.PoolHead = pCurrentWorker;
 123             }
 124             else
 125             {
 126
 127                 pLastWorker->fLink = pCurrentWorker;
 128             }
 129
 130             pLastWorker = pCurrentWorker;
 131
 132             pDevExt->Specific.Library.WorkerCount++;
 133         }
 134
 135         //
 136         // If there was a failure but there is at least one worker, then go with it.
 137         //
 138
 139         if( !NT_SUCCESS( ntStatus) &&
 140             pDevExt->Specific.Library.WorkerCount == 0)
 141         {
 142
 143             try_return( ntStatus);
 144         }
 145
 146         ntStatus = STATUS_SUCCESS;
 147
 148         //
 149         // Now our IO Worker queue
 150         //
 151
 152         pDevExt->Specific.Library.IOWorkerCount = 0;
 153
 154         KeInitializeEvent( &pDevExt->Specific.Library.IOWorkerQueueHasItems,
 155                            SynchronizationEvent,
 156                            FALSE);
 157
 158         //
 159         // Initialize the queue resource
 160         //
 161
 162         ExInitializeResourceLite( &pDevExt->Specific.Library.IOQueueLock);
 163
 164         while( pDevExt->Specific.Library.IOWorkerCount < AFS_IO_WORKER_COUNT)
 165         {
 166
 167             pCurrentWorker = (AFSWorkQueueContext *)AFSLibExAllocatePoolWithTag( NonPagedPool,
 168                                                                                  sizeof( AFSWorkQueueContext),
 169                                                                                  AFS_WORKER_CB_TAG);
 170
 171             if( pCurrentWorker == NULL)
 172             {
 173
 174                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 175                               AFS_TRACE_LEVEL_ERROR,
 176                               "AFSInitializeWorkerPool Failed to allocate IO worker context\n");
 177
 178                 ntStatus = STATUS_INSUFFICIENT_RESOURCES;
 179
 180                 break;
 181             }
 182
 183             RtlZeroMemory( pCurrentWorker,
 184                            sizeof( AFSWorkQueueContext));
 185
 186             ntStatus = AFSInitWorkerThread( pCurrentWorker,
 187                                             (PKSTART_ROUTINE)AFSIOWorkerThread);
 188
 189             if( !NT_SUCCESS( ntStatus))
 190             {
 191
 192                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 193                               AFS_TRACE_LEVEL_ERROR,
 194                               "AFSInitializeWorkerPool Failed to initialize IO worker thread Status %08lX\n", ntStatus);
 195
 196                 ExFreePool( pCurrentWorker);
 197
 198                 break;
 199             }
 200
 201             if( pDevExt->Specific.Library.IOPoolHead == NULL)
 202             {
 203
 204                 pDevExt->Specific.Library.IOPoolHead = pCurrentWorker;
 205             }
 206             else
 207             {
 208
 209                 pLastWorker->fLink = pCurrentWorker;
 210             }
 211
 212             pLastWorker = pCurrentWorker;
 213
 214             pDevExt->Specific.Library.IOWorkerCount++;
 215         }
 216
 217         //
 218         // If there was a failure but there is at least one worker, then go with it.
 219         //
 220
 221         if( !NT_SUCCESS( ntStatus) &&
 222             pDevExt->Specific.Library.IOWorkerCount == 0)
 223         {
 224
 225             try_return( ntStatus);
 226         }
 227
 228 try_exit:
 229
 230         if( !NT_SUCCESS( ntStatus))
 231         {
 232
 233             //
 234             // Failed to initialize the pool so tear it down
 235             //
 236
 237             AFSRemoveWorkerPool();
 238         }
 239     }
 240
 241     return ntStatus;
 242 }
 243
 244 //
 245 // Function: AFSRemoveWorkerPool
 246 //
 247 // Description:
 248 //
 249 //      This function tears down the worker thread pool
 250 //
 251 // Return:
 252 //
 253 //      A status is returned for the function
 254 //
 255
 256 NTSTATUS
 257 AFSRemoveWorkerPool()
 258 {
 259
 260     NTSTATUS ntStatus = STATUS_SUCCESS;
 261     ULONG index = 0;
 262     AFSWorkQueueContext        *pCurrentWorker = NULL, *pNextWorker = NULL;
 263     AFSDeviceExt *pDevExt = NULL;
 264
 265     pDevExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
 266
 267     //
 268     // Loop through the workers shutting them down in two stages.
 269     // First, clear AFS_WORKER_PROCESS_REQUESTS so that workers
 270     // stop processing requests.  Second, call AFSShutdownWorkerThread()
 271     // to wake the workers and wait for them to exit.
 272     //
 273
 274     pCurrentWorker = pDevExt->Specific.Library.PoolHead;
 275
 276     while( index < pDevExt->Specific.Library.WorkerCount)
 277     {
 278
 279         ClearFlag( pCurrentWorker->State, AFS_WORKER_PROCESS_REQUESTS);
 280
 281         pCurrentWorker = pCurrentWorker->fLink;
 282
 283         if ( pCurrentWorker == NULL)
 284         {
 285
 286             break;
 287         }
 288
 289         index++;
 290     }
 291
 292     pCurrentWorker = pDevExt->Specific.Library.PoolHead;
 293
 294     index = 0;
 295
 296     while( index < pDevExt->Specific.Library.WorkerCount)
 297     {
 298
 299         ntStatus = AFSShutdownWorkerThread( pCurrentWorker);
 300
 301         pNextWorker = pCurrentWorker->fLink;
 302
 303         ExFreePool( pCurrentWorker);
 304
 305         pCurrentWorker = pNextWorker;
 306
 307         if( pCurrentWorker == NULL)
 308         {
 309
 310             break;
 311         }
 312
 313         index++;
 314     }
 315
 316     pDevExt->Specific.Library.PoolHead = NULL;
 317
 318     ExDeleteResourceLite( &pDevExt->Specific.Library.QueueLock);
 319
 320     //
 321     // Loop through the IO workers shutting them down in two stages.
 322     // First, clear AFS_WORKER_PROCESS_REQUESTS so that workers
 323     // stop processing requests.  Second, call AFSShutdownIOWorkerThread()
 324     // to wake the workers and wait for them to exit.
 325     //
 326
 327     pCurrentWorker = pDevExt->Specific.Library.IOPoolHead;
 328
 329     index = 0;
 330
 331     while( index < pDevExt->Specific.Library.IOWorkerCount)
 332     {
 333
 334         ClearFlag( pCurrentWorker->State, AFS_WORKER_PROCESS_REQUESTS);
 335
 336         pCurrentWorker = pCurrentWorker->fLink;
 337
 338         if ( pCurrentWorker == NULL)
 339         {
 340
 341             break;
 342         }
 343
 344         index++;
 345     }
 346
 347     pCurrentWorker = pDevExt->Specific.Library.IOPoolHead;
 348
 349     index = 0;
 350
 351     while( index < pDevExt->Specific.Library.IOWorkerCount)
 352     {
 353
 354         ntStatus = AFSShutdownIOWorkerThread( pCurrentWorker);
 355
 356         pNextWorker = pCurrentWorker->fLink;
 357
 358         ExFreePool( pCurrentWorker);
 359
 360         pCurrentWorker = pNextWorker;
 361
 362         if( pCurrentWorker == NULL)
 363         {
 364
 365             break;
 366         }
 367
 368         index++;
 369     }
 370
 371     pDevExt->Specific.Library.IOPoolHead = NULL;
 372
 373     ExDeleteResourceLite( &pDevExt->Specific.Library.IOQueueLock);
 374
 375     return ntStatus;
 376 }
 377
 378 NTSTATUS
 379 AFSInitVolumeWorker( IN AFSVolumeCB *VolumeCB)
 380 {
 381
 382     NTSTATUS ntStatus = STATUS_SUCCESS;
 383     AFSWorkQueueContext *pWorker = &VolumeCB->VolumeWorkerContext;
 384     HANDLE hThread;
 385     AFSDeviceExt *pControlDeviceExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
 386     PKSTART_ROUTINE pStartRoutine = NULL;
 387     LONG lCount;
 388
 389     __Enter
 390     {
 391
 392         if ( VolumeCB != AFSGlobalRoot)
 393         {
 394
 395             return STATUS_INVALID_PARAMETER;
 396         }
 397
 398         pStartRoutine = AFSPrimaryVolumeWorkerThread;
 399
 400         //
 401         // Initialize the worker thread
 402         //
 403
 404         KeInitializeEvent( &pWorker->WorkerThreadReady,
 405                            NotificationEvent,
 406                            FALSE);
 407
 408         //
 409         // Set the worker to process requests
 410         //
 411
 412         pWorker->State = AFS_WORKER_PROCESS_REQUESTS;
 413
 414         //
 415         // Launch the thread
 416         //
 417
 418         ntStatus =  PsCreateSystemThread( &hThread,
 419                                           0,
 420                                           NULL,
 421                                           NULL,
 422                                           NULL,
 423                                           pStartRoutine,
 424                                           (void *)VolumeCB);
 425
 426         if( NT_SUCCESS( ntStatus))
 427         {
 428
 429             ObReferenceObjectByHandle( hThread,
 430                                        GENERIC_READ | GENERIC_WRITE,
 431                                        NULL,
 432                                        KernelMode,
 433                                        (PVOID *)&pWorker->WorkerThreadObject,
 434                                        NULL);
 435
 436             ntStatus = KeWaitForSingleObject( &pWorker->WorkerThreadReady,
 437                                               Executive,
 438                                               KernelMode,
 439                                               FALSE,
 440                                               NULL);
 441
 442             lCount = InterlockedIncrement( &pControlDeviceExt->Specific.Control.VolumeWorkerThreadCount);
 443
 444             if( lCount > 0)
 445             {
 446
 447                 KeClearEvent( &pControlDeviceExt->Specific.Control.VolumeWorkerCloseEvent);
 448             }
 449
 450             ZwClose( hThread);
 451         }
 452     }
 453
 454     return ntStatus;
 455 }
 456
 457 //
 458 // Function: AFSInitWorkerThread
 459 //
 460 // Description:
 461 //
 462 //      This function initializes a worker thread in the pool
 463 //
 464 // Return:
 465 //
 466 //      A status is returned for the function
 467 //
 468
 469 NTSTATUS
 470 AFSInitWorkerThread( IN AFSWorkQueueContext *PoolContext,
 471                      IN PKSTART_ROUTINE WorkerRoutine)
 472 {
 473
 474     NTSTATUS ntStatus = STATUS_SUCCESS;
 475     HANDLE Handle;
 476
 477     //
 478     // INitialize the worker signal thread
 479     //
 480
 481     KeInitializeEvent( &PoolContext->WorkerThreadReady,
 482                        NotificationEvent,
 483                        FALSE);
 484
 485     //
 486     // Set the worker to process requests
 487     //
 488
 489     PoolContext->State = AFS_WORKER_PROCESS_REQUESTS;
 490
 491     //
 492     // Launch the thread
 493     //
 494
 495     ntStatus =  PsCreateSystemThread( &Handle,
 496                                       0,
 497                                       NULL,
 498                                       NULL,
 499                                       NULL,
 500                                       WorkerRoutine,
 501                                       (void *)PoolContext);
 502
 503     if( NT_SUCCESS( ntStatus))
 504     {
 505
 506         ObReferenceObjectByHandle( Handle,
 507                                    GENERIC_READ | GENERIC_WRITE,
 508                                    NULL,
 509                                    KernelMode,
 510                                    (PVOID *)&PoolContext->WorkerThreadObject,
 511                                    NULL);
 512
 513         ntStatus = KeWaitForSingleObject( &PoolContext->WorkerThreadReady,
 514                                           Executive,
 515                                           KernelMode,
 516                                           FALSE,
 517                                           NULL);
 518
 519         ZwClose( Handle);
 520     }
 521
 522     return ntStatus;
 523 }
 524
 525 NTSTATUS
 526 AFSShutdownVolumeWorker( IN AFSVolumeCB *VolumeCB)
 527 {
 528
 529     NTSTATUS ntStatus = STATUS_SUCCESS;
 530     AFSWorkQueueContext *pWorker = &VolumeCB->VolumeWorkerContext;
 531
 532     //
 533     // Clear the 'keep processing' flag
 534     //
 535
 536     ClearFlag( pWorker->State, AFS_WORKER_PROCESS_REQUESTS);
 537
 538     if( pWorker->WorkerThreadObject != NULL)
 539     {
 540         while ( BooleanFlagOn( pWorker->State, AFS_WORKER_INITIALIZED) )
 541         {
 542
 543             ntStatus = KeWaitForSingleObject( pWorker->WorkerThreadObject,
 544                                               Executive,
 545                                               KernelMode,
 546                                               FALSE,
 547                                               NULL);
 548         }
 549
 550         ObDereferenceObject( pWorker->WorkerThreadObject);
 551
 552         pWorker->WorkerThreadObject = NULL;
 553     }
 554
 555     return ntStatus;
 556 }
 557
 558 //
 559 // Function: AFSShutdownWorkerThread
 560 //
 561 // Description:
 562 //
 563 //      This function shutsdown a worker thread in the pool
 564 //
 565 // Return:
 566 //
 567 //      A status is returned for the function
 568 //
 569
 570 NTSTATUS
 571 AFSShutdownWorkerThread( IN AFSWorkQueueContext *PoolContext)
 572 {
 573
 574     NTSTATUS ntStatus = STATUS_SUCCESS;
 575     AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
 576
 577     if( PoolContext->WorkerThreadObject != NULL)
 578     {
 579
 580         while ( BooleanFlagOn( PoolContext->State, AFS_WORKER_INITIALIZED) )
 581         {
 582
 583             //
 584             // Wake up the thread if it is a sleep
 585             //
 586
 587             KeSetEvent( &pDeviceExt->Specific.Library.WorkerQueueHasItems,
 588                         0,
 589                         FALSE);
 590
 591             ntStatus = KeWaitForSingleObject( PoolContext->WorkerThreadObject,
 592                                               Executive,
 593                                               KernelMode,
 594                                               FALSE,
 595                                               NULL);
 596         }
 597
 598         ObDereferenceObject( PoolContext->WorkerThreadObject);
 599
 600         PoolContext->WorkerThreadObject = NULL;
 601     }
 602
 603     return ntStatus;
 604 }
 605
 606 //
 607 // Function: AFSShutdownIOWorkerThread
 608 //
 609 // Description:
 610 //
 611 //      This function shutsdown an IO worker thread in the pool
 612 //
 613 // Return:
 614 //
 615 //      A status is returned for the function
 616 //
 617
 618 NTSTATUS
 619 AFSShutdownIOWorkerThread( IN AFSWorkQueueContext *PoolContext)
 620 {
 621
 622     NTSTATUS ntStatus = STATUS_SUCCESS;
 623     AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
 624
 625     if( PoolContext->WorkerThreadObject != NULL)
 626     {
 627
 628         while ( BooleanFlagOn( PoolContext->State, AFS_WORKER_INITIALIZED) )
 629         {
 630
 631             //
 632             // Wake up the thread if it is a sleep
 633             //
 634
 635             KeSetEvent( &pDeviceExt->Specific.Library.IOWorkerQueueHasItems,
 636                         0,
 637                         FALSE);
 638
 639             ntStatus = KeWaitForSingleObject( PoolContext->WorkerThreadObject,
 640                                               Executive,
 641                                               KernelMode,
 642                                               FALSE,
 643                                               NULL);
 644         }
 645
 646         ObDereferenceObject( PoolContext->WorkerThreadObject);
 647
 648         PoolContext->WorkerThreadObject = NULL;
 649     }
 650
 651     return ntStatus;
 652 }
 653
 654 //
 655 // Function: AFSWorkerThread
 656 //
 657 // Description:
 658 //
 659 //      This is the worker thread entry point.
 660 //
 661 // Return:
 662 //
 663 //      A status is returned for the function
 664 //
 665
 666 void
 667 AFSWorkerThread( IN PVOID Context)
 668 {
 669
 670     NTSTATUS ntStatus = STATUS_SUCCESS;
 671     AFSWorkQueueContext *pPoolContext = (AFSWorkQueueContext *)Context;
 672     AFSWorkItem *pWorkItem;
 673     BOOLEAN freeWorkItem = TRUE;
 674     AFSDeviceExt *pLibraryDevExt = NULL;
 675     LONG lCount;
 676
 677     pLibraryDevExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
 678
 679     //
 680     // Indicate that we are initialized and ready
 681     //
 682
 683     KeSetEvent( &pPoolContext->WorkerThreadReady,
 684                 0,
 685                 FALSE);
 686
 687     //
 688     // Indicate we are initialized
 689     //
 690
 691     SetFlag( pPoolContext->State, AFS_WORKER_INITIALIZED);
 692
 693     ntStatus = KeWaitForSingleObject( &pLibraryDevExt->Specific.Library.WorkerQueueHasItems,
 694                                       Executive,
 695                                       KernelMode,
 696                                       FALSE,
 697                                       NULL);
 698
 699     while( BooleanFlagOn( pPoolContext->State, AFS_WORKER_PROCESS_REQUESTS))
 700     {
 701
 702         if( !NT_SUCCESS( ntStatus))
 703         {
 704
 705             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 706                           AFS_TRACE_LEVEL_ERROR,
 707                           "AFSWorkerThread Wait for queue items failed Status %08lX\n", ntStatus);
 708
 709             ntStatus = STATUS_SUCCESS;
 710         }
 711         else
 712         {
 713
 714             pWorkItem = AFSRemoveWorkItem();
 715
 716             if( pWorkItem == NULL)
 717             {
 718
 719                 ntStatus = KeWaitForSingleObject( &pLibraryDevExt->Specific.Library.WorkerQueueHasItems,
 720                                                   Executive,
 721                                                   KernelMode,
 722                                                   FALSE,
 723                                                   NULL);
 724             }
 725             else
 726             {
 727
 728                 freeWorkItem = TRUE;
 729
 730                 //
 731                 // Switch on the type of work item to process
 732                 //
 733
 734                 switch( pWorkItem->RequestType)
 735                 {
 736
 737                     case AFS_WORK_FLUSH_FCB:
 738                     {
 739
 740                         ntStatus = AFSFlushExtents( pWorkItem->Specific.Fcb.Fcb,
 741                                                     &pWorkItem->AuthGroup);
 742
 743                         if( !NT_SUCCESS( ntStatus))
 744                         {
 745
 746                             AFSReleaseExtentsWithFlush( pWorkItem->Specific.Fcb.Fcb,
 747                                                         &pWorkItem->AuthGroup,
 748                                                         FALSE);
 749                         }
 750
 751                         ASSERT( pWorkItem->Specific.Fcb.Fcb->OpenReferenceCount != 0);
 752
 753                         lCount = InterlockedDecrement( &pWorkItem->Specific.Fcb.Fcb->OpenReferenceCount);
 754
 755                         break;
 756                     }
 757
 758                     case AFS_WORK_ENUMERATE_GLOBAL_ROOT:
 759                     {
 760
 761                         AFSEnumerateGlobalRoot( NULL);
 762
 763                         break;
 764                     }
 765
 766                     case AFS_WORK_INVALIDATE_OBJECT:
 767                     {
 768
 769                         AFSPerformObjectInvalidate( pWorkItem->Specific.Invalidate.ObjectInfo,
 770                                                     pWorkItem->Specific.Invalidate.InvalidateReason);
 771
 772                         freeWorkItem = TRUE;
 773
 774                         break;
 775                     }
 776
 777                     case AFS_WORK_START_IOS:
 778                     {
 779
 780                         freeWorkItem = TRUE;
 781
 782                         break;
 783                     }
 784
 785                     default:
 786
 787                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 788                                       AFS_TRACE_LEVEL_ERROR,
 789                                       "AFSWorkerThread Unknown request type %d\n", pWorkItem->RequestType);
 790
 791                         break;
 792                 }
 793
 794                 if( freeWorkItem)
 795                 {
 796
 797                     ExFreePoolWithTag( pWorkItem, AFS_WORK_ITEM_TAG);
 798                 }
 799
 800                 ntStatus = STATUS_SUCCESS;
 801             }
 802         }
 803     } // worker thread loop
 804
 805     ClearFlag( pPoolContext->State, AFS_WORKER_INITIALIZED);
 806
 807     // Wake up another worker so they too can exit
 808
 809     KeSetEvent( &pLibraryDevExt->Specific.Library.WorkerQueueHasItems,
 810                 0,
 811                 FALSE);
 812
 813     PsTerminateSystemThread( 0);
 814
 815     return;
 816 }
 817
 818 void
 819 AFSIOWorkerThread( IN PVOID Context)
 820 {
 821
 822     NTSTATUS ntStatus = STATUS_SUCCESS;
 823     AFSWorkQueueContext *pPoolContext = (AFSWorkQueueContext *)Context;
 824     AFSWorkItem *pWorkItem;
 825     BOOLEAN freeWorkItem = TRUE;
 826     AFSDeviceExt *pLibraryDevExt = NULL, *pRdrDevExt = NULL;
 827
 828     pLibraryDevExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
 829
 830     //
 831     // Indicate that we are initialized and ready
 832     //
 833
 834     KeSetEvent( &pPoolContext->WorkerThreadReady,
 835                 0,
 836                 FALSE);
 837
 838
 839     //
 840     // Indicate we are initialized
 841     //
 842
 843     SetFlag( pPoolContext->State, AFS_WORKER_INITIALIZED);
 844
 845     ntStatus = KeWaitForSingleObject( &pLibraryDevExt->Specific.Library.IOWorkerQueueHasItems,
 846                                       Executive,
 847                                       KernelMode,
 848                                       FALSE,
 849                                       NULL);
 850
 851     while( BooleanFlagOn( pPoolContext->State, AFS_WORKER_PROCESS_REQUESTS))
 852     {
 853
 854         if( !NT_SUCCESS( ntStatus))
 855         {
 856
 857             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 858                           AFS_TRACE_LEVEL_ERROR,
 859                           "AFSIOWorkerThread Wait for queue items failed Status %08lX\n", ntStatus);
 860
 861             ntStatus = STATUS_SUCCESS;
 862         }
 863         else
 864         {
 865
 866             pWorkItem = AFSRemoveIOWorkItem();
 867
 868             if( pWorkItem == NULL)
 869             {
 870
 871                 ntStatus = KeWaitForSingleObject( &pLibraryDevExt->Specific.Library.IOWorkerQueueHasItems,
 872                                                   Executive,
 873                                                   KernelMode,
 874                                                   FALSE,
 875                                                   NULL);
 876             }
 877             else
 878             {
 879
 880                 freeWorkItem = TRUE;
 881
 882                 //
 883                 // Switch on the type of work item to process
 884                 //
 885
 886                 switch( pWorkItem->RequestType)
 887                 {
 888
 889                     case AFS_WORK_START_IOS:
 890                     {
 891
 892                         pRdrDevExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
 893
 894                         //
 895                         // The final status is in the gather io
 896                         //
 897
 898                         ntStatus = AFSStartIos( pWorkItem->Specific.CacheAccess.CacheFileObject,
 899                                                 pWorkItem->Specific.CacheAccess.FunctionCode,
 900                                                 pWorkItem->Specific.CacheAccess.RequestFlags,
 901                                                 pWorkItem->Specific.CacheAccess.IoRuns,
 902                                                 pWorkItem->Specific.CacheAccess.RunCount,
 903                                                 pWorkItem->Specific.CacheAccess.GatherIo);
 904
 905                         //
 906                         // Regardless of the status we we do the complete - there may
 907                         // be IOs in flight
 908                         // Decrement the count - setting the event if we were told
 909                         // to. This may trigger completion.
 910                         //
 911
 912                         AFSCompleteIo( pWorkItem->Specific.CacheAccess.GatherIo, ntStatus );
 913
 914                         freeWorkItem = TRUE;
 915
 916                         break;
 917                     }
 918
 919                     default:
 920
 921                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 922                                       AFS_TRACE_LEVEL_ERROR,
 923                                       "AFSWorkerThread Unknown request type %d\n", pWorkItem->RequestType);
 924
 925                         break;
 926                 }
 927
 928                 if( freeWorkItem)
 929                 {
 930
 931                     ExFreePoolWithTag( pWorkItem, AFS_WORK_ITEM_TAG);
 932                 }
 933
 934                 ntStatus = STATUS_SUCCESS;
 935             }
 936         }
 937     } // worker thread loop
 938
 939     ClearFlag( pPoolContext->State, AFS_WORKER_INITIALIZED);
 940
 941     // Wake up another IOWorker so they too can exit
 942
 943     KeSetEvent( &pLibraryDevExt->Specific.Library.IOWorkerQueueHasItems,
 944                 0,
 945                 FALSE);
 946
 947     PsTerminateSystemThread( 0);
 948
 949     return;
 950 }
 951
 952 void
 953 AFSPrimaryVolumeWorkerThread( IN PVOID Context)
 954 {
 955
 956     UNREFERENCED_PARAMETER(Context);
 957     NTSTATUS ntStatus = STATUS_SUCCESS;
 958     AFSWorkQueueContext *pPoolContext = (AFSWorkQueueContext *)&AFSGlobalRoot->VolumeWorkerContext;
 959     AFSDeviceExt *pControlDeviceExt = NULL;
 960     AFSDeviceExt *pRDRDeviceExt = NULL;
 961     LARGE_INTEGER DueTime;
 962     LONG TimeOut;
 963     KTIMER Timer;
 964     AFSObjectInfoCB *pCurrentObject = NULL, *pNextObject = NULL, *pCurrentChildObject = NULL;
 965     AFSDirectoryCB *pCurrentDirEntry = NULL, *pNextDirEntry = NULL;
 966     BOOLEAN bReleaseVolumeLock = FALSE;
 967     AFSVolumeCB *pVolumeCB = NULL, *pNextVolume = NULL;
 968     AFSFcb *pFcb = NULL;
 969     LARGE_INTEGER liCurrentTime;
 970     BOOLEAN bVolumeObject = FALSE;
 971     BOOLEAN bFcbBusy = FALSE;
 972     LONG lCount;
 973
 974     pControlDeviceExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
 975
 976     pRDRDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
 977
 978     AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
 979                   AFS_TRACE_LEVEL_VERBOSE,
 980                   "AFSPrimaryVolumeWorkerThread Initialized\n");
 981
 982     //
 983     // Initialize the timer for the worker thread
 984     //
 985
 986     DueTime.QuadPart = -(5000);
 987
 988     TimeOut = 5000;
 989
 990     KeInitializeTimerEx( &Timer,
 991                          SynchronizationTimer);
 992
 993     KeSetTimerEx( &Timer,
 994                   DueTime,
 995                   TimeOut,
 996                   NULL);
 997
 998     //
 999     // Indicate that we are initialized and ready
1000     //
1001
1002     KeSetEvent( &pPoolContext->WorkerThreadReady,
1003                 0,
1004                 FALSE);
1005
1006     //
1007     // Indicate we are initialized
1008     //
1009
1010     SetFlag( pPoolContext->State, AFS_WORKER_INITIALIZED);
1011
1012     while( BooleanFlagOn( pPoolContext->State, AFS_WORKER_PROCESS_REQUESTS))
1013     {
1014
1015         if ( bFcbBusy == FALSE)
1016         {
1017
1018             KeWaitForSingleObject( &Timer,
1019                                    Executive,
1020                                    KernelMode,
1021                                    FALSE,
1022                                    NULL);
1023         }
1024         else
1025         {
1026
1027             bFcbBusy = FALSE;
1028         }
1029
1030         //
1031         // This is the primary volume worker so it will traverse the volume list
1032         // looking for cleanup or volumes requiring private workers
1033         //
1034
1035         AFSAcquireShared( &pRDRDeviceExt->Specific.RDR.VolumeListLock,
1036                           TRUE);
1037
1038         pVolumeCB = pRDRDeviceExt->Specific.RDR.VolumeListHead;
1039
1040         while( pVolumeCB != NULL)
1041         {
1042
1043             if( pVolumeCB == AFSGlobalRoot ||
1044                 !AFSAcquireExcl( pVolumeCB->VolumeLock,
1045                                  FALSE))
1046             {
1047
1048                 pVolumeCB = (AFSVolumeCB *)pVolumeCB->ListEntry.fLink;
1049
1050                 continue;
1051             }
1052
1053             if( pVolumeCB->ObjectInfoListHead == NULL)
1054             {
1055
1056                 AFSReleaseResource( pVolumeCB->VolumeLock);
1057
1058                 AFSReleaseResource( &pRDRDeviceExt->Specific.RDR.VolumeListLock);
1059
1060                 AFSAcquireExcl( pRDRDeviceExt->Specific.RDR.VolumeTree.TreeLock,
1061                                 TRUE);
1062
1063                 AFSAcquireExcl( &pRDRDeviceExt->Specific.RDR.VolumeListLock,
1064                                 TRUE);
1065
1066                 if( !AFSAcquireExcl( pVolumeCB->VolumeLock,
1067                                      FALSE))
1068                 {
1069
1070                     AFSConvertToShared( &pRDRDeviceExt->Specific.RDR.VolumeListLock);
1071
1072                     AFSReleaseResource( pRDRDeviceExt->Specific.RDR.VolumeTree.TreeLock);
1073
1074                     pVolumeCB = (AFSVolumeCB *)pVolumeCB->ListEntry.fLink;
1075
1076                     continue;
1077                 }
1078
1079                 KeQueryTickCount( &liCurrentTime);
1080
1081                 pNextVolume = (AFSVolumeCB *)pVolumeCB->ListEntry.fLink;
1082
1083                 AFSAcquireShared( &pVolumeCB->ObjectInformation.NonPagedInfo->ObjectInfoLock,
1084                                   TRUE);
1085
1086                 if( pVolumeCB->ObjectInfoListHead == NULL &&
1087                     pVolumeCB->DirectoryCB->DirOpenReferenceCount <= 0 &&
1088                     pVolumeCB->VolumeReferenceCount == 1 &&
1089                     ( pVolumeCB->RootFcb == NULL ||
1090                       pVolumeCB->RootFcb->OpenReferenceCount == 0) &&
1091                     pVolumeCB->ObjectInformation.ObjectReferenceCount <= 0)
1092                 {
1093
1094                     if( pVolumeCB->RootFcb != NULL)
1095                     {
1096
1097                         AFSRemoveRootFcb( pVolumeCB->RootFcb);
1098                     }
1099
1100                     AFSReleaseResource( &pVolumeCB->ObjectInformation.NonPagedInfo->ObjectInfoLock);
1101
1102                     AFSRemoveVolume( pVolumeCB);
1103                 }
1104                 else
1105                 {
1106
1107                     AFSReleaseResource( &pVolumeCB->ObjectInformation.NonPagedInfo->ObjectInfoLock);
1108
1109                     AFSReleaseResource( pVolumeCB->VolumeLock);
1110                 }
1111
1112                 AFSConvertToShared( &pRDRDeviceExt->Specific.RDR.VolumeListLock);
1113
1114                 AFSReleaseResource( pRDRDeviceExt->Specific.RDR.VolumeTree.TreeLock);
1115
1116                 pVolumeCB = pNextVolume;
1117
1118                 continue;
1119             }
1120
1121             //
1122             // Don't need this lock anymore now that we have a volume cb to work with
1123             //
1124
1125             AFSReleaseResource( &pRDRDeviceExt->Specific.RDR.VolumeListLock);
1126
1127             //
1128             // For now we only need the volume lock shared
1129             //
1130
1131             AFSConvertToShared( pVolumeCB->VolumeLock);
1132
1133             if( AFSAcquireShared( pVolumeCB->ObjectInfoTree.TreeLock,
1134                                   FALSE))
1135             {
1136
1137                 pCurrentObject = pVolumeCB->ObjectInfoListHead;
1138
1139                 pNextObject = NULL;
1140
1141                 bReleaseVolumeLock = TRUE;
1142
1143                 while( pCurrentObject != NULL)
1144                 {
1145
1146                     if( pCurrentObject != &pVolumeCB->ObjectInformation)
1147                     {
1148
1149                         pNextObject = (AFSObjectInfoCB *)pCurrentObject->ListEntry.fLink;
1150
1151                         if( pNextObject == NULL &&
1152                             pVolumeCB != AFSGlobalRoot)  // Don't free up the root of the global
1153                         {
1154
1155                             pNextObject = &pVolumeCB->ObjectInformation;
1156                         }
1157
1158                         bVolumeObject = FALSE;
1159                     }
1160                     else
1161                     {
1162
1163                         pNextObject = NULL;
1164
1165                         bVolumeObject = TRUE;
1166                     }
1167
1168                     if( pCurrentObject->FileType == AFS_FILE_TYPE_DIRECTORY &&
1169                         !BooleanFlagOn( pRDRDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_REDIRECTOR_SHUTDOWN))  // If we are in shutdown mode skip directories
1170                     {
1171
1172                         //
1173                         // If this object is deleted then remove it from the parent, if we can
1174                         //
1175
1176                         if( BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_FLAGS_DELETED) &&
1177                             pCurrentObject->ObjectReferenceCount <= 0 &&
1178                             ( pCurrentObject->Fcb == NULL ||
1179                               pCurrentObject->Fcb->OpenReferenceCount == 0) &&
1180                             pCurrentObject->Specific.Directory.DirectoryNodeListHead == NULL &&
1181                             pCurrentObject->Specific.Directory.ChildOpenReferenceCount == 0)
1182                         {
1183
1184                             AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
1185
1186                             //
1187                             // Dropping the TreeLock permits the
1188                             // pCurrentObject->ObjectReferenceCount to change
1189                             //
1190
1191                             if( AFSAcquireExcl( pVolumeCB->ObjectInfoTree.TreeLock,
1192                                                 FALSE))
1193                             {
1194
1195                                 AFSAcquireExcl( &pCurrentObject->NonPagedInfo->ObjectInfoLock,
1196                                                 TRUE);
1197
1198                                 if ( pCurrentObject->ObjectReferenceCount <= 0)
1199                                 {
1200
1201                                     AFSRemoveFcb( &pCurrentObject->Fcb);
1202
1203                                     if( pCurrentObject->Specific.Directory.PIOCtlDirectoryCB != NULL)
1204                                     {
1205
1206                                         AFSAcquireExcl( &pCurrentObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->NonPagedInfo->ObjectInfoLock,
1207                                                         TRUE);
1208
1209                                         AFSRemoveFcb( &pCurrentObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb);
1210
1211                                         AFSReleaseResource( &pCurrentObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->NonPagedInfo->ObjectInfoLock);
1212
1213                                         AFSDeleteObjectInfo( pCurrentObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation);
1214
1215                                         ExDeleteResourceLite( &pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->NonPaged->Lock);
1216
1217                                         AFSExFreePoolWithTag( pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->NonPaged, AFS_DIR_ENTRY_NP_TAG);
1218
1219                                         AFSExFreePoolWithTag( pCurrentObject->Specific.Directory.PIOCtlDirectoryCB, AFS_DIR_ENTRY_TAG);
1220                                     }
1221
1222                                     AFSReleaseResource( &pCurrentObject->NonPagedInfo->ObjectInfoLock);
1223
1224                                     AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
1225                                                   AFS_TRACE_LEVEL_VERBOSE,
1226                                                   "AFSPrimaryVolumeWorkerThread Deleting deleted object %08lX\n",
1227                                                   pCurrentObject);
1228
1229                                     AFSDeleteObjectInfo( pCurrentObject);
1230                                 }
1231                                 else
1232                                 {
1233
1234                                     AFSReleaseResource( &pCurrentObject->NonPagedInfo->ObjectInfoLock);
1235                                 }
1236
1237                                 AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
1238
1239                                 pCurrentObject = pNextObject;
1240
1241                                 continue;
1242                             }
1243                             else
1244                             {
1245
1246                                 bReleaseVolumeLock = FALSE;
1247
1248                                 break;
1249                             }
1250                         }
1251
1252                         if( pCurrentObject->Specific.Directory.ChildOpenReferenceCount > 0 ||
1253                             ( pCurrentObject->Fcb != NULL &&
1254                               pCurrentObject->Fcb->OpenReferenceCount > 0) ||
1255                             pCurrentObject->Specific.Directory.DirectoryNodeListHead == NULL)
1256                         {
1257
1258                             pCurrentObject = pNextObject;
1259
1260                             continue;
1261                         }
1262
1263                         if( !AFSAcquireShared( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
1264                                                FALSE))
1265                         {
1266
1267                             pCurrentObject = pNextObject;
1268
1269                             continue;
1270                         }
1271
1272                         KeQueryTickCount( &liCurrentTime);
1273
1274                         pCurrentDirEntry = pCurrentObject->Specific.Directory.DirectoryNodeListHead;
1275
1276                         while( pCurrentDirEntry != NULL)
1277                         {
1278
1279                             if( pCurrentDirEntry->DirOpenReferenceCount > 0 ||
1280                                 ( pCurrentDirEntry->ObjectInformation->Fcb != NULL &&
1281                                   pCurrentDirEntry->ObjectInformation->Fcb->OpenReferenceCount > 0) ||
1282                                 liCurrentTime.QuadPart <= pCurrentDirEntry->ObjectInformation->LastAccessCount.QuadPart ||
1283                                 liCurrentTime.QuadPart - pCurrentDirEntry->ObjectInformation->LastAccessCount.QuadPart <
1284                                                                         pControlDeviceExt->Specific.Control.ObjectLifeTimeCount.QuadPart ||
1285                                 ( pCurrentDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_DIRECTORY &&
1286                                    ( pCurrentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeListHead != NULL ||
1287                                      pCurrentDirEntry->ObjectInformation->Specific.Directory.ChildOpenReferenceCount > 0)) ||
1288                                 ( pCurrentDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_FILE &&
1289                                   pCurrentDirEntry->ObjectInformation->Fcb != NULL &&
1290                                   pCurrentDirEntry->ObjectInformation->Fcb->Specific.File.ExtentsDirtyCount > 0))
1291                             {
1292
1293                                 break;
1294                             }
1295
1296                             pCurrentDirEntry = (AFSDirectoryCB *)pCurrentDirEntry->ListEntry.fLink;
1297                         }
1298
1299                         if( pCurrentDirEntry != NULL)
1300                         {
1301
1302                             AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
1303
1304                             pCurrentObject = pNextObject;
1305
1306                             continue;
1307                         }
1308
1309                         AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
1310
1311                         AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
1312
1313                         //
1314                         // Now acquire the locks excl
1315                         //
1316
1317                         if( AFSAcquireExcl( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
1318                                             FALSE))
1319                         {
1320
1321                             if( AFSAcquireExcl( pVolumeCB->ObjectInfoTree.TreeLock,
1322                                                 FALSE))
1323                             {
1324
1325                                 if( pCurrentObject->Specific.Directory.ChildOpenReferenceCount > 0)
1326                                 {
1327
1328                                     AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
1329
1330                                     AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
1331
1332                                     pCurrentObject = pNextObject;
1333
1334                                     continue;
1335                                 }
1336
1337                                 KeQueryTickCount( &liCurrentTime);
1338
1339                                 pCurrentDirEntry = pCurrentObject->Specific.Directory.DirectoryNodeListHead;
1340
1341                                 while( pCurrentDirEntry != NULL)
1342                                 {
1343
1344                                     if( pCurrentDirEntry->DirOpenReferenceCount > 0 ||
1345                                         ( pCurrentDirEntry->ObjectInformation->Fcb != NULL &&
1346                                           pCurrentDirEntry->ObjectInformation->Fcb->OpenReferenceCount > 0) ||
1347                                         liCurrentTime.QuadPart <= pCurrentDirEntry->ObjectInformation->LastAccessCount.QuadPart ||
1348                                         liCurrentTime.QuadPart - pCurrentDirEntry->ObjectInformation->LastAccessCount.QuadPart <
1349                                                                                 pControlDeviceExt->Specific.Control.ObjectLifeTimeCount.QuadPart ||
1350                                         ( pCurrentDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_DIRECTORY &&
1351                                           ( pCurrentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeListHead != NULL ||
1352                                             pCurrentDirEntry->ObjectInformation->Specific.Directory.ChildOpenReferenceCount > 0)) ||
1353                                         ( pCurrentDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_FILE &&
1354                                           pCurrentDirEntry->ObjectInformation->Fcb != NULL &&
1355                                           pCurrentDirEntry->ObjectInformation->Fcb->Specific.File.ExtentsDirtyCount > 0))
1356                                     {
1357
1358                                         break;
1359                                     }
1360
1361                                     pCurrentDirEntry = (AFSDirectoryCB *)pCurrentDirEntry->ListEntry.fLink;
1362                                 }
1363
1364                                 if( pCurrentDirEntry != NULL)
1365                                 {
1366
1367                                     AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
1368
1369                                     AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
1370
1371                                     pCurrentObject = pNextObject;
1372
1373                                     continue;
1374                                 }
1375
1376                                 pCurrentDirEntry = pCurrentObject->Specific.Directory.DirectoryNodeListHead;
1377
1378                                 while( pCurrentDirEntry != NULL)
1379                                 {
1380
1381                                     pNextDirEntry = (AFSDirectoryCB *)pCurrentDirEntry->ListEntry.fLink;
1382
1383                                     pCurrentChildObject = pCurrentDirEntry->ObjectInformation;
1384
1385                                     pFcb = NULL;
1386
1387                                     AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING | AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1388                                                   AFS_TRACE_LEVEL_VERBOSE,
1389                                                   "AFSPrimaryVolumeWorkerThread Deleting DE %wZ Object %08lX\n",
1390                                                   &pCurrentDirEntry->NameInformation.FileName,
1391                                                   pCurrentChildObject);
1392
1393                                     AFSDeleteDirEntry( pCurrentObject,
1394                                                        pCurrentDirEntry);
1395
1396
1397                                     //
1398                                     // Acquire ObjectInfoLock shared here so as not to deadlock
1399                                     // with an invalidation call from the service during AFSCleanupFcb
1400                                     //
1401
1402                                     lCount = AFSObjectInfoIncrement( pCurrentChildObject);
1403
1404                                     if( lCount == 1 &&
1405                                         pCurrentChildObject->Fcb != NULL &&
1406                                         pCurrentChildObject->FileType == AFS_FILE_TYPE_FILE)
1407                                     {
1408
1409                                         //
1410                                         // We must not hold pVolumeCB->ObjectInfoTree.TreeLock exclusive
1411                                         // across an AFSCleanupFcb call since it can deadlock with an
1412                                         // invalidation call from the service.
1413                                         //
1414
1415                                         AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
1416
1417                                         //
1418                                         // Cannot hold a TreeLock across an AFSCleanupFcb call
1419                                         // as it can deadlock with an invalidation ioctl initiated
1420                                         // from the service.
1421                                         //
1422                                         // Dropping the TreeLock permits the
1423                                         // pCurrentObject->ObjectReferenceCount to change
1424                                         //
1425
1426                                         ntStatus = AFSCleanupFcb( pCurrentChildObject->Fcb,
1427                                                                   TRUE);
1428
1429                                         if ( ntStatus == STATUS_RETRY)
1430                                         {
1431
1432                                             bFcbBusy = TRUE;
1433                                         }
1434
1435                                         AFSAcquireExcl( pVolumeCB->ObjectInfoTree.TreeLock,
1436                                                         TRUE);
1437                                     }
1438
1439                                     lCount = AFSObjectInfoDecrement( pCurrentChildObject);
1440
1441                                     AFSAcquireExcl( &pCurrentChildObject->NonPagedInfo->ObjectInfoLock,
1442                                                     TRUE);
1443
1444                                     if( pCurrentChildObject->ObjectReferenceCount <= 0)
1445                                     {
1446
1447                                         AFSRemoveFcb( &pCurrentChildObject->Fcb);
1448
1449                                         if( pCurrentChildObject->FileType == AFS_FILE_TYPE_DIRECTORY &&
1450                                             pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB != NULL)
1451                                         {
1452
1453                                             AFSAcquireExcl( &pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->NonPagedInfo->ObjectInfoLock,
1454                                                             TRUE);
1455
1456                                             AFSRemoveFcb( &pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb);
1457
1458                                             AFSReleaseResource( &pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->NonPagedInfo->ObjectInfoLock);
1459
1460                                             AFSDeleteObjectInfo( pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation);
1461
1462                                             ExDeleteResourceLite( &pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->NonPaged->Lock);
1463
1464                                             AFSExFreePoolWithTag( pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->NonPaged, AFS_DIR_ENTRY_NP_TAG);
1465
1466                                             AFSExFreePoolWithTag( pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB, AFS_DIR_ENTRY_TAG);
1467                                         }
1468
1469                                         AFSReleaseResource( &pCurrentChildObject->NonPagedInfo->ObjectInfoLock);
1470
1471                                         AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
1472                                                       AFS_TRACE_LEVEL_VERBOSE,
1473                                                       "AFSPrimaryVolumeWorkerThread Deleting object %08lX\n",
1474                                                       pCurrentChildObject);
1475
1476                                         AFSDeleteObjectInfo( pCurrentChildObject);
1477                                     }
1478                                     else
1479                                     {
1480
1481                                         AFSReleaseResource( &pCurrentChildObject->NonPagedInfo->ObjectInfoLock);
1482                                     }
1483
1484                                     pCurrentDirEntry = pNextDirEntry;
1485
1486                                 }
1487
1488                                 pCurrentObject->Specific.Directory.DirectoryNodeListHead = NULL;
1489
1490                                 pCurrentObject->Specific.Directory.DirectoryNodeListTail = NULL;
1491
1492                                 pCurrentObject->Specific.Directory.ShortNameTree = NULL;
1493
1494                                 pCurrentObject->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead = NULL;
1495
1496                                 pCurrentObject->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead = NULL;
1497
1498                                 pCurrentObject->Specific.Directory.DirectoryNodeCount = 0;
1499
1500                                 AFSDbgLogMsg( AFS_SUBSYSTEM_DIR_NODE_COUNT,
1501                                               AFS_TRACE_LEVEL_VERBOSE,
1502                                               "AFSPrimaryVolumeWorkerThread Reset count to 0 on parent FID %08lX-%08lX-%08lX-%08lX\n",
1503                                               pCurrentObject->FileId.Cell,
1504                                               pCurrentObject->FileId.Volume,
1505                                               pCurrentObject->FileId.Vnode,
1506                                               pCurrentObject->FileId.Unique);
1507
1508                                 //
1509                                 // Clear our enumerated flag on this object so we retrieve info again on next access
1510                                 //
1511
1512                                 ClearFlag( pCurrentObject->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED);
1513
1514                                 AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
1515
1516                                 AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
1517                             }
1518                             else
1519                             {
1520
1521                                 AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
1522
1523                                 bReleaseVolumeLock = FALSE;
1524
1525                                 break;
1526                             }
1527                         }
1528                         else
1529                         {
1530
1531                             //
1532                             // Try to grab the volume lock again ... no problem if we don't
1533                             //
1534
1535                             if( !AFSAcquireExcl( pVolumeCB->ObjectInfoTree.TreeLock,
1536                                                  FALSE))
1537                             {
1538
1539                                 bReleaseVolumeLock = FALSE;
1540
1541                                 break;
1542                             }
1543                         }
1544
1545                         if( pCurrentObject != &pVolumeCB->ObjectInformation)
1546                         {
1547
1548                             pCurrentObject = (AFSObjectInfoCB *)pCurrentObject->ListEntry.fLink;
1549
1550                             if( pCurrentObject == NULL &&
1551                                 pVolumeCB != AFSGlobalRoot)
1552                             {
1553
1554                                 pCurrentObject = &pVolumeCB->ObjectInformation;
1555                             }
1556                         }
1557                         else
1558                         {
1559
1560                             pCurrentObject = NULL;
1561                         }
1562
1563                         continue;
1564                     }
1565                     else if( pCurrentObject->FileType == AFS_FILE_TYPE_FILE)
1566                     {
1567
1568                         lCount = AFSObjectInfoIncrement( pCurrentObject);
1569
1570                         AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
1571
1572                         if( pCurrentObject->Fcb != NULL)
1573                         {
1574
1575                             //
1576                             // Dropping the TreeLock permits the
1577                             // pCurrentObject->ObjectReferenceCount to change
1578                             //
1579
1580                             ntStatus = AFSCleanupFcb( pCurrentObject->Fcb,
1581                                                       FALSE);
1582
1583                             if ( ntStatus == STATUS_RETRY)
1584                             {
1585
1586                                 bFcbBusy = TRUE;
1587                             }
1588                         }
1589
1590                         lCount = AFSObjectInfoDecrement( pCurrentObject);
1591
1592                         if( !AFSAcquireExcl( pVolumeCB->ObjectInfoTree.TreeLock,
1593                                              FALSE))
1594                         {
1595
1596                             bReleaseVolumeLock = FALSE;
1597
1598                             break;
1599                         }
1600
1601                         AFSAcquireExcl( &pCurrentObject->NonPagedInfo->ObjectInfoLock,
1602                                         TRUE);
1603
1604                         if( BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_FLAGS_DELETED) &&
1605                             pCurrentObject->ObjectReferenceCount <= 0)
1606                         {
1607
1608                             AFSRemoveFcb( &pCurrentObject->Fcb);
1609
1610                             AFSReleaseResource( &pCurrentObject->NonPagedInfo->ObjectInfoLock);
1611
1612                             AFSDeleteObjectInfo( pCurrentObject);
1613                         }
1614                         else
1615                         {
1616
1617                             AFSReleaseResource( &pCurrentObject->NonPagedInfo->ObjectInfoLock);
1618                         }
1619
1620                         AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
1621
1622                         pCurrentObject = pNextObject;
1623
1624                         continue;
1625                     }
1626
1627                     pCurrentObject = pNextObject;
1628                 }
1629
1630                 if( bReleaseVolumeLock)
1631                 {
1632
1633                     AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
1634                 }
1635             }
1636
1637             //
1638             // Next volume cb
1639             //
1640
1641             AFSReleaseResource( pVolumeCB->VolumeLock);
1642
1643             AFSAcquireShared( &pRDRDeviceExt->Specific.RDR.VolumeListLock,
1644                               TRUE);
1645
1646             pVolumeCB = (AFSVolumeCB *)pVolumeCB->ListEntry.fLink;
1647         }
1648
1649         AFSReleaseResource( &pRDRDeviceExt->Specific.RDR.VolumeListLock);
1650
1651     } // worker thread loop
1652
1653     KeCancelTimer( &Timer);
1654
1655     ClearFlag( pPoolContext->State, AFS_WORKER_INITIALIZED);
1656
1657     AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
1658                   AFS_TRACE_LEVEL_VERBOSE,
1659                   "AFSPrimaryVolumeWorkerThread Exiting\n");
1660
1661     lCount = InterlockedDecrement( &pControlDeviceExt->Specific.Control.VolumeWorkerThreadCount);
1662
1663     if( lCount == 0)
1664     {
1665
1666         KeSetEvent( &pControlDeviceExt->Specific.Control.VolumeWorkerCloseEvent,
1667                     0,
1668                     FALSE);
1669     }
1670
1671     PsTerminateSystemThread( 0);
1672
1673     return;
1674 }
1675
1676 NTSTATUS
1677 AFSInsertWorkitem( IN AFSWorkItem *WorkItem)
1678 {
1679
1680     NTSTATUS ntStatus = STATUS_SUCCESS;
1681     AFSDeviceExt *pDevExt = NULL;
1682     LONG lCount;
1683
1684     pDevExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
1685
1686     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1687                   AFS_TRACE_LEVEL_VERBOSE,
1688                   "AFSInsertWorkitem Acquiring Control QueueLock lock %08lX EXCL %08lX\n",
1689                   &pDevExt->Specific.Library.QueueLock,
1690                   PsGetCurrentThread());
1691
1692     AFSAcquireExcl( &pDevExt->Specific.Library.QueueLock,
1693                     TRUE);
1694
1695     lCount = InterlockedIncrement( &pDevExt->Specific.Library.QueueItemCount);
1696
1697     AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
1698                   AFS_TRACE_LEVEL_VERBOSE,
1699                   "AFSInsertWorkitem Inserting work item %08lX Count %08lX\n",
1700                   WorkItem,
1701                   lCount);
1702
1703     if( pDevExt->Specific.Library.QueueTail != NULL) // queue already has nodes
1704     {
1705
1706         pDevExt->Specific.Library.QueueTail->next = WorkItem;
1707     }
1708     else // first node
1709     {
1710
1711         pDevExt->Specific.Library.QueueHead = WorkItem;
1712     }
1713
1714     WorkItem->next = NULL;
1715     pDevExt->Specific.Library.QueueTail = WorkItem;
1716
1717     // indicate that the queue has nodes
1718     KeSetEvent( &(pDevExt->Specific.Library.WorkerQueueHasItems),
1719                 0,
1720                 FALSE);
1721
1722     AFSReleaseResource( &pDevExt->Specific.Library.QueueLock);
1723
1724     return ntStatus;
1725 }
1726
1727 NTSTATUS
1728 AFSInsertIOWorkitem( IN AFSWorkItem *WorkItem)
1729 {
1730
1731     NTSTATUS ntStatus = STATUS_SUCCESS;
1732     AFSDeviceExt *pDevExt = NULL;
1733     LONG lCount;
1734
1735     pDevExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
1736
1737     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1738                   AFS_TRACE_LEVEL_VERBOSE,
1739                   "AFSInsertIOWorkitem Acquiring Control QueueLock lock %08lX EXCL %08lX\n",
1740                   &pDevExt->Specific.Library.IOQueueLock,
1741                   PsGetCurrentThread());
1742
1743     AFSAcquireExcl( &pDevExt->Specific.Library.IOQueueLock,
1744                     TRUE);
1745
1746     lCount = InterlockedIncrement( &pDevExt->Specific.Library.IOQueueItemCount);
1747
1748     AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
1749                   AFS_TRACE_LEVEL_VERBOSE,
1750                   "AFSInsertWorkitem Inserting IO work item %08lX Count %08lX\n",
1751                   WorkItem,
1752                   lCount);
1753
1754     if( pDevExt->Specific.Library.IOQueueTail != NULL) // queue already has nodes
1755     {
1756
1757         pDevExt->Specific.Library.IOQueueTail->next = WorkItem;
1758     }
1759     else // first node
1760     {
1761
1762         pDevExt->Specific.Library.IOQueueHead = WorkItem;
1763     }
1764
1765     WorkItem->next = NULL;
1766     pDevExt->Specific.Library.IOQueueTail = WorkItem;
1767
1768     // indicate that the queue has nodes
1769     KeSetEvent( &(pDevExt->Specific.Library.IOWorkerQueueHasItems),
1770                 0,
1771                 FALSE);
1772
1773     AFSReleaseResource( &pDevExt->Specific.Library.IOQueueLock);
1774
1775     return ntStatus;
1776 }
1777
1778 NTSTATUS
1779 AFSInsertWorkitemAtHead( IN AFSWorkItem *WorkItem)
1780 {
1781
1782     NTSTATUS ntStatus = STATUS_SUCCESS;
1783     AFSDeviceExt *pDevExt = NULL;
1784     LONG lCount;
1785
1786     pDevExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
1787
1788     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1789                   AFS_TRACE_LEVEL_VERBOSE,
1790                   "AFSInsertWorkitemAtHead Acquiring Control QueueLock lock %08lX EXCL %08lX\n",
1791                   &pDevExt->Specific.Library.QueueLock,
1792                   PsGetCurrentThread());
1793
1794     AFSAcquireExcl( &pDevExt->Specific.Library.QueueLock,
1795                     TRUE);
1796
1797     WorkItem->next = pDevExt->Specific.Library.QueueHead;
1798
1799     pDevExt->Specific.Library.QueueHead = WorkItem;
1800
1801     lCount = InterlockedIncrement( &pDevExt->Specific.Library.QueueItemCount);
1802
1803     AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
1804                   AFS_TRACE_LEVEL_VERBOSE,
1805                   "AFSInsertWorkitemAtHead Inserting work item %08lX Count %08lX\n",
1806                   WorkItem,
1807                   lCount);
1808
1809     //
1810     // indicate that the queue has nodes
1811     //
1812
1813     KeSetEvent( &(pDevExt->Specific.Library.WorkerQueueHasItems),
1814                 0,
1815                 FALSE);
1816
1817     AFSReleaseResource( &pDevExt->Specific.Library.QueueLock);
1818
1819     return ntStatus;
1820 }
1821
1822 AFSWorkItem *
1823 AFSRemoveWorkItem()
1824 {
1825
1826     AFSWorkItem        *pWorkItem = NULL;
1827     AFSDeviceExt *pDevExt = NULL;
1828     LONG lCount;
1829
1830     pDevExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
1831
1832     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1833                   AFS_TRACE_LEVEL_VERBOSE,
1834                   "AFSRemoveWorkItem Acquiring Control QueueLock lock %08lX EXCL %08lX\n",
1835                   &pDevExt->Specific.Library.QueueLock,
1836                   PsGetCurrentThread());
1837
1838     AFSAcquireExcl( &pDevExt->Specific.Library.QueueLock,
1839                     TRUE);
1840
1841     if( pDevExt->Specific.Library.QueueHead != NULL) // queue has nodes
1842     {
1843
1844         pWorkItem = pDevExt->Specific.Library.QueueHead;
1845
1846         lCount = InterlockedDecrement( &pDevExt->Specific.Library.QueueItemCount);
1847
1848         AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
1849                       AFS_TRACE_LEVEL_VERBOSE,
1850                       "AFSRemoveWorkItem Removing work item %08lX Count %08lX Thread %08lX\n",
1851                       pWorkItem,
1852                       lCount,
1853                       PsGetCurrentThreadId());
1854
1855         pDevExt->Specific.Library.QueueHead = pDevExt->Specific.Library.QueueHead->next;
1856
1857         if( pDevExt->Specific.Library.QueueHead == NULL) // if queue just became empty
1858         {
1859
1860             pDevExt->Specific.Library.QueueTail = NULL;
1861         }
1862         else
1863         {
1864
1865             //
1866             // Wake up another worker
1867             //
1868
1869             KeSetEvent( &(pDevExt->Specific.Library.WorkerQueueHasItems),
1870                         0,
1871                         FALSE);
1872         }
1873     }
1874
1875     AFSReleaseResource( &pDevExt->Specific.Library.QueueLock);
1876
1877     return pWorkItem;
1878 }
1879
1880 AFSWorkItem *
1881 AFSRemoveIOWorkItem()
1882 {
1883
1884     AFSWorkItem        *pWorkItem = NULL;
1885     AFSDeviceExt *pDevExt = NULL;
1886     LONG lCount;
1887
1888     pDevExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
1889
1890     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1891                   AFS_TRACE_LEVEL_VERBOSE,
1892                   "AFSRemoveIOWorkItem Acquiring Control QueueLock lock %08lX EXCL %08lX\n",
1893                   &pDevExt->Specific.Library.IOQueueLock,
1894                   PsGetCurrentThread());
1895
1896     AFSAcquireExcl( &pDevExt->Specific.Library.IOQueueLock,
1897                     TRUE);
1898
1899     if( pDevExt->Specific.Library.IOQueueHead != NULL) // queue has nodes
1900     {
1901
1902         pWorkItem = pDevExt->Specific.Library.IOQueueHead;
1903
1904         lCount = InterlockedDecrement( &pDevExt->Specific.Library.IOQueueItemCount);
1905
1906         AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
1907                       AFS_TRACE_LEVEL_VERBOSE,
1908                       "AFSRemoveWorkItem Removing work item %08lX Count %08lX Thread %08lX\n",
1909                       pWorkItem,
1910                       lCount,
1911                       PsGetCurrentThreadId());
1912
1913         pDevExt->Specific.Library.IOQueueHead = pDevExt->Specific.Library.IOQueueHead->next;
1914
1915         if( pDevExt->Specific.Library.IOQueueHead == NULL) // if queue just became empty
1916         {
1917
1918             pDevExt->Specific.Library.IOQueueTail = NULL;
1919         }
1920         else
1921         {
1922
1923             //
1924             // Wake up another worker
1925             //
1926
1927             KeSetEvent( &(pDevExt->Specific.Library.IOWorkerQueueHasItems),
1928                         0,
1929                         FALSE);
1930         }
1931     }
1932
1933     AFSReleaseResource( &pDevExt->Specific.Library.IOQueueLock);
1934
1935     return pWorkItem;
1936 }
1937
1938 NTSTATUS
1939 AFSQueueWorkerRequest( IN AFSWorkItem *WorkItem)
1940 {
1941
1942     NTSTATUS ntStatus = STATUS_SUCCESS;
1943     BOOLEAN bWait = BooleanFlagOn( WorkItem->RequestFlags, AFS_SYNCHRONOUS_REQUEST);
1944
1945     //
1946     // Submit the work item to the worker
1947     //
1948
1949     ntStatus = AFSInsertWorkitem( WorkItem);
1950
1951     if( bWait)
1952     {
1953
1954         //
1955         // Sync request so block on the work item event
1956         //
1957
1958         ntStatus = KeWaitForSingleObject( &WorkItem->Event,
1959                                           Executive,
1960                                           KernelMode,
1961                                           FALSE,
1962                                           NULL);
1963     }
1964
1965     return ntStatus;
1966 }
1967
1968 NTSTATUS
1969 AFSQueueIOWorkerRequest( IN AFSWorkItem *WorkItem)
1970 {
1971
1972     NTSTATUS ntStatus = STATUS_SUCCESS;
1973     BOOLEAN bWait = BooleanFlagOn( WorkItem->RequestFlags, AFS_SYNCHRONOUS_REQUEST);
1974
1975     //
1976     // Submit the work item to the worker
1977     //
1978
1979     ntStatus = AFSInsertIOWorkitem( WorkItem);
1980
1981     if( bWait)
1982     {
1983
1984         //
1985         // Sync request so block on the work item event
1986         //
1987
1988         ntStatus = KeWaitForSingleObject( &WorkItem->Event,
1989                                           Executive,
1990                                           KernelMode,
1991                                           FALSE,
1992                                           NULL);
1993     }
1994
1995     return ntStatus;
1996 }
1997
1998 NTSTATUS
1999 AFSQueueWorkerRequestAtHead( IN AFSWorkItem *WorkItem)
2000 {
2001
2002     NTSTATUS ntStatus = STATUS_SUCCESS;
2003     BOOLEAN bWait = BooleanFlagOn( WorkItem->RequestFlags, AFS_SYNCHRONOUS_REQUEST);
2004
2005     //
2006     // Submit the work item to the worker
2007     //
2008
2009     ntStatus = AFSInsertWorkitemAtHead( WorkItem);
2010
2011     if( bWait)
2012     {
2013
2014         //
2015         // Sync request so block on the work item event
2016         //
2017
2018         ntStatus = KeWaitForSingleObject( &WorkItem->Event,
2019                                           Executive,
2020                                           KernelMode,
2021                                           FALSE,
2022                                           NULL);
2023     }
2024
2025     return ntStatus;
2026 }
2027
2028 NTSTATUS
2029 AFSQueueFlushExtents( IN AFSFcb *Fcb,
2030                       IN GUID *AuthGroup)
2031 {
2032
2033     NTSTATUS ntStatus = STATUS_SUCCESS;
2034     AFSDeviceExt *pRDRDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
2035     AFSWorkItem *pWorkItem = NULL;
2036     LONG lCount;
2037
2038     __try
2039     {
2040
2041         AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
2042                       AFS_TRACE_LEVEL_VERBOSE,
2043                       "AFSQueueFlushExtents Queuing request for FID %08lX-%08lX-%08lX-%08lX\n",
2044                       Fcb->ObjectInformation->FileId.Cell,
2045                       Fcb->ObjectInformation->FileId.Volume,
2046                       Fcb->ObjectInformation->FileId.Vnode,
2047                       Fcb->ObjectInformation->FileId.Unique);
2048
2049         //
2050         // Increment our flush count here just to keep the number of items in the
2051         // queue down. We'll decrement it just below.
2052         //
2053
2054         lCount = InterlockedIncrement( &Fcb->Specific.File.QueuedFlushCount);
2055
2056         if( lCount > 3)
2057         {
2058
2059             AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
2060                           AFS_TRACE_LEVEL_VERBOSE,
2061                           "AFSQueueFlushExtents Max queued items for FID %08lX-%08lX-%08lX-%08lX\n",
2062                           Fcb->ObjectInformation->FileId.Cell,
2063                           Fcb->ObjectInformation->FileId.Volume,
2064                           Fcb->ObjectInformation->FileId.Vnode,
2065                           Fcb->ObjectInformation->FileId.Unique);
2066
2067             try_return( ntStatus);
2068         }
2069
2070         if( BooleanFlagOn( pRDRDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_REDIRECTOR_SHUTDOWN))
2071         {
2072
2073             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2074                           AFS_TRACE_LEVEL_ERROR,
2075                           "AFSQueueFlushExtents Failing request, in shutdown\n");
2076
2077             try_return( ntStatus = STATUS_TOO_LATE);
2078         }
2079
2080         //
2081         // Allocate our request structure and send it to the worker
2082         //
2083
2084         pWorkItem = (AFSWorkItem *)AFSLibExAllocatePoolWithTag( NonPagedPool,
2085                                                                 sizeof( AFSWorkItem),
2086                                                                 AFS_WORK_ITEM_TAG);
2087
2088         if( pWorkItem == NULL)
2089         {
2090
2091             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2092                           AFS_TRACE_LEVEL_ERROR,
2093                           "AFSQueueFlushExtents Failed to allocate work item\n");
2094
2095             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
2096         }
2097
2098         RtlZeroMemory( pWorkItem,
2099                        sizeof( AFSWorkItem));
2100
2101         pWorkItem->Size = sizeof( AFSWorkItem);
2102
2103         pWorkItem->ProcessID = (ULONGLONG)PsGetCurrentProcessId();
2104
2105         pWorkItem->RequestType = AFS_WORK_FLUSH_FCB;
2106
2107         if ( AuthGroup == NULL)
2108         {
2109
2110             RtlZeroMemory( &pWorkItem->AuthGroup,
2111                            sizeof( GUID));
2112
2113             ntStatus = AFSRetrieveValidAuthGroup( Fcb,
2114                                                   NULL,
2115                                                   TRUE,
2116                                                   &pWorkItem->AuthGroup);
2117         }
2118         else
2119         {
2120             RtlCopyMemory( &pWorkItem->AuthGroup,
2121                            AuthGroup,
2122                            sizeof( GUID));
2123         }
2124
2125         pWorkItem->Specific.Fcb.Fcb = Fcb;
2126
2127         lCount = InterlockedIncrement( &Fcb->OpenReferenceCount);
2128
2129         AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2130                       AFS_TRACE_LEVEL_VERBOSE,
2131                       "AFSQueueFlushExtents Increment count on Fcb %08lX Cnt %d\n",
2132                       Fcb,
2133                       lCount);
2134
2135         AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
2136                       AFS_TRACE_LEVEL_VERBOSE,
2137                       "AFSQueueFlushExtents Workitem %08lX for FID %08lX-%08lX-%08lX-%08lX\n",
2138                       pWorkItem,
2139                       Fcb->ObjectInformation->FileId.Cell,
2140                       Fcb->ObjectInformation->FileId.Volume,
2141                       Fcb->ObjectInformation->FileId.Vnode,
2142                       Fcb->ObjectInformation->FileId.Unique);
2143
2144         ntStatus = AFSQueueWorkerRequest( pWorkItem);
2145
2146 try_exit:
2147
2148         AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
2149                       AFS_TRACE_LEVEL_VERBOSE,
2150                       "AFSQueueFlushExtents Request complete Status %08lX FID %08lX-%08lX-%08lX-%08lX\n",
2151                       Fcb->ObjectInformation->FileId.Cell,
2152                       Fcb->ObjectInformation->FileId.Volume,
2153                       Fcb->ObjectInformation->FileId.Vnode,
2154                       Fcb->ObjectInformation->FileId.Unique,
2155                       ntStatus);
2156
2157         //
2158         // Remove the count we added above
2159         //
2160
2161         lCount = InterlockedDecrement( &Fcb->Specific.File.QueuedFlushCount);
2162
2163         ASSERT( lCount >= 0);
2164
2165         if( lCount == 0)
2166         {
2167
2168             KeSetEvent( &Fcb->NPFcb->Specific.File.QueuedFlushEvent,
2169                         0,
2170                         FALSE);
2171         }
2172
2173         if( !NT_SUCCESS( ntStatus))
2174         {
2175
2176             if( pWorkItem != NULL)
2177             {
2178
2179                 lCount = InterlockedDecrement( &Fcb->OpenReferenceCount);
2180
2181                 ExFreePoolWithTag( pWorkItem, AFS_WORK_ITEM_TAG);
2182             }
2183
2184             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2185                           AFS_TRACE_LEVEL_ERROR,
2186                           "AFSQueueFlushExtents Failed to queue request Status %08lX\n", ntStatus);
2187         }
2188     }
2189     __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
2190     {
2191
2192         AFSDbgLogMsg( 0,
2193                       0,
2194                       "EXCEPTION - AFSQueueFlushExtents\n");
2195
2196         AFSDumpTraceFilesFnc();
2197     }
2198
2199     return ntStatus;
2200 }
2201
2202 NTSTATUS
2203 AFSQueueGlobalRootEnumeration()
2204 {
2205
2206     NTSTATUS ntStatus = STATUS_SUCCESS;
2207     AFSWorkItem *pWorkItem = NULL;
2208
2209     __try
2210     {
2211
2212         pWorkItem = (AFSWorkItem *) AFSLibExAllocatePoolWithTag( NonPagedPool,
2213                                                                  sizeof(AFSWorkItem),
2214                                                                  AFS_WORK_ITEM_TAG);
2215         if (NULL == pWorkItem)
2216         {
2217
2218             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
2219                           AFS_TRACE_LEVEL_ERROR,
2220                           "AFSQueueGlobalRootEnumeration Failed to allocate work item\n");
2221
2222             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES );
2223         }
2224
2225         RtlZeroMemory( pWorkItem,
2226                        sizeof(AFSWorkItem));
2227
2228         pWorkItem->Size = sizeof( AFSWorkItem);
2229
2230         pWorkItem->RequestType = AFS_WORK_ENUMERATE_GLOBAL_ROOT;
2231
2232         AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
2233                       AFS_TRACE_LEVEL_VERBOSE,
2234                       "AFSQueueGlobalRootEnumeration Workitem %08lX\n",
2235                       pWorkItem);
2236
2237         ntStatus = AFSQueueWorkerRequest( pWorkItem);
2238
2239 try_exit:
2240
2241         AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
2242                       AFS_TRACE_LEVEL_VERBOSE,
2243                       "AFSQueueGlobalRootEnumeration Request complete Status %08lX\n",
2244                       ntStatus);
2245
2246         if( !NT_SUCCESS( ntStatus))
2247         {
2248
2249             if( pWorkItem != NULL)
2250             {
2251
2252                 ExFreePoolWithTag( pWorkItem, AFS_WORK_ITEM_TAG);
2253             }
2254
2255             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2256                           AFS_TRACE_LEVEL_ERROR,
2257                           "AFSQueueGlobalRootEnumeration Failed to queue request Status %08lX\n",
2258                           ntStatus);
2259         }
2260     }
2261     __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
2262     {
2263
2264         AFSDbgLogMsg( 0,
2265                       0,
2266                       "EXCEPTION - AFSQueueGlobalRootEnumeration\n");
2267
2268         AFSDumpTraceFilesFnc();
2269     }
2270
2271     return ntStatus;
2272 }
2273
2274 NTSTATUS
2275 AFSQueueStartIos( IN PFILE_OBJECT CacheFileObject,
2276                   IN UCHAR FunctionCode,
2277                   IN ULONG RequestFlags,
2278                   IN AFSIoRun *IoRuns,
2279                   IN ULONG RunCount,
2280                   IN AFSGatherIo *GatherIo)
2281 {
2282
2283     NTSTATUS ntStatus = STATUS_SUCCESS;
2284     AFSDeviceExt *pRDRDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
2285     AFSWorkItem *pWorkItem = NULL;
2286
2287     __try
2288     {
2289
2290         if( BooleanFlagOn( pRDRDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_REDIRECTOR_SHUTDOWN))
2291         {
2292
2293             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2294                           AFS_TRACE_LEVEL_ERROR,
2295                           "AFSQueueStartIos Failing request, in shutdown\n");
2296
2297             try_return( ntStatus = STATUS_TOO_LATE);
2298         }
2299
2300         //
2301         // Allocate our request structure and send it to the worker
2302         //
2303
2304         pWorkItem = (AFSWorkItem *)AFSLibExAllocatePoolWithTag( NonPagedPool,
2305                                                                 sizeof( AFSWorkItem),
2306                                                                 AFS_WORK_ITEM_TAG);
2307
2308         if( pWorkItem == NULL)
2309         {
2310
2311             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2312                           AFS_TRACE_LEVEL_ERROR,
2313                           "AFSQueueStartIos Failed to allocate work item\n");
2314
2315             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
2316         }
2317
2318         RtlZeroMemory( pWorkItem,
2319                        sizeof( AFSWorkItem));
2320
2321         KeInitializeEvent( &pWorkItem->Event,
2322                            NotificationEvent,
2323                            FALSE);
2324
2325         pWorkItem->Size = sizeof( AFSWorkItem);
2326
2327         pWorkItem->ProcessID = (ULONGLONG)PsGetCurrentProcessId();
2328
2329         pWorkItem->RequestType = AFS_WORK_START_IOS;
2330
2331         pWorkItem->Specific.CacheAccess.CacheFileObject = CacheFileObject;
2332
2333         pWorkItem->Specific.CacheAccess.FunctionCode = FunctionCode;
2334
2335         pWorkItem->Specific.CacheAccess.RequestFlags = RequestFlags;
2336
2337         pWorkItem->Specific.CacheAccess.IoRuns = IoRuns;
2338
2339         pWorkItem->Specific.CacheAccess.RunCount = RunCount;
2340
2341         pWorkItem->Specific.CacheAccess.GatherIo = GatherIo;
2342
2343         AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
2344                       AFS_TRACE_LEVEL_VERBOSE,
2345                       "AFSQueueStartIos Queuing IO Workitem %08lX\n",
2346                       pWorkItem);
2347
2348         ntStatus = AFSQueueIOWorkerRequest( pWorkItem);
2349
2350 try_exit:
2351
2352         AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
2353                       AFS_TRACE_LEVEL_VERBOSE,
2354                       "AFSQueueStartIos Request complete Status %08lX\n",
2355                       ntStatus);
2356
2357         if( !NT_SUCCESS( ntStatus))
2358         {
2359
2360             if( pWorkItem != NULL)
2361             {
2362
2363                 ExFreePoolWithTag( pWorkItem, AFS_WORK_ITEM_TAG);
2364             }
2365         }
2366     }
2367     __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
2368     {
2369
2370         AFSDbgLogMsg( 0,
2371                       0,
2372                       "EXCEPTION - AFSQueueStartIos\n");
2373
2374         AFSDumpTraceFilesFnc();
2375     }
2376
2377     return ntStatus;
2378 }
2379
2380 NTSTATUS
2381 AFSQueueInvalidateObject( IN AFSObjectInfoCB *ObjectInfo,
2382                           IN ULONG InvalidateReason)
2383 {
2384
2385     NTSTATUS ntStatus = STATUS_SUCCESS;
2386     AFSWorkItem *pWorkItem = NULL;
2387
2388     __try
2389     {
2390
2391         pWorkItem = (AFSWorkItem *) AFSLibExAllocatePoolWithTag( NonPagedPool,
2392                                                                  sizeof(AFSWorkItem),
2393                                                                  AFS_WORK_ITEM_TAG);
2394         if (NULL == pWorkItem)
2395         {
2396
2397             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
2398                           AFS_TRACE_LEVEL_ERROR,
2399                           "AFSQueueInvalidateObject Failed to allocate work item\n");
2400
2401             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES );
2402         }
2403
2404         RtlZeroMemory( pWorkItem,
2405                        sizeof(AFSWorkItem));
2406
2407         pWorkItem->Size = sizeof( AFSWorkItem);
2408
2409         pWorkItem->RequestType = AFS_WORK_INVALIDATE_OBJECT;
2410
2411         pWorkItem->Specific.Invalidate.ObjectInfo = ObjectInfo;
2412
2413         pWorkItem->Specific.Invalidate.InvalidateReason = InvalidateReason;
2414
2415         AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
2416                       AFS_TRACE_LEVEL_VERBOSE,
2417                       "AFSQueueInvalidateObject Workitem %08lX\n",
2418                       pWorkItem);
2419
2420         ntStatus = AFSQueueWorkerRequest( pWorkItem);
2421
2422 try_exit:
2423
2424         AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
2425                       AFS_TRACE_LEVEL_VERBOSE,
2426                       "AFSQueueInvalidateObject Request complete Status %08lX\n",
2427                       ntStatus);
2428
2429         if( !NT_SUCCESS( ntStatus))
2430         {
2431
2432             if( pWorkItem != NULL)
2433             {
2434                 ExFreePoolWithTag( pWorkItem, AFS_WORK_ITEM_TAG);
2435             }
2436
2437             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2438                           AFS_TRACE_LEVEL_ERROR,
2439                           "AFSQueueInvalidateObject Failed to queue request Status %08lX\n",
2440                           ntStatus);
2441         }
2442     }
2443     __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
2444     {
2445
2446         AFSDbgLogMsg( 0,
2447                       0,
2448                       "EXCEPTION - AFSQueueInvalidateObject\n");
2449
2450         AFSDumpTraceFilesFnc();
2451     }
2452
2453     return ntStatus;
2454 }