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;
148 BOOLEAN bOpenedReparsePoint = FALSE;
153 pIrpSp = IoGetCurrentIrpStackLocation( Irp);
154 pDeviceExt = (AFSDeviceExt *)DeviceObject->DeviceExtension;
155 ulCreateDisposition = (pIrpSp->Parameters.Create.Options >> 24) & 0x000000ff;
156 ulOptions = pIrpSp->Parameters.Create.Options;
157 bNoIntermediateBuffering = BooleanFlagOn( ulOptions, FILE_NO_INTERMEDIATE_BUFFERING);
158 bOpenTargetDirectory = BooleanFlagOn( pIrpSp->Flags, SL_OPEN_TARGET_DIRECTORY);
159 pFileObject = pIrpSp->FileObject;
160 pDesiredAccess = &pIrpSp->Parameters.Create.SecurityContext->DesiredAccess;
162 uniFileName.Length = uniFileName.MaximumLength = 0;
163 uniFileName.Buffer = NULL;
165 uniRootFileName.Length = uniRootFileName.MaximumLength = 0;
166 uniRootFileName.Buffer = NULL;
168 uniParsedFileName.Length = uniParsedFileName.MaximumLength = 0;
169 uniParsedFileName.Buffer = NULL;
171 uniSubstitutedPathName.Buffer = NULL;
172 uniSubstitutedPathName.Length = 0;
174 uniRelativeName.Buffer = NULL;
175 uniRelativeName.Length = 0;
177 if( AFSGlobalRoot == NULL)
179 try_return( ntStatus = STATUS_DEVICE_NOT_READY);
182 RtlZeroMemory( &stAuthGroup,
185 AFSRetrieveAuthGroupFnc( (ULONGLONG)PsGetCurrentProcessId(),
186 (ULONGLONG)PsGetCurrentThreadId(),
189 if( !BooleanFlagOn( AFSGlobalRoot->ObjectInformation.Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED))
192 ntStatus = AFSEnumerateGlobalRoot( &stAuthGroup);
194 if( !NT_SUCCESS( ntStatus))
197 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
198 AFS_TRACE_LEVEL_ERROR,
199 "AFSCommonCreate Failed to enumerate global root Status %08lX\n",
202 try_return( ntStatus);
207 // If we are in shutdown mode then fail the request
210 if( BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_REDIRECTOR_SHUTDOWN))
213 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
214 AFS_TRACE_LEVEL_WARNING,
215 "AFSCommonCreate (%08lX) Open request after shutdown\n",
218 try_return( ntStatus = STATUS_TOO_LATE);
222 // Go and parse the name for processing.
223 // If ulParseFlags is returned with AFS_PARSE_FLAG_FREE_FILE_BUFFER set,
224 // then we are responsible for releasing the uniRootFileName.Buffer.
227 ntStatus = AFSParseName( Irp,
237 if( !NT_SUCCESS( ntStatus))
240 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
241 uniFileName.Length > 0 ? AFS_TRACE_LEVEL_ERROR : AFS_TRACE_LEVEL_VERBOSE,
242 "AFSCommonCreate (%08lX) Failed to parse name \"%wZ\" Status %08lX\n",
247 try_return( ntStatus);
251 // Check for STATUS_REPARSE
254 if( ntStatus == STATUS_REPARSE)
258 // Update the information and return
261 Irp->IoStatus.Information = IO_REPARSE;
263 try_return( ntStatus);
267 // If the returned volume cb is NULL then we are dealing with the \\Server\GlobalRoot
271 if( pVolumeCB == NULL)
275 // Remove any leading or trailing slashes
278 if( uniFileName.Length >= sizeof( WCHAR) &&
279 uniFileName.Buffer[ (uniFileName.Length/sizeof( WCHAR)) - 1] == L'\\')
282 uniFileName.Length -= sizeof( WCHAR);
285 if( uniFileName.Length >= sizeof( WCHAR) &&
286 uniFileName.Buffer[ 0] == L'\\')
289 uniFileName.Buffer = &uniFileName.Buffer[ 1];
291 uniFileName.Length -= sizeof( WCHAR);
295 // If there is a remaining portion returned for this request then
296 // check if it is for the PIOCtl interface
299 if( uniFileName.Length > 0)
303 // We don't accept any other opens off of the AFS Root
306 ntStatus = STATUS_OBJECT_NAME_NOT_FOUND;
309 // If this is an open on "_._AFS_IOCTL_._" then perform handling on it accordingly
312 if( RtlCompareUnicodeString( &AFSPIOCtlName,
317 ntStatus = AFSOpenIOCtlFcb( Irp,
319 AFSGlobalRoot->DirectoryCB,
323 if( !NT_SUCCESS( ntStatus))
326 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
327 AFS_TRACE_LEVEL_ERROR,
328 "AFSCommonCreate Failed to open root IOCtl Fcb Status %08lX\n",
332 else if( pParentDirectoryCB != NULL &&
333 pParentDirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_SPECIAL_SHARE_NAME)
336 ntStatus = AFSOpenSpecialShareFcb( Irp,
342 if( !NT_SUCCESS( ntStatus))
345 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
346 AFS_TRACE_LEVEL_ERROR,
347 "AFSCommonCreate Failed to open special share Fcb Status %08lX\n",
352 try_return( ntStatus);
355 ntStatus = AFSOpenAFSRoot( Irp,
359 if( !NT_SUCCESS( ntStatus))
362 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
363 AFS_TRACE_LEVEL_ERROR,
364 "AFSCommonCreate Failed to open root Status %08lX\n",
367 InterlockedDecrement( &AFSGlobalRoot->DirectoryCB->OpenReferenceCount);
369 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
370 AFS_TRACE_LEVEL_VERBOSE,
371 "AFSCreate Decrement1 count on &wZ DE %p Ccb %p Cnt %d\n",
372 &AFSGlobalRoot->DirectoryCB->NameInformation.FileName,
373 AFSGlobalRoot->DirectoryCB,
375 AFSGlobalRoot->DirectoryCB->OpenReferenceCount);
378 try_return( ntStatus);
382 // We have a reference on the root volume
385 bReleaseVolume = TRUE;
388 // Attempt to locate the node in the name tree if this is not a target
389 // open and the target is not the root
392 uniComponentName.Length = 0;
393 uniComponentName.Buffer = NULL;
395 if( uniFileName.Length > sizeof( WCHAR) ||
396 uniFileName.Buffer[ 0] != L'\\')
399 if( !AFSValidNameFormat( &uniFileName))
402 ntStatus = STATUS_OBJECT_NAME_NOT_FOUND;
404 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
405 AFS_TRACE_LEVEL_VERBOSE,
406 "AFSCommonCreate (%08lX) Invalid name %wZ Status %08lX\n",
411 try_return( ntStatus);
415 // Opening a reparse point directly?
418 ulNameProcessingFlags = AFS_LOCATE_FLAGS_SUBSTITUTE_NAME;
420 if( BooleanFlagOn( ulOptions, FILE_OPEN_REPARSE_POINT))
422 ulNameProcessingFlags |= (AFS_LOCATE_FLAGS_NO_MP_TARGET_EVAL |
423 AFS_LOCATE_FLAGS_NO_SL_TARGET_EVAL |
424 AFS_LOCATE_FLAGS_NO_DFS_LINK_EVAL);
427 uniSubstitutedPathName = uniRootFileName;
429 ntStatus = AFSLocateNameEntry( &stAuthGroup,
434 ulNameProcessingFlags,
440 if( !NT_SUCCESS( ntStatus) &&
441 ntStatus != STATUS_OBJECT_NAME_NOT_FOUND)
444 if ( uniSubstitutedPathName.Buffer == uniRootFileName.Buffer)
446 uniSubstitutedPathName.Buffer = NULL;
450 // The routine above released the root while walking the
454 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
455 AFS_TRACE_LEVEL_VERBOSE,
456 "AFSCommonCreate (%08lX) Failed to locate name entry for %wZ Status %08lX\n",
462 // We released any root volume locks in the above on failure
465 bReleaseVolume = FALSE;
467 try_return( ntStatus);
471 // Check for STATUS_REPARSE
474 if( ntStatus == STATUS_REPARSE)
477 uniSubstitutedPathName.Buffer = NULL;
480 // Update the information and return
483 Irp->IoStatus.Information = IO_REPARSE;
486 // We released the volume lock above
489 bReleaseVolume = FALSE;
491 try_return( ntStatus);
495 // If we re-allocated the name, then update our substitute name
498 if( uniSubstitutedPathName.Buffer != uniRootFileName.Buffer)
501 uniSubstitutedPathName = uniRootFileName;
506 uniSubstitutedPathName.Buffer = NULL;
510 // Check for a symlink access
513 if( ntStatus == STATUS_OBJECT_NAME_NOT_FOUND &&
514 pParentDirectoryCB != NULL)
517 UNICODE_STRING uniFinalComponent;
519 uniFinalComponent.Length = 0;
520 uniFinalComponent.MaximumLength = 0;
521 uniFinalComponent.Buffer = NULL;
523 AFSRetrieveFinalComponent( &uniFileName,
526 ntStatus = AFSCheckSymlinkAccess( pParentDirectoryCB,
529 if( !NT_SUCCESS( ntStatus) &&
530 ntStatus != STATUS_OBJECT_NAME_NOT_FOUND)
533 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
534 AFS_TRACE_LEVEL_VERBOSE,
535 "AFSCommonCreate (%08lX) Failing access to symlink %wZ Status %08lX\n",
540 try_return( ntStatus);
546 // If we have no parent then this is a root open, be sure there is a directory entry
550 else if( pParentDirectoryCB == NULL &&
551 pDirectoryCB == NULL)
554 pDirectoryCB = pVolumeCB->DirectoryCB;
557 if( bOpenTargetDirectory)
561 // If we have a directory cb for the entry then dereference it and reference the parent
564 if( pDirectoryCB != NULL)
568 // Perform in this order to prevent thrashing
571 InterlockedIncrement( &pParentDirectoryCB->OpenReferenceCount);
573 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
574 AFS_TRACE_LEVEL_VERBOSE,
575 "AFSCreate Increment1 count on %wZ DE %p Ccb %p Cnt %d\n",
576 &pParentDirectoryCB->NameInformation.FileName,
579 pParentDirectoryCB->OpenReferenceCount);
582 // Do NOT decrement the reference count on the pDirectoryCB yet.
583 // The BackupEntry below might drop the count to zero leaving
584 // the entry subject to being deleted and we need some of the
585 // contents during later processing
588 AFSBackupEntry( pNameArray);
592 // OK, open the target directory
595 if( uniComponentName.Length == 0)
597 AFSRetrieveFinalComponent( &uniFileName,
601 ntStatus = AFSOpenTargetDirectory( Irp,
608 if( pDirectoryCB != NULL)
611 // It is now safe to drop the Reference Count
613 InterlockedDecrement( &pDirectoryCB->OpenReferenceCount);
615 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
616 AFS_TRACE_LEVEL_VERBOSE,
617 "AFSCreate Decrement2 count on %wZ DE %p Ccb %p Cnt %d\n",
618 &pDirectoryCB->NameInformation.FileName,
621 pDirectoryCB->OpenReferenceCount);
624 if( !NT_SUCCESS( ntStatus))
627 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
628 AFS_TRACE_LEVEL_ERROR,
629 "AFSCommonCreate Failed to open target directory %wZ Status %08lX\n",
630 &pParentDirectoryCB->NameInformation.FileName,
634 // Decrement the reference on the parent
637 InterlockedDecrement( &pParentDirectoryCB->OpenReferenceCount);
639 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
640 AFS_TRACE_LEVEL_VERBOSE,
641 "AFSCreate Decrement3 count on %wZ DE %p Ccb %p Cnt %d\n",
642 &pParentDirectoryCB->NameInformation.FileName,
645 pParentDirectoryCB->OpenReferenceCount);
648 try_return( ntStatus);
651 if ( BooleanFlagOn( ulOptions, FILE_OPEN_REPARSE_POINT))
654 if( pDirectoryCB == NULL ||
655 !BooleanFlagOn( pDirectoryCB->ObjectInformation->FileAttributes, FILE_ATTRIBUTE_REPARSE_POINT))
657 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
658 AFS_TRACE_LEVEL_VERBOSE,
659 "AFSCommonCreate (%08lX) Reparse open request but attribute not set for %wZ DirCB %p Type %08lX\n",
663 pDirectoryCB ? pDirectoryCB->ObjectInformation->FileType : 0);
667 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
668 AFS_TRACE_LEVEL_VERBOSE,
669 "AFSCommonCreate (%08lX) Opening as reparse point %wZ Type %08lX\n",
672 pDirectoryCB->ObjectInformation->FileType);
674 bOpenedReparsePoint = TRUE;
679 // Based on the options passed in, process the file accordingly.
682 if( ulCreateDisposition == FILE_CREATE ||
683 ( ( ulCreateDisposition == FILE_OPEN_IF ||
684 ulCreateDisposition == FILE_OVERWRITE_IF) &&
685 pDirectoryCB == NULL))
688 if( uniComponentName.Length == 0 ||
689 pDirectoryCB != NULL)
693 // We traversed the entire path so we found each entry,
694 // fail with collision
697 if( pDirectoryCB != NULL)
700 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
701 AFS_TRACE_LEVEL_VERBOSE,
702 "AFSCommonCreate Object name collision on create of %wZ Status %08lX\n",
703 &pDirectoryCB->NameInformation.FileName,
706 InterlockedDecrement( &pDirectoryCB->OpenReferenceCount);
708 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
709 AFS_TRACE_LEVEL_VERBOSE,
710 "AFSCreate Decrement4 count on %wZ DE %p Ccb %p Cnt %d\n",
711 &pDirectoryCB->NameInformation.FileName,
714 pDirectoryCB->OpenReferenceCount);
719 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
720 AFS_TRACE_LEVEL_VERBOSE,
721 "AFSCommonCreate Object name collision on create Status %08lX\n",
724 InterlockedDecrement( &pParentDirectoryCB->OpenReferenceCount);
726 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
727 AFS_TRACE_LEVEL_VERBOSE,
728 "AFSCreate Decrement5 count on %wZ DE %p Ccb %p Cnt %d\n",
729 &pParentDirectoryCB->NameInformation.FileName,
732 pParentDirectoryCB->OpenReferenceCount);
735 try_return( ntStatus = STATUS_OBJECT_NAME_COLLISION);
739 // OK, go and create the node
742 ntStatus = AFSProcessCreate( Irp,
752 if( !NT_SUCCESS( ntStatus))
755 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
756 AFS_TRACE_LEVEL_ERROR,
757 "AFSCommonCreate Failed to create of %wZ in directory %wZ Status %08lX\n",
759 &pParentDirectoryCB->NameInformation.FileName,
764 // Dereference the parent entry
767 InterlockedDecrement( &pParentDirectoryCB->OpenReferenceCount);
769 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
770 AFS_TRACE_LEVEL_VERBOSE,
771 "AFSCreate Decrement6 count on %wZ DE %p Ccb %p Cnt %d\n",
772 &pParentDirectoryCB->NameInformation.FileName,
775 pParentDirectoryCB->OpenReferenceCount);
777 try_return( ntStatus);
781 // We should not have an extra component except for PIOCtl opens
784 if( uniComponentName.Length > 0)
788 // If this is an open on "_._AFS_IOCTL_._" then perform handling on it accordingly
791 if( RtlCompareUnicodeString( &AFSPIOCtlName,
796 ntStatus = AFSOpenIOCtlFcb( Irp,
802 if( !NT_SUCCESS( ntStatus))
805 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
806 AFS_TRACE_LEVEL_ERROR,
807 "AFSCommonCreate Failed to IOCtl open on %wZ Status %08lX\n",
815 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
816 AFS_TRACE_LEVEL_VERBOSE,
817 "AFSCommonCreate (%08lX) File %wZ name not found\n",
821 ntStatus = STATUS_OBJECT_NAME_NOT_FOUND;
824 if( !NT_SUCCESS( ntStatus))
828 // Dereference the parent entry
831 if( pDirectoryCB != NULL)
834 InterlockedDecrement( &pDirectoryCB->OpenReferenceCount);
836 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
837 AFS_TRACE_LEVEL_VERBOSE,
838 "AFSCreate Decrement7a count on %wZ DE %p Ccb %p Cnt %d\n",
839 &pDirectoryCB->NameInformation.FileName,
842 pDirectoryCB->OpenReferenceCount);
847 InterlockedDecrement( &pParentDirectoryCB->OpenReferenceCount);
849 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
850 AFS_TRACE_LEVEL_VERBOSE,
851 "AFSCreate Decrement7b count on %wZ DE %p Ccb %p Cnt %d\n",
852 &pParentDirectoryCB->NameInformation.FileName,
855 pParentDirectoryCB->OpenReferenceCount);
859 try_return( ntStatus);
863 // For root opens the parent will be NULL
866 if( pParentDirectoryCB == NULL)
870 // Check for the delete on close flag for the root
873 if( BooleanFlagOn( ulOptions, FILE_DELETE_ON_CLOSE ))
876 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
877 AFS_TRACE_LEVEL_ERROR,
878 "AFSCommonCreate (%08lX) Attempt to open root as delete on close\n",
881 InterlockedDecrement( &pDirectoryCB->OpenReferenceCount);
883 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
884 AFS_TRACE_LEVEL_VERBOSE,
885 "AFSCreate Decrement8 count on %wZ DE %p Ccb %p Cnt %d\n",
886 &pDirectoryCB->NameInformation.FileName,
889 pDirectoryCB->OpenReferenceCount);
891 try_return( ntStatus = STATUS_CANNOT_DELETE);
895 // If this is the target directory, then bail
898 if( bOpenTargetDirectory)
901 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
902 AFS_TRACE_LEVEL_ERROR,
903 "AFSCommonCreate (%08lX) Attempt to open root as target directory\n",
906 InterlockedDecrement( &pDirectoryCB->OpenReferenceCount);
908 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
909 AFS_TRACE_LEVEL_VERBOSE,
910 "AFSCreate Decrement9 count on %wZ DE %p Ccb %p Cnt %d\n",
911 &pDirectoryCB->NameInformation.FileName,
914 pDirectoryCB->OpenReferenceCount);
916 try_return( ntStatus = STATUS_INVALID_PARAMETER);
920 // Go and open the root of the volume
923 ntStatus = AFSOpenRoot( Irp,
929 if( !NT_SUCCESS( ntStatus))
932 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
933 AFS_TRACE_LEVEL_ERROR,
934 "AFSCommonCreate Failed to open volume root %08lX-%08lX Status %08lX\n",
935 pVolumeCB->ObjectInformation.FileId.Cell,
936 pVolumeCB->ObjectInformation.FileId.Volume,
939 InterlockedDecrement( &pDirectoryCB->OpenReferenceCount);
941 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
942 AFS_TRACE_LEVEL_VERBOSE,
943 "AFSCreate Decrement10 count on %wZ DE %p Ccb %p Cnt %d\n",
944 &pDirectoryCB->NameInformation.FileName,
947 pDirectoryCB->OpenReferenceCount);
950 try_return( ntStatus);
954 // At this point if we have no pDirectoryCB it was not found.
957 if( pDirectoryCB == NULL)
960 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
961 AFS_TRACE_LEVEL_ERROR,
962 "AFSCommonCreate Failing access to %wZ\n",
965 try_return( ntStatus = STATUS_OBJECT_NAME_NOT_FOUND);
968 if( ulCreateDisposition == FILE_OVERWRITE ||
969 ulCreateDisposition == FILE_SUPERSEDE ||
970 ulCreateDisposition == FILE_OVERWRITE_IF)
974 // Go process a file for overwrite or supersede.
977 ntStatus = AFSProcessOverwriteSupersede( DeviceObject,
986 if( !NT_SUCCESS( ntStatus))
989 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
990 AFS_TRACE_LEVEL_ERROR,
991 "AFSCommonCreate Failed overwrite/supersede on %wZ Status %08lX\n",
992 &pDirectoryCB->NameInformation.FileName,
995 InterlockedDecrement( &pDirectoryCB->OpenReferenceCount);
997 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
998 AFS_TRACE_LEVEL_VERBOSE,
999 "AFSCreate Decrement11 count on %wZ DE %p Ccb %p Cnt %d\n",
1000 &pDirectoryCB->NameInformation.FileName,
1003 pDirectoryCB->OpenReferenceCount);
1006 try_return( ntStatus);
1010 // Trying to open the file
1013 ntStatus = AFSProcessOpen( Irp,
1021 if( !NT_SUCCESS( ntStatus))
1024 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1025 AFS_TRACE_LEVEL_ERROR,
1026 "AFSCommonCreate Failed open on %wZ Status %08lX\n",
1027 &pDirectoryCB->NameInformation.FileName,
1030 InterlockedDecrement( &pDirectoryCB->OpenReferenceCount);
1032 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1033 AFS_TRACE_LEVEL_VERBOSE,
1034 "AFSCreate Decrement12 count on %wZ DE %p Ccb %p Cnt %d\n",
1035 &pDirectoryCB->NameInformation.FileName,
1038 pDirectoryCB->OpenReferenceCount);
1043 if( NT_SUCCESS( ntStatus) &&
1044 ntStatus != STATUS_REPARSE)
1050 RtlCopyMemory( &pCcb->AuthGroup,
1055 // If we have a substitute name, then use it
1058 if( uniSubstitutedPathName.Buffer != NULL)
1061 pCcb->FullFileName = uniSubstitutedPathName;
1063 SetFlag( pCcb->Flags, CCB_FLAG_FREE_FULL_PATHNAME);
1065 ClearFlag( ulParseFlags, AFS_PARSE_FLAG_FREE_FILE_BUFFER);
1070 pCcb->FullFileName = uniRootFileName;
1072 if( BooleanFlagOn( ulParseFlags, AFS_PARSE_FLAG_FREE_FILE_BUFFER))
1075 SetFlag( pCcb->Flags, CCB_FLAG_FREE_FULL_PATHNAME);
1077 ClearFlag( ulParseFlags, AFS_PARSE_FLAG_FREE_FILE_BUFFER);
1081 if( bOpenedReparsePoint)
1083 SetFlag( pCcb->Flags, CCB_FLAG_MASK_OPENED_REPARSE_POINT);
1086 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1087 AFS_TRACE_LEVEL_VERBOSE,
1088 "AFSCreate Count on %wZ DE %p Ccb %p Cnt %d\n",
1089 &pCcb->DirectoryCB->NameInformation.FileName,
1092 pCcb->DirectoryCB->OpenReferenceCount);
1094 ASSERT( pCcb->DirectoryCB->OpenReferenceCount > 0);
1096 pCcb->CurrentDirIndex = 0;
1098 if( !BooleanFlagOn( ulParseFlags, AFS_PARSE_FLAG_ROOT_ACCESS))
1101 SetFlag( pCcb->Flags, CCB_FLAG_RETURN_RELATIVE_ENTRIES);
1105 // Save off the name array for this instance
1108 pCcb->NameArray = pNameArray;
1114 // If we make it here then init the FO for the request.
1117 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1118 AFS_TRACE_LEVEL_VERBOSE_2,
1119 "AFSCommonCreate (%08lX) FileObject %08lX FsContext %08lX FsContext2 %08lX\n",
1125 pFileObject->FsContext = (void *)pFcb;
1127 pFileObject->FsContext2 = (void *)pCcb;
1132 ASSERT( pFcb->OpenHandleCount > 0);
1134 ClearFlag( pFcb->Flags, AFS_FCB_FILE_CLOSED);
1137 // For files perform additional processing
1140 if( pFcb->Header.NodeTypeCode == AFS_FILE_FCB)
1142 pFileObject->SectionObjectPointer = &pFcb->NPFcb->SectionObjectPointers;
1146 // If the user did not request nobuffering then mark the FO as cacheable
1149 if( bNoIntermediateBuffering)
1152 pFileObject->Flags |= FO_NO_INTERMEDIATE_BUFFERING;
1157 pFileObject->Flags |= FO_CACHE_SUPPORTED;
1161 // If the file was opened for execution then we need to set the bit in the FO
1164 if( BooleanFlagOn( *pDesiredAccess,
1168 SetFlag( pFileObject->Flags, FO_FILE_FAST_IO_READ);
1172 // Update the last access time
1175 KeQuerySystemTime( &pFcb->ObjectInformation->LastAccessTime);
1186 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1187 AFS_TRACE_LEVEL_ERROR,
1188 "AFSCommonCreate (%08lX) Returning with NULL Fcb FileObject %08lX FsContext %08lX FsContext2 %08lX\n",
1197 if( NT_SUCCESS( ntStatus) &&
1198 ntStatus == STATUS_REPARSE)
1201 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1202 AFS_TRACE_LEVEL_ERROR,
1203 "AFSCommonCreate (%08lX) STATUS_REPARSE FileObject %08lX FsContext %08lX FsContext2 %08lX\n",
1211 // Free up the sub name if we have one
1214 if( uniSubstitutedPathName.Buffer != NULL)
1217 AFSExFreePool( uniSubstitutedPathName.Buffer);
1219 ClearFlag( ulParseFlags, AFS_PARSE_FLAG_FREE_FILE_BUFFER);
1224 // Free up the name array ...
1227 if( pNameArray != NULL)
1230 AFSFreeNameArray( pNameArray);
1233 if( BooleanFlagOn( ulParseFlags, AFS_PARSE_FLAG_FREE_FILE_BUFFER))
1236 AFSExFreePool( uniRootFileName.Buffer);
1242 InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
1244 AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
1245 AFS_TRACE_LEVEL_VERBOSE,
1246 "AFSCommonCreate Decrement count on Volume %08lX Cnt %d\n",
1248 pVolumeCB->VolumeReferenceCount);
1252 // Setup the Irp for completion, the Information has been set previously
1255 Irp->IoStatus.Status = ntStatus;
1262 AFSOpenRedirector( IN PIRP Irp,
1267 NTSTATUS ntStatus = STATUS_SUCCESS;
1273 // Initialize the Ccb for the file.
1276 ntStatus = AFSInitCcb( Ccb);
1278 if( !NT_SUCCESS( ntStatus))
1281 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1282 AFS_TRACE_LEVEL_ERROR,
1283 "AFSOpenRedirector (%08lX) Failed to allocate Ccb\n",
1286 try_return( ntStatus);
1293 (*Ccb)->DirectoryCB = AFSRedirectorRoot->DirectoryCB;
1296 // Increment the open count on this Fcb
1299 InterlockedIncrement( &AFSRedirectorRoot->RootFcb->OpenReferenceCount);
1301 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
1302 AFS_TRACE_LEVEL_VERBOSE,
1303 "AFSOpenRedirector Increment count on Fcb %08lX Cnt %d\n",
1304 AFSRedirectorRoot->RootFcb,
1305 AFSRedirectorRoot->RootFcb->OpenReferenceCount);
1307 InterlockedIncrement( &AFSRedirectorRoot->RootFcb->OpenHandleCount);
1309 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
1310 AFS_TRACE_LEVEL_VERBOSE,
1311 "AFSOpenRedirector Increment handle count on Fcb %08lX Cnt %d\n",
1312 AFSRedirectorRoot->RootFcb,
1313 AFSRedirectorRoot->RootFcb->OpenHandleCount);
1315 *Fcb = AFSRedirectorRoot->RootFcb;
1317 InterlockedIncrement( &(*Ccb)->DirectoryCB->OpenReferenceCount);
1320 // Return the open result for this file
1323 Irp->IoStatus.Information = FILE_OPENED;
1334 AFSOpenAFSRoot( IN PIRP Irp,
1339 NTSTATUS ntStatus = STATUS_SUCCESS;
1345 // Initialize the Ccb for the file.
1348 ntStatus = AFSInitCcb( Ccb);
1350 if( !NT_SUCCESS( ntStatus))
1353 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1354 AFS_TRACE_LEVEL_ERROR,
1355 "AFSOpenAFSRoot (%08lX) Failed to allocate Ccb\n",
1358 try_return( ntStatus);
1365 (*Ccb)->DirectoryCB = AFSGlobalRoot->DirectoryCB;
1368 // Increment the open count on this Fcb
1371 InterlockedIncrement( &AFSGlobalRoot->RootFcb->OpenReferenceCount);
1373 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
1374 AFS_TRACE_LEVEL_VERBOSE,
1375 "AFSOpenAFSRoot Increment count on Fcb %08lX Cnt %d\n",
1376 AFSGlobalRoot->RootFcb,
1377 AFSGlobalRoot->RootFcb->OpenReferenceCount);
1379 InterlockedIncrement( &AFSGlobalRoot->RootFcb->OpenHandleCount);
1381 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
1382 AFS_TRACE_LEVEL_VERBOSE,
1383 "AFSOpenAFSRoot Increment handle count on Fcb %08lX Cnt %d\n",
1384 AFSGlobalRoot->RootFcb,
1385 AFSGlobalRoot->RootFcb->OpenHandleCount);
1387 *Fcb = AFSGlobalRoot->RootFcb;
1390 // Return the open result for this file
1393 Irp->IoStatus.Information = FILE_OPENED;
1404 AFSOpenRoot( IN PIRP Irp,
1405 IN AFSVolumeCB *VolumeCB,
1407 OUT AFSFcb **RootFcb,
1411 NTSTATUS ntStatus = STATUS_SUCCESS;
1412 PFILE_OBJECT pFileObject = NULL;
1413 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1414 PACCESS_MASK pDesiredAccess = NULL;
1415 USHORT usShareAccess;
1416 BOOLEAN bAllocatedCcb = FALSE;
1417 BOOLEAN bReleaseFcb = FALSE;
1418 AFSFileOpenCB stOpenCB;
1419 AFSFileOpenResultCB stOpenResultCB;
1420 ULONG ulResultLen = 0;
1425 pDesiredAccess = &pIrpSp->Parameters.Create.SecurityContext->DesiredAccess;
1426 usShareAccess = pIrpSp->Parameters.Create.ShareAccess;
1428 pFileObject = pIrpSp->FileObject;
1431 // Check if we should go and retrieve updated information for the node
1434 ntStatus = AFSValidateEntry( VolumeCB->DirectoryCB,
1439 if( !NT_SUCCESS( ntStatus))
1442 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1443 AFS_TRACE_LEVEL_ERROR,
1444 "AFSOpenRoot (%08lX) Failed to validate root entry Status %08lX\n",
1448 try_return( ntStatus);
1452 // Check with the service that we can open the file
1455 RtlZeroMemory( &stOpenCB,
1456 sizeof( AFSFileOpenCB));
1458 stOpenCB.DesiredAccess = *pDesiredAccess;
1460 stOpenCB.ShareAccess = usShareAccess;
1462 stOpenResultCB.GrantedAccess = 0;
1464 ulResultLen = sizeof( AFSFileOpenResultCB);
1466 ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_OPEN_FILE,
1467 AFS_REQUEST_FLAG_SYNCHRONOUS | AFS_REQUEST_FLAG_HOLD_FID,
1470 &VolumeCB->ObjectInformation.FileId,
1472 sizeof( AFSFileOpenCB),
1473 (void *)&stOpenResultCB,
1476 if( !NT_SUCCESS( ntStatus))
1479 UNICODE_STRING uniGUID;
1482 uniGUID.MaximumLength = 0;
1483 uniGUID.Buffer = NULL;
1485 if( AuthGroup != NULL)
1487 RtlStringFromGUID( *AuthGroup,
1491 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1492 AFS_TRACE_LEVEL_ERROR,
1493 "AFSOpenRoot (%08lX) Failed open in service volume %08lX-%08lX AuthGroup %wZ Status %08lX\n",
1495 VolumeCB->ObjectInformation.FileId.Cell,
1496 VolumeCB->ObjectInformation.FileId.Volume,
1500 if( AuthGroup != NULL)
1502 RtlFreeUnicodeString( &uniGUID);
1505 try_return( ntStatus);
1509 // If the entry is not initialized then do it now
1512 if( !BooleanFlagOn( VolumeCB->ObjectInformation.Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED))
1515 AFSAcquireExcl( VolumeCB->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock,
1518 if( !BooleanFlagOn( VolumeCB->ObjectInformation.Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED))
1521 ntStatus = AFSEnumerateDirectory( AuthGroup,
1522 &VolumeCB->ObjectInformation,
1525 if( !NT_SUCCESS( ntStatus))
1528 AFSReleaseResource( VolumeCB->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock);
1530 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1531 AFS_TRACE_LEVEL_ERROR,
1532 "AFSOpenRoot (%08lX) Failed to enumerate directory Status %08lX\n",
1536 try_return( ntStatus);
1539 SetFlag( VolumeCB->ObjectInformation.Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED);
1542 AFSReleaseResource( VolumeCB->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock);
1546 // If the root fcb has been initialized then check access otherwise
1547 // init the volume fcb
1550 if( VolumeCB->RootFcb == NULL)
1553 ntStatus = AFSInitRootFcb( (ULONGLONG)PsGetCurrentProcessId(),
1556 if( !NT_SUCCESS( ntStatus))
1559 try_return( ntStatus);
1565 AFSAcquireExcl( VolumeCB->RootFcb->Header.Resource,
1572 // If there are current opens on the Fcb, check the access.
1575 if( VolumeCB->RootFcb->OpenHandleCount > 0)
1578 ntStatus = IoCheckShareAccess( *pDesiredAccess,
1581 &VolumeCB->RootFcb->ShareAccess,
1584 if( !NT_SUCCESS( ntStatus))
1587 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1588 AFS_TRACE_LEVEL_ERROR,
1589 "AFSOpenRoot (%08lX) Access check failure Status %08lX\n",
1593 try_return( ntStatus);
1598 // Initialize the Ccb for the file.
1601 ntStatus = AFSInitCcb( Ccb);
1603 if( !NT_SUCCESS( ntStatus))
1606 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1607 AFS_TRACE_LEVEL_ERROR,
1608 "AFSOpenRoot (%08lX) Failed to allocate Ccb Status %08lX\n",
1612 try_return( ntStatus);
1615 bAllocatedCcb = TRUE;
1621 (*Ccb)->DirectoryCB = VolumeCB->DirectoryCB;
1623 (*Ccb)->GrantedAccess = *pDesiredAccess;
1626 // OK, update the share access on the fileobject
1629 if( VolumeCB->RootFcb->OpenHandleCount > 0)
1632 IoUpdateShareAccess( pFileObject,
1633 &VolumeCB->RootFcb->ShareAccess);
1642 IoSetShareAccess( *pDesiredAccess,
1645 &VolumeCB->RootFcb->ShareAccess);
1649 // Increment the open count on this Fcb
1652 InterlockedIncrement( &VolumeCB->RootFcb->OpenReferenceCount);
1654 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
1655 AFS_TRACE_LEVEL_VERBOSE,
1656 "AFSOpenRoot Increment count on Fcb %08lX Cnt %d\n",
1658 VolumeCB->RootFcb->OpenReferenceCount);
1660 InterlockedIncrement( &VolumeCB->RootFcb->OpenHandleCount);
1662 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
1663 AFS_TRACE_LEVEL_VERBOSE,
1664 "AFSOpenRoot Increment handle count on Fcb %08lX Cnt %d\n",
1666 VolumeCB->RootFcb->OpenHandleCount);
1669 // Indicate the object is held
1672 SetFlag( VolumeCB->ObjectInformation.Flags, AFS_OBJECT_HELD_IN_SERVICE);
1675 // Return the open result for this file
1678 Irp->IoStatus.Information = FILE_OPENED;
1680 *RootFcb = VolumeCB->RootFcb;
1687 AFSReleaseResource( VolumeCB->RootFcb->Header.Resource);
1690 if( !NT_SUCCESS( ntStatus))
1702 Irp->IoStatus.Information = 0;
1710 AFSProcessCreate( IN PIRP Irp,
1712 IN AFSVolumeCB *VolumeCB,
1713 IN AFSDirectoryCB *ParentDirCB,
1714 IN PUNICODE_STRING FileName,
1715 IN PUNICODE_STRING ComponentName,
1716 IN PUNICODE_STRING FullFileName,
1721 NTSTATUS ntStatus = STATUS_SUCCESS;
1722 PFILE_OBJECT pFileObject = NULL;
1723 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1724 ULONG ulOptions = 0;
1725 ULONG ulShareMode = 0;
1727 ULONG ulAttributes = 0;
1728 LARGE_INTEGER liAllocationSize = {0,0};
1729 BOOLEAN bFileCreated = FALSE, bReleaseFcb = FALSE, bAllocatedCcb = FALSE;
1730 BOOLEAN bAllocatedFcb = FALSE;
1731 PACCESS_MASK pDesiredAccess = NULL;
1732 USHORT usShareAccess;
1733 AFSDirectoryCB *pDirEntry = NULL;
1734 AFSObjectInfoCB *pParentObjectInfo = NULL;
1735 AFSObjectInfoCB *pObjectInfo = NULL;
1740 pDesiredAccess = &pIrpSp->Parameters.Create.SecurityContext->DesiredAccess;
1741 usShareAccess = pIrpSp->Parameters.Create.ShareAccess;
1743 pFileObject = pIrpSp->FileObject;
1746 // Extract out the options
1749 ulOptions = pIrpSp->Parameters.Create.Options;
1752 // We pass all attributes they want to apply to the file to the create
1755 ulAttributes = pIrpSp->Parameters.Create.FileAttributes;
1758 // If this is a directory create then set the attribute correctly
1761 if( ulOptions & FILE_DIRECTORY_FILE)
1764 ulAttributes |= FILE_ATTRIBUTE_DIRECTORY;
1767 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1768 AFS_TRACE_LEVEL_VERBOSE,
1769 "AFSProcessCreate (%08lX) Creating file %wZ Attributes %08lX\n",
1774 if( BooleanFlagOn( VolumeCB->VolumeInformation.Characteristics, FILE_READ_ONLY_DEVICE))
1777 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1778 AFS_TRACE_LEVEL_ERROR,
1779 "AFSProcessCreate Request failed due to read only volume %wZ\n",
1782 try_return( ntStatus = STATUS_ACCESS_DENIED);
1785 pParentObjectInfo = ParentDirCB->ObjectInformation;
1788 // Allocate and insert the direntry into the parent node
1791 ntStatus = AFSCreateDirEntry( AuthGroup,
1799 if( !NT_SUCCESS( ntStatus))
1802 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1803 AFS_TRACE_LEVEL_ERROR,
1804 "AFSProcessCreate (%08lX) Failed to create directory entry %wZ Status %08lX\n",
1809 try_return( ntStatus);
1812 bFileCreated = TRUE;
1814 pObjectInfo = pDirEntry->ObjectInformation;
1816 if( BooleanFlagOn( pObjectInfo->Flags, AFS_OBJECT_FLAGS_NOT_EVALUATED) ||
1817 pObjectInfo->FileType == AFS_FILE_TYPE_UNKNOWN)
1820 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1821 AFS_TRACE_LEVEL_VERBOSE,
1822 "AFSProcessCreate (%08lX) Evaluating object %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1824 &pDirEntry->NameInformation.FileName,
1825 pObjectInfo->FileId.Cell,
1826 pObjectInfo->FileId.Volume,
1827 pObjectInfo->FileId.Vnode,
1828 pObjectInfo->FileId.Unique);
1830 ntStatus = AFSEvaluateNode( AuthGroup,
1833 if( !NT_SUCCESS( ntStatus))
1836 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1837 AFS_TRACE_LEVEL_ERROR,
1838 "AFSProcessCreate (%08lX) Failed to evaluate object %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
1840 &pDirEntry->NameInformation.FileName,
1841 pObjectInfo->FileId.Cell,
1842 pObjectInfo->FileId.Volume,
1843 pObjectInfo->FileId.Vnode,
1844 pObjectInfo->FileId.Unique,
1847 try_return( ntStatus);
1850 ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_NOT_EVALUATED);
1854 // We may have raced and the Fcb is already created
1857 if( pObjectInfo->Fcb != NULL)
1860 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1861 AFS_TRACE_LEVEL_VERBOSE,
1862 "AFSProcessCreate (%08lX) Not allocating Fcb for file %wZ\n",
1866 *Fcb = pObjectInfo->Fcb;
1868 AFSAcquireExcl( &(*Fcb)->NPFcb->Resource,
1875 // Allocate and initialize the Fcb for the file.
1878 ntStatus = AFSInitFcb( pDirEntry,
1881 if( !NT_SUCCESS( ntStatus))
1884 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1885 AFS_TRACE_LEVEL_ERROR,
1886 "AFSProcessCreate (%08lX) Failed to initialize fcb %wZ Status %08lX\n",
1891 try_return( ntStatus);
1894 bAllocatedFcb = TRUE;
1900 // Initialize the Ccb for the file.
1903 ntStatus = AFSInitCcb( Ccb);
1905 if( !NT_SUCCESS( ntStatus))
1908 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1909 AFS_TRACE_LEVEL_ERROR,
1910 "AFSProcessCreate (%08lX) Failed to initialize ccb %wZ Status %08lX\n",
1915 try_return( ntStatus);
1918 bAllocatedCcb = TRUE;
1921 // Initialize the Ccb
1924 (*Ccb)->DirectoryCB = pDirEntry;
1926 (*Ccb)->GrantedAccess = *pDesiredAccess;
1929 // If this is a file, update the headers filesizes.
1932 if( (*Fcb)->Header.NodeTypeCode == AFS_FILE_FCB)
1936 // Update the sizes with the information passed in
1939 (*Fcb)->Header.AllocationSize.QuadPart = pObjectInfo->AllocationSize.QuadPart;
1940 (*Fcb)->Header.FileSize.QuadPart = pObjectInfo->EndOfFile.QuadPart;
1941 (*Fcb)->Header.ValidDataLength.QuadPart = pObjectInfo->EndOfFile.QuadPart;
1944 // Notify the system of the addition
1947 AFSFsRtlNotifyFullReportChange( pParentObjectInfo,
1949 (ULONG)FILE_NOTIFY_CHANGE_FILE_NAME,
1950 (ULONG)FILE_ACTION_ADDED);
1952 (*Fcb)->NPFcb->Specific.File.ExtentsRequestStatus = STATUS_SUCCESS;
1954 else if( (*Fcb)->Header.NodeTypeCode == AFS_DIRECTORY_FCB)
1958 // This is a new directory node so indicate it has been enumerated
1961 SetFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED);
1964 // And the parent directory entry
1967 KeQuerySystemTime( &pParentObjectInfo->ChangeTime);
1970 // Notify the system of the addition
1973 AFSFsRtlNotifyFullReportChange( pParentObjectInfo,
1975 (ULONG)FILE_NOTIFY_CHANGE_DIR_NAME,
1976 (ULONG)FILE_ACTION_ADDED);
1978 else if( (*Fcb)->Header.NodeTypeCode == AFS_MOUNT_POINT_FCB ||
1979 (*Fcb)->Header.NodeTypeCode == AFS_SYMBOLIC_LINK_FCB ||
1980 (*Fcb)->Header.NodeTypeCode == AFS_DFS_LINK_FCB ||
1981 (*Fcb)->Header.NodeTypeCode == AFS_INVALID_FCB)
1985 // And the parent directory entry
1988 KeQuerySystemTime( &pParentObjectInfo->ChangeTime);
1991 // Notify the system of the addition
1994 AFSFsRtlNotifyFullReportChange( pParentObjectInfo,
1996 (ULONG)FILE_NOTIFY_CHANGE_DIR_NAME,
1997 (ULONG)FILE_ACTION_ADDED);
2001 // Save off the access for the open
2004 IoSetShareAccess( *pDesiredAccess,
2007 &(*Fcb)->ShareAccess);
2010 // Increment the open count on this Fcb
2013 InterlockedIncrement( &(*Fcb)->OpenReferenceCount);
2015 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2016 AFS_TRACE_LEVEL_VERBOSE,
2017 "AFSProcessCreate Increment count on Fcb %08lX Cnt %d\n",
2019 (*Fcb)->OpenReferenceCount);
2021 InterlockedIncrement( &(*Fcb)->OpenHandleCount);
2023 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2024 AFS_TRACE_LEVEL_VERBOSE,
2025 "AFSProcessCreate Increment handle count on Fcb %08lX Cnt %d\n",
2027 (*Fcb)->OpenHandleCount);
2030 // Increment the open reference and handle on the parent node
2033 InterlockedIncrement( &pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
2035 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2036 AFS_TRACE_LEVEL_VERBOSE,
2037 "AFSProcessCreate Increment child open handle count on Parent object %08lX Cnt %d\n",
2038 pObjectInfo->ParentObjectInformation,
2039 pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
2041 InterlockedIncrement( &pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
2043 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2044 AFS_TRACE_LEVEL_VERBOSE,
2045 "AFSProcessCreate Increment child open ref count on Parent object %08lX Cnt %d\n",
2046 pObjectInfo->ParentObjectInformation,
2047 pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
2049 if( ulOptions & FILE_DELETE_ON_CLOSE)
2053 // Mark it for delete on close
2056 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2057 AFS_TRACE_LEVEL_VERBOSE,
2058 "AFSProcessCreate (%08lX) Setting PENDING_DELETE flag in DirEntry %p Name %wZ\n",
2063 SetFlag( pDirEntry->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2067 // Indicate the object is locked in the service
2070 SetFlag( pObjectInfo->Flags, AFS_OBJECT_HELD_IN_SERVICE);
2073 // Return the open result for this file
2076 Irp->IoStatus.Information = FILE_CREATED;
2081 // If we created the Fcb we need to release the resources
2087 AFSReleaseResource( &(*Fcb)->NPFcb->Resource);
2090 if( !NT_SUCCESS( ntStatus))
2096 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2097 AFS_TRACE_LEVEL_VERBOSE,
2098 "AFSProcessCreate Create failed, removing DE %p from aprent object %p Status %08lX\n",
2104 // Remove the dir entry from the parent
2107 AFSAcquireExcl( pParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
2110 SetFlag( pDirEntry->Flags, AFS_DIR_ENTRY_DELETED);
2113 // Decrement the reference added during initialization of the DE
2116 InterlockedDecrement( &pDirEntry->OpenReferenceCount);
2118 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2119 AFS_TRACE_LEVEL_VERBOSE,
2120 "AFSProcessCreate Decrement count on %wZ DE %p Cnt %d\n",
2121 &pDirEntry->NameInformation.FileName,
2123 pDirEntry->OpenReferenceCount);
2126 // Pull the directory entry from the parent
2129 AFSRemoveDirNodeFromParent( pParentObjectInfo,
2131 FALSE); // Leave it in the enum list so the worker cleans it up
2133 AFSNotifyDelete( pDirEntry,
2138 // Tag the parent as needing verification
2141 SetFlag( pParentObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
2143 AFSReleaseResource( pParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
2156 AFSRemoveFcb( pObjectInfo->Fcb);
2158 pObjectInfo->Fcb = NULL;
2171 AFSOpenTargetDirectory( IN PIRP Irp,
2172 IN AFSVolumeCB *VolumeCB,
2173 IN AFSDirectoryCB *ParentDirectoryCB,
2174 IN AFSDirectoryCB *TargetDirectoryCB,
2175 IN UNICODE_STRING *TargetName,
2180 NTSTATUS ntStatus = STATUS_SUCCESS;
2181 PFILE_OBJECT pFileObject = NULL;
2182 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2183 PACCESS_MASK pDesiredAccess = NULL;
2184 USHORT usShareAccess;
2185 BOOLEAN bAllocatedCcb = FALSE;
2186 BOOLEAN bReleaseFcb = FALSE, bAllocatedFcb = FALSE;
2187 AFSObjectInfoCB *pParentObject = NULL, *pTargetObject = NULL;
2188 UNICODE_STRING uniTargetName;
2193 pDesiredAccess = &pIrpSp->Parameters.Create.SecurityContext->DesiredAccess;
2194 usShareAccess = pIrpSp->Parameters.Create.ShareAccess;
2196 pFileObject = pIrpSp->FileObject;
2198 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2199 AFS_TRACE_LEVEL_VERBOSE,
2200 "AFSOpenTargetDirectory (%08lX) Processing file %wZ\n",
2204 pParentObject = ParentDirectoryCB->ObjectInformation;
2206 if( pParentObject->FileType != AFS_FILE_TYPE_DIRECTORY)
2209 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2213 // Make sure we have an Fcb for the access
2216 if( pParentObject->Fcb != NULL)
2219 *Fcb = pParentObject->Fcb;
2221 AFSAcquireExcl( &(*Fcb)->NPFcb->Resource,
2228 // Allocate and initialize the Fcb for the file.
2231 ntStatus = AFSInitFcb( ParentDirectoryCB,
2234 if( !NT_SUCCESS( ntStatus))
2237 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2238 AFS_TRACE_LEVEL_ERROR,
2239 "AFSProcessCreate (%08lX) Failed to initialize fcb %wZ Status %08lX\n",
2241 &ParentDirectoryCB->NameInformation.FileName,
2244 try_return( ntStatus);
2247 bAllocatedFcb = TRUE;
2253 // If there are current opens on the Fcb, check the access.
2256 if( pParentObject->Fcb->OpenHandleCount > 0)
2259 ntStatus = IoCheckShareAccess( *pDesiredAccess,
2262 &pParentObject->Fcb->ShareAccess,
2265 if( !NT_SUCCESS( ntStatus))
2268 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2269 AFS_TRACE_LEVEL_ERROR,
2270 "AFSOpenTargetDirectory (%08lX) Access check failure %wZ Status %08lX\n",
2272 &ParentDirectoryCB->NameInformation.FileName,
2275 try_return( ntStatus);
2280 // Initialize the Ccb for the file.
2283 ntStatus = AFSInitCcb( Ccb);
2285 if( !NT_SUCCESS( ntStatus))
2288 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2289 AFS_TRACE_LEVEL_ERROR,
2290 "AFSOpenTargetDirectory (%08lX) Failed to initialize ccb %wZ Status %08lX\n",
2292 &ParentDirectoryCB->NameInformation.FileName,
2295 try_return( ntStatus);
2298 bAllocatedCcb = TRUE;
2301 // Initialize the Ccb
2304 (*Ccb)->DirectoryCB = ParentDirectoryCB;
2306 (*Ccb)->GrantedAccess = *pDesiredAccess;
2308 if( TargetDirectoryCB != NULL &&
2309 FsRtlAreNamesEqual( &TargetDirectoryCB->NameInformation.FileName,
2315 Irp->IoStatus.Information = FILE_EXISTS;
2317 uniTargetName = TargetDirectoryCB->NameInformation.FileName;
2322 Irp->IoStatus.Information = FILE_DOES_NOT_EXIST;
2324 uniTargetName = *TargetName;
2328 // Update the filename in the fileobject for rename processing
2331 RtlCopyMemory( pFileObject->FileName.Buffer,
2332 uniTargetName.Buffer,
2333 uniTargetName.Length);
2335 pFileObject->FileName.Length = uniTargetName.Length;
2338 // OK, update the share access on the fileobject
2341 if( pParentObject->Fcb->OpenHandleCount > 0)
2344 IoUpdateShareAccess( pFileObject,
2345 &pParentObject->Fcb->ShareAccess);
2354 IoSetShareAccess( *pDesiredAccess,
2357 &pParentObject->Fcb->ShareAccess);
2361 // Increment the open count on this Fcb
2364 InterlockedIncrement( &pParentObject->Fcb->OpenReferenceCount);
2366 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2367 AFS_TRACE_LEVEL_VERBOSE,
2368 "AFSOpenTargetDirectory Increment count on Fcb %08lX Cnt %d\n",
2370 pParentObject->Fcb->OpenReferenceCount);
2372 InterlockedIncrement( &pParentObject->Fcb->OpenHandleCount);
2374 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2375 AFS_TRACE_LEVEL_VERBOSE,
2376 "AFSOpenTargetDirectory Increment handle count on Fcb %08lX Cnt %d\n",
2378 pParentObject->Fcb->OpenHandleCount);
2381 // Increment the open reference and handle on the parent node
2384 if( pParentObject->ParentObjectInformation != NULL)
2387 InterlockedIncrement( &pParentObject->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
2389 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2390 AFS_TRACE_LEVEL_VERBOSE,
2391 "AFSOpenTargetDirectory Increment child open handle count on Parent object %08lX Cnt %d\n",
2392 pParentObject->ParentObjectInformation,
2393 pParentObject->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
2395 InterlockedIncrement( &pParentObject->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
2397 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2398 AFS_TRACE_LEVEL_VERBOSE,
2399 "AFSOpenTargetDirectory Increment child open ref count on Parent object %08lX Cnt %d\n",
2400 pParentObject->ParentObjectInformation,
2401 pParentObject->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
2409 AFSReleaseResource( &pParentObject->Fcb->NPFcb->Resource);
2412 if( !NT_SUCCESS( ntStatus))
2427 AFSRemoveFcb( pParentObject->Fcb);
2429 pParentObject->Fcb = NULL;
2440 AFSProcessOpen( IN PIRP Irp,
2442 IN AFSVolumeCB *VolumeCB,
2443 IN AFSDirectoryCB *ParentDirCB,
2444 IN AFSDirectoryCB *DirectoryCB,
2449 NTSTATUS ntStatus = STATUS_SUCCESS;
2450 PFILE_OBJECT pFileObject = NULL;
2451 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2452 PACCESS_MASK pDesiredAccess = NULL;
2453 USHORT usShareAccess;
2454 BOOLEAN bAllocatedCcb = FALSE, bReleaseFcb = FALSE, bAllocatedFcb = FALSE;
2455 ULONG ulAdditionalFlags = 0, ulOptions = 0;
2456 AFSFileOpenCB stOpenCB;
2457 AFSFileOpenResultCB stOpenResultCB;
2458 ULONG ulResultLen = 0;
2459 AFSObjectInfoCB *pParentObjectInfo = NULL;
2460 AFSObjectInfoCB *pObjectInfo = NULL;
2461 ULONG ulFileAccess = 0;
2462 AFSFileAccessReleaseCB stReleaseFileAccess;
2467 pDesiredAccess = &pIrpSp->Parameters.Create.SecurityContext->DesiredAccess;
2468 usShareAccess = pIrpSp->Parameters.Create.ShareAccess;
2470 pFileObject = pIrpSp->FileObject;
2472 pParentObjectInfo = ParentDirCB->ObjectInformation;
2474 pObjectInfo = DirectoryCB->ObjectInformation;
2477 // Check if the entry is pending a deletion
2480 if( BooleanFlagOn( DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE))
2483 ntStatus = STATUS_DELETE_PENDING;
2485 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2486 AFS_TRACE_LEVEL_ERROR,
2487 "AFSProcessOpen (%08lX) Entry pending delete %wZ Status %08lX\n",
2489 &DirectoryCB->NameInformation.FileName,
2492 try_return( ntStatus);
2496 // Extract out the options
2499 ulOptions = pIrpSp->Parameters.Create.Options;
2502 // Check if we should go and retrieve updated information for the node
2505 ntStatus = AFSValidateEntry( DirectoryCB,
2510 if( !NT_SUCCESS( ntStatus))
2513 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2514 AFS_TRACE_LEVEL_ERROR,
2515 "AFSProcessOpen (%08lX) Failed to validate entry %wZ Status %08lX\n",
2517 &DirectoryCB->NameInformation.FileName,
2520 try_return( ntStatus);
2524 // If this is marked for delete on close then be sure we can delete the entry
2527 if( BooleanFlagOn( ulOptions, FILE_DELETE_ON_CLOSE))
2530 ntStatus = AFSNotifyDelete( DirectoryCB,
2534 if( !NT_SUCCESS( ntStatus))
2537 ntStatus = STATUS_CANNOT_DELETE;
2539 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2540 AFS_TRACE_LEVEL_ERROR,
2541 "AFSProcessOpen (%08lX) Cannot delete entry %wZ marked for delete on close Status %08lX\n",
2543 &DirectoryCB->NameInformation.FileName,
2546 try_return( ntStatus);
2551 // Be sure we have an Fcb for the current object
2554 if( pObjectInfo->Fcb == NULL)
2557 ntStatus = AFSInitFcb( DirectoryCB,
2560 if( !NT_SUCCESS( ntStatus))
2563 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2564 AFS_TRACE_LEVEL_ERROR,
2565 "AFSProcessOpen (%08lX) Failed to init fcb on %wZ Status %08lX\n",
2567 &DirectoryCB->NameInformation.FileName,
2570 try_return( ntStatus);
2573 bAllocatedFcb = TRUE;
2578 AFSAcquireExcl( pObjectInfo->Fcb->Header.Resource,
2585 // Reference the Fcb so it won't go away while we call into the service for processing
2588 InterlockedIncrement( &pObjectInfo->Fcb->OpenReferenceCount);
2590 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2591 AFS_TRACE_LEVEL_VERBOSE,
2592 "AFSProcessOpen Increment count on Fcb %08lX Cnt %d\n",
2594 pObjectInfo->Fcb->OpenReferenceCount);
2597 // Check access on the entry
2600 if( pObjectInfo->Fcb->OpenHandleCount > 0)
2603 ntStatus = IoCheckShareAccess( *pDesiredAccess,
2606 &pObjectInfo->Fcb->ShareAccess,
2609 if( !NT_SUCCESS( ntStatus))
2612 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2613 AFS_TRACE_LEVEL_ERROR,
2614 "AFSProcessOpen (%08lX) Failed to check share access on %wZ Status %08lX\n",
2616 &DirectoryCB->NameInformation.FileName,
2619 try_return( ntStatus);
2624 // Additional checks
2627 if( pObjectInfo->Fcb->Header.NodeTypeCode == AFS_FILE_FCB)
2631 // If the caller is asking for write access then try to flush the image section
2634 if( FlagOn( *pDesiredAccess, FILE_WRITE_DATA) ||
2635 BooleanFlagOn(ulOptions, FILE_DELETE_ON_CLOSE))
2638 if( !MmFlushImageSection( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers,
2642 ntStatus = BooleanFlagOn(ulOptions, FILE_DELETE_ON_CLOSE) ? STATUS_CANNOT_DELETE :
2643 STATUS_SHARING_VIOLATION;
2645 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2646 AFS_TRACE_LEVEL_ERROR,
2647 "AFSProcessOpen (%08lX) Failed to flush image section %wZ Status %08lX\n",
2649 &DirectoryCB->NameInformation.FileName,
2652 try_return( ntStatus);
2656 if( BooleanFlagOn( ulOptions, FILE_DIRECTORY_FILE))
2659 ntStatus = STATUS_NOT_A_DIRECTORY;
2661 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2662 AFS_TRACE_LEVEL_ERROR,
2663 "AFSProcessOpen (%08lX) Attempt to open file as directory %wZ Status %08lX\n",
2665 &DirectoryCB->NameInformation.FileName,
2668 try_return( ntStatus);
2671 pObjectInfo->Fcb->NPFcb->Specific.File.ExtentsRequestStatus = STATUS_SUCCESS;
2673 else if( pObjectInfo->Fcb->Header.NodeTypeCode == AFS_DIRECTORY_FCB ||
2674 pObjectInfo->Fcb->Header.NodeTypeCode == AFS_ROOT_FCB)
2677 if( BooleanFlagOn( ulOptions, FILE_NON_DIRECTORY_FILE))
2680 ntStatus = STATUS_FILE_IS_A_DIRECTORY;
2682 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2683 AFS_TRACE_LEVEL_ERROR,
2684 "AFSProcessOpen (%08lX) Attempt to open directory as file %wZ Status %08lX\n",
2686 &DirectoryCB->NameInformation.FileName,
2689 try_return( ntStatus);
2692 else if( pObjectInfo->Fcb->Header.NodeTypeCode == AFS_MOUNT_POINT_FCB ||
2693 pObjectInfo->Fcb->Header.NodeTypeCode == AFS_SYMBOLIC_LINK_FCB ||
2694 pObjectInfo->Fcb->Header.NodeTypeCode == AFS_DFS_LINK_FCB ||
2695 pObjectInfo->Fcb->Header.NodeTypeCode == AFS_INVALID_FCB)
2702 try_return( ntStatus = STATUS_UNSUCCESSFUL);
2706 // Check with the service that we can open the file
2709 stOpenCB.ParentId = pParentObjectInfo->FileId;
2711 stOpenCB.DesiredAccess = *pDesiredAccess;
2713 stOpenCB.ShareAccess = usShareAccess;
2715 stOpenCB.ProcessId = (ULONGLONG)PsGetCurrentProcessId();
2717 stOpenCB.Identifier = (ULONGLONG)pFileObject;
2719 stOpenResultCB.GrantedAccess = 0;
2721 ulResultLen = sizeof( AFSFileOpenResultCB);
2723 ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_OPEN_FILE,
2724 AFS_REQUEST_FLAG_SYNCHRONOUS | AFS_REQUEST_FLAG_HOLD_FID,
2726 &DirectoryCB->NameInformation.FileName,
2727 &pObjectInfo->FileId,
2729 sizeof( AFSFileOpenCB),
2730 (void *)&stOpenResultCB,
2733 if( !NT_SUCCESS( ntStatus))
2736 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2737 AFS_TRACE_LEVEL_ERROR,
2738 "AFSProcessOpen (%08lX) Failed open in service %wZ Status %08lX\n",
2740 &DirectoryCB->NameInformation.FileName,
2743 try_return( ntStatus);
2747 // Save the granted access in case we need to release it below
2750 ulFileAccess = stOpenResultCB.FileAccess;
2753 // Check if there is a conflict
2756 if( !AFSCheckAccess( *pDesiredAccess,
2757 stOpenResultCB.GrantedAccess,
2758 BooleanFlagOn( DirectoryCB->ObjectInformation->FileAttributes, FILE_ATTRIBUTE_DIRECTORY)))
2761 ntStatus = STATUS_ACCESS_DENIED;
2763 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2764 AFS_TRACE_LEVEL_ERROR,
2765 "AFSProcessOpen (%08lX) Failed to check access from service Desired %08lX Granted %08lX Entry %wZ Status %08lX\n",
2768 stOpenResultCB.GrantedAccess,
2769 &DirectoryCB->NameInformation.FileName,
2772 try_return( ntStatus);
2776 // Initialize the Ccb for the file.
2779 ntStatus = AFSInitCcb( Ccb);
2781 if( !NT_SUCCESS( ntStatus))
2784 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2785 AFS_TRACE_LEVEL_ERROR,
2786 "AFSProcessOpen (%08lX) Failed to initialize ccb %wZ Status %08lX\n",
2788 &DirectoryCB->NameInformation.FileName,
2791 try_return( ntStatus);
2794 bAllocatedCcb = TRUE;
2796 (*Ccb)->DirectoryCB = DirectoryCB;
2798 (*Ccb)->FileAccess = ulFileAccess;
2800 (*Ccb)->GrantedAccess = *pDesiredAccess;
2803 // Perform the access check on the target if this is a mount point or symlink
2806 if( pObjectInfo->Fcb->OpenHandleCount > 0)
2809 IoUpdateShareAccess( pFileObject,
2810 &pObjectInfo->Fcb->ShareAccess);
2819 IoSetShareAccess( *pDesiredAccess,
2822 &pObjectInfo->Fcb->ShareAccess);
2826 // Increment the open count on this Fcb
2829 InterlockedIncrement( &pObjectInfo->Fcb->OpenReferenceCount);
2831 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2832 AFS_TRACE_LEVEL_VERBOSE,
2833 "AFSProcessOpen Increment2 count on Fcb %08lX Cnt %d\n",
2835 pObjectInfo->Fcb->OpenReferenceCount);
2837 InterlockedIncrement( &pObjectInfo->Fcb->OpenHandleCount);
2839 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2840 AFS_TRACE_LEVEL_VERBOSE,
2841 "AFSProcessOpen Increment handle count on Fcb %08lX Cnt %d\n",
2843 pObjectInfo->Fcb->OpenHandleCount);
2846 // Increment the open reference and handle on the parent node
2849 InterlockedIncrement( &pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
2851 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2852 AFS_TRACE_LEVEL_VERBOSE,
2853 "AFSProcessOpen Increment child open handle count on Parent object %08lX Cnt %d\n",
2854 pObjectInfo->ParentObjectInformation,
2855 pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
2857 InterlockedIncrement( &pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
2859 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2860 AFS_TRACE_LEVEL_VERBOSE,
2861 "AFSProcessOpen Increment child open ref count on Parent object %08lX Cnt %d\n",
2862 pObjectInfo->ParentObjectInformation,
2863 pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
2865 if( BooleanFlagOn( ulOptions, FILE_DELETE_ON_CLOSE))
2869 // Mark it for delete on close
2872 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2873 AFS_TRACE_LEVEL_VERBOSE,
2874 "AFSProcessOpen (%08lX) Setting PENDING_DELETE flag in DirEntry %p Name %wZ\n",
2877 &DirectoryCB->NameInformation.FileName);
2879 SetFlag( DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2883 // Indicate the object is held
2886 SetFlag( pObjectInfo->Flags, AFS_OBJECT_HELD_IN_SERVICE);
2889 // Return the open result for this file
2892 Irp->IoStatus.Information = FILE_OPENED;
2894 *Fcb = pObjectInfo->Fcb;
2902 // Remove the reference we added initially
2905 InterlockedDecrement( &pObjectInfo->Fcb->OpenReferenceCount);
2907 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2908 AFS_TRACE_LEVEL_VERBOSE,
2909 "AFSProcessOpen Decrement count on Fcb %08lX Cnt %d\n",
2911 pObjectInfo->Fcb->OpenReferenceCount);
2913 AFSReleaseResource( pObjectInfo->Fcb->Header.Resource);
2916 if( !NT_SUCCESS( ntStatus))
2919 if ( ulFileAccess > 0)
2922 stReleaseFileAccess.ProcessId = (ULONGLONG)PsGetCurrentProcessId();
2924 stReleaseFileAccess.FileAccess = ulFileAccess;
2926 stReleaseFileAccess.Identifier = (ULONGLONG)pFileObject;
2928 AFSProcessRequest( AFS_REQUEST_TYPE_RELEASE_FILE_ACCESS,
2929 AFS_REQUEST_FLAG_SYNCHRONOUS,
2931 &DirectoryCB->NameInformation.FileName,
2932 &pObjectInfo->FileId,
2933 (void *)&stReleaseFileAccess,
2934 sizeof( AFSFileAccessReleaseCB),
2951 AFSRemoveFcb( pObjectInfo->Fcb);
2953 pObjectInfo->Fcb = NULL;
2964 AFSProcessOverwriteSupersede( IN PDEVICE_OBJECT DeviceObject,
2966 IN AFSVolumeCB *VolumeCB,
2968 IN AFSDirectoryCB *ParentDirCB,
2969 IN AFSDirectoryCB *DirectoryCB,
2974 NTSTATUS ntStatus = STATUS_SUCCESS;
2975 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2976 PFILE_OBJECT pFileObject = NULL;
2977 LARGE_INTEGER liZero = {0,0};
2978 BOOLEAN bReleasePaging = FALSE, bReleaseFcb = FALSE;
2979 ULONG ulAttributes = 0;
2980 LARGE_INTEGER liTime;
2981 ULONG ulCreateDisposition = 0;
2982 BOOLEAN bAllocatedCcb = FALSE, bAllocatedFcb = FALSE;
2983 PACCESS_MASK pDesiredAccess = NULL;
2984 USHORT usShareAccess;
2985 AFSObjectInfoCB *pParentObjectInfo = NULL;
2986 AFSObjectInfoCB *pObjectInfo = NULL;
2991 pDesiredAccess = &pIrpSp->Parameters.Create.SecurityContext->DesiredAccess;
2992 usShareAccess = pIrpSp->Parameters.Create.ShareAccess;
2994 pFileObject = pIrpSp->FileObject;
2996 ulAttributes = pIrpSp->Parameters.Create.FileAttributes;
2998 ulCreateDisposition = (pIrpSp->Parameters.Create.Options >> 24) & 0x000000ff;
3000 if( BooleanFlagOn( VolumeCB->VolumeInformation.Characteristics, FILE_READ_ONLY_DEVICE))
3003 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3004 AFS_TRACE_LEVEL_ERROR,
3005 "AFSProcessOverwriteSupersede Request failed on %wZ due to read only volume\n",
3007 &DirectoryCB->NameInformation.FileName);
3009 try_return( ntStatus = STATUS_ACCESS_DENIED);
3012 pParentObjectInfo = ParentDirCB->ObjectInformation;
3014 pObjectInfo = DirectoryCB->ObjectInformation;
3017 // Check if we should go and retrieve updated information for the node
3020 ntStatus = AFSValidateEntry( DirectoryCB,
3025 if( !NT_SUCCESS( ntStatus))
3028 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3029 AFS_TRACE_LEVEL_ERROR,
3030 "AFSProcessOverwriteSupersede (%08lX) Failed to validate entry %wZ Status %08lX\n",
3032 &DirectoryCB->NameInformation.FileName,
3035 try_return( ntStatus);
3039 // Be sure we have an Fcb for the object block
3042 if( pObjectInfo->Fcb == NULL)
3045 ntStatus = AFSInitFcb( DirectoryCB,
3048 if( !NT_SUCCESS( ntStatus))
3051 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3052 AFS_TRACE_LEVEL_ERROR,
3053 "AFSProcessOverwriteSupersede (%08lX) Failed to initialize fcb %wZ Status %08lX\n",
3055 &DirectoryCB->NameInformation.FileName,
3058 try_return( ntStatus);
3061 bAllocatedFcb = TRUE;
3066 AFSAcquireExcl( pObjectInfo->Fcb->Header.Resource,
3073 // Reference the Fcb so it won't go away while processing the request
3076 InterlockedIncrement( &pObjectInfo->Fcb->OpenReferenceCount);
3078 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3079 AFS_TRACE_LEVEL_VERBOSE,
3080 "AFSProcessOverwriteSupersede Increment count on Fcb %08lX Cnt %d\n",
3082 pObjectInfo->Fcb->OpenReferenceCount);
3085 // Check access on the entry
3088 if( pObjectInfo->Fcb->OpenHandleCount > 0)
3091 ntStatus = IoCheckShareAccess( *pDesiredAccess,
3094 &pObjectInfo->Fcb->ShareAccess,
3097 if( !NT_SUCCESS( ntStatus))
3100 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3101 AFS_TRACE_LEVEL_ERROR,
3102 "AFSProcessOverwriteSupersede (%08lX) Access check failure %wZ Status %08lX\n",
3104 &DirectoryCB->NameInformation.FileName,
3107 try_return( ntStatus);
3112 // Before we actually truncate, check to see if the purge
3113 // is going to fail.
3116 if( !MmCanFileBeTruncated( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers,
3120 ntStatus = STATUS_USER_MAPPED_FILE;
3122 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3123 AFS_TRACE_LEVEL_ERROR,
3124 "AFSProcessOverwriteSupersede (%08lX) File user mapped %wZ Status %08lX\n",
3126 &DirectoryCB->NameInformation.FileName,
3129 try_return( ntStatus);
3133 // Initialize the Ccb for the file.
3136 ntStatus = AFSInitCcb( Ccb);
3138 if( !NT_SUCCESS( ntStatus))
3141 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3142 AFS_TRACE_LEVEL_ERROR,
3143 "AFSProcessOverwriteSupersede (%08lX) Failed to initialize ccb %wZ Status %08lX\n",
3145 &DirectoryCB->NameInformation.FileName,
3148 try_return( ntStatus);
3151 bAllocatedCcb = TRUE;
3154 // Initialize the Ccb
3157 (*Ccb)->DirectoryCB = DirectoryCB;
3159 (*Ccb)->GrantedAccess = *pDesiredAccess;
3162 // Need to purge any data currently in the cache
3165 CcPurgeCacheSection( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers,
3170 pObjectInfo->Fcb->Header.FileSize.QuadPart = 0;
3171 pObjectInfo->Fcb->Header.ValidDataLength.QuadPart = 0;
3172 pObjectInfo->Fcb->Header.AllocationSize.QuadPart = 0;
3174 pObjectInfo->EndOfFile.QuadPart = 0;
3175 pObjectInfo->AllocationSize.QuadPart = 0;
3178 // Trim down the extents. We do this BEFORE telling the service
3179 // the file is truncated since there is a potential race between
3180 // a worker thread releasing extents and us trimming
3183 AFSTrimExtents( pObjectInfo->Fcb,
3184 &pObjectInfo->Fcb->Header.FileSize);
3186 KeQuerySystemTime( &pObjectInfo->ChangeTime);
3188 KeQuerySystemTime( &pObjectInfo->LastAccessTime);
3190 //KeQuerySystemTime( &pObjectInfo->CreationTime);
3192 KeQuerySystemTime( &pObjectInfo->LastWriteTime);
3194 ntStatus = AFSUpdateFileInformation( &pParentObjectInfo->FileId,
3198 if( !NT_SUCCESS( ntStatus))
3201 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3202 AFS_TRACE_LEVEL_ERROR,
3203 "AFSProcessOverwriteSupersede (%08lX) Failed to update file information %wZ Status %08lX\n",
3205 &DirectoryCB->NameInformation.FileName,
3208 try_return( ntStatus);
3211 AFSAcquireExcl( pObjectInfo->Fcb->Header.PagingIoResource,
3214 bReleasePaging = TRUE;
3216 pFileObject->SectionObjectPointer = &pObjectInfo->Fcb->NPFcb->SectionObjectPointers;
3218 pFileObject->FsContext = (void *)pObjectInfo->Fcb;
3220 pFileObject->FsContext2 = (void *)*Ccb;
3223 // Set the update flag accordingly
3226 SetFlag( pObjectInfo->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED |
3227 AFS_FCB_FLAG_UPDATE_CREATE_TIME |
3228 AFS_FCB_FLAG_UPDATE_CHANGE_TIME |
3229 AFS_FCB_FLAG_UPDATE_ACCESS_TIME |
3230 AFS_FCB_FLAG_UPDATE_LAST_WRITE_TIME);
3232 CcSetFileSizes( pFileObject,
3233 (PCC_FILE_SIZES)&pObjectInfo->Fcb->Header.AllocationSize);
3235 AFSReleaseResource( pObjectInfo->Fcb->Header.PagingIoResource);
3237 bReleasePaging = FALSE;
3239 ulAttributes |= FILE_ATTRIBUTE_ARCHIVE;
3241 if( ulCreateDisposition == FILE_SUPERSEDE)
3244 pObjectInfo->FileAttributes = ulAttributes;
3250 pObjectInfo->FileAttributes |= ulAttributes;
3254 // Save off the access for the open
3257 if( pObjectInfo->Fcb->OpenHandleCount > 0)
3260 IoUpdateShareAccess( pFileObject,
3261 &pObjectInfo->Fcb->ShareAccess);
3270 IoSetShareAccess( *pDesiredAccess,
3273 &pObjectInfo->Fcb->ShareAccess);
3277 // Return the correct action
3280 if( ulCreateDisposition == FILE_SUPERSEDE)
3283 Irp->IoStatus.Information = FILE_SUPERSEDED;
3288 Irp->IoStatus.Information = FILE_OVERWRITTEN;
3292 // Increment the open count on this Fcb.
3295 InterlockedIncrement( &pObjectInfo->Fcb->OpenReferenceCount);
3297 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3298 AFS_TRACE_LEVEL_VERBOSE,
3299 "AFSProcessOverwriteSupersede Increment2 count on Fcb %08lX Cnt %d\n",
3301 pObjectInfo->Fcb->OpenReferenceCount);
3303 InterlockedIncrement( &pObjectInfo->Fcb->OpenHandleCount);
3305 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3306 AFS_TRACE_LEVEL_VERBOSE,
3307 "AFSProcessOverwriteSupersede Increment handle count on Fcb %08lX Cnt %d\n",
3309 pObjectInfo->Fcb->OpenHandleCount);
3312 // Increment the open reference and handle on the parent node
3315 InterlockedIncrement( &pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
3317 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3318 AFS_TRACE_LEVEL_VERBOSE,
3319 "AFSProcessOverwriteSupersede Increment child open handle count on Parent object %08lX Cnt %d\n",
3320 pObjectInfo->ParentObjectInformation,
3321 pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
3323 InterlockedIncrement( &pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
3325 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3326 AFS_TRACE_LEVEL_VERBOSE,
3327 "AFSProcessOverwriteSupersede Increment child open ref count on Parent object %08lX Cnt %d\n",
3328 pObjectInfo->ParentObjectInformation,
3329 pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
3331 *Fcb = pObjectInfo->Fcb;
3338 AFSReleaseResource( pObjectInfo->Fcb->Header.PagingIoResource);
3345 // Remove the reference we added above to prevent tear down
3348 InterlockedDecrement( &pObjectInfo->Fcb->OpenReferenceCount);
3350 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3351 AFS_TRACE_LEVEL_VERBOSE,
3352 "AFSProcessOverwriteSupersede Decrement count on Fcb %08lX Cnt %d\n",
3354 pObjectInfo->Fcb->OpenReferenceCount);
3356 AFSReleaseResource( pObjectInfo->Fcb->Header.Resource);
3359 if( !NT_SUCCESS( ntStatus))
3374 AFSRemoveFcb( pObjectInfo->Fcb);
3376 pObjectInfo->Fcb = NULL;
3387 AFSControlDeviceCreate( IN PIRP Irp)
3390 NTSTATUS ntStatus = STATUS_SUCCESS;
3396 // For now, jsut let the open happen
3399 Irp->IoStatus.Information = FILE_OPENED;
3406 AFSOpenIOCtlFcb( IN PIRP Irp,
3408 IN AFSDirectoryCB *ParentDirCB,
3413 NTSTATUS ntStatus = STATUS_SUCCESS;
3414 PFILE_OBJECT pFileObject = NULL;
3415 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3416 BOOLEAN bReleaseFcb = FALSE, bAllocatedCcb = FALSE, bAllocatedFcb = FALSE;
3417 UNICODE_STRING uniFullFileName;
3418 AFSPIOCtlOpenCloseRequestCB stPIOCtlOpen;
3420 AFSObjectInfoCB *pParentObjectInfo = NULL;
3425 pFileObject = pIrpSp->FileObject;
3427 pParentObjectInfo = ParentDirCB->ObjectInformation;
3430 // If we haven't initialized the PIOCtl DirectoryCB for this directory then do it now
3433 if( pParentObjectInfo->Specific.Directory.PIOCtlDirectoryCB == NULL)
3436 ntStatus = AFSInitPIOCtlDirectoryCB( pParentObjectInfo);
3438 if( !NT_SUCCESS( ntStatus))
3441 try_return( ntStatus);
3445 if( pParentObjectInfo->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb == NULL)
3449 // Allocate and initialize the Fcb for the file.
3452 ntStatus = AFSInitFcb( pParentObjectInfo->Specific.Directory.PIOCtlDirectoryCB,
3455 if( !NT_SUCCESS( ntStatus))
3458 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3459 AFS_TRACE_LEVEL_ERROR,
3460 "AFSOpenIOCtlFcb (%08lX) Failed to initialize fcb Status %08lX\n",
3464 try_return( ntStatus);
3467 bAllocatedFcb = TRUE;
3472 *Fcb = pParentObjectInfo->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb;
3474 AFSAcquireExcl( &(*Fcb)->NPFcb->Resource,
3481 // Initialize the Ccb for the file.
3484 ntStatus = AFSInitCcb( Ccb);
3486 if( !NT_SUCCESS( ntStatus))
3489 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3490 AFS_TRACE_LEVEL_ERROR,
3491 "AFSOpenIOCtlFcb (%08lX) Failed to initialize ccb Status %08lX\n",
3495 try_return( ntStatus);
3498 bAllocatedCcb = TRUE;
3504 (*Ccb)->DirectoryCB = pParentObjectInfo->Specific.Directory.PIOCtlDirectoryCB;
3507 // Set the PIOCtl index
3510 (*Ccb)->RequestID = InterlockedIncrement( &pParentObjectInfo->Specific.Directory.OpenRequestIndex);
3512 RtlZeroMemory( &stPIOCtlOpen,
3513 sizeof( AFSPIOCtlOpenCloseRequestCB));
3515 stPIOCtlOpen.RequestId = (*Ccb)->RequestID;
3517 stPIOCtlOpen.RootId = pParentObjectInfo->VolumeCB->ObjectInformation.FileId;
3519 RtlZeroMemory( &stFileID,
3520 sizeof( AFSFileID));
3523 // The parent directory FID of the node
3526 stFileID = pParentObjectInfo->FileId;
3529 // Issue the open request to the service
3532 ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_PIOCTL_OPEN,
3533 AFS_REQUEST_FLAG_SYNCHRONOUS,
3537 (void *)&stPIOCtlOpen,
3538 sizeof( AFSPIOCtlOpenCloseRequestCB),
3542 if( !NT_SUCCESS( ntStatus))
3545 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3546 AFS_TRACE_LEVEL_ERROR,
3547 "AFSOpenIOCtlFcb (%08lX) Failed service open Status %08lX\n",
3551 try_return( ntStatus);
3555 // Reference the directory entry
3558 InterlockedIncrement( &((*Ccb)->DirectoryCB->OpenReferenceCount));
3560 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3561 AFS_TRACE_LEVEL_VERBOSE,
3562 "AFSOpenIOCtlFcb Increment count on %wZ DE %p Ccb %p Cnt %d\n",
3563 &(*Ccb)->DirectoryCB->NameInformation.FileName,
3564 (*Ccb)->DirectoryCB,
3566 (*Ccb)->DirectoryCB->OpenReferenceCount);
3569 // Increment the open reference and handle on the node
3572 InterlockedIncrement( &(*Fcb)->OpenReferenceCount);
3574 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3575 AFS_TRACE_LEVEL_VERBOSE,
3576 "AFSOpenIOCtlFcb Increment count on Fcb %08lX Cnt %d\n",
3578 (*Fcb)->OpenReferenceCount);
3580 InterlockedIncrement( &(*Fcb)->OpenHandleCount);
3582 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3583 AFS_TRACE_LEVEL_VERBOSE,
3584 "AFSOpenIOCtlFcb Increment handle count on Fcb %08lX Cnt %d\n",
3586 (*Fcb)->OpenHandleCount);
3589 // Increment the open reference and handle on the parent node
3592 InterlockedIncrement( &pParentObjectInfo->Specific.Directory.ChildOpenHandleCount);
3594 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3595 AFS_TRACE_LEVEL_VERBOSE,
3596 "AFSOpenIOCtlFcb Increment child open handle count on Parent object %08lX Cnt %d\n",
3598 pParentObjectInfo->Specific.Directory.ChildOpenHandleCount);
3600 InterlockedIncrement( &pParentObjectInfo->Specific.Directory.ChildOpenReferenceCount);
3602 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3603 AFS_TRACE_LEVEL_VERBOSE,
3604 "AFSOpenIOCtlFcb Increment child open ref count on Parent object %08lX Cnt %d\n",
3606 pParentObjectInfo->Specific.Directory.ChildOpenReferenceCount);
3609 // Return the open result for this file
3612 Irp->IoStatus.Information = FILE_OPENED;
3617 //Dereference the passed in parent since the returned dir entry
3618 // is already referenced
3621 InterlockedDecrement( &ParentDirCB->OpenReferenceCount);
3623 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3624 AFS_TRACE_LEVEL_VERBOSE,
3625 "AFSOpenIOCtlFcb Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
3626 &ParentDirCB->NameInformation.FileName,
3629 ParentDirCB->OpenReferenceCount);
3632 // If we created the Fcb we need to release the resources
3638 AFSReleaseResource( &(*Fcb)->NPFcb->Resource);
3641 if( !NT_SUCCESS( ntStatus))
3657 // Need to tear down this Fcb since it is not in the tree for the worker thread
3660 AFSRemoveFcb( *Fcb);
3662 pParentObjectInfo->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb = NULL;
3675 AFSOpenSpecialShareFcb( IN PIRP Irp,
3677 IN AFSDirectoryCB *DirectoryCB,
3682 NTSTATUS ntStatus = STATUS_SUCCESS;
3683 PFILE_OBJECT pFileObject = NULL;
3684 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3685 BOOLEAN bReleaseFcb = FALSE, bAllocatedCcb = FALSE, bAllocateFcb = FALSE;
3686 AFSObjectInfoCB *pParentObjectInfo = NULL;
3687 AFSPipeOpenCloseRequestCB stPipeOpen;
3692 pFileObject = pIrpSp->FileObject;
3694 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3695 AFS_TRACE_LEVEL_VERBOSE_2,
3696 "AFSOpenSpecialShareFcb (%08lX) Processing Share %wZ open\n",
3698 &DirectoryCB->NameInformation.FileName);
3700 pParentObjectInfo = DirectoryCB->ObjectInformation->ParentObjectInformation;
3702 if( DirectoryCB->ObjectInformation->Fcb == NULL)
3706 // Allocate and initialize the Fcb for the file.
3709 ntStatus = AFSInitFcb( DirectoryCB,
3712 if( !NT_SUCCESS( ntStatus))
3715 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3716 AFS_TRACE_LEVEL_ERROR,
3717 "AFSOpenSpecialShareFcb (%08lX) Failed to initialize fcb Status %08lX\n",
3721 try_return( ntStatus);
3724 bAllocateFcb = TRUE;
3729 *Fcb = DirectoryCB->ObjectInformation->Fcb;
3731 AFSAcquireExcl( &(*Fcb)->NPFcb->Resource,
3738 // Initialize the Ccb for the file.
3741 ntStatus = AFSInitCcb( Ccb);
3743 if( !NT_SUCCESS( ntStatus))
3746 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3747 AFS_TRACE_LEVEL_ERROR,
3748 "AFSOpenSpecialShareFcb (%08lX) Failed to initialize ccb Status %08lX\n",
3752 try_return( ntStatus);
3755 bAllocatedCcb = TRUE;
3761 (*Ccb)->DirectoryCB = DirectoryCB;
3764 // Call the service to open the share
3767 (*Ccb)->RequestID = InterlockedIncrement( &pParentObjectInfo->Specific.Directory.OpenRequestIndex);
3769 RtlZeroMemory( &stPipeOpen,
3770 sizeof( AFSPipeOpenCloseRequestCB));
3772 stPipeOpen.RequestId = (*Ccb)->RequestID;
3774 stPipeOpen.RootId = pParentObjectInfo->VolumeCB->ObjectInformation.FileId;
3777 // Issue the open request to the service
3780 ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_PIPE_OPEN,
3781 AFS_REQUEST_FLAG_SYNCHRONOUS,
3783 &DirectoryCB->NameInformation.FileName,
3785 (void *)&stPipeOpen,
3786 sizeof( AFSPipeOpenCloseRequestCB),
3790 if( !NT_SUCCESS( ntStatus))
3793 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3794 AFS_TRACE_LEVEL_ERROR,
3795 "AFSOpenSpecialShareFcb (%08lX) Failed service open Status %08lX\n",
3799 try_return( ntStatus);
3803 // Increment the open count on this Fcb
3806 InterlockedIncrement( &(*Fcb)->OpenReferenceCount);
3808 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3809 AFS_TRACE_LEVEL_VERBOSE,
3810 "AFSOpenSpecialShareFcb Increment count on Fcb %08lX Cnt %d\n",
3812 (*Fcb)->OpenReferenceCount);
3814 InterlockedIncrement( &(*Fcb)->OpenHandleCount);
3816 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3817 AFS_TRACE_LEVEL_VERBOSE,
3818 "AFSOpenSpecialShareFcb Increment handle count on Fcb %08lX Cnt %d\n",
3820 (*Fcb)->OpenHandleCount);
3823 // Increment the open reference and handle on the parent node
3826 InterlockedIncrement( &pParentObjectInfo->Specific.Directory.ChildOpenHandleCount);
3828 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3829 AFS_TRACE_LEVEL_VERBOSE,
3830 "AFSOpenSpecialShareFcb Increment child open handle count on Parent object %08lX Cnt %d\n",
3832 pParentObjectInfo->Specific.Directory.ChildOpenHandleCount);
3834 InterlockedIncrement( &pParentObjectInfo->Specific.Directory.ChildOpenReferenceCount);
3836 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3837 AFS_TRACE_LEVEL_VERBOSE,
3838 "AFSOpenSpecialShareFcb Increment child open ref count on Parent object %08lX Cnt %d\n",
3840 pParentObjectInfo->Specific.Directory.ChildOpenReferenceCount);
3843 // Return the open result for this file
3846 Irp->IoStatus.Information = FILE_OPENED;
3853 AFSReleaseResource( &(*Fcb)->NPFcb->Resource);
3856 if( !NT_SUCCESS( ntStatus))
3872 // Need to tear down this Fcb since it is not in the tree for the worker thread
3875 AFSRemoveFcb( *Fcb);
3877 DirectoryCB->ObjectInformation->Fcb = NULL;