src/WINNT/afsrdr/kernel/lib/AFSFcbSupport.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: AFSFcbSupport.cpp
  37 //
  38
  39 #include "AFSCommon.h"
  40
  41 //
  42 // Function: AFSInitFcb
  43 //
  44 // Description:
  45 //
  46 //      This function performs Fcb initialization
  47 //
  48 // Return:
  49 //
  50 //      A status is returned for the function
  51 //
  52
  53 NTSTATUS
  54 AFSInitFcb( IN AFSDirectoryCB  *DirEntry,
  55             IN OUT AFSFcb     **Fcb)
  56 {
  57
  58     NTSTATUS ntStatus = STATUS_SUCCESS;
  59     AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
  60     AFSFcb *pFcb = NULL;
  61     AFSNonPagedFcb *pNPFcb = NULL;
  62     IO_STATUS_BLOCK stIoSb = {0,0};
  63     BOOLEAN bUninitFileLock = FALSE;
  64     USHORT  usFcbLength = 0;
  65     ULONGLONG   ullIndex = 0;
  66     AFSDirEnumEntry *pDirEnumCB = NULL;
  67     AFSObjectInfoCB *pObjectInfo = NULL, *pParentObjectInfo = NULL;
  68     AFSVolumeCB *pVolumeCB = NULL;
  69
  70     __Enter
  71     {
  72
  73         pObjectInfo = DirEntry->ObjectInformation;
  74
  75         pParentObjectInfo = pObjectInfo->ParentObjectInformation;
  76
  77         pVolumeCB = pObjectInfo->VolumeCB;
  78
  79         //
  80         // Allocate the Fcb and the nonpaged portion of the Fcb.
  81         //
  82
  83         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
  84                       AFS_TRACE_LEVEL_VERBOSE_2,
  85                       "AFSInitFcb Initializing fcb for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
  86                       &DirEntry->NameInformation.FileName,
  87                       pObjectInfo->FileId.Cell,
  88                       pObjectInfo->FileId.Volume,
  89                       pObjectInfo->FileId.Vnode,
  90                       pObjectInfo->FileId.Unique);
  91
  92         usFcbLength = sizeof( AFSFcb);
  93
  94         pFcb = (AFSFcb *)AFSExAllocatePoolWithTag( PagedPool,
  95                                                    usFcbLength,
  96                                                    AFS_FCB_ALLOCATION_TAG);
  97
  98         if( pFcb == NULL)
  99         {
 100
 101             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 102                           AFS_TRACE_LEVEL_ERROR,
 103                           "AFSInitFcb Failed to allocate fcb\n");
 104
 105             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 106         }
 107
 108         RtlZeroMemory( pFcb,
 109                        usFcbLength);
 110
 111         pFcb->Header.NodeByteSize = usFcbLength;
 112
 113         pNPFcb = (AFSNonPagedFcb *)AFSExAllocatePoolWithTag( NonPagedPool,
 114                                                              sizeof( AFSNonPagedFcb),
 115                                                              AFS_FCB_NP_ALLOCATION_TAG);
 116
 117         if( pNPFcb == NULL)
 118         {
 119
 120             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 121                           AFS_TRACE_LEVEL_ERROR,
 122                           "AFSInitFcb Failed to allocate non-paged fcb\n");
 123
 124             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 125         }
 126
 127         RtlZeroMemory( pNPFcb,
 128                        sizeof( AFSNonPagedFcb));
 129
 130         pNPFcb->Size = sizeof( AFSNonPagedFcb);
 131         pNPFcb->Type = AFS_NON_PAGED_FCB;
 132
 133         //
 134         // Initialize the advanced header
 135         //
 136
 137         ExInitializeFastMutex( &pNPFcb->AdvancedHdrMutex);
 138
 139         FsRtlSetupAdvancedHeader( &pFcb->Header, &pNPFcb->AdvancedHdrMutex);
 140
 141         //
 142         // OK, initialize the entry
 143         //
 144
 145         ExInitializeResourceLite( &pNPFcb->Resource);
 146
 147         ExInitializeResourceLite( &pNPFcb->PagingResource);
 148
 149         ExInitializeResourceLite( &pNPFcb->CcbListLock);
 150
 151         pFcb->Header.Resource = &pNPFcb->Resource;
 152
 153         pFcb->Header.PagingIoResource = &pNPFcb->PagingResource;
 154
 155         //
 156         // Grab the Fcb for processing
 157         //
 158
 159         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 160                       AFS_TRACE_LEVEL_VERBOSE,
 161                       "AFSInitFcb Acquiring Fcb lock %08lX EXCL %08lX\n",
 162                       &pNPFcb->Resource,
 163                       PsGetCurrentThread());
 164
 165         AFSAcquireExcl( &pNPFcb->Resource,
 166                         TRUE);
 167
 168         pFcb->NPFcb = pNPFcb;
 169
 170         //
 171         // Initialize some fields in the Fcb
 172         //
 173
 174         pFcb->ObjectInformation = pObjectInfo;
 175
 176         pObjectInfo->Fcb = pFcb;
 177
 178         //
 179         // Set type specific information
 180         //
 181
 182         if( pObjectInfo->FileType == AFS_FILE_TYPE_DIRECTORY)
 183         {
 184
 185             //
 186             // Reset the type to a directory type
 187             //
 188
 189             pFcb->Header.NodeTypeCode = AFS_DIRECTORY_FCB;
 190
 191             //
 192             // Initialize enumeration information
 193             //
 194
 195             KeInitializeEvent( &pFcb->NPFcb->Specific.Directory.DirectoryEnumEvent,
 196                                NotificationEvent,
 197                                FALSE);
 198         }
 199         else if( pObjectInfo->FileType == AFS_FILE_TYPE_FILE)
 200         {
 201
 202             pFcb->Header.NodeTypeCode = AFS_FILE_FCB;
 203
 204             //
 205             // Initialize the file specific information
 206             //
 207
 208             FsRtlInitializeFileLock( &pFcb->Specific.File.FileLock,
 209                                      NULL,
 210                                      NULL);
 211
 212             bUninitFileLock = TRUE;
 213
 214             //
 215             // Initialize the header file sizes to our dir entry information
 216             //
 217
 218             pFcb->Header.AllocationSize.QuadPart = pObjectInfo->AllocationSize.QuadPart;
 219             pFcb->Header.FileSize.QuadPart = pObjectInfo->EndOfFile.QuadPart;
 220             pFcb->Header.ValidDataLength.QuadPart = pObjectInfo->EndOfFile.QuadPart;
 221
 222             //
 223             // Initialize the Extents resources and so forth.  The
 224             // quiescent state is that no one has the extents for
 225             // IO (do the extents are not busy) and there is no
 226             // extents request outstanding (and hence the "last
 227             // one" is complete).
 228             //
 229             ExInitializeResourceLite( &pNPFcb->Specific.File.ExtentsResource );
 230
 231             KeInitializeEvent( &pNPFcb->Specific.File.ExtentsRequestComplete,
 232                                NotificationEvent,
 233                                TRUE );
 234
 235             for (ULONG i = 0; i < AFS_NUM_EXTENT_LISTS; i++)
 236             {
 237                 InitializeListHead(&pFcb->Specific.File.ExtentsLists[i]);
 238             }
 239
 240             pNPFcb->Specific.File.DirtyListHead = NULL;
 241             pNPFcb->Specific.File.DirtyListTail = NULL;
 242
 243             ExInitializeResourceLite( &pNPFcb->Specific.File.DirtyExtentsListLock);
 244
 245             KeInitializeEvent( &pNPFcb->Specific.File.FlushEvent,
 246                                SynchronizationEvent,
 247                                TRUE);
 248
 249             KeInitializeEvent( &pNPFcb->Specific.File.QueuedFlushEvent,
 250                                NotificationEvent,
 251                                TRUE);
 252         }
 253         else if( pObjectInfo->FileType == AFS_FILE_TYPE_SPECIAL_SHARE_NAME)
 254         {
 255
 256             pFcb->Header.NodeTypeCode = AFS_SPECIAL_SHARE_FCB;
 257         }
 258         else if( pObjectInfo->FileType == AFS_FILE_TYPE_PIOCTL)
 259         {
 260
 261             pFcb->Header.NodeTypeCode = AFS_IOCTL_FCB;
 262         }
 263         else if( pObjectInfo->FileType == AFS_FILE_TYPE_SYMLINK)
 264         {
 265
 266             pFcb->Header.NodeTypeCode = AFS_SYMBOLIC_LINK_FCB;
 267         }
 268         else if( pObjectInfo->FileType == AFS_FILE_TYPE_MOUNTPOINT)
 269         {
 270
 271             pFcb->Header.NodeTypeCode = AFS_MOUNT_POINT_FCB;
 272         }
 273         else if( pObjectInfo->FileType == AFS_FILE_TYPE_DFSLINK)
 274         {
 275             pFcb->Header.NodeTypeCode = AFS_DFS_LINK_FCB;
 276         }
 277         else
 278         {
 279             ASSERT( FALSE);
 280             try_return( ntStatus = STATUS_INVALID_PARAMETER);
 281         }
 282
 283         //
 284         // And return the Fcb
 285         //
 286
 287         *Fcb = pFcb;
 288
 289         AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
 290                       AFS_TRACE_LEVEL_VERBOSE,
 291                       "AFSInitFcb Initialized Fcb %08lX Name %wZ\n",
 292                       pFcb,
 293                       &DirEntry->NameInformation.FileName);
 294
 295 try_exit:
 296
 297         if( !NT_SUCCESS( ntStatus))
 298         {
 299
 300             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 301                           AFS_TRACE_LEVEL_ERROR,
 302                           "AFSInitFcb Failed to initialize fcb Status %08lX\n",
 303                           ntStatus);
 304
 305             if( pFcb != NULL)
 306             {
 307
 308                 if( bUninitFileLock)
 309                 {
 310
 311                     FsRtlUninitializeFileLock( &pFcb->Specific.File.FileLock);
 312                 }
 313
 314                 if( pNPFcb != NULL)
 315                 {
 316
 317                     AFSReleaseResource( &pNPFcb->Resource);
 318
 319                     ExDeleteResourceLite( &pNPFcb->PagingResource);
 320
 321                     ExDeleteResourceLite( &pNPFcb->CcbListLock);
 322
 323                     ExDeleteResourceLite( &pNPFcb->Resource);
 324                 }
 325
 326                 AFSExFreePool( pFcb);
 327             }
 328
 329             if( pNPFcb != NULL)
 330             {
 331
 332                 AFSExFreePool( pNPFcb);
 333             }
 334
 335             if( Fcb != NULL)
 336             {
 337
 338                 *Fcb = NULL;
 339             }
 340         }
 341     }
 342
 343     return ntStatus;
 344 }
 345
 346 NTSTATUS
 347 AFSInitVolume( IN GUID *AuthGroup,
 348                IN AFSFileID *RootFid,
 349                OUT AFSVolumeCB **VolumeCB)
 350 {
 351
 352     NTSTATUS ntStatus = STATUS_SUCCESS;
 353     IO_STATUS_BLOCK stIoStatus = {0,0};
 354     AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
 355     AFSNonPagedVolumeCB *pNonPagedVcb = NULL;
 356     AFSVolumeCB *pVolumeCB = NULL;
 357     AFSNonPagedObjectInfoCB *pNonPagedObject = NULL;
 358     ULONGLONG ullIndex = 0;
 359     BOOLEAN bReleaseLocks = FALSE;
 360     AFSVolumeInfoCB stVolumeInformation;
 361     AFSNonPagedDirectoryCB *pNonPagedDirEntry = NULL;
 362
 363     __Enter
 364     {
 365
 366         //
 367         // Before grabbing any locks ask the service for the volume information
 368         // This may be a waste but we need to get this information prior to
 369         // taking any volume tree locks. Don't do this for any 'reserved' cell entries
 370         //
 371
 372         if( RootFid->Cell != 0)
 373         {
 374
 375             RtlZeroMemory( &stVolumeInformation,
 376                            sizeof( AFSVolumeInfoCB));
 377
 378             ntStatus = AFSRetrieveVolumeInformation( AuthGroup,
 379                                                      RootFid,
 380                                                      &stVolumeInformation);
 381
 382             if( !NT_SUCCESS( ntStatus))
 383             {
 384
 385                 AFSDbgLogMsg( AFS_SUBSYSTEM_LOAD_LIBRARY | AFS_SUBSYSTEM_INIT_PROCESSING,
 386                               AFS_TRACE_LEVEL_ERROR,
 387                               "AFSInitVolume AFSRetrieveVolumeInformation(RootFid) failure %08lX\n",
 388                               ntStatus);
 389
 390                 try_return( ntStatus);
 391             }
 392
 393             //
 394             // Grab our tree locks and see if we raced with someone else
 395             //
 396
 397             AFSAcquireExcl( pDeviceExt->Specific.RDR.VolumeTree.TreeLock,
 398                             TRUE);
 399
 400             AFSAcquireExcl( &pDeviceExt->Specific.RDR.VolumeListLock,
 401                             TRUE);
 402
 403             bReleaseLocks = TRUE;
 404
 405             ullIndex = AFSCreateHighIndex( RootFid);
 406
 407             ntStatus = AFSLocateHashEntry( pDeviceExt->Specific.RDR.VolumeTree.TreeHead,
 408                                            ullIndex,
 409                                            (AFSBTreeEntry **)&pVolumeCB);
 410
 411             if( NT_SUCCESS( ntStatus) &&
 412                 pVolumeCB != NULL)
 413             {
 414
 415                 //
 416                 // So we don't lock with an invalidation call ...
 417                 //
 418
 419                 InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
 420
 421                 AFSReleaseResource( pDeviceExt->Specific.RDR.VolumeTree.TreeLock);
 422
 423                 AFSReleaseResource( &pDeviceExt->Specific.RDR.VolumeListLock);
 424
 425                 bReleaseLocks = FALSE;
 426
 427                 AFSAcquireExcl( pVolumeCB->VolumeLock,
 428                                 TRUE);
 429
 430                 InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
 431
 432                 *VolumeCB = pVolumeCB;
 433
 434                 try_return( ntStatus);
 435             }
 436
 437             //
 438             // Revert our status from the above call back to success.
 439             //
 440
 441             ntStatus = STATUS_SUCCESS;
 442         }
 443
 444         //
 445         // For the global root we allocate out volume node and insert it
 446         // into the volume tree ...
 447         //
 448
 449         pVolumeCB = (AFSVolumeCB *)AFSExAllocatePoolWithTag( NonPagedPool,
 450                                                              sizeof( AFSVolumeCB),
 451                                                              AFS_VCB_ALLOCATION_TAG);
 452
 453         if( pVolumeCB == NULL)
 454         {
 455
 456             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 457                           AFS_TRACE_LEVEL_ERROR,
 458                           "AFSInitVolume Failed to allocate the root volume cb\n");
 459
 460             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 461         }
 462
 463         RtlZeroMemory( pVolumeCB,
 464                        sizeof( AFSVolumeCB));
 465
 466         //
 467         // The non paged portion
 468         //
 469
 470         pNonPagedVcb = (AFSNonPagedVolumeCB *)AFSExAllocatePoolWithTag( NonPagedPool,
 471                                                                         sizeof( AFSNonPagedVolumeCB),
 472                                                                         AFS_VCB_ALLOCATION_TAG);
 473
 474         if( pNonPagedVcb == NULL)
 475         {
 476
 477             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 478                           AFS_TRACE_LEVEL_ERROR,
 479                           "AFSInitVolume Failed to allocate the root non paged volume cb\n");
 480
 481             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 482         }
 483
 484         RtlZeroMemory( pNonPagedVcb,
 485                        sizeof( AFSNonPagedVolumeCB));
 486
 487         ExInitializeResourceLite( &pNonPagedVcb->VolumeLock);
 488
 489         ExInitializeResourceLite( &pNonPagedVcb->ObjectInfoTreeLock);
 490
 491         pNonPagedObject = (AFSNonPagedObjectInfoCB *)AFSExAllocatePoolWithTag( NonPagedPool,
 492                                                                                sizeof( AFSNonPagedObjectInfoCB),
 493                                                                                AFS_VCB_ALLOCATION_TAG);
 494
 495         if( pNonPagedObject == NULL)
 496         {
 497
 498             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 499                           AFS_TRACE_LEVEL_ERROR,
 500                           "AFSInitVolume Failed to allocate the root non paged object cb\n");
 501
 502             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 503         }
 504
 505         RtlZeroMemory( pNonPagedObject,
 506                        sizeof( AFSNonPagedObjectInfoCB));
 507
 508         ExInitializeResourceLite( &pNonPagedObject->DirectoryNodeHdrLock);
 509
 510         pVolumeCB->NonPagedVcb = pNonPagedVcb;
 511
 512         pVolumeCB->ObjectInformation.NonPagedInfo = pNonPagedObject;
 513
 514         pVolumeCB->VolumeLock = &pNonPagedVcb->VolumeLock;
 515
 516         pVolumeCB->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock = &pNonPagedObject->DirectoryNodeHdrLock;
 517
 518         pVolumeCB->ObjectInfoTree.TreeLock = &pNonPagedVcb->ObjectInfoTreeLock;
 519
 520         //
 521         // Bias our reference by 1
 522         //
 523
 524         AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
 525                       AFS_TRACE_LEVEL_VERBOSE,
 526                       "AFSInitVolume Initializing count (1) on volume %08lX\n",
 527                       pVolumeCB);
 528
 529         pVolumeCB->VolumeReferenceCount = 1;
 530
 531         AFSAcquireExcl( pVolumeCB->VolumeLock,
 532                         TRUE);
 533
 534         pVolumeCB->DirectoryCB = (AFSDirectoryCB *)AFSExAllocatePoolWithTag( PagedPool,
 535                                                                              sizeof( AFSDirectoryCB) + sizeof( WCHAR),
 536                                                                              AFS_DIR_ENTRY_TAG);
 537
 538         if( pVolumeCB->DirectoryCB == NULL)
 539         {
 540
 541             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 542         }
 543
 544         pNonPagedDirEntry = (AFSNonPagedDirectoryCB *)AFSExAllocatePoolWithTag( NonPagedPool,
 545                                                                                 sizeof( AFSNonPagedDirectoryCB),
 546                                                                                 AFS_DIR_ENTRY_NP_TAG);
 547
 548         if( pNonPagedDirEntry == NULL)
 549         {
 550
 551             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 552         }
 553
 554         RtlZeroMemory( pVolumeCB->DirectoryCB,
 555                        sizeof( AFSDirectoryCB) + sizeof( WCHAR));
 556
 557         RtlZeroMemory( pNonPagedDirEntry,
 558                        sizeof( AFSNonPagedDirectoryCB));
 559
 560         ExInitializeResourceLite( &pNonPagedDirEntry->Lock);
 561
 562         pVolumeCB->DirectoryCB->NonPaged = pNonPagedDirEntry;
 563
 564         //
 565         // Initialize the non-paged portion of the directory entry
 566         //
 567
 568         KeQuerySystemTime( &pVolumeCB->ObjectInformation.CreationTime);
 569         KeQuerySystemTime( &pVolumeCB->ObjectInformation.LastWriteTime);
 570         KeQuerySystemTime( &pVolumeCB->ObjectInformation.LastAccessTime);
 571
 572         pVolumeCB->ObjectInformation.FileType = AFS_FILE_TYPE_DIRECTORY;
 573
 574         SetFlag( pVolumeCB->ObjectInformation.Flags, AFS_OBJECT_ROOT_VOLUME);
 575
 576         pVolumeCB->ObjectInformation.FileId.Cell = RootFid->Cell;
 577         pVolumeCB->ObjectInformation.FileId.Volume = RootFid->Volume;
 578         pVolumeCB->ObjectInformation.FileId.Vnode = RootFid->Vnode;
 579         pVolumeCB->ObjectInformation.FileId.Unique = RootFid->Unique;
 580         pVolumeCB->ObjectInformation.FileId.Hash = RootFid->Hash;
 581
 582         pVolumeCB->ObjectInformation.FileAttributes = FILE_ATTRIBUTE_DIRECTORY;
 583
 584         pVolumeCB->DirectoryCB->NameInformation.FileName.Length = sizeof( WCHAR);
 585
 586         pVolumeCB->DirectoryCB->NameInformation.FileName.MaximumLength = pVolumeCB->DirectoryCB->NameInformation.FileName.Length;
 587
 588         pVolumeCB->DirectoryCB->NameInformation.FileName.Buffer = (WCHAR *)((char *)pVolumeCB->DirectoryCB + sizeof( AFSDirectoryCB));
 589
 590         RtlCopyMemory( pVolumeCB->DirectoryCB->NameInformation.FileName.Buffer,
 591                        L"\\",
 592                        sizeof( WCHAR));
 593
 594         //
 595         // Copy in the volume information retrieved above
 596         //
 597
 598         RtlCopyMemory( &pVolumeCB->VolumeInformation,
 599                        &stVolumeInformation,
 600                        sizeof( AFSVolumeInfoCB));
 601
 602         //
 603         // Setup pointers
 604         //
 605
 606         pVolumeCB->DirectoryCB->ObjectInformation = &pVolumeCB->ObjectInformation;
 607
 608         pVolumeCB->DirectoryCB->ObjectInformation->VolumeCB = pVolumeCB;
 609
 610         //
 611         // Insert the volume into our volume tree. Don't insert any reserved entries
 612         //
 613
 614         if( RootFid->Cell != 0)
 615         {
 616
 617             pVolumeCB->TreeEntry.HashIndex = ullIndex;
 618
 619             if( pDeviceExt->Specific.RDR.VolumeTree.TreeHead == NULL)
 620             {
 621
 622                 pDeviceExt->Specific.RDR.VolumeTree.TreeHead = &pVolumeCB->TreeEntry;
 623             }
 624             else
 625             {
 626
 627                 AFSInsertHashEntry( pDeviceExt->Specific.RDR.VolumeTree.TreeHead,
 628                                     &pVolumeCB->TreeEntry);
 629             }
 630
 631             SetFlag( pVolumeCB->Flags, AFS_VOLUME_INSERTED_HASH_TREE);
 632
 633             if( pDeviceExt->Specific.RDR.VolumeListHead == NULL)
 634             {
 635
 636                 pDeviceExt->Specific.RDR.VolumeListHead = pVolumeCB;
 637             }
 638             else
 639             {
 640
 641                 pDeviceExt->Specific.RDR.VolumeListTail->ListEntry.fLink = (void *)pVolumeCB;
 642
 643                 pVolumeCB->ListEntry.bLink = pDeviceExt->Specific.RDR.VolumeListTail;
 644             }
 645
 646             pDeviceExt->Specific.RDR.VolumeListTail = pVolumeCB;
 647         }
 648
 649         *VolumeCB = pVolumeCB;
 650
 651 try_exit:
 652
 653         if( !NT_SUCCESS( ntStatus))
 654         {
 655
 656             if( pNonPagedVcb != NULL)
 657             {
 658
 659                 AFSReleaseResource( pVolumeCB->VolumeLock);
 660
 661                 ExDeleteResourceLite( &pNonPagedVcb->VolumeLock);
 662
 663                 ExDeleteResourceLite( &pNonPagedVcb->ObjectInfoTreeLock);
 664
 665                 AFSExFreePool( pNonPagedVcb);
 666             }
 667
 668             if( pNonPagedObject != NULL)
 669             {
 670
 671                 ExDeleteResourceLite( &pNonPagedObject->DirectoryNodeHdrLock);
 672
 673                 AFSExFreePool( pNonPagedObject);
 674             }
 675
 676             if( pVolumeCB != NULL)
 677             {
 678
 679                 if( pVolumeCB->DirectoryCB != NULL)
 680                 {
 681
 682                     AFSExFreePool( pVolumeCB->DirectoryCB);
 683                 }
 684
 685                 AFSExFreePool( pVolumeCB);
 686             }
 687
 688             if( pNonPagedDirEntry != NULL)
 689             {
 690
 691                 ExDeleteResourceLite( &pNonPagedDirEntry->Lock);
 692
 693                 AFSExFreePool( pNonPagedDirEntry);
 694             }
 695         }
 696
 697         if( bReleaseLocks)
 698         {
 699
 700             AFSReleaseResource( pDeviceExt->Specific.RDR.VolumeTree.TreeLock);
 701
 702             AFSReleaseResource( &pDeviceExt->Specific.RDR.VolumeListLock);
 703         }
 704     }
 705
 706     return ntStatus;
 707 }
 708
 709 NTSTATUS
 710 AFSRemoveVolume( IN AFSVolumeCB *VolumeCB)
 711 {
 712
 713     NTSTATUS ntStatus = STATUS_SUCCESS;
 714     AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
 715
 716     __Enter
 717     {
 718
 719         //
 720         // Remove the volume from the tree and list
 721         // Don't process the list information for reserved entries
 722         //
 723
 724         if( VolumeCB->ObjectInformation.FileId.Cell != 0)
 725         {
 726
 727             if( BooleanFlagOn( VolumeCB->Flags, AFS_VOLUME_INSERTED_HASH_TREE))
 728             {
 729
 730                 AFSRemoveHashEntry( &pDeviceExt->Specific.RDR.VolumeTree.TreeHead,
 731                                     &VolumeCB->TreeEntry);
 732             }
 733
 734             if( VolumeCB->ListEntry.fLink == NULL)
 735             {
 736
 737                 pDeviceExt->Specific.RDR.VolumeListTail = (AFSVolumeCB *)VolumeCB->ListEntry.bLink;
 738
 739                 if( pDeviceExt->Specific.RDR.VolumeListTail != NULL)
 740                 {
 741
 742                     pDeviceExt->Specific.RDR.VolumeListTail->ListEntry.fLink = NULL;
 743                 }
 744             }
 745             else
 746             {
 747
 748                 ((AFSVolumeCB *)(VolumeCB->ListEntry.fLink))->ListEntry.bLink = VolumeCB->ListEntry.bLink;
 749             }
 750
 751             if( VolumeCB->ListEntry.bLink == NULL)
 752             {
 753
 754                 pDeviceExt->Specific.RDR.VolumeListHead = (AFSVolumeCB *)VolumeCB->ListEntry.fLink;
 755
 756                 if( pDeviceExt->Specific.RDR.VolumeListHead != NULL)
 757                 {
 758
 759                     pDeviceExt->Specific.RDR.VolumeListHead->ListEntry.bLink = NULL;
 760                 }
 761             }
 762             else
 763             {
 764
 765                 ((AFSVolumeCB *)(VolumeCB->ListEntry.bLink))->ListEntry.fLink = VolumeCB->ListEntry.fLink;
 766             }
 767         }
 768
 769         //
 770         // Remove any PIOctl objects we have
 771         //
 772
 773         if( VolumeCB->ObjectInformation.Specific.Directory.PIOCtlDirectoryCB != NULL)
 774         {
 775
 776             if( VolumeCB->ObjectInformation.Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb != NULL)
 777             {
 778
 779                 AFSRemoveFcb( VolumeCB->ObjectInformation.Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb);
 780             }
 781
 782             AFSDeleteObjectInfo( VolumeCB->ObjectInformation.Specific.Directory.PIOCtlDirectoryCB->ObjectInformation);
 783
 784             AFSExFreePool( VolumeCB->ObjectInformation.Specific.Directory.PIOCtlDirectoryCB);
 785         }
 786
 787         if( BooleanFlagOn( VolumeCB->ObjectInformation.Flags, AFS_OBJECT_HELD_IN_SERVICE))
 788         {
 789
 790             //
 791             // Release the fid in the service
 792             //
 793
 794             AFSReleaseFid( &VolumeCB->ObjectInformation.FileId);
 795         }
 796
 797         //
 798         // Free up the memory
 799         //
 800
 801         if( VolumeCB->NonPagedVcb != NULL)
 802         {
 803
 804             if( ExIsResourceAcquiredLite( VolumeCB->VolumeLock))
 805             {
 806
 807                 AFSReleaseResource( VolumeCB->VolumeLock);
 808             }
 809
 810             ExDeleteResourceLite( &VolumeCB->NonPagedVcb->VolumeLock);
 811
 812             ExDeleteResourceLite( &VolumeCB->NonPagedVcb->ObjectInfoTreeLock);
 813
 814             AFSExFreePool( VolumeCB->NonPagedVcb);
 815         }
 816
 817         if( VolumeCB->ObjectInformation.NonPagedInfo != NULL)
 818         {
 819
 820             ExDeleteResourceLite( &VolumeCB->ObjectInformation.NonPagedInfo->DirectoryNodeHdrLock);
 821
 822             AFSExFreePool( VolumeCB->ObjectInformation.NonPagedInfo);
 823         }
 824
 825         if( VolumeCB->DirectoryCB != NULL)
 826         {
 827
 828             if( VolumeCB->DirectoryCB->NonPaged != NULL)
 829             {
 830
 831                 ExDeleteResourceLite( &VolumeCB->DirectoryCB->NonPaged->Lock);
 832
 833                 AFSExFreePool( VolumeCB->DirectoryCB->NonPaged);
 834             }
 835
 836             AFSExFreePool( VolumeCB->DirectoryCB);
 837         }
 838
 839         AFSExFreePool( VolumeCB);
 840     }
 841
 842     return ntStatus;
 843 }
 844
 845
 846 //
 847 // Function: AFSInitRootFcb
 848 //
 849 // Description:
 850 //
 851 //      This function performs Root node Fcb initialization
 852 //
 853 // Return:
 854 //
 855 //      A status is returned for the function
 856 //
 857
 858 NTSTATUS
 859 AFSInitRootFcb( IN ULONGLONG ProcessID,
 860                 IN AFSVolumeCB *VolumeCB)
 861 {
 862
 863     NTSTATUS ntStatus = STATUS_SUCCESS;
 864     AFSFcb *pFcb = NULL;
 865     AFSNonPagedFcb *pNPFcb = NULL;
 866     IO_STATUS_BLOCK stIoStatus = {0,0};
 867     AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
 868
 869     __Enter
 870     {
 871
 872         //
 873         // Initialize the root fcb
 874         //
 875
 876         pFcb = (AFSFcb *)AFSExAllocatePoolWithTag( PagedPool,
 877                                                    sizeof( AFSFcb),
 878                                                    AFS_FCB_ALLOCATION_TAG);
 879
 880         if( pFcb == NULL)
 881         {
 882
 883             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 884                           AFS_TRACE_LEVEL_ERROR,
 885                           "AFSInitRootFcb Failed to allocate the root fcb\n");
 886
 887             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 888         }
 889
 890         RtlZeroMemory( pFcb,
 891                        sizeof( AFSFcb));
 892
 893         pFcb->Header.NodeByteSize = sizeof( AFSFcb);
 894         pFcb->Header.NodeTypeCode = AFS_ROOT_FCB;
 895
 896         pNPFcb = (AFSNonPagedFcb *)AFSExAllocatePoolWithTag( NonPagedPool,
 897                                                              sizeof( AFSNonPagedFcb),
 898                                                              AFS_FCB_NP_ALLOCATION_TAG);
 899
 900         if( pNPFcb == NULL)
 901         {
 902
 903             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 904                           AFS_TRACE_LEVEL_ERROR,
 905                           "AFSInitRootFcb Failed to allocate the non-paged fcb\n");
 906
 907             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 908         }
 909
 910         RtlZeroMemory( pNPFcb,
 911                        sizeof( AFSNonPagedFcb));
 912
 913         pNPFcb->Size = sizeof( AFSNonPagedFcb);
 914         pNPFcb->Type = AFS_NON_PAGED_FCB;
 915
 916         //
 917         // OK, initialize the entry
 918         //
 919
 920         ExInitializeFastMutex( &pNPFcb->AdvancedHdrMutex);
 921
 922         FsRtlSetupAdvancedHeader( &pFcb->Header, &pNPFcb->AdvancedHdrMutex);
 923
 924         ExInitializeResourceLite( &pNPFcb->Resource);
 925
 926         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 927                       AFS_TRACE_LEVEL_VERBOSE,
 928                       "AFSInitRootFcb Acquiring Fcb lock %08lX EXCL %08lX\n",
 929                       &pNPFcb->Resource,
 930                       PsGetCurrentThread());
 931
 932         AFSAcquireExcl( &pNPFcb->Resource,
 933                         TRUE);
 934
 935         ExInitializeResourceLite( &pNPFcb->PagingResource);
 936
 937         ExInitializeResourceLite( &pNPFcb->CcbListLock);
 938
 939         pFcb->Header.Resource = &pNPFcb->Resource;
 940
 941         pFcb->Header.PagingIoResource = &pNPFcb->PagingResource;
 942
 943         pFcb->NPFcb = pNPFcb;
 944
 945         //
 946         // Initialize enumeration information
 947         //
 948
 949         KeInitializeEvent( &pFcb->NPFcb->Specific.Directory.DirectoryEnumEvent,
 950                            NotificationEvent,
 951                            FALSE);
 952
 953         //
 954         // Save the root Fcb in the VolumeCB
 955         //
 956
 957         VolumeCB->ObjectInformation.Fcb = pFcb;
 958
 959         VolumeCB->ObjectInformation.VolumeCB = VolumeCB;
 960
 961         VolumeCB->RootFcb = pFcb;
 962
 963         pFcb->ObjectInformation = &VolumeCB->ObjectInformation;
 964
 965 try_exit:
 966
 967         if( !NT_SUCCESS( ntStatus))
 968         {
 969
 970             if( pFcb != NULL)
 971             {
 972
 973                 AFSRemoveRootFcb( pFcb);
 974             }
 975         }
 976     }
 977
 978     return ntStatus;
 979 }
 980
 981 //
 982 // Function: AFSRemoveRootFcb
 983 //
 984 // Description:
 985 //
 986 //      This function performs root Fcb removal/deallocation
 987 //
 988 // Return:
 989 //
 990 //      A status is returned for the function
 991 //
 992
 993 void
 994 AFSRemoveRootFcb( IN AFSFcb *RootFcb)
 995 {
 996
 997     AFSDirectoryCB *pCurrentDirEntry = NULL;
 998     AFSVolumeCB *pVolumeCB = RootFcb->ObjectInformation->VolumeCB;
 999
1000     if( RootFcb->NPFcb != NULL)
1001     {
1002
1003         //
1004         // Now the resource
1005         //
1006
1007         ExDeleteResourceLite( &RootFcb->NPFcb->Resource);
1008
1009         ExDeleteResourceLite( &RootFcb->NPFcb->PagingResource);
1010
1011         ExDeleteResourceLite( &RootFcb->NPFcb->CcbListLock);
1012
1013         //
1014         // The non paged region
1015         //
1016
1017         AFSExFreePool( RootFcb->NPFcb);
1018     }
1019
1020     //
1021     // And the Fcb itself
1022     //
1023
1024     AFSExFreePool( RootFcb);
1025
1026     return;
1027 }
1028
1029 //
1030 // Function: AFSRemoveFcb
1031 //
1032 // Description:
1033 //
1034 //      This function performs Fcb removal/deallocation
1035 //
1036 // Return:
1037 //
1038 //      A status is returned for the function
1039 //
1040
1041 void
1042 AFSRemoveFcb( IN AFSFcb *Fcb)
1043 {
1044
1045     //
1046     // Uninitialize the file lock if it is a file
1047     //
1048
1049     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1050                   AFS_TRACE_LEVEL_VERBOSE,
1051                   "AFSRemoveFcb Removing Fcb %08lX\n",
1052                   Fcb);
1053
1054     if( Fcb->Header.NodeTypeCode == AFS_FILE_FCB)
1055     {
1056
1057         FsRtlUninitializeFileLock( &Fcb->Specific.File.FileLock);
1058
1059         //
1060         // The resource we allocated
1061         //
1062
1063         ExDeleteResourceLite( &Fcb->NPFcb->Specific.File.ExtentsResource );
1064
1065         ExDeleteResourceLite( &Fcb->NPFcb->Specific.File.DirtyExtentsListLock);
1066
1067     }
1068     else if( Fcb->Header.NodeTypeCode == AFS_DIRECTORY_FCB)
1069     {
1070
1071
1072     }
1073
1074     //
1075     // Tear down the FM specific contexts
1076     //
1077
1078     FsRtlTeardownPerStreamContexts( &Fcb->Header);
1079
1080     //
1081     // Delete the resources
1082     //
1083
1084     ExDeleteResourceLite( &Fcb->NPFcb->Resource);
1085
1086     ExDeleteResourceLite( &Fcb->NPFcb->PagingResource);
1087
1088     ExDeleteResourceLite( &Fcb->NPFcb->CcbListLock);
1089
1090     //
1091     // The non paged region
1092     //
1093
1094     AFSExFreePool( Fcb->NPFcb);
1095
1096     //
1097     // And the Fcb itself, which includes the name
1098     //
1099
1100     AFSExFreePool( Fcb);
1101
1102     return;
1103 }
1104
1105 NTSTATUS
1106 AFSInitCcb( IN OUT AFSCcb **Ccb)
1107 {
1108
1109     NTSTATUS Status = STATUS_SUCCESS;
1110     AFSCcb *pCcb = NULL;
1111
1112     __Enter
1113     {
1114
1115         //
1116         // Allocate our context control block
1117         //
1118
1119         pCcb = (AFSCcb *)AFSExAllocatePoolWithTag( PagedPool,
1120                                                    sizeof( AFSCcb),
1121                                                    AFS_CCB_ALLOCATION_TAG);
1122
1123         if( pCcb == NULL)
1124         {
1125
1126             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1127                           AFS_TRACE_LEVEL_ERROR,
1128                           "AFSInitCcb Failed to allocate Ccb\n");
1129
1130             try_return( Status = STATUS_INSUFFICIENT_RESOURCES);
1131         }
1132
1133         RtlZeroMemory( pCcb,
1134                        sizeof( AFSCcb));
1135
1136         pCcb->Size = sizeof( AFSCcb);
1137         pCcb->Type = AFS_CCB;
1138
1139         //
1140         // Return the Ccb
1141         //
1142
1143         *Ccb = pCcb;
1144
1145 try_exit:
1146
1147         if( !NT_SUCCESS( Status))
1148         {
1149
1150             if( pCcb != NULL)
1151             {
1152
1153                 AFSExFreePool( pCcb);
1154             }
1155
1156             *Ccb = NULL;
1157         }
1158     }
1159
1160     return Status;
1161 }
1162
1163 //
1164 // Function: AFSRemoveCcb
1165 //
1166 // Description:
1167 //
1168 //      This function performs Ccb removal/deallocation
1169 //
1170 // Return:
1171 //
1172 //      A status is returned for the function
1173 //
1174
1175 NTSTATUS
1176 AFSRemoveCcb( IN AFSFcb *Fcb,
1177               IN AFSCcb *Ccb)
1178 {
1179
1180     NTSTATUS ntStatus = STATUS_SUCCESS;
1181
1182     if( Fcb != NULL &&
1183         BooleanFlagOn( Ccb->Flags, CCB_FLAG_INSERTED_CCB_LIST))
1184     {
1185
1186         AFSAcquireExcl( &Fcb->NPFcb->CcbListLock,
1187                         TRUE);
1188
1189         if( Ccb->ListEntry.fLink == NULL)
1190         {
1191
1192             Fcb->CcbListTail = (AFSCcb *)Ccb->ListEntry.bLink;
1193
1194             if( Fcb->CcbListTail != NULL)
1195             {
1196                 Fcb->CcbListTail->ListEntry.fLink = NULL;
1197             }
1198         }
1199         else
1200         {
1201             ((AFSCcb *)(Ccb->ListEntry.fLink))->ListEntry.bLink = Ccb->ListEntry.bLink;
1202         }
1203
1204         if( Ccb->ListEntry.bLink == NULL)
1205         {
1206
1207             Fcb->CcbListHead = (AFSCcb *)Ccb->ListEntry.fLink;
1208
1209             if( Fcb->CcbListHead != NULL)
1210             {
1211                 Fcb->CcbListHead->ListEntry.bLink = NULL;
1212             }
1213         }
1214         else
1215         {
1216             ((AFSCcb *)(Ccb->ListEntry.bLink))->ListEntry.fLink = Ccb->ListEntry.fLink;
1217         }
1218
1219         AFSReleaseResource( &Fcb->NPFcb->CcbListLock);
1220     }
1221
1222     if( Ccb->MaskName.Buffer != NULL)
1223     {
1224
1225         AFSExFreePool( Ccb->MaskName.Buffer);
1226     }
1227
1228     if( BooleanFlagOn( Ccb->Flags, CCB_FLAG_FREE_FULL_PATHNAME))
1229     {
1230
1231         AFSExFreePool( Ccb->FullFileName.Buffer);
1232     }
1233
1234     //
1235     // If we have a name array then delete it
1236     //
1237
1238     if( Ccb->NameArray != NULL)
1239     {
1240
1241         AFSFreeNameArray( Ccb->NameArray);
1242
1243         Ccb->NameArray = NULL;
1244     }
1245
1246     if( Ccb->DirectorySnapshot != NULL)
1247     {
1248
1249         AFSExFreePool( Ccb->DirectorySnapshot);
1250
1251         Ccb->DirectorySnapshot = NULL;
1252     }
1253
1254     if( Ccb->NotifyMask.Buffer != NULL)
1255     {
1256
1257         AFSExFreePool( Ccb->NotifyMask.Buffer);
1258     }
1259
1260     //
1261     // Free up the Ccb
1262     //
1263
1264     AFSExFreePool( Ccb);
1265
1266     return ntStatus;
1267 }
1268
1269 NTSTATUS
1270 AFSInsertCcb( IN AFSFcb *Fcb,
1271               IN AFSCcb *Ccb)
1272 {
1273
1274     NTSTATUS ntStatus = STATUS_SUCCESS;
1275
1276     AFSAcquireExcl( &Fcb->NPFcb->CcbListLock,
1277                     TRUE);
1278
1279     if( Fcb->CcbListHead == NULL)
1280     {
1281         Fcb->CcbListHead = Ccb;
1282     }
1283     else
1284     {
1285         Fcb->CcbListTail->ListEntry.fLink = (void *)Ccb;
1286
1287         Ccb->ListEntry.bLink = (void *)Fcb->CcbListTail;
1288     }
1289
1290     Fcb->CcbListTail = Ccb;
1291
1292     SetFlag( Ccb->Flags, CCB_FLAG_INSERTED_CCB_LIST);
1293
1294     AFSReleaseResource( &Fcb->NPFcb->CcbListLock);
1295
1296     return ntStatus;
1297 }