src/WINNT/afsrdr/kernel/fs/AFSRDRSupport.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: AFSRDRSupport.cpp
  37 //
  38 #include "AFSCommon.h"
  39
  40 typedef NTSTATUS  (*FsRtlRegisterUncProviderEx_t)( PHANDLE  MupHandle, PUNICODE_STRING  RedirDevName, PDEVICE_OBJECT  DeviceObject, ULONG  Flags);
  41
  42 NTSTATUS
  43 AFSInitRDRDevice()
  44 {
  45
  46     NTSTATUS       ntStatus = STATUS_SUCCESS;
  47     UNICODE_STRING uniDeviceName;
  48     AFSDeviceExt  *pDeviceExt = NULL;
  49     UNICODE_STRING uniFsRtlRegisterUncProviderEx;
  50     FsRtlRegisterUncProviderEx_t pFsRtlRegisterUncProviderEx = NULL;
  51
  52     __Enter
  53     {
  54
  55         RtlInitUnicodeString( &uniDeviceName,
  56                               AFS_RDR_DEVICE_NAME);
  57
  58         RtlInitUnicodeString( &uniFsRtlRegisterUncProviderEx,
  59                               L"FsRtlRegisterUncProviderEx");
  60
  61         pFsRtlRegisterUncProviderEx = (FsRtlRegisterUncProviderEx_t)MmGetSystemRoutineAddress(&uniFsRtlRegisterUncProviderEx);
  62
  63         ntStatus = IoCreateDevice( AFSDriverObject,
  64                                    sizeof( AFSDeviceExt),
  65                                    pFsRtlRegisterUncProviderEx ? NULL : &uniDeviceName,
  66                                    FILE_DEVICE_NETWORK_FILE_SYSTEM,
  67                                    FILE_REMOTE_DEVICE,
  68                                    FALSE,
  69                                    &AFSRDRDeviceObject);
  70
  71         if( !NT_SUCCESS( ntStatus))
  72         {
  73
  74             AFSDbgLogMsg( AFS_SUBSYSTEM_INIT_PROCESSING,
  75                           AFS_TRACE_LEVEL_ERROR,
  76                           "AFSInitRDRDevice IoCreateDevice failure %08lX\n",
  77                           ntStatus);
  78
  79             try_return( ntStatus);
  80         }
  81
  82         pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
  83
  84         RtlZeroMemory( pDeviceExt,
  85                        sizeof( AFSDeviceExt));
  86
  87         //
  88         // Initialize resources
  89         //
  90
  91         pDeviceExt->Specific.RDR.VolumeTree.TreeLock = &pDeviceExt->Specific.RDR.VolumeTreeLock;
  92
  93         ExInitializeResourceLite( pDeviceExt->Specific.RDR.VolumeTree.TreeLock);
  94
  95         pDeviceExt->Specific.RDR.VolumeTree.TreeHead = NULL;
  96
  97         ExInitializeResourceLite( &pDeviceExt->Specific.RDR.VolumeListLock);
  98
  99         pDeviceExt->Specific.RDR.VolumeListHead = NULL;
 100
 101         pDeviceExt->Specific.RDR.VolumeListTail = NULL;
 102
 103         KeInitializeEvent( &pDeviceExt->Specific.RDR.QueuedReleaseExtentEvent,
 104                            NotificationEvent,
 105                            TRUE);
 106
 107         ExInitializeResourceLite( &pDeviceExt->Specific.RDR.RootCellTreeLock);
 108
 109         pDeviceExt->Specific.RDR.RootCellTree.TreeLock = &pDeviceExt->Specific.RDR.RootCellTreeLock;
 110
 111         pDeviceExt->Specific.RDR.RootCellTree.TreeHead = NULL;
 112
 113         ExInitializeResourceLite( &pDeviceExt->Specific.RDR.ProviderListLock);
 114
 115         ntStatus = AFSInitRdrFcb( &pDeviceExt->Fcb);
 116
 117         if ( !NT_SUCCESS(ntStatus))
 118         {
 119
 120             AFSDbgLogMsg( AFS_SUBSYSTEM_INIT_PROCESSING,
 121                           AFS_TRACE_LEVEL_ERROR,
 122                           "AFSInitRDRDevice AFSInitRdrFcb failure %08lX\n",
 123                           ntStatus);
 124
 125             try_return( ntStatus);
 126         }
 127
 128         //
 129         // Clear the initializing bit
 130         //
 131
 132         AFSRDRDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
 133
 134         //
 135         // Register this device with MUP with FilterMgr if Vista or above
 136         //
 137
 138         if( pFsRtlRegisterUncProviderEx)
 139         {
 140
 141             ntStatus = pFsRtlRegisterUncProviderEx( &AFSMUPHandle,
 142                                                     &uniDeviceName,
 143                                                     AFSRDRDeviceObject,
 144                                                     0);
 145             if ( !NT_SUCCESS( ntStatus))
 146             {
 147                 AFSDbgLogMsg( AFS_SUBSYSTEM_INIT_PROCESSING,
 148                               AFS_TRACE_LEVEL_ERROR,
 149                               "AFSInitRDRDevice FsRtlRegisterUncProvider failure %08lX\n",
 150                               ntStatus);
 151             }
 152         }
 153         else
 154         {
 155
 156             ntStatus = FsRtlRegisterUncProvider( &AFSMUPHandle,
 157                                                  &uniDeviceName,
 158                                                  FALSE);
 159
 160             if ( NT_SUCCESS( ntStatus))
 161             {
 162
 163                 IoRegisterFileSystem( AFSRDRDeviceObject);
 164             }
 165             else
 166             {
 167                 AFSDbgLogMsg( AFS_SUBSYSTEM_INIT_PROCESSING,
 168                               AFS_TRACE_LEVEL_ERROR,
 169                               "AFSInitRDRDevice FsRtlRegisterUncProvider failure %08lX\n",
 170                               ntStatus);
 171             }
 172         }
 173
 174         //
 175         // Good to go, all registered and ready to start receiving requests
 176         //
 177
 178 try_exit:
 179
 180         if( !NT_SUCCESS( ntStatus))
 181         {
 182
 183             //
 184             // Delete our device and bail
 185             //
 186
 187             ExDeleteResourceLite( pDeviceExt->Specific.RDR.VolumeTree.TreeLock);
 188
 189             ExDeleteResourceLite( &pDeviceExt->Specific.RDR.VolumeListLock);
 190
 191             ExDeleteResourceLite( &pDeviceExt->Specific.RDR.RootCellTreeLock);
 192
 193             ExDeleteResourceLite( &pDeviceExt->Specific.RDR.ProviderListLock);
 194
 195             IoDeleteDevice( AFSRDRDeviceObject);
 196
 197             AFSRDRDeviceObject = NULL;
 198
 199             try_return( ntStatus);
 200         }
 201     }
 202
 203     return ntStatus;
 204 }
 205
 206 NTSTATUS
 207 AFSRDRDeviceControl( IN PDEVICE_OBJECT DeviceObject,
 208                      IN PIRP Irp)
 209 {
 210     UNREFERENCED_PARAMETER(DeviceObject);
 211
 212     NTSTATUS           ntStatus = STATUS_SUCCESS;
 213     PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
 214     BOOLEAN            bCompleteIrp = TRUE;
 215
 216     __Enter
 217     {
 218
 219         switch( pIrpSp->Parameters.DeviceIoControl.IoControlCode)
 220         {
 221
 222             case IOCTL_REDIR_QUERY_PATH:
 223             {
 224
 225                 QUERY_PATH_REQUEST *pPathRequest = (QUERY_PATH_REQUEST *)pIrpSp->Parameters.DeviceIoControl.Type3InputBuffer;
 226                 QUERY_PATH_RESPONSE *pPathResponse = (QUERY_PATH_RESPONSE *)Irp->UserBuffer;
 227                 UNICODE_STRING uniPathName;
 228
 229                 ntStatus = STATUS_BAD_NETWORK_PATH;
 230
 231                 uniPathName.Length = (USHORT)pPathRequest->PathNameLength;
 232                 uniPathName.MaximumLength = uniPathName.Length;
 233
 234                 uniPathName.Buffer = pPathRequest->FilePathName;
 235
 236                 if( uniPathName.Length >= AFSServerName.Length + sizeof( WCHAR))
 237                 {
 238
 239                     USHORT usLength = uniPathName.Length;
 240
 241                     uniPathName.Length = AFSServerName.Length;
 242
 243                     //
 244                     // Skip over the first slash in the name
 245                     //
 246
 247                     uniPathName.Buffer = &uniPathName.Buffer[ 1];
 248
 249
 250                     //
 251                     // Check to see if the first (or only) component
 252                     // of the path matches the server name
 253                     //
 254
 255                     if( RtlCompareUnicodeString( &AFSServerName,
 256                                                  &uniPathName,
 257                                                  TRUE) == 0 &&
 258                         ( usLength == AFSServerName.Length + sizeof( WCHAR) ||
 259                           uniPathName.Buffer[ AFSServerName.Length / sizeof( WCHAR)] == '\\'))
 260                     {
 261
 262                         ntStatus = STATUS_SUCCESS;
 263
 264                         pPathResponse->LengthAccepted = AFSServerName.Length + sizeof( WCHAR);
 265                     }
 266                 }
 267
 268                 break;
 269             }
 270
 271             case IOCTL_REDIR_QUERY_PATH_EX:
 272             {
 273
 274                 QUERY_PATH_REQUEST_EX *pPathRequest = (QUERY_PATH_REQUEST_EX *)pIrpSp->Parameters.DeviceIoControl.Type3InputBuffer;
 275                 QUERY_PATH_RESPONSE *pPathResponse = (QUERY_PATH_RESPONSE *)Irp->UserBuffer;
 276                 UNICODE_STRING uniPathName;
 277
 278                 ntStatus = STATUS_BAD_NETWORK_PATH;
 279
 280                 uniPathName.Length = pPathRequest->PathName.Length;
 281                 uniPathName.MaximumLength = uniPathName.Length;
 282
 283                 uniPathName.Buffer = pPathRequest->PathName.Buffer;
 284
 285                 if( uniPathName.Length >= AFSServerName.Length + sizeof( WCHAR))
 286                 {
 287
 288                     USHORT usLength = uniPathName.Length;
 289
 290                     uniPathName.Length = AFSServerName.Length;
 291
 292                     //
 293                     // Skip over the first slash in the name
 294                     //
 295
 296                     uniPathName.Buffer = &uniPathName.Buffer[ 1];
 297
 298
 299                     //
 300                     // Check to see if the first (or only) component
 301                     // of the path matches the server name
 302                     //
 303
 304                     if( RtlCompareUnicodeString( &AFSServerName,
 305                                                  &uniPathName,
 306                                                  TRUE) == 0 &&
 307                         ( usLength == AFSServerName.Length + sizeof( WCHAR) ||
 308                           uniPathName.Buffer[ AFSServerName.Length / sizeof( WCHAR)] == '\\'))
 309                     {
 310
 311                         ntStatus = STATUS_SUCCESS;
 312
 313                         pPathResponse->LengthAccepted = AFSServerName.Length + sizeof( WCHAR);
 314                     }
 315                 }
 316
 317                 break;
 318             }
 319
 320             default:
 321
 322                 ntStatus = STATUS_INVALID_DEVICE_REQUEST;
 323
 324                 break;
 325         }
 326
 327         if (bCompleteIrp)
 328         {
 329             //
 330             // Complete the request
 331             //
 332
 333             AFSCompleteRequest( Irp,
 334                                 ntStatus);
 335         }
 336     }
 337
 338     return ntStatus;
 339 }
 340
 341 NTSTATUS
 342 AFSInitializeRedirector( IN AFSRedirectorInitInfo *RedirInitInfo)
 343 {
 344
 345     NTSTATUS ntStatus = STATUS_SUCCESS;
 346     LARGE_INTEGER cacheSizeBytes;
 347     AFSDeviceExt *pDevExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
 348     OBJECT_ATTRIBUTES   stObjectAttribs;
 349     IO_STATUS_BLOCK stIoStatus;
 350     UNICODE_STRING uniServiceName;
 351
 352     __Enter
 353     {
 354
 355         //
 356         // First this is to load the library
 357         //
 358
 359         RtlInitUnicodeString( &uniServiceName,
 360                               AFS_REDIR_LIBRARY_SERVICE_ENTRY);
 361
 362         ntStatus = AFSLoadLibrary( 0,
 363                                    &uniServiceName);
 364
 365         if( !NT_SUCCESS( ntStatus))
 366         {
 367
 368             AFSDbgLogMsg( AFS_SUBSYSTEM_INIT_PROCESSING,
 369                           AFS_TRACE_LEVEL_ERROR,
 370                           "AFSInitializeRedirector AFSLoadLibrary failure %08lX\n",
 371                           ntStatus);
 372
 373             try_return( ntStatus);
 374         }
 375
 376         //
 377         // Save off the cache file information
 378         //
 379
 380         pDevExt->Specific.RDR.CacheBlockSize = RedirInitInfo->CacheBlockSize;
 381
 382         pDevExt->Specific.RDR.CacheBlockCount = RedirInitInfo->ExtentCount;
 383
 384         pDevExt->Specific.RDR.MaximumRPCLength = RedirInitInfo->MaximumChunkLength;
 385
 386         cacheSizeBytes = RedirInitInfo->ExtentCount;
 387         cacheSizeBytes.QuadPart *= RedirInitInfo->CacheBlockSize;
 388
 389         AFSDumpFileLocation.Length = 0;
 390
 391         AFSDumpFileLocation.MaximumLength = (USHORT)RedirInitInfo->DumpFileLocationLength + (4 * sizeof( WCHAR));
 392
 393         AFSDumpFileLocation.Buffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
 394                                                                         AFSDumpFileLocation.MaximumLength,
 395                                                                         AFS_GENERIC_MEMORY_23_TAG);
 396
 397         if( AFSDumpFileLocation.Buffer == NULL)
 398         {
 399
 400             AFSDbgLogMsg( AFS_SUBSYSTEM_INIT_PROCESSING,
 401                           AFS_TRACE_LEVEL_ERROR,
 402                           "AFSInitializeRedirector AFS_GENERIC_MEMORY_23_TAG allocation error\n");
 403
 404             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 405         }
 406
 407         RtlCopyMemory( AFSDumpFileLocation.Buffer,
 408                        L"\\??\\",
 409                        4 * sizeof( WCHAR));
 410
 411         AFSDumpFileLocation.Length = 4 * sizeof( WCHAR);
 412
 413         RtlCopyMemory( &AFSDumpFileLocation.Buffer[ AFSDumpFileLocation.Length/sizeof( WCHAR)],
 414                        (void *)((char *)RedirInitInfo + RedirInitInfo->DumpFileLocationOffset),
 415                        RedirInitInfo->DumpFileLocationLength);
 416
 417         AFSDumpFileLocation.Length += (USHORT)RedirInitInfo->DumpFileLocationLength;
 418
 419         //
 420         // Be sure the shutdown flag is not set
 421         //
 422
 423         ClearFlag( pDevExt->DeviceFlags, AFS_DEVICE_FLAG_REDIRECTOR_SHUTDOWN);
 424
 425         //
 426         // Set up the Throttles.
 427         //
 428         // Max IO is 10% of the cache, or the value in the registry,
 429         // with a minimum of 5Mb (and a maximum of 50% cache size)
 430         //
 431         if( AFSMaxDirectIo)
 432         {
 433             //
 434             // collect what the user
 435             //
 436             pDevExt->Specific.RDR.MaxIo.QuadPart = AFSMaxDirectIo;
 437             pDevExt->Specific.RDR.MaxIo.QuadPart *= (1024 * 1024);
 438
 439         }
 440         else
 441         {
 442
 443             pDevExt->Specific.RDR.MaxIo.QuadPart = cacheSizeBytes.QuadPart / 2;
 444         }
 445
 446         if (pDevExt->Specific.RDR.MaxIo.QuadPart < (5 * 1024 * 1204))
 447         {
 448
 449             pDevExt->Specific.RDR.MaxIo.QuadPart = 5 * 1024 * 1204;
 450
 451         }
 452
 453         //
 454         // For small cache configurations ...
 455         //
 456
 457         if (pDevExt->Specific.RDR.MaxIo.QuadPart > cacheSizeBytes.QuadPart / 2)
 458         {
 459
 460             pDevExt->Specific.RDR.MaxIo.QuadPart  = cacheSizeBytes.QuadPart / 2;
 461         }
 462
 463         //
 464         // Maximum Dirty is 50% of the cache, or the value in the
 465         // registry.  No minimum, maximum of 90% of cache size.
 466         //
 467         if (AFSMaxDirtyFile)
 468         {
 469
 470             pDevExt->Specific.RDR.MaxDirty.QuadPart = AFSMaxDirtyFile;
 471             pDevExt->Specific.RDR.MaxDirty.QuadPart *= (1024 * 1024);
 472
 473         }
 474         else
 475         {
 476
 477             pDevExt->Specific.RDR.MaxDirty.QuadPart = cacheSizeBytes.QuadPart/2;
 478
 479         }
 480
 481         cacheSizeBytes.QuadPart *= 9;
 482         cacheSizeBytes.QuadPart  = cacheSizeBytes.QuadPart / 10;
 483
 484         if (pDevExt->Specific.RDR.MaxDirty.QuadPart > cacheSizeBytes.QuadPart)
 485         {
 486             pDevExt->Specific.RDR.MaxDirty.QuadPart = cacheSizeBytes.QuadPart;
 487         }
 488
 489         //
 490         // Store off any flags for the file system
 491         //
 492
 493         if( BooleanFlagOn( RedirInitInfo->Flags, AFS_REDIR_INIT_FLAG_HIDE_DOT_FILES))
 494         {
 495
 496             //
 497             // Hide files which begin with .
 498             //
 499
 500             SetFlag( pDevExt->DeviceFlags, AFS_DEVICE_FLAG_HIDE_DOT_NAMES);
 501         }
 502
 503         if( BooleanFlagOn( RedirInitInfo->Flags, AFS_REDIR_INIT_FLAG_DISABLE_SHORTNAMES))
 504         {
 505
 506             //
 507             // Hide files which begin with .
 508             //
 509
 510             SetFlag( pDevExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES);
 511         }
 512
 513         if( RedirInitInfo->MemoryCacheOffset.QuadPart != 0 &&
 514             RedirInitInfo->MemoryCacheLength.QuadPart != 0)
 515         {
 516
 517             ntStatus = STATUS_INSUFFICIENT_RESOURCES;
 518
 519 #ifdef AMD64
 520             pDevExt->Specific.RDR.CacheMdl = MmCreateMdl( NULL,
 521                                                           (void *)RedirInitInfo->MemoryCacheOffset.QuadPart,
 522                                                           RedirInitInfo->MemoryCacheLength.QuadPart);
 523 #else
 524             pDevExt->Specific.RDR.CacheMdl = MmCreateMdl( NULL,
 525                                                           (void *)RedirInitInfo->MemoryCacheOffset.LowPart,
 526                                                           RedirInitInfo->MemoryCacheLength.LowPart);
 527 #endif
 528
 529             if( pDevExt->Specific.RDR.CacheMdl != NULL)
 530             {
 531
 532                 __try
 533                 {
 534
 535                     MmProbeAndLockPages( pDevExt->Specific.RDR.CacheMdl,
 536                                          KernelMode,
 537                                          IoModifyAccess);
 538
 539                     pDevExt->Specific.RDR.CacheBaseAddress = MmGetSystemAddressForMdlSafe( pDevExt->Specific.RDR.CacheMdl,
 540                                                                                            NormalPagePriority);
 541                 }
 542                 __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
 543                 {
 544
 545                     AFSDumpTraceFilesFnc();
 546
 547                     IoFreeMdl( pDevExt->Specific.RDR.CacheMdl);
 548                     pDevExt->Specific.RDR.CacheMdl = NULL;
 549                 }
 550
 551                 if( pDevExt->Specific.RDR.CacheMdl != NULL)
 552                 {
 553                     pDevExt->Specific.RDR.CacheLength = RedirInitInfo->MemoryCacheLength;
 554                     ntStatus = STATUS_SUCCESS;
 555                 }
 556
 557             }
 558         }
 559
 560         if( !NT_SUCCESS( ntStatus) &&
 561             RedirInitInfo->CacheFileNameLength == 0)
 562         {
 563
 564             AFSDbgLogMsg( AFS_SUBSYSTEM_INIT_PROCESSING,
 565                           AFS_TRACE_LEVEL_ERROR,
 566                           "AFSInitializeRedirector Unable to initialize cache file %08lX\n",
 567                           ntStatus);
 568
 569             try_return( ntStatus);
 570         }
 571
 572         if( pDevExt->Specific.RDR.CacheMdl == NULL)
 573         {
 574
 575             if( RedirInitInfo->CacheFileNameLength == 0)
 576             {
 577
 578                 AFSDbgLogMsg( AFS_SUBSYSTEM_INIT_PROCESSING,
 579                               AFS_TRACE_LEVEL_ERROR,
 580                               "AFSInitializeRedirector CacheMdl == NULL\n");
 581
 582                 try_return( ntStatus = STATUS_INVALID_PARAMETER);
 583             }
 584
 585             //
 586             // Go open the cache file
 587             //
 588
 589             pDevExt->Specific.RDR.CacheFile.Length = 0;
 590             pDevExt->Specific.RDR.CacheFile.MaximumLength = (USHORT)RedirInitInfo->CacheFileNameLength + (4 * sizeof( WCHAR));
 591
 592             pDevExt->Specific.RDR.CacheFile.Buffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
 593                                                                                         pDevExt->Specific.RDR.CacheFile.MaximumLength,
 594                                                                                         AFS_GENERIC_MEMORY_24_TAG);
 595
 596             if( pDevExt->Specific.RDR.CacheFile.Buffer == NULL)
 597             {
 598
 599                 AFSDbgLogMsg( AFS_SUBSYSTEM_INIT_PROCESSING,
 600                               AFS_TRACE_LEVEL_ERROR,
 601                               "AFSInitializeRedirector AFS_GENERIC_MEMORY_24_TAG allocation failure\n");
 602
 603                 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 604             }
 605
 606             RtlCopyMemory( pDevExt->Specific.RDR.CacheFile.Buffer,
 607                            L"\\??\\",
 608                            4 * sizeof( WCHAR));
 609
 610             pDevExt->Specific.RDR.CacheFile.Length = 4 * sizeof( WCHAR);
 611
 612             RtlCopyMemory( &pDevExt->Specific.RDR.CacheFile.Buffer[ pDevExt->Specific.RDR.CacheFile.Length/sizeof( WCHAR)],
 613                            RedirInitInfo->CacheFileName,
 614                            RedirInitInfo->CacheFileNameLength);
 615
 616             pDevExt->Specific.RDR.CacheFile.Length += (USHORT)RedirInitInfo->CacheFileNameLength;
 617
 618             InitializeObjectAttributes( &stObjectAttribs,
 619                                         &pDevExt->Specific.RDR.CacheFile,
 620                                         OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
 621                                         NULL,
 622                                         NULL);
 623
 624             ntStatus = ZwOpenFile( &pDevExt->Specific.RDR.CacheFileHandle,
 625                                    GENERIC_READ | GENERIC_WRITE,
 626                                    &stObjectAttribs,
 627                                    &stIoStatus,
 628                                    FILE_SHARE_READ | FILE_SHARE_WRITE,
 629                                    FILE_WRITE_THROUGH | FILE_RANDOM_ACCESS);
 630
 631             if( !NT_SUCCESS( ntStatus))
 632             {
 633
 634                 AFSDbgLogMsg( AFS_SUBSYSTEM_INIT_PROCESSING,
 635                               AFS_TRACE_LEVEL_ERROR,
 636                               "AFSInitializeRedirector ZwOpenFile failure %08lX\n",
 637                               ntStatus);
 638
 639                 try_return( ntStatus);
 640             }
 641
 642             //
 643             // Map to the fileobject
 644             //
 645
 646             ntStatus = ObReferenceObjectByHandle( pDevExt->Specific.RDR.CacheFileHandle,
 647                                                   SYNCHRONIZE,
 648                                                   NULL,
 649                                                   KernelMode,
 650                                                   (void **)&pDevExt->Specific.RDR.CacheFileObject,
 651                                                   NULL);
 652
 653             if( !NT_SUCCESS( ntStatus))
 654             {
 655
 656                 AFSDbgLogMsg( AFS_SUBSYSTEM_INIT_PROCESSING,
 657                               AFS_TRACE_LEVEL_ERROR,
 658                               "AFSInitializeRedirector ObReferenceObjectByHandle failure %08lX\n",
 659                               ntStatus);
 660
 661                 try_return( ntStatus);
 662             }
 663         }
 664
 665         pDevExt->Specific.RDR.MaxLinkCount = RedirInitInfo->MaxPathLinkCount;
 666
 667         pDevExt->Specific.RDR.NameArrayLength = RedirInitInfo->NameArrayLength;
 668
 669         //
 670         // Intialize the library
 671         //
 672
 673         ntStatus = AFSInitializeLibrary( &RedirInitInfo->GlobalFileId,
 674                                          TRUE);
 675
 676         if ( !NT_SUCCESS( ntStatus))
 677         {
 678             AFSDbgLogMsg( AFS_SUBSYSTEM_INIT_PROCESSING,
 679                           AFS_TRACE_LEVEL_ERROR,
 680                           "AFSInitializeRedirector AFSInitializeLibrary failure %08lX\n",
 681                           ntStatus);
 682         }
 683
 684 try_exit:
 685
 686         if( !NT_SUCCESS( ntStatus))
 687         {
 688
 689             if( pDevExt->Specific.RDR.CacheMdl != NULL)
 690             {
 691
 692                 MmUnmapLockedPages( pDevExt->Specific.RDR.CacheBaseAddress,
 693                                     pDevExt->Specific.RDR.CacheMdl);
 694
 695                 MmUnlockPages( pDevExt->Specific.RDR.CacheMdl);
 696
 697                 ExFreePool( pDevExt->Specific.RDR.CacheMdl);
 698
 699                 pDevExt->Specific.RDR.CacheMdl = NULL;
 700                 pDevExt->Specific.RDR.CacheBaseAddress = NULL;
 701                 pDevExt->Specific.RDR.CacheLength.QuadPart = 0;
 702             }
 703
 704             if( pDevExt->Specific.RDR.CacheFileHandle != NULL)
 705             {
 706
 707                 ZwClose( pDevExt->Specific.RDR.CacheFileHandle);
 708
 709                 pDevExt->Specific.RDR.CacheFileHandle = NULL;
 710             }
 711
 712             if( pDevExt->Specific.RDR.CacheFileObject != NULL)
 713             {
 714
 715                 ObDereferenceObject( pDevExt->Specific.RDR.CacheFileObject);
 716
 717                 pDevExt->Specific.RDR.CacheFileObject = NULL;
 718             }
 719
 720             if( pDevExt->Specific.RDR.CacheFile.Buffer != NULL)
 721             {
 722
 723                 ExFreePool( pDevExt->Specific.RDR.CacheFile.Buffer);
 724
 725                 pDevExt->Specific.RDR.CacheFile.Buffer = NULL;
 726             }
 727
 728             if( AFSDumpFileLocation.Buffer != NULL)
 729             {
 730                 ExFreePool( AFSDumpFileLocation.Buffer);
 731
 732                 AFSDumpFileLocation.Buffer = NULL;
 733             }
 734
 735             if ( pDevExt->Fcb != NULL)
 736             {
 737
 738                 AFSRemoveRdrFcb( &pDevExt->Fcb);
 739
 740                 pDevExt = NULL;
 741             }
 742
 743             AFSUnloadLibrary( TRUE);
 744         }
 745     }
 746
 747     return ntStatus;
 748 }
 749
 750 NTSTATUS
 751 AFSCloseRedirector()
 752 {
 753
 754     NTSTATUS ntStatus = STATUS_SUCCESS;
 755     AFSDeviceExt *pDevExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
 756
 757     __Enter
 758     {
 759
 760         //
 761         // Unload the library first so we close off any accesses to the cache or underlying
 762         // shared memory
 763         //
 764
 765         AFSUnloadLibrary( TRUE);
 766
 767         //
 768         // Close off the cache file or mapping
 769         //
 770
 771         if( pDevExt->Specific.RDR.CacheMdl != NULL)
 772         {
 773
 774             MmUnmapLockedPages( pDevExt->Specific.RDR.CacheBaseAddress,
 775                                 pDevExt->Specific.RDR.CacheMdl);
 776
 777             MmUnlockPages( pDevExt->Specific.RDR.CacheMdl);
 778
 779             ExFreePool( pDevExt->Specific.RDR.CacheMdl);
 780
 781             pDevExt->Specific.RDR.CacheMdl = NULL;
 782             pDevExt->Specific.RDR.CacheBaseAddress = NULL;
 783             pDevExt->Specific.RDR.CacheLength.QuadPart = 0;
 784         }
 785
 786         if( pDevExt->Specific.RDR.CacheFileHandle != NULL)
 787         {
 788
 789             ZwClose( pDevExt->Specific.RDR.CacheFileHandle);
 790
 791             pDevExt->Specific.RDR.CacheFileHandle = NULL;
 792         }
 793
 794         if( pDevExt->Specific.RDR.CacheFileObject != NULL)
 795         {
 796
 797             ObDereferenceObject( pDevExt->Specific.RDR.CacheFileObject);
 798
 799             pDevExt->Specific.RDR.CacheFileObject = NULL;
 800         }
 801
 802         if( pDevExt->Specific.RDR.CacheFile.Buffer != NULL)
 803         {
 804
 805             ExFreePool( pDevExt->Specific.RDR.CacheFile.Buffer);
 806
 807             pDevExt->Specific.RDR.CacheFile.Buffer = NULL;
 808         }
 809
 810         if( AFSDumpFileLocation.Buffer != NULL)
 811         {
 812             ExFreePool( AFSDumpFileLocation.Buffer);
 813
 814             AFSDumpFileLocation.Buffer = NULL;
 815         }
 816
 817         if ( pDevExt->Fcb != NULL)
 818         {
 819
 820             AFSRemoveRdrFcb( &pDevExt->Fcb);
 821
 822             pDevExt->Fcb = NULL;
 823         }
 824
 825     }
 826
 827     return ntStatus;
 828 }
 829
 830 //
 831 // Function: AFSInitRdrFcb
 832 //
 833 // Description:
 834 //
 835 //      This function performs Redirector Fcb initialization
 836 //
 837 // Return:
 838 //
 839 //      A status is returned for the function
 840 //
 841
 842 NTSTATUS
 843 AFSInitRdrFcb( OUT AFSFcb **RdrFcb)
 844 {
 845
 846     NTSTATUS ntStatus = STATUS_SUCCESS;
 847     AFSFcb *pFcb = NULL;
 848     AFSNonPagedFcb *pNPFcb = NULL;
 849
 850     __Enter
 851     {
 852
 853         //
 854         // Initialize the root fcb
 855         //
 856
 857         pFcb = (AFSFcb *)AFSExAllocatePoolWithTag( PagedPool,
 858                                                    sizeof( AFSFcb),
 859                                                    AFS_FCB_ALLOCATION_TAG);
 860
 861         if( pFcb == NULL)
 862         {
 863
 864             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 865                           AFS_TRACE_LEVEL_ERROR,
 866                           "AFSInitRdrFcb Failed to allocate the root fcb\n");
 867
 868             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 869         }
 870
 871         RtlZeroMemory( pFcb,
 872                        sizeof( AFSFcb));
 873
 874         pFcb->Header.NodeByteSize = sizeof( AFSFcb);
 875         pFcb->Header.NodeTypeCode = AFS_REDIRECTOR_FCB;
 876
 877         pNPFcb = (AFSNonPagedFcb *)AFSExAllocatePoolWithTag( NonPagedPool,
 878                                                              sizeof( AFSNonPagedFcb),
 879                                                              AFS_FCB_NP_ALLOCATION_TAG);
 880
 881         if( pNPFcb == NULL)
 882         {
 883
 884             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 885                           AFS_TRACE_LEVEL_ERROR,
 886                           "AFSInitRdrFcb Failed to allocate the non-paged fcb\n");
 887
 888             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 889         }
 890
 891         RtlZeroMemory( pNPFcb,
 892                        sizeof( AFSNonPagedFcb));
 893
 894         pNPFcb->Size = sizeof( AFSNonPagedFcb);
 895
 896         pNPFcb->Type = AFS_NON_PAGED_FCB;
 897
 898         //
 899         // OK, initialize the entry
 900         //
 901
 902         ExInitializeFastMutex( &pNPFcb->AdvancedHdrMutex);
 903
 904         FsRtlSetupAdvancedHeader( &pFcb->Header, &pNPFcb->AdvancedHdrMutex);
 905
 906         ExInitializeResourceLite( &pNPFcb->Resource);
 907
 908         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 909                       AFS_TRACE_LEVEL_VERBOSE,
 910                       "AFSInitRootFcb Acquiring Fcb lock %08lX EXCL %08lX\n",
 911                       &pNPFcb->Resource,
 912                       PsGetCurrentThread());
 913
 914         ExInitializeResourceLite( &pNPFcb->PagingResource);
 915
 916         pFcb->Header.Resource = &pNPFcb->Resource;
 917
 918         pFcb->Header.PagingIoResource = &pNPFcb->PagingResource;
 919
 920         pFcb->NPFcb = pNPFcb;
 921
 922         if ( InterlockedCompareExchangePointer( (PVOID *)RdrFcb, pFcb, NULL) != NULL)
 923         {
 924
 925             try_return( ntStatus = STATUS_REPARSE);
 926         }
 927
 928 try_exit:
 929
 930         if( ntStatus != STATUS_SUCCESS)
 931         {
 932
 933             if( pFcb != NULL)
 934             {
 935
 936                 AFSRemoveRdrFcb( &pFcb);
 937             }
 938         }
 939     }
 940
 941     return ntStatus;
 942 }
 943
 944 //
 945 // Function: AFSRemoveRdrFcb
 946 //
 947 // Description:
 948 //
 949 //      This function performs Redirector Fcb removal/deallocation
 950 //
 951 // Return:
 952 //
 953 //      void.
 954 //
 955
 956 void
 957 AFSRemoveRdrFcb( IN OUT AFSFcb **RdrFcb)
 958 {
 959     AFSFcb *pFcb = NULL;
 960
 961     pFcb = (AFSFcb *) InterlockedCompareExchangePointer( (PVOID *)RdrFcb, NULL, (PVOID)(*RdrFcb));
 962
 963     if ( pFcb == NULL)
 964     {
 965
 966         return;
 967     }
 968
 969     if( pFcb->NPFcb != NULL)
 970     {
 971
 972         //
 973         // Now the resource
 974         //
 975
 976         ExDeleteResourceLite( &pFcb->NPFcb->Resource);
 977
 978         ExDeleteResourceLite( &pFcb->NPFcb->PagingResource);
 979
 980         //
 981         // The non paged region
 982         //
 983
 984         AFSExFreePoolWithTag( pFcb->NPFcb, AFS_FCB_NP_ALLOCATION_TAG);
 985     }
 986
 987     //
 988     // And the Fcb itself
 989     //
 990
 991     AFSExFreePoolWithTag( pFcb, AFS_FCB_ALLOCATION_TAG);
 992
 993     return;
 994 }