fcb.c File Reference

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

Include dependency graph for fcb.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
static ULONG	vfatNameHash (ULONG hash, PUNICODE_STRING NameU)
VOID	vfatSplitPathName (PUNICODE_STRING PathNameU, PUNICODE_STRING DirNameU, PUNICODE_STRING FileNameU)
static VOID	vfatInitFcb (PVFATFCB Fcb, PUNICODE_STRING NameU)
PVFATFCB	vfatNewFCB (PDEVICE_EXTENSION pVCB, PUNICODE_STRING pFileNameU)
static VOID	vfatDelFCBFromTable (PDEVICE_EXTENSION pVCB, PVFATFCB pFCB)
static NTSTATUS	vfatMakeFullName (PVFATFCB directoryFCB, PUNICODE_STRING LongNameU, PUNICODE_STRING ShortNameU, PUNICODE_STRING NameU)
VOID	vfatDestroyCCB (PVFATCCB pCcb)
VOID	vfatDestroyFCB (PVFATFCB pFCB)
BOOLEAN	vfatFCBIsRoot (PVFATFCB FCB)
VOID	vfatGrabFCB (PDEVICE_EXTENSION pVCB, PVFATFCB pFCB)
VOID	vfatReleaseFCB (PDEVICE_EXTENSION pVCB, PVFATFCB pFCB)
static VOID	vfatAddFCBToTable (PDEVICE_EXTENSION pVCB, PVFATFCB pFCB)
static VOID	vfatInitFCBFromDirEntry (PDEVICE_EXTENSION Vcb, PVFATFCB ParentFcb, PVFATFCB Fcb, PVFAT_DIRENTRY_CONTEXT DirContext)
NTSTATUS	vfatSetFCBNewDirName (PDEVICE_EXTENSION pVCB, PVFATFCB Fcb, PVFATFCB ParentFcb)
NTSTATUS	vfatUpdateFCB (PDEVICE_EXTENSION pVCB, PVFATFCB Fcb, PVFAT_DIRENTRY_CONTEXT DirContext, PVFATFCB ParentFcb)
PVFATFCB	vfatGrabFCBFromTable (PDEVICE_EXTENSION pVCB, PUNICODE_STRING PathNameU)
PVFATFCB	vfatMakeRootFCB (PDEVICE_EXTENSION pVCB)
PVFATFCB	vfatOpenRootFCB (PDEVICE_EXTENSION pVCB)
NTSTATUS	vfatMakeFCBFromDirEntry (PVCB vcb, PVFATFCB directoryFCB, PVFAT_DIRENTRY_CONTEXT DirContext, PVFATFCB *fileFCB)
NTSTATUS	vfatAttachFCBToFileObject (PDEVICE_EXTENSION vcb, PVFATFCB fcb, PFILE_OBJECT fileObject)
NTSTATUS	vfatDirFindFile (PDEVICE_EXTENSION pDeviceExt, PVFATFCB pDirectoryFCB, PUNICODE_STRING FileToFindU, PVFATFCB *pFoundFCB)
NTSTATUS	vfatGetFCBForFile (PDEVICE_EXTENSION pVCB, PVFATFCB *pParentFCB, PVFATFCB *pFCB, PUNICODE_STRING pFileNameU)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 15 of file fcb.c.

Function Documentation

vfatAddFCBToTable()

static VOID vfatAddFCBToTable ( PDEVICE_EXTENSION  pVCB, PVFATFCB  pFCB  )

static

Definition at line 400 of file fcb.c.

{
    ULONG Index;
    ULONG ShortIndex;
 
    ASSERT(pFCB->Hash.Hash == vfatNameHash(0, &pFCB->PathNameU));
    Index = pFCB->Hash.Hash % pVCB->HashTableSize;
    ShortIndex = pFCB->ShortHash.Hash % pVCB->HashTableSize;
 
    InsertTailList(&pVCB->FcbListHead, &pFCB->FcbListEntry);
 
    pFCB->Hash.next = pVCB->FcbHashTable[Index];
    pVCB->FcbHashTable[Index] = &pFCB->Hash;
    if (pFCB->Hash.Hash != pFCB->ShortHash.Hash)
    {
        pFCB->ShortHash.next = pVCB->FcbHashTable[ShortIndex];
        pVCB->FcbHashTable[ShortIndex] = &pFCB->ShortHash;
    }
    if (pFCB->parentFcb)
    {
        vfatGrabFCB(pVCB, pFCB->parentFcb);
    }
}

Referenced by vfatMakeFCBFromDirEntry(), vfatMakeRootFCB(), vfatSetFCBNewDirName(), and vfatUpdateFCB().

vfatAttachFCBToFileObject()

NTSTATUS vfatAttachFCBToFileObject	(	PDEVICE_EXTENSION	vcb,
		PVFATFCB	fcb,
		PFILE_OBJECT	fileObject
	)

Definition at line 754 of file fcb.c.

{
    PVFATCCB newCCB;
 
#ifdef KDBG
    if (DebugFile.Buffer != NULL && FsRtlIsNameInExpression(&DebugFile, &fcb->LongNameU, FALSE, NULL))
    {
        DPRINT1("Attaching %p to %p (%d)\n", fcb, fileObject, fcb->RefCount);
    }
#endif
 
    newCCB = ExAllocateFromNPagedLookasideList(&VfatGlobalData->CcbLookasideList);
    if (newCCB == NULL)
    {
        return  STATUS_INSUFFICIENT_RESOURCES;
    }
    RtlZeroMemory(newCCB, sizeof (VFATCCB));
 
    fileObject->SectionObjectPointer = &fcb->SectionObjectPointers;
    fileObject->FsContext = fcb;
    fileObject->FsContext2 = newCCB;
    fileObject->Vpb = vcb->IoVPB;
    DPRINT("file open: fcb:%p PathName:%wZ\n", fcb, &fcb->PathNameU);
 
#ifdef KDBG
    fcb->Flags &= ~FCB_CLEANED_UP;
    fcb->Flags &= ~FCB_CLOSED;
#endif
 
    return STATUS_SUCCESS;
}

Referenced by VfatCreateFile(), VfatMount(), and VfatOpenFile().

vfatDelFCBFromTable()

static VOID vfatDelFCBFromTable ( PDEVICE_EXTENSION  pVCB, PVFATFCB  pFCB  )

static

Definition at line 164 of file fcb.c.

{
    ULONG Index;
    ULONG ShortIndex;
    HASHENTRY* entry;
 
    Index = pFCB->Hash.Hash % pVCB->HashTableSize;
    ShortIndex = pFCB->ShortHash.Hash % pVCB->HashTableSize;
 
    if (pFCB->Hash.Hash != pFCB->ShortHash.Hash)
    {
        entry = pVCB->FcbHashTable[ShortIndex];
        if (entry->self == pFCB)
        {
            pVCB->FcbHashTable[ShortIndex] = entry->next;
        }
        else
        {
            while (entry->next->self != pFCB)
            {
                entry = entry->next;
            }
            entry->next = pFCB->ShortHash.next;
        }
    }
    entry = pVCB->FcbHashTable[Index];
    if (entry->self == pFCB)
    {
        pVCB->FcbHashTable[Index] = entry->next;
    }
    else
    {
        while (entry->next->self != pFCB)
        {
            entry = entry->next;
        }
        entry->next = pFCB->Hash.next;
    }
 
    RemoveEntryList(&pFCB->FcbListEntry);
}

Referenced by vfatReleaseFCB(), vfatSetFCBNewDirName(), and vfatUpdateFCB().

vfatDestroyCCB()

VOID vfatDestroyCCB

(

PVFATCCB

pCcb

)

Definition at line 257 of file fcb.c.

{
    if (pCcb->SearchPattern.Buffer)
    {
        ExFreePoolWithTag(pCcb->SearchPattern.Buffer, TAG_SEARCH);
    }
    ExFreeToNPagedLookasideList(&VfatGlobalData->CcbLookasideList, pCcb);
}

Referenced by VfatCloseFile(), and VfatMount().

vfatDestroyFCB()

VOID vfatDestroyFCB

(

PVFATFCB

pFCB

)

Definition at line 268 of file fcb.c.

{
#ifdef KDBG
    if (DebugFile.Buffer != NULL && FsRtlIsNameInExpression(&DebugFile, &pFCB->LongNameU, FALSE, NULL))
    {
        DPRINT1("Destroying: %p (%wZ) %d\n", pFCB, &pFCB->PathNameU, pFCB->RefCount);
    }
#endif
 
    FsRtlUninitializeFileLock(&pFCB->FileLock);
 
    if (!vfatFCBIsRoot(pFCB) &&
        !BooleanFlagOn(pFCB->Flags, FCB_IS_FAT) && !BooleanFlagOn(pFCB->Flags, FCB_IS_VOLUME))
    {
        RemoveEntryList(&pFCB->ParentListEntry);
    }
    ExFreePool(pFCB->PathNameBuffer);
    ExDeleteResourceLite(&pFCB->PagingIoResource);
    ExDeleteResourceLite(&pFCB->MainResource);
    ASSERT(IsListEmpty(&pFCB->ParentListHead));
    ExFreeToNPagedLookasideList(&VfatGlobalData->FcbLookasideList, pFCB);
}

Referenced by VfatCheckForDismount(), VfatDismountVolume(), VfatMount(), and vfatReleaseFCB().

vfatDirFindFile()

NTSTATUS vfatDirFindFile	(	PDEVICE_EXTENSION	pDeviceExt,
		PVFATFCB	pDirectoryFCB,
		PUNICODE_STRING	FileToFindU,
		PVFATFCB *	pFoundFCB
	)

Definition at line 790 of file fcb.c.

{
    NTSTATUS status;
    PVOID Context = NULL;
    PVOID Page = NULL;
    BOOLEAN First = TRUE;
    VFAT_DIRENTRY_CONTEXT DirContext;
    /* This buffer must have a size of 260 characters, because
    vfatMakeFCBFromDirEntry can copy 20 name entries with 13 characters. */
    WCHAR LongNameBuffer[260];
    WCHAR ShortNameBuffer[13];
    BOOLEAN FoundLong = FALSE;
    BOOLEAN FoundShort = FALSE;
    BOOLEAN IsFatX = vfatVolumeIsFatX(pDeviceExt);
 
    ASSERT(pDeviceExt);
    ASSERT(pDirectoryFCB);
    ASSERT(FileToFindU);
 
    DPRINT("vfatDirFindFile(VCB:%p, dirFCB:%p, File:%wZ)\n",
           pDeviceExt, pDirectoryFCB, FileToFindU);
    DPRINT("Dir Path:%wZ\n", &pDirectoryFCB->PathNameU);
 
    DirContext.DirIndex = 0;
    DirContext.LongNameU.Buffer = LongNameBuffer;
    DirContext.LongNameU.Length = 0;
    DirContext.LongNameU.MaximumLength = sizeof(LongNameBuffer);
    DirContext.ShortNameU.Buffer = ShortNameBuffer;
    DirContext.ShortNameU.Length = 0;
    DirContext.ShortNameU.MaximumLength = sizeof(ShortNameBuffer);
    DirContext.DeviceExt = pDeviceExt;
 
    while (TRUE)
    {
        status = VfatGetNextDirEntry(pDeviceExt,
            &Context,
            &Page,
            pDirectoryFCB,
            &DirContext,
            First);
        First = FALSE;
        if (status == STATUS_NO_MORE_ENTRIES)
        {
            return STATUS_OBJECT_NAME_NOT_FOUND;
        }
        if (!NT_SUCCESS(status))
        {
            return status;
        }
 
        DPRINT("  Index:%u  longName:%wZ\n",
               DirContext.DirIndex, &DirContext.LongNameU);
 
        if (!ENTRY_VOLUME(IsFatX, &DirContext.DirEntry))
        {
            if (DirContext.LongNameU.Length == 0 ||
                DirContext.ShortNameU.Length == 0)
            {
                DPRINT1("WARNING: File system corruption detected. You may need to run a disk repair utility.\n");
                if (VfatGlobalData->Flags & VFAT_BREAK_ON_CORRUPTION)
                {
                    ASSERT(DirContext.LongNameU.Length != 0 &&
                           DirContext.ShortNameU.Length != 0);
                }
                DirContext.DirIndex++;
                continue;
            }
            FoundLong = RtlEqualUnicodeString(FileToFindU, &DirContext.LongNameU, TRUE);
            if (FoundLong == FALSE)
            {
                FoundShort = RtlEqualUnicodeString(FileToFindU, &DirContext.ShortNameU, TRUE);
            }
            if (FoundLong || FoundShort)
            {
                status = vfatMakeFCBFromDirEntry(pDeviceExt,
                    pDirectoryFCB,
                    &DirContext,
                    pFoundFCB);
                CcUnpinData(Context);
                return status;
            }
        }
        DirContext.DirIndex++;
    }
 
    return STATUS_OBJECT_NAME_NOT_FOUND;
}

Referenced by vfatGetFCBForFile().

vfatFCBIsRoot()

BOOLEAN vfatFCBIsRoot

(

PVFATFCB

FCB

)

Definition at line 293 of file fcb.c.

{
    return FCB->PathNameU.Length == sizeof(WCHAR) && FCB->PathNameU.Buffer[0] == L'\\' ? TRUE : FALSE;
}

Referenced by FATAddEntry(), FATIsDirectoryEmpty(), FATXAddEntry(), FATXGetNextDirEntry(), FindFile(), vfatDestroyFCB(), vfatFindDirSpace(), vfatInitFCBFromDirEntry(), vfatMakeFullName(), VfatOpenFile(), VfatSetDispositionInformation(), VfatSetRenameInformation(), and VfatUpdateEntry().

vfatGetFCBForFile()

NTSTATUS vfatGetFCBForFile	(	PDEVICE_EXTENSION	pVCB,
		PVFATFCB *	pParentFCB,
		PVFATFCB *	pFCB,
		PUNICODE_STRING	pFileNameU
	)

Definition at line 883 of file fcb.c.

{
    NTSTATUS status;
    PVFATFCB FCB = NULL;
    PVFATFCB parentFCB;
    UNICODE_STRING NameU;
    UNICODE_STRING RootNameU = RTL_CONSTANT_STRING(L"\\");
    UNICODE_STRING FileNameU;
    WCHAR NameBuffer[260];
    PWCHAR curr, prev, last;
    ULONG Length;
 
    DPRINT("vfatGetFCBForFile (%p,%p,%p,%wZ)\n",
           pVCB, pParentFCB, pFCB, pFileNameU);
 
    RtlInitEmptyUnicodeString(&FileNameU, NameBuffer, sizeof(NameBuffer));
 
    parentFCB = *pParentFCB;
 
    if (parentFCB == NULL)
    {
        /* Passed-in name is the full name */
        RtlCopyUnicodeString(&FileNameU, pFileNameU);
 
        //  Trivial case, open of the root directory on volume
        if (RtlEqualUnicodeString(&FileNameU, &RootNameU, FALSE))
        {
            DPRINT("returning root FCB\n");
 
            FCB = vfatOpenRootFCB(pVCB);
            *pFCB = FCB;
            *pParentFCB = NULL;
 
            return (FCB != NULL) ? STATUS_SUCCESS : STATUS_OBJECT_PATH_NOT_FOUND;
        }
 
        /* Check for an existing FCB */
        FCB = vfatGrabFCBFromTable(pVCB, &FileNameU);
        if (FCB)
        {
            *pFCB = FCB;
            *pParentFCB = FCB->parentFcb;
            vfatGrabFCB(pVCB, *pParentFCB);
            return STATUS_SUCCESS;
        }
 
        last = curr = FileNameU.Buffer + FileNameU.Length / sizeof(WCHAR) - 1;
        while (*curr != L'\\' && curr > FileNameU.Buffer)
        {
            curr--;
        }
 
        if (curr > FileNameU.Buffer)
        {
            NameU.Buffer = FileNameU.Buffer;
            NameU.MaximumLength = NameU.Length = (curr - FileNameU.Buffer) * sizeof(WCHAR);
            FCB = vfatGrabFCBFromTable(pVCB, &NameU);
            if (FCB)
            {
                Length = (curr - FileNameU.Buffer) * sizeof(WCHAR);
                if (Length != FCB->PathNameU.Length)
                {
                    if (FileNameU.Length + FCB->PathNameU.Length - Length > FileNameU.MaximumLength)
                    {
                        vfatReleaseFCB(pVCB, FCB);
                        return STATUS_OBJECT_NAME_INVALID;
                    }
                    RtlMoveMemory(FileNameU.Buffer + FCB->PathNameU.Length / sizeof(WCHAR),
                        curr, FileNameU.Length - Length);
                    FileNameU.Length += (USHORT)(FCB->PathNameU.Length - Length);
                    curr = FileNameU.Buffer + FCB->PathNameU.Length / sizeof(WCHAR);
                    last = FileNameU.Buffer + FileNameU.Length / sizeof(WCHAR) - 1;
                }
                RtlCopyMemory(FileNameU.Buffer, FCB->PathNameU.Buffer, FCB->PathNameU.Length);
            }
        }
        else
        {
            FCB = NULL;
        }
 
        if (FCB == NULL)
        {
            FCB = vfatOpenRootFCB(pVCB);
            curr = FileNameU.Buffer;
        }
 
        parentFCB = NULL;
        prev = curr;
    }
    else
    {
        /* Make absolute path */
        RtlCopyUnicodeString(&FileNameU, &parentFCB->PathNameU);
        curr = FileNameU.Buffer + FileNameU.Length / sizeof(WCHAR) - 1;
        if (*curr != L'\\')
        {
            RtlAppendUnicodeToString(&FileNameU, L"\\");
            curr++;
        }
        ASSERT(*curr == L'\\');
        RtlAppendUnicodeStringToString(&FileNameU, pFileNameU);
 
        FCB = parentFCB;
        parentFCB = NULL;
        prev = curr;
        last = FileNameU.Buffer + FileNameU.Length / sizeof(WCHAR) - 1;
    }
 
    while (curr <= last)
    {
        if (parentFCB)
        {
            vfatReleaseFCB(pVCB, parentFCB);
            parentFCB = NULL;
        }
        //  fail if element in FCB is not a directory
        if (!vfatFCBIsDirectory(FCB))
        {
            DPRINT ("Element in requested path is not a directory\n");
 
            vfatReleaseFCB(pVCB, FCB);
            FCB = NULL;
            *pParentFCB = NULL;
            *pFCB = NULL;
 
            return  STATUS_OBJECT_PATH_NOT_FOUND;
        }
        parentFCB = FCB;
        if (prev < curr)
        {
            Length = (curr - prev) * sizeof(WCHAR);
            if (Length != parentFCB->LongNameU.Length)
            {
                if (FileNameU.Length + parentFCB->LongNameU.Length - Length > FileNameU.MaximumLength)
                {
                    vfatReleaseFCB(pVCB, parentFCB);
                    *pParentFCB = NULL;
                    *pFCB = NULL;
                    return STATUS_OBJECT_NAME_INVALID;
                }
                RtlMoveMemory(prev + parentFCB->LongNameU.Length / sizeof(WCHAR), curr,
                    FileNameU.Length - (curr - FileNameU.Buffer) * sizeof(WCHAR));
                FileNameU.Length += (USHORT)(parentFCB->LongNameU.Length - Length);
                curr = prev + parentFCB->LongNameU.Length / sizeof(WCHAR);
                last = FileNameU.Buffer + FileNameU.Length / sizeof(WCHAR) - 1;
            }
            RtlCopyMemory(prev, parentFCB->LongNameU.Buffer, parentFCB->LongNameU.Length);
        }
        curr++;
        prev = curr;
        while (*curr != L'\\' && curr <= last)
        {
            curr++;
        }
        NameU.Buffer = FileNameU.Buffer;
        NameU.Length = (curr - NameU.Buffer) * sizeof(WCHAR);
        NameU.MaximumLength = FileNameU.MaximumLength;
        DPRINT("%wZ\n", &NameU);
        FCB = vfatGrabFCBFromTable(pVCB, &NameU);
        if (FCB == NULL)
        {
            NameU.Buffer = prev;
            NameU.MaximumLength = NameU.Length = (curr - prev) * sizeof(WCHAR);
            status = vfatDirFindFile(pVCB, parentFCB, &NameU, &FCB);
            if (status == STATUS_OBJECT_NAME_NOT_FOUND)
            {
                *pFCB = NULL;
                if (curr > last)
                {
                    *pParentFCB = parentFCB;
                    return STATUS_OBJECT_NAME_NOT_FOUND;
                }
                else
                {
                    vfatReleaseFCB(pVCB, parentFCB);
                    *pParentFCB = NULL;
                    return STATUS_OBJECT_PATH_NOT_FOUND;
                }
            }
            else if (!NT_SUCCESS(status))
            {
                vfatReleaseFCB(pVCB, parentFCB);
                *pParentFCB = NULL;
                *pFCB = NULL;
 
                return status;
            }
        }
    }
 
    *pParentFCB = parentFCB;
    *pFCB = FCB;
 
    return STATUS_SUCCESS;
}

Referenced by VfatCreateFile(), VfatOpenFile(), and vfatPrepareTargetForRename().

vfatGrabFCB()

VOID vfatGrabFCB	(	PDEVICE_EXTENSION	pVCB,
		PVFATFCB	pFCB
	)

Definition at line 301 of file fcb.c.

{
#ifdef KDBG
    if (DebugFile.Buffer != NULL && FsRtlIsNameInExpression(&DebugFile, &pFCB->LongNameU, FALSE, NULL))
    {
        DPRINT1("Inc ref count (%d, oc: %d) for: %p (%wZ) at: %s(%d) %s\n", pFCB->RefCount, pFCB->OpenHandleCount, pFCB, &pFCB->PathNameU, File, Line, Func);
    }
#else
    DPRINT("Grabbing FCB at %p: %wZ, refCount:%d\n",
           pFCB, &pFCB->PathNameU, pFCB->RefCount);
#endif
 
    ASSERT(ExIsResourceAcquiredExclusive(&pVCB->DirResource));
 
    ASSERT(!BooleanFlagOn(pFCB->Flags, FCB_IS_FAT));
    ASSERT(pFCB != pVCB->VolumeFcb && !BooleanFlagOn(pFCB->Flags, FCB_IS_VOLUME));
    ASSERT(pFCB->RefCount > 0);
    ++pFCB->RefCount;
}

Referenced by vfatAddFCBToTable(), VfatCreateFile(), vfatFCBInitializeCacheFromVolume(), vfatGetFCBForFile(), vfatGrabFCBFromTable(), VfatOpenFile(), and VfatSetRenameInformation().

vfatGrabFCBFromTable()

PVFATFCB vfatGrabFCBFromTable	(	PDEVICE_EXTENSION	pVCB,
		PUNICODE_STRING	PathNameU
	)

Definition at line 594 of file fcb.c.

{
    PVFATFCB  rcFCB;
    ULONG Hash;
    UNICODE_STRING DirNameU;
    UNICODE_STRING FileNameU;
    PUNICODE_STRING FcbNameU;
 
    HASHENTRY* entry;
 
    DPRINT("'%wZ'\n", PathNameU);
 
    ASSERT(PathNameU->Length >= sizeof(WCHAR) && PathNameU->Buffer[0] == L'\\');
    Hash = vfatNameHash(0, PathNameU);
 
    entry = pVCB->FcbHashTable[Hash % pVCB->HashTableSize];
    if (entry)
    {
        vfatSplitPathName(PathNameU, &DirNameU, &FileNameU);
    }
 
    while (entry)
    {
        if (entry->Hash == Hash)
        {
            rcFCB = entry->self;
            DPRINT("'%wZ' '%wZ'\n", &DirNameU, &rcFCB->DirNameU);
            if (RtlEqualUnicodeString(&DirNameU, &rcFCB->DirNameU, TRUE))
            {
                if (rcFCB->Hash.Hash == Hash)
                {
                    FcbNameU = &rcFCB->LongNameU;
                }
                else
                {
                    FcbNameU = &rcFCB->ShortNameU;
                }
                /* compare the file name */
                DPRINT("'%wZ' '%wZ'\n", &FileNameU, FcbNameU);
                if (RtlEqualUnicodeString(&FileNameU, FcbNameU, TRUE))
                {
                    vfatGrabFCB(pVCB, rcFCB);
                    return rcFCB;
                }
            }
        }
        entry = entry->next;
    }
    return NULL;
}

Referenced by FindFile(), vfatGetFCBForFile(), and vfatOpenRootFCB().

vfatInitFcb()

static VOID vfatInitFcb ( PVFATFCB  Fcb, PUNICODE_STRING  NameU  )

static

Definition at line 83 of file fcb.c.

{
    USHORT PathNameBufferLength;
 
    if (NameU)
        PathNameBufferLength = NameU->Length + sizeof(WCHAR);
    else
        PathNameBufferLength = 0;
 
    Fcb->PathNameBuffer = ExAllocatePoolWithTag(NonPagedPool, PathNameBufferLength, TAG_FCB);
    if (!Fcb->PathNameBuffer)
    {
        /* FIXME: what to do if no more memory? */
        DPRINT1("Unable to initialize FCB for filename '%wZ'\n", NameU);
        KeBugCheckEx(FAT_FILE_SYSTEM, (ULONG_PTR)Fcb, (ULONG_PTR)NameU, 0, 0);
    }
 
    Fcb->RFCB.NodeTypeCode = NODE_TYPE_FCB;
    Fcb->RFCB.NodeByteSize = sizeof(VFATFCB);
 
    Fcb->PathNameU.Length = 0;
    Fcb->PathNameU.Buffer = Fcb->PathNameBuffer;
    Fcb->PathNameU.MaximumLength = PathNameBufferLength;
    Fcb->ShortNameU.Length = 0;
    Fcb->ShortNameU.Buffer = Fcb->ShortNameBuffer;
    Fcb->ShortNameU.MaximumLength = sizeof(Fcb->ShortNameBuffer);
    Fcb->DirNameU.Buffer = Fcb->PathNameU.Buffer;
    if (NameU && NameU->Length)
    {
        RtlCopyUnicodeString(&Fcb->PathNameU, NameU);
        vfatSplitPathName(&Fcb->PathNameU, &Fcb->DirNameU, &Fcb->LongNameU);
    }
    else
    {
        Fcb->DirNameU.Buffer = Fcb->LongNameU.Buffer = NULL;
        Fcb->DirNameU.MaximumLength = Fcb->DirNameU.Length = 0;
        Fcb->LongNameU.MaximumLength = Fcb->LongNameU.Length = 0;
    }
    RtlZeroMemory(&Fcb->FCBShareAccess, sizeof(SHARE_ACCESS));
    Fcb->OpenHandleCount = 0;
}

Referenced by vfatNewFCB().

vfatInitFCBFromDirEntry()

static VOID vfatInitFCBFromDirEntry ( PDEVICE_EXTENSION  Vcb, PVFATFCB  ParentFcb, PVFATFCB  Fcb, PVFAT_DIRENTRY_CONTEXT  DirContext  )

static

Definition at line 428 of file fcb.c.

{
    ULONG Size;
 
    RtlCopyMemory(&Fcb->entry, &DirContext->DirEntry, sizeof (DIR_ENTRY));
    RtlCopyUnicodeString(&Fcb->ShortNameU, &DirContext->ShortNameU);
    Fcb->Hash.Hash = vfatNameHash(0, &Fcb->PathNameU);
    if (vfatVolumeIsFatX(Vcb))
    {
        Fcb->ShortHash.Hash = Fcb->Hash.Hash;
    }
    else
    {
        Fcb->ShortHash.Hash = vfatNameHash(0, &Fcb->DirNameU);
        Fcb->ShortHash.Hash = vfatNameHash(Fcb->ShortHash.Hash, &Fcb->ShortNameU);
    }
 
    if (vfatFCBIsDirectory(Fcb))
    {
        ULONG FirstCluster, CurrentCluster;
        NTSTATUS Status = STATUS_SUCCESS;
        Size = 0;
        FirstCluster = vfatDirEntryGetFirstCluster(Vcb, &Fcb->entry);
        if (FirstCluster == 1)
        {
            Size = Vcb->FatInfo.rootDirectorySectors * Vcb->FatInfo.BytesPerSector;
        }
        else if (FirstCluster != 0)
        {
            CurrentCluster = FirstCluster;
            while (CurrentCluster != 0xffffffff && NT_SUCCESS(Status))
            {
                Size += Vcb->FatInfo.BytesPerCluster;
                Status = NextCluster(Vcb, FirstCluster, &CurrentCluster, FALSE);
            }
        }
    }
    else if (vfatVolumeIsFatX(Vcb))
    {
        Size = Fcb->entry.FatX.FileSize;
    }
    else
    {
        Size = Fcb->entry.Fat.FileSize;
    }
    Fcb->dirIndex = DirContext->DirIndex;
    Fcb->startIndex = DirContext->StartIndex;
    Fcb->parentFcb = ParentFcb;
    if (vfatVolumeIsFatX(Vcb) && !vfatFCBIsRoot(ParentFcb))
    {
        ASSERT(DirContext->DirIndex >= 2 && DirContext->StartIndex >= 2);
        Fcb->dirIndex = DirContext->DirIndex-2;
        Fcb->startIndex = DirContext->StartIndex-2;
    }
    Fcb->RFCB.FileSize.QuadPart = Size;
    Fcb->RFCB.ValidDataLength.QuadPart = Size;
    Fcb->RFCB.AllocationSize.QuadPart = ROUND_UP_64(Size, Vcb->FatInfo.BytesPerCluster);
}

Referenced by vfatMakeFCBFromDirEntry(), and vfatUpdateFCB().

vfatMakeFCBFromDirEntry()

NTSTATUS vfatMakeFCBFromDirEntry	(	PVCB	vcb,
		PVFATFCB	directoryFCB,
		PVFAT_DIRENTRY_CONTEXT	DirContext,
		PVFATFCB *	fileFCB
	)

Definition at line 725 of file fcb.c.

{
    PVFATFCB rcFCB;
    UNICODE_STRING NameU;
    NTSTATUS Status;
 
    Status = vfatMakeFullName(directoryFCB, &DirContext->LongNameU, &DirContext->ShortNameU, &NameU);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    rcFCB = vfatNewFCB(vcb, &NameU);
    vfatInitFCBFromDirEntry(vcb, directoryFCB, rcFCB, DirContext);
 
    rcFCB->RefCount = 1;
    InsertTailList(&directoryFCB->ParentListHead, &rcFCB->ParentListEntry);
    vfatAddFCBToTable(vcb, rcFCB);
    *fileFCB = rcFCB;
 
    ExFreePoolWithTag(NameU.Buffer, TAG_FCB);
    return STATUS_SUCCESS;
}

Referenced by FATAddEntry(), FATXAddEntry(), and vfatDirFindFile().

vfatMakeFullName()

static NTSTATUS vfatMakeFullName ( PVFATFCB  directoryFCB, PUNICODE_STRING  LongNameU, PUNICODE_STRING  ShortNameU, PUNICODE_STRING  NameU  )

static

Definition at line 210 of file fcb.c.

{
    PWCHAR PathNameBuffer;
    USHORT PathNameLength;
 
    PathNameLength = directoryFCB->PathNameU.Length + max(LongNameU->Length, ShortNameU->Length);
    if (!vfatFCBIsRoot(directoryFCB))
    {
        PathNameLength += sizeof(WCHAR);
    }
 
    if (PathNameLength > LONGNAME_MAX_LENGTH * sizeof(WCHAR))
    {
        return  STATUS_OBJECT_NAME_INVALID;
    }
    PathNameBuffer = ExAllocatePoolWithTag(NonPagedPool, PathNameLength + sizeof(WCHAR), TAG_FCB);
    if (!PathNameBuffer)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    NameU->Buffer = PathNameBuffer;
    NameU->Length = 0;
    NameU->MaximumLength = PathNameLength;
 
    RtlCopyUnicodeString(NameU, &directoryFCB->PathNameU);
    if (!vfatFCBIsRoot(directoryFCB))
    {
        RtlAppendUnicodeToString(NameU, L"\\");
    }
    if (LongNameU->Length > 0)
    {
        RtlAppendUnicodeStringToString(NameU, LongNameU);
    }
    else
    {
        RtlAppendUnicodeStringToString(NameU, ShortNameU);
    }
    NameU->Buffer[NameU->Length / sizeof(WCHAR)] = 0;
 
    return STATUS_SUCCESS;
}

Referenced by vfatMakeFCBFromDirEntry(), vfatSetFCBNewDirName(), and vfatUpdateFCB().

vfatMakeRootFCB()

PVFATFCB vfatMakeRootFCB

(

PDEVICE_EXTENSION

pVCB

)

Definition at line 648 of file fcb.c.

{
    PVFATFCB FCB;
    ULONG FirstCluster, CurrentCluster, Size = 0;
    NTSTATUS Status = STATUS_SUCCESS;
    UNICODE_STRING NameU = RTL_CONSTANT_STRING(L"\\");
 
    ASSERT(pVCB->RootFcb == NULL);
 
    FCB = vfatNewFCB(pVCB, &NameU);
    if (vfatVolumeIsFatX(pVCB))
    {
        memset(FCB->entry.FatX.Filename, ' ', 42);
        FCB->entry.FatX.FileSize = pVCB->FatInfo.rootDirectorySectors * pVCB->FatInfo.BytesPerSector;
        FCB->entry.FatX.Attrib = FILE_ATTRIBUTE_DIRECTORY;
        FCB->entry.FatX.FirstCluster = 1;
        Size = pVCB->FatInfo.rootDirectorySectors * pVCB->FatInfo.BytesPerSector;
    }
    else
    {
        memset(FCB->entry.Fat.ShortName, ' ', 11);
        FCB->entry.Fat.FileSize = pVCB->FatInfo.rootDirectorySectors * pVCB->FatInfo.BytesPerSector;
        FCB->entry.Fat.Attrib = FILE_ATTRIBUTE_DIRECTORY;
        if (pVCB->FatInfo.FatType == FAT32)
        {
            CurrentCluster = FirstCluster = pVCB->FatInfo.RootCluster;
            FCB->entry.Fat.FirstCluster = (unsigned short)(FirstCluster & 0xffff);
            FCB->entry.Fat.FirstClusterHigh = (unsigned short)(FirstCluster >> 16);
 
            while (CurrentCluster != 0xffffffff && NT_SUCCESS(Status))
            {
                Size += pVCB->FatInfo.BytesPerCluster;
                Status = NextCluster (pVCB, FirstCluster, &CurrentCluster, FALSE);
            }
        }
        else
        {
            FCB->entry.Fat.FirstCluster = 1;
            Size = pVCB->FatInfo.rootDirectorySectors * pVCB->FatInfo.BytesPerSector;
        }
    }
    FCB->ShortHash.Hash = FCB->Hash.Hash;
    FCB->RefCount = 2;
    FCB->dirIndex = 0;
    FCB->RFCB.FileSize.QuadPart = Size;
    FCB->RFCB.ValidDataLength.QuadPart = Size;
    FCB->RFCB.AllocationSize.QuadPart = Size;
    FCB->RFCB.IsFastIoPossible = FastIoIsNotPossible;
 
    vfatFCBInitializeCacheFromVolume(pVCB, FCB);
    vfatAddFCBToTable(pVCB, FCB);
 
    /* Cache it */
    pVCB->RootFcb = FCB;
 
    return FCB;
}

Referenced by vfatOpenRootFCB().

vfatNameHash()

static ULONG vfatNameHash ( ULONG  hash, PUNICODE_STRING  NameU  )

static

Definition at line 32 of file fcb.c.

{
    PWCHAR last;
    PWCHAR curr;
    register WCHAR c;
 
    // LFN could start from "."
    //ASSERT(NameU->Buffer[0] != L'.');
    curr = NameU->Buffer;
    last = NameU->Buffer + NameU->Length / sizeof(WCHAR);
 
    while(curr < last)
    {
        c = towlower(*curr++);
        hash = (hash + (c << 4) + (c >> 4)) * 11;
    }
    return hash;
}

Referenced by vfatAddFCBToTable(), vfatGrabFCBFromTable(), vfatInitFCBFromDirEntry(), vfatNewFCB(), and vfatSetFCBNewDirName().

vfatNewFCB()

PVFATFCB vfatNewFCB	(	PDEVICE_EXTENSION	pVCB,
		PUNICODE_STRING	pFileNameU
	)

Definition at line 128 of file fcb.c.

{
    PVFATFCB  rcFCB;
 
    DPRINT("'%wZ'\n", pFileNameU);
 
    rcFCB = ExAllocateFromNPagedLookasideList(&VfatGlobalData->FcbLookasideList);
    if (rcFCB == NULL)
    {
        return NULL;
    }
    RtlZeroMemory(rcFCB, sizeof(VFATFCB));
    vfatInitFcb(rcFCB, pFileNameU);
    if (vfatVolumeIsFatX(pVCB))
        rcFCB->Attributes = &rcFCB->entry.FatX.Attrib;
    else
        rcFCB->Attributes = &rcFCB->entry.Fat.Attrib;
    rcFCB->Hash.Hash = vfatNameHash(0, &rcFCB->PathNameU);
    rcFCB->Hash.self = rcFCB;
    rcFCB->ShortHash.self = rcFCB;
    ExInitializeResourceLite(&rcFCB->PagingIoResource);
    ExInitializeResourceLite(&rcFCB->MainResource);
    FsRtlInitializeFileLock(&rcFCB->FileLock, NULL, NULL);
    ExInitializeFastMutex(&rcFCB->LastMutex);
    rcFCB->RFCB.PagingIoResource = &rcFCB->PagingIoResource;
    rcFCB->RFCB.Resource = &rcFCB->MainResource;
    rcFCB->RFCB.IsFastIoPossible = FastIoIsNotPossible;
    InitializeListHead(&rcFCB->ParentListHead);
 
    return  rcFCB;
}

Referenced by vfatMakeFCBFromDirEntry(), vfatMakeRootFCB(), and VfatMount().

vfatOpenRootFCB()

PVFATFCB vfatOpenRootFCB

(

PDEVICE_EXTENSION

pVCB

)

Definition at line 708 of file fcb.c.

{
    PVFATFCB FCB;
    UNICODE_STRING NameU = RTL_CONSTANT_STRING(L"\\");
 
    FCB = vfatGrabFCBFromTable(pVCB, &NameU);
    if (FCB == NULL)
    {
        FCB = vfatMakeRootFCB(pVCB);
    }
    ASSERT(FCB == pVCB->RootFcb);
 
    return FCB;
}

Referenced by FsdSetFsLabelInformation(), ReadVolumeLabel(), and vfatGetFCBForFile().

vfatReleaseFCB()

VOID vfatReleaseFCB	(	PDEVICE_EXTENSION	pVCB,
		PVFATFCB	pFCB
	)

Definition at line 335 of file fcb.c.

{
    PVFATFCB tmpFcb;
 
#ifdef KDBG
    if (DebugFile.Buffer != NULL && FsRtlIsNameInExpression(&DebugFile, &pFCB->LongNameU, FALSE, NULL))
    {
        DPRINT1("Dec ref count (%d, oc: %d) for: %p (%wZ) at: %s(%d) %s\n", pFCB->RefCount, pFCB->OpenHandleCount, pFCB, &pFCB->PathNameU, File, Line, Func);
    }
#else
    DPRINT("Releasing FCB at %p: %wZ, refCount:%d\n",
           pFCB, &pFCB->PathNameU, pFCB->RefCount);
#endif
 
    ASSERT(ExIsResourceAcquiredExclusive(&pVCB->DirResource));
 
    while (pFCB)
    {
        ULONG RefCount;
 
        ASSERT(!BooleanFlagOn(pFCB->Flags, FCB_IS_FAT));
        ASSERT(pFCB != pVCB->VolumeFcb && !BooleanFlagOn(pFCB->Flags, FCB_IS_VOLUME));
        ASSERT(pFCB->RefCount > 0);
        RefCount = --pFCB->RefCount;
 
        if (RefCount == 1 && BooleanFlagOn(pFCB->Flags, FCB_CACHE_INITIALIZED))
        {
            PFILE_OBJECT tmpFileObject;
            tmpFileObject = pFCB->FileObject;
 
            pFCB->FileObject = NULL;
            CcUninitializeCacheMap(tmpFileObject, NULL, NULL);
            ClearFlag(pFCB->Flags, FCB_CACHE_INITIALIZED);
            ObDereferenceObject(tmpFileObject);
        }
 
        if (RefCount == 0)
        {
            ASSERT(pFCB->OpenHandleCount == 0);
            tmpFcb = pFCB->parentFcb;
            vfatDelFCBFromTable(pVCB, pFCB);
            vfatDestroyFCB(pFCB);
        }
        else
        {
            tmpFcb = NULL;
        }
        pFCB = tmpFcb;
    }
}

Referenced by FindFile(), FsdSetFsLabelInformation(), ReadVolumeLabel(), VfatCommonCloseFile(), VfatCreateFile(), vfatGetFCBForFile(), VfatOpenFile(), vfatPrepareTargetForRename(), vfatSetFCBNewDirName(), VfatSetRenameInformation(), and vfatUpdateFCB().

vfatSetFCBNewDirName()

NTSTATUS vfatSetFCBNewDirName	(	PDEVICE_EXTENSION	pVCB,
		PVFATFCB	Fcb,
		PVFATFCB	ParentFcb
	)

Definition at line 492 of file fcb.c.

{
    NTSTATUS Status;
    UNICODE_STRING NewNameU;
 
    /* Get full path name */
    Status = vfatMakeFullName(ParentFcb, &Fcb->LongNameU, &Fcb->ShortNameU, &NewNameU);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Delete old name */
    if (Fcb->PathNameBuffer)
    {
        ExFreePoolWithTag(Fcb->PathNameBuffer, TAG_FCB);
    }
    Fcb->PathNameU = NewNameU;
 
    /* Delete from table */
    vfatDelFCBFromTable(pVCB, Fcb);
 
    /* Split it properly */
    Fcb->PathNameBuffer = Fcb->PathNameU.Buffer;
    Fcb->DirNameU.Buffer = Fcb->PathNameU.Buffer;
    vfatSplitPathName(&Fcb->PathNameU, &Fcb->DirNameU, &Fcb->LongNameU);
    Fcb->Hash.Hash = vfatNameHash(0, &Fcb->PathNameU);
    if (vfatVolumeIsFatX(pVCB))
    {
        Fcb->ShortHash.Hash = Fcb->Hash.Hash;
    }
    else
    {
        Fcb->ShortHash.Hash = vfatNameHash(0, &Fcb->DirNameU);
        Fcb->ShortHash.Hash = vfatNameHash(Fcb->ShortHash.Hash, &Fcb->ShortNameU);
    }
 
    vfatAddFCBToTable(pVCB, Fcb);
    vfatReleaseFCB(pVCB, ParentFcb);
 
    return STATUS_SUCCESS;
}

Referenced by VfatRenameChildFCB().

vfatSplitPathName()

VOID vfatSplitPathName	(	PUNICODE_STRING	PathNameU,
		PUNICODE_STRING	DirNameU,
		PUNICODE_STRING	FileNameU
	)

Definition at line 54 of file fcb.c.

{
    PWCHAR pName;
    USHORT Length = 0;
    pName = PathNameU->Buffer + PathNameU->Length / sizeof(WCHAR) - 1;
    while (*pName != L'\\' && pName >= PathNameU->Buffer)
    {
        pName--;
        Length++;
    }
    ASSERT(*pName == L'\\' || pName < PathNameU->Buffer);
    if (FileNameU)
    {
        FileNameU->Buffer = pName + 1;
        FileNameU->Length = FileNameU->MaximumLength = Length * sizeof(WCHAR);
    }
    if (DirNameU)
    {
        DirNameU->Buffer = PathNameU->Buffer;
        DirNameU->Length = (pName + 1 - PathNameU->Buffer) * sizeof(WCHAR);
        DirNameU->MaximumLength = DirNameU->Length;
    }
}

Referenced by VfatCreateFile(), vfatGrabFCBFromTable(), vfatInitFcb(), vfatSetFCBNewDirName(), VfatSetRenameInformation(), and vfatUpdateFCB().

vfatUpdateFCB()

NTSTATUS vfatUpdateFCB	(	PDEVICE_EXTENSION	pVCB,
		PVFATFCB	Fcb,
		PVFAT_DIRENTRY_CONTEXT	DirContext,
		PVFATFCB	ParentFcb
	)

Definition at line 539 of file fcb.c.

{
    NTSTATUS Status;
    PVFATFCB OldParent;
 
    DPRINT("vfatUpdateFCB(%p, %p, %p, %p)\n", pVCB, Fcb, DirContext, ParentFcb);
 
    /* Get full path name */
    Status = vfatMakeFullName(ParentFcb, &DirContext->LongNameU, &DirContext->ShortNameU, &Fcb->PathNameU);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Delete old name */
    if (Fcb->PathNameBuffer)
    {
        ExFreePoolWithTag(Fcb->PathNameBuffer, TAG_FCB);
    }
 
    /* Delete from table */
    vfatDelFCBFromTable(pVCB, Fcb);
 
    /* Split it properly */
    Fcb->PathNameBuffer = Fcb->PathNameU.Buffer;
    Fcb->DirNameU.Buffer = Fcb->PathNameU.Buffer;
    vfatSplitPathName(&Fcb->PathNameU, &Fcb->DirNameU, &Fcb->LongNameU);
 
    /* Save old parent */
    OldParent = Fcb->parentFcb;
    RemoveEntryList(&Fcb->ParentListEntry);
 
    /* Reinit FCB */
    vfatInitFCBFromDirEntry(pVCB, ParentFcb, Fcb, DirContext);
 
    if (vfatFCBIsDirectory(Fcb))
    {
        CcFlushCache(&Fcb->SectionObjectPointers, NULL, 0, NULL);
    }
    InsertTailList(&ParentFcb->ParentListHead, &Fcb->ParentListEntry);
    vfatAddFCBToTable(pVCB, Fcb);
 
    /* If we moved across directories, dereference our old parent
     * We also dereference in case we're just renaming since AddFCBToTable references it
     */
    vfatReleaseFCB(pVCB, OldParent);
 
    return STATUS_SUCCESS;
}

Referenced by FATAddEntry(), FATXAddEntry(), and vfatRenameEntry().