src/WINNT/afsrdr/kernel/fs/AFSGeneric.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: AFSGeneric.cpp
  37 //
  38
  39 #include "AFSCommon.h"
  40
  41 //
  42 // Function: AFSExceptionFilter
  43 //
  44 // Description:
  45 //
  46 //      This function is the exception handler
  47 //
  48 // Return:
  49 //
  50 //      A status is returned for the function
  51 //
  52
  53 ULONG
  54 AFSExceptionFilter( IN ULONG Code,
  55                     IN PEXCEPTION_POINTERS ExceptPtrs)
  56 {
  57
  58     PEXCEPTION_RECORD ExceptRec;
  59     PCONTEXT Context;
  60
  61     __try
  62     {
  63
  64         ExceptRec = ExceptPtrs->ExceptionRecord;
  65
  66         Context = ExceptPtrs->ContextRecord;
  67
  68         AFSDbgLogMsg( 0,
  69                       0,
  70                       "AFSExceptionFilter (Framework) - EXR %p CXR %p Code %08lX Address %p\n",
  71                       ExceptRec,
  72                       Context,
  73                       ExceptRec->ExceptionCode,
  74                       ExceptRec->ExceptionAddress);
  75
  76         DbgPrint("**** Exception Caught in AFS Redirector ****\n");
  77
  78         DbgPrint("\n\nPerform the following WnDbg Cmds:\n");
  79         DbgPrint("\n\t.exr %p ;  .cxr %p\n\n", ExceptRec, Context);
  80
  81         DbgPrint("**** Exception Complete from AFS Redirector ****\n");
  82
  83         if( BooleanFlagOn( AFSDebugFlags, AFS_DBG_BUGCHECK_EXCEPTION))
  84         {
  85
  86             KeBugCheck( (ULONG)-2);
  87         }
  88         else
  89         {
  90
  91             AFSBreakPoint();
  92         }
  93     }
  94     __except( EXCEPTION_EXECUTE_HANDLER)
  95     {
  96
  97         NOTHING;
  98     }
  99
 100     return EXCEPTION_EXECUTE_HANDLER;
 101 }
 102
 103 //
 104 // Function: AFSAcquireExcl()
 105 //
 106 // Purpose: Called to acquire a resource exclusive with optional wait
 107 //
 108 // Parameters:
 109 //                PERESOURCE Resource - Resource to acquire
 110 //                BOOLEAN Wait - Whether to block
 111 //
 112 // Return:
 113 //                BOOLEAN - Whether the mask was acquired
 114 //
 115
 116 BOOLEAN
 117 AFSAcquireExcl( IN PERESOURCE Resource,
 118                 IN BOOLEAN wait)
 119 {
 120
 121     BOOLEAN bStatus = FALSE;
 122
 123     //
 124     // Normal kernel APCs must be disabled before calling
 125     // ExAcquireResourceExclusiveLite. Otherwise a bugcheck occurs.
 126     //
 127
 128     KeEnterCriticalRegion();
 129
 130     bStatus = ExAcquireResourceExclusiveLite( Resource,
 131                                               wait);
 132
 133     if( !bStatus)
 134     {
 135
 136         KeLeaveCriticalRegion();
 137     }
 138
 139     return bStatus;
 140 }
 141
 142 BOOLEAN
 143 AFSAcquireSharedStarveExclusive( IN PERESOURCE Resource,
 144                                  IN BOOLEAN Wait)
 145 {
 146
 147     BOOLEAN bStatus = FALSE;
 148
 149     KeEnterCriticalRegion();
 150
 151     bStatus = ExAcquireSharedStarveExclusive( Resource,
 152                                               Wait);
 153
 154     if( !bStatus)
 155     {
 156
 157         KeLeaveCriticalRegion();
 158     }
 159
 160     return bStatus;
 161 }
 162
 163 //
 164 // Function: AFSAcquireShared()
 165 //
 166 // Purpose: Called to acquire a resource shared with optional wait
 167 //
 168 // Parameters:
 169 //                PERESOURCE Resource - Resource to acquire
 170 //                BOOLEAN Wait - Whether to block
 171 //
 172 // Return:
 173 //                BOOLEAN - Whether the mask was acquired
 174 //
 175
 176 BOOLEAN
 177 AFSAcquireShared( IN PERESOURCE Resource,
 178                   IN BOOLEAN wait)
 179 {
 180
 181     BOOLEAN bStatus = FALSE;
 182
 183     KeEnterCriticalRegion();
 184
 185     bStatus = ExAcquireResourceSharedLite( Resource,
 186                                            wait);
 187
 188     if( !bStatus)
 189     {
 190
 191         KeLeaveCriticalRegion();
 192     }
 193
 194     return bStatus;
 195 }
 196
 197 //
 198 // Function: AFSReleaseResource()
 199 //
 200 // Purpose: Called to release a resource
 201 //
 202 // Parameters:
 203 //                PERESOURCE Resource - Resource to release
 204 //
 205 // Return:
 206 //                None
 207 //
 208
 209 void
 210 AFSReleaseResource( IN PERESOURCE Resource)
 211 {
 212
 213     if( Resource != &AFSDbgLogLock)
 214     {
 215
 216         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 217                       AFS_TRACE_LEVEL_VERBOSE,
 218                       "AFSReleaseResource Releasing lock %08lX Thread %08lX\n",
 219                       Resource,
 220                       PsGetCurrentThread());
 221     }
 222
 223     ExReleaseResourceLite( Resource);
 224
 225     KeLeaveCriticalRegion();
 226
 227     return;
 228 }
 229
 230 void
 231 AFSConvertToShared( IN PERESOURCE Resource)
 232 {
 233
 234     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 235                   AFS_TRACE_LEVEL_VERBOSE,
 236                   "AFSConvertToShared Converting lock %08lX Thread %08lX\n",
 237                   Resource,
 238                   PsGetCurrentThread());
 239
 240     ExConvertExclusiveToSharedLite( Resource);
 241
 242     return;
 243 }
 244
 245 //
 246 // Function: AFSCompleteRequest
 247 //
 248 // Description:
 249 //
 250 //      This function completes irps
 251 //
 252 // Return:
 253 //
 254 //      A status is returned for the function
 255 //
 256
 257 void
 258 AFSCompleteRequest( IN PIRP Irp,
 259                     IN ULONG Status)
 260 {
 261
 262     Irp->IoStatus.Status = Status;
 263
 264     IoCompleteRequest( Irp,
 265                        IO_NO_INCREMENT);
 266
 267     return;
 268 }
 269
 270 NTSTATUS
 271 AFSReadRegistry( IN PUNICODE_STRING RegistryPath)
 272 {
 273
 274     NTSTATUS ntStatus        = STATUS_SUCCESS;
 275     ULONG Default            = 0;
 276     UNICODE_STRING paramPath;
 277     ULONG Value                = 0;
 278     RTL_QUERY_REGISTRY_TABLE paramTable[2];
 279     UNICODE_STRING defaultUnicodeName;
 280     WCHAR SubKeyString[]    = L"\\Parameters";
 281
 282     //
 283     // Setup the paramPath buffer.
 284     //
 285
 286     paramPath.MaximumLength = RegistryPath->Length + sizeof( SubKeyString);
 287     paramPath.Buffer = (PWSTR)AFSExAllocatePoolWithTag( PagedPool,
 288                                                         paramPath.MaximumLength,
 289                                                         AFS_GENERIC_MEMORY_15_TAG);
 290
 291     RtlInitUnicodeString( &defaultUnicodeName,
 292                           L"NO NAME");
 293
 294     //
 295     // If it exists, setup the path.
 296     //
 297
 298     if( paramPath.Buffer != NULL)
 299     {
 300
 301         //
 302         // Move in the paths
 303         //
 304
 305         RtlCopyMemory( &paramPath.Buffer[ 0],
 306                        &RegistryPath->Buffer[ 0],
 307                        RegistryPath->Length);
 308
 309         RtlCopyMemory( &paramPath.Buffer[ RegistryPath->Length / 2],
 310                        SubKeyString,
 311                        sizeof( SubKeyString));
 312
 313         paramPath.Length = paramPath.MaximumLength;
 314
 315         RtlZeroMemory( paramTable,
 316                        sizeof( paramTable));
 317
 318         Value = 0;
 319
 320         //
 321         // Setup the table to query the registry for the needed value
 322         //
 323
 324         paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
 325         paramTable[0].Name = AFS_REG_DEBUG_FLAGS;
 326         paramTable[0].EntryContext = &Value;
 327
 328         paramTable[0].DefaultType = REG_DWORD;
 329         paramTable[0].DefaultData = &Default;
 330         paramTable[0].DefaultLength = sizeof (ULONG) ;
 331
 332         //
 333         // Query the registry
 334         //
 335
 336         ntStatus = RtlQueryRegistryValues( RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
 337                                            paramPath.Buffer,
 338                                            paramTable,
 339                                            NULL,
 340                                            NULL);
 341
 342         if( NT_SUCCESS( ntStatus))
 343         {
 344
 345             AFSDebugFlags = Value;
 346         }
 347
 348         RtlZeroMemory( paramTable,
 349                        sizeof( paramTable));
 350
 351         Value = 0;
 352
 353         //
 354         // Setup the table to query the registry for the needed value
 355         //
 356
 357         paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
 358         paramTable[0].Name = AFS_REG_TRACE_SUBSYSTEM;
 359         paramTable[0].EntryContext = &Value;
 360
 361         paramTable[0].DefaultType = REG_DWORD;
 362         paramTable[0].DefaultData = &Default;
 363         paramTable[0].DefaultLength = sizeof (ULONG) ;
 364
 365         //
 366         // Query the registry
 367         //
 368
 369         ntStatus = RtlQueryRegistryValues( RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
 370                                            paramPath.Buffer,
 371                                            paramTable,
 372                                            NULL,
 373                                            NULL);
 374
 375         if( NT_SUCCESS( ntStatus))
 376         {
 377
 378             AFSTraceComponent = Value;
 379         }
 380
 381         RtlZeroMemory( paramTable,
 382                        sizeof( paramTable));
 383
 384         Value = 0;
 385
 386         //
 387         // Setup the table to query the registry for the needed value
 388         //
 389
 390         paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
 391         paramTable[0].Name = AFS_REG_TRACE_BUFFER_LENGTH;
 392         paramTable[0].EntryContext = &Value;
 393
 394         paramTable[0].DefaultType = REG_DWORD;
 395         paramTable[0].DefaultData = &Default;
 396         paramTable[0].DefaultLength = sizeof (ULONG);
 397
 398         //
 399         // Query the registry
 400         //
 401
 402         ntStatus = RtlQueryRegistryValues( RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
 403                                            paramPath.Buffer,
 404                                            paramTable,
 405                                            NULL,
 406                                            NULL);
 407
 408         if( NT_SUCCESS( ntStatus) &&
 409             Value > 0)
 410         {
 411
 412             AFSDbgBufferLength = Value;
 413
 414             //
 415             // Let's limit things a bit ...
 416             //
 417
 418             if( AFSDbgBufferLength > 10240)
 419             {
 420
 421                 AFSDbgBufferLength = 1024;
 422             }
 423         }
 424         else
 425         {
 426
 427             AFSDbgBufferLength = 0;
 428         }
 429
 430         //
 431         // Make it bytes
 432         //
 433
 434         AFSDbgBufferLength *= 1024;
 435
 436         //
 437         // Now get ready to set up for MaxServerDirty
 438         //
 439
 440         paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
 441         paramTable[0].Name = AFS_REG_MAX_DIRTY;
 442         paramTable[0].EntryContext = &Value;
 443
 444         paramTable[0].DefaultType = REG_DWORD;
 445         paramTable[0].DefaultData = &Default;
 446         paramTable[0].DefaultLength = sizeof (ULONG) ;
 447
 448         //
 449         // Query the registry
 450         //
 451
 452         ntStatus = RtlQueryRegistryValues( RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
 453                                            paramPath.Buffer,
 454                                            paramTable,
 455                                            NULL,
 456                                            NULL);
 457
 458         if( NT_SUCCESS( ntStatus))
 459         {
 460
 461             AFSMaxDirtyFile = Value;
 462         }
 463
 464         RtlZeroMemory( paramTable,
 465                        sizeof( paramTable));
 466
 467         Value = 0;
 468
 469         //
 470         // Setup the table to query the registry for the needed value
 471         //
 472
 473         paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
 474         paramTable[0].Name = AFS_REG_TRACE_LEVEL;
 475         paramTable[0].EntryContext = &Value;
 476
 477         paramTable[0].DefaultType = REG_DWORD;
 478         paramTable[0].DefaultData = &Default;
 479         paramTable[0].DefaultLength = sizeof (ULONG) ;
 480
 481         //
 482         // Query the registry
 483         //
 484
 485         ntStatus = RtlQueryRegistryValues( RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
 486                                            paramPath.Buffer,
 487                                            paramTable,
 488                                            NULL,
 489                                            NULL);
 490
 491         if( NT_SUCCESS( ntStatus))
 492         {
 493
 494             AFSTraceLevel = Value;
 495         }
 496
 497         //
 498         // MaxIO
 499         //
 500
 501         paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
 502         paramTable[0].Name = AFS_REG_MAX_IO;
 503         paramTable[0].EntryContext = &Value;
 504
 505         paramTable[0].DefaultType = REG_DWORD;
 506         paramTable[0].DefaultData = &Default;
 507         paramTable[0].DefaultLength = sizeof (ULONG) ;
 508
 509         //
 510         // Query the registry
 511         //
 512
 513         ntStatus = RtlQueryRegistryValues( RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
 514                                            paramPath.Buffer,
 515                                            paramTable,
 516                                            NULL,
 517                                            NULL);
 518
 519         if( NT_SUCCESS( ntStatus))
 520         {
 521
 522             AFSMaxDirectIo = Value;
 523         }
 524
 525         //
 526         // Now set up for ShutdownStatus query
 527         //
 528
 529         paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
 530         paramTable[0].Name = AFS_REG_SHUTDOWN_STATUS;
 531         paramTable[0].EntryContext = &Value;
 532
 533         paramTable[0].DefaultType = REG_DWORD;
 534         paramTable[0].DefaultData = &Default;
 535         paramTable[0].DefaultLength = sizeof (ULONG) ;
 536
 537         //
 538         // Query the registry
 539         //
 540
 541         ntStatus = RtlQueryRegistryValues( RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
 542                                            paramPath.Buffer,
 543                                            paramTable,
 544                                            NULL,
 545                                            NULL);
 546
 547         if( !NT_SUCCESS( ntStatus) ||
 548             Value != (ULONG)-1)
 549         {
 550
 551             SetFlag( AFSDebugFlags, AFS_DBG_CLEAN_SHUTDOWN);
 552         }
 553
 554         //
 555         // Now set up for RequireCleanShutdown query
 556         //
 557
 558         paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
 559         paramTable[0].Name = AFS_REG_REQUIRE_CLEAN_SHUTDOWN;
 560         paramTable[0].EntryContext = &Value;
 561
 562         paramTable[0].DefaultType = REG_DWORD;
 563         paramTable[0].DefaultData = &Default;
 564         paramTable[0].DefaultLength = sizeof (ULONG) ;
 565
 566         //
 567         // Query the registry
 568         //
 569
 570         ntStatus = RtlQueryRegistryValues( RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
 571                                            paramPath.Buffer,
 572                                            paramTable,
 573                                            NULL,
 574                                            NULL);
 575
 576         if( !NT_SUCCESS( ntStatus) ||
 577             Value != 0L)
 578         {
 579
 580             SetFlag( AFSDebugFlags, AFS_DBG_REQUIRE_CLEAN_SHUTDOWN);
 581         }
 582
 583         //
 584         // Free up the buffer
 585         //
 586
 587         ExFreePool( paramPath.Buffer);
 588
 589         ntStatus = STATUS_SUCCESS;
 590     }
 591     else
 592     {
 593         ntStatus = STATUS_INSUFFICIENT_RESOURCES;
 594     }
 595
 596     return ntStatus;
 597 }
 598
 599 NTSTATUS
 600 AFSUpdateRegistryParameter( IN PUNICODE_STRING ValueName,
 601                             IN ULONG ValueType,
 602                             IN void *ValueData,
 603                             IN ULONG ValueDataLength)
 604 {
 605
 606     NTSTATUS ntStatus        = STATUS_SUCCESS;
 607     UNICODE_STRING paramPath, uniParamKey;
 608     HANDLE hParameters = 0;
 609     ULONG ulDisposition = 0;
 610     OBJECT_ATTRIBUTES stObjectAttributes;
 611
 612     __Enter
 613     {
 614
 615         RtlInitUnicodeString( &uniParamKey,
 616                               L"\\Parameters");
 617
 618         //
 619         // Setup the paramPath buffer.
 620         //
 621
 622         paramPath.MaximumLength = AFSRegistryPath.Length + uniParamKey.Length;
 623         paramPath.Buffer = (PWSTR)AFSExAllocatePoolWithTag( PagedPool,
 624                                                             paramPath.MaximumLength,
 625                                                             AFS_GENERIC_MEMORY_16_TAG);
 626
 627         if( paramPath.Buffer == NULL)
 628         {
 629
 630             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 631         }
 632
 633         //
 634         // Move in the paths
 635         //
 636
 637         RtlCopyMemory( paramPath.Buffer,
 638                        AFSRegistryPath.Buffer,
 639                        AFSRegistryPath.Length);
 640
 641         paramPath.Length = AFSRegistryPath.Length;
 642
 643         RtlCopyMemory( &paramPath.Buffer[ paramPath.Length / 2],
 644                        uniParamKey.Buffer,
 645                        uniParamKey.Length);
 646
 647         paramPath.Length += uniParamKey.Length;
 648
 649         InitializeObjectAttributes( &stObjectAttributes,
 650                                     &paramPath,
 651                                     OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
 652                                     NULL,
 653                                     NULL);
 654
 655         ntStatus = ZwOpenKey( &hParameters,
 656                               KEY_ALL_ACCESS,
 657                               &stObjectAttributes);
 658
 659         if( !NT_SUCCESS( ntStatus))
 660         {
 661
 662             try_return( ntStatus);
 663         }
 664
 665         //
 666         // Set the value
 667         //
 668
 669         ntStatus = ZwSetValueKey( hParameters,
 670                                   ValueName,
 671                                   0,
 672                                   ValueType,
 673                                   ValueData,
 674                                   ValueDataLength);
 675
 676         ZwClose( hParameters);
 677
 678 try_exit:
 679
 680         if( paramPath.Buffer != NULL)
 681         {
 682
 683             //
 684             // Free up the buffer
 685             //
 686
 687             ExFreePool( paramPath.Buffer);
 688         }
 689     }
 690
 691     return ntStatus;
 692 }
 693
 694 NTSTATUS
 695 AFSInitializeControlDevice()
 696 {
 697
 698     NTSTATUS ntStatus = STATUS_SUCCESS;
 699     AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSDeviceObject->DeviceExtension;
 700     AFSProcessCB *pProcessCB = NULL;
 701
 702     __Enter
 703     {
 704
 705         //
 706         // Initialize the comm pool resources
 707         //
 708
 709         ExInitializeResourceLite( &pDeviceExt->Specific.Control.CommServiceCB.IrpPoolLock);
 710
 711         ExInitializeResourceLite( &pDeviceExt->Specific.Control.CommServiceCB.ResultPoolLock);
 712
 713         ExInitializeResourceLite( &pDeviceExt->Specific.Control.ExtentReleaseResource);
 714
 715         ExInitializeResourceLite( &pDeviceExt->Specific.Control.SysName32ListLock);
 716
 717         ExInitializeResourceLite( &pDeviceExt->Specific.Control.SysName64ListLock);
 718
 719         //
 720         // And the events
 721         //
 722
 723         KeInitializeEvent( &pDeviceExt->Specific.Control.CommServiceCB.IrpPoolHasEntries,
 724                            NotificationEvent,
 725                            FALSE);
 726
 727         KeInitializeEvent( &pDeviceExt->Specific.Control.CommServiceCB.IrpPoolHasReleaseEntries,
 728                            NotificationEvent,
 729                            FALSE);
 730
 731         KeInitializeEvent( &pDeviceExt->Specific.Control.ExtentReleaseEvent,
 732                            NotificationEvent,
 733                            FALSE);
 734
 735         pDeviceExt->Specific.Control.ExtentReleaseSequence = 0;
 736
 737         KeInitializeEvent( &pDeviceExt->Specific.Control.VolumeWorkerCloseEvent,
 738                            NotificationEvent,
 739                            TRUE);
 740
 741         //
 742         // Library support information
 743         //
 744
 745         KeInitializeEvent( &pDeviceExt->Specific.Control.LoadLibraryEvent,
 746                            SynchronizationEvent,
 747                            TRUE);
 748
 749         //
 750         // Initialize the library queued as cancelled
 751         //
 752
 753         pDeviceExt->Specific.Control.LibraryState = AFS_LIBRARY_QUEUE_CANCELLED;
 754
 755         ExInitializeResourceLite( &pDeviceExt->Specific.Control.LibraryStateLock);
 756
 757         pDeviceExt->Specific.Control.InflightLibraryRequests = 0;
 758
 759         KeInitializeEvent( &pDeviceExt->Specific.Control.InflightLibraryEvent,
 760                            NotificationEvent,
 761                            FALSE);
 762
 763         pDeviceExt->Specific.Control.ExtentCount = 0;
 764         pDeviceExt->Specific.Control.ExtentsHeldLength = 0;
 765
 766         KeInitializeEvent( &pDeviceExt->Specific.Control.ExtentsHeldEvent,
 767                            NotificationEvent,
 768                            TRUE);
 769
 770         pDeviceExt->Specific.Control.OutstandingServiceRequestCount = 0;
 771
 772         KeInitializeEvent( &pDeviceExt->Specific.Control.OutstandingServiceRequestEvent,
 773                            NotificationEvent,
 774                            TRUE);
 775
 776         ExInitializeResourceLite( &pDeviceExt->Specific.Control.LibraryQueueLock);
 777
 778         pDeviceExt->Specific.Control.LibraryQueueHead = NULL;
 779
 780         pDeviceExt->Specific.Control.LibraryQueueTail = NULL;
 781
 782         //
 783         // Set the initial state of the irp pool
 784         //
 785
 786         pDeviceExt->Specific.Control.CommServiceCB.IrpPoolControlFlag = POOL_INACTIVE;
 787
 788         //
 789         // Initialize our process and sid tree information
 790         //
 791
 792         ExInitializeResourceLite( &pDeviceExt->Specific.Control.ProcessTreeLock);
 793
 794         pDeviceExt->Specific.Control.ProcessTree.TreeLock = &pDeviceExt->Specific.Control.ProcessTreeLock;
 795
 796         pDeviceExt->Specific.Control.ProcessTree.TreeHead = NULL;
 797
 798         ExInitializeResourceLite( &pDeviceExt->Specific.Control.AuthGroupTreeLock);
 799
 800         pDeviceExt->Specific.Control.AuthGroupTree.TreeLock = &pDeviceExt->Specific.Control.AuthGroupTreeLock;
 801
 802         pDeviceExt->Specific.Control.AuthGroupTree.TreeHead = NULL;
 803     }
 804
 805     return ntStatus;
 806 }
 807
 808 NTSTATUS
 809 AFSRemoveControlDevice()
 810 {
 811
 812     NTSTATUS ntStatus = STATUS_SUCCESS;
 813     AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSDeviceObject->DeviceExtension;
 814     AFSProcessCB *pProcessCB = NULL;
 815
 816     __Enter
 817     {
 818
 819         //
 820         // Initialize the comm pool resources
 821         //
 822
 823         ExDeleteResourceLite( &pDeviceExt->Specific.Control.CommServiceCB.IrpPoolLock);
 824
 825         ExDeleteResourceLite( &pDeviceExt->Specific.Control.CommServiceCB.ResultPoolLock);
 826
 827         ExDeleteResourceLite( &pDeviceExt->Specific.Control.ExtentReleaseResource);
 828
 829         ExDeleteResourceLite( &pDeviceExt->Specific.Control.SysName32ListLock);
 830
 831         ExDeleteResourceLite( &pDeviceExt->Specific.Control.SysName64ListLock);
 832
 833         ExDeleteResourceLite( &pDeviceExt->Specific.Control.ProcessTreeLock);
 834
 835         if( pDeviceExt->Specific.Control.ProcessTree.TreeHead != NULL)
 836         {
 837             ExFreePool( pDeviceExt->Specific.Control.ProcessTree.TreeHead);
 838         }
 839
 840         ExDeleteResourceLite( &pDeviceExt->Specific.Control.AuthGroupTreeLock);
 841
 842         ExDeleteResourceLite( &pDeviceExt->Specific.Control.LibraryStateLock);
 843
 844         ExDeleteResourceLite( &pDeviceExt->Specific.Control.LibraryQueueLock);
 845     }
 846
 847     return ntStatus;
 848 }
 849
 850 void
 851 AFSInitServerStrings()
 852 {
 853
 854     UNICODE_STRING uniFullName;
 855     WCHAR wchBuffer[ 50];
 856
 857     //
 858     // Add the server name into the list of resources
 859     //
 860
 861     uniFullName.Length = (2 * sizeof( WCHAR)) + AFSServerName.Length;
 862     uniFullName.MaximumLength = uniFullName.Length + sizeof( WCHAR);
 863
 864     uniFullName.Buffer = wchBuffer;
 865
 866     wchBuffer[ 0] = L'\\';
 867     wchBuffer[ 1] = L'\\';
 868
 869     RtlCopyMemory( &wchBuffer[ 2],
 870                    AFSServerName.Buffer,
 871                    AFSServerName.Length);
 872
 873     AFSAddConnectionEx( &uniFullName,
 874                         RESOURCEDISPLAYTYPE_SERVER,
 875                         0);
 876
 877     //
 878     // Add in the global share name
 879     //
 880
 881     wchBuffer[ uniFullName.Length/sizeof( WCHAR)] = L'\\';
 882
 883     uniFullName.Length += sizeof( WCHAR);
 884
 885     RtlCopyMemory( &wchBuffer[ uniFullName.Length/sizeof( WCHAR)],
 886                    AFSGlobalRootName.Buffer,
 887                    AFSGlobalRootName.Length);
 888
 889     uniFullName.Length += AFSGlobalRootName.Length;
 890
 891     AFSAddConnectionEx( &uniFullName,
 892                         RESOURCEDISPLAYTYPE_SHARE,
 893                         AFS_CONNECTION_FLAG_GLOBAL_SHARE);
 894
 895     return;
 896 }
 897
 898 NTSTATUS
 899 AFSReadServerName()
 900 {
 901
 902     NTSTATUS ntStatus        = STATUS_SUCCESS;
 903     ULONG Default            = 0;
 904     UNICODE_STRING paramPath;
 905     RTL_QUERY_REGISTRY_TABLE paramTable[2];
 906
 907     __Enter
 908     {
 909
 910         //
 911         // Setup the paramPath buffer.
 912         //
 913
 914         paramPath.MaximumLength = PAGE_SIZE;
 915         paramPath.Buffer = (PWSTR)AFSExAllocatePoolWithTag( PagedPool,
 916                                                             paramPath.MaximumLength,
 917                                                             AFS_GENERIC_MEMORY_17_TAG);
 918
 919         //
 920         // If it exists, setup the path.
 921         //
 922
 923         if( paramPath.Buffer == NULL)
 924         {
 925
 926             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 927         }
 928
 929         //
 930         // Move in the paths
 931         //
 932
 933         RtlZeroMemory( paramPath.Buffer,
 934                        paramPath.MaximumLength);
 935
 936         RtlCopyMemory( &paramPath.Buffer[ 0],
 937                        L"\\TransarcAFSDaemon\\Parameters",
 938                        58);
 939
 940         paramPath.Length = 58;
 941
 942         RtlZeroMemory( paramTable,
 943                        sizeof( paramTable));
 944
 945         //
 946         // Setup the table to query the registry for the needed value
 947         //
 948
 949         AFSServerName.Length = 0;
 950         AFSServerName.MaximumLength = 0;
 951         AFSServerName.Buffer = NULL;
 952
 953         paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
 954         paramTable[0].Name = AFS_NETBIOS_NAME;
 955         paramTable[0].EntryContext = &AFSServerName;
 956
 957         paramTable[0].DefaultType = REG_NONE;
 958         paramTable[0].DefaultData = NULL;
 959         paramTable[0].DefaultLength = 0;
 960
 961         //
 962         // Query the registry
 963         //
 964
 965         ntStatus = RtlQueryRegistryValues( RTL_REGISTRY_SERVICES,
 966                                            paramPath.Buffer,
 967                                            paramTable,
 968                                            NULL,
 969                                            NULL);
 970
 971         //
 972         // Free up the buffer
 973         //
 974
 975         ExFreePool( paramPath.Buffer);
 976
 977 try_exit:
 978
 979         if( !NT_SUCCESS( ntStatus))
 980         {
 981
 982             RtlInitUnicodeString( &AFSServerName,
 983                                   L"AFS");
 984         }
 985     }
 986
 987     return ntStatus;
 988 }
 989
 990 NTSTATUS
 991 AFSSetSysNameInformation( IN AFSSysNameNotificationCB *SysNameInfo,
 992                           IN ULONG SysNameInfoBufferLength)
 993 {
 994
 995     NTSTATUS         ntStatus = STATUS_SUCCESS;
 996     AFSDeviceExt    *pControlDevExt = (AFSDeviceExt *)AFSDeviceObject->DeviceExtension;
 997     AFSSysNameCB    *pSysName = NULL;
 998     ERESOURCE       *pSysNameLock = NULL;
 999     AFSSysNameCB   **pSysNameListHead = NULL, **pSysNameListTail = NULL;
1000     ULONG            ulIndex = 0;
1001     __Enter
1002     {
1003
1004         //
1005         // Depending on the architecture of the information, set up the lsit
1006         //
1007
1008         if( SysNameInfo->Architecture == AFS_SYSNAME_ARCH_32BIT)
1009         {
1010
1011             pSysNameLock = &pControlDevExt->Specific.Control.SysName32ListLock;
1012
1013             pSysNameListHead = &pControlDevExt->Specific.Control.SysName32ListHead;
1014
1015             pSysNameListTail = &pControlDevExt->Specific.Control.SysName32ListTail;
1016         }
1017         else
1018         {
1019
1020 #if defined(_WIN64)
1021
1022             pSysNameLock = &pControlDevExt->Specific.Control.SysName64ListLock;
1023
1024             pSysNameListHead = &pControlDevExt->Specific.Control.SysName64ListHead;
1025
1026             pSysNameListTail = &pControlDevExt->Specific.Control.SysName64ListTail;
1027
1028 #else
1029
1030             try_return( ntStatus = STATUS_INVALID_PARAMETER);
1031 #endif
1032         }
1033
1034         //
1035         // Process the request
1036         //
1037
1038         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1039                       AFS_TRACE_LEVEL_VERBOSE,
1040                       "AFSSetSysNameInformation Acquiring SysName lock %08lX EXCL %08lX\n",
1041                       pSysNameLock,
1042                       PsGetCurrentThread());
1043
1044         AFSAcquireExcl( pSysNameLock,
1045                         TRUE);
1046
1047         //
1048         // If we already have a list, then tear it down
1049         //
1050
1051         if( *pSysNameListHead != NULL)
1052         {
1053
1054             AFSResetSysNameList( *pSysNameListHead);
1055
1056             *pSysNameListHead = NULL;
1057         }
1058
1059         //
1060         // Loop through the entries adding in a node for each
1061         //
1062
1063         while( ulIndex < SysNameInfo->NumberOfNames)
1064         {
1065
1066             pSysName = (AFSSysNameCB *)AFSExAllocatePoolWithTag( PagedPool,
1067                                                                  sizeof( AFSSysNameCB) +
1068                                                                  SysNameInfo->SysNames[ ulIndex].Length +
1069                                                                  sizeof( WCHAR),
1070                                                                  AFS_SYS_NAME_NODE_TAG);
1071
1072             if( pSysName == NULL)
1073             {
1074
1075                 //
1076                 // Reset the current list
1077                 //
1078
1079                 AFSResetSysNameList( *pSysNameListHead);
1080
1081                 *pSysNameListHead = NULL;
1082
1083                 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
1084             }
1085
1086             RtlZeroMemory( pSysName,
1087                            sizeof( AFSSysNameCB) +
1088                                    SysNameInfo->SysNames[ ulIndex].Length +
1089                                    sizeof( WCHAR));
1090
1091             pSysName->SysName.Length = (USHORT)SysNameInfo->SysNames[ ulIndex].Length;
1092
1093             pSysName->SysName.MaximumLength = pSysName->SysName.Length + sizeof( WCHAR);
1094
1095             pSysName->SysName.Buffer = (WCHAR *)((char *)pSysName + sizeof( AFSSysNameCB));
1096
1097             RtlCopyMemory( pSysName->SysName.Buffer,
1098                            SysNameInfo->SysNames[ ulIndex].String,
1099                            pSysName->SysName.Length);
1100
1101             if( *pSysNameListHead == NULL)
1102             {
1103
1104                 *pSysNameListHead = pSysName;
1105             }
1106             else
1107             {
1108
1109                 (*pSysNameListTail)->fLink = pSysName;
1110             }
1111
1112             *pSysNameListTail = pSysName;
1113
1114             ulIndex++;
1115         }
1116
1117 try_exit:
1118
1119         AFSReleaseResource( pSysNameLock);
1120     }
1121
1122     return ntStatus;
1123 }
1124
1125 void
1126 AFSResetSysNameList( IN AFSSysNameCB *SysNameList)
1127 {
1128
1129     AFSSysNameCB *pNextEntry = NULL, *pCurrentEntry = SysNameList;
1130
1131     while( pCurrentEntry != NULL)
1132     {
1133
1134         pNextEntry = pCurrentEntry->fLink;
1135
1136         ExFreePool( pCurrentEntry);
1137
1138         pCurrentEntry = pNextEntry;
1139     }
1140
1141     return;
1142 }
1143
1144 NTSTATUS
1145 AFSDefaultDispatch( IN PDEVICE_OBJECT DeviceObject,
1146                     IN PIRP Irp)
1147 {
1148
1149     NTSTATUS            ntStatus = STATUS_INVALID_DEVICE_REQUEST;
1150     PIO_STACK_LOCATION  pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1151
1152     AFSCompleteRequest( Irp,
1153                         ntStatus);
1154
1155     return ntStatus;
1156 }
1157
1158 NTSTATUS
1159 AFSSendDeviceIoControl( IN DEVICE_OBJECT *TargetDeviceObject,
1160                         IN ULONG IOControl,
1161                         IN void *InputBuffer,
1162                         IN ULONG InputBufferLength,
1163                         IN OUT void *OutputBuffer,
1164                         IN ULONG OutputBufferLength,
1165                         OUT ULONG *ResultLength)
1166 {
1167
1168     NTSTATUS            ntStatus = STATUS_SUCCESS;
1169     PIRP                pIrp = NULL;
1170     KEVENT              kEvent;
1171     PIO_STACK_LOCATION  pIoStackLocation = NULL;
1172
1173     __Enter
1174     {
1175
1176         //
1177         // Initialize the event
1178         //
1179
1180         KeInitializeEvent( &kEvent,
1181                            SynchronizationEvent,
1182                            FALSE);
1183
1184         //
1185         // Allocate an irp for this request.  This could also come from a
1186         // private pool, for instance.
1187         //
1188
1189         pIrp = IoAllocateIrp( TargetDeviceObject->StackSize,
1190                               FALSE);
1191
1192         if( pIrp == NULL)
1193         {
1194
1195             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
1196         }
1197
1198         //
1199         // Build the IRP's main body
1200         //
1201
1202         pIrp->RequestorMode = KernelMode;
1203
1204         //
1205         // Set up the I/O stack location.
1206         //
1207
1208         pIoStackLocation = IoGetNextIrpStackLocation( pIrp);
1209         pIoStackLocation->MajorFunction = IRP_MJ_DEVICE_CONTROL;
1210         pIoStackLocation->DeviceObject = TargetDeviceObject;
1211
1212         pIoStackLocation->Parameters.DeviceIoControl.IoControlCode = IOControl;
1213
1214         pIrp->AssociatedIrp.SystemBuffer = (void *)InputBuffer;
1215         pIoStackLocation->Parameters.DeviceIoControl.InputBufferLength = InputBufferLength;
1216
1217         //
1218         // Set the completion routine.
1219         //
1220
1221         IoSetCompletionRoutine( pIrp,
1222                                 AFSIrpComplete,
1223                                 &kEvent,
1224                                 TRUE,
1225                                 TRUE,
1226                                 TRUE);
1227
1228         //
1229         // Send it to the FSD
1230         //
1231
1232         ntStatus = IoCallDriver( TargetDeviceObject,
1233                                  pIrp);
1234
1235         if( NT_SUCCESS( ntStatus))
1236         {
1237
1238             //
1239             // Wait for the I/O
1240             //
1241
1242             ntStatus = KeWaitForSingleObject( &kEvent,
1243                                               Executive,
1244                                               KernelMode,
1245                                               FALSE,
1246                                               0);
1247
1248             if( NT_SUCCESS( ntStatus))
1249             {
1250
1251                 ntStatus = pIrp->IoStatus.Status;
1252
1253                 if( ResultLength != NULL)
1254                 {
1255                     *ResultLength = (ULONG)pIrp->IoStatus.Information;
1256                 }
1257             }
1258         }
1259
1260 try_exit:
1261
1262         if( pIrp != NULL)
1263         {
1264
1265             if( pIrp->MdlAddress != NULL)
1266             {
1267
1268                 if( FlagOn( pIrp->MdlAddress->MdlFlags, MDL_PAGES_LOCKED))
1269                 {
1270
1271                     MmUnlockPages( pIrp->MdlAddress);
1272                 }
1273
1274                 IoFreeMdl( pIrp->MdlAddress);
1275             }
1276
1277             pIrp->MdlAddress = NULL;
1278
1279             //
1280             // Free the Irp
1281             //
1282
1283             IoFreeIrp( pIrp);
1284         }
1285     }
1286
1287     return ntStatus;
1288 }
1289
1290 NTSTATUS
1291 AFSIrpComplete( IN PDEVICE_OBJECT DeviceObject,
1292                 IN PIRP           Irp,
1293                 IN PVOID          Context)
1294 {
1295
1296     KEVENT *pEvent = (KEVENT *)Context;
1297
1298     KeSetEvent( pEvent,
1299                 0,
1300                 FALSE);
1301
1302     return STATUS_MORE_PROCESSING_REQUIRED;
1303 }
1304
1305 void *
1306 AFSExAllocatePoolWithTag( IN POOL_TYPE  PoolType,
1307                           IN SIZE_T  NumberOfBytes,
1308                           IN ULONG  Tag)
1309 {
1310
1311     void *pBuffer = NULL;
1312
1313     pBuffer = ExAllocatePoolWithTag( PoolType,
1314                                      NumberOfBytes,
1315                                      Tag);
1316
1317     if( pBuffer == NULL)
1318     {
1319
1320         if( BooleanFlagOn( AFSDebugFlags, AFS_DBG_BUGCHECK_EXCEPTION))
1321         {
1322
1323             KeBugCheck( (ULONG)-2);
1324         }
1325         else
1326         {
1327
1328             AFSDbgLogMsg( 0,
1329                           0,
1330                           "AFSExAllocatePoolWithTag failure Type %08lX Size %08lX Tag %08lX %08lX\n",
1331                           PoolType,
1332                           NumberOfBytes,
1333                           Tag,
1334                           PsGetCurrentThread());
1335
1336             switch ( Tag ) {
1337
1338             case AFS_GENERIC_MEMORY_21_TAG:
1339             case AFS_GENERIC_MEMORY_22_TAG:
1340                 // AFSDumpTraceFiles -- do nothing;
1341                 break;
1342
1343             default:
1344                 AFSBreakPoint();
1345             }
1346         }
1347     }
1348
1349     return pBuffer;
1350 }
1351
1352 void
1353 AFSExFreePool( IN void *Buffer)
1354 {
1355
1356     ExFreePool( Buffer);
1357
1358     return;
1359 }
1360
1361 NTSTATUS
1362 AFSShutdownRedirector()
1363 {
1364
1365     NTSTATUS ntStatus = STATUS_SUCCESS;
1366     AFSDeviceExt *pRDRDevExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
1367     AFSDeviceExt *pControlDevExt = (AFSDeviceExt *)AFSDeviceObject->DeviceExtension;
1368     LARGE_INTEGER liTimeout;
1369
1370     __Enter
1371     {
1372
1373         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1374                       AFS_TRACE_LEVEL_VERBOSE,
1375                       "%s Shutting down redirector Extent count %08lX Request count %08lX\n",
1376                                 __FUNCTION__,
1377                                 pControlDevExt->Specific.Control.ExtentCount,
1378                                 pControlDevExt->Specific.Control.OutstandingServiceRequestCount);
1379
1380         //
1381         // Set the shutdown flag so the worker is more agressive in tearing down extents
1382         //
1383
1384         SetFlag( pRDRDevExt->DeviceFlags, AFS_DEVICE_FLAG_REDIRECTOR_SHUTDOWN);
1385
1386         //
1387         // Wait on any outstanding service requests
1388         //
1389
1390         liTimeout.QuadPart = -(30 *AFS_ONE_SECOND);
1391
1392         ntStatus = KeWaitForSingleObject( &pControlDevExt->Specific.Control.OutstandingServiceRequestEvent,
1393                                           Executive,
1394                                           KernelMode,
1395                                           FALSE,
1396                                           &liTimeout);
1397
1398         if( ntStatus == STATUS_TIMEOUT)
1399         {
1400
1401             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1402                           AFS_TRACE_LEVEL_WARNING,
1403                               "AFSShutdownRedirector Failed to complete all service requests Remaining count %08lX\n",
1404                                                     pControlDevExt->Specific.Control.OutstandingServiceRequestCount);
1405
1406             try_return( ntStatus = STATUS_UNSUCCESSFUL);
1407         }
1408
1409         AFSProcessQueuedResults( TRUE);
1410
1411         //
1412         // Wait for all extents to be released
1413         //
1414
1415         liTimeout.QuadPart = -(30 *AFS_ONE_SECOND);
1416
1417         ntStatus = KeWaitForSingleObject( &pControlDevExt->Specific.Control.ExtentsHeldEvent,
1418                                           Executive,
1419                                           KernelMode,
1420                                           FALSE,
1421                                           &liTimeout);
1422
1423         if( ntStatus == STATUS_TIMEOUT)
1424         {
1425
1426             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1427                           AFS_TRACE_LEVEL_WARNING,
1428                               "AFSShutdownRedirector Failed to purge all extents Remaining count %08lX\n",
1429                                                     pControlDevExt->Specific.Control.ExtentCount);
1430
1431             try_return( ntStatus = STATUS_UNSUCCESSFUL);
1432         }
1433
1434         ntStatus = AFSUnloadLibrary( TRUE);
1435
1436         if( !NT_SUCCESS( ntStatus))
1437         {
1438
1439             try_return( ntStatus);
1440         }
1441
1442 try_exit:
1443
1444         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1445                       AFS_TRACE_LEVEL_VERBOSE,
1446                       "%s Completed shut down of redirector Extent count %08lX Request count %08lX Status %08lX\n",
1447                                 __FUNCTION__,
1448                                 pControlDevExt->Specific.Control.ExtentCount,
1449                                 pControlDevExt->Specific.Control.OutstandingServiceRequestCount,
1450                                 ntStatus);
1451     }
1452
1453     return ntStatus;
1454 }
1455
1456 //
1457 // Cache manager callback routines
1458 //
1459
1460 BOOLEAN
1461 AFSAcquireFcbForLazyWrite( IN PVOID Fcb,
1462                            IN BOOLEAN Wait)
1463 {
1464
1465     BOOLEAN bStatus = FALSE;
1466     AFSFcb *pFcb = (AFSFcb *)Fcb;
1467     BOOLEAN bReleaseMain = FALSE, bReleasePaging = FALSE;
1468
1469     //
1470     // Try and acquire the Fcb resource
1471     //
1472
1473     AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
1474                   AFS_TRACE_LEVEL_VERBOSE,
1475                   "AFSAcquireFcbForLazyWrite Acquiring Fcb %08lX\n",
1476                   Fcb);
1477
1478     ASSERT( NULL == pFcb->Specific.File.LazyWriterThread);
1479
1480     pFcb->Specific.File.LazyWriterThread = PsGetCurrentThread();
1481
1482     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1483                   AFS_TRACE_LEVEL_VERBOSE,
1484                   "AFSAcquireFcbForLazyWrite Attempt to acquire Fcb lock %08lX SHARED %08lX\n",
1485                   &pFcb->NPFcb->Resource,
1486                   PsGetCurrentThread());
1487
1488     if( AFSAcquireShared( &pFcb->NPFcb->Resource,
1489                           Wait))
1490     {
1491
1492         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1493                       AFS_TRACE_LEVEL_VERBOSE,
1494                       "AFSAcquireFcbForLazyWrite Acquired Fcb lock %08lX SHARED %08lX\n",
1495                       &pFcb->NPFcb->Resource,
1496                       PsGetCurrentThread());
1497
1498         bReleaseMain = TRUE;
1499
1500         //
1501         // Try and grab the paging
1502         //
1503
1504         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1505                       AFS_TRACE_LEVEL_VERBOSE,
1506                       "AFSAcquireFcbForLazyWrite Attempt to acquire Fcb PagingIo lock %08lX SHARED %08lX\n",
1507                       &pFcb->NPFcb->PagingResource,
1508                       PsGetCurrentThread());
1509
1510         if( AFSAcquireShared( &pFcb->NPFcb->PagingResource,
1511                               Wait))
1512         {
1513
1514             AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1515                           AFS_TRACE_LEVEL_VERBOSE,
1516                           "AFSAcquireFcbForLazyWrite Acquired Fcb PagingIo lock %08lX SHARED %08lX\n",
1517                           &pFcb->NPFcb->PagingResource,
1518                           PsGetCurrentThread());
1519
1520             bReleasePaging = TRUE;
1521
1522             //
1523             // All is well ...
1524             //
1525
1526             bStatus = TRUE;
1527
1528             IoSetTopLevelIrp( (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
1529         }
1530     }
1531
1532     if( !bStatus)
1533     {
1534
1535         if( bReleaseMain)
1536         {
1537
1538             AFSReleaseResource( &pFcb->NPFcb->Resource);
1539         }
1540
1541         if( bReleasePaging)
1542         {
1543
1544             AFSReleaseResource( &pFcb->NPFcb->PagingResource);
1545         }
1546     }
1547
1548     return bStatus;
1549 }
1550
1551 VOID
1552 AFSReleaseFcbFromLazyWrite( IN PVOID Fcb)
1553 {
1554
1555     AFSFcb *pFcb = (AFSFcb *)Fcb;
1556
1557     AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
1558                   AFS_TRACE_LEVEL_VERBOSE,
1559                   "AFSReleaseFcbFromLazyWrite Releasing Fcb %08lX\n",
1560                   Fcb);
1561
1562     IoSetTopLevelIrp( NULL);
1563
1564     ASSERT( PsGetCurrentThread() == pFcb->Specific.File.LazyWriterThread);
1565
1566     pFcb->Specific.File.LazyWriterThread = NULL;
1567
1568
1569     AFSReleaseResource( &pFcb->NPFcb->PagingResource);
1570
1571     AFSReleaseResource( &pFcb->NPFcb->Resource);
1572
1573     return;
1574 }
1575
1576 BOOLEAN
1577 AFSAcquireFcbForReadAhead( IN PVOID Fcb,
1578                            IN BOOLEAN Wait)
1579 {
1580
1581     BOOLEAN bStatus = FALSE;
1582     AFSFcb *pFcb = (AFSFcb *)Fcb;
1583
1584     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1585                   AFS_TRACE_LEVEL_VERBOSE,
1586                   "AFSAcquireFcbForReadAhead Attempt to acquire Fcb lock %08lX SHARED %08lX\n",
1587                   &pFcb->NPFcb->Resource,
1588                   PsGetCurrentThread());
1589
1590     if( AFSAcquireShared( &pFcb->NPFcb->Resource,
1591                           Wait))
1592     {
1593
1594         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1595                       AFS_TRACE_LEVEL_VERBOSE,
1596                       "AFSAcquireFcbForReadAhead Acquired Fcb lock %08lX SHARED %08lX\n",
1597                       &pFcb->NPFcb->Resource,
1598                       PsGetCurrentThread());
1599
1600         bStatus = TRUE;
1601
1602         IoSetTopLevelIrp( (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
1603     }
1604
1605     return bStatus;
1606 }
1607
1608 VOID
1609 AFSReleaseFcbFromReadAhead( IN PVOID Fcb)
1610 {
1611
1612     AFSFcb *pFcb = (AFSFcb *)Fcb;
1613
1614     IoSetTopLevelIrp( NULL);
1615
1616     AFSReleaseResource( &pFcb->NPFcb->Resource);
1617
1618     return;
1619 }
1620
1621 NTSTATUS
1622 AFSGetCallerSID( OUT UNICODE_STRING *SIDString, OUT BOOLEAN *pbImpersonation)
1623 {
1624
1625     NTSTATUS ntStatus = STATUS_SUCCESS;
1626     PACCESS_TOKEN hToken = NULL;
1627     TOKEN_USER *pTokenInfo = NULL;
1628     BOOLEAN bCopyOnOpen = FALSE;
1629     BOOLEAN bEffectiveOnly = FALSE;
1630     BOOLEAN bPrimaryToken = FALSE;
1631     SECURITY_IMPERSONATION_LEVEL stImpersonationLevel;
1632     UNICODE_STRING uniSIDString;
1633
1634     __Enter
1635     {
1636
1637         hToken = PsReferenceImpersonationToken( PsGetCurrentThread(),
1638                                                 &bCopyOnOpen,
1639                                                 &bEffectiveOnly,
1640                                                 &stImpersonationLevel);
1641
1642         if( hToken == NULL)
1643         {
1644
1645             hToken = PsReferencePrimaryToken( PsGetCurrentProcess());
1646
1647             if( hToken == NULL)
1648             {
1649
1650                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1651                               AFS_TRACE_LEVEL_ERROR,
1652                               "AFSGetCallerSID Failed to retrieve impersonation or primary token\n");
1653
1654                 try_return( ntStatus);
1655             }
1656
1657             bPrimaryToken = TRUE;
1658         }
1659
1660         ntStatus = SeQueryInformationToken( hToken,
1661                                             TokenUser,
1662                                             (PVOID *)&pTokenInfo);
1663
1664         if( !NT_SUCCESS( ntStatus))
1665         {
1666
1667             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1668                           AFS_TRACE_LEVEL_ERROR,
1669                           "AFSGetCallerSID Failed to retrieve information Status %08lX\n", ntStatus);
1670
1671             try_return( ntStatus);
1672         }
1673
1674         uniSIDString.Length = 0;
1675         uniSIDString.MaximumLength = 0;
1676         uniSIDString.Buffer = NULL;
1677
1678         ntStatus = RtlConvertSidToUnicodeString( &uniSIDString,
1679                                                  pTokenInfo->User.Sid,
1680                                                  TRUE);
1681
1682         if( !NT_SUCCESS( ntStatus))
1683         {
1684
1685             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1686                           AFS_TRACE_LEVEL_ERROR,
1687                           "AFSGetCallerSID Failed to convert sid to string Status %08lX\n", ntStatus);
1688
1689             try_return( ntStatus);
1690         }
1691
1692         *SIDString = uniSIDString;
1693
1694         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING | AFS_SUBSYSTEM_AUTHGROUP_PROCESSING,
1695                       AFS_TRACE_LEVEL_VERBOSE_2,
1696                       "AFSGetCallerSID Successfully retrieved SID %wZ\n",
1697                       SIDString);
1698
1699         if ( bPrimaryToken == FALSE &&
1700              pbImpersonation)
1701         {
1702             *pbImpersonation = TRUE;
1703         }
1704
1705 try_exit:
1706
1707         if( hToken != NULL)
1708         {
1709             if( bPrimaryToken)
1710             {
1711                 PsDereferencePrimaryToken( hToken);
1712             }
1713             else
1714             {
1715                 PsDereferenceImpersonationToken( hToken);
1716             }
1717         }
1718
1719         if( pTokenInfo != NULL)
1720         {
1721             AFSExFreePool( pTokenInfo);
1722         }
1723     }
1724
1725     return ntStatus;
1726 }
1727
1728 ULONG
1729 AFSGetSessionId( IN HANDLE ProcessId, OUT BOOLEAN *pbImpersonation)
1730 {
1731
1732     NTSTATUS ntStatus = STATUS_SUCCESS;
1733     PACCESS_TOKEN hToken = NULL;
1734     ULONG ulSessionId = (ULONG)-1;
1735     BOOLEAN bCopyOnOpen = FALSE;
1736     BOOLEAN bEffectiveOnly = FALSE;
1737     BOOLEAN bPrimaryToken = FALSE;
1738     SECURITY_IMPERSONATION_LEVEL stImpersonationLevel;
1739
1740     __Enter
1741     {
1742
1743         hToken = PsReferenceImpersonationToken( PsGetCurrentThread(),
1744                                                 &bCopyOnOpen,
1745                                                 &bEffectiveOnly,
1746                                                 &stImpersonationLevel);
1747
1748         if( hToken == NULL)
1749         {
1750
1751             hToken = PsReferencePrimaryToken( PsGetCurrentProcess());
1752
1753             if( hToken == NULL)
1754             {
1755
1756                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1757                               AFS_TRACE_LEVEL_ERROR,
1758                               "AFSGetSessionId Failed to retrieve impersonation or primary token\n");
1759
1760                 try_return( ntStatus);
1761             }
1762
1763             bPrimaryToken = TRUE;
1764         }
1765
1766         ntStatus = SeQueryInformationToken( hToken,
1767                                             TokenSessionId,
1768                                             (PVOID *)&ulSessionId);
1769
1770         if( !NT_SUCCESS( ntStatus))
1771         {
1772             ulSessionId = (ULONG)-1;
1773
1774             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1775                           AFS_TRACE_LEVEL_ERROR,
1776                           "AFSGetSessionId Failed to retrieve session id Status %08lX\n",
1777                           ntStatus);
1778
1779             try_return( ntStatus);
1780         }
1781
1782         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING | AFS_SUBSYSTEM_AUTHGROUP_PROCESSING,
1783                       AFS_TRACE_LEVEL_VERBOSE_2,
1784                       "AFSGetSessionId found %08lX\n",
1785                       ulSessionId);
1786
1787         if ( bPrimaryToken == FALSE &&
1788              pbImpersonation)
1789         {
1790             *pbImpersonation = TRUE;
1791         }
1792
1793 try_exit:
1794
1795         if( hToken != NULL)
1796         {
1797             if( bPrimaryToken)
1798             {
1799                 PsDereferencePrimaryToken( hToken);
1800             }
1801             else
1802             {
1803                 PsDereferenceImpersonationToken( hToken);
1804             }
1805         }
1806     }
1807
1808     return ulSessionId;
1809 }
1810
1811 NTSTATUS
1812 AFSCheckThreadDacl( OUT GUID *AuthGroup)
1813 {
1814
1815     NTSTATUS ntStatus = STATUS_UNSUCCESSFUL;
1816     ULONG idx;
1817     PACCESS_TOKEN token = NULL;
1818     PTOKEN_DEFAULT_DACL defDacl = NULL;
1819     PACE_HEADER ace;
1820     PACCESS_ALLOWED_ACE adace;
1821     BOOLEAN bCopyOnOpen = FALSE, bEffectiveOnly = FALSE;
1822     SECURITY_IMPERSONATION_LEVEL stImpersonationLevel;
1823     BOOLEAN bLocatedACE = FALSE;
1824
1825     __Enter
1826     {
1827
1828         token = PsReferenceImpersonationToken( PsGetCurrentThread(),
1829                                                &bCopyOnOpen,
1830                                                &bEffectiveOnly,
1831                                                &stImpersonationLevel);
1832
1833         if( token == NULL)
1834         {
1835            try_return( ntStatus);
1836         }
1837
1838         ntStatus = SeQueryInformationToken( token,
1839                                             TokenDefaultDacl,
1840                                             (PVOID *)&defDacl);
1841
1842         if( ntStatus != STATUS_SUCCESS)
1843         {
1844            try_return( ntStatus);
1845         }
1846
1847         // scan through all ACEs in the DACL
1848         for (idx = 0, ace = (PACE_HEADER)((char *)defDacl->DefaultDacl + sizeof(ACL)); idx < defDacl->DefaultDacl->AceCount; idx++)
1849         {
1850            if (ace->AceType == ACCESS_ALLOWED_ACE_TYPE)
1851            {
1852               adace = (PACCESS_ALLOWED_ACE)ace;
1853
1854               if (adace->Header.AceSize == (FIELD_OFFSET(ACCESS_ALLOWED_ACE, SidStart) + AFS_DACL_SID_LENGTH))
1855               {
1856                  if (RtlCompareMemory( RtlSubAuthoritySid((PSID)&adace->SidStart, 0), &AFSSidGuid, sizeof(GUID)) == sizeof(GUID))
1857                  {
1858
1859                     RtlCopyMemory( AuthGroup,
1860                                    RtlSubAuthoritySid((PSID)&adace->SidStart, 4),
1861                                    sizeof( GUID));
1862
1863                     bLocatedACE = TRUE;
1864
1865                     break;
1866                  }
1867               }
1868            }
1869
1870            // go to next ace
1871            ace = (PACE_HEADER)((char *)ace + ace->AceSize);
1872         }
1873
1874 try_exit:
1875
1876         if( token != NULL)
1877         {
1878             PsDereferenceImpersonationToken( token);
1879         }
1880
1881         if (defDacl != NULL)
1882         {
1883            ExFreePool(defDacl);
1884         }
1885
1886         if( !bLocatedACE)
1887         {
1888             ntStatus = STATUS_UNSUCCESSFUL;
1889         }
1890     }
1891
1892     return ntStatus;
1893 }
1894
1895 NTSTATUS
1896 AFSProcessSetProcessDacl( IN AFSProcessCB *ProcessCB)
1897 {
1898
1899     PTOKEN_DEFAULT_DACL defDacl = NULL;
1900     HANDLE hToken = NULL;
1901     PACE_HEADER ace = NULL;
1902     SID_IDENTIFIER_AUTHORITY sia = SECURITY_NT_AUTHORITY;
1903     PACCESS_ALLOWED_ACE aaace;
1904     ULONG bytesNeeded;
1905     ULONG bytesReturned;
1906     ULONG idx;
1907     PSID psid;
1908     NTSTATUS ntStatus = STATUS_SUCCESS;
1909
1910     __Enter
1911     {
1912
1913         ntStatus = ZwOpenProcessTokenEx( NtCurrentProcess(),
1914                                          GENERIC_ALL,
1915                                          OBJ_KERNEL_HANDLE,
1916                                          &hToken);
1917
1918         if( !NT_SUCCESS( ntStatus))
1919         {
1920             try_return( ntStatus);
1921         }
1922
1923         // get the size of the current DACL
1924         ntStatus = ZwQueryInformationToken( hToken,
1925                                             TokenDefaultDacl,
1926                                             NULL,
1927                                             0,
1928                                             &bytesNeeded);
1929
1930         // if we failed to get the buffer size needed
1931         if ((ntStatus != STATUS_SUCCESS) && (ntStatus != STATUS_BUFFER_TOO_SMALL))
1932         {
1933             try_return( ntStatus);
1934         }
1935
1936         // tack on enough space for our ACE if we need to add it...
1937         bytesNeeded += FIELD_OFFSET(ACCESS_ALLOWED_ACE, SidStart) + AFS_DACL_SID_LENGTH;
1938
1939         // allocate space for the DACL
1940         defDacl = (PTOKEN_DEFAULT_DACL)ExAllocatePoolWithTag( PagedPool, bytesNeeded, AFS_GENERIC_MEMORY_26_TAG);
1941
1942         if (defDacl == NULL)
1943         {
1944            try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
1945         }
1946
1947         // get the DACL
1948         ntStatus = ZwQueryInformationToken( hToken,
1949                                             TokenDefaultDacl,
1950                                             defDacl,
1951                                             bytesNeeded,
1952                                             &bytesReturned);
1953
1954         if( ntStatus != STATUS_SUCCESS)
1955         {
1956             try_return( ntStatus);
1957         }
1958
1959         // scan through DACL to see if we have the SID set already...
1960         ace = (PACE_HEADER)((char *)defDacl->DefaultDacl + sizeof(ACL));
1961         for (idx = 0; idx < defDacl->DefaultDacl->AceCount; idx++)
1962         {
1963             if (ace->AceType == ACCESS_ALLOWED_ACE_TYPE)
1964             {
1965                 aaace = (PACCESS_ALLOWED_ACE)ace;
1966
1967                 if (aaace->Header.AceSize == (FIELD_OFFSET(ACCESS_ALLOWED_ACE, SidStart) + AFS_DACL_SID_LENGTH))
1968                 {
1969                     // if the GUID part matches
1970                     if( RtlCompareMemory( RtlSubAuthoritySid((PSID)&aaace->SidStart, 0),
1971                                           &AFSSidGuid,
1972                                           sizeof(GUID)) == sizeof(GUID))
1973                     {
1974
1975                         if ( RtlCompareMemory( RtlSubAuthoritySid((PSID)&aaace->SidStart, 4),
1976                                                ProcessCB->ActiveAuthGroup,
1977                                                sizeof( GUID)) != sizeof( GUID))
1978                         {
1979
1980                             RtlCopyMemory( RtlSubAuthoritySid((PSID)&aaace->SidStart, 4),
1981                                            ProcessCB->ActiveAuthGroup,
1982                                            sizeof( GUID));
1983
1984                             if( AFSSetInformationToken != NULL)
1985                             {
1986                                 ntStatus = AFSSetInformationToken( hToken,
1987                                                                    TokenDefaultDacl,
1988                                                                    defDacl,
1989                                                                    bytesReturned);
1990                             }
1991                         }
1992
1993                         try_return( ntStatus);
1994                     }
1995                 }
1996             }
1997
1998             // go to next ace
1999             ace = (PACE_HEADER)((char *)ace + ace->AceSize);
2000         }
2001
2002         //
2003         // if we made it here we need to add a new ACE to the DACL
2004         //
2005
2006         aaace = (ACCESS_ALLOWED_ACE *)ace;
2007         aaace->Header.AceType = ACCESS_ALLOWED_ACE_TYPE;
2008         aaace->Header.AceFlags = 0;
2009         aaace->Mask = GENERIC_ALL;
2010         psid = (PSID)&aaace->SidStart;
2011         RtlInitializeSid( psid, &sia, 8);
2012
2013         RtlCopyMemory( RtlSubAuthoritySid(psid, 0),
2014                        &AFSSidGuid,
2015                        sizeof(GUID));
2016
2017         RtlCopyMemory( RtlSubAuthoritySid(psid, 4),
2018                        ProcessCB->ActiveAuthGroup,
2019                        sizeof( GUID));
2020
2021         aaace->Header.AceSize = (USHORT)(FIELD_OFFSET(ACCESS_ALLOWED_ACE, SidStart) + RtlLengthSid( psid));
2022
2023         defDacl->DefaultDacl->AclSize += aaace->Header.AceSize;
2024         defDacl->DefaultDacl->AceCount++;
2025
2026         if( AFSSetInformationToken != NULL)
2027         {
2028             ntStatus = AFSSetInformationToken( hToken,
2029                                               TokenDefaultDacl,
2030                                               defDacl,
2031                                               defDacl->DefaultDacl->AclSize + sizeof(PTOKEN_DEFAULT_DACL));
2032         }
2033
2034 try_exit:
2035
2036         if( hToken != NULL)
2037         {
2038             ZwClose( hToken);
2039         }
2040
2041         if (defDacl != NULL)
2042         {
2043            ExFreePool( defDacl);
2044         }
2045     }
2046
2047     return ntStatus;
2048 }
2049
2050