PFCB
NTAPI
FatCreateFcb(IN PFAT_IRP_CONTEXT IrpContext,
IN PVCB Vcb,
IN PFCB ParentDcb,
IN FF_FILE *FileHandle)
{
PFCB Fcb;
/* Allocate it and zero it */
Fcb = ExAllocatePoolWithTag(NonPagedPool, sizeof(FCB), TAG_FCB);
RtlZeroMemory(Fcb, sizeof(FCB));
/* Set node types */
Fcb->Header.NodeTypeCode = FAT_NTC_FCB;
Fcb->Header.NodeByteSize = sizeof(FCB);
Fcb->Condition = FcbGood;
/* Initialize resources */
Fcb->Header.Resource = &Fcb->Resource;
ExInitializeResourceLite(Fcb->Header.Resource);
Fcb->Header.PagingIoResource = &Fcb->PagingIoResource;
ExInitializeResourceLite(Fcb->Header.PagingIoResource);
/* Initialize mutexes */
Fcb->Header.FastMutex = &Fcb->HeaderMutex;
ExInitializeFastMutex(&Fcb->HeaderMutex);
FsRtlSetupAdvancedHeader(&Fcb->Header, &Fcb->HeaderMutex);
/* Insert into parent's DCB list */
InsertTailList(&ParentDcb->Dcb.ParentDcbList, &Fcb->ParentDcbLinks);
/* Set backlinks */
Fcb->ParentFcb = ParentDcb;
Fcb->Vcb = Vcb;
/* Set file handle and sizes */
Fcb->Header.FileSize.LowPart = FileHandle->Filesize;
Fcb->Header.ValidDataLength.LowPart = FileHandle->Filesize;
Fcb->FatHandle = FileHandle;
/* Initialize locks */
FsRtlInitializeFileLock(&Fcb->Fcb.Lock, NULL, NULL);
FsRtlInitializeOplock(&Fcb->Fcb.Oplock);
/* Set names */
FatSetFcbNames(IrpContext, Fcb);
return Fcb;
}
NTSTATUS FspFileNodeCreate(PDEVICE_OBJECT DeviceObject,
ULONG ExtraSize, FSP_FILE_NODE **PFileNode)
{
PAGED_CODE();
*PFileNode = 0;
FSP_FILE_NODE_NONPAGED *NonPaged = FspAllocNonPaged(sizeof *NonPaged);
if (0 == NonPaged)
return STATUS_INSUFFICIENT_RESOURCES;
FSP_FILE_NODE *FileNode = FspAlloc(sizeof *FileNode + ExtraSize);
if (0 == FileNode)
{
FspFree(NonPaged);
return STATUS_INSUFFICIENT_RESOURCES;
}
RtlZeroMemory(NonPaged, sizeof *NonPaged);
ExInitializeResourceLite(&NonPaged->Resource);
ExInitializeResourceLite(&NonPaged->PagingIoResource);
ExInitializeFastMutex(&NonPaged->HeaderFastMutex);
KeInitializeSpinLock(&NonPaged->DirInfoSpinLock);
RtlZeroMemory(FileNode, sizeof *FileNode + ExtraSize);
FileNode->Header.NodeTypeCode = FspFileNodeFileKind;
FileNode->Header.NodeByteSize = sizeof *FileNode;
FileNode->Header.IsFastIoPossible = FastIoIsNotPossible;
FileNode->Header.Resource = &NonPaged->Resource;
FileNode->Header.PagingIoResource = &NonPaged->PagingIoResource;
FileNode->Header.ValidDataLength.QuadPart = MAXLONGLONG;
/* disable ValidDataLength functionality */
FsRtlSetupAdvancedHeader(&FileNode->Header, &NonPaged->HeaderFastMutex);
FileNode->NonPaged = NonPaged;
FileNode->RefCount = 1;
FileNode->FsvolDeviceObject = DeviceObject;
FspDeviceReference(FileNode->FsvolDeviceObject);
RtlInitEmptyUnicodeString(&FileNode->FileName, FileNode->FileNameBuf, (USHORT)ExtraSize);
FsRtlInitializeFileLock(&FileNode->FileLock, FspFileNodeCompleteLockIrp, 0);
*PFileNode = FileNode;
return STATUS_SUCCESS;
}
/*
* @implemented
*/
PFILE_LOCK
NTAPI
FsRtlAllocateFileLock(IN PCOMPLETE_LOCK_IRP_ROUTINE CompleteLockIrpRoutine OPTIONAL,
IN PUNLOCK_ROUTINE UnlockRoutine OPTIONAL)
{
PFILE_LOCK FileLock;
/* Try to allocate it */
FileLock = ExAllocateFromPagedLookasideList(&FsRtlFileLockLookasideList);
if (FileLock)
{
/* Initialize it */
FsRtlInitializeFileLock(FileLock,
CompleteLockIrpRoutine,
UnlockRoutine);
}
/* Return the lock */
return FileLock;
}
NTSTATUS
AFSInitFcb( IN AFSDirectoryCB *DirEntry,
IN OUT AFSFcb **Fcb)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
AFSFcb *pFcb = NULL;
AFSNonPagedFcb *pNPFcb = NULL;
IO_STATUS_BLOCK stIoSb = {0,0};
BOOLEAN bUninitFileLock = FALSE;
USHORT usFcbLength = 0;
ULONGLONG ullIndex = 0;
AFSDirEnumEntry *pDirEnumCB = NULL;
AFSObjectInfoCB *pObjectInfo = NULL, *pParentObjectInfo = NULL;
AFSVolumeCB *pVolumeCB = NULL;
__Enter
{
pObjectInfo = DirEntry->ObjectInformation;
pParentObjectInfo = pObjectInfo->ParentObjectInformation;
pVolumeCB = pObjectInfo->VolumeCB;
//
// Allocate the Fcb and the nonpaged portion of the Fcb.
//
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE_2,
"AFSInitFcb Initializing fcb for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
&DirEntry->NameInformation.FileName,
pObjectInfo->FileId.Cell,
pObjectInfo->FileId.Volume,
pObjectInfo->FileId.Vnode,
pObjectInfo->FileId.Unique);
usFcbLength = sizeof( AFSFcb);
pFcb = (AFSFcb *)AFSExAllocatePoolWithTag( PagedPool,
usFcbLength,
AFS_FCB_ALLOCATION_TAG);
if( pFcb == NULL)
{
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSInitFcb Failed to allocate fcb\n");
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
}
RtlZeroMemory( pFcb,
usFcbLength);
pFcb->Header.NodeByteSize = usFcbLength;
pNPFcb = (AFSNonPagedFcb *)AFSExAllocatePoolWithTag( NonPagedPool,
sizeof( AFSNonPagedFcb),
AFS_FCB_NP_ALLOCATION_TAG);
if( pNPFcb == NULL)
{
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSInitFcb Failed to allocate non-paged fcb\n");
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
}
RtlZeroMemory( pNPFcb,
sizeof( AFSNonPagedFcb));
pNPFcb->Size = sizeof( AFSNonPagedFcb);
pNPFcb->Type = AFS_NON_PAGED_FCB;
//
// Initialize the advanced header
//
ExInitializeFastMutex( &pNPFcb->AdvancedHdrMutex);
FsRtlSetupAdvancedHeader( &pFcb->Header, &pNPFcb->AdvancedHdrMutex);
//
// OK, initialize the entry
//
ExInitializeResourceLite( &pNPFcb->Resource);
ExInitializeResourceLite( &pNPFcb->PagingResource);
ExInitializeResourceLite( &pNPFcb->CcbListLock);
pFcb->Header.Resource = &pNPFcb->Resource;
pFcb->Header.PagingIoResource = &pNPFcb->PagingResource;
//
// Grab the Fcb for processing
//
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSInitFcb Acquiring Fcb lock %08lX EXCL %08lX\n",
&pNPFcb->Resource,
PsGetCurrentThread());
AFSAcquireExcl( &pNPFcb->Resource,
TRUE);
pFcb->NPFcb = pNPFcb;
//
// Initialize some fields in the Fcb
//
pFcb->ObjectInformation = pObjectInfo;
pObjectInfo->Fcb = pFcb;
//
// Set type specific information
//
if( pObjectInfo->FileType == AFS_FILE_TYPE_DIRECTORY)
{
//
// Reset the type to a directory type
//
pFcb->Header.NodeTypeCode = AFS_DIRECTORY_FCB;
//
// Initialize enumeration information
//
KeInitializeEvent( &pFcb->NPFcb->Specific.Directory.DirectoryEnumEvent,
NotificationEvent,
FALSE);
}
else if( pObjectInfo->FileType == AFS_FILE_TYPE_FILE)
{
pFcb->Header.NodeTypeCode = AFS_FILE_FCB;
//
// Initialize the file specific information
//
FsRtlInitializeFileLock( &pFcb->Specific.File.FileLock,
NULL,
NULL);
bUninitFileLock = TRUE;
//
// Initialize the header file sizes to our dir entry information
//
pFcb->Header.AllocationSize.QuadPart = pObjectInfo->AllocationSize.QuadPart;
pFcb->Header.FileSize.QuadPart = pObjectInfo->EndOfFile.QuadPart;
pFcb->Header.ValidDataLength.QuadPart = pObjectInfo->EndOfFile.QuadPart;
//
// Initialize the Extents resources and so forth. The
// quiescent state is that no one has the extents for
// IO (do the extents are not busy) and there is no
// extents request outstanding (and hence the "last
// one" is complete).
//
ExInitializeResourceLite( &pNPFcb->Specific.File.ExtentsResource );
KeInitializeEvent( &pNPFcb->Specific.File.ExtentsRequestComplete,
NotificationEvent,
TRUE );
for (ULONG i = 0; i < AFS_NUM_EXTENT_LISTS; i++)
{
InitializeListHead(&pFcb->Specific.File.ExtentsLists[i]);
}
pNPFcb->Specific.File.DirtyListHead = NULL;
pNPFcb->Specific.File.DirtyListTail = NULL;
ExInitializeResourceLite( &pNPFcb->Specific.File.DirtyExtentsListLock);
KeInitializeEvent( &pNPFcb->Specific.File.FlushEvent,
SynchronizationEvent,
TRUE);
KeInitializeEvent( &pNPFcb->Specific.File.QueuedFlushEvent,
NotificationEvent,
TRUE);
}
else if( pObjectInfo->FileType == AFS_FILE_TYPE_SPECIAL_SHARE_NAME)
{
pFcb->Header.NodeTypeCode = AFS_SPECIAL_SHARE_FCB;
}
else if( pObjectInfo->FileType == AFS_FILE_TYPE_PIOCTL)
{
pFcb->Header.NodeTypeCode = AFS_IOCTL_FCB;
}
else if( pObjectInfo->FileType == AFS_FILE_TYPE_SYMLINK)
{
pFcb->Header.NodeTypeCode = AFS_SYMBOLIC_LINK_FCB;
}
else if( pObjectInfo->FileType == AFS_FILE_TYPE_MOUNTPOINT)
{
pFcb->Header.NodeTypeCode = AFS_MOUNT_POINT_FCB;
}
else if( pObjectInfo->FileType == AFS_FILE_TYPE_DFSLINK)
{
pFcb->Header.NodeTypeCode = AFS_DFS_LINK_FCB;
}
else
{
pFcb->Header.NodeTypeCode = AFS_INVALID_FCB;
}
//
// And return the Fcb
//
*Fcb = pFcb;
AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSInitFcb Initialized Fcb %08lX Name %wZ\n",
pFcb,
&DirEntry->NameInformation.FileName);
try_exit:
if( !NT_SUCCESS( ntStatus))
{
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSInitFcb Failed to initialize fcb Status %08lX\n",
ntStatus);
if( pFcb != NULL)
{
if( bUninitFileLock)
{
FsRtlUninitializeFileLock( &pFcb->Specific.File.FileLock);
}
if( pNPFcb != NULL)
{
AFSReleaseResource( &pNPFcb->Resource);
ExDeleteResourceLite( &pNPFcb->PagingResource);
ExDeleteResourceLite( &pNPFcb->CcbListLock);
ExDeleteResourceLite( &pNPFcb->Resource);
}
AFSExFreePool( pFcb);
}
if( pNPFcb != NULL)
{
AFSExFreePool( pNPFcb);
}
if( Fcb != NULL)
{
*Fcb = NULL;
}
}
}
return ntStatus;
}
PFFS_FCB
FFSv2AllocateFcb(
IN PFFS_VCB Vcb,
IN PFFS_MCB FFSMcb,
IN PFFSv2_INODE dinode2)
{
PFFS_FCB Fcb;
ExAcquireResourceExclusiveLite(
&FFSGlobal->LAResource,
TRUE);
Fcb = (PFFS_FCB)(ExAllocateFromNPagedLookasideList(&(FFSGlobal->FFSFcbLookasideList)));
ExReleaseResourceForThreadLite(
&FFSGlobal->LAResource,
ExGetCurrentResourceThread());
if (Fcb == NULL)
{
Fcb = (PFFS_FCB)ExAllocatePool(NonPagedPool, sizeof(FFS_FCB));
RtlZeroMemory(Fcb, sizeof(FFS_FCB));
SetFlag(Fcb->Flags, FCB_FROM_POOL);
}
else
{
RtlZeroMemory(Fcb, sizeof(FFS_FCB));
}
if (!Fcb)
{
return NULL;
}
Fcb->Identifier.Type = FFSFCB;
Fcb->Identifier.Size = sizeof(FFS_FCB);
FsRtlInitializeFileLock(
&Fcb->FileLockAnchor,
NULL,
NULL);
Fcb->OpenHandleCount = 0;
Fcb->ReferenceCount = 0;
Fcb->Vcb = Vcb;
#if DBG
Fcb->AnsiFileName.MaximumLength = (USHORT)
RtlxUnicodeStringToOemSize(&(FFSMcb->ShortName)) + 1;
Fcb->AnsiFileName.Buffer = (PUCHAR)
ExAllocatePool(PagedPool, Fcb->AnsiFileName.MaximumLength);
if (!Fcb->AnsiFileName.Buffer)
{
goto errorout;
}
RtlZeroMemory(Fcb->AnsiFileName.Buffer, Fcb->AnsiFileName.MaximumLength);
FFSUnicodeToOEM(&(Fcb->AnsiFileName),
&(FFSMcb->ShortName));
#endif
FFSMcb->FileAttr = FILE_ATTRIBUTE_NORMAL;
if ((dinode2->di_mode & IFMT) == IFDIR)
{
SetFlag(FFSMcb->FileAttr, FILE_ATTRIBUTE_DIRECTORY);
}
if (IsFlagOn(Vcb->Flags, VCB_READ_ONLY) ||
FFSIsReadOnly(dinode2->di_mode))
{
SetFlag(FFSMcb->FileAttr, FILE_ATTRIBUTE_READONLY);
}
Fcb->dinode2 = dinode2;
Fcb->FFSMcb = FFSMcb;
FFSMcb->FFSFcb = Fcb;
RtlZeroMemory(&Fcb->Header, sizeof(FSRTL_COMMON_FCB_HEADER));
Fcb->Header.NodeTypeCode = (USHORT)FFSFCB;
Fcb->Header.NodeByteSize = sizeof(FFS_FCB);
Fcb->Header.IsFastIoPossible = FastIoIsNotPossible;
Fcb->Header.Resource = &(Fcb->MainResource);
Fcb->Header.PagingIoResource = &(Fcb->PagingIoResource);
{
ULONG Totalblocks = (ULONG)(Fcb->dinode2->di_blocks);
Fcb->Header.AllocationSize.QuadPart =
(((LONGLONG)FFSDataBlocks(Vcb, Totalblocks)) << BLOCK_BITS);
}
Fcb->Header.FileSize.QuadPart = (LONGLONG)(Fcb->dinode2->di_size);
Fcb->Header.ValidDataLength.QuadPart = (LONGLONG)(0x7fffffffffffffff);
Fcb->SectionObject.DataSectionObject = NULL;
Fcb->SectionObject.SharedCacheMap = NULL;
Fcb->SectionObject.ImageSectionObject = NULL;
ExInitializeResourceLite(&(Fcb->MainResource));
ExInitializeResourceLite(&(Fcb->PagingIoResource));
InsertTailList(&Vcb->FcbList, &Fcb->Next);
#if DBG
ExAcquireResourceExclusiveLite(
&FFSGlobal->CountResource,
TRUE);
FFSGlobal->FcbAllocated++;
ExReleaseResourceForThreadLite(
&FFSGlobal->CountResource,
ExGetCurrentResourceThread());
#endif
return Fcb;
#if DBG
errorout:
#endif
if (Fcb)
{
#if DBG
if (Fcb->AnsiFileName.Buffer)
ExFreePool(Fcb->AnsiFileName.Buffer);
#endif
if (FlagOn(Fcb->Flags, FCB_FROM_POOL))
{
ExFreePool(Fcb);
}
else
{
ExAcquireResourceExclusiveLite(
&FFSGlobal->LAResource,
TRUE);
ExFreeToNPagedLookasideList(&(FFSGlobal->FFSFcbLookasideList), Fcb);
ExReleaseResourceForThreadLite(
&FFSGlobal->LAResource,
ExGetCurrentResourceThread());
}
}
return NULL;
}
PNDAS_FCB
ReadonlyAllocateFcb (
IN PFILESPY_DEVICE_EXTENSION DevExt,
IN PUNICODE_STRING FullFileName,
IN BOOLEAN IsPagingFile
)
{
PNDAS_FCB fcb;
fcb = FsRtlAllocatePoolWithTag( NonPagedPool,
sizeof(NDAS_FCB),
LFS_FCB_TAG );
if (fcb == NULL) {
SPY_LOG_PRINT( LFS_DEBUG_READONLY_ERROR, ("ReadonlyAllocateFcb: failed to allocate fcb\n") );
return NULL;
}
RtlZeroMemory( fcb, sizeof(NDAS_FCB) );
fcb->NonPaged = LfsAllocateNonPagedFcb();
if (fcb->NonPaged == NULL) {
SPY_LOG_PRINT( LFS_DEBUG_READONLY_ERROR, ("ReadonlyAllocateFcb: failed to allocate fcb->NonPaged\n") );
ExFreePool( fcb );
return NULL;
}
RtlZeroMemory( fcb->NonPaged, sizeof(NON_PAGED_FCB) );
#define FAT_NTC_FCB (0x0502)
fcb->Header.NodeTypeCode = FAT_NTC_FCB;
fcb->Header.IsFastIoPossible = FastIoIsPossible;
fcb->Header.Resource = LfsAllocateResource();
fcb->Header.PagingIoResource = NULL; //fcb->Header.Resource;
if (fcb->Header.Resource == NULL) {
SPY_LOG_PRINT( LFS_DEBUG_READONLY_ERROR, ("ReadonlyAllocateFcb: failed to allocate fcb->Header.Resource\n") );
ExFreePool( fcb->NonPaged );
ExFreePool( fcb );
return NULL;
}
if (LfsFsRtlTeardownPerStreamContexts) {
ExInitializeFastMutex( &fcb->NonPaged->AdvancedFcbHeaderMutex );
FsRtlSetupAdvancedHeader( &fcb->Header, &fcb->NonPaged->AdvancedFcbHeaderMutex );
if (IsPagingFile) {
ClearFlag( fcb->Header.Flags2, FSRTL_FLAG2_SUPPORTS_FILTER_CONTEXTS );
}
}
FsRtlInitializeFileLock( &fcb->FileLock, NULL, NULL );
fcb->ReferenceCount = 1;
InitializeListHead( &fcb->ListEntry );
fcb->Readonly = DevExt->LfsDeviceExt.Readonly;
RtlInitEmptyUnicodeString( &fcb->FullFileName,
fcb->FullFileNameBuffer,
sizeof(fcb->FullFileNameBuffer) );
RtlCopyUnicodeString( &fcb->FullFileName, FullFileName );
RtlInitEmptyUnicodeString( &fcb->CaseInSensitiveFullFileName,
fcb->CaseInSensitiveFullFileNameBuffer,
sizeof(fcb->CaseInSensitiveFullFileNameBuffer) );
RtlDowncaseUnicodeString( &fcb->CaseInSensitiveFullFileName,
&fcb->FullFileName,
FALSE );
if(FullFileName->Length)
if(FullFileName->Buffer[0] != L'\\')
ASSERT( LFS_BUG );
return fcb;
}
