fcb.c File Reference

#include "ntfs.h"
#include <debug.h>

Include dependency graph for fcb.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
static PCWSTR	NtfsGetNextPathElement (PCWSTR FileName)
static VOID	NtfsWSubString (PWCHAR pTarget, PCWSTR pSource, size_t pLength)
PNTFS_FCB	NtfsCreateFCB (PCWSTR FileName, PCWSTR Stream, PNTFS_VCB Vcb)
VOID	NtfsDestroyFCB (PNTFS_FCB Fcb)
BOOLEAN	NtfsFCBIsDirectory (PNTFS_FCB Fcb)
BOOLEAN NTAPI	NtfsIsRegularFileObject (_In_ PFILE_OBJECT FileObject)
BOOLEAN	NtfsFCBIsReparsePoint (PNTFS_FCB Fcb)
BOOLEAN	NtfsFCBIsCompressed (PNTFS_FCB Fcb)
BOOLEAN	NtfsFCBIsEncrypted (PNTFS_FCB Fcb)
BOOLEAN	NtfsFCBIsRoot (PNTFS_FCB Fcb)
VOID	NtfsGrabFCB (PNTFS_VCB Vcb, PNTFS_FCB Fcb)
VOID	NtfsReleaseFCB (PNTFS_VCB Vcb, PNTFS_FCB Fcb)
VOID	NtfsAddFCBToTable (PNTFS_VCB Vcb, PNTFS_FCB Fcb)
NtfsRemoveFCBFromTable
Takes the FCB of a deleted file or directory out of the table, so a later open of the same path goes to the disk instead of finding it. The FCB lives on until its last reference is released.
VOID	NtfsRemoveFCBFromTable (_In_ PNTFS_VCB Vcb, _In_ PNTFS_FCB Fcb)
PNTFS_FCB	NtfsGrabFCBFromTable (PNTFS_VCB Vcb, PCWSTR FileName)
NTSTATUS	NtfsFCBInitializeCache (PNTFS_VCB Vcb, PNTFS_FCB Fcb)
PNTFS_FCB	NtfsMakeRootFCB (PNTFS_VCB Vcb)
PNTFS_FCB	NtfsOpenRootFCB (PNTFS_VCB Vcb)
NTSTATUS	NtfsMakeFCBFromDirEntry (PNTFS_VCB Vcb, PNTFS_FCB DirectoryFCB, PUNICODE_STRING Name, PCWSTR Stream, PFILE_RECORD_HEADER Record, ULONGLONG MFTIndex, PNTFS_FCB *fileFCB)
NTSTATUS	NtfsAttachFCBToFileObject (PNTFS_VCB Vcb, PNTFS_FCB Fcb, PFILE_OBJECT FileObject)
static NTSTATUS	NtfsDirFindFile (PNTFS_VCB Vcb, PNTFS_FCB DirectoryFcb, PWSTR FileToFind, BOOLEAN CaseSensitive, PNTFS_FCB *FoundFCB)
NTSTATUS	NtfsGetFCBForFile (PNTFS_VCB Vcb, PNTFS_FCB *pParentFCB, PNTFS_FCB *pFCB, PCWSTR pFileName, BOOLEAN CaseSensitive)
NTSTATUS	NtfsReadFCBAttribute (PNTFS_VCB Vcb, PNTFS_FCB pFCB, ULONG Type, PCWSTR Name, ULONG NameLength, PVOID *Data)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 32 of file fcb.c.

Function Documentation

NtfsAddFCBToTable()

VOID NtfsAddFCBToTable	(	PNTFS_VCB	Vcb,
		PNTFS_FCB	Fcb
	)

Definition at line 250 of file fcb.c.

{
    KIRQL oldIrql;
 
    KeAcquireSpinLock(&Vcb->FcbListLock, &oldIrql);
    Fcb->Vcb = Vcb;
    InsertTailList(&Vcb->FcbListHead, &Fcb->FcbListEntry);
    KeReleaseSpinLock(&Vcb->FcbListLock, oldIrql);
}

Referenced by NtfsMakeFCBFromDirEntry(), and NtfsMakeRootFCB().

NtfsAttachFCBToFileObject()

NTSTATUS NtfsAttachFCBToFileObject	(	PNTFS_VCB	Vcb,
		PNTFS_FCB	Fcb,
		PFILE_OBJECT	FileObject
	)

Definition at line 533 of file fcb.c.

{
    PNTFS_CCB newCCB;
 
    newCCB = ExAllocatePoolWithTag(NonPagedPool, sizeof(NTFS_CCB), TAG_CCB);
    if (newCCB == NULL)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlZeroMemory(newCCB, sizeof(NTFS_CCB));
 
    newCCB->Identifier.Type = NTFS_TYPE_CCB;
    newCCB->Identifier.Size = sizeof(NTFS_TYPE_CCB);
 
    FileObject->SectionObjectPointer = &Fcb->SectionObjectPointers;
    FileObject->FsContext = Fcb;
    FileObject->FsContext2 = newCCB;
    newCCB->PtrFileObject = FileObject;
    Fcb->Vcb = Vcb;
 
    /* Directories are excluded: they have no $DATA to map, and a data section on one gives Mm
     * pages to fault in that we can never satisfy. */
    if (!(Fcb->Flags & FCB_CACHE_INITIALIZED) && !NtfsFCBIsDirectory(Fcb))
    {
        _SEH2_TRY
        {
            CcInitializeCacheMap(FileObject,
                                 (PCC_FILE_SIZES)(&Fcb->RFCB.AllocationSize),
                                 FALSE,
                                 &(NtfsGlobalData->CacheMgrCallbacks),
                                 Fcb);
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            FileObject->FsContext2 = NULL;
            ExFreePoolWithTag(newCCB, TAG_CCB);
            return _SEH2_GetExceptionCode();
        }
        _SEH2_END;
 
        Fcb->Flags |= FCB_CACHE_INITIALIZED;
    }
 
    //DPRINT("file open: fcb:%x file size: %d\n", Fcb, Fcb->Entry.DataLengthL);
 
    return STATUS_SUCCESS;
}

Referenced by NtfsCreateFile(), NtfsOpenFile(), NtfsOpenFileById(), and NtfsOpenTargetDirectory().

NtfsCreateFCB()

PNTFS_FCB NtfsCreateFCB	(	PCWSTR	FileName,
		PCWSTR	Stream,
		PNTFS_VCB	Vcb
	)

Definition at line 67 of file fcb.c.

{
    PNTFS_FCB Fcb;
 
    ASSERT(Vcb);
    ASSERT(Vcb->Identifier.Type == NTFS_TYPE_VCB);
 
    Fcb = ExAllocateFromNPagedLookasideList(&NtfsGlobalData->FcbLookasideList);
    if (Fcb == NULL)
    {
        return NULL;
    }
 
    RtlZeroMemory(Fcb, sizeof(NTFS_FCB));
 
    Fcb->Identifier.Type = NTFS_TYPE_FCB;
    Fcb->Identifier.Size = sizeof(NTFS_TYPE_FCB);
 
    Fcb->Vcb = Vcb;
 
    if (FileName)
    {
        wcscpy(Fcb->PathName, FileName);
        if (wcsrchr(Fcb->PathName, '\\') != 0)
        {
            Fcb->ObjectName = wcsrchr(Fcb->PathName, '\\');
        }
        else
        {
            Fcb->ObjectName = Fcb->PathName;
        }
    }
 
    if (Stream)
    {
        wcscpy(Fcb->Stream, Stream);
    }
    else
    {
        Fcb->Stream[0] = UNICODE_NULL;
    }
 
    ExInitializeResourceLite(&Fcb->MainResource);
    ExInitializeResourceLite(&Fcb->PagingIoResource);
    FsRtlInitializeFileLock(&Fcb->FileLock, NULL, NULL);
 
    Fcb->RFCB.Resource = &(Fcb->MainResource);
    Fcb->RFCB.PagingIoResource = &(Fcb->PagingIoResource);
 
    /* NtfsFastIoCheckIfPossible decides per request */
    Fcb->RFCB.IsFastIoPossible = FastIoIsQuestionable;
 
    return Fcb;
}

Referenced by NtfsGetVolumeData(), NtfsMakeFCBFromDirEntry(), NtfsMakeRootFCB(), and NtfsMountVolume().

NtfsDestroyFCB()

VOID NtfsDestroyFCB

(

PNTFS_FCB

Fcb

)

Definition at line 126 of file fcb.c.

{
    ASSERT(Fcb);
    ASSERT(Fcb->Identifier.Type == NTFS_TYPE_FCB);
 
    /* The volume stream belongs to the VCB */
    if (Fcb->FileObject && !(Fcb->Flags & FCB_IS_VOLUME_STREAM))
        ObDereferenceObject(Fcb->FileObject);
 
    FsRtlUninitializeFileLock(&Fcb->FileLock);
    ExDeleteResourceLite(&Fcb->PagingIoResource);
    ExDeleteResourceLite(&Fcb->MainResource);
 
    ExFreeToNPagedLookasideList(&NtfsGlobalData->FcbLookasideList, Fcb);
}

Referenced by NtfsReleaseFCB().

NtfsDirFindFile()

static NTSTATUS NtfsDirFindFile ( PNTFS_VCB  Vcb, PNTFS_FCB  DirectoryFcb, PWSTR  FileToFind, BOOLEAN  CaseSensitive, PNTFS_FCB *  FoundFCB  )

static

Definition at line 586 of file fcb.c.

{
    NTSTATUS Status;
    ULONGLONG CurrentDir;
    UNICODE_STRING File;
    PFILE_RECORD_HEADER FileRecord;
    ULONGLONG MFTIndex;
    PWSTR Colon, OldColon;
    PNTFS_ATTR_CONTEXT DataContext;
    USHORT Length = 0;
 
    DPRINT("NtfsDirFindFile(%p, %p, %S, %s, %p)\n",
           Vcb,
           DirectoryFcb,
           FileToFind,
           CaseSensitive ? "TRUE" : "FALSE",
           FoundFCB);
 
    *FoundFCB = NULL;
    RtlInitUnicodeString(&File, FileToFind);
    CurrentDir = DirectoryFcb->MFTIndex;
 
    Colon = wcsrchr(FileToFind, L':');
    if (Colon != NULL)
    {
        Length = File.Length;
        File.Length = (Colon - FileToFind) * sizeof(WCHAR);
 
        if (_wcsicmp(Colon + 1, L"$DATA") == 0)
        {
            OldColon = Colon;
            Colon[0] = UNICODE_NULL;
            Colon = wcsrchr(FileToFind, L':');
            if (Colon != NULL)
            {
                Length = File.Length;
                File.Length = (Colon - FileToFind) * sizeof(WCHAR);
            }
            else
            {
                Colon = OldColon;
                Colon[0] = L':';
            }
        }
 
        /* Skip colon */
        ++Colon;
        DPRINT("Will now look for file '%wZ' with stream '%S'\n", &File, Colon);
    }
 
    Status = NtfsLookupFileAt(Vcb, &File, CaseSensitive, &FileRecord, &MFTIndex, CurrentDir);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    if (Length != 0)
    {
        File.Length = Length;
    }
 
    if ((FileRecord->Flags & FRH_DIRECTORY) && Colon != 0)
    {
        ExFreeToNPagedLookasideList(&Vcb->FileRecLookasideList, FileRecord);
        return STATUS_INVALID_PARAMETER;
    }
    else if (Colon != 0)
    {
        Status = FindAttribute(Vcb, FileRecord, AttributeData, Colon, wcslen(Colon), &DataContext, NULL);
        if (!NT_SUCCESS(Status))
        {
            return STATUS_OBJECT_NAME_NOT_FOUND;
        }
        ReleaseAttributeContext(DataContext);
    }
 
    Status = NtfsMakeFCBFromDirEntry(Vcb, DirectoryFcb, &File, Colon, FileRecord, MFTIndex, FoundFCB);
    ExFreeToNPagedLookasideList(&Vcb->FileRecLookasideList, FileRecord);
 
    return Status;
}

Referenced by NtfsGetFCBForFile().

NtfsFCBInitializeCache()

NTSTATUS NtfsFCBInitializeCache	(	PNTFS_VCB	Vcb,
		PNTFS_FCB	Fcb
	)

Definition at line 334 of file fcb.c.

{
    PFILE_OBJECT FileObject;
    NTSTATUS Status;
    PNTFS_CCB newCCB;
 
    FileObject = IoCreateStreamFileObject(NULL, Vcb->StorageDevice);
 
    newCCB = ExAllocatePoolWithTag(NonPagedPool, sizeof(NTFS_CCB), TAG_CCB);
    if (newCCB == NULL)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlZeroMemory(newCCB, sizeof(NTFS_CCB));
 
    newCCB->Identifier.Type = NTFS_TYPE_CCB;
    newCCB->Identifier.Size = sizeof(NTFS_TYPE_CCB);
 
    FileObject->SectionObjectPointer = &Fcb->SectionObjectPointers;
    FileObject->FsContext = Fcb;
    FileObject->FsContext2 = newCCB;
    newCCB->PtrFileObject = FileObject;
    Fcb->FileObject = FileObject;
    Fcb->Vcb = Vcb;
 
    Status = STATUS_SUCCESS;
    _SEH2_TRY
    {
        CcInitializeCacheMap(FileObject,
                             (PCC_FILE_SIZES)(&Fcb->RFCB.AllocationSize),
                             FALSE,
                             &(NtfsGlobalData->CacheMgrCallbacks),
                             Fcb);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        FileObject->FsContext2 = NULL;
        ExFreePoolWithTag(newCCB, TAG_CCB);
        ObDereferenceObject(FileObject);
        Fcb->FileObject = NULL;
        return _SEH2_GetExceptionCode();
    }
    _SEH2_END;
 
    /* The FCB keeps its reference, tearing down the cache map would otherwise free the stream */
    Fcb->Flags |= FCB_CACHE_INITIALIZED;
 
    return Status;
}

Referenced by NtfsMakeFCBFromDirEntry(), and NtfsMakeRootFCB().

NtfsFCBIsCompressed()

BOOLEAN NtfsFCBIsCompressed

(

PNTFS_FCB

Fcb

)

Definition at line 173 of file fcb.c.

{
    return ((Fcb->Entry.FileAttributes & NTFS_FILE_TYPE_COMPRESSED) == NTFS_FILE_TYPE_COMPRESSED);
}

Referenced by NtfsCachedRead(), NtfsCachedWrite(), NtfsFastIoCheckIfPossible(), NtfsQueryDirectory(), NtfsReadFile(), and NtfsWriteFile().

NtfsFCBIsDirectory()

BOOLEAN NtfsFCBIsDirectory

(

PNTFS_FCB

Fcb

)

Definition at line 144 of file fcb.c.

{
    return ((Fcb->Entry.FileAttributes & NTFS_FILE_TYPE_DIRECTORY) == NTFS_FILE_TYPE_DIRECTORY);
}

Referenced by NtfsAttachFCBToFileObject(), NtfsBuildRenamePath(), NtfsCleanupFile(), NtfsCreateFile(), NtfsGetFCBForFile(), NtfsGetStandardInformation(), NtfsIsRegularFileObject(), NtfsMakeAbsoluteFilename(), NtfsOpenTargetDirectory(), NtfsRead(), NtfsReleaseFCB(), NtfsSetAllocationInformation(), NtfsSetDispositionInformation(), and NtfsWrite().

NtfsFCBIsEncrypted()

BOOLEAN NtfsFCBIsEncrypted

(

PNTFS_FCB

Fcb

)

Definition at line 179 of file fcb.c.

{
    return ((Fcb->Entry.FileAttributes & NTFS_FILE_TYPE_ENCRYPTED) == NTFS_FILE_TYPE_ENCRYPTED);
}

Referenced by NtfsCachedRead(), NtfsFastIoCheckIfPossible(), and NtfsReadFile().

NtfsFCBIsReparsePoint()

BOOLEAN NtfsFCBIsReparsePoint

(

PNTFS_FCB

Fcb

)

Definition at line 166 of file fcb.c.

{
    return ((Fcb->Entry.FileAttributes & NTFS_FILE_TYPE_REPARSE) == NTFS_FILE_TYPE_REPARSE);
}

Referenced by NtfsCreateFile().

NtfsFCBIsRoot()

BOOLEAN NtfsFCBIsRoot

(

PNTFS_FCB

Fcb

)

Definition at line 185 of file fcb.c.

{
    return (wcscmp(Fcb->PathName, L"\\") == 0);
}

Referenced by NtfsBuildRenamePath(), NtfsMakeAbsoluteFilename(), NtfsMakeFCBFromDirEntry(), NtfsSetDispositionInformation(), and NtfsSetRenameInformation().

NtfsGetFCBForFile()

NTSTATUS NtfsGetFCBForFile	(	PNTFS_VCB	Vcb,
		PNTFS_FCB *	pParentFCB,
		PNTFS_FCB *	pFCB,
		PCWSTR	pFileName,
		BOOLEAN	CaseSensitive
	)

Definition at line 674 of file fcb.c.

{
    NTSTATUS Status;
    WCHAR pathName [MAX_PATH];
    WCHAR elementName [MAX_PATH];
    PCWSTR currentElement;
    PNTFS_FCB FCB;
    PNTFS_FCB parentFCB;
 
    DPRINT("NtfsGetFCBForFile(%p, %p, %p, '%S', %s)\n",
           Vcb,
           pParentFCB,
           pFCB,
           pFileName,
           CaseSensitive ? "TRUE" : "FALSE");
 
    /* Dummy code */
//  FCB = NtfsOpenRootFCB(Vcb);
//  *pFCB = FCB;
//  *pParentFCB = NULL;
 
#if 1
    /* Trivial case, open of the root directory on volume */
    if (pFileName[0] == L'\0' || wcscmp(pFileName, L"\\") == 0)
    {
        DPRINT("returning root FCB\n");
 
        FCB = NtfsOpenRootFCB(Vcb);
        *pFCB = FCB;
        *pParentFCB = NULL;
 
        return (FCB != NULL) ? STATUS_SUCCESS : STATUS_OBJECT_PATH_NOT_FOUND;
    }
    else
    {
        currentElement = pFileName + 1;
        wcscpy (pathName, L"\\");
        FCB = NtfsOpenRootFCB (Vcb);
    }
 
    parentFCB = NULL;
 
    /* Parse filename and check each path element for existence and access */
    while (NtfsGetNextPathElement(currentElement) != 0)
    {
        /* Skip blank directory levels */
        if ((NtfsGetNextPathElement(currentElement) - currentElement) == 0)
        {
            currentElement++;
            continue;
        }
 
        DPRINT("Parsing, currentElement:%S\n", currentElement);
        DPRINT("  parentFCB:%p FCB:%p\n", parentFCB, FCB);
 
        /* Descend to next directory level */
        if (parentFCB)
        {
            NtfsReleaseFCB(Vcb, parentFCB);
            parentFCB = NULL;
        }
 
        /* fail if element in FCB is not a directory */
        if (!NtfsFCBIsDirectory(FCB))
        {
            DPRINT("Element in requested path is not a directory\n");
 
            NtfsReleaseFCB(Vcb, FCB);
            FCB = 0;
            *pParentFCB = NULL;
            *pFCB = NULL;
 
            return STATUS_OBJECT_PATH_NOT_FOUND;
        }
 
        parentFCB = FCB;
 
        /* Extract next directory level into dirName */
        NtfsWSubString(pathName,
                       pFileName,
                       NtfsGetNextPathElement(currentElement) - pFileName);
        DPRINT("  pathName:%S\n", pathName);
 
        FCB = NtfsGrabFCBFromTable(Vcb, pathName);
        if (FCB == NULL)
        {
            NtfsWSubString(elementName,
                           currentElement,
                           NtfsGetNextPathElement(currentElement) - currentElement);
            DPRINT("  elementName:%S\n", elementName);
 
            Status = NtfsDirFindFile(Vcb, parentFCB, elementName, CaseSensitive, &FCB);
            if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
            {
                *pParentFCB = parentFCB;
                *pFCB = NULL;
                currentElement = NtfsGetNextPathElement(currentElement);
                if (*currentElement == L'\0' || NtfsGetNextPathElement(currentElement + 1) == 0)
                {
                    return STATUS_OBJECT_NAME_NOT_FOUND;
                }
                else
                {
                    return STATUS_OBJECT_PATH_NOT_FOUND;
                }
            }
            else if (!NT_SUCCESS(Status))
            {
                NtfsReleaseFCB(Vcb, parentFCB);
                *pParentFCB = NULL;
                *pFCB = NULL;
 
                return Status;
            }
        }
 
        currentElement = NtfsGetNextPathElement(currentElement);
    }
 
    *pParentFCB = parentFCB;
    *pFCB = FCB;
#endif
 
    return STATUS_SUCCESS;
}

Referenced by NtfsOpenFile(), and NtfsOpenTargetDirectory().

NtfsGetNextPathElement()

static PCWSTR NtfsGetNextPathElement ( PCWSTR  FileName )

static

Definition at line 39 of file fcb.c.

{
    if (*FileName == L'\0')
    {
        return NULL;
    }
 
    while (*FileName != L'\0' && *FileName != L'\\')
    {
        FileName++;
    }
 
    return FileName;
}

Referenced by NtfsGetFCBForFile().

NtfsGrabFCB()

VOID NtfsGrabFCB	(	PNTFS_VCB	Vcb,
		PNTFS_FCB	Fcb
	)

Definition at line 192 of file fcb.c.

{
    KIRQL oldIrql;
 
    DPRINT("grabbing FCB at %p: %S, refCount:%d\n",
           Fcb,
           Fcb->PathName,
           Fcb->RefCount);
 
    KeAcquireSpinLock(&Vcb->FcbListLock, &oldIrql);
    Fcb->RefCount++;
    KeReleaseSpinLock(&Vcb->FcbListLock, oldIrql);
}

Referenced by NtfsMakeRootFCB().

NtfsGrabFCBFromTable()

PNTFS_FCB NtfsGrabFCBFromTable	(	PNTFS_VCB	Vcb,
		PCWSTR	FileName
	)

Definition at line 291 of file fcb.c.

{
    KIRQL oldIrql;
    PNTFS_FCB Fcb;
    PLIST_ENTRY current_entry;
 
    KeAcquireSpinLock(&Vcb->FcbListLock, &oldIrql);
 
    if (FileName == NULL || *FileName == 0)
    {
        DPRINT("Return FCB for stream file object\n");
        Fcb = Vcb->StreamFileObject->FsContext;
        Fcb->RefCount++;
        KeReleaseSpinLock(&Vcb->FcbListLock, oldIrql);
        return Fcb;
    }
 
    current_entry = Vcb->FcbListHead.Flink;
    while (current_entry != &Vcb->FcbListHead)
    {
        Fcb = CONTAINING_RECORD(current_entry, NTFS_FCB, FcbListEntry);
 
        DPRINT("Comparing '%S' and '%S'\n", FileName, Fcb->PathName);
        if (_wcsicmp(FileName, Fcb->PathName) == 0)
        {
            Fcb->RefCount++;
            KeReleaseSpinLock(&Vcb->FcbListLock, oldIrql);
            return Fcb;
        }
 
        //FIXME: need to compare against short name in FCB here
 
        current_entry = current_entry->Flink;
    }
 
    KeReleaseSpinLock(&Vcb->FcbListLock, oldIrql);
 
    return NULL;
}

Referenced by NtfsClearRenameTarget(), NtfsGetFCBForFile(), NtfsOpenFile(), NtfsOpenFileById(), NtfsOpenRootFCB(), and NtfsOpenTargetDirectory().

NtfsIsRegularFileObject()

BOOLEAN NTAPI NtfsIsRegularFileObject

(

_In_ PFILE_OBJECT

FileObject

)

Definition at line 153 of file fcb.c.

{
    PNTFS_FCB Fcb = (PNTFS_FCB)FileObject->FsContext;
 
    if (Fcb == NULL || Fcb->Identifier.Type != NTFS_TYPE_FCB)
        return FALSE;
 
    return !(Fcb->Flags & FCB_IS_VOLUME) && !NtfsFCBIsDirectory(Fcb);
}

Referenced by NtfsCleanup(), NtfsFastIoCheckIfPossible(), NtfsFastIoRead(), NtfsFastIoWrite(), NtfsFlushBuffers(), NtfsLockControl(), NtfsRead(), and NtfsWrite().

NtfsMakeFCBFromDirEntry()

NTSTATUS NtfsMakeFCBFromDirEntry	(	PNTFS_VCB	Vcb,
		PNTFS_FCB	DirectoryFCB,
		PUNICODE_STRING	Name,
		PCWSTR	Stream,
		PFILE_RECORD_HEADER	Record,
		ULONGLONG	MFTIndex,
		PNTFS_FCB *	fileFCB
	)

Definition at line 458 of file fcb.c.

{
    WCHAR pathName[MAX_PATH];
    PFILENAME_ATTRIBUTE FileName;
    PSTANDARD_INFORMATION StdInfo;
    PNTFS_FCB rcFCB;
    ULONGLONG Size, AllocatedSize;
 
    DPRINT("NtfsMakeFCBFromDirEntry(%p, %p, %wZ, %p, %p, %p)\n", Vcb, DirectoryFCB, Name, Stream, Record, fileFCB);
 
    FileName = GetBestFileNameFromRecord(Vcb, Record);
    if (!FileName)
    {
        return STATUS_OBJECT_NAME_NOT_FOUND; // Not sure that's the best here
    }
 
    if (DirectoryFCB && Name)
    {
        if (Name->Buffer[0] != 0 && wcslen(DirectoryFCB->PathName) +
            sizeof(WCHAR) + Name->Length / sizeof(WCHAR) > MAX_PATH)
        {
            return STATUS_OBJECT_NAME_INVALID;
        }
 
        wcscpy(pathName, DirectoryFCB->PathName);
        if (!NtfsFCBIsRoot(DirectoryFCB))
        {
            wcscat(pathName, L"\\");
        }
        wcscat(pathName, Name->Buffer);
    }
    else
    {
        RtlCopyMemory(pathName, FileName->Name, FileName->NameLength * sizeof (WCHAR));
        pathName[FileName->NameLength] = UNICODE_NULL;
    }
 
    Size = NtfsGetFileSize(Vcb, Record, (Stream ? Stream : L""), (Stream ? wcslen(Stream) : 0), &AllocatedSize);
 
    rcFCB = NtfsCreateFCB(pathName, Stream, Vcb);
    if (!rcFCB)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    memcpy(&rcFCB->Entry, FileName, FIELD_OFFSET(FILENAME_ATTRIBUTE, NameLength));
    rcFCB->Entry.NameType = FileName->NameType;
    rcFCB->RFCB.FileSize.QuadPart = Size;
    rcFCB->RFCB.ValidDataLength.QuadPart = Size;
    rcFCB->RFCB.AllocationSize.QuadPart = AllocatedSize;
 
    StdInfo = GetStandardInformationFromRecord(Vcb, Record);
    if (StdInfo != NULL)
    {
        rcFCB->Entry.FileAttributes |= StdInfo->FileAttribute;
    }
 
    NtfsFCBInitializeCache(Vcb, rcFCB);
    rcFCB->RefCount = 1;
    rcFCB->MFTIndex = MFTIndex;
    rcFCB->LinkCount = Record->LinkCount;
    NtfsAddFCBToTable(Vcb, rcFCB);
    *fileFCB = rcFCB;
 
    return STATUS_SUCCESS;
}

Referenced by NtfsDirFindFile(), and NtfsOpenFileById().

NtfsMakeRootFCB()

PNTFS_FCB NtfsMakeRootFCB

(

PNTFS_VCB

Vcb

)

Definition at line 388 of file fcb.c.

{
    PNTFS_FCB Fcb;
    PFILE_RECORD_HEADER MftRecord;
    PFILENAME_ATTRIBUTE FileName;
 
    MftRecord = ExAllocateFromNPagedLookasideList(&Vcb->FileRecLookasideList);
    if (MftRecord == NULL)
    {
        return NULL;
    }
 
    if (!NT_SUCCESS(ReadFileRecord(Vcb, NTFS_FILE_ROOT, MftRecord)))
    {
        ExFreeToNPagedLookasideList(&Vcb->FileRecLookasideList, MftRecord);
        return NULL;
    }
 
    FileName = GetFileNameFromRecord(Vcb, MftRecord, NTFS_FILE_NAME_WIN32);
    if (!FileName)
    {
        ExFreeToNPagedLookasideList(&Vcb->FileRecLookasideList, MftRecord);
        return NULL;
    }
 
    Fcb = NtfsCreateFCB(L"\\", NULL, Vcb);
    if (!Fcb)
    {
        ExFreeToNPagedLookasideList(&Vcb->FileRecLookasideList, MftRecord);
        return NULL;
    }
 
    memcpy(&Fcb->Entry, FileName, FIELD_OFFSET(FILENAME_ATTRIBUTE, NameLength));
    Fcb->Entry.NameType = FileName->NameType;
    Fcb->Entry.NameLength = 0;
    Fcb->Entry.Name[0] = UNICODE_NULL;
    Fcb->RefCount = 1;
    Fcb->DirIndex = 0;
    Fcb->RFCB.FileSize.QuadPart = FileName->DataSize;
    Fcb->RFCB.ValidDataLength.QuadPart = FileName->DataSize;
    Fcb->RFCB.AllocationSize.QuadPart = FileName->AllocatedSize;
    Fcb->MFTIndex = NTFS_FILE_ROOT;
    Fcb->LinkCount = MftRecord->LinkCount;
 
    NtfsFCBInitializeCache(Vcb, Fcb);
    NtfsAddFCBToTable(Vcb, Fcb);
    NtfsGrabFCB(Vcb, Fcb);
 
    ExFreeToNPagedLookasideList(&Vcb->FileRecLookasideList, MftRecord);
 
    return Fcb;
}

Referenced by NtfsOpenRootFCB().

NtfsOpenRootFCB()

PNTFS_FCB NtfsOpenRootFCB

(

PNTFS_VCB

Vcb

)

Definition at line 443 of file fcb.c.

{
    PNTFS_FCB Fcb;
 
    Fcb = NtfsGrabFCBFromTable(Vcb, L"\\");
    if (Fcb == NULL)
    {
        Fcb = NtfsMakeRootFCB(Vcb);
    }
 
    return Fcb;
}

Referenced by NtfsGetFCBForFile().

NtfsReadFCBAttribute()

NTSTATUS NtfsReadFCBAttribute	(	PNTFS_VCB	Vcb,
		PNTFS_FCB	pFCB,
		ULONG	Type,
		PCWSTR	Name,
		ULONG	NameLength,
		PVOID *	Data
	)

Definition at line 806 of file fcb.c.

{
    NTSTATUS Status;
    PFILE_RECORD_HEADER FileRecord;
    PNTFS_ATTR_CONTEXT AttrCtxt;
    ULONGLONG AttrLength;
 
    FileRecord = ExAllocateFromNPagedLookasideList(&Vcb->FileRecLookasideList);
    if (FileRecord == NULL)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    Status = ReadFileRecord(Vcb, pFCB->MFTIndex, FileRecord);
    if (!NT_SUCCESS(Status))
    {
        ExFreeToNPagedLookasideList(&Vcb->FileRecLookasideList, FileRecord);
        return Status;
    }
 
    Status = FindAttribute(Vcb, FileRecord, Type, Name, NameLength, &AttrCtxt, NULL);
    if (!NT_SUCCESS(Status))
    {
        ExFreeToNPagedLookasideList(&Vcb->FileRecLookasideList, FileRecord);
        return Status;
    }
 
    AttrLength = AttributeDataLength(AttrCtxt->pRecord);
    *Data = ExAllocatePoolWithTag(NonPagedPool, AttrLength, TAG_NTFS);
    if (*Data == NULL)
    {
        ReleaseAttributeContext(AttrCtxt);
        ExFreeToNPagedLookasideList(&Vcb->FileRecLookasideList, FileRecord);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    ReadAttribute(Vcb, AttrCtxt, 0, *Data, AttrLength);
 
    ReleaseAttributeContext(AttrCtxt);
    ExFreeToNPagedLookasideList(&Vcb->FileRecLookasideList, FileRecord);
 
    return STATUS_SUCCESS;
}

Referenced by NtfsCreateFile().

NtfsReleaseFCB()

VOID NtfsReleaseFCB	(	PNTFS_VCB	Vcb,
		PNTFS_FCB	Fcb
	)

Definition at line 209 of file fcb.c.

{
    KIRQL oldIrql;
 
    DPRINT("releasing FCB at %p: %S, refCount:%d\n",
           Fcb,
           Fcb->PathName,
           Fcb->RefCount);
 
    KeAcquireSpinLock(&Vcb->FcbListLock, &oldIrql);
    Fcb->RefCount--;
    if (Fcb->RefCount <= 0 && (!NtfsFCBIsDirectory(Fcb) || (Fcb->Flags & FCB_DELETED)))
    {
        KeReleaseSpinLock(&Vcb->FcbListLock, oldIrql);
 
        CcUninitializeCacheMap(Fcb->FileObject, NULL, NULL);
 
        if (Fcb->SectionObjectPointers.DataSectionObject != NULL ||
            Fcb->SectionObjectPointers.ImageSectionObject != NULL)
        {
            DPRINT("Keeping FCB %p (%S): still mapped\n", Fcb, Fcb->PathName);
            return;
        }
 
        /* A deleted FCB already left the table */
        KeAcquireSpinLock(&Vcb->FcbListLock, &oldIrql);
        if (!(Fcb->Flags & FCB_DELETED))
            RemoveEntryList(&Fcb->FcbListEntry);
        KeReleaseSpinLock(&Vcb->FcbListLock, oldIrql);
 
        NtfsDestroyFCB(Fcb);
    }
    else
    {
        KeReleaseSpinLock(&Vcb->FcbListLock, oldIrql);
    }
}

Referenced by NtfsClearRenameTarget(), NtfsCloseFile(), NtfsFlushVolumeFiles(), NtfsGetFCBForFile(), NtfsOpenFile(), and NtfsOpenTargetDirectory().

NtfsRemoveFCBFromTable()

VOID NtfsRemoveFCBFromTable	(	_In_ PNTFS_VCB	Vcb,
		_In_ PNTFS_FCB	Fcb
	)

Definition at line 270 of file fcb.c.

{
    KIRQL OldIrql;
 
    KeAcquireSpinLock(&Vcb->FcbListLock, &OldIrql);
 
    /* FCB_DELETED tells NtfsReleaseFCB() the entry is already unlinked */
    if (!(Fcb->Flags & FCB_DELETED))
    {
        RemoveEntryList(&Fcb->FcbListEntry);
        InitializeListHead(&Fcb->FcbListEntry);
        Fcb->Flags |= FCB_DELETED;
    }
 
    KeReleaseSpinLock(&Vcb->FcbListLock, OldIrql);
}

Referenced by NtfsCleanupFile().

NtfsWSubString()

static VOID NtfsWSubString ( PWCHAR  pTarget, PCWSTR  pSource, size_t  pLength  )

static

Definition at line 57 of file fcb.c.

{
    wcsncpy(pTarget, pSource, pLength);
    pTarget[pLength] = L'\0';
}

Referenced by NtfsGetFCBForFile().