2 * Copyright (c) 2008, 2009, 2010, 2011 Kernel Drivers, LLC.
3 * Copyright (c) 2009, 2010, 2011 Your File System, Inc.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
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
14 * this list of conditions and the following disclaimer in the
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.
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.
36 // File: AFSCreate.cpp
39 #include "AFSCommon.h"
42 // Function: AFSCreate
46 // This function is the dispatch handler for the IRP_MJ_CREATE requests. It makes the determination to
47 // which interface this request is destined.
51 // A status is returned for the function. The Irp completion processing is handled in the specific
56 AFSCreate( IN PDEVICE_OBJECT LibDeviceObject,
60 NTSTATUS ntStatus = STATUS_SUCCESS;
61 IO_STACK_LOCATION *pIrpSp;
62 FILE_OBJECT *pFileObject = NULL;
67 pIrpSp = IoGetCurrentIrpStackLocation( Irp);
68 pFileObject = pIrpSp->FileObject;
70 if( pFileObject == NULL ||
71 pFileObject->FileName.Buffer == NULL)
74 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
75 AFS_TRACE_LEVEL_VERBOSE,
76 "AFSCreate (%08lX) Processing control device open request\n",
79 ntStatus = AFSControlDeviceCreate( Irp);
81 try_return( ntStatus);
84 if( AFSRDRDeviceObject == NULL)
87 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
88 AFS_TRACE_LEVEL_VERBOSE,
89 "AFSCreate (%08lX) Invalid request to open before library is initialized\n",
92 try_return( ntStatus = STATUS_DEVICE_NOT_READY);
95 ntStatus = AFSCommonCreate( AFSRDRDeviceObject,
102 __except( AFSExceptionFilter( GetExceptionCode(), GetExceptionInformation()) )
107 "EXCEPTION - AFSCreate\n");
109 ntStatus = STATUS_ACCESS_DENIED;
113 // Complete the request
116 AFSCompleteRequest( Irp,
123 AFSCommonCreate( IN PDEVICE_OBJECT DeviceObject,
127 NTSTATUS ntStatus = STATUS_SUCCESS;
128 UNICODE_STRING uniFileName;
129 ULONG ulCreateDisposition = 0;
131 BOOLEAN bNoIntermediateBuffering = FALSE;
132 FILE_OBJECT *pFileObject = NULL;
133 IO_STACK_LOCATION *pIrpSp;
136 AFSDeviceExt *pDeviceExt = NULL;
137 BOOLEAN bOpenTargetDirectory = FALSE, bReleaseVolume = FALSE;
138 PACCESS_MASK pDesiredAccess = NULL;
139 UNICODE_STRING uniComponentName, uniPathName, uniRootFileName, uniParsedFileName;
140 UNICODE_STRING uniSubstitutedPathName;
141 UNICODE_STRING uniRelativeName;
142 AFSNameArrayHdr *pNameArray = NULL;
143 AFSVolumeCB *pVolumeCB = NULL;
144 AFSDirectoryCB *pParentDirectoryCB = NULL, *pDirectoryCB = NULL;
145 ULONG ulParseFlags = 0;
147 ULONG ulNameProcessingFlags = 0;
152 pIrpSp = IoGetCurrentIrpStackLocation( Irp);
153 pDeviceExt = (AFSDeviceExt *)DeviceObject->DeviceExtension;
154 ulCreateDisposition = (pIrpSp->Parameters.Create.Options >> 24) & 0x000000ff;
155 ulOptions = pIrpSp->Parameters.Create.Options;
156 bNoIntermediateBuffering = BooleanFlagOn( ulOptions, FILE_NO_INTERMEDIATE_BUFFERING);
157 bOpenTargetDirectory = BooleanFlagOn( pIrpSp->Flags, SL_OPEN_TARGET_DIRECTORY);
158 pFileObject = pIrpSp->FileObject;
159 pDesiredAccess = &pIrpSp->Parameters.Create.SecurityContext->DesiredAccess;
161 uniFileName.Length = uniFileName.MaximumLength = 0;
162 uniFileName.Buffer = NULL;
164 uniRootFileName.Length = uniRootFileName.MaximumLength = 0;
165 uniRootFileName.Buffer = NULL;
167 uniParsedFileName.Length = uniParsedFileName.MaximumLength = 0;
168 uniParsedFileName.Buffer = NULL;
170 uniSubstitutedPathName.Buffer = NULL;
171 uniSubstitutedPathName.Length = 0;
173 uniRelativeName.Buffer = NULL;
174 uniRelativeName.Length = 0;
176 if( AFSGlobalRoot == NULL)
178 try_return( ntStatus = STATUS_DEVICE_NOT_READY);
181 RtlZeroMemory( &stAuthGroup,
184 AFSRetrieveAuthGroupFnc( (ULONGLONG)PsGetCurrentProcessId(),
185 (ULONGLONG)PsGetCurrentThreadId(),
188 if( !BooleanFlagOn( AFSGlobalRoot->ObjectInformation.Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED))
191 ntStatus = AFSEnumerateGlobalRoot( &stAuthGroup);
193 if( !NT_SUCCESS( ntStatus))
196 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
197 AFS_TRACE_LEVEL_ERROR,
198 "AFSCommonCreate Failed to enumerate global root Status %08lX\n",
201 try_return( ntStatus);
206 // If we are in shutdown mode then fail the request
209 if( BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_REDIRECTOR_SHUTDOWN))
212 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
213 AFS_TRACE_LEVEL_WARNING,
214 "AFSCommonCreate (%08lX) Open request after shutdown\n",
217 try_return( ntStatus = STATUS_TOO_LATE);
221 // Go and parse the name for processing.
222 // If ulParseFlags is returned with AFS_PARSE_FLAG_FREE_FILE_BUFFER set,
223 // then we are responsible for releasing the uniRootFileName.Buffer.
226 ntStatus = AFSParseName( Irp,
236 if( !NT_SUCCESS( ntStatus))
239 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
240 uniFileName.Length > 0 ? AFS_TRACE_LEVEL_ERROR : AFS_TRACE_LEVEL_VERBOSE,
241 "AFSCommonCreate (%08lX) Failed to parse name \"%wZ\" Status %08lX\n",
246 try_return( ntStatus);
250 // Check for STATUS_REPARSE
253 if( ntStatus == STATUS_REPARSE)
257 // Update the information and return
260 Irp->IoStatus.Information = IO_REPARSE;
262 try_return( ntStatus);
266 // If the returned volume cb is NULL then we are dealing with the \\Server\GlobalRoot
270 if( pVolumeCB == NULL)
274 // Remove any leading or trailing slashes
277 if( uniFileName.Length >= sizeof( WCHAR) &&
278 uniFileName.Buffer[ (uniFileName.Length/sizeof( WCHAR)) - 1] == L'\\')
281 uniFileName.Length -= sizeof( WCHAR);
284 if( uniFileName.Length >= sizeof( WCHAR) &&
285 uniFileName.Buffer[ 0] == L'\\')
288 uniFileName.Buffer = &uniFileName.Buffer[ 1];
290 uniFileName.Length -= sizeof( WCHAR);
294 // If there is a remaining portion returned for this request then
295 // check if it is for the PIOCtl interface
298 if( uniFileName.Length > 0)
302 // We don't accept any other opens off of the AFS Root
305 ntStatus = STATUS_OBJECT_NAME_NOT_FOUND;
308 // If this is an open on "_._AFS_IOCTL_._" then perform handling on it accordingly
311 if( RtlCompareUnicodeString( &AFSPIOCtlName,
316 ntStatus = AFSOpenIOCtlFcb( Irp,
318 AFSGlobalRoot->DirectoryCB,
322 if( !NT_SUCCESS( ntStatus))
325 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
326 AFS_TRACE_LEVEL_ERROR,
327 "AFSCommonCreate Failed to open root IOCtl Fcb Status %08lX\n",
331 else if( pParentDirectoryCB != NULL &&
332 pParentDirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_SPECIAL_SHARE_NAME)
335 ntStatus = AFSOpenSpecialShareFcb( Irp,
341 if( !NT_SUCCESS( ntStatus))
344 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
345 AFS_TRACE_LEVEL_ERROR,
346 "AFSCommonCreate Failed to open special share Fcb Status %08lX\n",
351 try_return( ntStatus);
354 ntStatus = AFSOpenAFSRoot( Irp,
358 if( !NT_SUCCESS( ntStatus))
361 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
362 AFS_TRACE_LEVEL_ERROR,
363 "AFSCommonCreate Failed to open root Status %08lX\n",
366 InterlockedDecrement( &AFSGlobalRoot->DirectoryCB->OpenReferenceCount);
368 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
369 AFS_TRACE_LEVEL_VERBOSE,
370 "AFSCreate Decrement1 count on &wZ DE %p Ccb %p Cnt %d\n",
371 &AFSGlobalRoot->DirectoryCB->NameInformation.FileName,
372 AFSGlobalRoot->DirectoryCB,
374 AFSGlobalRoot->DirectoryCB->OpenReferenceCount);
377 try_return( ntStatus);
381 // We have our root node shared
384 bReleaseVolume = TRUE;
387 // Attempt to locate the node in the name tree if this is not a target
388 // open and the target is not the root
391 uniComponentName.Length = 0;
392 uniComponentName.Buffer = NULL;
394 if( uniFileName.Length > sizeof( WCHAR) ||
395 uniFileName.Buffer[ 0] != L'\\')
398 if( !AFSValidNameFormat( &uniFileName))
401 ntStatus = STATUS_OBJECT_NAME_NOT_FOUND;
403 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
404 AFS_TRACE_LEVEL_VERBOSE,
405 "AFSCommonCreate (%08lX) Invalid name %wZ Status %08lX\n",
410 try_return( ntStatus);
414 // Opening a reparse point directly?
417 ulNameProcessingFlags = AFS_LOCATE_FLAGS_SUBSTITUTE_NAME;
419 if( BooleanFlagOn( ulOptions, FILE_OPEN_REPARSE_POINT))
421 ulNameProcessingFlags |= (AFS_LOCATE_FLAGS_NO_MP_TARGET_EVAL |
422 AFS_LOCATE_FLAGS_NO_SL_TARGET_EVAL |
423 AFS_LOCATE_FLAGS_NO_DFS_LINK_EVAL);
426 uniSubstitutedPathName = uniRootFileName;
428 ntStatus = AFSLocateNameEntry( &stAuthGroup,
433 ulNameProcessingFlags,
439 if( !NT_SUCCESS( ntStatus) &&
440 ntStatus != STATUS_OBJECT_NAME_NOT_FOUND)
443 if ( uniSubstitutedPathName.Buffer == uniRootFileName.Buffer)
445 uniSubstitutedPathName.Buffer = NULL;
449 // The routine above released the root while walking the
453 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
454 AFS_TRACE_LEVEL_VERBOSE,
455 "AFSCommonCreate (%08lX) Failed to locate name entry for %wZ Status %08lX\n",
461 // We released any root volume locks in the above on failure
464 bReleaseVolume = FALSE;
466 try_return( ntStatus);
470 // Check for STATUS_REPARSE
473 if( ntStatus == STATUS_REPARSE)
476 uniSubstitutedPathName.Buffer = NULL;
479 // Update the information and return
482 Irp->IoStatus.Information = IO_REPARSE;
485 // We released the volume lock above
488 bReleaseVolume = FALSE;
490 try_return( ntStatus);
494 // If we re-allocated the name, then update our substitute name
497 if( uniSubstitutedPathName.Buffer != uniRootFileName.Buffer)
500 uniSubstitutedPathName = uniRootFileName;
505 uniSubstitutedPathName.Buffer = NULL;
509 // Check for a symlink access
512 if( ntStatus == STATUS_OBJECT_NAME_NOT_FOUND &&
513 pParentDirectoryCB != NULL)
516 UNICODE_STRING uniFinalComponent;
518 uniFinalComponent.Length = 0;
519 uniFinalComponent.MaximumLength = 0;
520 uniFinalComponent.Buffer = NULL;
522 AFSRetrieveFinalComponent( &uniFileName,
525 ntStatus = AFSCheckSymlinkAccess( pParentDirectoryCB,
528 if( !NT_SUCCESS( ntStatus) &&
529 ntStatus != STATUS_OBJECT_NAME_NOT_FOUND)
532 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
533 AFS_TRACE_LEVEL_VERBOSE,
534 "AFSCommonCreate (%08lX) Failing access to symlink %wZ Status %08lX\n",
539 try_return( ntStatus);
545 // If we have no parent then this is a root open, be sure there is a directory entry
549 else if( pParentDirectoryCB == NULL &&
550 pDirectoryCB == NULL)
553 pDirectoryCB = pVolumeCB->DirectoryCB;
556 if( bOpenTargetDirectory)
560 // If we have a directory cb for the entry then dereference it and reference the parent
563 if( pDirectoryCB != NULL)
567 // Perform in this order to prevent thrashing
570 InterlockedIncrement( &pParentDirectoryCB->OpenReferenceCount);
572 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
573 AFS_TRACE_LEVEL_VERBOSE,
574 "AFSCreate Increment1 count on %wZ DE %p Ccb %p Cnt %d\n",
575 &pParentDirectoryCB->NameInformation.FileName,
578 pParentDirectoryCB->OpenReferenceCount);
580 InterlockedDecrement( &pDirectoryCB->OpenReferenceCount);
582 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
583 AFS_TRACE_LEVEL_VERBOSE,
584 "AFSCreate Decrement2 count on %wZ DE %p Ccb %p Cnt %d\n",
585 &pDirectoryCB->NameInformation.FileName,
588 pDirectoryCB->OpenReferenceCount);
591 // The name array also contains a reference to the pDirectoryCB so we need to remove it
592 // Note that this could decrement the count to zero allowing it to be deleted, hence
593 // don't access the pointer contents beyond here.
596 AFSBackupEntry( pNameArray);
600 // OK, open the target directory
603 if( uniComponentName.Length == 0)
605 AFSRetrieveFinalComponent( &uniFileName,
609 ntStatus = AFSOpenTargetDirectory( Irp,
617 if( !NT_SUCCESS( ntStatus))
620 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
621 AFS_TRACE_LEVEL_ERROR,
622 "AFSCommonCreate Failed to open target directory %wZ Status %08lX\n",
623 &pParentDirectoryCB->NameInformation.FileName,
627 // Decrement the reference on the parent
630 InterlockedDecrement( &pParentDirectoryCB->OpenReferenceCount);
632 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
633 AFS_TRACE_LEVEL_VERBOSE,
634 "AFSCreate Decrement3 count on %wZ DE %p Ccb %p Cnt %d\n",
635 &pParentDirectoryCB->NameInformation.FileName,
638 pParentDirectoryCB->OpenReferenceCount);
641 try_return( ntStatus);
644 if ( BooleanFlagOn( ulOptions, FILE_OPEN_REPARSE_POINT) &&
645 pDirectoryCB != NULL &&
646 !BooleanFlagOn( pDirectoryCB->ObjectInformation->FileAttributes, FILE_ATTRIBUTE_REPARSE_POINT))
649 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
650 AFS_TRACE_LEVEL_VERBOSE,
651 "AFSCommonCreate (%08lX) Reparse open request but attribute not set for %wZ Type %08lX\n",
654 pDirectoryCB->ObjectInformation->FileType);
658 // Based on the options passed in, process the file accordingly.
661 if( ulCreateDisposition == FILE_CREATE ||
662 ( ( ulCreateDisposition == FILE_OPEN_IF ||
663 ulCreateDisposition == FILE_OVERWRITE_IF) &&
664 pDirectoryCB == NULL))
667 if( uniComponentName.Length == 0 ||
668 pDirectoryCB != NULL)
672 // We traversed the entire path so we found each entry,
673 // fail with collision
676 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
677 AFS_TRACE_LEVEL_VERBOSE,
678 "AFSCommonCreate Object name collision on create of %wZ Status %08lX\n",
679 &pDirectoryCB->NameInformation.FileName,
682 if( pDirectoryCB != NULL)
685 InterlockedDecrement( &pDirectoryCB->OpenReferenceCount);
687 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
688 AFS_TRACE_LEVEL_VERBOSE,
689 "AFSCreate Decrement4 count on %wZ DE %p Ccb %p Cnt %d\n",
690 &pDirectoryCB->NameInformation.FileName,
693 pDirectoryCB->OpenReferenceCount);
698 InterlockedDecrement( &pParentDirectoryCB->OpenReferenceCount);
700 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
701 AFS_TRACE_LEVEL_VERBOSE,
702 "AFSCreate Decrement5 count on %wZ DE %p Ccb %p Cnt %d\n",
703 &pParentDirectoryCB->NameInformation.FileName,
706 pParentDirectoryCB->OpenReferenceCount);
709 try_return( ntStatus = STATUS_OBJECT_NAME_COLLISION);
713 // OK, go and create the node
716 ntStatus = AFSProcessCreate( Irp,
726 if( !NT_SUCCESS( ntStatus))
729 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
730 AFS_TRACE_LEVEL_ERROR,
731 "AFSCommonCreate Failed to create of %wZ in directory %wZ Status %08lX\n",
733 &pParentDirectoryCB->NameInformation.FileName,
740 // Reference the new dir entry
743 InterlockedIncrement( &pCcb->DirectoryCB->OpenReferenceCount);
745 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
746 AFS_TRACE_LEVEL_VERBOSE,
747 "AFSCreate Increment (Create) count on %wZ DE %p Ccb %p Cnt %d\n",
748 &pCcb->DirectoryCB->NameInformation.FileName,
751 pCcb->DirectoryCB->OpenReferenceCount);
755 // Dereference the parent entry
758 InterlockedDecrement( &pParentDirectoryCB->OpenReferenceCount);
760 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
761 AFS_TRACE_LEVEL_VERBOSE,
762 "AFSCreate Decrement6 count on %wZ DE %p Ccb %p Cnt %d\n",
763 &pParentDirectoryCB->NameInformation.FileName,
766 pParentDirectoryCB->OpenReferenceCount);
768 try_return( ntStatus);
772 // We should not have an extra component except for PIOCtl opens
775 if( uniComponentName.Length > 0)
779 // If this is an open on "_._AFS_IOCTL_._" then perform handling on it accordingly
782 if( RtlCompareUnicodeString( &AFSPIOCtlName,
787 ntStatus = AFSOpenIOCtlFcb( Irp,
793 if( !NT_SUCCESS( ntStatus))
796 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
797 AFS_TRACE_LEVEL_ERROR,
798 "AFSCommonCreate Failed to IOCtl open on %wZ Status %08lX\n",
806 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
807 AFS_TRACE_LEVEL_VERBOSE,
808 "AFSCommonCreate (%08lX) File %wZ name not found\n",
812 ntStatus = STATUS_OBJECT_NAME_NOT_FOUND;
815 if( !NT_SUCCESS( ntStatus))
819 // Dereference the parent entry
822 if( pDirectoryCB != NULL)
825 InterlockedDecrement( &pDirectoryCB->OpenReferenceCount);
827 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
828 AFS_TRACE_LEVEL_VERBOSE,
829 "AFSCreate Decrement7a count on %wZ DE %p Ccb %p Cnt %d\n",
830 &pDirectoryCB->NameInformation.FileName,
833 pDirectoryCB->OpenReferenceCount);
838 InterlockedDecrement( &pParentDirectoryCB->OpenReferenceCount);
840 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
841 AFS_TRACE_LEVEL_VERBOSE,
842 "AFSCreate Decrement7b count on %wZ DE %p Ccb %p Cnt %d\n",
843 &pParentDirectoryCB->NameInformation.FileName,
846 pParentDirectoryCB->OpenReferenceCount);
850 try_return( ntStatus);
854 // For root opens the parent will be NULL
857 if( pParentDirectoryCB == NULL)
861 // Check for the delete on close flag for the root
864 if( BooleanFlagOn( ulOptions, FILE_DELETE_ON_CLOSE ))
867 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
868 AFS_TRACE_LEVEL_ERROR,
869 "AFSCommonCreate (%08lX) Attempt to open root as delete on close\n",
872 InterlockedDecrement( &pDirectoryCB->OpenReferenceCount);
874 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
875 AFS_TRACE_LEVEL_VERBOSE,
876 "AFSCreate Decrement8 count on %wZ DE %p Ccb %p Cnt %d\n",
877 &pDirectoryCB->NameInformation.FileName,
880 pDirectoryCB->OpenReferenceCount);
882 try_return( ntStatus = STATUS_CANNOT_DELETE);
886 // If this is the target directory, then bail
889 if( bOpenTargetDirectory)
892 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
893 AFS_TRACE_LEVEL_ERROR,
894 "AFSCommonCreate (%08lX) Attempt to open root as target directory\n",
897 InterlockedDecrement( &pDirectoryCB->OpenReferenceCount);
899 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
900 AFS_TRACE_LEVEL_VERBOSE,
901 "AFSCreate Decrement9 count on %wZ DE %p Ccb %p Cnt %d\n",
902 &pDirectoryCB->NameInformation.FileName,
905 pDirectoryCB->OpenReferenceCount);
907 try_return( ntStatus = STATUS_INVALID_PARAMETER);
911 // Go and open the root of the volume
914 ntStatus = AFSOpenRoot( Irp,
920 if( !NT_SUCCESS( ntStatus))
923 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
924 AFS_TRACE_LEVEL_ERROR,
925 "AFSCommonCreate Failed to open root (2) Status %08lX\n",
928 InterlockedDecrement( &pDirectoryCB->OpenReferenceCount);
930 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
931 AFS_TRACE_LEVEL_VERBOSE,
932 "AFSCreate Decrement10 count on %wZ DE %p Ccb %p Cnt %d\n",
933 &pDirectoryCB->NameInformation.FileName,
936 pDirectoryCB->OpenReferenceCount);
939 try_return( ntStatus);
943 // At this point if we have no pDirectoryCB it was not found.
946 if( pDirectoryCB == NULL)
949 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
950 AFS_TRACE_LEVEL_ERROR,
951 "AFSCommonCreate Failing access to %wZ\n",
954 try_return( ntStatus = STATUS_OBJECT_NAME_NOT_FOUND);
957 if( ulCreateDisposition == FILE_OVERWRITE ||
958 ulCreateDisposition == FILE_SUPERSEDE ||
959 ulCreateDisposition == FILE_OVERWRITE_IF)
963 // Go process a file for overwrite or supersede.
966 ntStatus = AFSProcessOverwriteSupersede( DeviceObject,
975 if( !NT_SUCCESS( ntStatus))
978 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
979 AFS_TRACE_LEVEL_ERROR,
980 "AFSCommonCreate Failed overwrite/supersede on %wZ Status %08lX\n",
981 &pDirectoryCB->NameInformation.FileName,
984 InterlockedDecrement( &pDirectoryCB->OpenReferenceCount);
986 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
987 AFS_TRACE_LEVEL_VERBOSE,
988 "AFSCreate Decrement11 count on %wZ DE %p Ccb %p Cnt %d\n",
989 &pDirectoryCB->NameInformation.FileName,
992 pDirectoryCB->OpenReferenceCount);
995 try_return( ntStatus);
999 // Trying to open the file
1002 ntStatus = AFSProcessOpen( Irp,
1010 if( !NT_SUCCESS( ntStatus))
1013 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1014 AFS_TRACE_LEVEL_ERROR,
1015 "AFSCommonCreate Failed open on %wZ Status %08lX\n",
1016 &pDirectoryCB->NameInformation.FileName,
1019 InterlockedDecrement( &pDirectoryCB->OpenReferenceCount);
1021 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1022 AFS_TRACE_LEVEL_VERBOSE,
1023 "AFSCreate Decrement12 count on %wZ DE %p Ccb %p Cnt %d\n",
1024 &pDirectoryCB->NameInformation.FileName,
1027 pDirectoryCB->OpenReferenceCount);
1032 if( NT_SUCCESS( ntStatus) &&
1033 ntStatus != STATUS_REPARSE)
1040 // If we have a substitute name, then use it
1043 if( uniSubstitutedPathName.Buffer != NULL)
1046 pCcb->FullFileName = uniSubstitutedPathName;
1048 SetFlag( pCcb->Flags, CCB_FLAG_FREE_FULL_PATHNAME);
1050 ClearFlag( ulParseFlags, AFS_PARSE_FLAG_FREE_FILE_BUFFER);
1055 pCcb->FullFileName = uniRootFileName;
1057 if( BooleanFlagOn( ulParseFlags, AFS_PARSE_FLAG_FREE_FILE_BUFFER))
1060 SetFlag( pCcb->Flags, CCB_FLAG_FREE_FULL_PATHNAME);
1062 ClearFlag( ulParseFlags, AFS_PARSE_FLAG_FREE_FILE_BUFFER);
1066 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1067 AFS_TRACE_LEVEL_VERBOSE,
1068 "AFSCreate Count on %wZ DE %p Ccb %p Cnt %d\n",
1069 &pCcb->DirectoryCB->NameInformation.FileName,
1072 pCcb->DirectoryCB->OpenReferenceCount);
1074 ASSERT( pCcb->DirectoryCB->OpenReferenceCount > 0);
1076 pCcb->CurrentDirIndex = 0;
1078 if( !BooleanFlagOn( ulParseFlags, AFS_PARSE_FLAG_ROOT_ACCESS))
1081 SetFlag( pCcb->Flags, CCB_FLAG_RETURN_RELATIVE_ENTRIES);
1085 // Save off the name array for this instance
1088 pCcb->NameArray = pNameArray;
1094 // If we make it here then init the FO for the request.
1097 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1098 AFS_TRACE_LEVEL_VERBOSE_2,
1099 "AFSCommonCreate (%08lX) FileObject %08lX FsContext %08lX FsContext2 %08lX\n",
1105 pFileObject->FsContext = (void *)pFcb;
1107 pFileObject->FsContext2 = (void *)pCcb;
1112 ASSERT( pFcb->OpenHandleCount > 0);
1114 ClearFlag( pFcb->Flags, AFS_FCB_FILE_CLOSED);
1116 RtlCopyMemory( &pFcb->AuthGroup,
1121 // For files perform additional processing
1124 if( pFcb->Header.NodeTypeCode == AFS_FILE_FCB)
1126 pFileObject->SectionObjectPointer = &pFcb->NPFcb->SectionObjectPointers;
1130 // If the user did not request nobuffering then mark the FO as cacheable
1133 if( bNoIntermediateBuffering)
1136 pFileObject->Flags |= FO_NO_INTERMEDIATE_BUFFERING;
1141 pFileObject->Flags |= FO_CACHE_SUPPORTED;
1145 // If the file was opened for execution then we need to set the bit in the FO
1148 if( BooleanFlagOn( *pDesiredAccess,
1152 SetFlag( pFileObject->Flags, FO_FILE_FAST_IO_READ);
1156 // Update the last access time
1159 KeQuerySystemTime( &pFcb->ObjectInformation->LastAccessTime);
1164 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1165 AFS_TRACE_LEVEL_ERROR,
1166 "AFSCommonCreate (%08lX) Returning with NULL Fcb FileObject %08lX FsContext %08lX FsContext2 %08lX\n",
1175 if( NT_SUCCESS( ntStatus) &&
1176 ntStatus == STATUS_REPARSE)
1179 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1180 AFS_TRACE_LEVEL_ERROR,
1181 "AFSCommonCreate (%08lX) STATUS_REPARSE FileObject %08lX FsContext %08lX FsContext2 %08lX\n",
1189 // Free up the sub name if we have one
1192 if( uniSubstitutedPathName.Buffer != NULL)
1195 AFSExFreePool( uniSubstitutedPathName.Buffer);
1197 ClearFlag( ulParseFlags, AFS_PARSE_FLAG_FREE_FILE_BUFFER);
1202 // Free up the name array ...
1205 if( pNameArray != NULL)
1208 AFSFreeNameArray( pNameArray);
1211 if( BooleanFlagOn( ulParseFlags, AFS_PARSE_FLAG_FREE_FILE_BUFFER))
1214 AFSExFreePool( uniRootFileName.Buffer);
1220 InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
1222 AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
1223 AFS_TRACE_LEVEL_VERBOSE,
1224 "AFSCommonCreate Decrement count on Volume %08lX Cnt %d\n",
1226 pVolumeCB->VolumeReferenceCount);
1228 AFSReleaseResource( pVolumeCB->VolumeLock);
1232 // Setup the Irp for completion, the Information has been set previously
1235 Irp->IoStatus.Status = ntStatus;
1242 AFSOpenRedirector( IN PIRP Irp,
1247 NTSTATUS ntStatus = STATUS_SUCCESS;
1253 // Initialize the Ccb for the file.
1256 ntStatus = AFSInitCcb( Ccb);
1258 if( !NT_SUCCESS( ntStatus))
1261 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1262 AFS_TRACE_LEVEL_ERROR,
1263 "AFSOpenRedirector (%08lX) Failed to allocate Ccb\n",
1266 try_return( ntStatus);
1273 (*Ccb)->DirectoryCB = AFSRedirectorRoot->DirectoryCB;
1276 // Increment the open count on this Fcb
1279 InterlockedIncrement( &AFSRedirectorRoot->RootFcb->OpenReferenceCount);
1281 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
1282 AFS_TRACE_LEVEL_VERBOSE,
1283 "AFSOpenRedirector Increment count on Fcb %08lX Cnt %d\n",
1284 AFSRedirectorRoot->RootFcb,
1285 AFSRedirectorRoot->RootFcb->OpenReferenceCount);
1287 InterlockedIncrement( &AFSRedirectorRoot->RootFcb->OpenHandleCount);
1289 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
1290 AFS_TRACE_LEVEL_VERBOSE,
1291 "AFSOpenRedirector Increment handle count on Fcb %08lX Cnt %d\n",
1292 AFSRedirectorRoot->RootFcb,
1293 AFSRedirectorRoot->RootFcb->OpenHandleCount);
1295 *Fcb = AFSRedirectorRoot->RootFcb;
1297 InterlockedIncrement( &(*Ccb)->DirectoryCB->OpenReferenceCount);
1300 // Return the open result for this file
1303 Irp->IoStatus.Information = FILE_OPENED;
1314 AFSOpenAFSRoot( IN PIRP Irp,
1319 NTSTATUS ntStatus = STATUS_SUCCESS;
1325 // Initialize the Ccb for the file.
1328 ntStatus = AFSInitCcb( Ccb);
1330 if( !NT_SUCCESS( ntStatus))
1333 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1334 AFS_TRACE_LEVEL_ERROR,
1335 "AFSOpenAFSRoot (%08lX) Failed to allocate Ccb\n",
1338 try_return( ntStatus);
1345 (*Ccb)->DirectoryCB = AFSGlobalRoot->DirectoryCB;
1348 // Increment the open count on this Fcb
1351 InterlockedIncrement( &AFSGlobalRoot->RootFcb->OpenReferenceCount);
1353 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
1354 AFS_TRACE_LEVEL_VERBOSE,
1355 "AFSOpenAFSRoot Increment count on Fcb %08lX Cnt %d\n",
1356 AFSGlobalRoot->RootFcb,
1357 AFSGlobalRoot->RootFcb->OpenReferenceCount);
1359 InterlockedIncrement( &AFSGlobalRoot->RootFcb->OpenHandleCount);
1361 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
1362 AFS_TRACE_LEVEL_VERBOSE,
1363 "AFSOpenAFSRoot Increment handle count on Fcb %08lX Cnt %d\n",
1364 AFSGlobalRoot->RootFcb,
1365 AFSGlobalRoot->RootFcb->OpenHandleCount);
1367 *Fcb = AFSGlobalRoot->RootFcb;
1370 // Return the open result for this file
1373 Irp->IoStatus.Information = FILE_OPENED;
1384 AFSOpenRoot( IN PIRP Irp,
1385 IN AFSVolumeCB *VolumeCB,
1387 OUT AFSFcb **RootFcb,
1391 NTSTATUS ntStatus = STATUS_SUCCESS;
1392 PFILE_OBJECT pFileObject = NULL;
1393 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1394 PACCESS_MASK pDesiredAccess = NULL;
1395 USHORT usShareAccess;
1396 BOOLEAN bAllocatedCcb = FALSE;
1397 BOOLEAN bReleaseFcb = FALSE;
1398 AFSFileOpenCB stOpenCB;
1399 AFSFileOpenResultCB stOpenResultCB;
1400 ULONG ulResultLen = 0;
1405 pDesiredAccess = &pIrpSp->Parameters.Create.SecurityContext->DesiredAccess;
1406 usShareAccess = pIrpSp->Parameters.Create.ShareAccess;
1408 pFileObject = pIrpSp->FileObject;
1411 // Check if we should go and retrieve updated information for the node
1414 ntStatus = AFSValidateEntry( VolumeCB->DirectoryCB,
1419 if( !NT_SUCCESS( ntStatus))
1422 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1423 AFS_TRACE_LEVEL_ERROR,
1424 "AFSOpenRoot (%08lX) Failed to validate root entry Status %08lX\n",
1428 try_return( ntStatus);
1432 // Check with the service that we can open the file
1435 RtlZeroMemory( &stOpenCB,
1436 sizeof( AFSFileOpenCB));
1438 stOpenCB.DesiredAccess = *pDesiredAccess;
1440 stOpenCB.ShareAccess = usShareAccess;
1442 stOpenResultCB.GrantedAccess = 0;
1444 ulResultLen = sizeof( AFSFileOpenResultCB);
1446 ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_OPEN_FILE,
1447 AFS_REQUEST_FLAG_SYNCHRONOUS | AFS_REQUEST_FLAG_HOLD_FID,
1450 &VolumeCB->ObjectInformation.FileId,
1452 sizeof( AFSFileOpenCB),
1453 (void *)&stOpenResultCB,
1456 if( !NT_SUCCESS( ntStatus))
1459 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1460 AFS_TRACE_LEVEL_ERROR,
1461 "AFSOpenRoot (%08lX) Failed to open file in service Status %08lX\n",
1465 try_return( ntStatus);
1469 // If the entry is not initialized then do it now
1472 if( !BooleanFlagOn( VolumeCB->ObjectInformation.Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED))
1475 AFSAcquireExcl( VolumeCB->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock,
1478 if( !BooleanFlagOn( VolumeCB->ObjectInformation.Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED))
1481 ntStatus = AFSEnumerateDirectory( AuthGroup,
1482 &VolumeCB->ObjectInformation,
1485 if( !NT_SUCCESS( ntStatus))
1488 AFSReleaseResource( VolumeCB->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock);
1490 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1491 AFS_TRACE_LEVEL_ERROR,
1492 "AFSOpenRoot (%08lX) Failed to enumerate directory Status %08lX\n",
1496 try_return( ntStatus);
1499 SetFlag( VolumeCB->ObjectInformation.Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED);
1502 AFSReleaseResource( VolumeCB->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock);
1506 // If the root fcb has been initialized then check access otherwise
1507 // init the volume fcb
1510 if( VolumeCB->RootFcb == NULL)
1513 ntStatus = AFSInitRootFcb( (ULONGLONG)PsGetCurrentProcessId(),
1516 if( !NT_SUCCESS( ntStatus))
1519 try_return( ntStatus);
1525 AFSAcquireExcl( VolumeCB->RootFcb->Header.Resource,
1532 // If there are current opens on the Fcb, check the access.
1535 if( VolumeCB->RootFcb->OpenHandleCount > 0)
1538 ntStatus = IoCheckShareAccess( *pDesiredAccess,
1541 &VolumeCB->RootFcb->ShareAccess,
1544 if( !NT_SUCCESS( ntStatus))
1547 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1548 AFS_TRACE_LEVEL_ERROR,
1549 "AFSOpenRoot (%08lX) Access check failure Status %08lX\n",
1553 try_return( ntStatus);
1558 // Initialize the Ccb for the file.
1561 ntStatus = AFSInitCcb( Ccb);
1563 if( !NT_SUCCESS( ntStatus))
1566 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1567 AFS_TRACE_LEVEL_ERROR,
1568 "AFSOpenRoot (%08lX) Failed to allocate Ccb Status %08lX\n",
1572 try_return( ntStatus);
1575 bAllocatedCcb = TRUE;
1581 (*Ccb)->DirectoryCB = VolumeCB->DirectoryCB;
1584 // OK, update the share access on the fileobject
1587 if( VolumeCB->RootFcb->OpenHandleCount > 0)
1590 IoUpdateShareAccess( pFileObject,
1591 &VolumeCB->RootFcb->ShareAccess);
1600 IoSetShareAccess( *pDesiredAccess,
1603 &VolumeCB->RootFcb->ShareAccess);
1607 // Increment the open count on this Fcb
1610 InterlockedIncrement( &VolumeCB->RootFcb->OpenReferenceCount);
1612 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
1613 AFS_TRACE_LEVEL_VERBOSE,
1614 "AFSOpenRoot Increment count on Fcb %08lX Cnt %d\n",
1616 VolumeCB->RootFcb->OpenReferenceCount);
1618 InterlockedIncrement( &VolumeCB->RootFcb->OpenHandleCount);
1620 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
1621 AFS_TRACE_LEVEL_VERBOSE,
1622 "AFSOpenRoot Increment handle count on Fcb %08lX Cnt %d\n",
1624 VolumeCB->RootFcb->OpenHandleCount);
1627 // Indicate the object is held
1630 SetFlag( VolumeCB->ObjectInformation.Flags, AFS_OBJECT_HELD_IN_SERVICE);
1633 // Return the open result for this file
1636 Irp->IoStatus.Information = FILE_OPENED;
1638 *RootFcb = VolumeCB->RootFcb;
1645 AFSReleaseResource( VolumeCB->RootFcb->Header.Resource);
1648 if( !NT_SUCCESS( ntStatus))
1654 AFSRemoveCcb( *Ccb);
1659 Irp->IoStatus.Information = 0;
1667 AFSProcessCreate( IN PIRP Irp,
1669 IN AFSVolumeCB *VolumeCB,
1670 IN AFSDirectoryCB *ParentDirCB,
1671 IN PUNICODE_STRING FileName,
1672 IN PUNICODE_STRING ComponentName,
1673 IN PUNICODE_STRING FullFileName,
1678 NTSTATUS ntStatus = STATUS_SUCCESS;
1679 PFILE_OBJECT pFileObject = NULL;
1680 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1681 ULONG ulOptions = 0;
1682 ULONG ulShareMode = 0;
1684 ULONG ulAttributes = 0;
1685 LARGE_INTEGER liAllocationSize = {0,0};
1686 BOOLEAN bFileCreated = FALSE, bReleaseFcb = FALSE, bAllocatedCcb = FALSE;
1687 BOOLEAN bAllocatedFcb = FALSE;
1688 PACCESS_MASK pDesiredAccess = NULL;
1689 USHORT usShareAccess;
1690 AFSDirectoryCB *pDirEntry = NULL;
1691 AFSObjectInfoCB *pParentObjectInfo = NULL;
1692 AFSObjectInfoCB *pObjectInfo = NULL;
1697 pDesiredAccess = &pIrpSp->Parameters.Create.SecurityContext->DesiredAccess;
1698 usShareAccess = pIrpSp->Parameters.Create.ShareAccess;
1700 pFileObject = pIrpSp->FileObject;
1703 // Extract out the options
1706 ulOptions = pIrpSp->Parameters.Create.Options;
1709 // We pass all attributes they want to apply to the file to the create
1712 ulAttributes = pIrpSp->Parameters.Create.FileAttributes;
1715 // If this is a directory create then set the attribute correctly
1718 if( ulOptions & FILE_DIRECTORY_FILE)
1721 ulAttributes |= FILE_ATTRIBUTE_DIRECTORY;
1724 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1725 AFS_TRACE_LEVEL_VERBOSE,
1726 "AFSProcessCreate (%08lX) Creating file %wZ Attributes %08lX\n",
1731 if( BooleanFlagOn( VolumeCB->VolumeInformation.Characteristics, FILE_READ_ONLY_DEVICE))
1734 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1735 AFS_TRACE_LEVEL_ERROR,
1736 "AFSProcessCreate Request failed due to read only volume %wZ\n",
1739 try_return( ntStatus = STATUS_ACCESS_DENIED);
1742 pParentObjectInfo = ParentDirCB->ObjectInformation;
1745 // Allocate and insert the direntry into the parent node
1748 ntStatus = AFSCreateDirEntry( AuthGroup,
1756 if( !NT_SUCCESS( ntStatus))
1759 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1760 AFS_TRACE_LEVEL_ERROR,
1761 "AFSProcessCreate (%08lX) Failed to create directory entry %wZ Status %08lX\n",
1766 try_return( ntStatus);
1769 bFileCreated = TRUE;
1771 pObjectInfo = pDirEntry->ObjectInformation;
1774 // We may have raced and the Fcb is already created
1777 if( pObjectInfo->Fcb != NULL)
1780 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1781 AFS_TRACE_LEVEL_VERBOSE,
1782 "AFSProcessCreate (%08lX) Not allocating Fcb for file %wZ\n",
1786 *Fcb = pObjectInfo->Fcb;
1788 AFSAcquireExcl( &(*Fcb)->NPFcb->Resource,
1795 // Allocate and initialize the Fcb for the file.
1798 ntStatus = AFSInitFcb( pDirEntry,
1801 if( !NT_SUCCESS( ntStatus))
1804 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1805 AFS_TRACE_LEVEL_ERROR,
1806 "AFSProcessCreate (%08lX) Failed to initialize fcb %wZ Status %08lX\n",
1811 try_return( ntStatus);
1814 bAllocatedFcb = TRUE;
1820 // Initialize the Ccb for the file.
1823 ntStatus = AFSInitCcb( Ccb);
1825 if( !NT_SUCCESS( ntStatus))
1828 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1829 AFS_TRACE_LEVEL_ERROR,
1830 "AFSProcessCreate (%08lX) Failed to initialize ccb %wZ Status %08lX\n",
1835 try_return( ntStatus);
1838 bAllocatedCcb = TRUE;
1841 // Initialize the Ccb
1844 (*Ccb)->DirectoryCB = pDirEntry;
1847 // If this is a file, update the headers filesizes.
1850 if( (*Fcb)->Header.NodeTypeCode == AFS_FILE_FCB)
1854 // Update the sizes with the information passed in
1857 (*Fcb)->Header.AllocationSize.QuadPart = pObjectInfo->AllocationSize.QuadPart;
1858 (*Fcb)->Header.FileSize.QuadPart = pObjectInfo->EndOfFile.QuadPart;
1859 (*Fcb)->Header.ValidDataLength.QuadPart = pObjectInfo->EndOfFile.QuadPart;
1862 // Notify the system of the addition
1865 AFSFsRtlNotifyFullReportChange( pParentObjectInfo,
1867 (ULONG)FILE_NOTIFY_CHANGE_FILE_NAME,
1868 (ULONG)FILE_ACTION_ADDED);
1870 (*Fcb)->NPFcb->Specific.File.ExtentsRequestStatus = STATUS_SUCCESS;
1872 else if( (*Fcb)->Header.NodeTypeCode == AFS_DIRECTORY_FCB)
1876 // This is a new directory node so indicate it has been enumerated
1879 SetFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED);
1882 // And the parent directory entry
1885 KeQuerySystemTime( &pParentObjectInfo->ChangeTime);
1888 // Notify the system of the addition
1891 AFSFsRtlNotifyFullReportChange( pParentObjectInfo,
1893 (ULONG)FILE_NOTIFY_CHANGE_DIR_NAME,
1894 (ULONG)FILE_ACTION_ADDED);
1896 else if( (*Fcb)->Header.NodeTypeCode == AFS_MOUNT_POINT_FCB ||
1897 (*Fcb)->Header.NodeTypeCode == AFS_SYMBOLIC_LINK_FCB ||
1898 (*Fcb)->Header.NodeTypeCode == AFS_DFS_LINK_FCB)
1902 // And the parent directory entry
1905 KeQuerySystemTime( &pParentObjectInfo->ChangeTime);
1908 // Notify the system of the addition
1911 AFSFsRtlNotifyFullReportChange( pParentObjectInfo,
1913 (ULONG)FILE_NOTIFY_CHANGE_DIR_NAME,
1914 (ULONG)FILE_ACTION_ADDED);
1918 // Save off the access for the open
1921 IoSetShareAccess( *pDesiredAccess,
1924 &(*Fcb)->ShareAccess);
1927 // Increment the open count on this Fcb
1930 InterlockedIncrement( &(*Fcb)->OpenReferenceCount);
1932 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
1933 AFS_TRACE_LEVEL_VERBOSE,
1934 "AFSProcessCreate Increment count on Fcb %08lX Cnt %d\n",
1936 (*Fcb)->OpenReferenceCount);
1938 InterlockedIncrement( &(*Fcb)->OpenHandleCount);
1940 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
1941 AFS_TRACE_LEVEL_VERBOSE,
1942 "AFSProcessCreate Increment handle count on Fcb %08lX Cnt %d\n",
1944 (*Fcb)->OpenHandleCount);
1947 // Increment the open reference and handle on the parent node
1950 InterlockedIncrement( &pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
1952 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
1953 AFS_TRACE_LEVEL_VERBOSE,
1954 "AFSProcessCreate Increment child open handle count on Parent object %08lX Cnt %d\n",
1955 pObjectInfo->ParentObjectInformation,
1956 pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
1958 InterlockedIncrement( &pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
1960 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
1961 AFS_TRACE_LEVEL_VERBOSE,
1962 "AFSProcessCreate Increment child open ref count on Parent object %08lX Cnt %d\n",
1963 pObjectInfo->ParentObjectInformation,
1964 pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
1966 if( ulOptions & FILE_DELETE_ON_CLOSE)
1970 // Mark it for delete on close
1973 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1974 AFS_TRACE_LEVEL_VERBOSE,
1975 "AFSProcessCreate (%08lX) Setting PENDING_DELETE flag in DirEntry %p Name %wZ\n",
1980 SetFlag( pDirEntry->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
1984 // Indicate the object is locked in the service
1987 SetFlag( pObjectInfo->Flags, AFS_OBJECT_HELD_IN_SERVICE);
1990 // Return the open result for this file
1993 Irp->IoStatus.Information = FILE_CREATED;
1998 // If we created the Fcb we need to release the resources
2004 AFSReleaseResource( &(*Fcb)->NPFcb->Resource);
2007 if( !NT_SUCCESS( ntStatus))
2014 // Remove the dir entry from the parent
2017 AFSAcquireExcl( pParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
2020 AFSDeleteDirEntry( pParentObjectInfo,
2023 AFSReleaseResource( pParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
2029 AFSRemoveCcb( *Ccb);
2035 AFSRemoveFcb( pObjectInfo->Fcb);
2037 pObjectInfo->Fcb = NULL;
2050 AFSOpenTargetDirectory( IN PIRP Irp,
2051 IN AFSVolumeCB *VolumeCB,
2052 IN AFSDirectoryCB *ParentDirectoryCB,
2053 IN AFSDirectoryCB *TargetDirectoryCB,
2054 IN UNICODE_STRING *TargetName,
2059 NTSTATUS ntStatus = STATUS_SUCCESS;
2060 PFILE_OBJECT pFileObject = NULL;
2061 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2062 PACCESS_MASK pDesiredAccess = NULL;
2063 USHORT usShareAccess;
2064 BOOLEAN bAllocatedCcb = FALSE;
2065 BOOLEAN bReleaseFcb = FALSE, bAllocatedFcb = FALSE;
2066 AFSObjectInfoCB *pParentObject = NULL, *pTargetObject = NULL;
2067 UNICODE_STRING uniTargetName;
2072 pDesiredAccess = &pIrpSp->Parameters.Create.SecurityContext->DesiredAccess;
2073 usShareAccess = pIrpSp->Parameters.Create.ShareAccess;
2075 pFileObject = pIrpSp->FileObject;
2077 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2078 AFS_TRACE_LEVEL_VERBOSE,
2079 "AFSOpenTargetDirectory (%08lX) Processing file %wZ\n",
2083 pParentObject = ParentDirectoryCB->ObjectInformation;
2085 if( pParentObject->FileType != AFS_FILE_TYPE_DIRECTORY)
2088 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2092 // Make sure we have an Fcb for the access
2095 if( pParentObject->Fcb != NULL)
2098 *Fcb = pParentObject->Fcb;
2100 AFSAcquireExcl( &(*Fcb)->NPFcb->Resource,
2107 // Allocate and initialize the Fcb for the file.
2110 ntStatus = AFSInitFcb( ParentDirectoryCB,
2113 if( !NT_SUCCESS( ntStatus))
2116 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2117 AFS_TRACE_LEVEL_ERROR,
2118 "AFSProcessCreate (%08lX) Failed to initialize fcb %wZ Status %08lX\n",
2120 &ParentDirectoryCB->NameInformation.FileName,
2123 try_return( ntStatus);
2126 bAllocatedFcb = TRUE;
2132 // If there are current opens on the Fcb, check the access.
2135 if( pParentObject->Fcb->OpenHandleCount > 0)
2138 ntStatus = IoCheckShareAccess( *pDesiredAccess,
2141 &pParentObject->Fcb->ShareAccess,
2144 if( !NT_SUCCESS( ntStatus))
2147 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2148 AFS_TRACE_LEVEL_ERROR,
2149 "AFSOpenTargetDirectory (%08lX) Access check failure %wZ Status %08lX\n",
2151 &ParentDirectoryCB->NameInformation.FileName,
2154 try_return( ntStatus);
2159 // Initialize the Ccb for the file.
2162 ntStatus = AFSInitCcb( Ccb);
2164 if( !NT_SUCCESS( ntStatus))
2167 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2168 AFS_TRACE_LEVEL_ERROR,
2169 "AFSOpenTargetDirectory (%08lX) Failed to initialize ccb %wZ Status %08lX\n",
2171 &ParentDirectoryCB->NameInformation.FileName,
2174 try_return( ntStatus);
2177 bAllocatedCcb = TRUE;
2180 // Initialize the Ccb
2183 (*Ccb)->DirectoryCB = ParentDirectoryCB;
2185 if( TargetDirectoryCB != NULL &&
2186 FsRtlAreNamesEqual( &TargetDirectoryCB->NameInformation.FileName,
2192 Irp->IoStatus.Information = FILE_EXISTS;
2194 uniTargetName = TargetDirectoryCB->NameInformation.FileName;
2199 Irp->IoStatus.Information = FILE_DOES_NOT_EXIST;
2201 uniTargetName = *TargetName;
2205 // Update the filename in the fileobject for rename processing
2208 RtlCopyMemory( pFileObject->FileName.Buffer,
2209 uniTargetName.Buffer,
2210 uniTargetName.Length);
2212 pFileObject->FileName.Length = uniTargetName.Length;
2215 // OK, update the share access on the fileobject
2218 if( pParentObject->Fcb->OpenHandleCount > 0)
2221 IoUpdateShareAccess( pFileObject,
2222 &pParentObject->Fcb->ShareAccess);
2231 IoSetShareAccess( *pDesiredAccess,
2234 &pParentObject->Fcb->ShareAccess);
2238 // Increment the open count on this Fcb
2241 InterlockedIncrement( &pParentObject->Fcb->OpenReferenceCount);
2243 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2244 AFS_TRACE_LEVEL_VERBOSE,
2245 "AFSOpenTargetDirectory Increment count on Fcb %08lX Cnt %d\n",
2247 pParentObject->Fcb->OpenReferenceCount);
2249 InterlockedIncrement( &pParentObject->Fcb->OpenHandleCount);
2251 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2252 AFS_TRACE_LEVEL_VERBOSE,
2253 "AFSOpenTargetDirectory Increment handle count on Fcb %08lX Cnt %d\n",
2255 pParentObject->Fcb->OpenHandleCount);
2258 // Increment the open reference and handle on the parent node
2261 if( pParentObject->ParentObjectInformation != NULL)
2264 InterlockedIncrement( &pParentObject->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
2266 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2267 AFS_TRACE_LEVEL_VERBOSE,
2268 "AFSOpenTargetDirectory Increment child open handle count on Parent object %08lX Cnt %d\n",
2269 pParentObject->ParentObjectInformation,
2270 pParentObject->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
2272 InterlockedIncrement( &pParentObject->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
2274 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2275 AFS_TRACE_LEVEL_VERBOSE,
2276 "AFSOpenTargetDirectory Increment child open ref count on Parent object %08lX Cnt %d\n",
2277 pParentObject->ParentObjectInformation,
2278 pParentObject->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
2286 AFSReleaseResource( &pParentObject->Fcb->NPFcb->Resource);
2289 if( !NT_SUCCESS( ntStatus))
2295 AFSRemoveCcb( *Ccb);
2303 AFSRemoveFcb( pParentObject->Fcb);
2305 pParentObject->Fcb = NULL;
2316 AFSProcessOpen( IN PIRP Irp,
2318 IN AFSVolumeCB *VolumeCB,
2319 IN AFSDirectoryCB *ParentDirCB,
2320 IN AFSDirectoryCB *DirectoryCB,
2325 NTSTATUS ntStatus = STATUS_SUCCESS;
2326 PFILE_OBJECT pFileObject = NULL;
2327 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2328 PACCESS_MASK pDesiredAccess = NULL;
2329 USHORT usShareAccess;
2330 BOOLEAN bAllocatedCcb = FALSE, bReleaseFcb = FALSE, bAllocatedFcb = FALSE;
2331 ULONG ulAdditionalFlags = 0, ulOptions = 0;
2332 AFSFileOpenCB stOpenCB;
2333 AFSFileOpenResultCB stOpenResultCB;
2334 ULONG ulResultLen = 0;
2335 AFSObjectInfoCB *pParentObjectInfo = NULL;
2336 AFSObjectInfoCB *pObjectInfo = NULL;
2341 pDesiredAccess = &pIrpSp->Parameters.Create.SecurityContext->DesiredAccess;
2342 usShareAccess = pIrpSp->Parameters.Create.ShareAccess;
2344 pFileObject = pIrpSp->FileObject;
2346 pParentObjectInfo = ParentDirCB->ObjectInformation;
2348 pObjectInfo = DirectoryCB->ObjectInformation;
2351 // Check if the entry is pending a deletion
2354 if( BooleanFlagOn( DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE))
2357 ntStatus = STATUS_DELETE_PENDING;
2359 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2360 AFS_TRACE_LEVEL_ERROR,
2361 "AFSProcessOpen (%08lX) Entry pending delete %wZ Status %08lX\n",
2363 &DirectoryCB->NameInformation.FileName,
2366 try_return( ntStatus);
2370 // Extract out the options
2373 ulOptions = pIrpSp->Parameters.Create.Options;
2376 // Check if we should go and retrieve updated information for the node
2379 ntStatus = AFSValidateEntry( DirectoryCB,
2384 if( !NT_SUCCESS( ntStatus))
2387 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2388 AFS_TRACE_LEVEL_ERROR,
2389 "AFSProcessOpen (%08lX) Failed to validate entry %wZ Status %08lX\n",
2391 &DirectoryCB->NameInformation.FileName,
2394 try_return( ntStatus);
2398 // If this is marked for delete on close then be sure we can delete the entry
2401 if( BooleanFlagOn( ulOptions, FILE_DELETE_ON_CLOSE))
2404 ntStatus = AFSNotifyDelete( DirectoryCB,
2407 if( !NT_SUCCESS( ntStatus))
2410 ntStatus = STATUS_CANNOT_DELETE;
2412 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2413 AFS_TRACE_LEVEL_ERROR,
2414 "AFSProcessOpen (%08lX) Cannot delete entry %wZ marked for delete on close Status %08lX\n",
2416 &DirectoryCB->NameInformation.FileName,
2419 try_return( ntStatus);
2424 // Be sure we have an Fcb for the current object
2427 if( pObjectInfo->Fcb == NULL)
2430 ntStatus = AFSInitFcb( DirectoryCB,
2433 if( !NT_SUCCESS( ntStatus))
2436 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2437 AFS_TRACE_LEVEL_ERROR,
2438 "AFSProcessOpen (%08lX) Failed to init fcb on %wZ Status %08lX\n",
2440 &DirectoryCB->NameInformation.FileName,
2443 try_return( ntStatus);
2446 bAllocatedFcb = TRUE;
2451 AFSAcquireExcl( pObjectInfo->Fcb->Header.Resource,
2458 // Reference the Fcb so it won't go away while we call into the service for processing
2461 InterlockedIncrement( &pObjectInfo->Fcb->OpenReferenceCount);
2463 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2464 AFS_TRACE_LEVEL_VERBOSE,
2465 "AFSProcessOpen Increment count on Fcb %08lX Cnt %d\n",
2467 pObjectInfo->Fcb->OpenReferenceCount);
2470 // Check access on the entry
2473 if( pObjectInfo->Fcb->OpenHandleCount > 0)
2476 ntStatus = IoCheckShareAccess( *pDesiredAccess,
2479 &pObjectInfo->Fcb->ShareAccess,
2482 if( !NT_SUCCESS( ntStatus))
2485 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2486 AFS_TRACE_LEVEL_ERROR,
2487 "AFSProcessOpen (%08lX) Failed to check share access on %wZ Status %08lX\n",
2489 &DirectoryCB->NameInformation.FileName,
2492 try_return( ntStatus);
2497 // Additional checks
2500 if( pObjectInfo->Fcb->Header.NodeTypeCode == AFS_FILE_FCB)
2504 // If the caller is asking for write access then try to flush the image section
2507 if( FlagOn( *pDesiredAccess, FILE_WRITE_DATA) ||
2508 BooleanFlagOn(ulOptions, FILE_DELETE_ON_CLOSE))
2511 if( !MmFlushImageSection( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers,
2515 ntStatus = BooleanFlagOn(ulOptions, FILE_DELETE_ON_CLOSE) ? STATUS_CANNOT_DELETE :
2516 STATUS_SHARING_VIOLATION;
2518 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2519 AFS_TRACE_LEVEL_ERROR,
2520 "AFSProcessOpen (%08lX) Failed to flush image section %wZ Status %08lX\n",
2522 &DirectoryCB->NameInformation.FileName,
2525 try_return( ntStatus);
2529 if( BooleanFlagOn( ulOptions, FILE_DIRECTORY_FILE))
2532 ntStatus = STATUS_NOT_A_DIRECTORY;
2534 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2535 AFS_TRACE_LEVEL_ERROR,
2536 "AFSProcessOpen (%08lX) Attempt to open file as directory %wZ Status %08lX\n",
2538 &DirectoryCB->NameInformation.FileName,
2541 try_return( ntStatus);
2544 pObjectInfo->Fcb->NPFcb->Specific.File.ExtentsRequestStatus = STATUS_SUCCESS;
2546 else if( pObjectInfo->Fcb->Header.NodeTypeCode == AFS_DIRECTORY_FCB ||
2547 pObjectInfo->Fcb->Header.NodeTypeCode == AFS_ROOT_FCB)
2550 if( BooleanFlagOn( ulOptions, FILE_NON_DIRECTORY_FILE))
2553 ntStatus = STATUS_FILE_IS_A_DIRECTORY;
2555 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2556 AFS_TRACE_LEVEL_ERROR,
2557 "AFSProcessOpen (%08lX) Attempt to open directory as file %wZ Status %08lX\n",
2559 &DirectoryCB->NameInformation.FileName,
2562 try_return( ntStatus);
2565 else if( pObjectInfo->Fcb->Header.NodeTypeCode == AFS_MOUNT_POINT_FCB ||
2566 pObjectInfo->Fcb->Header.NodeTypeCode == AFS_SYMBOLIC_LINK_FCB ||
2567 pObjectInfo->Fcb->Header.NodeTypeCode == AFS_DFS_LINK_FCB)
2574 try_return( ntStatus = STATUS_UNSUCCESSFUL);
2578 // Check with the service that we can open the file
2581 stOpenCB.ParentId = pParentObjectInfo->FileId;
2583 stOpenCB.DesiredAccess = *pDesiredAccess;
2585 stOpenCB.ShareAccess = usShareAccess;
2587 stOpenResultCB.GrantedAccess = 0;
2589 ulResultLen = sizeof( AFSFileOpenResultCB);
2591 ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_OPEN_FILE,
2592 AFS_REQUEST_FLAG_SYNCHRONOUS | AFS_REQUEST_FLAG_HOLD_FID,
2594 &DirectoryCB->NameInformation.FileName,
2595 &pObjectInfo->FileId,
2597 sizeof( AFSFileOpenCB),
2598 (void *)&stOpenResultCB,
2601 if( !NT_SUCCESS( ntStatus))
2604 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2605 AFS_TRACE_LEVEL_ERROR,
2606 "AFSProcessOpen (%08lX) Failed open in service %wZ Status %08lX\n",
2608 &DirectoryCB->NameInformation.FileName,
2611 try_return( ntStatus);
2615 // Check if there is a conflict
2618 if( !AFSCheckAccess( *pDesiredAccess,
2619 stOpenResultCB.GrantedAccess,
2620 BooleanFlagOn( DirectoryCB->ObjectInformation->FileAttributes, FILE_ATTRIBUTE_DIRECTORY)))
2623 ntStatus = STATUS_ACCESS_DENIED;
2625 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2626 AFS_TRACE_LEVEL_ERROR,
2627 "AFSProcessOpen (%08lX) Failed to check access from service Desired %08lX Granted %08lX Entry %wZ Status %08lX\n",
2630 stOpenResultCB.GrantedAccess,
2631 &DirectoryCB->NameInformation.FileName,
2634 try_return( ntStatus);
2638 // Initialize the Ccb for the file.
2641 ntStatus = AFSInitCcb( Ccb);
2643 if( !NT_SUCCESS( ntStatus))
2646 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2647 AFS_TRACE_LEVEL_ERROR,
2648 "AFSProcessOpen (%08lX) Failed to initialize ccb %wZ Status %08lX\n",
2650 &DirectoryCB->NameInformation.FileName,
2653 try_return( ntStatus);
2656 bAllocatedCcb = TRUE;
2658 (*Ccb)->DirectoryCB = DirectoryCB;
2661 // Perform the access check on the target if this is a mount point or symlink
2664 if( pObjectInfo->Fcb->OpenHandleCount > 0)
2667 IoUpdateShareAccess( pFileObject,
2668 &pObjectInfo->Fcb->ShareAccess);
2677 IoSetShareAccess( *pDesiredAccess,
2680 &pObjectInfo->Fcb->ShareAccess);
2684 // Increment the open count on this Fcb
2687 InterlockedIncrement( &pObjectInfo->Fcb->OpenReferenceCount);
2689 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2690 AFS_TRACE_LEVEL_VERBOSE,
2691 "AFSProcessOpen Increment2 count on Fcb %08lX Cnt %d\n",
2693 pObjectInfo->Fcb->OpenReferenceCount);
2695 InterlockedIncrement( &pObjectInfo->Fcb->OpenHandleCount);
2697 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2698 AFS_TRACE_LEVEL_VERBOSE,
2699 "AFSProcessOpen Increment handle count on Fcb %08lX Cnt %d\n",
2701 pObjectInfo->Fcb->OpenHandleCount);
2704 // Increment the open reference and handle on the parent node
2707 InterlockedIncrement( &pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
2709 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2710 AFS_TRACE_LEVEL_VERBOSE,
2711 "AFSProcessOpen Increment child open handle count on Parent object %08lX Cnt %d\n",
2712 pObjectInfo->ParentObjectInformation,
2713 pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
2715 InterlockedIncrement( &pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
2717 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2718 AFS_TRACE_LEVEL_VERBOSE,
2719 "AFSProcessOpen Increment child open ref count on Parent object %08lX Cnt %d\n",
2720 pObjectInfo->ParentObjectInformation,
2721 pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
2723 if( BooleanFlagOn( ulOptions, FILE_DELETE_ON_CLOSE))
2727 // Mark it for delete on close
2730 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2731 AFS_TRACE_LEVEL_VERBOSE,
2732 "AFSProcessOpen (%08lX) Setting PENDING_DELETE flag in DirEntry %p Name %wZ\n",
2735 &DirectoryCB->NameInformation.FileName);
2737 SetFlag( DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2741 // Indicate the object is held
2744 SetFlag( pObjectInfo->Flags, AFS_OBJECT_HELD_IN_SERVICE);
2747 // Return the open result for this file
2750 Irp->IoStatus.Information = FILE_OPENED;
2752 *Fcb = pObjectInfo->Fcb;
2760 // Remove the reference we added initially
2763 InterlockedDecrement( &pObjectInfo->Fcb->OpenReferenceCount);
2765 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2766 AFS_TRACE_LEVEL_VERBOSE,
2767 "AFSProcessOpen Decrement count on Fcb %08lX Cnt %d\n",
2769 pObjectInfo->Fcb->OpenReferenceCount);
2771 AFSReleaseResource( pObjectInfo->Fcb->Header.Resource);
2774 if( !NT_SUCCESS( ntStatus))
2780 AFSRemoveCcb( *Ccb);
2788 AFSRemoveFcb( pObjectInfo->Fcb);
2790 pObjectInfo->Fcb = NULL;
2801 AFSProcessOverwriteSupersede( IN PDEVICE_OBJECT DeviceObject,
2803 IN AFSVolumeCB *VolumeCB,
2805 IN AFSDirectoryCB *ParentDirCB,
2806 IN AFSDirectoryCB *DirectoryCB,
2811 NTSTATUS ntStatus = STATUS_SUCCESS;
2812 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2813 PFILE_OBJECT pFileObject = NULL;
2814 LARGE_INTEGER liZero = {0,0};
2815 BOOLEAN bReleasePaging = FALSE, bReleaseFcb = FALSE;
2816 ULONG ulAttributes = 0;
2817 LARGE_INTEGER liTime;
2818 ULONG ulCreateDisposition = 0;
2819 BOOLEAN bAllocatedCcb = FALSE, bAllocatedFcb = FALSE;
2820 PACCESS_MASK pDesiredAccess = NULL;
2821 USHORT usShareAccess;
2822 AFSObjectInfoCB *pParentObjectInfo = NULL;
2823 AFSObjectInfoCB *pObjectInfo = NULL;
2828 pDesiredAccess = &pIrpSp->Parameters.Create.SecurityContext->DesiredAccess;
2829 usShareAccess = pIrpSp->Parameters.Create.ShareAccess;
2831 pFileObject = pIrpSp->FileObject;
2833 ulAttributes = pIrpSp->Parameters.Create.FileAttributes;
2835 ulCreateDisposition = (pIrpSp->Parameters.Create.Options >> 24) & 0x000000ff;
2837 if( BooleanFlagOn( VolumeCB->VolumeInformation.Characteristics, FILE_READ_ONLY_DEVICE))
2840 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2841 AFS_TRACE_LEVEL_ERROR,
2842 "AFSProcessOverwriteSupersede Request failed on %wZ due to read only volume\n",
2844 &DirectoryCB->NameInformation.FileName);
2846 try_return( ntStatus = STATUS_ACCESS_DENIED);
2849 pParentObjectInfo = ParentDirCB->ObjectInformation;
2851 pObjectInfo = DirectoryCB->ObjectInformation;
2854 // Check if we should go and retrieve updated information for the node
2857 ntStatus = AFSValidateEntry( DirectoryCB,
2862 if( !NT_SUCCESS( ntStatus))
2865 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2866 AFS_TRACE_LEVEL_ERROR,
2867 "AFSProcessOverwriteSupersede (%08lX) Failed to validate entry %wZ Status %08lX\n",
2869 &DirectoryCB->NameInformation.FileName,
2872 try_return( ntStatus);
2876 // Be sure we have an Fcb for the object block
2879 if( pObjectInfo->Fcb == NULL)
2882 ntStatus = AFSInitFcb( DirectoryCB,
2885 if( !NT_SUCCESS( ntStatus))
2888 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2889 AFS_TRACE_LEVEL_ERROR,
2890 "AFSProcessOverwriteSupersede (%08lX) Failed to initialize fcb %wZ Status %08lX\n",
2892 &DirectoryCB->NameInformation.FileName,
2895 try_return( ntStatus);
2898 bAllocatedFcb = TRUE;
2903 AFSAcquireExcl( pObjectInfo->Fcb->Header.Resource,
2910 // Reference the Fcb so it won't go away while processing the request
2913 InterlockedIncrement( &pObjectInfo->Fcb->OpenReferenceCount);
2915 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2916 AFS_TRACE_LEVEL_VERBOSE,
2917 "AFSProcessOverwriteSupersede Increment count on Fcb %08lX Cnt %d\n",
2919 pObjectInfo->Fcb->OpenReferenceCount);
2922 // Check access on the entry
2925 if( pObjectInfo->Fcb->OpenHandleCount > 0)
2928 ntStatus = IoCheckShareAccess( *pDesiredAccess,
2931 &pObjectInfo->Fcb->ShareAccess,
2934 if( !NT_SUCCESS( ntStatus))
2937 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2938 AFS_TRACE_LEVEL_ERROR,
2939 "AFSProcessOverwriteSupersede (%08lX) Access check failure %wZ Status %08lX\n",
2941 &DirectoryCB->NameInformation.FileName,
2944 try_return( ntStatus);
2949 // Before we actually truncate, check to see if the purge
2950 // is going to fail.
2953 if( !MmCanFileBeTruncated( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers,
2957 ntStatus = STATUS_USER_MAPPED_FILE;
2959 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2960 AFS_TRACE_LEVEL_ERROR,
2961 "AFSProcessOverwriteSupersede (%08lX) File user mapped %wZ Status %08lX\n",
2963 &DirectoryCB->NameInformation.FileName,
2966 try_return( ntStatus);
2970 // Initialize the Ccb for the file.
2973 ntStatus = AFSInitCcb( Ccb);
2975 if( !NT_SUCCESS( ntStatus))
2978 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2979 AFS_TRACE_LEVEL_ERROR,
2980 "AFSProcessOverwriteSupersede (%08lX) Failed to initialize ccb %wZ Status %08lX\n",
2982 &DirectoryCB->NameInformation.FileName,
2985 try_return( ntStatus);
2988 bAllocatedCcb = TRUE;
2991 // Initialize the Ccb
2994 (*Ccb)->DirectoryCB = DirectoryCB;
2997 // Need to purge any data currently in the cache
3000 CcPurgeCacheSection( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers,
3005 pObjectInfo->Fcb->Header.FileSize.QuadPart = 0;
3006 pObjectInfo->Fcb->Header.ValidDataLength.QuadPart = 0;
3007 pObjectInfo->Fcb->Header.AllocationSize.QuadPart = 0;
3009 pObjectInfo->EndOfFile.QuadPart = 0;
3010 pObjectInfo->AllocationSize.QuadPart = 0;
3013 // Trim down the extents. We do this BEFORE telling the service
3014 // the file is truncated since there is a potential race between
3015 // a worker thread releasing extents and us trimming
3018 AFSTrimExtents( pObjectInfo->Fcb,
3019 &pObjectInfo->Fcb->Header.FileSize);
3021 KeQuerySystemTime( &pObjectInfo->ChangeTime);
3023 KeQuerySystemTime( &pObjectInfo->LastAccessTime);
3025 //KeQuerySystemTime( &pObjectInfo->CreationTime);
3027 KeQuerySystemTime( &pObjectInfo->LastWriteTime);
3029 ntStatus = AFSUpdateFileInformation( &pParentObjectInfo->FileId,
3033 if( !NT_SUCCESS( ntStatus))
3036 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3037 AFS_TRACE_LEVEL_ERROR,
3038 "AFSProcessOverwriteSupersede (%08lX) Failed to update file information %wZ Status %08lX\n",
3040 &DirectoryCB->NameInformation.FileName,
3043 try_return( ntStatus);
3046 AFSAcquireExcl( pObjectInfo->Fcb->Header.PagingIoResource,
3049 bReleasePaging = TRUE;
3051 pFileObject->SectionObjectPointer = &pObjectInfo->Fcb->NPFcb->SectionObjectPointers;
3053 pFileObject->FsContext = (void *)pObjectInfo->Fcb;
3055 pFileObject->FsContext2 = (void *)*Ccb;
3058 // Set the update flag accordingly
3061 SetFlag( pObjectInfo->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED |
3062 AFS_FCB_FLAG_UPDATE_CREATE_TIME |
3063 AFS_FCB_FLAG_UPDATE_CHANGE_TIME |
3064 AFS_FCB_FLAG_UPDATE_ACCESS_TIME |
3065 AFS_FCB_FLAG_UPDATE_LAST_WRITE_TIME);
3067 CcSetFileSizes( pFileObject,
3068 (PCC_FILE_SIZES)&pObjectInfo->Fcb->Header.AllocationSize);
3070 AFSReleaseResource( pObjectInfo->Fcb->Header.PagingIoResource);
3072 bReleasePaging = FALSE;
3074 ulAttributes |= FILE_ATTRIBUTE_ARCHIVE;
3076 if( ulCreateDisposition == FILE_SUPERSEDE)
3079 pObjectInfo->FileAttributes = ulAttributes;
3085 pObjectInfo->FileAttributes |= ulAttributes;
3089 // Save off the access for the open
3092 if( pObjectInfo->Fcb->OpenHandleCount > 0)
3095 IoUpdateShareAccess( pFileObject,
3096 &pObjectInfo->Fcb->ShareAccess);
3105 IoSetShareAccess( *pDesiredAccess,
3108 &pObjectInfo->Fcb->ShareAccess);
3112 // Return the correct action
3115 if( ulCreateDisposition == FILE_SUPERSEDE)
3118 Irp->IoStatus.Information = FILE_SUPERSEDED;
3123 Irp->IoStatus.Information = FILE_OVERWRITTEN;
3127 // Increment the open count on this Fcb.
3130 InterlockedIncrement( &pObjectInfo->Fcb->OpenReferenceCount);
3132 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3133 AFS_TRACE_LEVEL_VERBOSE,
3134 "AFSProcessOverwriteSupersede Increment2 count on Fcb %08lX Cnt %d\n",
3136 pObjectInfo->Fcb->OpenReferenceCount);
3138 InterlockedIncrement( &pObjectInfo->Fcb->OpenHandleCount);
3140 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3141 AFS_TRACE_LEVEL_VERBOSE,
3142 "AFSProcessOverwriteSupersede Increment handle count on Fcb %08lX Cnt %d\n",
3144 pObjectInfo->Fcb->OpenHandleCount);
3147 // Increment the open reference and handle on the parent node
3150 InterlockedIncrement( &pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
3152 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3153 AFS_TRACE_LEVEL_VERBOSE,
3154 "AFSProcessOverwriteSupersede Increment child open handle count on Parent object %08lX Cnt %d\n",
3155 pObjectInfo->ParentObjectInformation,
3156 pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
3158 InterlockedIncrement( &pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
3160 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3161 AFS_TRACE_LEVEL_VERBOSE,
3162 "AFSProcessOverwriteSupersede Increment child open ref count on Parent object %08lX Cnt %d\n",
3163 pObjectInfo->ParentObjectInformation,
3164 pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
3166 *Fcb = pObjectInfo->Fcb;
3173 AFSReleaseResource( pObjectInfo->Fcb->Header.PagingIoResource);
3180 // Remove the reference we added above to prevent tear down
3183 InterlockedDecrement( &pObjectInfo->Fcb->OpenReferenceCount);
3185 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3186 AFS_TRACE_LEVEL_VERBOSE,
3187 "AFSProcessOverwriteSupersede Decrement count on Fcb %08lX Cnt %d\n",
3189 pObjectInfo->Fcb->OpenReferenceCount);
3191 AFSReleaseResource( pObjectInfo->Fcb->Header.Resource);
3194 if( !NT_SUCCESS( ntStatus))
3200 AFSRemoveCcb( *Ccb);
3208 AFSRemoveFcb( pObjectInfo->Fcb);
3210 pObjectInfo->Fcb = NULL;
3221 AFSControlDeviceCreate( IN PIRP Irp)
3224 NTSTATUS ntStatus = STATUS_SUCCESS;
3230 // For now, jsut let the open happen
3233 Irp->IoStatus.Information = FILE_OPENED;
3240 AFSOpenIOCtlFcb( IN PIRP Irp,
3242 IN AFSDirectoryCB *ParentDirCB,
3247 NTSTATUS ntStatus = STATUS_SUCCESS;
3248 PFILE_OBJECT pFileObject = NULL;
3249 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3250 BOOLEAN bReleaseFcb = FALSE, bAllocatedCcb = FALSE, bAllocatedFcb = FALSE;
3251 UNICODE_STRING uniFullFileName;
3252 AFSPIOCtlOpenCloseRequestCB stPIOCtlOpen;
3254 AFSObjectInfoCB *pParentObjectInfo = NULL;
3259 pFileObject = pIrpSp->FileObject;
3261 pParentObjectInfo = ParentDirCB->ObjectInformation;
3264 // If we haven't initialized the PIOCtl DirectoryCB for this directory then do it now
3267 if( pParentObjectInfo->Specific.Directory.PIOCtlDirectoryCB == NULL)
3270 ntStatus = AFSInitPIOCtlDirectoryCB( pParentObjectInfo);
3272 if( !NT_SUCCESS( ntStatus))
3275 try_return( ntStatus);
3279 if( pParentObjectInfo->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb == NULL)
3283 // Allocate and initialize the Fcb for the file.
3286 ntStatus = AFSInitFcb( pParentObjectInfo->Specific.Directory.PIOCtlDirectoryCB,
3289 if( !NT_SUCCESS( ntStatus))
3292 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3293 AFS_TRACE_LEVEL_ERROR,
3294 "AFSOpenIOCtlFcb (%08lX) Failed to initialize fcb Status %08lX\n",
3298 try_return( ntStatus);
3301 bAllocatedFcb = TRUE;
3306 *Fcb = pParentObjectInfo->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb;
3308 AFSAcquireExcl( &(*Fcb)->NPFcb->Resource,
3315 // Initialize the Ccb for the file.
3318 ntStatus = AFSInitCcb( Ccb);
3320 if( !NT_SUCCESS( ntStatus))
3323 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3324 AFS_TRACE_LEVEL_ERROR,
3325 "AFSOpenIOCtlFcb (%08lX) Failed to initialize ccb Status %08lX\n",
3329 try_return( ntStatus);
3332 bAllocatedCcb = TRUE;
3338 (*Ccb)->DirectoryCB = pParentObjectInfo->Specific.Directory.PIOCtlDirectoryCB;
3341 // Set the PIOCtl index
3344 (*Ccb)->RequestID = InterlockedIncrement( &pParentObjectInfo->Specific.Directory.OpenRequestIndex);
3346 RtlZeroMemory( &stPIOCtlOpen,
3347 sizeof( AFSPIOCtlOpenCloseRequestCB));
3349 stPIOCtlOpen.RequestId = (*Ccb)->RequestID;
3351 stPIOCtlOpen.RootId = pParentObjectInfo->VolumeCB->ObjectInformation.FileId;
3353 RtlZeroMemory( &stFileID,
3354 sizeof( AFSFileID));
3357 // The parent directory FID of the node
3360 stFileID = pParentObjectInfo->FileId;
3363 // Issue the open request to the service
3366 ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_PIOCTL_OPEN,
3367 AFS_REQUEST_FLAG_SYNCHRONOUS,
3371 (void *)&stPIOCtlOpen,
3372 sizeof( AFSPIOCtlOpenCloseRequestCB),
3376 if( !NT_SUCCESS( ntStatus))
3379 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3380 AFS_TRACE_LEVEL_ERROR,
3381 "AFSOpenIOCtlFcb (%08lX) Failed service open Status %08lX\n",
3385 try_return( ntStatus);
3389 // Reference the directory entry
3392 InterlockedIncrement( &((*Ccb)->DirectoryCB->OpenReferenceCount));
3394 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3395 AFS_TRACE_LEVEL_VERBOSE,
3396 "AFSOpenIOCtlFcb Increment count on %wZ DE %p Ccb %p Cnt %d\n",
3397 &(*Ccb)->DirectoryCB->NameInformation.FileName,
3398 (*Ccb)->DirectoryCB,
3400 (*Ccb)->DirectoryCB->OpenReferenceCount);
3403 // Increment the open reference and handle on the node
3406 InterlockedIncrement( &(*Fcb)->OpenReferenceCount);
3408 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3409 AFS_TRACE_LEVEL_VERBOSE,
3410 "AFSOpenIOCtlFcb Increment count on Fcb %08lX Cnt %d\n",
3412 (*Fcb)->OpenReferenceCount);
3414 InterlockedIncrement( &(*Fcb)->OpenHandleCount);
3416 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3417 AFS_TRACE_LEVEL_VERBOSE,
3418 "AFSOpenIOCtlFcb Increment handle count on Fcb %08lX Cnt %d\n",
3420 (*Fcb)->OpenHandleCount);
3423 // Increment the open reference and handle on the parent node
3426 InterlockedIncrement( &pParentObjectInfo->Specific.Directory.ChildOpenHandleCount);
3428 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3429 AFS_TRACE_LEVEL_VERBOSE,
3430 "AFSOpenIOCtlFcb Increment child open handle count on Parent object %08lX Cnt %d\n",
3432 pParentObjectInfo->Specific.Directory.ChildOpenHandleCount);
3434 InterlockedIncrement( &pParentObjectInfo->Specific.Directory.ChildOpenReferenceCount);
3436 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3437 AFS_TRACE_LEVEL_VERBOSE,
3438 "AFSOpenIOCtlFcb Increment child open ref count on Parent object %08lX Cnt %d\n",
3440 pParentObjectInfo->Specific.Directory.ChildOpenReferenceCount);
3443 // Return the open result for this file
3446 Irp->IoStatus.Information = FILE_OPENED;
3451 //Dereference the passed in parent since the returned dir entry
3452 // is already referenced
3455 InterlockedDecrement( &ParentDirCB->OpenReferenceCount);
3457 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3458 AFS_TRACE_LEVEL_VERBOSE,
3459 "AFSOpenIOCtlFcb Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
3460 &ParentDirCB->NameInformation.FileName,
3463 ParentDirCB->OpenReferenceCount);
3466 // If we created the Fcb we need to release the resources
3472 AFSReleaseResource( &(*Fcb)->NPFcb->Resource);
3475 if( !NT_SUCCESS( ntStatus))
3481 AFSRemoveCcb( *Ccb);
3490 // Need to tear down this Fcb since it is not in the tree for the worker thread
3493 AFSRemoveFcb( *Fcb);
3495 pParentObjectInfo->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb = NULL;
3508 AFSOpenSpecialShareFcb( IN PIRP Irp,
3510 IN AFSDirectoryCB *DirectoryCB,
3515 NTSTATUS ntStatus = STATUS_SUCCESS;
3516 PFILE_OBJECT pFileObject = NULL;
3517 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3518 BOOLEAN bReleaseFcb = FALSE, bAllocatedCcb = FALSE, bAllocateFcb = FALSE;
3519 AFSObjectInfoCB *pParentObjectInfo = NULL;
3520 AFSPipeOpenCloseRequestCB stPipeOpen;
3525 pFileObject = pIrpSp->FileObject;
3527 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3528 AFS_TRACE_LEVEL_VERBOSE_2,
3529 "AFSOpenSpecialShareFcb (%08lX) Processing Share %wZ open\n",
3531 &DirectoryCB->NameInformation.FileName);
3533 pParentObjectInfo = DirectoryCB->ObjectInformation->ParentObjectInformation;
3535 if( DirectoryCB->ObjectInformation->Fcb == NULL)
3539 // Allocate and initialize the Fcb for the file.
3542 ntStatus = AFSInitFcb( DirectoryCB,
3545 if( !NT_SUCCESS( ntStatus))
3548 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3549 AFS_TRACE_LEVEL_ERROR,
3550 "AFSOpenSpecialShareFcb (%08lX) Failed to initialize fcb Status %08lX\n",
3554 try_return( ntStatus);
3557 bAllocateFcb = TRUE;
3562 *Fcb = DirectoryCB->ObjectInformation->Fcb;
3564 AFSAcquireExcl( &(*Fcb)->NPFcb->Resource,
3571 // Initialize the Ccb for the file.
3574 ntStatus = AFSInitCcb( Ccb);
3576 if( !NT_SUCCESS( ntStatus))
3579 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3580 AFS_TRACE_LEVEL_ERROR,
3581 "AFSOpenSpecialShareFcb (%08lX) Failed to initialize ccb Status %08lX\n",
3585 try_return( ntStatus);
3588 bAllocatedCcb = TRUE;
3594 (*Ccb)->DirectoryCB = DirectoryCB;
3597 // Call the service to open the share
3600 (*Ccb)->RequestID = InterlockedIncrement( &pParentObjectInfo->Specific.Directory.OpenRequestIndex);
3602 RtlZeroMemory( &stPipeOpen,
3603 sizeof( AFSPipeOpenCloseRequestCB));
3605 stPipeOpen.RequestId = (*Ccb)->RequestID;
3607 stPipeOpen.RootId = pParentObjectInfo->VolumeCB->ObjectInformation.FileId;
3610 // Issue the open request to the service
3613 ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_PIPE_OPEN,
3614 AFS_REQUEST_FLAG_SYNCHRONOUS,
3616 &DirectoryCB->NameInformation.FileName,
3618 (void *)&stPipeOpen,
3619 sizeof( AFSPipeOpenCloseRequestCB),
3623 if( !NT_SUCCESS( ntStatus))
3626 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3627 AFS_TRACE_LEVEL_ERROR,
3628 "AFSOpenSpecialShareFcb (%08lX) Failed service open Status %08lX\n",
3632 try_return( ntStatus);
3636 // Increment the open count on this Fcb
3639 InterlockedIncrement( &(*Fcb)->OpenReferenceCount);
3641 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3642 AFS_TRACE_LEVEL_VERBOSE,
3643 "AFSOpenSpecialShareFcb Increment count on Fcb %08lX Cnt %d\n",
3645 (*Fcb)->OpenReferenceCount);
3647 InterlockedIncrement( &(*Fcb)->OpenHandleCount);
3649 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3650 AFS_TRACE_LEVEL_VERBOSE,
3651 "AFSOpenSpecialShareFcb Increment handle count on Fcb %08lX Cnt %d\n",
3653 (*Fcb)->OpenHandleCount);
3656 // Increment the open reference and handle on the parent node
3659 InterlockedIncrement( &pParentObjectInfo->Specific.Directory.ChildOpenHandleCount);
3661 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3662 AFS_TRACE_LEVEL_VERBOSE,
3663 "AFSOpenSpecialShareFcb Increment child open handle count on Parent object %08lX Cnt %d\n",
3665 pParentObjectInfo->Specific.Directory.ChildOpenHandleCount);
3667 InterlockedIncrement( &pParentObjectInfo->Specific.Directory.ChildOpenReferenceCount);
3669 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3670 AFS_TRACE_LEVEL_VERBOSE,
3671 "AFSOpenSpecialShareFcb Increment child open ref count on Parent object %08lX Cnt %d\n",
3673 pParentObjectInfo->Specific.Directory.ChildOpenReferenceCount);
3676 // Return the open result for this file
3679 Irp->IoStatus.Information = FILE_OPENED;
3686 AFSReleaseResource( &(*Fcb)->NPFcb->Resource);
3689 if( !NT_SUCCESS( ntStatus))
3695 AFSRemoveCcb( *Ccb);
3704 // Need to tear down this Fcb since it is not in the tree for the worker thread
3707 AFSRemoveFcb( *Fcb);
3709 DirectoryCB->ObjectInformation->Fcb = NULL;